Merge "Have LOCAL_ASFLAGS honor debug/non-debug configuration."
diff --git a/Android.mk b/Android.mk
index 5da9bdd..4ff857b 100644
--- a/Android.mk
+++ b/Android.mk
@@ -98,29 +98,13 @@
# ART_HOST_DEPENDENCIES depends on Android.executable.mk above for ART_HOST_EXECUTABLES
ART_HOST_DEPENDENCIES := \
- $(ART_HOST_EXECUTABLES) \
- $(HOST_OUT_JAVA_LIBRARIES)/core-libart-hostdex.jar \
- $(HOST_OUT_JAVA_LIBRARIES)/core-oj-hostdex.jar \
- $(ART_HOST_OUT_SHARED_LIBRARIES)/libjavacore$(ART_HOST_SHLIB_EXTENSION) \
- $(ART_HOST_OUT_SHARED_LIBRARIES)/libopenjdk$(ART_HOST_SHLIB_EXTENSION) \
- $(ART_HOST_OUT_SHARED_LIBRARIES)/libopenjdkjvm$(ART_HOST_SHLIB_EXTENSION)
+ $(ART_HOST_EXECUTABLES) \
+ $(ART_HOST_DEX_DEPENDENCIES) \
+ $(ART_HOST_SHARED_LIBRARY_DEPENDENCIES)
ART_TARGET_DEPENDENCIES := \
- $(ART_TARGET_EXECUTABLES) \
- $(TARGET_OUT_JAVA_LIBRARIES)/core-libart.jar \
- $(TARGET_OUT_JAVA_LIBRARIES)/core-oj.jar \
- $(TARGET_OUT_SHARED_LIBRARIES)/libjavacore.so \
- $(TARGET_OUT_SHARED_LIBRARIES)/libopenjdk.so \
- $(TARGET_OUT_SHARED_LIBRARIES)/libopenjdkjvm.so
-ifdef TARGET_2ND_ARCH
-ART_TARGET_DEPENDENCIES += $(2ND_TARGET_OUT_SHARED_LIBRARIES)/libjavacore.so
-ART_TARGET_DEPENDENCIES += $(2ND_TARGET_OUT_SHARED_LIBRARIES)/libopenjdk.so
-ART_TARGET_DEPENDENCIES += $(2ND_TARGET_OUT_SHARED_LIBRARIES)/libopenjdkjvm.so
-endif
-ifdef HOST_2ND_ARCH
-ART_HOST_DEPENDENCIES += $(2ND_HOST_OUT_SHARED_LIBRARIES)/libjavacore.so
-ART_HOST_DEPENDENCIES += $(2ND_HOST_OUT_SHARED_LIBRARIES)/libopenjdk.so
-ART_HOST_DEPENDENCIES += $(2ND_HOST_OUT_SHARED_LIBRARIES)/libopenjdkjvm.so
-endif
+ $(ART_TARGET_EXECUTABLES) \
+ $(ART_TARGET_DEX_DEPENDENCIES) \
+ $(ART_TARGET_SHARED_LIBRARY_DEPENDENCIES)
########################################################################
# test rules
diff --git a/build/Android.common_path.mk b/build/Android.common_path.mk
index 7be1894..b1644df 100644
--- a/build/Android.common_path.mk
+++ b/build/Android.common_path.mk
@@ -99,4 +99,18 @@
TARGET_JACK_CLASSPATH_DEPENDENCIES := $(call intermediates-dir-for,JAVA_LIBRARIES,core-oj, ,COMMON)/classes.jack $(call intermediates-dir-for,JAVA_LIBRARIES,core-libart, ,COMMON)/classes.jack
TARGET_JACK_CLASSPATH := $(abspath $(call intermediates-dir-for,JAVA_LIBRARIES,core-oj, ,COMMON)/classes.jack):$(abspath $(call intermediates-dir-for,JAVA_LIBRARIES,core-libart, ,COMMON)/classes.jack)
+ART_HOST_DEX_DEPENDENCIES := $(foreach jar,$(HOST_CORE_JARS),$(HOST_OUT_JAVA_LIBRARIES)/$(jar).jar)
+ART_TARGET_DEX_DEPENDENCIES := $(foreach jar,$(TARGET_CORE_JARS),$(TARGET_OUT_JAVA_LIBRARIES)/$(jar).jar)
+
+ART_CORE_SHARED_LIBRARIES := libjavacore libopenjdk libopenjdkjvm
+ART_HOST_SHARED_LIBRARY_DEPENDENCIES := $(foreach lib,$(ART_CORE_SHARED_LIBRARIES), $(ART_HOST_OUT_SHARED_LIBRARIES)/$(lib)$(ART_HOST_SHLIB_EXTENSION))
+ifdef HOST_2ND_ARCH
+ART_HOST_SHARED_LIBRARY_DEPENDENCIES += $(foreach lib,$(ART_CORE_SHARED_LIBRARIES), $(2ND_HOST_OUT_SHARED_LIBRARIES)/$(lib).so)
+endif
+
+ART_TARGET_SHARED_LIBRARY_DEPENDENCIES := $(foreach lib,$(ART_CORE_SHARED_LIBRARIES), $(TARGET_OUT_SHARED_LIBRARIES)/$(lib).so)
+ifdef TARGET_2ND_ARCH
+ART_TARGET_SHARED_LIBRARY_DEPENDENCIES += $(foreach lib,$(ART_CORE_SHARED_LIBRARIES), $(2ND_TARGET_OUT_SHARED_LIBRARIES)/$(lib).so)
+endif
+
endif # ART_ANDROID_COMMON_PATH_MK
diff --git a/build/Android.gtest.mk b/build/Android.gtest.mk
index fc2ba89..74c3033 100644
--- a/build/Android.gtest.mk
+++ b/build/Android.gtest.mk
@@ -94,17 +94,17 @@
ART_GTEST_dex2oat_environment_tests_HOST_DEPS := \
$(HOST_CORE_IMAGE_default_no-pic_64) \
- $(HOST_CORE_IMAGE_default_no-pic_32)
+ $(HOST_CORE_IMAGE_default_no-pic_32) \
+ $(HOST_OUT_EXECUTABLES)/patchoatd
ART_GTEST_dex2oat_environment_tests_TARGET_DEPS := \
$(TARGET_CORE_IMAGE_default_no-pic_64) \
- $(TARGET_CORE_IMAGE_default_no-pic_32)
+ $(TARGET_CORE_IMAGE_default_no-pic_32) \
+ $(TARGET_OUT_EXECUTABLES)/patchoatd
ART_GTEST_oat_file_assistant_test_HOST_DEPS := \
- $(ART_GTEST_dex2oat_environment_tests_HOST_DEPS) \
- $(HOST_OUT_EXECUTABLES)/patchoatd
+ $(ART_GTEST_dex2oat_environment_tests_HOST_DEPS)
ART_GTEST_oat_file_assistant_test_TARGET_DEPS := \
- $(ART_GTEST_dex2oat_environment_tests_TARGET_DEPS) \
- $(TARGET_OUT_EXECUTABLES)/patchoatd
+ $(ART_GTEST_dex2oat_environment_tests_TARGET_DEPS)
ART_GTEST_dex2oat_test_HOST_DEPS := \
@@ -318,6 +318,8 @@
compiler/utils/arm64/managed_register_arm64_test.cc \
COMPILER_GTEST_COMMON_SRC_FILES_mips := \
+ compiler/linker/mips/relative_patcher_mips_test.cc \
+ compiler/linker/mips/relative_patcher_mips32r6_test.cc \
COMPILER_GTEST_COMMON_SRC_FILES_mips64 := \
diff --git a/compiler/Android.mk b/compiler/Android.mk
index 43a50e2..02c176c 100644
--- a/compiler/Android.mk
+++ b/compiler/Android.mk
@@ -113,8 +113,11 @@
LIBART_COMPILER_SRC_FILES_mips := \
jni/quick/mips/calling_convention_mips.cc \
+ linker/mips/relative_patcher_mips.cc \
optimizing/code_generator_mips.cc \
+ optimizing/dex_cache_array_fixups_mips.cc \
optimizing/intrinsics_mips.cc \
+ optimizing/pc_relative_fixups_mips.cc \
utils/mips/assembler_mips.cc \
utils/mips/managed_register_mips.cc \
diff --git a/compiler/driver/compiler_driver.cc b/compiler/driver/compiler_driver.cc
index e52dda3..4c0095d 100644
--- a/compiler/driver/compiler_driver.cc
+++ b/compiler/driver/compiler_driver.cc
@@ -394,7 +394,7 @@
dump_passes_(dump_passes),
timings_logger_(timer),
compiler_context_(nullptr),
- support_boot_image_fixup_(instruction_set != kMips && instruction_set != kMips64),
+ support_boot_image_fixup_(instruction_set != kMips64),
dex_files_for_oat_file_(nullptr),
compiled_method_storage_(swap_fd),
profile_compilation_info_(profile_compilation_info),
@@ -2521,11 +2521,28 @@
true);
}
// Create the conflict tables.
- if (!klass->IsTemp() && klass->ShouldHaveEmbeddedImtAndVTable()) {
- Runtime::Current()->GetClassLinker()->FillIMTAndConflictTables(klass);
- }
+ FillIMTAndConflictTables(klass);
return true;
}
+
+ private:
+ void FillIMTAndConflictTables(mirror::Class* klass) SHARED_REQUIRES(Locks::mutator_lock_) {
+ if (!klass->ShouldHaveImt()) {
+ return;
+ }
+ if (visited_classes_.find(klass) != visited_classes_.end()) {
+ return;
+ }
+ if (klass->HasSuperClass()) {
+ FillIMTAndConflictTables(klass->GetSuperClass());
+ }
+ if (!klass->IsTemp()) {
+ Runtime::Current()->GetClassLinker()->FillIMTAndConflictTables(klass);
+ }
+ visited_classes_.insert(klass);
+ }
+
+ std::set<mirror::Class*> visited_classes_;
};
void CompilerDriver::InitializeClasses(jobject class_loader,
diff --git a/compiler/image_writer.cc b/compiler/image_writer.cc
index da10568..063eb11 100644
--- a/compiler/image_writer.cc
+++ b/compiler/image_writer.cc
@@ -1232,9 +1232,10 @@
}
// Assign offsets for all runtime methods in the IMT since these may hold conflict tables
// live.
- if (as_klass->ShouldHaveEmbeddedImtAndVTable()) {
- for (size_t i = 0; i < mirror::Class::kImtSize; ++i) {
- ArtMethod* imt_method = as_klass->GetEmbeddedImTableEntry(i, target_ptr_size_);
+ if (as_klass->ShouldHaveImt()) {
+ ImTable* imt = as_klass->GetImt(target_ptr_size_);
+ for (size_t i = 0; i < ImTable::kSize; ++i) {
+ ArtMethod* imt_method = imt->Get(i, target_ptr_size_);
DCHECK(imt_method != nullptr);
if (imt_method->IsRuntimeMethod() &&
!IsInBootImage(imt_method) &&
@@ -1243,6 +1244,11 @@
}
}
}
+
+ if (as_klass->ShouldHaveImt()) {
+ ImTable* imt = as_klass->GetImt(target_ptr_size_);
+ TryAssignImTableOffset(imt, oat_index);
+ }
} else if (h_obj->IsObjectArray()) {
// Walk elements of an object array.
int32_t length = h_obj->AsObjectArray<mirror::Object>()->GetLength();
@@ -1269,6 +1275,23 @@
return native_object_relocations_.find(ptr) != native_object_relocations_.end();
}
+void ImageWriter::TryAssignImTableOffset(ImTable* imt, size_t oat_index) {
+ // No offset, or already assigned.
+ if (imt == nullptr || IsInBootImage(imt) || NativeRelocationAssigned(imt)) {
+ return;
+ }
+ // If the method is a conflict method we also want to assign the conflict table offset.
+ ImageInfo& image_info = GetImageInfo(oat_index);
+ const size_t size = ImTable::SizeInBytes(target_ptr_size_);
+ native_object_relocations_.emplace(
+ imt,
+ NativeObjectRelocation {
+ oat_index,
+ image_info.bin_slot_sizes_[kBinImTable],
+ kNativeObjectRelocationTypeIMTable});
+ image_info.bin_slot_sizes_[kBinImTable] += size;
+}
+
void ImageWriter::TryAssignConflictTableOffset(ImtConflictTable* table, size_t oat_index) {
// No offset, or already assigned.
if (table == nullptr || NativeRelocationAssigned(table)) {
@@ -1391,6 +1414,7 @@
bin_offset = RoundUp(bin_offset, method_alignment);
break;
}
+ case kBinImTable:
case kBinIMTConflictTable: {
bin_offset = RoundUp(bin_offset, target_ptr_size_);
break;
@@ -1461,6 +1485,10 @@
bin_slot_offsets_[kBinArtMethodClean],
bin_slot_sizes_[kBinArtMethodClean] + bin_slot_sizes_[kBinArtMethodDirty]);
+ // IMT section.
+ ImageSection* imt_section = &out_sections[ImageHeader::kSectionImTables];
+ *imt_section = ImageSection(bin_slot_offsets_[kBinImTable], bin_slot_sizes_[kBinImTable]);
+
// Conflict tables section.
ImageSection* imt_conflict_tables_section = &out_sections[ImageHeader::kSectionIMTConflictTables];
*imt_conflict_tables_section = ImageSection(bin_slot_offsets_[kBinIMTConflictTable],
@@ -1585,6 +1613,13 @@
ImageWriter* const image_writer_;
};
+void ImageWriter::CopyAndFixupImTable(ImTable* orig, ImTable* copy) {
+ for (size_t i = 0; i < ImTable::kSize; ++i) {
+ ArtMethod* method = orig->Get(i, target_ptr_size_);
+ copy->Set(i, NativeLocationInImage(method), target_ptr_size_);
+ }
+}
+
void ImageWriter::CopyAndFixupImtConflictTable(ImtConflictTable* orig, ImtConflictTable* copy) {
const size_t count = orig->NumEntries(target_ptr_size_);
for (size_t i = 0; i < count; ++i) {
@@ -1642,6 +1677,12 @@
case kNativeObjectRelocationTypeDexCacheArray:
// Nothing to copy here, everything is done in FixupDexCache().
break;
+ case kNativeObjectRelocationTypeIMTable: {
+ ImTable* orig_imt = reinterpret_cast<ImTable*>(pair.first);
+ ImTable* dest_imt = reinterpret_cast<ImTable*>(dest);
+ CopyAndFixupImTable(orig_imt, dest_imt);
+ break;
+ }
case kNativeObjectRelocationTypeIMTConflictTable: {
auto* orig_table = reinterpret_cast<ImtConflictTable*>(pair.first);
CopyAndFixupImtConflictTable(
@@ -1850,13 +1891,25 @@
}
template <typename T>
+std::string PrettyPrint(T* ptr) SHARED_REQUIRES(Locks::mutator_lock_) {
+ std::ostringstream oss;
+ oss << ptr;
+ return oss.str();
+}
+
+template <>
+std::string PrettyPrint(ArtMethod* method) SHARED_REQUIRES(Locks::mutator_lock_) {
+ return PrettyMethod(method);
+}
+
+template <typename T>
T* ImageWriter::NativeLocationInImage(T* obj) {
if (obj == nullptr || IsInBootImage(obj)) {
return obj;
} else {
auto it = native_object_relocations_.find(obj);
- CHECK(it != native_object_relocations_.end()) << obj << " spaces "
- << Runtime::Current()->GetHeap()->DumpSpaces();
+ CHECK(it != native_object_relocations_.end()) << obj << " " << PrettyPrint(obj)
+ << " spaces " << Runtime::Current()->GetHeap()->DumpSpaces();
const NativeObjectRelocation& relocation = it->second;
ImageInfo& image_info = GetImageInfo(relocation.oat_index);
return reinterpret_cast<T*>(image_info.image_begin_ + relocation.offset);
@@ -2210,6 +2263,8 @@
return kBinDexCacheArray;
case kNativeObjectRelocationTypeRuntimeMethod:
return kBinRuntimeMethod;
+ case kNativeObjectRelocationTypeIMTable:
+ return kBinImTable;
case kNativeObjectRelocationTypeIMTConflictTable:
return kBinIMTConflictTable;
}
diff --git a/compiler/image_writer.h b/compiler/image_writer.h
index 51976c5..1efdc22 100644
--- a/compiler/image_writer.h
+++ b/compiler/image_writer.h
@@ -169,6 +169,8 @@
// ArtMethods may be dirty if the class has native methods or a declaring class that isn't
// initialized.
kBinArtMethodDirty,
+ // IMT (clean)
+ kBinImTable,
// Conflict tables (clean).
kBinIMTConflictTable,
// Runtime methods (always clean, do not have a length prefix array).
@@ -191,6 +193,7 @@
kNativeObjectRelocationTypeArtMethodDirty,
kNativeObjectRelocationTypeArtMethodArrayDirty,
kNativeObjectRelocationTypeRuntimeMethod,
+ kNativeObjectRelocationTypeIMTable,
kNativeObjectRelocationTypeIMTConflictTable,
kNativeObjectRelocationTypeDexCacheArray,
};
@@ -401,6 +404,7 @@
void CopyAndFixupObject(mirror::Object* obj) SHARED_REQUIRES(Locks::mutator_lock_);
void CopyAndFixupMethod(ArtMethod* orig, ArtMethod* copy, const ImageInfo& image_info)
SHARED_REQUIRES(Locks::mutator_lock_);
+ void CopyAndFixupImTable(ImTable* orig, ImTable* copy) SHARED_REQUIRES(Locks::mutator_lock_);
void CopyAndFixupImtConflictTable(ImtConflictTable* orig, ImtConflictTable* copy)
SHARED_REQUIRES(Locks::mutator_lock_);
void FixupClass(mirror::Class* orig, mirror::Class* copy)
@@ -433,6 +437,8 @@
size_t oat_index)
SHARED_REQUIRES(Locks::mutator_lock_);
+ void TryAssignImTableOffset(ImTable* imt, size_t oat_index) SHARED_REQUIRES(Locks::mutator_lock_);
+
// Assign the offset for an IMT conflict table. Does nothing if the table already has a native
// relocation.
void TryAssignConflictTableOffset(ImtConflictTable* table, size_t oat_index)
diff --git a/compiler/linker/mips/relative_patcher_mips.cc b/compiler/linker/mips/relative_patcher_mips.cc
new file mode 100644
index 0000000..7c0423b
--- /dev/null
+++ b/compiler/linker/mips/relative_patcher_mips.cc
@@ -0,0 +1,109 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "linker/mips/relative_patcher_mips.h"
+
+#include "compiled_method.h"
+
+namespace art {
+namespace linker {
+
+uint32_t MipsRelativePatcher::ReserveSpace(
+ uint32_t offset,
+ const CompiledMethod* compiled_method ATTRIBUTE_UNUSED,
+ MethodReference method_ref ATTRIBUTE_UNUSED) {
+ return offset; // No space reserved; no limit on relative call distance.
+}
+
+uint32_t MipsRelativePatcher::ReserveSpaceEnd(uint32_t offset) {
+ return offset; // No space reserved; no limit on relative call distance.
+}
+
+uint32_t MipsRelativePatcher::WriteThunks(OutputStream* out ATTRIBUTE_UNUSED, uint32_t offset) {
+ return offset; // No thunks added; no limit on relative call distance.
+}
+
+void MipsRelativePatcher::PatchCall(std::vector<uint8_t>* code ATTRIBUTE_UNUSED,
+ uint32_t literal_offset ATTRIBUTE_UNUSED,
+ uint32_t patch_offset ATTRIBUTE_UNUSED,
+ uint32_t target_offset ATTRIBUTE_UNUSED) {
+ UNIMPLEMENTED(FATAL) << "PatchCall unimplemented on MIPS";
+}
+
+void MipsRelativePatcher::PatchPcRelativeReference(std::vector<uint8_t>* code,
+ const LinkerPatch& patch,
+ uint32_t patch_offset,
+ uint32_t target_offset) {
+ uint32_t anchor_literal_offset = patch.PcInsnOffset();
+ uint32_t literal_offset = patch.LiteralOffset();
+
+ // Basic sanity checks.
+ if (is_r6) {
+ DCHECK_GE(code->size(), 8u);
+ DCHECK_LE(literal_offset, code->size() - 8u);
+ DCHECK_EQ(literal_offset, anchor_literal_offset);
+ // AUIPC reg, offset_high
+ DCHECK_EQ((*code)[literal_offset + 0], 0x34);
+ DCHECK_EQ((*code)[literal_offset + 1], 0x12);
+ DCHECK_EQ(((*code)[literal_offset + 2] & 0x1F), 0x1E);
+ DCHECK_EQ(((*code)[literal_offset + 3] & 0xFC), 0xEC);
+ // ADDIU reg, reg, offset_low
+ DCHECK_EQ((*code)[literal_offset + 4], 0x78);
+ DCHECK_EQ((*code)[literal_offset + 5], 0x56);
+ DCHECK_EQ(((*code)[literal_offset + 7] & 0xFC), 0x24);
+ } else {
+ DCHECK_GE(code->size(), 16u);
+ DCHECK_LE(literal_offset, code->size() - 12u);
+ DCHECK_GE(literal_offset, 4u);
+ DCHECK_EQ(literal_offset + 4u, anchor_literal_offset);
+ // NAL
+ DCHECK_EQ((*code)[literal_offset - 4], 0x00);
+ DCHECK_EQ((*code)[literal_offset - 3], 0x00);
+ DCHECK_EQ((*code)[literal_offset - 2], 0x10);
+ DCHECK_EQ((*code)[literal_offset - 1], 0x04);
+ // LUI reg, offset_high
+ DCHECK_EQ((*code)[literal_offset + 0], 0x34);
+ DCHECK_EQ((*code)[literal_offset + 1], 0x12);
+ DCHECK_EQ(((*code)[literal_offset + 2] & 0xE0), 0x00);
+ DCHECK_EQ((*code)[literal_offset + 3], 0x3C);
+ // ORI reg, reg, offset_low
+ DCHECK_EQ((*code)[literal_offset + 4], 0x78);
+ DCHECK_EQ((*code)[literal_offset + 5], 0x56);
+ DCHECK_EQ(((*code)[literal_offset + 7] & 0xFC), 0x34);
+ // ADDU reg, reg, RA
+ DCHECK_EQ((*code)[literal_offset + 8], 0x21);
+ DCHECK_EQ(((*code)[literal_offset + 9] & 0x07), 0x00);
+ DCHECK_EQ(((*code)[literal_offset + 10] & 0x1F), 0x1F);
+ DCHECK_EQ(((*code)[literal_offset + 11] & 0xFC), 0x00);
+ }
+
+ // Apply patch.
+ uint32_t anchor_offset = patch_offset - literal_offset + anchor_literal_offset;
+ uint32_t diff = target_offset - anchor_offset + kDexCacheArrayLwOffset;
+ if (is_r6) {
+ diff += (diff & 0x8000) << 1; // Account for sign extension in ADDIU.
+ }
+
+ // LUI reg, offset_high / AUIPC reg, offset_high
+ (*code)[literal_offset + 0] = static_cast<uint8_t>(diff >> 16);
+ (*code)[literal_offset + 1] = static_cast<uint8_t>(diff >> 24);
+ // ORI reg, reg, offset_low / ADDIU reg, reg, offset_low
+ (*code)[literal_offset + 4] = static_cast<uint8_t>(diff >> 0);
+ (*code)[literal_offset + 5] = static_cast<uint8_t>(diff >> 8);
+}
+
+} // namespace linker
+} // namespace art
diff --git a/compiler/linker/mips/relative_patcher_mips.h b/compiler/linker/mips/relative_patcher_mips.h
new file mode 100644
index 0000000..4ff2f2f
--- /dev/null
+++ b/compiler/linker/mips/relative_patcher_mips.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ART_COMPILER_LINKER_MIPS_RELATIVE_PATCHER_MIPS_H_
+#define ART_COMPILER_LINKER_MIPS_RELATIVE_PATCHER_MIPS_H_
+
+#include "linker/relative_patcher.h"
+#include "arch/mips/instruction_set_features_mips.h"
+
+namespace art {
+namespace linker {
+
+class MipsRelativePatcher FINAL : public RelativePatcher {
+ public:
+ explicit MipsRelativePatcher(const MipsInstructionSetFeatures* features)
+ : is_r6(features->IsR6()) {}
+
+ uint32_t ReserveSpace(uint32_t offset,
+ const CompiledMethod* compiled_method,
+ MethodReference method_ref) OVERRIDE;
+ uint32_t ReserveSpaceEnd(uint32_t offset) OVERRIDE;
+ uint32_t WriteThunks(OutputStream* out, uint32_t offset) OVERRIDE;
+ void PatchCall(std::vector<uint8_t>* code,
+ uint32_t literal_offset,
+ uint32_t patch_offset,
+ uint32_t target_offset) OVERRIDE;
+ void PatchPcRelativeReference(std::vector<uint8_t>* code,
+ const LinkerPatch& patch,
+ uint32_t patch_offset,
+ uint32_t target_offset) OVERRIDE;
+
+ private:
+ // We'll maximize the range of a single load instruction for dex cache array accesses
+ // by aligning offset -32768 with the offset of the first used element.
+ static constexpr uint32_t kDexCacheArrayLwOffset = 0x8000;
+ bool is_r6;
+
+ DISALLOW_COPY_AND_ASSIGN(MipsRelativePatcher);
+};
+
+} // namespace linker
+} // namespace art
+
+#endif // ART_COMPILER_LINKER_MIPS_RELATIVE_PATCHER_MIPS_H_
diff --git a/compiler/linker/mips/relative_patcher_mips32r6_test.cc b/compiler/linker/mips/relative_patcher_mips32r6_test.cc
new file mode 100644
index 0000000..0f1dcbc
--- /dev/null
+++ b/compiler/linker/mips/relative_patcher_mips32r6_test.cc
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "linker/relative_patcher_test.h"
+#include "linker/mips/relative_patcher_mips.h"
+
+namespace art {
+namespace linker {
+
+// We'll maximize the range of a single load instruction for dex cache array accesses
+// by aligning offset -32768 with the offset of the first used element.
+static constexpr uint32_t kDexCacheArrayLwOffset = 0x8000;
+
+class Mips32r6RelativePatcherTest : public RelativePatcherTest {
+ public:
+ Mips32r6RelativePatcherTest() : RelativePatcherTest(kMips, "mips32r6") {}
+
+ protected:
+ uint32_t GetMethodOffset(uint32_t method_idx) {
+ auto result = method_offset_map_.FindMethodOffset(MethodRef(method_idx));
+ CHECK(result.first);
+ return result.second;
+ }
+};
+
+TEST_F(Mips32r6RelativePatcherTest, DexCacheReference) {
+ dex_cache_arrays_begin_ = 0x12345678;
+ constexpr size_t kElementOffset = 0x1234;
+ static const uint8_t raw_code[] = {
+ 0x34, 0x12, 0x5E, 0xEE, // auipc s2, high(diff); placeholder = 0x1234
+ 0x78, 0x56, 0x52, 0x26, // addiu s2, s2, low(diff); placeholder = 0x5678
+ };
+ constexpr uint32_t literal_offset = 0; // At auipc (where patching starts).
+ constexpr uint32_t anchor_offset = literal_offset; // At auipc (where PC+0 points).
+ ArrayRef<const uint8_t> code(raw_code);
+ LinkerPatch patches[] = {
+ LinkerPatch::DexCacheArrayPatch(literal_offset, nullptr, anchor_offset, kElementOffset),
+ };
+ AddCompiledMethod(MethodRef(1u), code, ArrayRef<const LinkerPatch>(patches));
+ Link();
+
+ auto result = method_offset_map_.FindMethodOffset(MethodRef(1u));
+ ASSERT_TRUE(result.first);
+ uint32_t diff = dex_cache_arrays_begin_ + kElementOffset - (result.second + anchor_offset) +
+ kDexCacheArrayLwOffset;
+ diff += (diff & 0x8000) << 1; // Account for sign extension in addiu.
+ static const uint8_t expected_code[] = {
+ static_cast<uint8_t>(diff >> 16), static_cast<uint8_t>(diff >> 24), 0x5E, 0xEE,
+ static_cast<uint8_t>(diff), static_cast<uint8_t>(diff >> 8), 0x52, 0x26,
+ };
+ EXPECT_TRUE(CheckLinkedMethod(MethodRef(1u), ArrayRef<const uint8_t>(expected_code)));
+}
+
+} // namespace linker
+} // namespace art
diff --git a/compiler/linker/mips/relative_patcher_mips_test.cc b/compiler/linker/mips/relative_patcher_mips_test.cc
new file mode 100644
index 0000000..8391b53
--- /dev/null
+++ b/compiler/linker/mips/relative_patcher_mips_test.cc
@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "linker/relative_patcher_test.h"
+#include "linker/mips/relative_patcher_mips.h"
+
+namespace art {
+namespace linker {
+
+// We'll maximize the range of a single load instruction for dex cache array accesses
+// by aligning offset -32768 with the offset of the first used element.
+static constexpr uint32_t kDexCacheArrayLwOffset = 0x8000;
+
+class MipsRelativePatcherTest : public RelativePatcherTest {
+ public:
+ MipsRelativePatcherTest() : RelativePatcherTest(kMips, "mips32r2") {}
+
+ protected:
+ uint32_t GetMethodOffset(uint32_t method_idx) {
+ auto result = method_offset_map_.FindMethodOffset(MethodRef(method_idx));
+ CHECK(result.first);
+ return result.second;
+ }
+};
+
+TEST_F(MipsRelativePatcherTest, DexCacheReference) {
+ dex_cache_arrays_begin_ = 0x12345678;
+ constexpr size_t kElementOffset = 0x1234;
+ static const uint8_t raw_code[] = {
+ 0x00, 0x00, 0x10, 0x04, // nal
+ 0x34, 0x12, 0x12, 0x3C, // lui s2, high(diff); placeholder = 0x1234
+ 0x78, 0x56, 0x52, 0x36, // ori s2, s2, low(diff); placeholder = 0x5678
+ 0x21, 0x90, 0x5F, 0x02, // addu s2, s2, ra
+ };
+ constexpr uint32_t literal_offset = 4; // At lui (where patching starts).
+ constexpr uint32_t anchor_offset = 8; // At ori (where PC+0 points).
+ ArrayRef<const uint8_t> code(raw_code);
+ LinkerPatch patches[] = {
+ LinkerPatch::DexCacheArrayPatch(literal_offset, nullptr, anchor_offset, kElementOffset),
+ };
+ AddCompiledMethod(MethodRef(1u), code, ArrayRef<const LinkerPatch>(patches));
+ Link();
+
+ auto result = method_offset_map_.FindMethodOffset(MethodRef(1u));
+ ASSERT_TRUE(result.first);
+ uint32_t diff = dex_cache_arrays_begin_ + kElementOffset - (result.second + anchor_offset) +
+ kDexCacheArrayLwOffset;
+ static const uint8_t expected_code[] = {
+ 0x00, 0x00, 0x10, 0x04,
+ static_cast<uint8_t>(diff >> 16), static_cast<uint8_t>(diff >> 24), 0x12, 0x3C,
+ static_cast<uint8_t>(diff), static_cast<uint8_t>(diff >> 8), 0x52, 0x36,
+ 0x21, 0x90, 0x5F, 0x02,
+ };
+ EXPECT_TRUE(CheckLinkedMethod(MethodRef(1u), ArrayRef<const uint8_t>(expected_code)));
+}
+
+} // namespace linker
+} // namespace art
diff --git a/compiler/linker/relative_patcher.cc b/compiler/linker/relative_patcher.cc
index 3a22983..7765594 100644
--- a/compiler/linker/relative_patcher.cc
+++ b/compiler/linker/relative_patcher.cc
@@ -22,6 +22,9 @@
#ifdef ART_ENABLE_CODEGEN_arm64
#include "linker/arm64/relative_patcher_arm64.h"
#endif
+#ifdef ART_ENABLE_CODEGEN_mips
+#include "linker/mips/relative_patcher_mips.h"
+#endif
#ifdef ART_ENABLE_CODEGEN_x86
#include "linker/x86/relative_patcher_x86.h"
#endif
@@ -95,6 +98,11 @@
return std::unique_ptr<RelativePatcher>(
new Arm64RelativePatcher(provider, features->AsArm64InstructionSetFeatures()));
#endif
+#ifdef ART_ENABLE_CODEGEN_mips
+ case kMips:
+ return std::unique_ptr<RelativePatcher>(
+ new MipsRelativePatcher(features->AsMipsInstructionSetFeatures()));
+#endif
default:
return std::unique_ptr<RelativePatcher>(new RelativePatcherNone);
}
diff --git a/compiler/optimizing/bounds_check_elimination.cc b/compiler/optimizing/bounds_check_elimination.cc
index e9fcfe2..1fc247f 100644
--- a/compiler/optimizing/bounds_check_elimination.cc
+++ b/compiler/optimizing/bounds_check_elimination.cc
@@ -847,7 +847,7 @@
}
// Try index range obtained by induction variable analysis.
// Disables dynamic bce if OOB is certain.
- if (InductionRangeFitsIn(&array_range, bounds_check, index, &try_dynamic_bce)) {
+ if (InductionRangeFitsIn(&array_range, bounds_check, &try_dynamic_bce)) {
ReplaceInstruction(bounds_check, index);
return;
}
@@ -912,9 +912,9 @@
static bool HasSameInputAtBackEdges(HPhi* phi) {
DCHECK(phi->IsLoopHeaderPhi());
- auto&& inputs = phi->GetInputs();
+ HConstInputsRef inputs = phi->GetInputs();
// Start with input 1. Input 0 is from the incoming block.
- HInstruction* input1 = inputs[1];
+ const HInstruction* input1 = inputs[1];
DCHECK(phi->GetBlock()->GetLoopInformation()->IsBackEdge(
*phi->GetBlock()->GetPredecessors()[1]));
for (size_t i = 2; i < inputs.size(); ++i) {
@@ -1299,33 +1299,30 @@
* parameter try_dynamic_bce is set to false if OOB is certain.
*/
bool InductionRangeFitsIn(ValueRange* array_range,
- HInstruction* context,
- HInstruction* index,
+ HBoundsCheck* context,
bool* try_dynamic_bce) {
InductionVarRange::Value v1;
InductionVarRange::Value v2;
bool needs_finite_test = false;
- if (induction_range_.GetInductionRange(context, index, &v1, &v2, &needs_finite_test)) {
- do {
- if (v1.is_known && (v1.a_constant == 0 || v1.a_constant == 1) &&
- v2.is_known && (v2.a_constant == 0 || v2.a_constant == 1)) {
- DCHECK(v1.a_constant == 1 || v1.instruction == nullptr);
- DCHECK(v2.a_constant == 1 || v2.instruction == nullptr);
- ValueRange index_range(GetGraph()->GetArena(),
- ValueBound(v1.instruction, v1.b_constant),
- ValueBound(v2.instruction, v2.b_constant));
- // If analysis reveals a certain OOB, disable dynamic BCE.
- if (index_range.GetLower().LessThan(array_range->GetLower()) ||
- index_range.GetUpper().GreaterThan(array_range->GetUpper())) {
- *try_dynamic_bce = false;
- return false;
- }
- // Use analysis for static bce only if loop is finite.
- if (!needs_finite_test && index_range.FitsIn(array_range)) {
- return true;
- }
+ HInstruction* index = context->InputAt(0);
+ HInstruction* hint = ValueBound::HuntForDeclaration(context->InputAt(1));
+ if (induction_range_.GetInductionRange(context, index, hint, &v1, &v2, &needs_finite_test)) {
+ if (v1.is_known && (v1.a_constant == 0 || v1.a_constant == 1) &&
+ v2.is_known && (v2.a_constant == 0 || v2.a_constant == 1)) {
+ DCHECK(v1.a_constant == 1 || v1.instruction == nullptr);
+ DCHECK(v2.a_constant == 1 || v2.instruction == nullptr);
+ ValueRange index_range(GetGraph()->GetArena(),
+ ValueBound(v1.instruction, v1.b_constant),
+ ValueBound(v2.instruction, v2.b_constant));
+ // If analysis reveals a certain OOB, disable dynamic BCE. Otherwise,
+ // use analysis for static bce only if loop is finite.
+ if (index_range.GetLower().LessThan(array_range->GetLower()) ||
+ index_range.GetUpper().GreaterThan(array_range->GetUpper())) {
+ *try_dynamic_bce = false;
+ } else if (!needs_finite_test && index_range.FitsIn(array_range)) {
+ return true;
}
- } while (induction_range_.RefineOuter(&v1, &v2));
+ }
}
return false;
}
diff --git a/compiler/optimizing/code_generator.cc b/compiler/optimizing/code_generator.cc
index 12aa152..4520f9b 100644
--- a/compiler/optimizing/code_generator.cc
+++ b/compiler/optimizing/code_generator.cc
@@ -111,7 +111,7 @@
<< " " << locations->Out();
}
- auto&& inputs = instruction->GetInputs();
+ HConstInputsRef inputs = instruction->GetInputs();
for (size_t i = 0; i < inputs.size(); ++i) {
DCHECK(CheckType(inputs[i]->GetType(), locations->InAt(i)))
<< inputs[i]->GetType() << " " << locations->InAt(i);
diff --git a/compiler/optimizing/code_generator_arm.cc b/compiler/optimizing/code_generator_arm.cc
index 5316d59..690ecc3 100644
--- a/compiler/optimizing/code_generator_arm.cc
+++ b/compiler/optimizing/code_generator_arm.cc
@@ -1889,8 +1889,6 @@
LocationSummary* locations = invoke->GetLocations();
Register temp = locations->GetTemp(0).AsRegister<Register>();
Register hidden_reg = locations->GetTemp(1).AsRegister<Register>();
- uint32_t method_offset = mirror::Class::EmbeddedImTableEntryOffset(
- invoke->GetImtIndex() % mirror::Class::kImtSize, kArmPointerSize).Uint32Value();
Location receiver = locations->InAt(0);
uint32_t class_offset = mirror::Object::ClassOffset().Int32Value();
@@ -1916,10 +1914,14 @@
// intact/accessible until the end of the marking phase (the
// concurrent copying collector may not in the future).
__ MaybeUnpoisonHeapReference(temp);
+ __ LoadFromOffset(kLoadWord, temp, temp,
+ mirror::Class::ImtPtrOffset(kArmPointerSize).Uint32Value());
+ uint32_t method_offset = static_cast<uint32_t>(ImTable::OffsetOfElement(
+ invoke->GetImtIndex() % ImTable::kSize, kArmPointerSize));
// temp = temp->GetImtEntryAt(method_offset);
+ __ LoadFromOffset(kLoadWord, temp, temp, method_offset);
uint32_t entry_point =
ArtMethod::EntryPointFromQuickCompiledCodeOffset(kArmWordSize).Int32Value();
- __ LoadFromOffset(kLoadWord, temp, temp, method_offset);
// LR = temp->GetEntryPoint();
__ LoadFromOffset(kLoadWord, LR, temp, entry_point);
// LR();
@@ -2290,8 +2292,7 @@
case Primitive::kPrimFloat: {
// Processing a Dex `float-to-int' instruction.
SRegister temp = locations->GetTemp(0).AsFpuRegisterPairLow<SRegister>();
- __ vmovs(temp, in.AsFpuRegister<SRegister>());
- __ vcvtis(temp, temp);
+ __ vcvtis(temp, in.AsFpuRegister<SRegister>());
__ vmovrs(out.AsRegister<Register>(), temp);
break;
}
@@ -2299,9 +2300,7 @@
case Primitive::kPrimDouble: {
// Processing a Dex `double-to-int' instruction.
SRegister temp_s = locations->GetTemp(0).AsFpuRegisterPairLow<SRegister>();
- DRegister temp_d = FromLowSToD(temp_s);
- __ vmovd(temp_d, FromLowSToD(in.AsFpuRegisterPairLow<SRegister>()));
- __ vcvtid(temp_s, temp_d);
+ __ vcvtid(temp_s, FromLowSToD(in.AsFpuRegisterPairLow<SRegister>()));
__ vmovrs(out.AsRegister<Register>(), temp_s);
break;
}
@@ -6959,8 +6958,11 @@
method_offset = mirror::Class::EmbeddedVTableEntryOffset(
instruction->GetIndex(), kArmPointerSize).SizeValue();
} else {
- method_offset = mirror::Class::EmbeddedImTableEntryOffset(
- instruction->GetIndex() % mirror::Class::kImtSize, kArmPointerSize).Uint32Value();
+ __ LoadFromOffset(kLoadWord, locations->Out().AsRegister<Register>(),
+ locations->InAt(0).AsRegister<Register>(),
+ mirror::Class::ImtPtrOffset(kArmPointerSize).Uint32Value());
+ method_offset = static_cast<uint32_t>(ImTable::OffsetOfElement(
+ instruction->GetIndex() % ImTable::kSize, kArmPointerSize));
}
__ LoadFromOffset(kLoadWord,
locations->Out().AsRegister<Register>(),
diff --git a/compiler/optimizing/code_generator_arm64.cc b/compiler/optimizing/code_generator_arm64.cc
index fc2c2c3..c8d33d5 100644
--- a/compiler/optimizing/code_generator_arm64.cc
+++ b/compiler/optimizing/code_generator_arm64.cc
@@ -3506,8 +3506,6 @@
// TODO: b/18116999, our IMTs can miss an IncompatibleClassChangeError.
LocationSummary* locations = invoke->GetLocations();
Register temp = XRegisterFrom(locations->GetTemp(0));
- uint32_t method_offset = mirror::Class::EmbeddedImTableEntryOffset(
- invoke->GetImtIndex() % mirror::Class::kImtSize, kArm64PointerSize).Uint32Value();
Location receiver = locations->InAt(0);
Offset class_offset = mirror::Object::ClassOffset();
Offset entry_point = ArtMethod::EntryPointFromQuickCompiledCodeOffset(kArm64WordSize);
@@ -3537,6 +3535,10 @@
// intact/accessible until the end of the marking phase (the
// concurrent copying collector may not in the future).
GetAssembler()->MaybeUnpoisonHeapReference(temp.W());
+ __ Ldr(temp,
+ MemOperand(temp, mirror::Class::ImtPtrOffset(kArm64PointerSize).Uint32Value()));
+ uint32_t method_offset = static_cast<uint32_t>(ImTable::OffsetOfElement(
+ invoke->GetImtIndex() % ImTable::kSize, kArm64PointerSize));
// temp = temp->GetImtEntryAt(method_offset);
__ Ldr(temp, MemOperand(temp, method_offset));
// lr = temp->GetEntryPoint();
@@ -5353,8 +5355,10 @@
method_offset = mirror::Class::EmbeddedVTableEntryOffset(
instruction->GetIndex(), kArm64PointerSize).SizeValue();
} else {
- method_offset = mirror::Class::EmbeddedImTableEntryOffset(
- instruction->GetIndex() % mirror::Class::kImtSize, kArm64PointerSize).Uint32Value();
+ __ Ldr(XRegisterFrom(locations->Out()), MemOperand(XRegisterFrom(locations->InAt(0)),
+ mirror::Class::ImtPtrOffset(kArm64PointerSize).Uint32Value()));
+ method_offset = static_cast<uint32_t>(ImTable::OffsetOfElement(
+ instruction->GetIndex() % ImTable::kSize, kArm64PointerSize));
}
__ Ldr(XRegisterFrom(locations->Out()),
MemOperand(XRegisterFrom(locations->InAt(0)), method_offset));
diff --git a/compiler/optimizing/code_generator_mips.cc b/compiler/optimizing/code_generator_mips.cc
index 4d44c18..b6dca95 100644
--- a/compiler/optimizing/code_generator_mips.cc
+++ b/compiler/optimizing/code_generator_mips.cc
@@ -39,6 +39,10 @@
static constexpr int kCurrentMethodStackOffset = 0;
static constexpr Register kMethodRegisterArgument = A0;
+// We'll maximize the range of a single load instruction for dex cache array accesses
+// by aligning offset -32768 with the offset of the first used element.
+static constexpr uint32_t kDexCacheArrayLwOffset = 0x8000;
+
Location MipsReturnLocation(Primitive::Type return_type) {
switch (return_type) {
case Primitive::kPrimBoolean:
@@ -477,7 +481,12 @@
instruction_visitor_(graph, this),
move_resolver_(graph->GetArena(), this),
assembler_(graph->GetArena(), &isa_features),
- isa_features_(isa_features) {
+ isa_features_(isa_features),
+ method_patches_(MethodReferenceComparator(),
+ graph->GetArena()->Adapter(kArenaAllocCodeGenerator)),
+ call_patches_(MethodReferenceComparator(),
+ graph->GetArena()->Adapter(kArenaAllocCodeGenerator)),
+ pc_relative_dex_cache_patches_(graph->GetArena()->Adapter(kArenaAllocCodeGenerator)) {
// Save RA (containing the return address) to mimic Quick.
AddAllocatedRegister(Location::RegisterLocation(RA));
}
@@ -948,6 +957,71 @@
}
}
+void CodeGeneratorMIPS::EmitLinkerPatches(ArenaVector<LinkerPatch>* linker_patches) {
+ DCHECK(linker_patches->empty());
+ size_t size =
+ method_patches_.size() +
+ call_patches_.size() +
+ pc_relative_dex_cache_patches_.size();
+ linker_patches->reserve(size);
+ for (const auto& entry : method_patches_) {
+ const MethodReference& target_method = entry.first;
+ Literal* literal = entry.second;
+ DCHECK(literal->GetLabel()->IsBound());
+ uint32_t literal_offset = __ GetLabelLocation(literal->GetLabel());
+ linker_patches->push_back(LinkerPatch::MethodPatch(literal_offset,
+ target_method.dex_file,
+ target_method.dex_method_index));
+ }
+ for (const auto& entry : call_patches_) {
+ const MethodReference& target_method = entry.first;
+ Literal* literal = entry.second;
+ DCHECK(literal->GetLabel()->IsBound());
+ uint32_t literal_offset = __ GetLabelLocation(literal->GetLabel());
+ linker_patches->push_back(LinkerPatch::CodePatch(literal_offset,
+ target_method.dex_file,
+ target_method.dex_method_index));
+ }
+ for (const PcRelativePatchInfo& info : pc_relative_dex_cache_patches_) {
+ const DexFile& dex_file = info.target_dex_file;
+ size_t base_element_offset = info.offset_or_index;
+ DCHECK(info.high_label.IsBound());
+ uint32_t high_offset = __ GetLabelLocation(&info.high_label);
+ DCHECK(info.pc_rel_label.IsBound());
+ uint32_t pc_rel_offset = __ GetLabelLocation(&info.pc_rel_label);
+ linker_patches->push_back(LinkerPatch::DexCacheArrayPatch(high_offset,
+ &dex_file,
+ pc_rel_offset,
+ base_element_offset));
+ }
+}
+
+CodeGeneratorMIPS::PcRelativePatchInfo* CodeGeneratorMIPS::NewPcRelativeDexCacheArrayPatch(
+ const DexFile& dex_file, uint32_t element_offset) {
+ return NewPcRelativePatch(dex_file, element_offset, &pc_relative_dex_cache_patches_);
+}
+
+CodeGeneratorMIPS::PcRelativePatchInfo* CodeGeneratorMIPS::NewPcRelativePatch(
+ const DexFile& dex_file, uint32_t offset_or_index, ArenaDeque<PcRelativePatchInfo>* patches) {
+ patches->emplace_back(dex_file, offset_or_index);
+ return &patches->back();
+}
+
+Literal* CodeGeneratorMIPS::DeduplicateMethodLiteral(MethodReference target_method,
+ MethodToLiteralMap* map) {
+ return map->GetOrCreate(
+ target_method,
+ [this]() { return __ NewLiteral<uint32_t>(/* placeholder */ 0u); });
+}
+
+Literal* CodeGeneratorMIPS::DeduplicateMethodAddressLiteral(MethodReference target_method) {
+ return DeduplicateMethodLiteral(target_method, &method_patches_);
+}
+
+Literal* CodeGeneratorMIPS::DeduplicateMethodCodeLiteral(MethodReference target_method) {
+ return DeduplicateMethodLiteral(target_method, &call_patches_);
+}
+
void CodeGeneratorMIPS::MarkGCCard(Register object, Register value) {
MipsLabel done;
Register card = AT;
@@ -3698,8 +3772,6 @@
void InstructionCodeGeneratorMIPS::VisitInvokeInterface(HInvokeInterface* invoke) {
// TODO: b/18116999, our IMTs can miss an IncompatibleClassChangeError.
Register temp = invoke->GetLocations()->GetTemp(0).AsRegister<Register>();
- uint32_t method_offset = mirror::Class::EmbeddedImTableEntryOffset(
- invoke->GetImtIndex() % mirror::Class::kImtSize, kMipsPointerSize).Uint32Value();
Location receiver = invoke->GetLocations()->InAt(0);
uint32_t class_offset = mirror::Object::ClassOffset().Int32Value();
Offset entry_point = ArtMethod::EntryPointFromQuickCompiledCodeOffset(kMipsWordSize);
@@ -3716,6 +3788,10 @@
__ LoadFromOffset(kLoadWord, temp, receiver.AsRegister<Register>(), class_offset);
}
codegen_->MaybeRecordImplicitNullCheck(invoke);
+ __ LoadFromOffset(kLoadWord, temp, temp,
+ mirror::Class::ImtPtrOffset(kMipsPointerSize).Uint32Value());
+ uint32_t method_offset = static_cast<uint32_t>(ImTable::OffsetOfElement(
+ invoke->GetImtIndex() % ImTable::kSize, kMipsPointerSize));
// temp = temp->GetImtEntryAt(method_offset);
__ LoadFromOffset(kLoadWord, temp, temp, method_offset);
// T9 = temp->GetEntryPoint();
@@ -3741,12 +3817,38 @@
// art::PrepareForRegisterAllocation.
DCHECK(!invoke->IsStaticWithExplicitClinitCheck());
+ HInvokeStaticOrDirect::MethodLoadKind method_load_kind = invoke->GetMethodLoadKind();
+ HInvokeStaticOrDirect::CodePtrLocation code_ptr_location = invoke->GetCodePtrLocation();
+ bool isR6 = codegen_->GetInstructionSetFeatures().IsR6();
+
+ // kDirectAddressWithFixup and kCallDirectWithFixup need no extra input on R6 because
+ // R6 has PC-relative addressing.
+ bool has_extra_input = !isR6 &&
+ ((method_load_kind == HInvokeStaticOrDirect::MethodLoadKind::kDirectAddressWithFixup) ||
+ (code_ptr_location == HInvokeStaticOrDirect::CodePtrLocation::kCallDirectWithFixup));
+
+ if (invoke->HasPcRelativeDexCache()) {
+ // kDexCachePcRelative is mutually exclusive with
+ // kDirectAddressWithFixup/kCallDirectWithFixup.
+ CHECK(!has_extra_input);
+ has_extra_input = true;
+ }
+
IntrinsicLocationsBuilderMIPS intrinsic(codegen_);
if (intrinsic.TryDispatch(invoke)) {
+ if (invoke->GetLocations()->CanCall() && has_extra_input) {
+ invoke->GetLocations()->SetInAt(invoke->GetSpecialInputIndex(), Location::Any());
+ }
return;
}
HandleInvoke(invoke);
+
+ // Add the extra input register if either the dex cache array base register
+ // or the PC-relative base register for accessing literals is needed.
+ if (has_extra_input) {
+ invoke->GetLocations()->SetInAt(invoke->GetSpecialInputIndex(), Location::RequiresRegister());
+ }
}
static bool TryGenerateIntrinsicCode(HInvoke* invoke, CodeGeneratorMIPS* codegen) {
@@ -3771,42 +3873,103 @@
return HLoadClass::LoadKind::kDexCacheViaMethod;
}
+Register CodeGeneratorMIPS::GetInvokeStaticOrDirectExtraParameter(HInvokeStaticOrDirect* invoke,
+ Register temp) {
+ CHECK_EQ(invoke->InputCount(), invoke->GetNumberOfArguments() + 1u);
+ Location location = invoke->GetLocations()->InAt(invoke->GetSpecialInputIndex());
+ if (!invoke->GetLocations()->Intrinsified()) {
+ return location.AsRegister<Register>();
+ }
+ // For intrinsics we allow any location, so it may be on the stack.
+ if (!location.IsRegister()) {
+ __ LoadFromOffset(kLoadWord, temp, SP, location.GetStackIndex());
+ return temp;
+ }
+ // For register locations, check if the register was saved. If so, get it from the stack.
+ // Note: There is a chance that the register was saved but not overwritten, so we could
+ // save one load. However, since this is just an intrinsic slow path we prefer this
+ // simple and more robust approach rather that trying to determine if that's the case.
+ SlowPathCode* slow_path = GetCurrentSlowPath();
+ DCHECK(slow_path != nullptr); // For intrinsified invokes the call is emitted on the slow path.
+ if (slow_path->IsCoreRegisterSaved(location.AsRegister<Register>())) {
+ int stack_offset = slow_path->GetStackOffsetOfCoreRegister(location.AsRegister<Register>());
+ __ LoadFromOffset(kLoadWord, temp, SP, stack_offset);
+ return temp;
+ }
+ return location.AsRegister<Register>();
+}
+
HInvokeStaticOrDirect::DispatchInfo CodeGeneratorMIPS::GetSupportedInvokeStaticOrDirectDispatch(
const HInvokeStaticOrDirect::DispatchInfo& desired_dispatch_info,
MethodReference target_method ATTRIBUTE_UNUSED) {
- switch (desired_dispatch_info.method_load_kind) {
+ HInvokeStaticOrDirect::DispatchInfo dispatch_info = desired_dispatch_info;
+ // We disable PC-relative load when there is an irreducible loop, as the optimization
+ // is incompatible with it.
+ bool has_irreducible_loops = GetGraph()->HasIrreducibleLoops();
+ bool fallback_load = true;
+ bool fallback_call = true;
+ switch (dispatch_info.method_load_kind) {
case HInvokeStaticOrDirect::MethodLoadKind::kDirectAddressWithFixup:
case HInvokeStaticOrDirect::MethodLoadKind::kDexCachePcRelative:
- // TODO: Implement these types. For the moment, we fall back to kDexCacheViaMethod.
- return HInvokeStaticOrDirect::DispatchInfo {
- HInvokeStaticOrDirect::MethodLoadKind::kDexCacheViaMethod,
- HInvokeStaticOrDirect::CodePtrLocation::kCallArtMethod,
- 0u,
- 0u
- };
+ fallback_load = has_irreducible_loops;
+ break;
default:
+ fallback_load = false;
break;
}
- switch (desired_dispatch_info.code_ptr_location) {
+ switch (dispatch_info.code_ptr_location) {
case HInvokeStaticOrDirect::CodePtrLocation::kCallDirectWithFixup:
+ fallback_call = has_irreducible_loops;
+ break;
case HInvokeStaticOrDirect::CodePtrLocation::kCallPCRelative:
- // TODO: Implement these types. For the moment, we fall back to kCallArtMethod.
- return HInvokeStaticOrDirect::DispatchInfo {
- desired_dispatch_info.method_load_kind,
- HInvokeStaticOrDirect::CodePtrLocation::kCallArtMethod,
- desired_dispatch_info.method_load_data,
- 0u
- };
+ // TODO: Implement this type.
+ break;
default:
- return desired_dispatch_info;
+ fallback_call = false;
+ break;
}
+ if (fallback_load) {
+ dispatch_info.method_load_kind = HInvokeStaticOrDirect::MethodLoadKind::kDexCacheViaMethod;
+ dispatch_info.method_load_data = 0;
+ }
+ if (fallback_call) {
+ dispatch_info.code_ptr_location = HInvokeStaticOrDirect::CodePtrLocation::kCallArtMethod;
+ dispatch_info.direct_code_ptr = 0;
+ }
+ return dispatch_info;
}
void CodeGeneratorMIPS::GenerateStaticOrDirectCall(HInvokeStaticOrDirect* invoke, Location temp) {
// All registers are assumed to be correctly set up per the calling convention.
-
Location callee_method = temp; // For all kinds except kRecursive, callee will be in temp.
- switch (invoke->GetMethodLoadKind()) {
+ HInvokeStaticOrDirect::MethodLoadKind method_load_kind = invoke->GetMethodLoadKind();
+ HInvokeStaticOrDirect::CodePtrLocation code_ptr_location = invoke->GetCodePtrLocation();
+ bool isR6 = isa_features_.IsR6();
+ // kDirectAddressWithFixup and kCallDirectWithFixup have no extra input on R6 because
+ // R6 has PC-relative addressing.
+ bool has_extra_input = invoke->HasPcRelativeDexCache() ||
+ (!isR6 &&
+ ((method_load_kind == HInvokeStaticOrDirect::MethodLoadKind::kDirectAddressWithFixup) ||
+ (code_ptr_location == HInvokeStaticOrDirect::CodePtrLocation::kCallDirectWithFixup)));
+ Register base_reg = has_extra_input
+ ? GetInvokeStaticOrDirectExtraParameter(invoke, temp.AsRegister<Register>())
+ : ZERO;
+
+ // For better instruction scheduling we load the direct code pointer before the method pointer.
+ switch (code_ptr_location) {
+ case HInvokeStaticOrDirect::CodePtrLocation::kCallDirect:
+ // T9 = invoke->GetDirectCodePtr();
+ __ LoadConst32(T9, invoke->GetDirectCodePtr());
+ break;
+ case HInvokeStaticOrDirect::CodePtrLocation::kCallDirectWithFixup:
+ // T9 = code address from literal pool with link-time patch.
+ __ LoadLiteral(T9, base_reg, DeduplicateMethodCodeLiteral(invoke->GetTargetMethod()));
+ break;
+ default:
+ break;
+ }
+
+ switch (method_load_kind) {
case HInvokeStaticOrDirect::MethodLoadKind::kStringInit:
// temp = thread->string_init_entrypoint
__ LoadFromOffset(kLoadWord,
@@ -3821,11 +3984,18 @@
__ LoadConst32(temp.AsRegister<Register>(), invoke->GetMethodAddress());
break;
case HInvokeStaticOrDirect::MethodLoadKind::kDirectAddressWithFixup:
- case HInvokeStaticOrDirect::MethodLoadKind::kDexCachePcRelative:
- // TODO: Implement these types.
- // Currently filtered out by GetSupportedInvokeStaticOrDirectDispatch().
- LOG(FATAL) << "Unsupported";
- UNREACHABLE();
+ __ LoadLiteral(temp.AsRegister<Register>(),
+ base_reg,
+ DeduplicateMethodAddressLiteral(invoke->GetTargetMethod()));
+ break;
+ case HInvokeStaticOrDirect::MethodLoadKind::kDexCachePcRelative: {
+ HMipsDexCacheArraysBase* base =
+ invoke->InputAt(invoke->GetSpecialInputIndex())->AsMipsDexCacheArraysBase();
+ int32_t offset =
+ invoke->GetDexCacheArrayOffset() - base->GetElementOffset() - kDexCacheArrayLwOffset;
+ __ LoadFromOffset(kLoadWord, temp.AsRegister<Register>(), base_reg, offset);
+ break;
+ }
case HInvokeStaticOrDirect::MethodLoadKind::kDexCacheViaMethod: {
Location current_method = invoke->GetLocations()->InAt(invoke->GetSpecialInputIndex());
Register reg = temp.AsRegister<Register>();
@@ -3856,20 +4026,19 @@
}
}
- switch (invoke->GetCodePtrLocation()) {
+ switch (code_ptr_location) {
case HInvokeStaticOrDirect::CodePtrLocation::kCallSelf:
- __ Jalr(&frame_entry_label_, T9);
+ __ Bal(&frame_entry_label_);
break;
case HInvokeStaticOrDirect::CodePtrLocation::kCallDirect:
- // LR = invoke->GetDirectCodePtr();
- __ LoadConst32(T9, invoke->GetDirectCodePtr());
- // LR()
+ case HInvokeStaticOrDirect::CodePtrLocation::kCallDirectWithFixup:
+ // T9 prepared above for better instruction scheduling.
+ // T9()
__ Jalr(T9);
__ Nop();
break;
- case HInvokeStaticOrDirect::CodePtrLocation::kCallDirectWithFixup:
case HInvokeStaticOrDirect::CodePtrLocation::kCallPCRelative:
- // TODO: Implement these types.
+ // TODO: Implement this type.
// Currently filtered out by GetSupportedInvokeStaticOrDirectDispatch().
LOG(FATAL) << "Unsupported";
UNREACHABLE();
@@ -5140,6 +5309,57 @@
}
}
+void LocationsBuilderMIPS::VisitMipsComputeBaseMethodAddress(
+ HMipsComputeBaseMethodAddress* insn) {
+ LocationSummary* locations =
+ new (GetGraph()->GetArena()) LocationSummary(insn, LocationSummary::kNoCall);
+ locations->SetOut(Location::RequiresRegister());
+}
+
+void InstructionCodeGeneratorMIPS::VisitMipsComputeBaseMethodAddress(
+ HMipsComputeBaseMethodAddress* insn) {
+ LocationSummary* locations = insn->GetLocations();
+ Register reg = locations->Out().AsRegister<Register>();
+
+ CHECK(!codegen_->GetInstructionSetFeatures().IsR6());
+
+ // Generate a dummy PC-relative call to obtain PC.
+ __ Nal();
+ // Grab the return address off RA.
+ __ Move(reg, RA);
+
+ // Remember this offset (the obtained PC value) for later use with constant area.
+ __ BindPcRelBaseLabel();
+}
+
+void LocationsBuilderMIPS::VisitMipsDexCacheArraysBase(HMipsDexCacheArraysBase* base) {
+ LocationSummary* locations = new (GetGraph()->GetArena()) LocationSummary(base);
+ locations->SetOut(Location::RequiresRegister());
+}
+
+void InstructionCodeGeneratorMIPS::VisitMipsDexCacheArraysBase(HMipsDexCacheArraysBase* base) {
+ Register reg = base->GetLocations()->Out().AsRegister<Register>();
+ CodeGeneratorMIPS::PcRelativePatchInfo* info =
+ codegen_->NewPcRelativeDexCacheArrayPatch(base->GetDexFile(), base->GetElementOffset());
+
+ if (codegen_->GetInstructionSetFeatures().IsR6()) {
+ __ Bind(&info->high_label);
+ __ Bind(&info->pc_rel_label);
+ // Add a 32-bit offset to PC.
+ __ Auipc(reg, /* placeholder */ 0x1234);
+ __ Addiu(reg, reg, /* placeholder */ 0x5678);
+ } else {
+ // Generate a dummy PC-relative call to obtain PC.
+ __ Nal();
+ __ Bind(&info->high_label);
+ __ Lui(reg, /* placeholder */ 0x1234);
+ __ Bind(&info->pc_rel_label);
+ __ Ori(reg, reg, /* placeholder */ 0x5678);
+ // Add a 32-bit offset to PC.
+ __ Addu(reg, reg, RA);
+ }
+}
+
void LocationsBuilderMIPS::VisitInvokeUnresolved(HInvokeUnresolved* invoke) {
// The trampoline uses the same calling convention as dex calling conventions,
// except instead of loading arg0/r0 with the target Method*, arg0/r0 will contain
@@ -5165,8 +5385,12 @@
method_offset = mirror::Class::EmbeddedVTableEntryOffset(
instruction->GetIndex(), kMipsPointerSize).SizeValue();
} else {
- method_offset = mirror::Class::EmbeddedImTableEntryOffset(
- instruction->GetIndex() % mirror::Class::kImtSize, kMipsPointerSize).Uint32Value();
+ __ LoadFromOffset(kLoadWord,
+ locations->Out().AsRegister<Register>(),
+ locations->InAt(0).AsRegister<Register>(),
+ mirror::Class::ImtPtrOffset(kMipsPointerSize).Uint32Value());
+ method_offset = static_cast<uint32_t>(ImTable::OffsetOfElement(
+ instruction->GetIndex() % ImTable::kSize, kMipsPointerSize));
}
__ LoadFromOffset(kLoadWord,
locations->Out().AsRegister<Register>(),
diff --git a/compiler/optimizing/code_generator_mips.h b/compiler/optimizing/code_generator_mips.h
index 6487f28..08f74c0 100644
--- a/compiler/optimizing/code_generator_mips.h
+++ b/compiler/optimizing/code_generator_mips.h
@@ -285,6 +285,9 @@
MipsAssembler* GetAssembler() OVERRIDE { return &assembler_; }
const MipsAssembler& GetAssembler() const OVERRIDE { return assembler_; }
+ // Emit linker patches.
+ void EmitLinkerPatches(ArenaVector<LinkerPatch>* linker_patches) OVERRIDE;
+
void MarkGCCard(Register object, Register value);
// Register allocation.
@@ -372,7 +375,39 @@
void GenerateImplicitNullCheck(HNullCheck* instruction);
void GenerateExplicitNullCheck(HNullCheck* instruction);
+ // The PcRelativePatchInfo is used for PC-relative addressing of dex cache arrays
+ // and boot image strings. The only difference is the interpretation of the offset_or_index.
+ struct PcRelativePatchInfo {
+ PcRelativePatchInfo(const DexFile& dex_file, uint32_t off_or_idx)
+ : target_dex_file(dex_file), offset_or_index(off_or_idx) { }
+ PcRelativePatchInfo(PcRelativePatchInfo&& other) = default;
+
+ const DexFile& target_dex_file;
+ // Either the dex cache array element offset or the string index.
+ uint32_t offset_or_index;
+ // Label for the instruction loading the most significant half of the offset that's added to PC
+ // to form the base address (the least significant half is loaded with the instruction that
+ // follows).
+ MipsLabel high_label;
+ // Label for the instruction corresponding to PC+0.
+ MipsLabel pc_rel_label;
+ };
+
+ PcRelativePatchInfo* NewPcRelativeDexCacheArrayPatch(const DexFile& dex_file,
+ uint32_t element_offset);
+
private:
+ Register GetInvokeStaticOrDirectExtraParameter(HInvokeStaticOrDirect* invoke, Register temp);
+
+ using MethodToLiteralMap = ArenaSafeMap<MethodReference, Literal*, MethodReferenceComparator>;
+
+ Literal* DeduplicateMethodLiteral(MethodReference target_method, MethodToLiteralMap* map);
+ Literal* DeduplicateMethodAddressLiteral(MethodReference target_method);
+ Literal* DeduplicateMethodCodeLiteral(MethodReference target_method);
+ PcRelativePatchInfo* NewPcRelativePatch(const DexFile& dex_file,
+ uint32_t offset_or_index,
+ ArenaDeque<PcRelativePatchInfo>* patches);
+
// Labels for each block that will be compiled.
MipsLabel* block_labels_;
MipsLabel frame_entry_label_;
@@ -382,6 +417,12 @@
MipsAssembler assembler_;
const MipsInstructionSetFeatures& isa_features_;
+ // Method patch info, map MethodReference to a literal for method address and method code.
+ MethodToLiteralMap method_patches_;
+ MethodToLiteralMap call_patches_;
+ // PC-relative patch info for each HMipsDexCacheArraysBase.
+ ArenaDeque<PcRelativePatchInfo> pc_relative_dex_cache_patches_;
+
DISALLOW_COPY_AND_ASSIGN(CodeGeneratorMIPS);
};
diff --git a/compiler/optimizing/code_generator_mips64.cc b/compiler/optimizing/code_generator_mips64.cc
index 2e78884..9f2664c 100644
--- a/compiler/optimizing/code_generator_mips64.cc
+++ b/compiler/optimizing/code_generator_mips64.cc
@@ -2932,8 +2932,6 @@
void InstructionCodeGeneratorMIPS64::VisitInvokeInterface(HInvokeInterface* invoke) {
// TODO: b/18116999, our IMTs can miss an IncompatibleClassChangeError.
GpuRegister temp = invoke->GetLocations()->GetTemp(0).AsRegister<GpuRegister>();
- uint32_t method_offset = mirror::Class::EmbeddedImTableEntryOffset(
- invoke->GetImtIndex() % mirror::Class::kImtSize, kMips64PointerSize).Uint32Value();
Location receiver = invoke->GetLocations()->InAt(0);
uint32_t class_offset = mirror::Object::ClassOffset().Int32Value();
Offset entry_point = ArtMethod::EntryPointFromQuickCompiledCodeOffset(kMips64DoublewordSize);
@@ -2950,6 +2948,10 @@
__ LoadFromOffset(kLoadUnsignedWord, temp, receiver.AsRegister<GpuRegister>(), class_offset);
}
codegen_->MaybeRecordImplicitNullCheck(invoke);
+ __ LoadFromOffset(kLoadDoubleword, temp, temp,
+ mirror::Class::ImtPtrOffset(kMips64PointerSize).Uint32Value());
+ uint32_t method_offset = static_cast<uint32_t>(ImTable::OffsetOfElement(
+ invoke->GetImtIndex() % ImTable::kSize, kMips64PointerSize));
// temp = temp->GetImtEntryAt(method_offset);
__ LoadFromOffset(kLoadDoubleword, temp, temp, method_offset);
// T9 = temp->GetEntryPoint();
diff --git a/compiler/optimizing/code_generator_x86.cc b/compiler/optimizing/code_generator_x86.cc
index 1261619..be20f1f 100644
--- a/compiler/optimizing/code_generator_x86.cc
+++ b/compiler/optimizing/code_generator_x86.cc
@@ -2027,8 +2027,6 @@
LocationSummary* locations = invoke->GetLocations();
Register temp = locations->GetTemp(0).AsRegister<Register>();
XmmRegister hidden_reg = locations->GetTemp(1).AsFpuRegister<XmmRegister>();
- uint32_t method_offset = mirror::Class::EmbeddedImTableEntryOffset(
- invoke->GetImtIndex() % mirror::Class::kImtSize, kX86PointerSize).Uint32Value();
Location receiver = locations->InAt(0);
uint32_t class_offset = mirror::Object::ClassOffset().Int32Value();
@@ -2055,7 +2053,12 @@
// intact/accessible until the end of the marking phase (the
// concurrent copying collector may not in the future).
__ MaybeUnpoisonHeapReference(temp);
+ // temp = temp->GetAddressOfIMT()
+ __ movl(temp,
+ Address(temp, mirror::Class::ImtPtrOffset(kX86PointerSize).Uint32Value()));
// temp = temp->GetImtEntryAt(method_offset);
+ uint32_t method_offset = static_cast<uint32_t>(ImTable::OffsetOfElement(
+ invoke->GetImtIndex() % ImTable::kSize, kX86PointerSize));
__ movl(temp, Address(temp, method_offset));
// call temp->GetEntryPoint();
__ call(Address(temp,
@@ -4075,8 +4078,12 @@
method_offset = mirror::Class::EmbeddedVTableEntryOffset(
instruction->GetIndex(), kX86PointerSize).SizeValue();
} else {
- method_offset = mirror::Class::EmbeddedImTableEntryOffset(
- instruction->GetIndex() % mirror::Class::kImtSize, kX86PointerSize).Uint32Value();
+ __ movl(locations->InAt(0).AsRegister<Register>(),
+ Address(locations->InAt(0).AsRegister<Register>(),
+ mirror::Class::ImtPtrOffset(kX86PointerSize).Uint32Value()));
+ // temp = temp->GetImtEntryAt(method_offset);
+ method_offset = static_cast<uint32_t>(ImTable::OffsetOfElement(
+ instruction->GetIndex() % ImTable::kSize, kX86PointerSize));
}
__ movl(locations->Out().AsRegister<Register>(),
Address(locations->InAt(0).AsRegister<Register>(), method_offset));
diff --git a/compiler/optimizing/code_generator_x86_64.cc b/compiler/optimizing/code_generator_x86_64.cc
index 5e30203..cac33cd 100644
--- a/compiler/optimizing/code_generator_x86_64.cc
+++ b/compiler/optimizing/code_generator_x86_64.cc
@@ -2257,8 +2257,6 @@
LocationSummary* locations = invoke->GetLocations();
CpuRegister temp = locations->GetTemp(0).AsRegister<CpuRegister>();
CpuRegister hidden_reg = locations->GetTemp(1).AsRegister<CpuRegister>();
- uint32_t method_offset = mirror::Class::EmbeddedImTableEntryOffset(
- invoke->GetImtIndex() % mirror::Class::kImtSize, kX86_64PointerSize).Uint32Value();
Location receiver = locations->InAt(0);
size_t class_offset = mirror::Object::ClassOffset().SizeValue();
@@ -2284,6 +2282,12 @@
// intact/accessible until the end of the marking phase (the
// concurrent copying collector may not in the future).
__ MaybeUnpoisonHeapReference(temp);
+ // temp = temp->GetAddressOfIMT()
+ __ movq(temp,
+ Address(temp, mirror::Class::ImtPtrOffset(kX86_64PointerSize).Uint32Value()));
+ // temp = temp->GetImtEntryAt(method_offset);
+ uint32_t method_offset = static_cast<uint32_t>(ImTable::OffsetOfElement(
+ invoke->GetImtIndex() % ImTable::kSize, kX86_64PointerSize));
// temp = temp->GetImtEntryAt(method_offset);
__ movq(temp, Address(temp, method_offset));
// call temp->GetEntryPoint();
@@ -4007,8 +4011,11 @@
method_offset = mirror::Class::EmbeddedVTableEntryOffset(
instruction->GetIndex(), kX86_64PointerSize).SizeValue();
} else {
- method_offset = mirror::Class::EmbeddedImTableEntryOffset(
- instruction->GetIndex() % mirror::Class::kImtSize, kX86_64PointerSize).Uint32Value();
+ __ movq(locations->Out().AsRegister<CpuRegister>(),
+ Address(locations->InAt(0).AsRegister<CpuRegister>(),
+ mirror::Class::ImtPtrOffset(kX86_64PointerSize).Uint32Value()));
+ method_offset = static_cast<uint32_t>(ImTable::OffsetOfElement(
+ instruction->GetIndex() % ImTable::kSize, kX86_64PointerSize));
}
__ movq(locations->Out().AsRegister<CpuRegister>(),
Address(locations->InAt(0).AsRegister<CpuRegister>(), method_offset));
diff --git a/compiler/optimizing/dex_cache_array_fixups_mips.cc b/compiler/optimizing/dex_cache_array_fixups_mips.cc
new file mode 100644
index 0000000..0f42d9c
--- /dev/null
+++ b/compiler/optimizing/dex_cache_array_fixups_mips.cc
@@ -0,0 +1,94 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "dex_cache_array_fixups_mips.h"
+
+#include "base/arena_containers.h"
+#include "utils/dex_cache_arrays_layout-inl.h"
+
+namespace art {
+namespace mips {
+
+/**
+ * Finds instructions that need the dex cache arrays base as an input.
+ */
+class DexCacheArrayFixupsVisitor : public HGraphVisitor {
+ public:
+ explicit DexCacheArrayFixupsVisitor(HGraph* graph)
+ : HGraphVisitor(graph),
+ dex_cache_array_bases_(std::less<const DexFile*>(),
+ // Attribute memory use to code generator.
+ graph->GetArena()->Adapter(kArenaAllocCodeGenerator)) {}
+
+ void MoveBasesIfNeeded() {
+ for (const auto& entry : dex_cache_array_bases_) {
+ // Bring the base closer to the first use (previously, it was in the
+ // entry block) and relieve some pressure on the register allocator
+ // while avoiding recalculation of the base in a loop.
+ HMipsDexCacheArraysBase* base = entry.second;
+ base->MoveBeforeFirstUserAndOutOfLoops();
+ }
+ }
+
+ private:
+ void VisitInvokeStaticOrDirect(HInvokeStaticOrDirect* invoke) OVERRIDE {
+ // If this is an invoke with PC-relative access to the dex cache methods array,
+ // we need to add the dex cache arrays base as the special input.
+ if (invoke->HasPcRelativeDexCache()) {
+ // Initialize base for target method dex file if needed.
+ MethodReference target_method = invoke->GetTargetMethod();
+ HMipsDexCacheArraysBase* base = GetOrCreateDexCacheArrayBase(*target_method.dex_file);
+ // Update the element offset in base.
+ DexCacheArraysLayout layout(kMipsPointerSize, target_method.dex_file);
+ base->UpdateElementOffset(layout.MethodOffset(target_method.dex_method_index));
+ // Add the special argument base to the method.
+ DCHECK(!invoke->HasCurrentMethodInput());
+ invoke->AddSpecialInput(base);
+ }
+ }
+
+ HMipsDexCacheArraysBase* GetOrCreateDexCacheArrayBase(const DexFile& dex_file) {
+ return dex_cache_array_bases_.GetOrCreate(
+ &dex_file,
+ [this, &dex_file]() {
+ HMipsDexCacheArraysBase* base =
+ new (GetGraph()->GetArena()) HMipsDexCacheArraysBase(dex_file);
+ HBasicBlock* entry_block = GetGraph()->GetEntryBlock();
+ // Insert the base at the start of the entry block, move it to a better
+ // position later in MoveBaseIfNeeded().
+ entry_block->InsertInstructionBefore(base, entry_block->GetFirstInstruction());
+ return base;
+ });
+ }
+
+ using DexCacheArraysBaseMap =
+ ArenaSafeMap<const DexFile*, HMipsDexCacheArraysBase*, std::less<const DexFile*>>;
+ DexCacheArraysBaseMap dex_cache_array_bases_;
+};
+
+void DexCacheArrayFixups::Run() {
+ if (graph_->HasIrreducibleLoops()) {
+ // Do not run this optimization, as irreducible loops do not work with an instruction
+ // that can be live-in at the irreducible loop header.
+ return;
+ }
+ DexCacheArrayFixupsVisitor visitor(graph_);
+ visitor.VisitInsertionOrder();
+ visitor.MoveBasesIfNeeded();
+}
+
+} // namespace mips
+} // namespace art
diff --git a/compiler/optimizing/dex_cache_array_fixups_mips.h b/compiler/optimizing/dex_cache_array_fixups_mips.h
new file mode 100644
index 0000000..c8def28
--- /dev/null
+++ b/compiler/optimizing/dex_cache_array_fixups_mips.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ART_COMPILER_OPTIMIZING_DEX_CACHE_ARRAY_FIXUPS_MIPS_H_
+#define ART_COMPILER_OPTIMIZING_DEX_CACHE_ARRAY_FIXUPS_MIPS_H_
+
+#include "nodes.h"
+#include "optimization.h"
+
+namespace art {
+namespace mips {
+
+class DexCacheArrayFixups : public HOptimization {
+ public:
+ DexCacheArrayFixups(HGraph* graph, OptimizingCompilerStats* stats)
+ : HOptimization(graph, "dex_cache_array_fixups_mips", stats) {}
+
+ void Run() OVERRIDE;
+};
+
+} // namespace mips
+} // namespace art
+
+#endif // ART_COMPILER_OPTIMIZING_DEX_CACHE_ARRAY_FIXUPS_MIPS_H_
diff --git a/compiler/optimizing/graph_checker.cc b/compiler/optimizing/graph_checker.cc
index 2bd2403..c8cba20 100644
--- a/compiler/optimizing/graph_checker.cc
+++ b/compiler/optimizing/graph_checker.cc
@@ -362,7 +362,7 @@
instruction->GetId()));
}
size_t use_index = use.GetIndex();
- auto&& user_inputs = user->GetInputs();
+ HConstInputsRef user_inputs = user->GetInputs();
if ((use_index >= user_inputs.size()) || (user_inputs[use_index] != instruction)) {
AddError(StringPrintf("User %s:%d of instruction %s:%d has a wrong "
"UseListNode index.",
@@ -490,7 +490,7 @@
VisitInstruction(invoke);
if (invoke->IsStaticWithExplicitClinitCheck()) {
- HInstruction* last_input = invoke->GetInputs().back();
+ const HInstruction* last_input = invoke->GetInputs().back();
if (last_input == nullptr) {
AddError(StringPrintf("Static invoke %s:%d marked as having an explicit clinit check "
"has a null pointer as last input.",
@@ -664,17 +664,19 @@
}
}
-static bool IsSameSizeConstant(HInstruction* insn1, HInstruction* insn2) {
+static bool IsSameSizeConstant(const HInstruction* insn1, const HInstruction* insn2) {
return insn1->IsConstant()
&& insn2->IsConstant()
&& Primitive::Is64BitType(insn1->GetType()) == Primitive::Is64BitType(insn2->GetType());
}
-static bool IsConstantEquivalent(HInstruction* insn1, HInstruction* insn2, BitVector* visited) {
+static bool IsConstantEquivalent(const HInstruction* insn1,
+ const HInstruction* insn2,
+ BitVector* visited) {
if (insn1->IsPhi() &&
insn1->AsPhi()->IsVRegEquivalentOf(insn2)) {
- auto&& insn1_inputs = insn1->GetInputs();
- auto&& insn2_inputs = insn2->GetInputs();
+ HConstInputsRef insn1_inputs = insn1->GetInputs();
+ HConstInputsRef insn2_inputs = insn2->GetInputs();
if (insn1_inputs.size() != insn2_inputs.size()) {
return false;
}
diff --git a/compiler/optimizing/graph_visualizer.cc b/compiler/optimizing/graph_visualizer.cc
index 4af8d19..9d67373 100644
--- a/compiler/optimizing/graph_visualizer.cc
+++ b/compiler/optimizing/graph_visualizer.cc
@@ -511,7 +511,7 @@
void PrintInstruction(HInstruction* instruction) {
output_ << instruction->DebugName();
- auto&& inputs = instruction->GetInputs();
+ HConstInputsRef inputs = instruction->GetInputs();
if (!inputs.empty()) {
StringList input_list;
for (const HInstruction* input : inputs) {
diff --git a/compiler/optimizing/induction_var_analysis.cc b/compiler/optimizing/induction_var_analysis.cc
index 52426d7..129c2a9 100644
--- a/compiler/optimizing/induction_var_analysis.cc
+++ b/compiler/optimizing/induction_var_analysis.cc
@@ -341,7 +341,7 @@
HInstruction* phi,
size_t input_index) {
// Match all phi inputs from input_index onwards exactly.
- auto&& inputs = phi->GetInputs();
+ HInputsRef inputs = phi->GetInputs();
DCHECK_LT(input_index, inputs.size());
InductionInfo* a = LookupInfo(loop, inputs[input_index]);
for (size_t i = input_index + 1; i < inputs.size(); i++) {
@@ -464,7 +464,7 @@
HInductionVarAnalysis::InductionInfo* HInductionVarAnalysis::SolvePhi(HInstruction* phi,
size_t input_index) {
// Match all phi inputs from input_index onwards exactly.
- auto&& inputs = phi->GetInputs();
+ HInputsRef inputs = phi->GetInputs();
DCHECK_LT(input_index, inputs.size());
auto ita = cycle_.find(inputs[input_index]);
if (ita != cycle_.end()) {
diff --git a/compiler/optimizing/induction_var_analysis.h b/compiler/optimizing/induction_var_analysis.h
index f1965f0..7c74816 100644
--- a/compiler/optimizing/induction_var_analysis.h
+++ b/compiler/optimizing/induction_var_analysis.h
@@ -132,7 +132,7 @@
InductionInfo* a,
InductionInfo* b,
Primitive::Type type) {
- DCHECK(a != nullptr);
+ DCHECK(a != nullptr && b != nullptr);
return new (graph_->GetArena()) InductionInfo(kInvariant, op, a, b, nullptr, type);
}
diff --git a/compiler/optimizing/induction_var_range.cc b/compiler/optimizing/induction_var_range.cc
index bc920d9..5e587e0 100644
--- a/compiler/optimizing/induction_var_range.cc
+++ b/compiler/optimizing/induction_var_range.cc
@@ -73,9 +73,12 @@
return v;
}
-/**
- * Corrects a value for type to account for arithmetic wrap-around in lower precision.
- */
+/** Helper method to test for a constant value. */
+static bool IsConstantValue(InductionVarRange::Value v) {
+ return v.is_known && v.a_constant == 0;
+}
+
+/** Corrects a value for type to account for arithmetic wrap-around in lower precision. */
static InductionVarRange::Value CorrectForType(InductionVarRange::Value v, Primitive::Type type) {
switch (type) {
case Primitive::kPrimShort:
@@ -85,26 +88,15 @@
// TODO: maybe some room for improvement, like allowing widening conversions
const int32_t min = Primitive::MinValueOfIntegralType(type);
const int32_t max = Primitive::MaxValueOfIntegralType(type);
- return (v.is_known && v.a_constant == 0 && min <= v.b_constant && v.b_constant <= max)
+ return (IsConstantValue(v) && min <= v.b_constant && v.b_constant <= max)
? v
: InductionVarRange::Value();
}
default:
- // At int or higher.
return v;
}
}
-/** Helper method to test for a constant value. */
-static bool IsConstantValue(InductionVarRange::Value v) {
- return v.is_known && v.a_constant == 0;
-}
-
-/** Helper method to test for same constant value. */
-static bool IsSameConstantValue(InductionVarRange::Value v1, InductionVarRange::Value v2) {
- return IsConstantValue(v1) && IsConstantValue(v2) && v1.b_constant == v2.b_constant;
-}
-
/** Helper method to insert an instruction. */
static HInstruction* Insert(HBasicBlock* block, HInstruction* instruction) {
DCHECK(block != nullptr);
@@ -119,22 +111,22 @@
//
InductionVarRange::InductionVarRange(HInductionVarAnalysis* induction_analysis)
- : induction_analysis_(induction_analysis) {
+ : induction_analysis_(induction_analysis),
+ chase_hint_(nullptr) {
DCHECK(induction_analysis != nullptr);
}
bool InductionVarRange::GetInductionRange(HInstruction* context,
HInstruction* instruction,
+ HInstruction* chase_hint,
/*out*/Value* min_val,
/*out*/Value* max_val,
/*out*/bool* needs_finite_test) {
- HLoopInformation* loop = context->GetBlock()->GetLoopInformation(); // closest enveloping loop
- if (loop == nullptr) {
- return false; // no loop
- }
- HInductionVarAnalysis::InductionInfo* info = induction_analysis_->LookupInfo(loop, instruction);
- if (info == nullptr) {
- return false; // no induction information
+ HLoopInformation* loop = nullptr;
+ HInductionVarAnalysis::InductionInfo* info = nullptr;
+ HInductionVarAnalysis::InductionInfo* trip = nullptr;
+ if (!HasInductionInfo(context, instruction, &loop, &info, &trip)) {
+ return false;
}
// Type int or lower (this is not too restrictive since intended clients, like
// bounds check elimination, will have truncated higher precision induction
@@ -148,45 +140,15 @@
default:
return false;
}
- // Set up loop information.
- HBasicBlock* header = loop->GetHeader();
- bool in_body = context->GetBlock() != header;
- HInductionVarAnalysis::InductionInfo* trip =
- induction_analysis_->LookupInfo(loop, header->GetLastInstruction());
// Find range.
+ chase_hint_ = chase_hint;
+ bool in_body = context->GetBlock() != loop->GetHeader();
*min_val = GetVal(info, trip, in_body, /* is_min */ true);
*max_val = SimplifyMax(GetVal(info, trip, in_body, /* is_min */ false));
*needs_finite_test = NeedsTripCount(info) && IsUnsafeTripCount(trip);
return true;
}
-bool InductionVarRange::RefineOuter(/*in-out*/ Value* min_val,
- /*in-out*/ Value* max_val) const {
- if (min_val->instruction != nullptr || max_val->instruction != nullptr) {
- Value v1_min = RefineOuter(*min_val, /* is_min */ true);
- Value v2_max = RefineOuter(*max_val, /* is_min */ false);
- // The refined range is safe if both sides refine the same instruction. Otherwise, since two
- // different ranges are combined, the new refined range is safe to pass back to the client if
- // the extremes of the computed ranges ensure no arithmetic wrap-around anomalies occur.
- if (min_val->instruction != max_val->instruction) {
- Value v1_max = RefineOuter(*min_val, /* is_min */ false);
- Value v2_min = RefineOuter(*max_val, /* is_min */ true);
- if (!IsConstantValue(v1_max) ||
- !IsConstantValue(v2_min) ||
- v1_max.b_constant > v2_min.b_constant) {
- return false;
- }
- }
- // Did something change?
- if (v1_min.instruction != min_val->instruction || v2_max.instruction != max_val->instruction) {
- *min_val = v1_min;
- *max_val = v2_max;
- return true;
- }
- }
- return false;
-}
-
bool InductionVarRange::CanGenerateCode(HInstruction* context,
HInstruction* instruction,
/*out*/bool* needs_finite_test,
@@ -226,7 +188,7 @@
bool InductionVarRange::IsConstant(HInductionVarAnalysis::InductionInfo* info,
ConstantRequest request,
- /*out*/ int64_t *value) const {
+ /*out*/ int64_t* value) const {
if (info != nullptr) {
// A direct 32-bit or 64-bit constant fetch. This immediately satisfies
// any of the three requests (kExact, kAtMost, and KAtLeast).
@@ -236,27 +198,16 @@
return true;
}
}
- // Try range analysis while traversing outward on loops.
- bool in_body = true; // no known trip count
- Value v_min = GetVal(info, nullptr, in_body, /* is_min */ true);
- Value v_max = GetVal(info, nullptr, in_body, /* is_min */ false);
- do {
- // Make sure *both* extremes are known to avoid arithmetic wrap-around anomalies.
- if (IsConstantValue(v_min) && IsConstantValue(v_max) && v_min.b_constant <= v_max.b_constant) {
- if ((request == kExact && v_min.b_constant == v_max.b_constant) || request == kAtMost) {
- *value = v_max.b_constant;
- return true;
- } else if (request == kAtLeast) {
- *value = v_min.b_constant;
- return true;
- }
- }
- } while (RefineOuter(&v_min, &v_max));
- // Exploit array length + c >= c, with c <= 0 to avoid arithmetic wrap-around anomalies
- // (e.g. array length == maxint and c == 1 would yield minint).
- if (request == kAtLeast) {
- if (v_min.a_constant == 1 && v_min.b_constant <= 0 && v_min.instruction->IsArrayLength()) {
- *value = v_min.b_constant;
+ // Try range analysis on the invariant, but only on proper range to avoid wrap-around anomalies.
+ Value min_val = GetVal(info, nullptr, /* in_body */ true, /* is_min */ true);
+ Value max_val = GetVal(info, nullptr, /* in_body */ true, /* is_min */ false);
+ if (IsConstantValue(min_val) &&
+ IsConstantValue(max_val) && min_val.b_constant <= max_val.b_constant) {
+ if ((request == kExact && min_val.b_constant == max_val.b_constant) || request == kAtMost) {
+ *value = max_val.b_constant;
+ return true;
+ } else if (request == kAtLeast) {
+ *value = min_val.b_constant;
return true;
}
}
@@ -264,6 +215,51 @@
return false;
}
+bool InductionVarRange::HasInductionInfo(
+ HInstruction* context,
+ HInstruction* instruction,
+ /*out*/ HLoopInformation** loop,
+ /*out*/ HInductionVarAnalysis::InductionInfo** info,
+ /*out*/ HInductionVarAnalysis::InductionInfo** trip) const {
+ HLoopInformation* l = context->GetBlock()->GetLoopInformation(); // closest enveloping loop
+ if (l != nullptr) {
+ HInductionVarAnalysis::InductionInfo* i = induction_analysis_->LookupInfo(l, instruction);
+ if (i != nullptr) {
+ *loop = l;
+ *info = i;
+ *trip = induction_analysis_->LookupInfo(l, l->GetHeader()->GetLastInstruction());
+ return true;
+ }
+ }
+ return false;
+}
+
+bool InductionVarRange::IsWellBehavedTripCount(HInductionVarAnalysis::InductionInfo* trip) const {
+ if (trip != nullptr) {
+ // Both bounds that define a trip-count are well-behaved if they either are not defined
+ // in any loop, or are contained in a proper interval. This allows finding the min/max
+ // of an expression by chasing outward.
+ InductionVarRange range(induction_analysis_);
+ HInductionVarAnalysis::InductionInfo* lower = trip->op_b->op_a;
+ HInductionVarAnalysis::InductionInfo* upper = trip->op_b->op_b;
+ int64_t not_used = 0;
+ return (!HasFetchInLoop(lower) || range.IsConstant(lower, kAtLeast, ¬_used)) &&
+ (!HasFetchInLoop(upper) || range.IsConstant(upper, kAtLeast, ¬_used));
+ }
+ return true;
+}
+
+bool InductionVarRange::HasFetchInLoop(HInductionVarAnalysis::InductionInfo* info) const {
+ if (info != nullptr) {
+ if (info->induction_class == HInductionVarAnalysis::kInvariant &&
+ info->operation == HInductionVarAnalysis::kFetch) {
+ return info->fetch->GetBlock()->GetLoopInformation() != nullptr;
+ }
+ return HasFetchInLoop(info->op_a) || HasFetchInLoop(info->op_b);
+ }
+ return false;
+}
+
bool InductionVarRange::NeedsTripCount(HInductionVarAnalysis::InductionInfo* info) const {
if (info != nullptr) {
if (info->induction_class == HInductionVarAnalysis::kLinear) {
@@ -299,13 +295,13 @@
HInductionVarAnalysis::InductionInfo* trip,
bool in_body,
bool is_min) const {
- // Detect common situation where an offset inside the trip count cancels out during range
+ // Detect common situation where an offset inside the trip-count cancels out during range
// analysis (finding max a * (TC - 1) + OFFSET for a == 1 and TC = UPPER - OFFSET or finding
// min a * (TC - 1) + OFFSET for a == -1 and TC = OFFSET - UPPER) to avoid losing information
// with intermediate results that only incorporate single instructions.
if (trip != nullptr) {
HInductionVarAnalysis::InductionInfo* trip_expr = trip->op_a;
- if (trip_expr->operation == HInductionVarAnalysis::kSub) {
+ if (trip_expr->type == info->type && trip_expr->operation == HInductionVarAnalysis::kSub) {
int64_t stride_value = 0;
if (IsConstant(info->op_a, kExact, &stride_value)) {
if (!is_min && stride_value == 1) {
@@ -349,12 +345,25 @@
HInductionVarAnalysis::InductionInfo* trip,
bool in_body,
bool is_min) const {
- // Detect constants and chase the fetch a bit deeper into the HIR tree, so that it becomes
- // more likely range analysis will compare the same instructions as terminal nodes.
+ // Stop chasing the instruction at constant or hint.
int64_t value;
- if (IsIntAndGet(instruction, &value) && CanLongValueFitIntoInt(value)) {
+ if (IsIntAndGet(instruction, &value) && CanLongValueFitIntoInt(value)) {
return Value(static_cast<int32_t>(value));
- } else if (instruction->IsAdd()) {
+ } else if (instruction == chase_hint_) {
+ return Value(instruction, 1, 0);
+ }
+ // Special cases when encountering a single instruction that denotes trip count in the
+ // loop-body: min is 1 and, when chasing constants, max of safe trip-count is max int
+ if (in_body && trip != nullptr && instruction == trip->op_a->fetch) {
+ if (is_min) {
+ return Value(1);
+ } else if (chase_hint_ == nullptr && !IsUnsafeTripCount(trip)) {
+ return Value(std::numeric_limits<int32_t>::max());
+ }
+ }
+ // Chase the instruction a bit deeper into the HIR tree, so that it becomes more likely
+ // range analysis will compare the same instructions as terminal nodes.
+ if (instruction->IsAdd()) {
if (IsIntAndGet(instruction->InputAt(0), &value) && CanLongValueFitIntoInt(value)) {
return AddValue(Value(static_cast<int32_t>(value)),
GetFetch(instruction->InputAt(1), trip, in_body, is_min));
@@ -362,19 +371,35 @@
return AddValue(GetFetch(instruction->InputAt(0), trip, in_body, is_min),
Value(static_cast<int32_t>(value)));
}
- } else if (instruction->IsArrayLength() && instruction->InputAt(0)->IsNewArray()) {
- return GetFetch(instruction->InputAt(0)->InputAt(0), trip, in_body, is_min);
+ } else if (instruction->IsArrayLength()) {
+ // Return extreme values when chasing constants. Otherwise, chase deeper.
+ if (chase_hint_ == nullptr) {
+ return is_min ? Value(0) : Value(std::numeric_limits<int32_t>::max());
+ } else if (instruction->InputAt(0)->IsNewArray()) {
+ return GetFetch(instruction->InputAt(0)->InputAt(0), trip, in_body, is_min);
+ }
} else if (instruction->IsTypeConversion()) {
// Since analysis is 32-bit (or narrower) we allow a widening along the path.
if (instruction->AsTypeConversion()->GetInputType() == Primitive::kPrimInt &&
instruction->AsTypeConversion()->GetResultType() == Primitive::kPrimLong) {
return GetFetch(instruction->InputAt(0), trip, in_body, is_min);
}
- } else if (is_min) {
- // Special case for finding minimum: minimum of trip-count in loop-body is 1.
- if (trip != nullptr && in_body && instruction == trip->op_a->fetch) {
- return Value(1);
- }
+ }
+ // Chase an invariant fetch that is defined by an outer loop if the trip-count used
+ // so far is well-behaved in both bounds and the next trip-count is safe.
+ // Example:
+ // for (int i = 0; i <= 100; i++) // safe
+ // for (int j = 0; j <= i; j++) // well-behaved
+ // j is in range [0, i ] (if i is chase hint)
+ // or in range [0, 100] (otherwise)
+ HLoopInformation* next_loop = nullptr;
+ HInductionVarAnalysis::InductionInfo* next_info = nullptr;
+ HInductionVarAnalysis::InductionInfo* next_trip = nullptr;
+ bool next_in_body = true; // inner loop is always in body of outer loop
+ if (HasInductionInfo(instruction, instruction, &next_loop, &next_info, &next_trip) &&
+ IsWellBehavedTripCount(trip) &&
+ !IsUnsafeTripCount(next_trip)) {
+ return GetVal(next_info, next_trip, next_in_body, is_min);
}
return Value(instruction, 1, 0);
}
@@ -421,9 +446,8 @@
break;
}
break;
- case HInductionVarAnalysis::kLinear: {
+ case HInductionVarAnalysis::kLinear:
return CorrectForType(GetLinear(info, trip, in_body, is_min), info->type);
- }
case HInductionVarAnalysis::kWrapAround:
case HInductionVarAnalysis::kPeriodic:
return MergeVal(GetVal(info->op_a, trip, in_body, is_min),
@@ -438,20 +462,18 @@
HInductionVarAnalysis::InductionInfo* trip,
bool in_body,
bool is_min) const {
+ // Constant times range.
+ int64_t value = 0;
+ if (IsConstant(info1, kExact, &value)) {
+ return MulRangeAndConstant(value, info2, trip, in_body, is_min);
+ } else if (IsConstant(info2, kExact, &value)) {
+ return MulRangeAndConstant(value, info1, trip, in_body, is_min);
+ }
+ // Interval ranges.
Value v1_min = GetVal(info1, trip, in_body, /* is_min */ true);
Value v1_max = GetVal(info1, trip, in_body, /* is_min */ false);
Value v2_min = GetVal(info2, trip, in_body, /* is_min */ true);
Value v2_max = GetVal(info2, trip, in_body, /* is_min */ false);
- // Try to refine first operand.
- if (!IsConstantValue(v1_min) && !IsConstantValue(v1_max)) {
- RefineOuter(&v1_min, &v1_max);
- }
- // Constant times range.
- if (IsSameConstantValue(v1_min, v1_max)) {
- return MulRangeAndConstant(v2_min, v2_max, v1_min, is_min);
- } else if (IsSameConstantValue(v2_min, v2_max)) {
- return MulRangeAndConstant(v1_min, v1_max, v2_min, is_min);
- }
// Positive range vs. positive or negative range.
if (IsConstantValue(v1_min) && v1_min.b_constant >= 0) {
if (IsConstantValue(v2_min) && v2_min.b_constant >= 0) {
@@ -476,14 +498,16 @@
HInductionVarAnalysis::InductionInfo* trip,
bool in_body,
bool is_min) const {
+ // Range divided by constant.
+ int64_t value = 0;
+ if (IsConstant(info2, kExact, &value)) {
+ return DivRangeAndConstant(value, info1, trip, in_body, is_min);
+ }
+ // Interval ranges.
Value v1_min = GetVal(info1, trip, in_body, /* is_min */ true);
Value v1_max = GetVal(info1, trip, in_body, /* is_min */ false);
Value v2_min = GetVal(info2, trip, in_body, /* is_min */ true);
Value v2_max = GetVal(info2, trip, in_body, /* is_min */ false);
- // Range divided by constant.
- if (IsSameConstantValue(v2_min, v2_max)) {
- return DivRangeAndConstant(v1_min, v1_max, v2_min, is_min);
- }
// Positive range vs. positive or negative range.
if (IsConstantValue(v1_min) && v1_min.b_constant >= 0) {
if (IsConstantValue(v2_min) && v2_min.b_constant >= 0) {
@@ -503,18 +527,30 @@
return Value();
}
-InductionVarRange::Value InductionVarRange::MulRangeAndConstant(Value v_min,
- Value v_max,
- Value c,
- bool is_min) const {
- return is_min == (c.b_constant >= 0) ? MulValue(v_min, c) : MulValue(v_max, c);
+InductionVarRange::Value InductionVarRange::MulRangeAndConstant(
+ int64_t value,
+ HInductionVarAnalysis::InductionInfo* info,
+ HInductionVarAnalysis::InductionInfo* trip,
+ bool in_body,
+ bool is_min) const {
+ if (CanLongValueFitIntoInt(value)) {
+ Value c(static_cast<int32_t>(value));
+ return MulValue(GetVal(info, trip, in_body, is_min == value >= 0), c);
+ }
+ return Value();
}
-InductionVarRange::Value InductionVarRange::DivRangeAndConstant(Value v_min,
- Value v_max,
- Value c,
- bool is_min) const {
- return is_min == (c.b_constant >= 0) ? DivValue(v_min, c) : DivValue(v_max, c);
+InductionVarRange::Value InductionVarRange::DivRangeAndConstant(
+ int64_t value,
+ HInductionVarAnalysis::InductionInfo* info,
+ HInductionVarAnalysis::InductionInfo* trip,
+ bool in_body,
+ bool is_min) const {
+ if (CanLongValueFitIntoInt(value)) {
+ Value c(static_cast<int32_t>(value));
+ return DivValue(GetVal(info, trip, in_body, is_min == value >= 0), c);
+ }
+ return Value();
}
InductionVarRange::Value InductionVarRange::AddValue(Value v1, Value v2) const {
@@ -580,28 +616,6 @@
return Value();
}
-InductionVarRange::Value InductionVarRange::RefineOuter(Value v, bool is_min) const {
- if (v.instruction == nullptr) {
- return v; // nothing to refine
- }
- HLoopInformation* loop =
- v.instruction->GetBlock()->GetLoopInformation(); // closest enveloping loop
- if (loop == nullptr) {
- return v; // no loop
- }
- HInductionVarAnalysis::InductionInfo* info = induction_analysis_->LookupInfo(loop, v.instruction);
- if (info == nullptr) {
- return v; // no induction information
- }
- // Set up loop information.
- HBasicBlock* header = loop->GetHeader();
- bool in_body = true; // inner always in more outer
- HInductionVarAnalysis::InductionInfo* trip =
- induction_analysis_->LookupInfo(loop, header->GetLastInstruction());
- // Try to refine "a x instruction + b" with outer loop range information on instruction.
- return AddValue(MulValue(Value(v.a_constant), GetVal(info, trip, in_body, is_min)), Value(v.b_constant));
-}
-
bool InductionVarRange::GenerateCode(HInstruction* context,
HInstruction* instruction,
HGraph* graph,
@@ -611,27 +625,18 @@
/*out*/HInstruction** taken_test,
/*out*/bool* needs_finite_test,
/*out*/bool* needs_taken_test) const {
- HLoopInformation* loop = context->GetBlock()->GetLoopInformation(); // closest enveloping loop
- if (loop == nullptr) {
- return false; // no loop
- }
- HInductionVarAnalysis::InductionInfo* info = induction_analysis_->LookupInfo(loop, instruction);
- if (info == nullptr) {
- return false; // no induction information
- }
- // Set up loop information.
- HBasicBlock* header = loop->GetHeader();
- bool in_body = context->GetBlock() != header;
- HInductionVarAnalysis::InductionInfo* trip =
- induction_analysis_->LookupInfo(loop, header->GetLastInstruction());
- if (trip == nullptr) {
- return false; // codegen relies on trip count
+ HLoopInformation* loop = nullptr;
+ HInductionVarAnalysis::InductionInfo* info = nullptr;
+ HInductionVarAnalysis::InductionInfo* trip = nullptr;
+ if (!HasInductionInfo(context, instruction, &loop, &info, &trip) || trip == nullptr) {
+ return false; // codegen needs all information, including tripcount
}
// Determine what tests are needed. A finite test is needed if the evaluation code uses the
// trip-count and the loop maybe unsafe (because in such cases, the index could "overshoot"
// the computed range). A taken test is needed for any unknown trip-count, even if evaluation
// code does not use the trip-count explicitly (since there could be an implicit relation
// between e.g. an invariant subscript and a not-taken condition).
+ bool in_body = context->GetBlock() != loop->GetHeader();
*needs_finite_test = NeedsTripCount(info) && IsUnsafeTripCount(trip);
*needs_taken_test = IsBodyTripCount(trip);
// Code generation for taken test: generate the code when requested or otherwise analyze
diff --git a/compiler/optimizing/induction_var_range.h b/compiler/optimizing/induction_var_range.h
index 0af4156..00aaa16 100644
--- a/compiler/optimizing/induction_var_range.h
+++ b/compiler/optimizing/induction_var_range.h
@@ -57,21 +57,19 @@
explicit InductionVarRange(HInductionVarAnalysis* induction);
/**
- * Given a context denoted by the first instruction, returns a possibly conservative
- * lower and upper bound on the instruction's value in the output parameters min_val
- * and max_val, respectively. The need_finite_test flag denotes if an additional finite-test
- * is needed to protect the range evaluation inside its loop. Returns false on failure.
+ * Given a context denoted by the first instruction, returns a possibly conservative lower
+ * and upper bound on the instruction's value in the output parameters min_val and max_val,
+ * respectively. The need_finite_test flag denotes if an additional finite-test is needed
+ * to protect the range evaluation inside its loop. The parameter chase_hint defines an
+ * instruction at which chasing may stop. Returns false on failure.
*/
bool GetInductionRange(HInstruction* context,
HInstruction* instruction,
+ HInstruction* chase_hint,
/*out*/ Value* min_val,
/*out*/ Value* max_val,
/*out*/ bool* needs_finite_test);
- /** Refines the values with induction of next outer loop. Returns true on change. */
- bool RefineOuter(/*in-out*/ Value* min_val,
- /*in-out*/ Value* max_val) const;
-
/**
* Returns true if range analysis is able to generate code for the lower and upper
* bound expressions on the instruction in the given context. The need_finite_test
@@ -132,11 +130,20 @@
*/
bool IsConstant(HInductionVarAnalysis::InductionInfo* info,
ConstantRequest request,
- /*out*/ int64_t *value) const;
+ /*out*/ int64_t* value) const;
+ /** Returns whether induction information can be obtained. */
+ bool HasInductionInfo(HInstruction* context,
+ HInstruction* instruction,
+ /*out*/ HLoopInformation** loop,
+ /*out*/ HInductionVarAnalysis::InductionInfo** info,
+ /*out*/ HInductionVarAnalysis::InductionInfo** trip) const;
+
+ bool HasFetchInLoop(HInductionVarAnalysis::InductionInfo* info) const;
bool NeedsTripCount(HInductionVarAnalysis::InductionInfo* info) const;
bool IsBodyTripCount(HInductionVarAnalysis::InductionInfo* trip) const;
bool IsUnsafeTripCount(HInductionVarAnalysis::InductionInfo* trip) const;
+ bool IsWellBehavedTripCount(HInductionVarAnalysis::InductionInfo* trip) const;
Value GetLinear(HInductionVarAnalysis::InductionInfo* info,
HInductionVarAnalysis::InductionInfo* trip,
@@ -161,8 +168,16 @@
bool in_body,
bool is_min) const;
- Value MulRangeAndConstant(Value v1, Value v2, Value c, bool is_min) const;
- Value DivRangeAndConstant(Value v1, Value v2, Value c, bool is_min) const;
+ Value MulRangeAndConstant(int64_t value,
+ HInductionVarAnalysis::InductionInfo* info,
+ HInductionVarAnalysis::InductionInfo* trip,
+ bool in_body,
+ bool is_min) const;
+ Value DivRangeAndConstant(int64_t value,
+ HInductionVarAnalysis::InductionInfo* info,
+ HInductionVarAnalysis::InductionInfo* trip,
+ bool in_body,
+ bool is_min) const;
Value AddValue(Value v1, Value v2) const;
Value SubValue(Value v1, Value v2) const;
@@ -171,12 +186,6 @@
Value MergeVal(Value v1, Value v2, bool is_min) const;
/**
- * Returns refined value using induction of next outer loop or the input value if no
- * further refinement is possible.
- */
- Value RefineOuter(Value val, bool is_min) const;
-
- /**
* Generates code for lower/upper/taken-test in the HIR. Returns true on success.
* With values nullptr, the method can be used to determine if code generation
* would be successful without generating actual code yet.
@@ -200,7 +209,10 @@
bool is_min) const;
/** Results of prior induction variable analysis. */
- HInductionVarAnalysis *induction_analysis_;
+ HInductionVarAnalysis* induction_analysis_;
+
+ /** Instruction at which chasing may stop. */
+ HInstruction* chase_hint_;
friend class HInductionVarAnalysis;
friend class InductionVarRangeTest;
diff --git a/compiler/optimizing/induction_var_range_test.cc b/compiler/optimizing/induction_var_range_test.cc
index dc04dc2..4ea170f 100644
--- a/compiler/optimizing/induction_var_range_test.cc
+++ b/compiler/optimizing/induction_var_range_test.cc
@@ -66,6 +66,8 @@
entry_block_->AddInstruction(x_);
y_ = new (&allocator_) HParameterValue(graph_->GetDexFile(), 0, 0, Primitive::kPrimInt);
entry_block_->AddInstruction(y_);
+ // Set arbitrary range analysis hint while testing private methods.
+ SetHint(x_);
}
/** Constructs loop with given upper bound. */
@@ -111,6 +113,11 @@
iva_->Run();
}
+ /** Sets hint. */
+ void SetHint(HInstruction* hint) {
+ range_.chase_hint_ = hint;
+ }
+
/** Constructs an invariant. */
HInductionVarAnalysis::InductionInfo* CreateInvariant(char opc,
HInductionVarAnalysis::InductionInfo* a,
@@ -122,6 +129,7 @@
case 'n': op = HInductionVarAnalysis::kNeg; break;
case '*': op = HInductionVarAnalysis::kMul; break;
case '/': op = HInductionVarAnalysis::kDiv; break;
+ case '<': op = HInductionVarAnalysis::kLT; break;
default: op = HInductionVarAnalysis::kNop; break;
}
return iva_->CreateInvariantOp(op, a, b);
@@ -137,22 +145,21 @@
return CreateFetch(graph_->GetIntConstant(c));
}
- /** Constructs a trip-count. */
+ /** Constructs a constant trip-count. */
HInductionVarAnalysis::InductionInfo* CreateTripCount(int32_t tc, bool in_loop, bool safe) {
- Primitive::Type type = Primitive::kPrimInt;
+ HInductionVarAnalysis::InductionOp op = HInductionVarAnalysis::kTripCountInBodyUnsafe;
if (in_loop && safe) {
- return iva_->CreateTripCount(
- HInductionVarAnalysis::kTripCountInLoop, CreateConst(tc), nullptr, type);
+ op = HInductionVarAnalysis::kTripCountInLoop;
} else if (in_loop) {
- return iva_->CreateTripCount(
- HInductionVarAnalysis::kTripCountInLoopUnsafe, CreateConst(tc), nullptr, type);
+ op = HInductionVarAnalysis::kTripCountInLoopUnsafe;
} else if (safe) {
- return iva_->CreateTripCount(
- HInductionVarAnalysis::kTripCountInBody, CreateConst(tc), nullptr, type);
- } else {
- return iva_->CreateTripCount(
- HInductionVarAnalysis::kTripCountInBodyUnsafe, CreateConst(tc), nullptr, type);
+ op = HInductionVarAnalysis::kTripCountInBody;
}
+ // Return TC with taken-test 0 < TC.
+ return iva_->CreateTripCount(op,
+ CreateConst(tc),
+ CreateInvariant('<', CreateConst(0), CreateConst(tc)),
+ Primitive::kPrimInt);
}
/** Constructs a linear a * i + b induction. */
@@ -197,13 +204,13 @@
}
Value GetMin(HInductionVarAnalysis::InductionInfo* info,
- HInductionVarAnalysis::InductionInfo* induc) {
- return range_.GetVal(info, induc, /* in_body */ true, /* is_min */ true);
+ HInductionVarAnalysis::InductionInfo* trip) {
+ return range_.GetVal(info, trip, /* in_body */ true, /* is_min */ true);
}
Value GetMax(HInductionVarAnalysis::InductionInfo* info,
- HInductionVarAnalysis::InductionInfo* induc) {
- return range_.GetVal(info, induc, /* in_body */ true, /* is_min */ false);
+ HInductionVarAnalysis::InductionInfo* trip) {
+ return range_.GetVal(info, trip, /* in_body */ true, /* is_min */ false);
}
Value GetMul(HInductionVarAnalysis::InductionInfo* info1,
@@ -558,6 +565,31 @@
ExpectEqual(Value(), MaxValue(Value(55), Value(y_, 1, -50)));
}
+TEST_F(InductionVarRangeTest, ArrayLengthAndHints) {
+ HInstruction* new_array = new (&allocator_)
+ HNewArray(x_,
+ graph_->GetCurrentMethod(),
+ 0, Primitive::kPrimInt,
+ graph_->GetDexFile(),
+ kQuickAllocArray);
+ entry_block_->AddInstruction(new_array);
+ HInstruction* array_length = new (&allocator_) HArrayLength(new_array, 0);
+ entry_block_->AddInstruction(array_length);
+ // With null hint: yields extreme constants.
+ const int32_t max_value = std::numeric_limits<int32_t>::max();
+ SetHint(nullptr);
+ ExpectEqual(Value(0), GetMin(CreateFetch(array_length), nullptr));
+ ExpectEqual(Value(max_value), GetMax(CreateFetch(array_length), nullptr));
+ // With explicit hint: yields the length instruction.
+ SetHint(array_length);
+ ExpectEqual(Value(array_length, 1, 0), GetMin(CreateFetch(array_length), nullptr));
+ ExpectEqual(Value(array_length, 1, 0), GetMax(CreateFetch(array_length), nullptr));
+ // With any non-null hint: chases beyond the length instruction.
+ SetHint(x_);
+ ExpectEqual(Value(x_, 1, 0), GetMin(CreateFetch(array_length), nullptr));
+ ExpectEqual(Value(x_, 1, 0), GetMax(CreateFetch(array_length), nullptr));
+}
+
//
// Tests on public methods.
//
@@ -570,23 +602,20 @@
bool needs_finite_test = true;
// In context of header: known.
- range_.GetInductionRange(condition_, condition_->InputAt(0), &v1, &v2, &needs_finite_test);
+ range_.GetInductionRange(condition_, condition_->InputAt(0), x_, &v1, &v2, &needs_finite_test);
EXPECT_FALSE(needs_finite_test);
ExpectEqual(Value(0), v1);
ExpectEqual(Value(1000), v2);
- EXPECT_FALSE(range_.RefineOuter(&v1, &v2));
// In context of loop-body: known.
- range_.GetInductionRange(increment_, condition_->InputAt(0), &v1, &v2, &needs_finite_test);
+ range_.GetInductionRange(increment_, condition_->InputAt(0), x_, &v1, &v2, &needs_finite_test);
EXPECT_FALSE(needs_finite_test);
ExpectEqual(Value(0), v1);
ExpectEqual(Value(999), v2);
- EXPECT_FALSE(range_.RefineOuter(&v1, &v2));
- range_.GetInductionRange(increment_, increment_, &v1, &v2, &needs_finite_test);
+ range_.GetInductionRange(increment_, increment_, x_, &v1, &v2, &needs_finite_test);
EXPECT_FALSE(needs_finite_test);
ExpectEqual(Value(1), v1);
ExpectEqual(Value(1000), v2);
- EXPECT_FALSE(range_.RefineOuter(&v1, &v2));
}
TEST_F(InductionVarRangeTest, ConstantTripCountDown) {
@@ -597,23 +626,20 @@
bool needs_finite_test = true;
// In context of header: known.
- range_.GetInductionRange(condition_, condition_->InputAt(0), &v1, &v2, &needs_finite_test);
+ range_.GetInductionRange(condition_, condition_->InputAt(0), x_, &v1, &v2, &needs_finite_test);
EXPECT_FALSE(needs_finite_test);
ExpectEqual(Value(0), v1);
ExpectEqual(Value(1000), v2);
- EXPECT_FALSE(range_.RefineOuter(&v1, &v2));
// In context of loop-body: known.
- range_.GetInductionRange(increment_, condition_->InputAt(0), &v1, &v2, &needs_finite_test);
+ range_.GetInductionRange(increment_, condition_->InputAt(0), x_, &v1, &v2, &needs_finite_test);
EXPECT_FALSE(needs_finite_test);
ExpectEqual(Value(1), v1);
ExpectEqual(Value(1000), v2);
- EXPECT_FALSE(range_.RefineOuter(&v1, &v2));
- range_.GetInductionRange(increment_, increment_, &v1, &v2, &needs_finite_test);
+ range_.GetInductionRange(increment_, increment_, x_, &v1, &v2, &needs_finite_test);
EXPECT_FALSE(needs_finite_test);
ExpectEqual(Value(0), v1);
ExpectEqual(Value(999), v2);
- EXPECT_FALSE(range_.RefineOuter(&v1, &v2));
}
TEST_F(InductionVarRangeTest, SymbolicTripCountUp) {
@@ -625,23 +651,20 @@
bool needs_taken_test = true;
// In context of header: upper unknown.
- range_.GetInductionRange(condition_, condition_->InputAt(0), &v1, &v2, &needs_finite_test);
+ range_.GetInductionRange(condition_, condition_->InputAt(0), x_, &v1, &v2, &needs_finite_test);
EXPECT_FALSE(needs_finite_test);
ExpectEqual(Value(0), v1);
ExpectEqual(Value(), v2);
- EXPECT_FALSE(range_.RefineOuter(&v1, &v2));
// In context of loop-body: known.
- range_.GetInductionRange(increment_, condition_->InputAt(0), &v1, &v2, &needs_finite_test);
+ range_.GetInductionRange(increment_, condition_->InputAt(0), x_, &v1, &v2, &needs_finite_test);
EXPECT_FALSE(needs_finite_test);
ExpectEqual(Value(0), v1);
ExpectEqual(Value(x_, 1, -1), v2);
- EXPECT_FALSE(range_.RefineOuter(&v1, &v2));
- range_.GetInductionRange(increment_, increment_, &v1, &v2, &needs_finite_test);
+ range_.GetInductionRange(increment_, increment_, x_, &v1, &v2, &needs_finite_test);
EXPECT_FALSE(needs_finite_test);
ExpectEqual(Value(1), v1);
ExpectEqual(Value(x_, 1, 0), v2);
- EXPECT_FALSE(range_.RefineOuter(&v1, &v2));
HInstruction* lower = nullptr;
HInstruction* upper = nullptr;
@@ -695,23 +718,20 @@
bool needs_taken_test = true;
// In context of header: lower unknown.
- range_.GetInductionRange(condition_, condition_->InputAt(0), &v1, &v2, &needs_finite_test);
+ range_.GetInductionRange(condition_, condition_->InputAt(0), x_, &v1, &v2, &needs_finite_test);
EXPECT_FALSE(needs_finite_test);
ExpectEqual(Value(), v1);
ExpectEqual(Value(1000), v2);
- EXPECT_FALSE(range_.RefineOuter(&v1, &v2));
// In context of loop-body: known.
- range_.GetInductionRange(increment_, condition_->InputAt(0), &v1, &v2, &needs_finite_test);
+ range_.GetInductionRange(increment_, condition_->InputAt(0), x_, &v1, &v2, &needs_finite_test);
EXPECT_FALSE(needs_finite_test);
ExpectEqual(Value(x_, 1, 1), v1);
ExpectEqual(Value(1000), v2);
- EXPECT_FALSE(range_.RefineOuter(&v1, &v2));
- range_.GetInductionRange(increment_, increment_, &v1, &v2, &needs_finite_test);
+ range_.GetInductionRange(increment_, increment_, x_, &v1, &v2, &needs_finite_test);
EXPECT_FALSE(needs_finite_test);
ExpectEqual(Value(x_, 1, 0), v1);
ExpectEqual(Value(999), v2);
- EXPECT_FALSE(range_.RefineOuter(&v1, &v2));
HInstruction* lower = nullptr;
HInstruction* upper = nullptr;
diff --git a/compiler/optimizing/inliner.cc b/compiler/optimizing/inliner.cc
index c67b2d5..6c1292c 100644
--- a/compiler/optimizing/inliner.cc
+++ b/compiler/optimizing/inliner.cc
@@ -187,12 +187,12 @@
static uint32_t FindMethodIndexIn(ArtMethod* method,
const DexFile& dex_file,
- uint32_t referrer_index)
+ uint32_t name_and_signature_index)
SHARED_REQUIRES(Locks::mutator_lock_) {
if (IsSameDexFile(*method->GetDexFile(), dex_file)) {
return method->GetDexMethodIndex();
} else {
- return method->FindDexMethodIndexInOtherDexFile(dex_file, referrer_index);
+ return method->FindDexMethodIndexInOtherDexFile(dex_file, name_and_signature_index);
}
}
@@ -656,8 +656,8 @@
}
ArtMethod* new_method = nullptr;
if (invoke_instruction->IsInvokeInterface()) {
- new_method = ic.GetTypeAt(i)->GetEmbeddedImTableEntry(
- method_index % mirror::Class::kImtSize, pointer_size);
+ new_method = ic.GetTypeAt(i)->GetImt(pointer_size)->Get(
+ method_index % ImTable::kSize, pointer_size);
if (new_method->IsRuntimeMethod()) {
// Bail out as soon as we see a conflict trampoline in one of the target's
// interface table.
@@ -750,7 +750,40 @@
bool HInliner::TryInlineAndReplace(HInvoke* invoke_instruction, ArtMethod* method, bool do_rtp) {
HInstruction* return_replacement = nullptr;
if (!TryBuildAndInline(invoke_instruction, method, &return_replacement)) {
- return false;
+ if (invoke_instruction->IsInvokeInterface()) {
+ // Turn an invoke-interface into an invoke-virtual. An invoke-virtual is always
+ // better than an invoke-interface because:
+ // 1) In the best case, the interface call has one more indirection (to fetch the IMT).
+ // 2) We will not go to the conflict trampoline with an invoke-virtual.
+ // TODO: Consider sharpening once it is not dependent on the compiler driver.
+ const DexFile& caller_dex_file = *caller_compilation_unit_.GetDexFile();
+ uint32_t method_index = FindMethodIndexIn(
+ method, caller_dex_file, invoke_instruction->GetDexMethodIndex());
+ if (method_index == DexFile::kDexNoIndex) {
+ return false;
+ }
+ HInvokeVirtual* new_invoke = new (graph_->GetArena()) HInvokeVirtual(
+ graph_->GetArena(),
+ invoke_instruction->GetNumberOfArguments(),
+ invoke_instruction->GetType(),
+ invoke_instruction->GetDexPc(),
+ method_index,
+ method->GetMethodIndex());
+ HInputsRef inputs = invoke_instruction->GetInputs();
+ for (size_t index = 0; index != inputs.size(); ++index) {
+ new_invoke->SetArgumentAt(index, inputs[index]);
+ }
+ invoke_instruction->GetBlock()->InsertInstructionBefore(new_invoke, invoke_instruction);
+ new_invoke->CopyEnvironmentFrom(invoke_instruction->GetEnvironment());
+ if (invoke_instruction->GetType() == Primitive::kPrimNot) {
+ new_invoke->SetReferenceTypeInfo(invoke_instruction->GetReferenceTypeInfo());
+ }
+ return_replacement = new_invoke;
+ } else {
+ // TODO: Consider sharpening an invoke virtual once it is not dependent on the
+ // compiler driver.
+ return false;
+ }
}
if (return_replacement != nullptr) {
invoke_instruction->ReplaceWith(return_replacement);
@@ -1239,14 +1272,6 @@
return false;
}
- if (current->IsInvokeInterface()) {
- // Disable inlining of interface calls. The cost in case of entering the
- // resolution conflict is currently too high.
- VLOG(compiler) << "Method " << PrettyMethod(method_index, callee_dex_file)
- << " could not be inlined because it has an interface call.";
- return false;
- }
-
if (!same_dex_file && current->NeedsEnvironment()) {
VLOG(compiler) << "Method " << PrettyMethod(method_index, callee_dex_file)
<< " could not be inlined because " << current->DebugName()
diff --git a/compiler/optimizing/instruction_simplifier.cc b/compiler/optimizing/instruction_simplifier.cc
index 3041c4d..e0410dc 100644
--- a/compiler/optimizing/instruction_simplifier.cc
+++ b/compiler/optimizing/instruction_simplifier.cc
@@ -54,6 +54,9 @@
// De Morgan's laws:
// ~a & ~b = ~(a | b) and ~a | ~b = ~(a & b)
bool TryDeMorganNegationFactoring(HBinaryOperation* op);
+ bool TryHandleAssociativeAndCommutativeOperation(HBinaryOperation* instruction);
+ bool TrySubtractionChainSimplification(HBinaryOperation* instruction);
+
void VisitShift(HBinaryOperation* shift);
void VisitEqual(HEqual* equal) OVERRIDE;
@@ -963,7 +966,18 @@
return;
}
- TryReplaceWithRotate(instruction);
+ if (TryReplaceWithRotate(instruction)) {
+ return;
+ }
+
+ // TryHandleAssociativeAndCommutativeOperation() does not remove its input,
+ // so no need to return.
+ TryHandleAssociativeAndCommutativeOperation(instruction);
+
+ if ((instruction->GetLeft()->IsSub() || instruction->GetRight()->IsSub()) &&
+ TrySubtractionChainSimplification(instruction)) {
+ return;
+ }
}
void InstructionSimplifierVisitor::VisitAnd(HAnd* instruction) {
@@ -1025,7 +1039,13 @@
return;
}
- TryDeMorganNegationFactoring(instruction);
+ if (TryDeMorganNegationFactoring(instruction)) {
+ return;
+ }
+
+ // TryHandleAssociativeAndCommutativeOperation() does not remove its input,
+ // so no need to return.
+ TryHandleAssociativeAndCommutativeOperation(instruction);
}
void InstructionSimplifierVisitor::VisitGreaterThan(HGreaterThan* condition) {
@@ -1242,6 +1262,7 @@
instruction->ReplaceWith(input_cst);
instruction->GetBlock()->RemoveInstruction(instruction);
RecordSimplification();
+ return;
} else if (IsPowerOfTwo(factor)) {
// Replace code looking like
// MUL dst, src, pow_of_2
@@ -1251,6 +1272,7 @@
HShl* shl = new (allocator) HShl(type, input_other, shift);
block->ReplaceAndRemoveInstructionWith(instruction, shl);
RecordSimplification();
+ return;
} else if (IsPowerOfTwo(factor - 1)) {
// Transform code looking like
// MUL dst, src, (2^n + 1)
@@ -1265,6 +1287,7 @@
block->InsertInstructionBefore(shl, instruction);
block->ReplaceAndRemoveInstructionWith(instruction, add);
RecordSimplification();
+ return;
} else if (IsPowerOfTwo(factor + 1)) {
// Transform code looking like
// MUL dst, src, (2^n - 1)
@@ -1279,8 +1302,13 @@
block->InsertInstructionBefore(shl, instruction);
block->ReplaceAndRemoveInstructionWith(instruction, sub);
RecordSimplification();
+ return;
}
}
+
+ // TryHandleAssociativeAndCommutativeOperation() does not remove its input,
+ // so no need to return.
+ TryHandleAssociativeAndCommutativeOperation(instruction);
}
void InstructionSimplifierVisitor::VisitNeg(HNeg* instruction) {
@@ -1380,7 +1408,13 @@
if (TryDeMorganNegationFactoring(instruction)) return;
- TryReplaceWithRotate(instruction);
+ if (TryReplaceWithRotate(instruction)) {
+ return;
+ }
+
+ // TryHandleAssociativeAndCommutativeOperation() does not remove its input,
+ // so no need to return.
+ TryHandleAssociativeAndCommutativeOperation(instruction);
}
void InstructionSimplifierVisitor::VisitShl(HShl* instruction) {
@@ -1471,6 +1505,11 @@
instruction->GetBlock()->RemoveInstruction(instruction);
RecordSimplification();
left->GetBlock()->RemoveInstruction(left);
+ return;
+ }
+
+ if (TrySubtractionChainSimplification(instruction)) {
+ return;
}
}
@@ -1524,7 +1563,13 @@
return;
}
- TryReplaceWithRotate(instruction);
+ if (TryReplaceWithRotate(instruction)) {
+ return;
+ }
+
+ // TryHandleAssociativeAndCommutativeOperation() does not remove its input,
+ // so no need to return.
+ TryHandleAssociativeAndCommutativeOperation(instruction);
}
void InstructionSimplifierVisitor::SimplifyStringEquals(HInvoke* instruction) {
@@ -1823,4 +1868,150 @@
}
}
+// Replace code looking like
+// OP y, x, const1
+// OP z, y, const2
+// with
+// OP z, x, const3
+// where OP is both an associative and a commutative operation.
+bool InstructionSimplifierVisitor::TryHandleAssociativeAndCommutativeOperation(
+ HBinaryOperation* instruction) {
+ DCHECK(instruction->IsCommutative());
+
+ if (!Primitive::IsIntegralType(instruction->GetType())) {
+ return false;
+ }
+
+ HInstruction* left = instruction->GetLeft();
+ HInstruction* right = instruction->GetRight();
+ // Variable names as described above.
+ HConstant* const2;
+ HBinaryOperation* y;
+
+ if (instruction->InstructionTypeEquals(left) && right->IsConstant()) {
+ const2 = right->AsConstant();
+ y = left->AsBinaryOperation();
+ } else if (left->IsConstant() && instruction->InstructionTypeEquals(right)) {
+ const2 = left->AsConstant();
+ y = right->AsBinaryOperation();
+ } else {
+ // The node does not match the pattern.
+ return false;
+ }
+
+ // If `y` has more than one use, we do not perform the optimization
+ // because it might increase code size (e.g. if the new constant is
+ // no longer encodable as an immediate operand in the target ISA).
+ if (!y->HasOnlyOneNonEnvironmentUse()) {
+ return false;
+ }
+
+ // GetConstantRight() can return both left and right constants
+ // for commutative operations.
+ HConstant* const1 = y->GetConstantRight();
+ if (const1 == nullptr) {
+ return false;
+ }
+
+ instruction->ReplaceInput(const1, 0);
+ instruction->ReplaceInput(const2, 1);
+ HConstant* const3 = instruction->TryStaticEvaluation();
+ DCHECK(const3 != nullptr);
+ instruction->ReplaceInput(y->GetLeastConstantLeft(), 0);
+ instruction->ReplaceInput(const3, 1);
+ RecordSimplification();
+ return true;
+}
+
+static HBinaryOperation* AsAddOrSub(HInstruction* binop) {
+ return (binop->IsAdd() || binop->IsSub()) ? binop->AsBinaryOperation() : nullptr;
+}
+
+// Helper function that performs addition statically, considering the result type.
+static int64_t ComputeAddition(Primitive::Type type, int64_t x, int64_t y) {
+ // Use the Compute() method for consistency with TryStaticEvaluation().
+ if (type == Primitive::kPrimInt) {
+ return HAdd::Compute<int32_t>(x, y);
+ } else {
+ DCHECK_EQ(type, Primitive::kPrimLong);
+ return HAdd::Compute<int64_t>(x, y);
+ }
+}
+
+// Helper function that handles the child classes of HConstant
+// and returns an integer with the appropriate sign.
+static int64_t GetValue(HConstant* constant, bool is_negated) {
+ int64_t ret = Int64FromConstant(constant);
+ return is_negated ? -ret : ret;
+}
+
+// Replace code looking like
+// OP1 y, x, const1
+// OP2 z, y, const2
+// with
+// OP3 z, x, const3
+// where OPx is either ADD or SUB, and at least one of OP{1,2} is SUB.
+bool InstructionSimplifierVisitor::TrySubtractionChainSimplification(
+ HBinaryOperation* instruction) {
+ DCHECK(instruction->IsAdd() || instruction->IsSub()) << instruction->DebugName();
+
+ Primitive::Type type = instruction->GetType();
+ if (!Primitive::IsIntegralType(type)) {
+ return false;
+ }
+
+ HInstruction* left = instruction->GetLeft();
+ HInstruction* right = instruction->GetRight();
+ // Variable names as described above.
+ HConstant* const2 = right->IsConstant() ? right->AsConstant() : left->AsConstant();
+ if (const2 == nullptr) {
+ return false;
+ }
+
+ HBinaryOperation* y = (AsAddOrSub(left) != nullptr)
+ ? left->AsBinaryOperation()
+ : AsAddOrSub(right);
+ // If y has more than one use, we do not perform the optimization because
+ // it might increase code size (e.g. if the new constant is no longer
+ // encodable as an immediate operand in the target ISA).
+ if ((y == nullptr) || !y->HasOnlyOneNonEnvironmentUse()) {
+ return false;
+ }
+
+ left = y->GetLeft();
+ HConstant* const1 = left->IsConstant() ? left->AsConstant() : y->GetRight()->AsConstant();
+ if (const1 == nullptr) {
+ return false;
+ }
+
+ HInstruction* x = (const1 == left) ? y->GetRight() : left;
+ // If both inputs are constants, let the constant folding pass deal with it.
+ if (x->IsConstant()) {
+ return false;
+ }
+
+ bool is_const2_negated = (const2 == right) && instruction->IsSub();
+ int64_t const2_val = GetValue(const2, is_const2_negated);
+ bool is_y_negated = (y == right) && instruction->IsSub();
+ right = y->GetRight();
+ bool is_const1_negated = is_y_negated ^ ((const1 == right) && y->IsSub());
+ int64_t const1_val = GetValue(const1, is_const1_negated);
+ bool is_x_negated = is_y_negated ^ ((x == right) && y->IsSub());
+ int64_t const3_val = ComputeAddition(type, const1_val, const2_val);
+ HBasicBlock* block = instruction->GetBlock();
+ HConstant* const3 = block->GetGraph()->GetConstant(type, const3_val);
+ ArenaAllocator* arena = instruction->GetArena();
+ HInstruction* z;
+
+ if (is_x_negated) {
+ z = new (arena) HSub(type, const3, x, instruction->GetDexPc());
+ } else {
+ z = new (arena) HAdd(type, x, const3, instruction->GetDexPc());
+ }
+
+ block->ReplaceAndRemoveInstructionWith(instruction, z);
+ RecordSimplification();
+ return true;
+}
+
} // namespace art
diff --git a/compiler/optimizing/intrinsics_arm.cc b/compiler/optimizing/intrinsics_arm.cc
index f43f8ed..579fb9d 100644
--- a/compiler/optimizing/intrinsics_arm.cc
+++ b/compiler/optimizing/intrinsics_arm.cc
@@ -1365,7 +1365,6 @@
Register input,
Location length,
SlowPathCode* slow_path,
- Register input_len,
Register temp,
bool length_is_input_length = false) {
// Where is the length in the Array?
@@ -1386,8 +1385,8 @@
}
} else {
// Check that length(input) >= pos.
- __ LoadFromOffset(kLoadWord, input_len, input, length_offset);
- __ subs(temp, input_len, ShifterOperand(pos_const));
+ __ LoadFromOffset(kLoadWord, temp, input, length_offset);
+ __ subs(temp, temp, ShifterOperand(pos_const));
__ b(slow_path->GetEntryLabel(), LT);
// Check that (length(input) - pos) >= length.
@@ -1451,20 +1450,26 @@
Label conditions_on_positions_validated;
SystemArrayCopyOptimizations optimizations(invoke);
- if (!optimizations.GetDestinationIsSource() &&
- (!src_pos.IsConstant() || !dest_pos.IsConstant())) {
- __ cmp(src, ShifterOperand(dest));
- }
// If source and destination are the same, we go to slow path if we need to do
// forward copying.
if (src_pos.IsConstant()) {
int32_t src_pos_constant = src_pos.GetConstant()->AsIntConstant()->GetValue();
if (dest_pos.IsConstant()) {
+ int32_t dest_pos_constant = dest_pos.GetConstant()->AsIntConstant()->GetValue();
+ if (optimizations.GetDestinationIsSource()) {
+ // Checked when building locations.
+ DCHECK_GE(src_pos_constant, dest_pos_constant);
+ } else if (src_pos_constant < dest_pos_constant) {
+ __ cmp(src, ShifterOperand(dest));
+ __ b(slow_path->GetEntryLabel(), EQ);
+ }
+
// Checked when building locations.
DCHECK(!optimizations.GetDestinationIsSource()
|| (src_pos_constant >= dest_pos.GetConstant()->AsIntConstant()->GetValue()));
} else {
if (!optimizations.GetDestinationIsSource()) {
+ __ cmp(src, ShifterOperand(dest));
__ b(&conditions_on_positions_validated, NE);
}
__ cmp(dest_pos.AsRegister<Register>(), ShifterOperand(src_pos_constant));
@@ -1472,6 +1477,7 @@
}
} else {
if (!optimizations.GetDestinationIsSource()) {
+ __ cmp(src, ShifterOperand(dest));
__ b(&conditions_on_positions_validated, NE);
}
if (dest_pos.IsConstant()) {
@@ -1511,7 +1517,6 @@
length,
slow_path,
temp1,
- temp2,
optimizations.GetCountIsSourceLength());
// Validity checks: dest.
@@ -1521,7 +1526,6 @@
length,
slow_path,
temp1,
- temp2,
optimizations.GetCountIsDestinationLength());
if (!optimizations.GetDoesNotNeedTypeCheck()) {
@@ -1599,7 +1603,7 @@
// Compute base source address, base destination address, and end source address.
- uint32_t element_size = sizeof(int32_t);
+ int32_t element_size = Primitive::ComponentSize(Primitive::kPrimNot);
uint32_t offset = mirror::Array::DataOffset(element_size).Uint32Value();
if (src_pos.IsConstant()) {
int32_t constant = src_pos.GetConstant()->AsIntConstant()->GetValue();
@@ -1625,8 +1629,7 @@
}
// Iterate over the arrays and do a raw copy of the objects. We don't need to
- // poison/unpoison, nor do any read barrier as the next uses of the destination
- // array will do it.
+ // poison/unpoison.
Label loop, done;
__ cmp(temp1, ShifterOperand(temp3));
__ b(&done, EQ);
diff --git a/compiler/optimizing/intrinsics_arm64.cc b/compiler/optimizing/intrinsics_arm64.cc
index 1685cf9..1d50753 100644
--- a/compiler/optimizing/intrinsics_arm64.cc
+++ b/compiler/optimizing/intrinsics_arm64.cc
@@ -608,54 +608,66 @@
__ Frintn(DRegisterFrom(locations->Out()), DRegisterFrom(locations->InAt(0)));
}
-static void CreateFPToIntPlusTempLocations(ArenaAllocator* arena, HInvoke* invoke) {
+static void CreateFPToIntPlusFPTempLocations(ArenaAllocator* arena, HInvoke* invoke) {
LocationSummary* locations = new (arena) LocationSummary(invoke,
LocationSummary::kNoCall,
kIntrinsified);
locations->SetInAt(0, Location::RequiresFpuRegister());
locations->SetOut(Location::RequiresRegister());
+ locations->AddTemp(Location::RequiresFpuRegister());
}
-static void GenMathRound(LocationSummary* locations,
- bool is_double,
- vixl::MacroAssembler* masm) {
- FPRegister in_reg = is_double ?
- DRegisterFrom(locations->InAt(0)) : SRegisterFrom(locations->InAt(0));
- Register out_reg = is_double ?
- XRegisterFrom(locations->Out()) : WRegisterFrom(locations->Out());
- UseScratchRegisterScope temps(masm);
- FPRegister temp1_reg = temps.AcquireSameSizeAs(in_reg);
+static void GenMathRound(HInvoke* invoke, bool is_double, vixl::MacroAssembler* masm) {
+ // Java 8 API definition for Math.round():
+ // Return the closest long or int to the argument, with ties rounding to positive infinity.
+ //
+ // There is no single instruction in ARMv8 that can support the above definition.
+ // We choose to use FCVTAS here, because it has closest semantic.
+ // FCVTAS performs rounding to nearest integer, ties away from zero.
+ // For most inputs (positive values, zero or NaN), this instruction is enough.
+ // We only need a few handling code after FCVTAS if the input is negative half value.
+ //
+ // The reason why we didn't choose FCVTPS instruction here is that
+ // although it performs rounding toward positive infinity, it doesn't perform rounding to nearest.
+ // For example, FCVTPS(-1.9) = -1 and FCVTPS(1.1) = 2.
+ // If we were using this instruction, for most inputs, more handling code would be needed.
+ LocationSummary* l = invoke->GetLocations();
+ FPRegister in_reg = is_double ? DRegisterFrom(l->InAt(0)) : SRegisterFrom(l->InAt(0));
+ FPRegister tmp_fp = is_double ? DRegisterFrom(l->GetTemp(0)) : SRegisterFrom(l->GetTemp(0));
+ Register out_reg = is_double ? XRegisterFrom(l->Out()) : WRegisterFrom(l->Out());
+ vixl::Label done;
- // 0.5 can be encoded as an immediate, so use fmov.
- if (is_double) {
- __ Fmov(temp1_reg, static_cast<double>(0.5));
- } else {
- __ Fmov(temp1_reg, static_cast<float>(0.5));
- }
- __ Fadd(temp1_reg, in_reg, temp1_reg);
- __ Fcvtms(out_reg, temp1_reg);
+ // Round to nearest integer, ties away from zero.
+ __ Fcvtas(out_reg, in_reg);
+
+ // For positive values, zero or NaN inputs, rounding is done.
+ __ Tbz(out_reg, out_reg.size() - 1, &done);
+
+ // Handle input < 0 cases.
+ // If input is negative but not a tie, previous result (round to nearest) is valid.
+ // If input is a negative tie, out_reg += 1.
+ __ Frinta(tmp_fp, in_reg);
+ __ Fsub(tmp_fp, in_reg, tmp_fp);
+ __ Fcmp(tmp_fp, 0.5);
+ __ Cinc(out_reg, out_reg, eq);
+
+ __ Bind(&done);
}
void IntrinsicLocationsBuilderARM64::VisitMathRoundDouble(HInvoke* invoke) {
- // See intrinsics.h.
- if (kRoundIsPlusPointFive) {
- CreateFPToIntPlusTempLocations(arena_, invoke);
- }
+ CreateFPToIntPlusFPTempLocations(arena_, invoke);
}
void IntrinsicCodeGeneratorARM64::VisitMathRoundDouble(HInvoke* invoke) {
- GenMathRound(invoke->GetLocations(), /* is_double */ true, GetVIXLAssembler());
+ GenMathRound(invoke, /* is_double */ true, GetVIXLAssembler());
}
void IntrinsicLocationsBuilderARM64::VisitMathRoundFloat(HInvoke* invoke) {
- // See intrinsics.h.
- if (kRoundIsPlusPointFive) {
- CreateFPToIntPlusTempLocations(arena_, invoke);
- }
+ CreateFPToIntPlusFPTempLocations(arena_, invoke);
}
void IntrinsicCodeGeneratorARM64::VisitMathRoundFloat(HInvoke* invoke) {
- GenMathRound(invoke->GetLocations(), /* is_double */ false, GetVIXLAssembler());
+ GenMathRound(invoke, /* is_double */ false, GetVIXLAssembler());
}
void IntrinsicLocationsBuilderARM64::VisitMemoryPeekByte(HInvoke* invoke) {
@@ -1840,7 +1852,6 @@
const Register& input,
const Location& length,
SlowPathCodeARM64* slow_path,
- const Register& input_len,
const Register& temp,
bool length_is_input_length = false) {
const int32_t length_offset = mirror::Array::LengthOffset().Int32Value();
@@ -1855,8 +1866,8 @@
}
} else {
// Check that length(input) >= pos.
- __ Ldr(input_len, MemOperand(input, length_offset));
- __ Subs(temp, input_len, pos_const);
+ __ Ldr(temp, MemOperand(input, length_offset));
+ __ Subs(temp, temp, pos_const);
__ B(slow_path->GetEntryLabel(), lt);
// Check that (length(input) - pos) >= length.
@@ -1967,7 +1978,6 @@
length,
slow_path,
src_curr_addr,
- dst_curr_addr,
false);
CheckSystemArrayCopyPosition(masm,
@@ -1976,7 +1986,6 @@
length,
slow_path,
src_curr_addr,
- dst_curr_addr,
false);
src_curr_addr = src_curr_addr.X();
@@ -2101,20 +2110,25 @@
vixl::Label conditions_on_positions_validated;
SystemArrayCopyOptimizations optimizations(invoke);
- if (!optimizations.GetDestinationIsSource() &&
- (!src_pos.IsConstant() || !dest_pos.IsConstant())) {
- __ Cmp(src, dest);
- }
// If source and destination are the same, we go to slow path if we need to do
// forward copying.
if (src_pos.IsConstant()) {
int32_t src_pos_constant = src_pos.GetConstant()->AsIntConstant()->GetValue();
if (dest_pos.IsConstant()) {
+ int32_t dest_pos_constant = dest_pos.GetConstant()->AsIntConstant()->GetValue();
+ if (optimizations.GetDestinationIsSource()) {
+ // Checked when building locations.
+ DCHECK_GE(src_pos_constant, dest_pos_constant);
+ } else if (src_pos_constant < dest_pos_constant) {
+ __ Cmp(src, dest);
+ __ B(slow_path->GetEntryLabel(), eq);
+ }
// Checked when building locations.
DCHECK(!optimizations.GetDestinationIsSource()
|| (src_pos_constant >= dest_pos.GetConstant()->AsIntConstant()->GetValue()));
} else {
if (!optimizations.GetDestinationIsSource()) {
+ __ Cmp(src, dest);
__ B(&conditions_on_positions_validated, ne);
}
__ Cmp(WRegisterFrom(dest_pos), src_pos_constant);
@@ -2122,6 +2136,7 @@
}
} else {
if (!optimizations.GetDestinationIsSource()) {
+ __ Cmp(src, dest);
__ B(&conditions_on_positions_validated, ne);
}
__ Cmp(RegisterFrom(src_pos, invoke->InputAt(1)->GetType()),
@@ -2158,7 +2173,6 @@
length,
slow_path,
temp1,
- temp2,
optimizations.GetCountIsSourceLength());
// Validity checks: dest.
@@ -2168,7 +2182,6 @@
length,
slow_path,
temp1,
- temp2,
optimizations.GetCountIsDestinationLength());
{
// We use a block to end the scratch scope before the write barrier, thus
@@ -2264,8 +2277,7 @@
src_stop_addr);
// Iterate over the arrays and do a raw copy of the objects. We don't need to
- // poison/unpoison, nor do any read barrier as the next uses of the destination
- // array will do it.
+ // poison/unpoison.
vixl::Label loop, done;
const int32_t element_size = Primitive::ComponentSize(Primitive::kPrimNot);
__ Bind(&loop);
diff --git a/compiler/optimizing/intrinsics_mips64.cc b/compiler/optimizing/intrinsics_mips64.cc
index 9243f4c..cc4971b 100644
--- a/compiler/optimizing/intrinsics_mips64.cc
+++ b/compiler/optimizing/intrinsics_mips64.cc
@@ -876,6 +876,151 @@
GenRoundingMode(invoke->GetLocations(), kCeil, GetAssembler());
}
+static void GenRound(LocationSummary* locations, Mips64Assembler* assembler, Primitive::Type type) {
+ FpuRegister in = locations->InAt(0).AsFpuRegister<FpuRegister>();
+ FpuRegister half = locations->GetTemp(0).AsFpuRegister<FpuRegister>();
+ GpuRegister out = locations->Out().AsRegister<GpuRegister>();
+
+ DCHECK(type == Primitive::kPrimFloat || type == Primitive::kPrimDouble);
+
+ Mips64Label done;
+ Mips64Label finite;
+ Mips64Label add;
+
+ // if (in.isNaN) {
+ // return 0;
+ // }
+ //
+ // out = floor(in);
+ //
+ // /*
+ // * TODO: Amend this code when emulator FCSR.NAN2008=1 bug is fixed.
+ // *
+ // * Starting with MIPSR6, which always sets FCSR.NAN2008=1, negative
+ // * numbers which are too large to be represented in a 32-/64-bit
+ // * signed integer will be processed by floor.X.Y to output
+ // * Integer.MIN_VALUE/Long.MIN_VALUE, and will no longer be
+ // * processed by this "if" statement.
+ // *
+ // * However, this bug in the 64-bit MIPS emulator causes the
+ // * behavior of floor.X.Y to be the same as pre-R6 implementations
+ // * of MIPS64. When that bug is fixed this logic should be amended.
+ // */
+ // if (out == MAX_VALUE) {
+ // TMP = (in < 0.0) ? 1 : 0;
+ // /*
+ // * If TMP is 1, then adding it to out will wrap its value from
+ // * MAX_VALUE to MIN_VALUE.
+ // */
+ // return out += TMP;
+ // }
+ //
+ // /*
+ // * For negative values not handled by the previous "if" statement the
+ // * test here will correctly set the value of TMP.
+ // */
+ // TMP = ((in - out) >= 0.5) ? 1 : 0;
+ // return out += TMP;
+
+ // Test for NaN.
+ if (type == Primitive::kPrimDouble) {
+ __ CmpUnD(FTMP, in, in);
+ } else {
+ __ CmpUnS(FTMP, in, in);
+ }
+
+ // Return zero for NaN.
+ __ Move(out, ZERO);
+ __ Bc1nez(FTMP, &done);
+
+ // out = floor(in);
+ if (type == Primitive::kPrimDouble) {
+ __ FloorLD(FTMP, in);
+ __ Dmfc1(out, FTMP);
+ } else {
+ __ FloorWS(FTMP, in);
+ __ Mfc1(out, FTMP);
+ }
+
+ // TMP = (out = java.lang.Integer.MAX_VALUE) ? 1 : 0;
+ if (type == Primitive::kPrimDouble) {
+ __ LoadConst64(AT, std::numeric_limits<int64_t>::max());
+ } else {
+ __ LoadConst32(AT, std::numeric_limits<int32_t>::max());
+ }
+ __ Bnec(AT, out, &finite);
+
+ if (type == Primitive::kPrimDouble) {
+ __ Dmtc1(ZERO, FTMP);
+ __ CmpLtD(FTMP, in, FTMP);
+ __ Dmfc1(AT, FTMP);
+ } else {
+ __ Mtc1(ZERO, FTMP);
+ __ CmpLtS(FTMP, in, FTMP);
+ __ Mfc1(AT, FTMP);
+ }
+
+ __ Bc(&add);
+
+ __ Bind(&finite);
+
+ // TMP = (0.5 <= (in - out)) ? -1 : 0;
+ if (type == Primitive::kPrimDouble) {
+ __ Cvtdl(FTMP, FTMP); // Convert output of floor.l.d back to "double".
+ __ LoadConst64(AT, bit_cast<int64_t, double>(0.5));
+ __ SubD(FTMP, in, FTMP);
+ __ Dmtc1(AT, half);
+ __ CmpLeD(FTMP, half, FTMP);
+ __ Dmfc1(AT, FTMP);
+ } else {
+ __ Cvtsw(FTMP, FTMP); // Convert output of floor.w.s back to "float".
+ __ LoadConst32(AT, bit_cast<int32_t, float>(0.5f));
+ __ SubS(FTMP, in, FTMP);
+ __ Mtc1(AT, half);
+ __ CmpLeS(FTMP, half, FTMP);
+ __ Mfc1(AT, FTMP);
+ }
+
+ __ Bind(&add);
+
+ // Return out -= TMP.
+ if (type == Primitive::kPrimDouble) {
+ __ Dsubu(out, out, AT);
+ } else {
+ __ Subu(out, out, AT);
+ }
+
+ __ Bind(&done);
+}
+
+// int java.lang.Math.round(float)
+void IntrinsicLocationsBuilderMIPS64::VisitMathRoundFloat(HInvoke* invoke) {
+ LocationSummary* locations = new (arena_) LocationSummary(invoke,
+ LocationSummary::kNoCall,
+ kIntrinsified);
+ locations->SetInAt(0, Location::RequiresFpuRegister());
+ locations->AddTemp(Location::RequiresFpuRegister());
+ locations->SetOut(Location::RequiresRegister());
+}
+
+void IntrinsicCodeGeneratorMIPS64::VisitMathRoundFloat(HInvoke* invoke) {
+ GenRound(invoke->GetLocations(), GetAssembler(), Primitive::kPrimFloat);
+}
+
+// long java.lang.Math.round(double)
+void IntrinsicLocationsBuilderMIPS64::VisitMathRoundDouble(HInvoke* invoke) {
+ LocationSummary* locations = new (arena_) LocationSummary(invoke,
+ LocationSummary::kNoCall,
+ kIntrinsified);
+ locations->SetInAt(0, Location::RequiresFpuRegister());
+ locations->AddTemp(Location::RequiresFpuRegister());
+ locations->SetOut(Location::RequiresRegister());
+}
+
+void IntrinsicCodeGeneratorMIPS64::VisitMathRoundDouble(HInvoke* invoke) {
+ GenRound(invoke->GetLocations(), GetAssembler(), Primitive::kPrimDouble);
+}
+
// byte libcore.io.Memory.peekByte(long address)
void IntrinsicLocationsBuilderMIPS64::VisitMemoryPeekByte(HInvoke* invoke) {
CreateIntToIntLocations(arena_, invoke);
@@ -1734,9 +1879,6 @@
GenIsInfinite(invoke->GetLocations(), /* is64bit */ true, GetAssembler());
}
-UNIMPLEMENTED_INTRINSIC(MIPS64, MathRoundDouble)
-UNIMPLEMENTED_INTRINSIC(MIPS64, MathRoundFloat)
-
UNIMPLEMENTED_INTRINSIC(MIPS64, ReferenceGetReferent)
UNIMPLEMENTED_INTRINSIC(MIPS64, StringGetCharsNoCheck)
UNIMPLEMENTED_INTRINSIC(MIPS64, SystemArrayCopyChar)
diff --git a/compiler/optimizing/intrinsics_x86.cc b/compiler/optimizing/intrinsics_x86.cc
index 031cd13..812bdf5 100644
--- a/compiler/optimizing/intrinsics_x86.cc
+++ b/compiler/optimizing/intrinsics_x86.cc
@@ -1070,30 +1070,45 @@
static void CheckPosition(X86Assembler* assembler,
Location pos,
Register input,
- Register length,
+ Location length,
SlowPathCode* slow_path,
- Register input_len,
- Register temp) {
- // Where is the length in the String?
+ Register temp,
+ bool length_is_input_length = false) {
+ // Where is the length in the Array?
const uint32_t length_offset = mirror::Array::LengthOffset().Uint32Value();
if (pos.IsConstant()) {
int32_t pos_const = pos.GetConstant()->AsIntConstant()->GetValue();
if (pos_const == 0) {
- // Check that length(input) >= length.
- __ cmpl(Address(input, length_offset), length);
- __ j(kLess, slow_path->GetEntryLabel());
+ if (!length_is_input_length) {
+ // Check that length(input) >= length.
+ if (length.IsConstant()) {
+ __ cmpl(Address(input, length_offset),
+ Immediate(length.GetConstant()->AsIntConstant()->GetValue()));
+ } else {
+ __ cmpl(Address(input, length_offset), length.AsRegister<Register>());
+ }
+ __ j(kLess, slow_path->GetEntryLabel());
+ }
} else {
// Check that length(input) >= pos.
- __ movl(input_len, Address(input, length_offset));
- __ cmpl(input_len, Immediate(pos_const));
+ __ movl(temp, Address(input, length_offset));
+ __ subl(temp, Immediate(pos_const));
__ j(kLess, slow_path->GetEntryLabel());
// Check that (length(input) - pos) >= length.
- __ leal(temp, Address(input_len, -pos_const));
- __ cmpl(temp, length);
+ if (length.IsConstant()) {
+ __ cmpl(temp, Immediate(length.GetConstant()->AsIntConstant()->GetValue()));
+ } else {
+ __ cmpl(temp, length.AsRegister<Register>());
+ }
__ j(kLess, slow_path->GetEntryLabel());
}
+ } else if (length_is_input_length) {
+ // The only way the copy can succeed is if pos is zero.
+ Register pos_reg = pos.AsRegister<Register>();
+ __ testl(pos_reg, pos_reg);
+ __ j(kNotEqual, slow_path->GetEntryLabel());
} else {
// Check that pos >= 0.
Register pos_reg = pos.AsRegister<Register>();
@@ -1107,7 +1122,11 @@
// Check that (length(input) - pos) >= length.
__ movl(temp, Address(input, length_offset));
__ subl(temp, pos_reg);
- __ cmpl(temp, length);
+ if (length.IsConstant()) {
+ __ cmpl(temp, Immediate(length.GetConstant()->AsIntConstant()->GetValue()));
+ } else {
+ __ cmpl(temp, length.AsRegister<Register>());
+ }
__ j(kLess, slow_path->GetEntryLabel());
}
}
@@ -1159,11 +1178,11 @@
__ movl(count, length.AsRegister<Register>());
}
- // Validity checks: source.
- CheckPosition(assembler, srcPos, src, count, slow_path, src_base, dest_base);
+ // Validity checks: source. Use src_base as a temporary register.
+ CheckPosition(assembler, srcPos, src, Location::RegisterLocation(count), slow_path, src_base);
- // Validity checks: dest.
- CheckPosition(assembler, destPos, dest, count, slow_path, src_base, dest_base);
+ // Validity checks: dest. Use src_base as a temporary register.
+ CheckPosition(assembler, destPos, dest, Location::RegisterLocation(count), slow_path, src_base);
// Okay, everything checks out. Finally time to do the copy.
// Check assumption that sizeof(Char) is 2 (used in scaling below).
@@ -2646,8 +2665,274 @@
__ Bind(slow_path->GetExitLabel());
}
+static bool IsSameInput(HInstruction* instruction, size_t input0, size_t input1) {
+ return instruction->InputAt(input0) == instruction->InputAt(input1);
+}
+
+void IntrinsicLocationsBuilderX86::VisitSystemArrayCopy(HInvoke* invoke) {
+ // TODO(rpl): Implement read barriers in the SystemArrayCopy
+ // intrinsic and re-enable it (b/29516905).
+ if (kEmitCompilerReadBarrier) {
+ return;
+ }
+
+ CodeGenerator::CreateSystemArrayCopyLocationSummary(invoke);
+ if (invoke->GetLocations() != nullptr) {
+ // Need a byte register for marking.
+ invoke->GetLocations()->SetTempAt(1, Location::RegisterLocation(ECX));
+
+ static constexpr size_t kSrc = 0;
+ static constexpr size_t kSrcPos = 1;
+ static constexpr size_t kDest = 2;
+ static constexpr size_t kDestPos = 3;
+ static constexpr size_t kLength = 4;
+
+ if (!invoke->InputAt(kSrcPos)->IsIntConstant() &&
+ !invoke->InputAt(kDestPos)->IsIntConstant() &&
+ !invoke->InputAt(kLength)->IsIntConstant()) {
+ if (!IsSameInput(invoke, kSrcPos, kDestPos) &&
+ !IsSameInput(invoke, kSrcPos, kLength) &&
+ !IsSameInput(invoke, kDestPos, kLength) &&
+ !IsSameInput(invoke, kSrc, kDest)) {
+ // Not enough registers, make the length also take a stack slot.
+ invoke->GetLocations()->SetInAt(kLength, Location::Any());
+ }
+ }
+ }
+}
+
+void IntrinsicCodeGeneratorX86::VisitSystemArrayCopy(HInvoke* invoke) {
+ // TODO(rpl): Implement read barriers in the SystemArrayCopy
+ // intrinsic and re-enable it (b/29516905).
+ DCHECK(!kEmitCompilerReadBarrier);
+
+ X86Assembler* assembler = GetAssembler();
+ LocationSummary* locations = invoke->GetLocations();
+
+ uint32_t class_offset = mirror::Object::ClassOffset().Int32Value();
+ uint32_t super_offset = mirror::Class::SuperClassOffset().Int32Value();
+ uint32_t component_offset = mirror::Class::ComponentTypeOffset().Int32Value();
+ uint32_t primitive_offset = mirror::Class::PrimitiveTypeOffset().Int32Value();
+
+ Register src = locations->InAt(0).AsRegister<Register>();
+ Location src_pos = locations->InAt(1);
+ Register dest = locations->InAt(2).AsRegister<Register>();
+ Location dest_pos = locations->InAt(3);
+ Location length = locations->InAt(4);
+ Register temp1 = locations->GetTemp(0).AsRegister<Register>();
+ Register temp2 = locations->GetTemp(1).AsRegister<Register>();
+
+ SlowPathCode* slow_path = new (GetAllocator()) IntrinsicSlowPathX86(invoke);
+ codegen_->AddSlowPath(slow_path);
+
+ NearLabel conditions_on_positions_validated;
+ SystemArrayCopyOptimizations optimizations(invoke);
+
+ // If source and destination are the same, we go to slow path if we need to do
+ // forward copying.
+ if (src_pos.IsConstant()) {
+ int32_t src_pos_constant = src_pos.GetConstant()->AsIntConstant()->GetValue();
+ if (dest_pos.IsConstant()) {
+ int32_t dest_pos_constant = dest_pos.GetConstant()->AsIntConstant()->GetValue();
+ if (optimizations.GetDestinationIsSource()) {
+ // Checked when building locations.
+ DCHECK_GE(src_pos_constant, dest_pos_constant);
+ } else if (src_pos_constant < dest_pos_constant) {
+ __ cmpl(src, dest);
+ __ j(kEqual, slow_path->GetEntryLabel());
+ }
+ } else {
+ if (!optimizations.GetDestinationIsSource()) {
+ __ cmpl(src, dest);
+ __ j(kNotEqual, &conditions_on_positions_validated);
+ }
+ __ cmpl(dest_pos.AsRegister<Register>(), Immediate(src_pos_constant));
+ __ j(kGreater, slow_path->GetEntryLabel());
+ }
+ } else {
+ if (!optimizations.GetDestinationIsSource()) {
+ __ cmpl(src, dest);
+ __ j(kNotEqual, &conditions_on_positions_validated);
+ }
+ if (dest_pos.IsConstant()) {
+ int32_t dest_pos_constant = dest_pos.GetConstant()->AsIntConstant()->GetValue();
+ __ cmpl(src_pos.AsRegister<Register>(), Immediate(dest_pos_constant));
+ __ j(kLess, slow_path->GetEntryLabel());
+ } else {
+ __ cmpl(src_pos.AsRegister<Register>(), dest_pos.AsRegister<Register>());
+ __ j(kLess, slow_path->GetEntryLabel());
+ }
+ }
+
+ __ Bind(&conditions_on_positions_validated);
+
+ if (!optimizations.GetSourceIsNotNull()) {
+ // Bail out if the source is null.
+ __ testl(src, src);
+ __ j(kEqual, slow_path->GetEntryLabel());
+ }
+
+ if (!optimizations.GetDestinationIsNotNull() && !optimizations.GetDestinationIsSource()) {
+ // Bail out if the destination is null.
+ __ testl(dest, dest);
+ __ j(kEqual, slow_path->GetEntryLabel());
+ }
+
+ Register temp3 = locations->GetTemp(2).AsRegister<Register>();
+ if (length.IsStackSlot()) {
+ __ movl(temp3, Address(ESP, length.GetStackIndex()));
+ length = Location::RegisterLocation(temp3);
+ }
+
+ // If the length is negative, bail out.
+ // We have already checked in the LocationsBuilder for the constant case.
+ if (!length.IsConstant() &&
+ !optimizations.GetCountIsSourceLength() &&
+ !optimizations.GetCountIsDestinationLength()) {
+ __ testl(length.AsRegister<Register>(), length.AsRegister<Register>());
+ __ j(kLess, slow_path->GetEntryLabel());
+ }
+
+ // Validity checks: source.
+ CheckPosition(assembler,
+ src_pos,
+ src,
+ length,
+ slow_path,
+ temp1,
+ optimizations.GetCountIsSourceLength());
+
+ // Validity checks: dest.
+ CheckPosition(assembler,
+ dest_pos,
+ dest,
+ length,
+ slow_path,
+ temp1,
+ optimizations.GetCountIsDestinationLength());
+
+ if (!optimizations.GetDoesNotNeedTypeCheck()) {
+ // Check whether all elements of the source array are assignable to the component
+ // type of the destination array. We do two checks: the classes are the same,
+ // or the destination is Object[]. If none of these checks succeed, we go to the
+ // slow path.
+ if (!optimizations.GetSourceIsNonPrimitiveArray()) {
+ // /* HeapReference<Class> */ temp1 = temp1->klass_
+ __ movl(temp1, Address(src, class_offset));
+ __ MaybeUnpoisonHeapReference(temp1);
+ // Bail out if the source is not a non primitive array.
+ // /* HeapReference<Class> */ temp1 = temp1->component_type_
+ __ movl(temp1, Address(temp1, component_offset));
+ __ testl(temp1, temp1);
+ __ j(kEqual, slow_path->GetEntryLabel());
+ __ MaybeUnpoisonHeapReference(temp1);
+ __ cmpw(Address(temp1, primitive_offset), Immediate(Primitive::kPrimNot));
+ __ j(kNotEqual, slow_path->GetEntryLabel());
+ }
+
+ if (!optimizations.GetDestinationIsNonPrimitiveArray()) {
+ // /* HeapReference<Class> */ temp1 = temp1->klass_
+ __ movl(temp1, Address(dest, class_offset));
+ __ MaybeUnpoisonHeapReference(temp1);
+ // Bail out if the destination is not a non primitive array.
+ // /* HeapReference<Class> */ temp2 = temp1->component_type_
+ __ movl(temp2, Address(temp1, component_offset));
+ __ testl(temp2, temp2);
+ __ j(kEqual, slow_path->GetEntryLabel());
+ __ MaybeUnpoisonHeapReference(temp2);
+ __ cmpw(Address(temp2, primitive_offset), Immediate(Primitive::kPrimNot));
+ __ j(kNotEqual, slow_path->GetEntryLabel());
+ // Re-poison the heap reference to make the compare instruction below
+ // compare two poisoned references.
+ __ PoisonHeapReference(temp1);
+ } else {
+ // /* HeapReference<Class> */ temp1 = temp1->klass_
+ __ movl(temp1, Address(dest, class_offset));
+ }
+
+ // Note: if poisoning is on, we are here comparing two poisoned references.
+ __ cmpl(temp1, Address(src, class_offset));
+
+ if (optimizations.GetDestinationIsTypedObjectArray()) {
+ NearLabel do_copy;
+ __ j(kEqual, &do_copy);
+ __ MaybeUnpoisonHeapReference(temp1);
+ // /* HeapReference<Class> */ temp1 = temp1->component_type_
+ __ movl(temp1, Address(temp1, component_offset));
+ __ MaybeUnpoisonHeapReference(temp1);
+ __ cmpl(Address(temp1, super_offset), Immediate(0));
+ __ j(kNotEqual, slow_path->GetEntryLabel());
+ __ Bind(&do_copy);
+ } else {
+ __ j(kNotEqual, slow_path->GetEntryLabel());
+ }
+ } else if (!optimizations.GetSourceIsNonPrimitiveArray()) {
+ DCHECK(optimizations.GetDestinationIsNonPrimitiveArray());
+ // Bail out if the source is not a non primitive array.
+ // /* HeapReference<Class> */ temp1 = src->klass_
+ __ movl(temp1, Address(src, class_offset));
+ __ MaybeUnpoisonHeapReference(temp1);
+ // /* HeapReference<Class> */ temp1 = temp1->component_type_
+ __ movl(temp1, Address(temp1, component_offset));
+ __ testl(temp1, temp1);
+ __ j(kEqual, slow_path->GetEntryLabel());
+ __ MaybeUnpoisonHeapReference(temp1);
+ __ cmpw(Address(temp1, primitive_offset), Immediate(Primitive::kPrimNot));
+ __ j(kNotEqual, slow_path->GetEntryLabel());
+ }
+
+ // Compute base source address, base destination address, and end source address.
+ int32_t element_size = Primitive::ComponentSize(Primitive::kPrimNot);
+ DCHECK_EQ(element_size, 4);
+ uint32_t offset = mirror::Array::DataOffset(element_size).Uint32Value();
+ if (src_pos.IsConstant()) {
+ int32_t constant = src_pos.GetConstant()->AsIntConstant()->GetValue();
+ __ leal(temp1, Address(src, element_size * constant + offset));
+ } else {
+ __ leal(temp1, Address(src, src_pos.AsRegister<Register>(), ScaleFactor::TIMES_4, offset));
+ }
+
+ if (dest_pos.IsConstant()) {
+ int32_t constant = dest_pos.GetConstant()->AsIntConstant()->GetValue();
+ __ leal(temp2, Address(dest, element_size * constant + offset));
+ } else {
+ __ leal(temp2, Address(dest, dest_pos.AsRegister<Register>(), ScaleFactor::TIMES_4, offset));
+ }
+
+ if (length.IsConstant()) {
+ int32_t constant = length.GetConstant()->AsIntConstant()->GetValue();
+ __ leal(temp3, Address(temp1, element_size * constant));
+ } else {
+ __ leal(temp3, Address(temp1, length.AsRegister<Register>(), ScaleFactor::TIMES_4, 0));
+ }
+
+ // Iterate over the arrays and do a raw copy of the objects. We don't need to
+ // poison/unpoison.
+ NearLabel loop, done;
+ __ cmpl(temp1, temp3);
+ __ j(kEqual, &done);
+ __ Bind(&loop);
+ __ pushl(Address(temp1, 0));
+ __ cfi().AdjustCFAOffset(4);
+ __ popl(Address(temp2, 0));
+ __ cfi().AdjustCFAOffset(-4);
+ __ addl(temp1, Immediate(element_size));
+ __ addl(temp2, Immediate(element_size));
+ __ cmpl(temp1, temp3);
+ __ j(kNotEqual, &loop);
+ __ Bind(&done);
+
+ // We only need one card marking on the destination array.
+ codegen_->MarkGCCard(temp1,
+ temp2,
+ dest,
+ Register(kNoRegister),
+ /* value_can_be_null */ false);
+
+ __ Bind(slow_path->GetExitLabel());
+}
+
UNIMPLEMENTED_INTRINSIC(X86, MathRoundDouble)
-UNIMPLEMENTED_INTRINSIC(X86, SystemArrayCopy)
UNIMPLEMENTED_INTRINSIC(X86, FloatIsInfinite)
UNIMPLEMENTED_INTRINSIC(X86, DoubleIsInfinite)
UNIMPLEMENTED_INTRINSIC(X86, IntegerHighestOneBit)
diff --git a/compiler/optimizing/intrinsics_x86_64.cc b/compiler/optimizing/intrinsics_x86_64.cc
index c5b44d4..891aaf5 100644
--- a/compiler/optimizing/intrinsics_x86_64.cc
+++ b/compiler/optimizing/intrinsics_x86_64.cc
@@ -922,7 +922,6 @@
CpuRegister input,
Location length,
SlowPathCode* slow_path,
- CpuRegister input_len,
CpuRegister temp,
bool length_is_input_length = false) {
// Where is the length in the Array?
@@ -943,12 +942,11 @@
}
} else {
// Check that length(input) >= pos.
- __ movl(input_len, Address(input, length_offset));
- __ cmpl(input_len, Immediate(pos_const));
+ __ movl(temp, Address(input, length_offset));
+ __ subl(temp, Immediate(pos_const));
__ j(kLess, slow_path->GetEntryLabel());
// Check that (length(input) - pos) >= length.
- __ leal(temp, Address(input_len, -pos_const));
if (length.IsConstant()) {
__ cmpl(temp, Immediate(length.GetConstant()->AsIntConstant()->GetValue()));
} else {
@@ -1023,11 +1021,11 @@
__ j(kLess, slow_path->GetEntryLabel());
}
- // Validity checks: source.
- CheckPosition(assembler, src_pos, src, length, slow_path, src_base, dest_base);
+ // Validity checks: source. Use src_base as a temporary register.
+ CheckPosition(assembler, src_pos, src, length, slow_path, src_base);
- // Validity checks: dest.
- CheckPosition(assembler, dest_pos, dest, length, slow_path, src_base, dest_base);
+ // Validity checks: dest. Use src_base as a temporary register.
+ CheckPosition(assembler, dest_pos, dest, length, slow_path, src_base);
// We need the count in RCX.
if (length.IsConstant()) {
@@ -1103,20 +1101,22 @@
NearLabel conditions_on_positions_validated;
SystemArrayCopyOptimizations optimizations(invoke);
- if (!optimizations.GetDestinationIsSource() &&
- (!src_pos.IsConstant() || !dest_pos.IsConstant())) {
- __ cmpl(src, dest);
- }
// If source and destination are the same, we go to slow path if we need to do
// forward copying.
if (src_pos.IsConstant()) {
int32_t src_pos_constant = src_pos.GetConstant()->AsIntConstant()->GetValue();
if (dest_pos.IsConstant()) {
- // Checked when building locations.
- DCHECK(!optimizations.GetDestinationIsSource()
- || (src_pos_constant >= dest_pos.GetConstant()->AsIntConstant()->GetValue()));
+ int32_t dest_pos_constant = dest_pos.GetConstant()->AsIntConstant()->GetValue();
+ if (optimizations.GetDestinationIsSource()) {
+ // Checked when building locations.
+ DCHECK_GE(src_pos_constant, dest_pos_constant);
+ } else if (src_pos_constant < dest_pos_constant) {
+ __ cmpl(src, dest);
+ __ j(kEqual, slow_path->GetEntryLabel());
+ }
} else {
if (!optimizations.GetDestinationIsSource()) {
+ __ cmpl(src, dest);
__ j(kNotEqual, &conditions_on_positions_validated);
}
__ cmpl(dest_pos.AsRegister<CpuRegister>(), Immediate(src_pos_constant));
@@ -1124,6 +1124,7 @@
}
} else {
if (!optimizations.GetDestinationIsSource()) {
+ __ cmpl(src, dest);
__ j(kNotEqual, &conditions_on_positions_validated);
}
if (dest_pos.IsConstant()) {
@@ -1166,7 +1167,6 @@
length,
slow_path,
temp1,
- temp2,
optimizations.GetCountIsSourceLength());
// Validity checks: dest.
@@ -1176,7 +1176,6 @@
length,
slow_path,
temp1,
- temp2,
optimizations.GetCountIsDestinationLength());
if (!optimizations.GetDoesNotNeedTypeCheck()) {
@@ -1255,7 +1254,7 @@
// Compute base source address, base destination address, and end source address.
- uint32_t element_size = sizeof(int32_t);
+ int32_t element_size = Primitive::ComponentSize(Primitive::kPrimNot);
uint32_t offset = mirror::Array::DataOffset(element_size).Uint32Value();
if (src_pos.IsConstant()) {
int32_t constant = src_pos.GetConstant()->AsIntConstant()->GetValue();
@@ -1279,8 +1278,7 @@
}
// Iterate over the arrays and do a raw copy of the objects. We don't need to
- // poison/unpoison, nor do any read barrier as the next uses of the destination
- // array will do it.
+ // poison/unpoison.
NearLabel loop, done;
__ cmpl(temp1, temp3);
__ j(kEqual, &done);
diff --git a/compiler/optimizing/nodes.cc b/compiler/optimizing/nodes.cc
index c2c212b..d557f42 100644
--- a/compiler/optimizing/nodes.cc
+++ b/compiler/optimizing/nodes.cc
@@ -754,7 +754,7 @@
}
static void UpdateInputsUsers(HInstruction* instruction) {
- auto&& inputs = instruction->GetInputs();
+ HInputsRef inputs = instruction->GetInputs();
for (size_t i = 0; i < inputs.size(); ++i) {
inputs[i]->AddUseAt(instruction, i);
}
@@ -1312,8 +1312,8 @@
DCHECK_EQ(GetKind(), other->GetKind());
if (!InstructionDataEquals(other)) return false;
if (GetType() != other->GetType()) return false;
- auto&& inputs = GetInputs();
- auto&& other_inputs = other->GetInputs();
+ HConstInputsRef inputs = GetInputs();
+ HConstInputsRef other_inputs = other->GetInputs();
if (inputs.size() != other_inputs.size()) return false;
for (size_t i = 0; i != inputs.size(); ++i) {
if (inputs[i] != other_inputs[i]) return false;
diff --git a/compiler/optimizing/nodes.h b/compiler/optimizing/nodes.h
index 6b2c33e..0f0ef26 100644
--- a/compiler/optimizing/nodes.h
+++ b/compiler/optimizing/nodes.h
@@ -1307,7 +1307,13 @@
M(Arm64IntermediateAddress, Instruction)
#endif
+#ifndef ART_ENABLE_CODEGEN_mips
#define FOR_EACH_CONCRETE_INSTRUCTION_MIPS(M)
+#else
+#define FOR_EACH_CONCRETE_INSTRUCTION_MIPS(M) \
+ M(MipsComputeBaseMethodAddress, Instruction) \
+ M(MipsDexCacheArraysBase, Instruction)
+#endif
#define FOR_EACH_CONCRETE_INSTRUCTION_MIPS64(M)
@@ -1415,6 +1421,21 @@
typename HUseList<T>::iterator before_use_node_;
};
+// Helper class that extracts the input instruction from HUserRecord<HInstruction*>.
+// This is used for HInstruction::GetInputs() to return a container wrapper providing
+// HInstruction* values even though the underlying container has HUserRecord<>s.
+struct HInputExtractor {
+ HInstruction* operator()(HUserRecord<HInstruction*>& record) const {
+ return record.GetInstruction();
+ }
+ const HInstruction* operator()(const HUserRecord<HInstruction*>& record) const {
+ return record.GetInstruction();
+ }
+};
+
+using HInputsRef = TransformArrayRef<HUserRecord<HInstruction*>, HInputExtractor>;
+using HConstInputsRef = TransformArrayRef<const HUserRecord<HInstruction*>, HInputExtractor>;
+
/**
* Side-effects representation.
*
@@ -1804,20 +1825,12 @@
const_cast<HInstruction*>(this)->GetInputRecords());
}
- auto GetInputs() {
- return MakeTransformArrayRef(
- GetInputRecords(),
- [](HUserRecord<HInstruction*>& record) -> HInstruction* {
- return record.GetInstruction();
- });
+ HInputsRef GetInputs() {
+ return MakeTransformArrayRef(GetInputRecords(), HInputExtractor());
}
- auto GetInputs() const {
- return MakeTransformArrayRef(
- GetInputRecords(),
- [](const HUserRecord<HInstruction*>& record) -> const HInstruction* {
- return record.GetInstruction();
- });
+ HConstInputsRef GetInputs() const {
+ return MakeTransformArrayRef(GetInputRecords(), HInputExtractor());
}
size_t InputCount() const { return GetInputRecords().size(); }
@@ -2408,7 +2421,7 @@
bool IsDead() const { return !IsLive(); }
bool IsLive() const { return GetPackedFlag<kFlagIsLive>(); }
- bool IsVRegEquivalentOf(HInstruction* other) const {
+ bool IsVRegEquivalentOf(const HInstruction* other) const {
return other != nullptr
&& other->IsPhi()
&& other->AsPhi()->GetBlock() == GetBlock()
@@ -3160,7 +3173,7 @@
}
private:
- template <typename T> bool Compute(T x, T y) const { return x == y; }
+ template <typename T> static bool Compute(T x, T y) { return x == y; }
DISALLOW_COPY_AND_ASSIGN(HEqual);
};
@@ -3203,7 +3216,7 @@
}
private:
- template <typename T> bool Compute(T x, T y) const { return x != y; }
+ template <typename T> static bool Compute(T x, T y) { return x != y; }
DISALLOW_COPY_AND_ASSIGN(HNotEqual);
};
@@ -3240,7 +3253,7 @@
}
private:
- template <typename T> bool Compute(T x, T y) const { return x < y; }
+ template <typename T> static bool Compute(T x, T y) { return x < y; }
DISALLOW_COPY_AND_ASSIGN(HLessThan);
};
@@ -3277,7 +3290,7 @@
}
private:
- template <typename T> bool Compute(T x, T y) const { return x <= y; }
+ template <typename T> static bool Compute(T x, T y) { return x <= y; }
DISALLOW_COPY_AND_ASSIGN(HLessThanOrEqual);
};
@@ -3314,7 +3327,7 @@
}
private:
- template <typename T> bool Compute(T x, T y) const { return x > y; }
+ template <typename T> static bool Compute(T x, T y) { return x > y; }
DISALLOW_COPY_AND_ASSIGN(HGreaterThan);
};
@@ -3351,7 +3364,7 @@
}
private:
- template <typename T> bool Compute(T x, T y) const { return x >= y; }
+ template <typename T> static bool Compute(T x, T y) { return x >= y; }
DISALLOW_COPY_AND_ASSIGN(HGreaterThanOrEqual);
};
@@ -3389,7 +3402,7 @@
}
private:
- template <typename T> bool Compute(T x, T y) const {
+ template <typename T> static bool Compute(T x, T y) {
return MakeUnsigned(x) < MakeUnsigned(y);
}
@@ -3429,7 +3442,7 @@
}
private:
- template <typename T> bool Compute(T x, T y) const {
+ template <typename T> static bool Compute(T x, T y) {
return MakeUnsigned(x) <= MakeUnsigned(y);
}
@@ -3469,7 +3482,7 @@
}
private:
- template <typename T> bool Compute(T x, T y) const {
+ template <typename T> static bool Compute(T x, T y) {
return MakeUnsigned(x) > MakeUnsigned(y);
}
@@ -3509,7 +3522,7 @@
}
private:
- template <typename T> bool Compute(T x, T y) const {
+ template <typename T> static bool Compute(T x, T y) {
return MakeUnsigned(x) >= MakeUnsigned(y);
}
@@ -4182,7 +4195,7 @@
DCHECK_EQ(result_type, Primitive::PrimitiveKind(input->GetType()));
}
- template <typename T> T Compute(T x) const { return -x; }
+ template <typename T> static T Compute(T x) { return -x; }
HConstant* Evaluate(HIntConstant* x) const OVERRIDE {
return GetBlock()->GetGraph()->GetIntConstant(Compute(x->GetValue()), GetDexPc());
@@ -4252,7 +4265,7 @@
bool IsCommutative() const OVERRIDE { return true; }
- template <typename T> T Compute(T x, T y) const { return x + y; }
+ template <typename T> static T Compute(T x, T y) { return x + y; }
HConstant* Evaluate(HIntConstant* x, HIntConstant* y) const OVERRIDE {
return GetBlock()->GetGraph()->GetIntConstant(
@@ -4285,7 +4298,7 @@
uint32_t dex_pc = kNoDexPc)
: HBinaryOperation(result_type, left, right, SideEffects::None(), dex_pc) {}
- template <typename T> T Compute(T x, T y) const { return x - y; }
+ template <typename T> static T Compute(T x, T y) { return x - y; }
HConstant* Evaluate(HIntConstant* x, HIntConstant* y) const OVERRIDE {
return GetBlock()->GetGraph()->GetIntConstant(
@@ -4320,7 +4333,7 @@
bool IsCommutative() const OVERRIDE { return true; }
- template <typename T> T Compute(T x, T y) const { return x * y; }
+ template <typename T> static T Compute(T x, T y) { return x * y; }
HConstant* Evaluate(HIntConstant* x, HIntConstant* y) const OVERRIDE {
return GetBlock()->GetGraph()->GetIntConstant(
@@ -4486,7 +4499,7 @@
}
template <typename T>
- T Compute(T value, int32_t distance, int32_t max_shift_distance) const {
+ static T Compute(T value, int32_t distance, int32_t max_shift_distance) {
return value << (distance & max_shift_distance);
}
@@ -4532,7 +4545,7 @@
}
template <typename T>
- T Compute(T value, int32_t distance, int32_t max_shift_distance) const {
+ static T Compute(T value, int32_t distance, int32_t max_shift_distance) {
return value >> (distance & max_shift_distance);
}
@@ -4578,7 +4591,7 @@
}
template <typename T>
- T Compute(T value, int32_t distance, int32_t max_shift_distance) const {
+ static T Compute(T value, int32_t distance, int32_t max_shift_distance) {
typedef typename std::make_unsigned<T>::type V;
V ux = static_cast<V>(value);
return static_cast<T>(ux >> (distance & max_shift_distance));
@@ -4624,7 +4637,7 @@
bool IsCommutative() const OVERRIDE { return true; }
- template <typename T> T Compute(T x, T y) const { return x & y; }
+ template <typename T> static T Compute(T x, T y) { return x & y; }
HConstant* Evaluate(HIntConstant* x, HIntConstant* y) const OVERRIDE {
return GetBlock()->GetGraph()->GetIntConstant(
@@ -4661,7 +4674,7 @@
bool IsCommutative() const OVERRIDE { return true; }
- template <typename T> T Compute(T x, T y) const { return x | y; }
+ template <typename T> static T Compute(T x, T y) { return x | y; }
HConstant* Evaluate(HIntConstant* x, HIntConstant* y) const OVERRIDE {
return GetBlock()->GetGraph()->GetIntConstant(
@@ -4698,7 +4711,7 @@
bool IsCommutative() const OVERRIDE { return true; }
- template <typename T> T Compute(T x, T y) const { return x ^ y; }
+ template <typename T> static T Compute(T x, T y) { return x ^ y; }
HConstant* Evaluate(HIntConstant* x, HIntConstant* y) const OVERRIDE {
return GetBlock()->GetGraph()->GetIntConstant(
@@ -4734,7 +4747,7 @@
}
template <typename T>
- T Compute(T value, int32_t distance, int32_t max_shift_value) const {
+ static T Compute(T value, int32_t distance, int32_t max_shift_value) {
typedef typename std::make_unsigned<T>::type V;
V ux = static_cast<V>(value);
if ((distance & max_shift_value) == 0) {
@@ -4830,7 +4843,7 @@
return true;
}
- template <typename T> T Compute(T x) const { return ~x; }
+ template <typename T> static T Compute(T x) { return ~x; }
HConstant* Evaluate(HIntConstant* x) const OVERRIDE {
return GetBlock()->GetGraph()->GetIntConstant(Compute(x->GetValue()), GetDexPc());
@@ -4863,7 +4876,7 @@
return true;
}
- template <typename T> bool Compute(T x) const {
+ template <typename T> static bool Compute(T x) {
DCHECK(IsUint<1>(x)) << x;
return !x;
}
@@ -6544,6 +6557,9 @@
#ifdef ART_ENABLE_CODEGEN_arm64
#include "nodes_arm64.h"
#endif
+#ifdef ART_ENABLE_CODEGEN_mips
+#include "nodes_mips.h"
+#endif
#ifdef ART_ENABLE_CODEGEN_x86
#include "nodes_x86.h"
#endif
diff --git a/compiler/optimizing/nodes_mips.h b/compiler/optimizing/nodes_mips.h
new file mode 100644
index 0000000..de77245
--- /dev/null
+++ b/compiler/optimizing/nodes_mips.h
@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ART_COMPILER_OPTIMIZING_NODES_MIPS_H_
+#define ART_COMPILER_OPTIMIZING_NODES_MIPS_H_
+
+namespace art {
+
+// Compute the address of the method for MIPS Constant area support.
+class HMipsComputeBaseMethodAddress : public HExpression<0> {
+ public:
+ // Treat the value as an int32_t, but it is really a 32 bit native pointer.
+ HMipsComputeBaseMethodAddress()
+ : HExpression(Primitive::kPrimInt, SideEffects::None(), kNoDexPc) {}
+
+ bool CanBeMoved() const OVERRIDE { return true; }
+
+ DECLARE_INSTRUCTION(MipsComputeBaseMethodAddress);
+
+ private:
+ DISALLOW_COPY_AND_ASSIGN(HMipsComputeBaseMethodAddress);
+};
+
+class HMipsDexCacheArraysBase : public HExpression<0> {
+ public:
+ explicit HMipsDexCacheArraysBase(const DexFile& dex_file)
+ : HExpression(Primitive::kPrimInt, SideEffects::None(), kNoDexPc),
+ dex_file_(&dex_file),
+ element_offset_(static_cast<size_t>(-1)) { }
+
+ bool CanBeMoved() const OVERRIDE { return true; }
+
+ void UpdateElementOffset(size_t element_offset) {
+ // We'll maximize the range of a single load instruction for dex cache array accesses
+ // by aligning offset -32768 with the offset of the first used element.
+ element_offset_ = std::min(element_offset_, element_offset);
+ }
+
+ const DexFile& GetDexFile() const {
+ return *dex_file_;
+ }
+
+ size_t GetElementOffset() const {
+ return element_offset_;
+ }
+
+ DECLARE_INSTRUCTION(MipsDexCacheArraysBase);
+
+ private:
+ const DexFile* dex_file_;
+ size_t element_offset_;
+
+ DISALLOW_COPY_AND_ASSIGN(HMipsDexCacheArraysBase);
+};
+
+} // namespace art
+
+#endif // ART_COMPILER_OPTIMIZING_NODES_MIPS_H_
diff --git a/compiler/optimizing/optimizing_compiler.cc b/compiler/optimizing/optimizing_compiler.cc
index c9a4bfe..d703b0f 100644
--- a/compiler/optimizing/optimizing_compiler.cc
+++ b/compiler/optimizing/optimizing_compiler.cc
@@ -28,6 +28,11 @@
#include "instruction_simplifier_arm64.h"
#endif
+#ifdef ART_ENABLE_CODEGEN_mips
+#include "dex_cache_array_fixups_mips.h"
+#include "pc_relative_fixups_mips.h"
+#endif
+
#ifdef ART_ENABLE_CODEGEN_x86
#include "pc_relative_fixups_x86.h"
#endif
@@ -462,6 +467,20 @@
break;
}
#endif
+#ifdef ART_ENABLE_CODEGEN_mips
+ case kMips: {
+ mips::PcRelativeFixups* pc_relative_fixups =
+ new (arena) mips::PcRelativeFixups(graph, codegen, stats);
+ mips::DexCacheArrayFixups* dex_cache_array_fixups =
+ new (arena) mips::DexCacheArrayFixups(graph, stats);
+ HOptimization* mips_optimizations[] = {
+ pc_relative_fixups,
+ dex_cache_array_fixups
+ };
+ RunOptimizations(mips_optimizations, arraysize(mips_optimizations), pass_observer);
+ break;
+ }
+#endif
#ifdef ART_ENABLE_CODEGEN_x86
case kX86: {
x86::PcRelativeFixups* pc_relative_fixups =
diff --git a/compiler/optimizing/pc_relative_fixups_mips.cc b/compiler/optimizing/pc_relative_fixups_mips.cc
new file mode 100644
index 0000000..ba405cd
--- /dev/null
+++ b/compiler/optimizing/pc_relative_fixups_mips.cc
@@ -0,0 +1,133 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "pc_relative_fixups_mips.h"
+#include "code_generator_mips.h"
+#include "intrinsics_mips.h"
+
+namespace art {
+namespace mips {
+
+/**
+ * Finds instructions that need the constant area base as an input.
+ */
+class PCRelativeHandlerVisitor : public HGraphVisitor {
+ public:
+ PCRelativeHandlerVisitor(HGraph* graph, CodeGenerator* codegen)
+ : HGraphVisitor(graph),
+ codegen_(down_cast<CodeGeneratorMIPS*>(codegen)),
+ base_(nullptr) {}
+
+ void MoveBaseIfNeeded() {
+ if (base_ != nullptr) {
+ // Bring the base closer to the first use (previously, it was in the
+ // entry block) and relieve some pressure on the register allocator
+ // while avoiding recalculation of the base in a loop.
+ base_->MoveBeforeFirstUserAndOutOfLoops();
+ }
+ }
+
+ private:
+ void VisitInvokeStaticOrDirect(HInvokeStaticOrDirect* invoke) OVERRIDE {
+ HandleInvoke(invoke);
+ }
+
+ void InitializePCRelativeBasePointer() {
+ // Ensure we only initialize the pointer once.
+ if (base_ != nullptr) {
+ return;
+ }
+ // Insert the base at the start of the entry block, move it to a better
+ // position later in MoveBaseIfNeeded().
+ base_ = new (GetGraph()->GetArena()) HMipsComputeBaseMethodAddress();
+ HBasicBlock* entry_block = GetGraph()->GetEntryBlock();
+ entry_block->InsertInstructionBefore(base_, entry_block->GetFirstInstruction());
+ DCHECK(base_ != nullptr);
+ }
+
+ void HandleInvoke(HInvoke* invoke) {
+ // If this is an invoke-static/-direct with PC-relative dex cache array
+ // addressing, we need the PC-relative address base.
+ HInvokeStaticOrDirect* invoke_static_or_direct = invoke->AsInvokeStaticOrDirect();
+ if (invoke_static_or_direct != nullptr) {
+ HInvokeStaticOrDirect::MethodLoadKind method_load_kind =
+ invoke_static_or_direct->GetMethodLoadKind();
+ HInvokeStaticOrDirect::CodePtrLocation code_ptr_location =
+ invoke_static_or_direct->GetCodePtrLocation();
+
+ bool has_extra_input =
+ (method_load_kind == HInvokeStaticOrDirect::MethodLoadKind::kDirectAddressWithFixup) ||
+ (code_ptr_location == HInvokeStaticOrDirect::CodePtrLocation::kCallDirectWithFixup);
+
+ // We can't add a pointer to the constant area if we already have a current
+ // method pointer. This may arise when sharpening doesn't remove the current
+ // method pointer from the invoke.
+ if (invoke_static_or_direct->HasCurrentMethodInput()) {
+ DCHECK(!invoke_static_or_direct->HasPcRelativeDexCache());
+ CHECK(!has_extra_input); // TODO: review this.
+ return;
+ }
+
+ if (has_extra_input && !WillHaveCallFreeIntrinsicsCodeGen(invoke)) {
+ InitializePCRelativeBasePointer();
+ // Add the extra parameter base_.
+ invoke_static_or_direct->AddSpecialInput(base_);
+ }
+ }
+ }
+
+ bool WillHaveCallFreeIntrinsicsCodeGen(HInvoke* invoke) {
+ if (invoke->GetIntrinsic() != Intrinsics::kNone) {
+ // This invoke may have intrinsic code generation defined. However, we must
+ // now also determine if this code generation is truly there and call-free
+ // (not unimplemented, no bail on instruction features, or call on slow path).
+ // This is done by actually calling the locations builder on the instruction
+ // and clearing out the locations once result is known. We assume this
+ // call only has creating locations as side effects!
+ IntrinsicLocationsBuilderMIPS builder(codegen_);
+ bool success = builder.TryDispatch(invoke) && !invoke->GetLocations()->CanCall();
+ invoke->SetLocations(nullptr);
+ return success;
+ }
+ return false;
+ }
+
+ CodeGeneratorMIPS* codegen_;
+
+ // The generated HMipsComputeBaseMethodAddress in the entry block needed as an
+ // input to the HMipsLoadFromConstantTable instructions.
+ HMipsComputeBaseMethodAddress* base_;
+};
+
+void PcRelativeFixups::Run() {
+ CodeGeneratorMIPS* mips_codegen = down_cast<CodeGeneratorMIPS*>(codegen_);
+ if (mips_codegen->GetInstructionSetFeatures().IsR6()) {
+ // Do nothing for R6 because it has PC-relative addressing.
+ // TODO: review. Move this check into RunArchOptimizations()?
+ return;
+ }
+ if (graph_->HasIrreducibleLoops()) {
+ // Do not run this optimization, as irreducible loops do not work with an instruction
+ // that can be live-in at the irreducible loop header.
+ return;
+ }
+ PCRelativeHandlerVisitor visitor(graph_, codegen_);
+ visitor.VisitInsertionOrder();
+ visitor.MoveBaseIfNeeded();
+}
+
+} // namespace mips
+} // namespace art
diff --git a/compiler/optimizing/pc_relative_fixups_mips.h b/compiler/optimizing/pc_relative_fixups_mips.h
new file mode 100644
index 0000000..1e8b071
--- /dev/null
+++ b/compiler/optimizing/pc_relative_fixups_mips.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ART_COMPILER_OPTIMIZING_PC_RELATIVE_FIXUPS_MIPS_H_
+#define ART_COMPILER_OPTIMIZING_PC_RELATIVE_FIXUPS_MIPS_H_
+
+#include "nodes.h"
+#include "optimization.h"
+
+namespace art {
+
+class CodeGenerator;
+
+namespace mips {
+
+class PcRelativeFixups : public HOptimization {
+ public:
+ PcRelativeFixups(HGraph* graph, CodeGenerator* codegen, OptimizingCompilerStats* stats)
+ : HOptimization(graph, "pc_relative_fixups_mips", stats),
+ codegen_(codegen) {}
+
+ void Run() OVERRIDE;
+
+ private:
+ CodeGenerator* codegen_;
+};
+
+} // namespace mips
+} // namespace art
+
+#endif // ART_COMPILER_OPTIMIZING_PC_RELATIVE_FIXUPS_MIPS_H_
diff --git a/compiler/optimizing/pc_relative_fixups_x86.cc b/compiler/optimizing/pc_relative_fixups_x86.cc
index 93116f8..921f3df 100644
--- a/compiler/optimizing/pc_relative_fixups_x86.cc
+++ b/compiler/optimizing/pc_relative_fixups_x86.cc
@@ -211,7 +211,7 @@
}
// Ensure that we can load FP arguments from the constant area.
- auto&& inputs = invoke->GetInputs();
+ HInputsRef inputs = invoke->GetInputs();
for (size_t i = 0; i < inputs.size(); i++) {
HConstant* input = inputs[i]->AsConstant();
if (input != nullptr && Primitive::IsFloatingPointType(input->GetType())) {
diff --git a/compiler/optimizing/pretty_printer.h b/compiler/optimizing/pretty_printer.h
index f9bef68..5891350 100644
--- a/compiler/optimizing/pretty_printer.h
+++ b/compiler/optimizing/pretty_printer.h
@@ -39,7 +39,7 @@
}
void PrintPostInstruction(HInstruction* instruction) {
- auto&& inputs = instruction->GetInputs();
+ HConstInputsRef inputs = instruction->GetInputs();
if (!inputs.empty()) {
PrintString("(");
bool first = true;
diff --git a/compiler/optimizing/reference_type_propagation.cc b/compiler/optimizing/reference_type_propagation.cc
index 3dfd728..965d5ee 100644
--- a/compiler/optimizing/reference_type_propagation.cc
+++ b/compiler/optimizing/reference_type_propagation.cc
@@ -816,10 +816,10 @@
void ReferenceTypePropagation::UpdatePhi(HPhi* instr) {
DCHECK(instr->IsLive());
- auto&& inputs = instr->GetInputs();
+ HInputsRef inputs = instr->GetInputs();
size_t first_input_index_not_null = 0;
while (first_input_index_not_null < inputs.size() &&
- inputs[first_input_index_not_null]->IsNullConstant()) {
+ inputs[first_input_index_not_null]->IsNullConstant()) {
first_input_index_not_null++;
}
if (first_input_index_not_null == inputs.size()) {
diff --git a/compiler/optimizing/register_allocator.cc b/compiler/optimizing/register_allocator.cc
index 4a6b835..9d99668 100644
--- a/compiler/optimizing/register_allocator.cc
+++ b/compiler/optimizing/register_allocator.cc
@@ -753,7 +753,7 @@
if (defined_by != nullptr && !current->IsSplit()) {
LocationSummary* locations = defined_by->GetLocations();
if (!locations->OutputCanOverlapWithInputs() && locations->Out().IsUnallocated()) {
- auto&& inputs = defined_by->GetInputs();
+ HInputsRef inputs = defined_by->GetInputs();
for (size_t i = 0; i < inputs.size(); ++i) {
// Take the last interval of the input. It is the location of that interval
// that will be used at `defined_by`.
diff --git a/compiler/optimizing/ssa_builder.cc b/compiler/optimizing/ssa_builder.cc
index ed50c69..5a574d9 100644
--- a/compiler/optimizing/ssa_builder.cc
+++ b/compiler/optimizing/ssa_builder.cc
@@ -181,7 +181,7 @@
return true;
} else {
DCHECK(common_type == Primitive::kPrimNot || Primitive::IsFloatingPointType(common_type));
- auto&& inputs = phi->GetInputs();
+ HInputsRef inputs = phi->GetInputs();
for (size_t i = 0; i < inputs.size(); ++i) {
HInstruction* input = inputs[i];
if (input->GetType() != common_type) {
@@ -617,7 +617,7 @@
|| (next->AsPhi()->GetRegNumber() != phi->GetRegNumber())
|| (next->GetType() != type)) {
ArenaAllocator* allocator = graph_->GetArena();
- auto&& inputs = phi->GetInputs();
+ HInputsRef inputs = phi->GetInputs();
HPhi* new_phi =
new (allocator) HPhi(allocator, phi->GetRegNumber(), inputs.size(), type);
// Copy the inputs. Note that the graph may not be correctly typed
diff --git a/compiler/optimizing/ssa_liveness_analysis.cc b/compiler/optimizing/ssa_liveness_analysis.cc
index 212d935..7af4302 100644
--- a/compiler/optimizing/ssa_liveness_analysis.cc
+++ b/compiler/optimizing/ssa_liveness_analysis.cc
@@ -177,7 +177,7 @@
static void RecursivelyProcessInputs(HInstruction* current,
HInstruction* actual_user,
BitVector* live_in) {
- auto&& inputs = current->GetInputs();
+ HInputsRef inputs = current->GetInputs();
for (size_t i = 0; i < inputs.size(); ++i) {
HInstruction* input = inputs[i];
bool has_in_location = current->GetLocations()->InAt(i).IsValid();
@@ -431,7 +431,7 @@
// If the instruction dies at the phi assignment, we can try having the
// same register.
if (end == user->GetBlock()->GetPredecessors()[input_index]->GetLifetimeEnd()) {
- auto&& inputs = user->GetInputs();
+ HInputsRef inputs = user->GetInputs();
for (size_t i = 0; i < inputs.size(); ++i) {
if (i == input_index) {
continue;
@@ -472,7 +472,7 @@
if (defined_by_->IsPhi()) {
// Try to use the same register as one of the inputs.
const ArenaVector<HBasicBlock*>& predecessors = defined_by_->GetBlock()->GetPredecessors();
- auto&& inputs = defined_by_->GetInputs();
+ HInputsRef inputs = defined_by_->GetInputs();
for (size_t i = 0; i < inputs.size(); ++i) {
size_t end = predecessors[i]->GetLifetimeEnd();
LiveInterval* input_interval = inputs[i]->GetLiveInterval()->GetSiblingAt(end - 1);
diff --git a/compiler/utils/arm/assembler_arm.h b/compiler/utils/arm/assembler_arm.h
index a571d14..9cf72a2 100644
--- a/compiler/utils/arm/assembler_arm.h
+++ b/compiler/utils/arm/assembler_arm.h
@@ -754,32 +754,7 @@
}
}
- void LoadDImmediate(DRegister sd, double value, Condition cond = AL) {
- if (!vmovd(sd, value, cond)) {
- uint64_t int_value = bit_cast<uint64_t, double>(value);
- if (int_value == bit_cast<uint64_t, double>(0.0)) {
- // 0.0 is quite common, so we special case it by loading
- // 2.0 in `sd` and then substracting it.
- bool success = vmovd(sd, 2.0, cond);
- CHECK(success);
- vsubd(sd, sd, sd, cond);
- } else {
- if (sd < 16) {
- SRegister low = static_cast<SRegister>(sd << 1);
- SRegister high = static_cast<SRegister>(low + 1);
- LoadSImmediate(low, bit_cast<float, uint32_t>(Low32Bits(int_value)), cond);
- if (High32Bits(int_value) == Low32Bits(int_value)) {
- vmovs(high, low);
- } else {
- LoadSImmediate(high, bit_cast<float, uint32_t>(High32Bits(int_value)), cond);
- }
- } else {
- LOG(FATAL) << "Unimplemented loading of double into a D register "
- << "that cannot be split into two S registers";
- }
- }
- }
- }
+ virtual void LoadDImmediate(DRegister dd, double value, Condition cond = AL) = 0;
virtual void MarkExceptionHandler(Label* label) = 0;
virtual void LoadFromOffset(LoadOperandType type,
diff --git a/compiler/utils/arm/assembler_arm32.cc b/compiler/utils/arm/assembler_arm32.cc
index 6f7119d..c95dfa8 100644
--- a/compiler/utils/arm/assembler_arm32.cc
+++ b/compiler/utils/arm/assembler_arm32.cc
@@ -1486,6 +1486,34 @@
}
}
+void Arm32Assembler::LoadDImmediate(DRegister dd, double value, Condition cond) {
+ if (!vmovd(dd, value, cond)) {
+ uint64_t int_value = bit_cast<uint64_t, double>(value);
+ if (int_value == bit_cast<uint64_t, double>(0.0)) {
+ // 0.0 is quite common, so we special case it by loading
+ // 2.0 in `dd` and then subtracting it.
+ bool success = vmovd(dd, 2.0, cond);
+ CHECK(success);
+ vsubd(dd, dd, dd, cond);
+ } else {
+ if (dd < 16) {
+ // Note: Depending on the particular CPU, this may cause register
+ // forwarding hazard, negatively impacting the performance.
+ SRegister low = static_cast<SRegister>(dd << 1);
+ SRegister high = static_cast<SRegister>(low + 1);
+ LoadSImmediate(low, bit_cast<float, uint32_t>(Low32Bits(int_value)), cond);
+ if (High32Bits(int_value) == Low32Bits(int_value)) {
+ vmovs(high, low);
+ } else {
+ LoadSImmediate(high, bit_cast<float, uint32_t>(High32Bits(int_value)), cond);
+ }
+ } else {
+ LOG(FATAL) << "Unimplemented loading of double into a D register "
+ << "that cannot be split into two S registers";
+ }
+ }
+ }
+}
// Implementation note: this method must emit at most one instruction when
// Address::CanHoldLoadOffsetArm.
diff --git a/compiler/utils/arm/assembler_arm32.h b/compiler/utils/arm/assembler_arm32.h
index 8726ac8..554dd23 100644
--- a/compiler/utils/arm/assembler_arm32.h
+++ b/compiler/utils/arm/assembler_arm32.h
@@ -270,6 +270,7 @@
// Load and Store. May clobber IP.
void LoadImmediate(Register rd, int32_t value, Condition cond = AL) OVERRIDE;
+ void LoadDImmediate(DRegister dd, double value, Condition cond = AL) OVERRIDE;
void MarkExceptionHandler(Label* label) OVERRIDE;
void LoadFromOffset(LoadOperandType type,
Register reg,
diff --git a/compiler/utils/arm/assembler_thumb2.cc b/compiler/utils/arm/assembler_thumb2.cc
index a72ea41..8747dad 100644
--- a/compiler/utils/arm/assembler_thumb2.cc
+++ b/compiler/utils/arm/assembler_thumb2.cc
@@ -1917,7 +1917,7 @@
case kLongOrFPLiteral1KiB:
return 4u;
- case kLongOrFPLiteral256KiB:
+ case kLongOrFPLiteral64KiB:
return 10u;
case kLongOrFPLiteralFar:
return 14u;
@@ -1989,7 +1989,7 @@
break;
case kLiteral1MiB:
case kLiteral64KiB:
- case kLongOrFPLiteral256KiB:
+ case kLongOrFPLiteral64KiB:
case kLiteralAddr64KiB:
DCHECK_GE(diff, 4); // The target must be at least 4 bytes after the ADD rX, PC.
diff -= 4; // One extra 32-bit MOV.
@@ -2105,10 +2105,10 @@
if (IsUint<10>(GetOffset(current_code_size))) {
break;
}
- current_code_size += IncreaseSize(kLongOrFPLiteral256KiB);
+ current_code_size += IncreaseSize(kLongOrFPLiteral64KiB);
FALLTHROUGH_INTENDED;
- case kLongOrFPLiteral256KiB:
- if (IsUint<18>(GetOffset(current_code_size))) {
+ case kLongOrFPLiteral64KiB:
+ if (IsUint<16>(GetOffset(current_code_size))) {
break;
}
current_code_size += IncreaseSize(kLongOrFPLiteralFar);
@@ -2269,11 +2269,10 @@
buffer->Store<int16_t>(location_ + 2u, static_cast<int16_t>(encoding & 0xffff));
break;
}
- case kLongOrFPLiteral256KiB: {
- int32_t offset = GetOffset(code_size);
- int32_t mov_encoding = MovModImmEncoding32(IP, offset & ~0x3ff);
+ case kLongOrFPLiteral64KiB: {
+ int32_t mov_encoding = MovwEncoding32(IP, GetOffset(code_size));
int16_t add_pc_encoding = AddRdnRmEncoding16(IP, PC);
- int32_t ldr_encoding = LoadWideOrFpEncoding(IP, offset & 0x3ff); // DCHECKs type_.
+ int32_t ldr_encoding = LoadWideOrFpEncoding(IP, 0u); // DCHECKs type_.
buffer->Store<int16_t>(location_, mov_encoding >> 16);
buffer->Store<int16_t>(location_ + 2u, static_cast<int16_t>(mov_encoding & 0xffff));
buffer->Store<int16_t>(location_ + 4u, add_pc_encoding);
@@ -3598,6 +3597,24 @@
}
}
+void Thumb2Assembler::LoadDImmediate(DRegister dd, double value, Condition cond) {
+ if (!vmovd(dd, value, cond)) {
+ uint64_t int_value = bit_cast<uint64_t, double>(value);
+ if (int_value == bit_cast<uint64_t, double>(0.0)) {
+ // 0.0 is quite common, so we special case it by loading
+ // 2.0 in `dd` and then subtracting it.
+ bool success = vmovd(dd, 2.0, cond);
+ CHECK(success);
+ vsubd(dd, dd, dd, cond);
+ } else {
+ Literal* literal = literal64_dedupe_map_.GetOrCreate(
+ int_value,
+ [this, int_value]() { return NewLiteral<uint64_t>(int_value); });
+ LoadLiteral(dd, literal);
+ }
+ }
+}
+
int32_t Thumb2Assembler::GetAllowedLoadOffsetBits(LoadOperandType type) {
switch (type) {
case kLoadSignedByte:
diff --git a/compiler/utils/arm/assembler_thumb2.h b/compiler/utils/arm/assembler_thumb2.h
index 2ca74fc..4ee23c0 100644
--- a/compiler/utils/arm/assembler_thumb2.h
+++ b/compiler/utils/arm/assembler_thumb2.h
@@ -43,6 +43,7 @@
fixups_(arena->Adapter(kArenaAllocAssembler)),
fixup_dependents_(arena->Adapter(kArenaAllocAssembler)),
literals_(arena->Adapter(kArenaAllocAssembler)),
+ literal64_dedupe_map_(std::less<uint64_t>(), arena->Adapter(kArenaAllocAssembler)),
jump_tables_(arena->Adapter(kArenaAllocAssembler)),
last_position_adjustment_(0u),
last_old_position_(0u),
@@ -319,6 +320,7 @@
// Load and Store. May clobber IP.
void LoadImmediate(Register rd, int32_t value, Condition cond = AL) OVERRIDE;
+ void LoadDImmediate(DRegister dd, double value, Condition cond = AL) OVERRIDE;
void MarkExceptionHandler(Label* label) OVERRIDE;
void LoadFromOffset(LoadOperandType type,
Register reg,
@@ -464,8 +466,8 @@
// Load long or FP literal variants.
// VLDR s/dX, label; 32-bit insn, up to 1KiB offset; 4 bytes.
kLongOrFPLiteral1KiB,
- // MOV ip, modimm + ADD ip, pc + VLDR s/dX, [IP, #imm8*4]; up to 256KiB offset; 10 bytes.
- kLongOrFPLiteral256KiB,
+ // MOV ip, imm16 + ADD ip, pc + VLDR s/dX, [IP, #0]; up to 64KiB offset; 10 bytes.
+ kLongOrFPLiteral64KiB,
// MOV ip, imm16 + MOVT ip, imm16 + ADD ip, pc + VLDR s/dX, [IP]; any offset; 14 bytes.
kLongOrFPLiteralFar,
};
@@ -500,7 +502,7 @@
// Load wide literal.
static Fixup LoadWideLiteral(uint32_t location, Register rt, Register rt2,
Size size = kLongOrFPLiteral1KiB) {
- DCHECK(size == kLongOrFPLiteral1KiB || size == kLongOrFPLiteral256KiB ||
+ DCHECK(size == kLongOrFPLiteral1KiB || size == kLongOrFPLiteral64KiB ||
size == kLongOrFPLiteralFar);
DCHECK(!IsHighRegister(rt) || (size != kLiteral1KiB && size != kLiteral64KiB));
return Fixup(rt, rt2, kNoSRegister, kNoDRegister,
@@ -510,7 +512,7 @@
// Load FP single literal.
static Fixup LoadSingleLiteral(uint32_t location, SRegister sd,
Size size = kLongOrFPLiteral1KiB) {
- DCHECK(size == kLongOrFPLiteral1KiB || size == kLongOrFPLiteral256KiB ||
+ DCHECK(size == kLongOrFPLiteral1KiB || size == kLongOrFPLiteral64KiB ||
size == kLongOrFPLiteralFar);
return Fixup(kNoRegister, kNoRegister, sd, kNoDRegister,
AL, kLoadFPLiteralSingle, size, location);
@@ -519,7 +521,7 @@
// Load FP double literal.
static Fixup LoadDoubleLiteral(uint32_t location, DRegister dd,
Size size = kLongOrFPLiteral1KiB) {
- DCHECK(size == kLongOrFPLiteral1KiB || size == kLongOrFPLiteral256KiB ||
+ DCHECK(size == kLongOrFPLiteral1KiB || size == kLongOrFPLiteral64KiB ||
size == kLongOrFPLiteralFar);
return Fixup(kNoRegister, kNoRegister, kNoSRegister, dd,
AL, kLoadFPLiteralDouble, size, location);
@@ -870,6 +872,9 @@
// without invalidating pointers and references to existing elements.
ArenaDeque<Literal> literals_;
+ // Deduplication map for 64-bit literals, used for LoadDImmediate().
+ ArenaSafeMap<uint64_t, Literal*> literal64_dedupe_map_;
+
// Jump table list.
ArenaDeque<JumpTable> jump_tables_;
diff --git a/compiler/utils/arm/assembler_thumb2_test.cc b/compiler/utils/arm/assembler_thumb2_test.cc
index 7f1dc49..f3fa72c 100644
--- a/compiler/utils/arm/assembler_thumb2_test.cc
+++ b/compiler/utils/arm/assembler_thumb2_test.cc
@@ -869,10 +869,11 @@
}
std::string expected =
- "mov.w ip, #((2f - 1f - 4) & ~0x3ff)\n"
+ // "as" does not consider ((2f - 1f - 4) & 0xffff) a constant expression for movw.
+ "movw ip, #(0x408 - 0x4 - 4)\n"
"1:\n"
"add ip, pc\n"
- "ldrd r1, r3, [ip, #((2f - 1b - 4) & 0x3ff)]\n" +
+ "ldrd r1, r3, [ip, #0]\n" +
RepeatInsn(kLdrR0R0Count, "ldr r0, [r0]\n") +
".align 2, 0\n"
"2:\n"
@@ -884,48 +885,78 @@
__ GetAdjustedPosition(label.Position()));
}
-TEST_F(AssemblerThumb2Test, LoadLiteralSingleMax256KiB) {
+TEST_F(AssemblerThumb2Test, LoadLiteralSingleMax64KiB) {
// The literal size must match but the type doesn't, so use an int32_t rather than float.
arm::Literal* literal = __ NewLiteral<int32_t>(0x12345678);
__ LoadLiteral(arm::S3, literal);
Label label;
__ Bind(&label);
- constexpr size_t kLdrR0R0Count = (1 << 17) - 3u;
- for (size_t i = 0; i != kLdrR0R0Count; ++i) {
- __ ldr(arm::R0, arm::Address(arm::R0));
- }
-
- std::string expected =
- "mov.w ip, #((2f - 1f - 4) & ~0x3ff)\n"
- "1:\n"
- "add ip, pc\n"
- "vldr s3, [ip, #((2f - 1b - 4) & 0x3ff)]\n" +
- RepeatInsn(kLdrR0R0Count, "ldr r0, [r0]\n") +
- ".align 2, 0\n"
- "2:\n"
- ".word 0x12345678\n";
- DriverStr(expected, "LoadLiteralSingleMax256KiB");
-
- EXPECT_EQ(static_cast<uint32_t>(label.Position()) + 6u,
- __ GetAdjustedPosition(label.Position()));
-}
-
-TEST_F(AssemblerThumb2Test, LoadLiteralDoubleBeyondMax256KiB) {
- // The literal size must match but the type doesn't, so use an int64_t rather than double.
- arm::Literal* literal = __ NewLiteral<int64_t>(INT64_C(0x1234567887654321));
- __ LoadLiteral(arm::D3, literal);
- Label label;
- __ Bind(&label);
- constexpr size_t kLdrR0R0Count = (1 << 17) - 2u;
+ constexpr size_t kLdrR0R0Count = (1 << 15) - 3u;
for (size_t i = 0; i != kLdrR0R0Count; ++i) {
__ ldr(arm::R0, arm::Address(arm::R0));
}
std::string expected =
// "as" does not consider ((2f - 1f - 4) & 0xffff) a constant expression for movw.
- "movw ip, #(0x40000 & 0xffff)\n"
+ "movw ip, #(0x10004 - 0x4 - 4)\n"
+ "1:\n"
+ "add ip, pc\n"
+ "vldr s3, [ip, #0]\n" +
+ RepeatInsn(kLdrR0R0Count, "ldr r0, [r0]\n") +
+ ".align 2, 0\n"
+ "2:\n"
+ ".word 0x12345678\n";
+ DriverStr(expected, "LoadLiteralSingleMax64KiB");
+
+ EXPECT_EQ(static_cast<uint32_t>(label.Position()) + 6u,
+ __ GetAdjustedPosition(label.Position()));
+}
+
+TEST_F(AssemblerThumb2Test, LoadLiteralSingleMax64KiB_UnalignedPC) {
+ // The literal size must match but the type doesn't, so use an int32_t rather than float.
+ arm::Literal* literal = __ NewLiteral<int32_t>(0x12345678);
+ __ ldr(arm::R0, arm::Address(arm::R0));
+ __ LoadLiteral(arm::S3, literal);
+ Label label;
+ __ Bind(&label);
+ constexpr size_t kLdrR0R0Count = (1 << 15) - 4u;
+ for (size_t i = 0; i != kLdrR0R0Count; ++i) {
+ __ ldr(arm::R0, arm::Address(arm::R0));
+ }
+
+ std::string expected =
+ "ldr r0, [r0]\n"
+ // "as" does not consider ((2f - 1f - 4) & 0xffff) a constant expression for movw.
+ "movw ip, #(0x10004 - 0x6 - 4)\n"
+ "1:\n"
+ "add ip, pc\n"
+ "vldr s3, [ip, #0]\n" +
+ RepeatInsn(kLdrR0R0Count, "ldr r0, [r0]\n") +
+ ".align 2, 0\n"
+ "2:\n"
+ ".word 0x12345678\n";
+ DriverStr(expected, "LoadLiteralSingleMax64KiB_UnalignedPC");
+
+ EXPECT_EQ(static_cast<uint32_t>(label.Position()) + 6u,
+ __ GetAdjustedPosition(label.Position()));
+}
+
+TEST_F(AssemblerThumb2Test, LoadLiteralDoubleBeyondMax64KiB) {
+ // The literal size must match but the type doesn't, so use an int64_t rather than double.
+ arm::Literal* literal = __ NewLiteral<int64_t>(INT64_C(0x1234567887654321));
+ __ LoadLiteral(arm::D3, literal);
+ Label label;
+ __ Bind(&label);
+ constexpr size_t kLdrR0R0Count = (1 << 15) - 2u;
+ for (size_t i = 0; i != kLdrR0R0Count; ++i) {
+ __ ldr(arm::R0, arm::Address(arm::R0));
+ }
+
+ std::string expected =
+ // "as" does not consider ((2f - 1f - 4) & 0xffff) a constant expression for movw.
+ "movw ip, #((0x1000c - 0x8 - 4) & 0xffff)\n"
// "as" does not consider ((2f - 1f - 4) >> 16) a constant expression for movt.
- "movt ip, #(0x40000 >> 16)\n"
+ "movt ip, #((0x1000c - 0x8 - 4) >> 16)\n"
"1:\n"
"add ip, pc\n"
"vldr d3, [ip, #0]\n" +
@@ -934,7 +965,7 @@
"2:\n"
".word 0x87654321\n"
".word 0x12345678\n";
- DriverStr(expected, "LoadLiteralDoubleBeyondMax256KiB");
+ DriverStr(expected, "LoadLiteralDoubleBeyondMax64KiB");
EXPECT_EQ(static_cast<uint32_t>(label.Position()) + 10u,
__ GetAdjustedPosition(label.Position()));
@@ -946,16 +977,16 @@
__ LoadLiteral(arm::D3, literal);
Label label;
__ Bind(&label);
- constexpr size_t kLdrR0R0Count = (1 << 17) - 2u + 0x1234;
+ constexpr size_t kLdrR0R0Count = (1 << 15) - 2u + 0x1234;
for (size_t i = 0; i != kLdrR0R0Count; ++i) {
__ ldr(arm::R0, arm::Address(arm::R0));
}
std::string expected =
// "as" does not consider ((2f - 1f - 4) & 0xffff) a constant expression for movw.
- "movw ip, #((0x40000 + 2 * 0x1234) & 0xffff)\n"
+ "movw ip, #((0x1000c + 2 * 0x1234 - 0x8 - 4) & 0xffff)\n"
// "as" does not consider ((2f - 1f - 4) >> 16) a constant expression for movt.
- "movt ip, #((0x40000 + 2 * 0x1234) >> 16)\n"
+ "movt ip, #((0x1000c + 2 * 0x1234 - 0x8 - 4) >> 16)\n"
"1:\n"
"add ip, pc\n"
"vldr d3, [ip, #0]\n" +
diff --git a/compiler/utils/assembler_test.h b/compiler/utils/assembler_test.h
index afe0576..92b4c8e 100644
--- a/compiler/utils/assembler_test.h
+++ b/compiler/utils/assembler_test.h
@@ -344,6 +344,17 @@
}
template <typename ImmType>
+ std::string RepeatFFIb(void (Ass::*f)(FPReg, FPReg, ImmType), int imm_bits, std::string fmt) {
+ return RepeatTemplatedRegistersImmBits<FPReg, FPReg, ImmType>(f,
+ imm_bits,
+ GetFPRegisters(),
+ GetFPRegisters(),
+ &AssemblerTest::GetFPRegName,
+ &AssemblerTest::GetFPRegName,
+ fmt);
+ }
+
+ template <typename ImmType>
std::string RepeatIbFF(void (Ass::*f)(ImmType, FPReg, FPReg), int imm_bits, std::string fmt) {
return RepeatTemplatedImmBitsRegisters<ImmType, FPReg, FPReg>(f,
GetFPRegisters(),
diff --git a/compiler/utils/mips/assembler_mips.cc b/compiler/utils/mips/assembler_mips.cc
index ac93083..ebaf1c0 100644
--- a/compiler/utils/mips/assembler_mips.cc
+++ b/compiler/utils/mips/assembler_mips.cc
@@ -39,6 +39,7 @@
for (auto& exception_block : exception_blocks_) {
EmitExceptionPoll(&exception_block);
}
+ EmitLiterals();
PromoteBranches();
}
@@ -444,6 +445,12 @@
EmitI(0x25, rs, rt, imm16);
}
+void MipsAssembler::Lwpc(Register rs, uint32_t imm19) {
+ CHECK(IsR6());
+ CHECK(IsUint<19>(imm19)) << imm19;
+ EmitI21(0x3B, rs, (0x01 << 19) | imm19);
+}
+
void MipsAssembler::Lui(Register rt, uint16_t imm16) {
EmitI(0xf, static_cast<Register>(0), rt, imm16);
}
@@ -532,6 +539,10 @@
EmitI(0x4, static_cast<Register>(0), static_cast<Register>(0), imm16);
}
+void MipsAssembler::Bal(uint16_t imm16) {
+ EmitI(0x1, static_cast<Register>(0), static_cast<Register>(0x11), imm16);
+}
+
void MipsAssembler::Beq(Register rs, Register rt, uint16_t imm16) {
EmitI(0x4, rs, rt, imm16);
}
@@ -624,6 +635,11 @@
EmitI26(0x32, imm26);
}
+void MipsAssembler::Balc(uint32_t imm26) {
+ CHECK(IsR6());
+ EmitI26(0x3A, imm26);
+}
+
void MipsAssembler::Jic(Register rt, uint16_t imm16) {
CHECK(IsR6());
EmitI(0x36, static_cast<Register>(0), rt, imm16);
@@ -1489,30 +1505,47 @@
type_ = (offset_size <= branch_info_[short_type].offset_size) ? short_type : long_type;
}
-void MipsAssembler::Branch::InitializeType(bool is_call, bool is_r6) {
+void MipsAssembler::Branch::InitializeType(bool is_call, bool is_literal, bool is_r6) {
+ CHECK_EQ(is_call && is_literal, false);
OffsetBits offset_size = GetOffsetSizeNeeded(location_, target_);
if (is_r6) {
// R6
- if (is_call) {
+ if (is_literal) {
+ CHECK(!IsResolved());
+ type_ = kR6Literal;
+ } else if (is_call) {
InitShortOrLong(offset_size, kR6Call, kR6LongCall);
- } else if (condition_ == kUncond) {
- InitShortOrLong(offset_size, kR6UncondBranch, kR6LongUncondBranch);
} else {
- if (condition_ == kCondEQZ || condition_ == kCondNEZ) {
- // Special case for beqzc/bnezc with longer offset than in other b<cond>c instructions.
- type_ = (offset_size <= kOffset23) ? kR6CondBranch : kR6LongCondBranch;
- } else {
- InitShortOrLong(offset_size, kR6CondBranch, kR6LongCondBranch);
+ switch (condition_) {
+ case kUncond:
+ InitShortOrLong(offset_size, kR6UncondBranch, kR6LongUncondBranch);
+ break;
+ case kCondEQZ:
+ case kCondNEZ:
+ // Special case for beqzc/bnezc with longer offset than in other b<cond>c instructions.
+ type_ = (offset_size <= kOffset23) ? kR6CondBranch : kR6LongCondBranch;
+ break;
+ default:
+ InitShortOrLong(offset_size, kR6CondBranch, kR6LongCondBranch);
+ break;
}
}
} else {
// R2
- if (is_call) {
+ if (is_literal) {
+ CHECK(!IsResolved());
+ type_ = kLiteral;
+ } else if (is_call) {
InitShortOrLong(offset_size, kCall, kLongCall);
- } else if (condition_ == kUncond) {
- InitShortOrLong(offset_size, kUncondBranch, kLongUncondBranch);
} else {
- InitShortOrLong(offset_size, kCondBranch, kLongCondBranch);
+ switch (condition_) {
+ case kUncond:
+ InitShortOrLong(offset_size, kUncondBranch, kLongUncondBranch);
+ break;
+ default:
+ InitShortOrLong(offset_size, kCondBranch, kLongCondBranch);
+ break;
+ }
}
}
old_type_ = type_;
@@ -1544,14 +1577,14 @@
}
}
-MipsAssembler::Branch::Branch(bool is_r6, uint32_t location, uint32_t target)
+MipsAssembler::Branch::Branch(bool is_r6, uint32_t location, uint32_t target, bool is_call)
: old_location_(location),
location_(location),
target_(target),
lhs_reg_(0),
rhs_reg_(0),
condition_(kUncond) {
- InitializeType(false, is_r6);
+ InitializeType(is_call, /* is_literal */ false, is_r6);
}
MipsAssembler::Branch::Branch(bool is_r6,
@@ -1608,19 +1641,23 @@
// Branch condition is always true, make the branch unconditional.
condition_ = kUncond;
}
- InitializeType(false, is_r6);
+ InitializeType(/* is_call */ false, /* is_literal */ false, is_r6);
}
-MipsAssembler::Branch::Branch(bool is_r6, uint32_t location, uint32_t target, Register indirect_reg)
+MipsAssembler::Branch::Branch(bool is_r6, uint32_t location, Register dest_reg, Register base_reg)
: old_location_(location),
location_(location),
- target_(target),
- lhs_reg_(indirect_reg),
- rhs_reg_(0),
+ target_(kUnresolved),
+ lhs_reg_(dest_reg),
+ rhs_reg_(base_reg),
condition_(kUncond) {
- CHECK_NE(indirect_reg, ZERO);
- CHECK_NE(indirect_reg, AT);
- InitializeType(true, is_r6);
+ CHECK_NE(dest_reg, ZERO);
+ if (is_r6) {
+ CHECK_EQ(base_reg, ZERO);
+ } else {
+ CHECK_NE(base_reg, ZERO);
+ }
+ InitializeType(/* is_call */ false, /* is_literal */ true, is_r6);
}
MipsAssembler::BranchCondition MipsAssembler::Branch::OppositeCondition(
@@ -1722,19 +1759,27 @@
case kUncondBranch:
case kCondBranch:
case kCall:
+ // R2 near literal.
+ case kLiteral:
// R6 short branches.
case kR6UncondBranch:
case kR6CondBranch:
case kR6Call:
+ // R6 near literal.
+ case kR6Literal:
return false;
// R2 long branches.
case kLongUncondBranch:
case kLongCondBranch:
case kLongCall:
+ // R2 far literal.
+ case kFarLiteral:
// R6 long branches.
case kR6LongUncondBranch:
case kR6LongCondBranch:
case kR6LongCall:
+ // R6 far literal.
+ case kR6FarLiteral:
return true;
}
UNREACHABLE();
@@ -1803,6 +1848,10 @@
case kCall:
type_ = kLongCall;
break;
+ // R2 near literal.
+ case kLiteral:
+ type_ = kFarLiteral;
+ break;
// R6 short branches.
case kR6UncondBranch:
type_ = kR6LongUncondBranch;
@@ -1813,6 +1862,10 @@
case kR6Call:
type_ = kR6LongCall;
break;
+ // R6 near literal.
+ case kR6Literal:
+ type_ = kR6FarLiteral;
+ break;
default:
// Note: 'type_' is already long.
break;
@@ -1820,14 +1873,26 @@
CHECK(IsLong());
}
-uint32_t MipsAssembler::Branch::PromoteIfNeeded(uint32_t max_short_distance) {
+uint32_t MipsAssembler::GetBranchLocationOrPcRelBase(const MipsAssembler::Branch* branch) const {
+ switch (branch->GetType()) {
+ case Branch::kLiteral:
+ case Branch::kFarLiteral:
+ return GetLabelLocation(&pc_rel_base_label_);
+ default:
+ return branch->GetLocation();
+ }
+}
+
+uint32_t MipsAssembler::Branch::PromoteIfNeeded(uint32_t location, uint32_t max_short_distance) {
+ // `location` is either `GetLabelLocation(&pc_rel_base_label_)` for R2 literals or
+ // `this->GetLocation()` for everything else.
// If the branch is still unresolved or already long, nothing to do.
if (IsLong() || !IsResolved()) {
return 0;
}
// Promote the short branch to long if the offset size is too small
- // to hold the distance between location_ and target_.
- if (GetOffsetSizeNeeded(location_, target_) > GetOffsetSize()) {
+ // to hold the distance between location and target_.
+ if (GetOffsetSizeNeeded(location, target_) > GetOffsetSize()) {
PromoteToLong();
uint32_t old_size = GetOldSize();
uint32_t new_size = GetSize();
@@ -1837,7 +1902,7 @@
// The following logic is for debugging/testing purposes.
// Promote some short branches to long when it's not really required.
if (UNLIKELY(max_short_distance != std::numeric_limits<uint32_t>::max())) {
- int64_t distance = static_cast<int64_t>(target_) - location_;
+ int64_t distance = static_cast<int64_t>(target_) - location;
distance = (distance >= 0) ? distance : -distance;
if (distance >= max_short_distance) {
PromoteToLong();
@@ -1854,12 +1919,26 @@
return location_ + branch_info_[type_].instr_offset * sizeof(uint32_t);
}
-uint32_t MipsAssembler::Branch::GetOffset() const {
+uint32_t MipsAssembler::GetBranchOrPcRelBaseForEncoding(const MipsAssembler::Branch* branch) const {
+ switch (branch->GetType()) {
+ case Branch::kLiteral:
+ case Branch::kFarLiteral:
+ return GetLabelLocation(&pc_rel_base_label_);
+ default:
+ return branch->GetOffsetLocation() +
+ Branch::branch_info_[branch->GetType()].pc_org * sizeof(uint32_t);
+ }
+}
+
+uint32_t MipsAssembler::Branch::GetOffset(uint32_t location) const {
+ // `location` is either `GetLabelLocation(&pc_rel_base_label_)` for R2 literals or
+ // `this->GetOffsetLocation() + branch_info_[this->GetType()].pc_org * sizeof(uint32_t)`
+ // for everything else.
CHECK(IsResolved());
uint32_t ofs_mask = 0xFFFFFFFF >> (32 - GetOffsetSize());
// Calculate the byte distance between instructions and also account for
// different PC-relative origins.
- uint32_t offset = target_ - GetOffsetLocation() - branch_info_[type_].pc_org * sizeof(uint32_t);
+ uint32_t offset = target_ - location;
// Prepare the offset for encoding into the instruction(s).
offset = (offset & ofs_mask) >> branch_info_[type_].offset_shift;
return offset;
@@ -1906,7 +1985,7 @@
label->BindTo(bound_pc);
}
-uint32_t MipsAssembler::GetLabelLocation(MipsLabel* label) const {
+uint32_t MipsAssembler::GetLabelLocation(const MipsLabel* label) const {
CHECK(label->IsBound());
uint32_t target = label->Position();
if (label->prev_branch_id_plus_one_) {
@@ -1941,6 +2020,10 @@
return old_position + last_position_adjustment_;
}
+void MipsAssembler::BindPcRelBaseLabel() {
+ Bind(&pc_rel_base_label_);
+}
+
void MipsAssembler::FinalizeLabeledBranch(MipsLabel* label) {
uint32_t length = branches_.back().GetLength();
if (!label->IsBound()) {
@@ -1962,7 +2045,7 @@
void MipsAssembler::Buncond(MipsLabel* label) {
uint32_t target = label->IsBound() ? GetLabelLocation(label) : Branch::kUnresolved;
- branches_.emplace_back(IsR6(), buffer_.Size(), target);
+ branches_.emplace_back(IsR6(), buffer_.Size(), target, /* is_call */ false);
FinalizeLabeledBranch(label);
}
@@ -1976,12 +2059,46 @@
FinalizeLabeledBranch(label);
}
-void MipsAssembler::Call(MipsLabel* label, Register indirect_reg) {
+void MipsAssembler::Call(MipsLabel* label) {
uint32_t target = label->IsBound() ? GetLabelLocation(label) : Branch::kUnresolved;
- branches_.emplace_back(IsR6(), buffer_.Size(), target, indirect_reg);
+ branches_.emplace_back(IsR6(), buffer_.Size(), target, /* is_call */ true);
FinalizeLabeledBranch(label);
}
+Literal* MipsAssembler::NewLiteral(size_t size, const uint8_t* data) {
+ DCHECK(size == 4u || size == 8u) << size;
+ literals_.emplace_back(size, data);
+ return &literals_.back();
+}
+
+void MipsAssembler::LoadLiteral(Register dest_reg, Register base_reg, Literal* literal) {
+ // Literal loads are treated as pseudo branches since they require very similar handling.
+ DCHECK_EQ(literal->GetSize(), 4u);
+ MipsLabel* label = literal->GetLabel();
+ DCHECK(!label->IsBound());
+ branches_.emplace_back(IsR6(),
+ buffer_.Size(),
+ dest_reg,
+ base_reg);
+ FinalizeLabeledBranch(label);
+}
+
+void MipsAssembler::EmitLiterals() {
+ if (!literals_.empty()) {
+ // We don't support byte and half-word literals.
+ // TODO: proper alignment for 64-bit literals when they're implemented.
+ for (Literal& literal : literals_) {
+ MipsLabel* label = literal.GetLabel();
+ Bind(label);
+ AssemblerBuffer::EnsureCapacity ensured(&buffer_);
+ DCHECK(literal.GetSize() == 4u || literal.GetSize() == 8u);
+ for (size_t i = 0, size = literal.GetSize(); i != size; ++i) {
+ buffer_.Emit<uint8_t>(literal.GetData()[i]);
+ }
+ }
+ }
+}
+
void MipsAssembler::PromoteBranches() {
// Promote short branches to long as necessary.
bool changed;
@@ -1989,7 +2106,8 @@
changed = false;
for (auto& branch : branches_) {
CHECK(branch.IsResolved());
- uint32_t delta = branch.PromoteIfNeeded();
+ uint32_t base = GetBranchLocationOrPcRelBase(&branch);
+ uint32_t delta = branch.PromoteIfNeeded(base);
// If this branch has been promoted and needs to expand in size,
// relocate all branches by the expansion size.
if (delta) {
@@ -2027,27 +2145,35 @@
// R2 short branches.
{ 2, 0, 1, MipsAssembler::Branch::kOffset18, 2 }, // kUncondBranch
{ 2, 0, 1, MipsAssembler::Branch::kOffset18, 2 }, // kCondBranch
- { 5, 2, 0, MipsAssembler::Branch::kOffset16, 0 }, // kCall
+ { 2, 0, 1, MipsAssembler::Branch::kOffset18, 2 }, // kCall
+ // R2 near literal.
+ { 1, 0, 0, MipsAssembler::Branch::kOffset16, 0 }, // kLiteral
// R2 long branches.
{ 9, 3, 1, MipsAssembler::Branch::kOffset32, 0 }, // kLongUncondBranch
{ 10, 4, 1, MipsAssembler::Branch::kOffset32, 0 }, // kLongCondBranch
{ 6, 1, 1, MipsAssembler::Branch::kOffset32, 0 }, // kLongCall
+ // R2 far literal.
+ { 3, 0, 0, MipsAssembler::Branch::kOffset32, 0 }, // kFarLiteral
// R6 short branches.
{ 1, 0, 1, MipsAssembler::Branch::kOffset28, 2 }, // kR6UncondBranch
{ 2, 0, 1, MipsAssembler::Branch::kOffset18, 2 }, // kR6CondBranch
// Exception: kOffset23 for beqzc/bnezc.
- { 2, 0, 0, MipsAssembler::Branch::kOffset21, 2 }, // kR6Call
+ { 1, 0, 1, MipsAssembler::Branch::kOffset28, 2 }, // kR6Call
+ // R6 near literal.
+ { 1, 0, 0, MipsAssembler::Branch::kOffset21, 2 }, // kR6Literal
// R6 long branches.
{ 2, 0, 0, MipsAssembler::Branch::kOffset32, 0 }, // kR6LongUncondBranch
{ 3, 1, 0, MipsAssembler::Branch::kOffset32, 0 }, // kR6LongCondBranch
- { 3, 0, 0, MipsAssembler::Branch::kOffset32, 0 }, // kR6LongCall
+ { 2, 0, 0, MipsAssembler::Branch::kOffset32, 0 }, // kR6LongCall
+ // R6 far literal.
+ { 2, 0, 0, MipsAssembler::Branch::kOffset32, 0 }, // kR6FarLiteral
};
-// Note: make sure branch_info_[] and mitBranch() are kept synchronized.
+// Note: make sure branch_info_[] and EmitBranch() are kept synchronized.
void MipsAssembler::EmitBranch(MipsAssembler::Branch* branch) {
CHECK_EQ(overwriting_, true);
overwrite_location_ = branch->GetLocation();
- uint32_t offset = branch->GetOffset();
+ uint32_t offset = branch->GetOffset(GetBranchOrPcRelBaseForEncoding(branch));
BranchCondition condition = branch->GetCondition();
Register lhs = branch->GetLeftRegister();
Register rhs = branch->GetRightRegister();
@@ -2064,12 +2190,15 @@
Nop(); // TODO: improve by filling the delay slot.
break;
case Branch::kCall:
- Nal();
- Nop(); // TODO: is this NOP really needed here?
CHECK_EQ(overwrite_location_, branch->GetOffsetLocation());
- Addiu(lhs, RA, offset);
- Jalr(lhs);
- Nop();
+ Bal(offset);
+ Nop(); // TODO: improve by filling the delay slot.
+ break;
+
+ // R2 near literal.
+ case Branch::kLiteral:
+ CHECK_EQ(overwrite_location_, branch->GetOffsetLocation());
+ Lw(lhs, rhs, offset);
break;
// R2 long branches.
@@ -2123,11 +2252,20 @@
CHECK_EQ(overwrite_location_, branch->GetOffsetLocation());
Lui(AT, High16Bits(offset));
Ori(AT, AT, Low16Bits(offset));
- Addu(lhs, AT, RA);
- Jalr(lhs);
+ Addu(AT, AT, RA);
+ Jalr(AT);
Nop();
break;
+ // R2 far literal.
+ case Branch::kFarLiteral:
+ offset += (offset & 0x8000) << 1; // Account for sign extension in lw.
+ CHECK_EQ(overwrite_location_, branch->GetOffsetLocation());
+ Lui(AT, High16Bits(offset));
+ Addu(AT, AT, rhs);
+ Lw(lhs, AT, Low16Bits(offset));
+ break;
+
// R6 short branches.
case Branch::kR6UncondBranch:
CHECK_EQ(overwrite_location_, branch->GetOffsetLocation());
@@ -2140,8 +2278,13 @@
break;
case Branch::kR6Call:
CHECK_EQ(overwrite_location_, branch->GetOffsetLocation());
- Addiupc(lhs, offset);
- Jialc(lhs, 0);
+ Balc(offset);
+ break;
+
+ // R6 near literal.
+ case Branch::kR6Literal:
+ CHECK_EQ(overwrite_location_, branch->GetOffsetLocation());
+ Lwpc(lhs, offset);
break;
// R6 long branches.
@@ -2159,11 +2302,18 @@
Jic(AT, Low16Bits(offset));
break;
case Branch::kR6LongCall:
- offset += (offset & 0x8000) << 1; // Account for sign extension in addiu.
+ offset += (offset & 0x8000) << 1; // Account for sign extension in jialc.
CHECK_EQ(overwrite_location_, branch->GetOffsetLocation());
- Auipc(lhs, High16Bits(offset));
- Addiu(lhs, lhs, Low16Bits(offset));
- Jialc(lhs, 0);
+ Auipc(AT, High16Bits(offset));
+ Jialc(AT, Low16Bits(offset));
+ break;
+
+ // R6 far literal.
+ case Branch::kR6FarLiteral:
+ offset += (offset & 0x8000) << 1; // Account for sign extension in lw.
+ CHECK_EQ(overwrite_location_, branch->GetOffsetLocation());
+ Auipc(AT, High16Bits(offset));
+ Lw(lhs, AT, Low16Bits(offset));
break;
}
CHECK_EQ(overwrite_location_, branch->GetEndLocation());
@@ -2174,8 +2324,8 @@
Buncond(label);
}
-void MipsAssembler::Jalr(MipsLabel* label, Register indirect_reg) {
- Call(label, indirect_reg);
+void MipsAssembler::Bal(MipsLabel* label) {
+ Call(label);
}
void MipsAssembler::Beq(Register rs, Register rt, MipsLabel* label) {
diff --git a/compiler/utils/mips/assembler_mips.h b/compiler/utils/mips/assembler_mips.h
index 31b3b31..1f7781f 100644
--- a/compiler/utils/mips/assembler_mips.h
+++ b/compiler/utils/mips/assembler_mips.h
@@ -17,10 +17,12 @@
#ifndef ART_COMPILER_UTILS_MIPS_ASSEMBLER_MIPS_H_
#define ART_COMPILER_UTILS_MIPS_ASSEMBLER_MIPS_H_
+#include <deque>
#include <utility>
#include <vector>
#include "arch/mips/instruction_set_features_mips.h"
+#include "base/arena_containers.h"
#include "base/macros.h"
#include "constants_mips.h"
#include "globals.h"
@@ -79,6 +81,49 @@
DISALLOW_COPY_AND_ASSIGN(MipsLabel);
};
+// Assembler literal is a value embedded in code, retrieved using a PC-relative load.
+class Literal {
+ public:
+ static constexpr size_t kMaxSize = 8;
+
+ Literal(uint32_t size, const uint8_t* data)
+ : label_(), size_(size) {
+ DCHECK_LE(size, Literal::kMaxSize);
+ memcpy(data_, data, size);
+ }
+
+ template <typename T>
+ T GetValue() const {
+ DCHECK_EQ(size_, sizeof(T));
+ T value;
+ memcpy(&value, data_, sizeof(T));
+ return value;
+ }
+
+ uint32_t GetSize() const {
+ return size_;
+ }
+
+ const uint8_t* GetData() const {
+ return data_;
+ }
+
+ MipsLabel* GetLabel() {
+ return &label_;
+ }
+
+ const MipsLabel* GetLabel() const {
+ return &label_;
+ }
+
+ private:
+ MipsLabel label_;
+ const uint32_t size_;
+ uint8_t data_[kMaxSize];
+
+ DISALLOW_COPY_AND_ASSIGN(Literal);
+};
+
// Slowpath entered when Thread::Current()->_exception is non-null.
class MipsExceptionSlowPath {
public:
@@ -107,6 +152,7 @@
: Assembler(arena),
overwriting_(false),
overwrite_location_(0),
+ literals_(arena->Adapter(kArenaAllocAssembler)),
last_position_adjustment_(0),
last_old_position_(0),
last_branch_id_(0),
@@ -182,6 +228,7 @@
void Lwr(Register rt, Register rs, uint16_t imm16);
void Lbu(Register rt, Register rs, uint16_t imm16);
void Lhu(Register rt, Register rs, uint16_t imm16);
+ void Lwpc(Register rs, uint32_t imm19); // R6
void Lui(Register rt, uint16_t imm16);
void Aui(Register rt, Register rs, uint16_t imm16); // R6
void Sync(uint32_t stype);
@@ -205,6 +252,7 @@
void Sltiu(Register rt, Register rs, uint16_t imm16);
void B(uint16_t imm16);
+ void Bal(uint16_t imm16);
void Beq(Register rs, Register rt, uint16_t imm16);
void Bne(Register rs, Register rt, uint16_t imm16);
void Beqz(Register rt, uint16_t imm16);
@@ -226,6 +274,7 @@
void Auipc(Register rs, uint16_t imm16); // R6
void Addiupc(Register rs, uint32_t imm19); // R6
void Bc(uint32_t imm26); // R6
+ void Balc(uint32_t imm26); // R6
void Jic(Register rt, uint16_t imm16); // R6
void Jialc(Register rt, uint16_t imm16); // R6
void Bltc(Register rs, Register rt, uint16_t imm16); // R6
@@ -365,7 +414,7 @@
// These will generate R2 branches or R6 branches as appropriate.
void Bind(MipsLabel* label);
void B(MipsLabel* label);
- void Jalr(MipsLabel* label, Register indirect_reg);
+ void Bal(MipsLabel* label);
void Beq(Register rs, Register rt, MipsLabel* label);
void Bne(Register rs, Register rt, MipsLabel* label);
void Beqz(Register rt, MipsLabel* label);
@@ -412,6 +461,21 @@
UNIMPLEMENTED(FATAL) << "Do not use Jump for MIPS";
}
+ // Create a new literal with a given value.
+ // NOTE: Force the template parameter to be explicitly specified.
+ template <typename T>
+ Literal* NewLiteral(typename Identity<T>::type value) {
+ static_assert(std::is_integral<T>::value, "T must be an integral type.");
+ return NewLiteral(sizeof(value), reinterpret_cast<const uint8_t*>(&value));
+ }
+
+ // Create a new literal with the given data.
+ Literal* NewLiteral(size_t size, const uint8_t* data);
+
+ // Load literal using the base register (for R2 only) or using PC-relative loads
+ // (for R6 only; base_reg must be ZERO).
+ void LoadLiteral(Register dest_reg, Register base_reg, Literal* literal);
+
//
// Overridden common assembler high-level functionality.
//
@@ -569,12 +633,22 @@
// Returns the (always-)current location of a label (can be used in class CodeGeneratorMIPS,
// must be used instead of MipsLabel::GetPosition()).
- uint32_t GetLabelLocation(MipsLabel* label) const;
+ uint32_t GetLabelLocation(const MipsLabel* label) const;
// Get the final position of a label after local fixup based on the old position
// recorded before FinalizeCode().
uint32_t GetAdjustedPosition(uint32_t old_position);
+ // R2 doesn't have PC-relative addressing, which we need to access literals. We simulate it by
+ // reading the PC value into a general-purpose register with the NAL instruction and then loading
+ // literals through this base register. The code generator calls this method (at most once per
+ // method being compiled) to bind a label to the location for which the PC value is acquired.
+ // The assembler then computes literal offsets relative to this label.
+ void BindPcRelBaseLabel();
+
+ // Note that PC-relative literal loads are handled as pseudo branches because they need very
+ // similar relocation and may similarly expand in size to accomodate for larger offsets relative
+ // to PC.
enum BranchCondition {
kCondLT,
kCondGE,
@@ -604,18 +678,26 @@
kUncondBranch,
kCondBranch,
kCall,
+ // R2 near literal.
+ kLiteral,
// R2 long branches.
kLongUncondBranch,
kLongCondBranch,
kLongCall,
+ // R2 far literal.
+ kFarLiteral,
// R6 short branches.
kR6UncondBranch,
kR6CondBranch,
kR6Call,
+ // R6 near literal.
+ kR6Literal,
// R6 long branches.
kR6LongUncondBranch,
kR6LongCondBranch,
kR6LongCall,
+ // R6 far literal.
+ kR6FarLiteral,
};
// Bit sizes of offsets defined as enums to minimize chance of typos.
enum OffsetBits {
@@ -650,17 +732,17 @@
};
static const BranchInfo branch_info_[/* Type */];
- // Unconditional branch.
- Branch(bool is_r6, uint32_t location, uint32_t target);
+ // Unconditional branch or call.
+ Branch(bool is_r6, uint32_t location, uint32_t target, bool is_call);
// Conditional branch.
Branch(bool is_r6,
uint32_t location,
uint32_t target,
BranchCondition condition,
Register lhs_reg,
- Register rhs_reg = ZERO);
- // Call (branch and link) that stores the target address in a given register (i.e. T9).
- Branch(bool is_r6, uint32_t location, uint32_t target, Register indirect_reg);
+ Register rhs_reg);
+ // Literal.
+ Branch(bool is_r6, uint32_t location, Register dest_reg, Register base_reg);
// Some conditional branches with lhs = rhs are effectively NOPs, while some
// others are effectively unconditional. MIPSR6 conditional branches require lhs != rhs.
@@ -736,17 +818,18 @@
// that is allowed for short branches. This is for debugging/testing purposes.
// max_short_distance = 0 forces all short branches to become long.
// Use the implicit default argument when not debugging/testing.
- uint32_t PromoteIfNeeded(uint32_t max_short_distance = std::numeric_limits<uint32_t>::max());
+ uint32_t PromoteIfNeeded(uint32_t location,
+ uint32_t max_short_distance = std::numeric_limits<uint32_t>::max());
// Returns the location of the instruction(s) containing the offset.
uint32_t GetOffsetLocation() const;
// Calculates and returns the offset ready for encoding in the branch instruction(s).
- uint32_t GetOffset() const;
+ uint32_t GetOffset(uint32_t location) const;
private:
// Completes branch construction by determining and recording its type.
- void InitializeType(bool is_call, bool is_r6);
+ void InitializeType(bool is_call, bool is_literal, bool is_r6);
// Helper for the above.
void InitShortOrLong(OffsetBits ofs_size, Type short_type, Type long_type);
@@ -776,12 +859,15 @@
void Buncond(MipsLabel* label);
void Bcond(MipsLabel* label, BranchCondition condition, Register lhs, Register rhs = ZERO);
- void Call(MipsLabel* label, Register indirect_reg);
+ void Call(MipsLabel* label);
void FinalizeLabeledBranch(MipsLabel* label);
Branch* GetBranch(uint32_t branch_id);
const Branch* GetBranch(uint32_t branch_id) const;
+ uint32_t GetBranchLocationOrPcRelBase(const MipsAssembler::Branch* branch) const;
+ uint32_t GetBranchOrPcRelBaseForEncoding(const MipsAssembler::Branch* branch) const;
+ void EmitLiterals();
void PromoteBranches();
void EmitBranch(Branch* branch);
void EmitBranches();
@@ -816,6 +902,15 @@
// The current overwrite location.
uint32_t overwrite_location_;
+ // Use std::deque<> for literal labels to allow insertions at the end
+ // without invalidating pointers and references to existing elements.
+ ArenaDeque<Literal> literals_;
+
+ // There's no PC-relative addressing on MIPS32R2. So, in order to access literals relative to PC
+ // we get PC using the NAL instruction. This label marks the position within the assembler buffer
+ // that PC (from NAL) points to.
+ MipsLabel pc_rel_base_label_;
+
// Data for AdjustedPosition(), see the description there.
uint32_t last_position_adjustment_;
uint32_t last_old_position_;
diff --git a/compiler/utils/mips/assembler_mips32r6_test.cc b/compiler/utils/mips/assembler_mips32r6_test.cc
index ce92d60..49ef272 100644
--- a/compiler/utils/mips/assembler_mips32r6_test.cc
+++ b/compiler/utils/mips/assembler_mips32r6_test.cc
@@ -48,8 +48,30 @@
return "mips";
}
+ std::string GetAssemblerCmdName() OVERRIDE {
+ // We assemble and link for MIPS32R6. See GetAssemblerParameters() for details.
+ return "gcc";
+ }
+
std::string GetAssemblerParameters() OVERRIDE {
- return " --no-warn -32 -march=mips32r6";
+ // We assemble and link for MIPS32R6. The reason is that object files produced for MIPS32R6
+ // (and MIPS64R6) with the GNU assembler don't have correct final offsets in PC-relative
+ // branches in the .text section and so they require a relocation pass (there's a relocation
+ // section, .rela.text, that has the needed info to fix up the branches).
+ // We use "-modd-spreg" so we can use odd-numbered single precision FPU registers.
+ // We put the code at address 0x1000000 (instead of 0) to avoid overlapping with the
+ // .MIPS.abiflags section (there doesn't seem to be a way to suppress its generation easily).
+ return " -march=mips32r6 -modd-spreg -Wa,--no-warn"
+ " -Wl,-Ttext=0x1000000 -Wl,-e0x1000000 -nostdlib";
+ }
+
+ void Pad(std::vector<uint8_t>& data) OVERRIDE {
+ // The GNU linker unconditionally pads the code segment with NOPs to a size that is a multiple
+ // of 16 and there doesn't appear to be a way to suppress this padding. Our assembler doesn't
+ // pad, so, in order for two assembler outputs to match, we need to match the padding as well.
+ // NOP is encoded as four zero bytes on MIPS.
+ size_t pad_size = RoundUp(data.size(), 16u) - data.size();
+ data.insert(data.end(), pad_size, 0);
}
std::string GetDisassembleParameters() OVERRIDE {
@@ -272,6 +294,21 @@
DriverStr(RepeatRRIb(&mips::MipsAssembler::Aui, 16, "aui ${reg1}, ${reg2}, {imm}"), "Aui");
}
+TEST_F(AssemblerMIPS32r6Test, Auipc) {
+ DriverStr(RepeatRIb(&mips::MipsAssembler::Auipc, 16, "auipc ${reg}, {imm}"), "Auipc");
+}
+
+TEST_F(AssemblerMIPS32r6Test, Lwpc) {
+ // Lwpc() takes an unsigned 19-bit immediate, while the GNU assembler needs a signed offset,
+ // hence the sign extension from bit 18 with `imm - ((imm & 0x40000) << 1)`.
+ // The GNU assembler also wants the offset to be a multiple of 4, which it will shift right
+ // by 2 positions when encoding, hence `<< 2` to compensate for that shift.
+ // We capture the value of the immediate with `.set imm, {imm}` because the value is needed
+ // twice for the sign extension, but `{imm}` is substituted only once.
+ const char* code = ".set imm, {imm}\nlw ${reg}, ((imm - ((imm & 0x40000) << 1)) << 2)($pc)";
+ DriverStr(RepeatRIb(&mips::MipsAssembler::Lwpc, 19, code), "Lwpc");
+}
+
TEST_F(AssemblerMIPS32r6Test, Bitswap) {
DriverStr(RepeatRR(&mips::MipsAssembler::Bitswap, "bitswap ${reg1}, ${reg2}"), "bitswap");
}
@@ -598,12 +635,45 @@
DriverStr(expected, "StoreDToOffset");
}
+TEST_F(AssemblerMIPS32r6Test, LoadFarthestNearLiteral) {
+ mips::Literal* literal = __ NewLiteral<uint32_t>(0x12345678);
+ __ LoadLiteral(mips::V0, mips::ZERO, literal);
+ constexpr size_t kAdduCount = 0x3FFDE;
+ for (size_t i = 0; i != kAdduCount; ++i) {
+ __ Addu(mips::ZERO, mips::ZERO, mips::ZERO);
+ }
+
+ std::string expected =
+ "lwpc $v0, 1f\n" +
+ RepeatInsn(kAdduCount, "addu $zero, $zero, $zero\n") +
+ "1:\n"
+ ".word 0x12345678\n";
+ DriverStr(expected, "LoadFarthestNearLiteral");
+}
+
+TEST_F(AssemblerMIPS32r6Test, LoadNearestFarLiteral) {
+ mips::Literal* literal = __ NewLiteral<uint32_t>(0x12345678);
+ __ LoadLiteral(mips::V0, mips::ZERO, literal);
+ constexpr size_t kAdduCount = 0x3FFDF;
+ for (size_t i = 0; i != kAdduCount; ++i) {
+ __ Addu(mips::ZERO, mips::ZERO, mips::ZERO);
+ }
+
+ std::string expected =
+ "1:\n"
+ "auipc $at, %hi(2f - 1b)\n"
+ "lw $v0, %lo(2f - 1b)($at)\n" +
+ RepeatInsn(kAdduCount, "addu $zero, $zero, $zero\n") +
+ "2:\n"
+ ".word 0x12345678\n";
+ DriverStr(expected, "LoadNearestFarLiteral");
+}
+
//////////////
// BRANCHES //
//////////////
-// TODO: MipsAssembler::Auipc
-// MipsAssembler::Addiupc
+// TODO: MipsAssembler::Addiupc
// MipsAssembler::Bc
// MipsAssembler::Jic
// MipsAssembler::Jialc
diff --git a/compiler/utils/mips/assembler_mips_test.cc b/compiler/utils/mips/assembler_mips_test.cc
index c722d0c..50a8dc2 100644
--- a/compiler/utils/mips/assembler_mips_test.cc
+++ b/compiler/utils/mips/assembler_mips_test.cc
@@ -647,6 +647,26 @@
DriverStr(RepeatRRIb(&mips::MipsAssembler::Movt, 3, "movt ${reg1}, ${reg2}, $fcc{imm}"), "Movt");
}
+TEST_F(AssemblerMIPSTest, MovfS) {
+ DriverStr(RepeatFFIb(&mips::MipsAssembler::MovfS, 3, "movf.s ${reg1}, ${reg2}, $fcc{imm}"),
+ "MovfS");
+}
+
+TEST_F(AssemblerMIPSTest, MovfD) {
+ DriverStr(RepeatFFIb(&mips::MipsAssembler::MovfD, 3, "movf.d ${reg1}, ${reg2}, $fcc{imm}"),
+ "MovfD");
+}
+
+TEST_F(AssemblerMIPSTest, MovtS) {
+ DriverStr(RepeatFFIb(&mips::MipsAssembler::MovtS, 3, "movt.s ${reg1}, ${reg2}, $fcc{imm}"),
+ "MovtS");
+}
+
+TEST_F(AssemblerMIPSTest, MovtD) {
+ DriverStr(RepeatFFIb(&mips::MipsAssembler::MovtD, 3, "movt.d ${reg1}, ${reg2}, $fcc{imm}"),
+ "MovtD");
+}
+
TEST_F(AssemblerMIPSTest, CvtSW) {
DriverStr(RepeatFF(&mips::MipsAssembler::Cvtsw, "cvt.s.w ${reg1}, ${reg2}"), "CvtSW");
}
@@ -2273,6 +2293,44 @@
DriverStr(expected, "LoadConst32");
}
+TEST_F(AssemblerMIPSTest, LoadFarthestNearLiteral) {
+ mips::Literal* literal = __ NewLiteral<uint32_t>(0x12345678);
+ __ BindPcRelBaseLabel();
+ __ LoadLiteral(mips::V0, mips::V1, literal);
+ constexpr size_t kAddiuCount = 0x1FDE;
+ for (size_t i = 0; i != kAddiuCount; ++i) {
+ __ Addiu(mips::A0, mips::A1, 0);
+ }
+
+ std::string expected =
+ "1:\n"
+ "lw $v0, %lo(2f - 1b)($v1)\n" +
+ RepeatInsn(kAddiuCount, "addiu $a0, $a1, %hi(2f - 1b)\n") +
+ "2:\n"
+ ".word 0x12345678\n";
+ DriverStr(expected, "LoadFarthestNearLiteral");
+}
+
+TEST_F(AssemblerMIPSTest, LoadNearestFarLiteral) {
+ mips::Literal* literal = __ NewLiteral<uint32_t>(0x12345678);
+ __ BindPcRelBaseLabel();
+ __ LoadLiteral(mips::V0, mips::V1, literal);
+ constexpr size_t kAdduCount = 0x1FDF;
+ for (size_t i = 0; i != kAdduCount; ++i) {
+ __ Addu(mips::ZERO, mips::ZERO, mips::ZERO);
+ }
+
+ std::string expected =
+ "1:\n"
+ "lui $at, %hi(2f - 1b)\n"
+ "addu $at, $at, $v1\n"
+ "lw $v0, %lo(2f - 1b)($at)\n" +
+ RepeatInsn(kAdduCount, "addu $zero, $zero, $zero\n") +
+ "2:\n"
+ ".word 0x12345678\n";
+ DriverStr(expected, "LoadNearestFarLiteral");
+}
+
#undef __
} // namespace art
diff --git a/compiler/utils/transform_array_ref.h b/compiler/utils/transform_array_ref.h
index 6297b88..a6da34f 100644
--- a/compiler/utils/transform_array_ref.h
+++ b/compiler/utils/transform_array_ref.h
@@ -70,6 +70,11 @@
TransformArrayRef(const ArrayRef<OtherBT>& base, Function fn)
: data_(base, fn) { }
+ template <typename OtherBT,
+ typename = typename std::enable_if<std::is_same<BaseType, const OtherBT>::value>::type>
+ TransformArrayRef(const TransformArrayRef<OtherBT, Function>& other)
+ : TransformArrayRef(other.base(), other.GetFunction()) { }
+
// Assignment operators.
TransformArrayRef& operator=(const TransformArrayRef& other) = default;
@@ -149,6 +154,9 @@
}
Data data_;
+
+ template <typename OtherBT, typename OtherFunction>
+ friend class TransformArrayRef;
};
template <typename BaseType, typename Function>
diff --git a/compiler/utils/transform_array_ref_test.cc b/compiler/utils/transform_array_ref_test.cc
index 2593fad..8d71fd7 100644
--- a/compiler/utils/transform_array_ref_test.cc
+++ b/compiler/utils/transform_array_ref_test.cc
@@ -160,6 +160,48 @@
taref[i] = transform_input[i];
}
ASSERT_EQ(std::vector<ValueHolder>({ 24, 37, 11, 71 }), transformed);
+
+ const std::vector<ValueHolder>& cinput = input;
+
+ auto ctaref = MakeTransformArrayRef(cinput, ref);
+ static_assert(std::is_same<int, decltype(ctaref)::value_type>::value, "value_type");
+ static_assert(std::is_same<const int*, decltype(ctaref)::pointer>::value, "pointer");
+ static_assert(std::is_same<const int&, decltype(ctaref)::reference>::value, "reference");
+ static_assert(std::is_same<const int*, decltype(ctaref)::const_pointer>::value, "const_pointer");
+ static_assert(std::is_same<const int&, decltype(ctaref)::const_reference>::value,
+ "const_reference");
+
+ std::copy(ctaref.begin(), ctaref.end(), std::back_inserter(output));
+ ASSERT_EQ(std::vector<int>({ 1, 0, 1, 0, 3, 1 }), output);
+ output.clear();
+
+ std::copy(ctaref.cbegin(), ctaref.cend(), std::back_inserter(output));
+ ASSERT_EQ(std::vector<int>({ 1, 0, 1, 0, 3, 1 }), output);
+ output.clear();
+
+ std::copy(ctaref.rbegin(), ctaref.rend(), std::back_inserter(output));
+ ASSERT_EQ(std::vector<int>({ 1, 3, 0, 1, 0, 1 }), output);
+ output.clear();
+
+ std::copy(ctaref.crbegin(), ctaref.crend(), std::back_inserter(output));
+ ASSERT_EQ(std::vector<int>({ 1, 3, 0, 1, 0, 1 }), output);
+ output.clear();
+
+ ASSERT_EQ(cinput.size(), ctaref.size());
+ ASSERT_EQ(cinput.empty(), ctaref.empty());
+ ASSERT_EQ(cinput.front().value, ctaref.front());
+ ASSERT_EQ(cinput.back().value, ctaref.back());
+
+ for (size_t i = 0; i != cinput.size(); ++i) {
+ ASSERT_EQ(cinput[i].value, ctaref[i]);
+ }
+
+ // Test conversion adding const.
+ decltype(ctaref) ctaref2 = taref;
+ ASSERT_EQ(taref.size(), ctaref2.size());
+ for (size_t i = 0; i != taref.size(); ++i) {
+ ASSERT_EQ(taref[i], ctaref2[i]);
+ }
}
} // namespace art
diff --git a/compiler/utils/transform_iterator.h b/compiler/utils/transform_iterator.h
index f0769d4..3bc9046 100644
--- a/compiler/utils/transform_iterator.h
+++ b/compiler/utils/transform_iterator.h
@@ -44,11 +44,7 @@
typename std::iterator_traits<BaseIterator>::iterator_category>::value,
"Transform iterator base must be an input iterator.");
- using InputType =
- typename std::conditional<
- std::is_same<void, typename std::iterator_traits<BaseIterator>::reference>::value,
- typename std::iterator_traits<BaseIterator>::value_type,
- typename std::iterator_traits<BaseIterator>::reference>::type;
+ using InputType = typename std::iterator_traits<BaseIterator>::reference;
using ResultType = typename std::result_of<Function(InputType)>::type;
public:
diff --git a/compiler/utils/transform_iterator_test.cc b/compiler/utils/transform_iterator_test.cc
index dbb4779..57ff0a6 100644
--- a/compiler/utils/transform_iterator_test.cc
+++ b/compiler/utils/transform_iterator_test.cc
@@ -20,8 +20,6 @@
#include <type_traits>
#include <vector>
-#include <array>
-
#include "gtest/gtest.h"
#include "utils/transform_iterator.h"
diff --git a/dex2oat/dex2oat_test.cc b/dex2oat/dex2oat_test.cc
index 6188883..93351e9 100644
--- a/dex2oat/dex2oat_test.cc
+++ b/dex2oat/dex2oat_test.cc
@@ -154,33 +154,44 @@
CHECK(android_root != nullptr);
argv.push_back("--android-root=" + std::string(android_root));
- std::string command_line(Join(argv, ' '));
+ int link[2];
- // We need to fix up the '&' being used for "do not check classpath."
- size_t ampersand = command_line.find(" &");
- CHECK_NE(ampersand, std::string::npos);
- command_line = command_line.replace(ampersand, 2, " \\&");
+ if (pipe(link) == -1) {
+ return false;
+ }
- command_line += " 2>&1";
+ pid_t pid = fork();
+ if (pid == -1) {
+ return false;
+ }
- // We need dex2oat to actually log things.
- setenv("ANDROID_LOG_TAGS", "*:d", 1);
-
- FILE* pipe = popen(command_line.c_str(), "r");
-
- setenv("ANDROID_LOG_TAGS", "*:e", 1);
-
- if (pipe == nullptr) {
- success_ = false;
- } else {
- char buffer[128];
-
- while (fgets(buffer, 128, pipe) != nullptr) {
- output_ += buffer;
+ if (pid == 0) {
+ // We need dex2oat to actually log things.
+ setenv("ANDROID_LOG_TAGS", "*:d", 1);
+ dup2(link[1], STDERR_FILENO);
+ close(link[0]);
+ close(link[1]);
+ std::vector<const char*> c_args;
+ for (const std::string& str : argv) {
+ c_args.push_back(str.c_str());
}
+ c_args.push_back(nullptr);
+ execv(c_args[0], const_cast<char* const*>(c_args.data()));
+ exit(1);
+ } else {
+ close(link[1]);
+ char buffer[128];
+ memset(buffer, 0, 128);
+ ssize_t bytes_read = 0;
- int result = pclose(pipe);
- success_ = result == 0;
+ while (TEMP_FAILURE_RETRY(bytes_read = read(link[0], buffer, 128)) > 0) {
+ output_ += std::string(buffer, bytes_read);
+ }
+ close(link[0]);
+ int status = 0;
+ if (waitpid(pid, &status, 0) != -1) {
+ success_ = (status == 0);
+ }
}
return success_;
}
diff --git a/disassembler/disassembler_mips.cc b/disassembler/disassembler_mips.cc
index a95ea64..769263e 100644
--- a/disassembler/disassembler_mips.cc
+++ b/disassembler/disassembler_mips.cc
@@ -330,8 +330,10 @@
{ kITypeMask, 55u << kOpcodeShift, "ld", "TO", },
{ kITypeMask, 56u << kOpcodeShift, "sc", "TO", },
{ kITypeMask, 57u << kOpcodeShift, "swc1", "tO", },
+ { kJTypeMask, 58u << kOpcodeShift, "balc", "P" },
{ kITypeMask | (0x1f << 16), (59u << kOpcodeShift) | (30 << 16), "auipc", "Si" },
{ kITypeMask | (0x3 << 19), (59u << kOpcodeShift) | (0 << 19), "addiupc", "Sp" },
+ { kITypeMask | (0x3 << 19), (59u << kOpcodeShift) | (1 << 19), "lwpc", "So" },
{ kITypeMask, 61u << kOpcodeShift, "sdc1", "tO", },
{ kITypeMask | (0x1f << 21), 62u << kOpcodeShift, "jialc", "Ti" },
{ kITypeMask | (1 << 21), (62u << kOpcodeShift) | (1 << 21), "bnezc", "Sb" }, // TODO: de-dup?
@@ -384,6 +386,8 @@
{ kFpMask | (0x21f << 16), kCop1 | (0x200 << 16) | 13, "trunc.w", "fad" },
{ kFpMask | (0x21f << 16), kCop1 | (0x200 << 16) | 14, "ceil.w", "fad" },
{ kFpMask | (0x21f << 16), kCop1 | (0x200 << 16) | 15, "floor.w", "fad" },
+ { kFpMask | (0x201 << 16), kCop1 | (0x200 << 16) | 17, "movf", "fadc" },
+ { kFpMask | (0x201 << 16), kCop1 | (0x201 << 16) | 17, "movt", "fadc" },
{ kFpMask | (0x21f << 16), kCop1 | (0x200 << 16) | 26, "rint", "fad" },
{ kFpMask | (0x21f << 16), kCop1 | (0x200 << 16) | 27, "class", "fad" },
{ kFpMask | (0x21f << 16), kCop1 | (0x200 << 16) | 32, "cvt.s", "fad" },
@@ -507,7 +511,15 @@
}
}
break;
- case 'P': // 26-bit offset in bc.
+ case 'o': // 19-bit offset in lwpc.
+ {
+ int32_t offset = (instruction & 0x7ffff) - ((instruction & 0x40000) << 1);
+ offset <<= 2;
+ args << FormatInstructionPointer(instr_ptr + offset);
+ args << StringPrintf(" ; %+d", offset);
+ }
+ break;
+ case 'P': // 26-bit offset in bc and balc.
{
int32_t offset = (instruction & 0x3ffffff) - ((instruction & 0x2000000) << 1);
offset <<= 2;
@@ -538,6 +550,7 @@
}
}
+ // TODO: Simplify this once these sequences are simplified in the compiler.
// Special cases for sequences of:
// pc-relative +/- 2GB branch:
// auipc reg, imm
diff --git a/oatdump/oatdump.cc b/oatdump/oatdump.cc
index bb35f8d..3f031a3 100644
--- a/oatdump/oatdump.cc
+++ b/oatdump/oatdump.cc
@@ -1751,7 +1751,7 @@
const auto& method_section = state->image_header_.GetMethodsSection();
size_t num_methods = dex_cache->NumResolvedMethods();
if (num_methods != 0u) {
- os << "Methods (size=" << num_methods << "):";
+ os << "Methods (size=" << num_methods << "):\n";
ScopedIndentation indent2(&state->vios_);
auto* resolved_methods = dex_cache->GetResolvedMethods();
for (size_t i = 0, length = dex_cache->NumResolvedMethods(); i < length; ++i) {
@@ -1760,10 +1760,12 @@
image_pointer_size);
size_t run = 0;
for (size_t j = i + 1;
- j != length && elem == mirror::DexCache::GetElementPtrSize(resolved_methods,
- j,
- image_pointer_size);
- ++j, ++run) {}
+ j != length && elem == mirror::DexCache::GetElementPtrSize(resolved_methods,
+ j,
+ image_pointer_size);
+ ++j) {
+ ++run;
+ }
if (run == 0) {
os << StringPrintf("%zd: ", i);
} else {
@@ -1784,17 +1786,20 @@
}
size_t num_fields = dex_cache->NumResolvedFields();
if (num_fields != 0u) {
- os << "Fields (size=" << num_fields << "):";
+ os << "Fields (size=" << num_fields << "):\n";
ScopedIndentation indent2(&state->vios_);
auto* resolved_fields = dex_cache->GetResolvedFields();
for (size_t i = 0, length = dex_cache->NumResolvedFields(); i < length; ++i) {
- auto* elem = mirror::DexCache::GetElementPtrSize(resolved_fields, i, image_pointer_size);
+ auto* elem = mirror::DexCache::GetElementPtrSize(
+ resolved_fields, i, image_pointer_size);
size_t run = 0;
for (size_t j = i + 1;
- j != length && elem == mirror::DexCache::GetElementPtrSize(resolved_fields,
- j,
- image_pointer_size);
- ++j, ++run) {}
+ j != length && elem == mirror::DexCache::GetElementPtrSize(resolved_fields,
+ j,
+ image_pointer_size);
+ ++j) {
+ ++run;
+ }
if (run == 0) {
os << StringPrintf("%zd: ", i);
} else {
@@ -1813,6 +1818,32 @@
os << StringPrintf("%p %s\n", elem, msg.c_str());
}
}
+ size_t num_types = dex_cache->NumResolvedTypes();
+ if (num_types != 0u) {
+ os << "Types (size=" << num_types << "):\n";
+ ScopedIndentation indent2(&state->vios_);
+ auto* resolved_types = dex_cache->GetResolvedTypes();
+ for (size_t i = 0; i < num_types; ++i) {
+ auto* elem = resolved_types[i].Read();
+ size_t run = 0;
+ for (size_t j = i + 1; j != num_types && elem == resolved_types[j].Read(); ++j) {
+ ++run;
+ }
+ if (run == 0) {
+ os << StringPrintf("%zd: ", i);
+ } else {
+ os << StringPrintf("%zd to %zd: ", i, i + run);
+ i = i + run;
+ }
+ std::string msg;
+ if (elem == nullptr) {
+ msg = "null";
+ } else {
+ msg = PrettyClass(elem);
+ }
+ os << StringPrintf("%p %s\n", elem, msg.c_str());
+ }
+ }
}
}
std::string temp;
diff --git a/patchoat/patchoat.cc b/patchoat/patchoat.cc
index 0a7ffda..5bb61bb 100644
--- a/patchoat/patchoat.cc
+++ b/patchoat/patchoat.cc
@@ -494,6 +494,17 @@
image_header->VisitPackedArtMethods(&visitor, heap_->Begin(), pointer_size);
}
+void PatchOat::PatchImTables(const ImageHeader* image_header) {
+ const size_t pointer_size = InstructionSetPointerSize(isa_);
+ // We can safely walk target image since the conflict tables are independent.
+ image_header->VisitPackedImTables(
+ [this](ArtMethod* method) {
+ return RelocatedAddressOfPointer(method);
+ },
+ image_->Begin(),
+ pointer_size);
+}
+
void PatchOat::PatchImtConflictTables(const ImageHeader* image_header) {
const size_t pointer_size = InstructionSetPointerSize(isa_);
// We can safely walk target image since the conflict tables are independent.
@@ -636,6 +647,7 @@
PatchArtFields(image_header);
PatchArtMethods(image_header);
+ PatchImTables(image_header);
PatchImtConflictTables(image_header);
PatchInternedStrings(image_header);
PatchClassTable(image_header);
diff --git a/patchoat/patchoat.h b/patchoat/patchoat.h
index 3ef837f..61ec695 100644
--- a/patchoat/patchoat.h
+++ b/patchoat/patchoat.h
@@ -117,6 +117,7 @@
bool PatchImage(bool primary_image) SHARED_REQUIRES(Locks::mutator_lock_);
void PatchArtFields(const ImageHeader* image_header) SHARED_REQUIRES(Locks::mutator_lock_);
void PatchArtMethods(const ImageHeader* image_header) SHARED_REQUIRES(Locks::mutator_lock_);
+ void PatchImTables(const ImageHeader* image_header) SHARED_REQUIRES(Locks::mutator_lock_);
void PatchImtConflictTables(const ImageHeader* image_header)
SHARED_REQUIRES(Locks::mutator_lock_);
void PatchInternedStrings(const ImageHeader* image_header)
diff --git a/runtime/arch/arm/quick_entrypoints_arm.S b/runtime/arch/arm/quick_entrypoints_arm.S
index 0797def..d940164 100644
--- a/runtime/arch/arm/quick_entrypoints_arm.S
+++ b/runtime/arch/arm/quick_entrypoints_arm.S
@@ -88,12 +88,6 @@
#endif
.endm
- // Ugly compile-time check, but we only have the preprocessor.
-#if (FRAME_SIZE_REFS_ONLY_CALLEE_SAVE != 28 + 4)
-#error "REFS_ONLY_CALLEE_SAVE_FRAME(ARM) size not as expected."
-#endif
-.endm
-
.macro RESTORE_REFS_ONLY_CALLEE_SAVE_FRAME
add sp, #4 @ bottom word holds Method*
.cfi_adjust_cfa_offset -4
diff --git a/runtime/arch/mips/entrypoints_direct_mips.h b/runtime/arch/mips/entrypoints_direct_mips.h
index 0d01ad5..5b74d62 100644
--- a/runtime/arch/mips/entrypoints_direct_mips.h
+++ b/runtime/arch/mips/entrypoints_direct_mips.h
@@ -45,6 +45,7 @@
entrypoint == kQuickCmpgFloat ||
entrypoint == kQuickCmplDouble ||
entrypoint == kQuickCmplFloat ||
+ entrypoint == kQuickReadBarrierJni ||
entrypoint == kQuickReadBarrierMark ||
entrypoint == kQuickReadBarrierSlow ||
entrypoint == kQuickReadBarrierForRootSlow;
diff --git a/runtime/arch/mips/entrypoints_init_mips.cc b/runtime/arch/mips/entrypoints_init_mips.cc
index 833ba1b..6697a8d 100644
--- a/runtime/arch/mips/entrypoints_init_mips.cc
+++ b/runtime/arch/mips/entrypoints_init_mips.cc
@@ -283,7 +283,7 @@
// Read barrier.
qpoints->pReadBarrierJni = ReadBarrierJni;
- static_assert(!IsDirectEntrypoint(kQuickReadBarrierJni), "Non-direct C stub marked direct.");
+ static_assert(IsDirectEntrypoint(kQuickReadBarrierJni), "Direct C stub not marked direct.");
qpoints->pReadBarrierMark = artReadBarrierMark;
static_assert(IsDirectEntrypoint(kQuickReadBarrierMark), "Direct C stub not marked direct.");
qpoints->pReadBarrierSlow = artReadBarrierSlow;
diff --git a/runtime/arch/mips/fault_handler_mips.cc b/runtime/arch/mips/fault_handler_mips.cc
index 754284c..7969a8f 100644
--- a/runtime/arch/mips/fault_handler_mips.cc
+++ b/runtime/arch/mips/fault_handler_mips.cc
@@ -44,7 +44,7 @@
uintptr_t* out_return_pc, uintptr_t* out_sp) {
struct ucontext* uc = reinterpret_cast<struct ucontext*>(context);
struct sigcontext *sc = reinterpret_cast<struct sigcontext*>(&uc->uc_mcontext);
- *out_sp = static_cast<uintptr_t>(sc->sc_regs[29]); // SP register
+ *out_sp = static_cast<uintptr_t>(sc->sc_regs[mips::SP]);
VLOG(signals) << "sp: " << *out_sp;
if (*out_sp == 0) {
return;
@@ -56,7 +56,7 @@
uintptr_t* overflow_addr = reinterpret_cast<uintptr_t*>(
reinterpret_cast<uint8_t*>(*out_sp) - GetStackOverflowReservedBytes(kMips));
if (overflow_addr == fault_addr) {
- *out_method = reinterpret_cast<ArtMethod*>(sc->sc_regs[4]); // A0 register
+ *out_method = reinterpret_cast<ArtMethod*>(sc->sc_regs[mips::A0]);
} else {
// The method is at the top of the stack.
*out_method = *reinterpret_cast<ArtMethod**>(*out_sp);
@@ -82,12 +82,12 @@
struct ucontext *uc = reinterpret_cast<struct ucontext*>(context);
struct sigcontext *sc = reinterpret_cast<struct sigcontext*>(&uc->uc_mcontext);
- sc->sc_regs[31] = sc->sc_pc + 4; // RA needs to point to gc map location
+ sc->sc_regs[mips::RA] = sc->sc_pc + 4; // RA needs to point to gc map location
sc->sc_pc = reinterpret_cast<uintptr_t>(art_quick_throw_null_pointer_exception_from_signal);
- sc->sc_regs[25] = sc->sc_pc; // make sure T9 points to the function
+ sc->sc_regs[mips::T9] = sc->sc_pc; // make sure T9 points to the function
// Pass the faulting address as the first argument of
// art_quick_throw_null_pointer_exception_from_signal.
- sc->sc_regs[0] = reinterpret_cast<uintptr_t>(info->si_addr);
+ sc->sc_regs[mips::A0] = reinterpret_cast<uintptr_t>(info->si_addr);
VLOG(signals) << "Generating null pointer exception";
return true;
}
@@ -116,7 +116,7 @@
VLOG(signals) << "stack overflow handler with sp at " << std::hex << &uc;
VLOG(signals) << "sigcontext: " << std::hex << sc;
- uintptr_t sp = sc->sc_regs[29]; // SP register
+ uintptr_t sp = sc->sc_regs[mips::SP];
VLOG(signals) << "sp: " << std::hex << sp;
uintptr_t fault_addr = reinterpret_cast<uintptr_t>(info->si_addr); // BVA addr
@@ -139,7 +139,7 @@
// caused this fault. This will be inserted into a callee save frame by
// the function to which this handler returns (art_quick_throw_stack_overflow).
sc->sc_pc = reinterpret_cast<uintptr_t>(art_quick_throw_stack_overflow);
- sc->sc_regs[25] = sc->sc_pc; // make sure T9 points to the function
+ sc->sc_regs[mips::T9] = sc->sc_pc; // make sure T9 points to the function
// The kernel will now return to the address in sc->arm_pc.
return true;
diff --git a/runtime/arch/mips/instruction_set_features_mips.cc b/runtime/arch/mips/instruction_set_features_mips.cc
index 93d79b7..b3a9866 100644
--- a/runtime/arch/mips/instruction_set_features_mips.cc
+++ b/runtime/arch/mips/instruction_set_features_mips.cc
@@ -76,21 +76,22 @@
GetFlagsFromCppDefined(&mips_isa_gte2, &r6, &fpu_32bit);
// Override defaults based on variant string.
- // Only care if it is R1, R2 or R6 and we assume all CPUs will have a FP unit.
+ // Only care if it is R1, R2, R5 or R6 and we assume all CPUs will have a FP unit.
constexpr const char* kMips32Prefix = "mips32r";
const size_t kPrefixLength = strlen(kMips32Prefix);
if (variant.compare(0, kPrefixLength, kMips32Prefix, kPrefixLength) == 0 &&
variant.size() > kPrefixLength) {
- if (variant[kPrefixLength] >= '6') {
- fpu_32bit = false;
- r6 = true;
- }
- if (variant[kPrefixLength] >= '2') {
- mips_isa_gte2 = true;
- }
+ r6 = (variant[kPrefixLength] >= '6');
+ fpu_32bit = (variant[kPrefixLength] < '5');
+ mips_isa_gte2 = (variant[kPrefixLength] >= '2');
} else if (variant == "default") {
- // Default variant is: smp = true, has fpu, is gte2, is not r6. This is the traditional
- // setting.
+ // Default variant is: smp = true, has FPU, is gte2. This is the traditional setting.
+ //
+ // Note, we get FPU bitness and R6-ness from the build (using cpp defines, see above)
+ // and don't override them because many things depend on the "default" variant being
+ // sufficient for most purposes. That is, "default" should work for both R2 and R6.
+ // Use "mips32r#" to get a specific configuration, possibly not matching the runtime
+ // ISA (e.g. for ISA-specific testing of dex2oat internals).
mips_isa_gte2 = true;
} else {
LOG(WARNING) << "Unexpected CPU variant for Mips32 using defaults: " << variant;
diff --git a/runtime/arch/mips/instruction_set_features_mips.h b/runtime/arch/mips/instruction_set_features_mips.h
index aac436e..120dc1c 100644
--- a/runtime/arch/mips/instruction_set_features_mips.h
+++ b/runtime/arch/mips/instruction_set_features_mips.h
@@ -81,8 +81,19 @@
private:
MipsInstructionSetFeatures(bool smp, bool fpu_32bit, bool mips_isa_gte2, bool r6)
- : InstructionSetFeatures(smp), fpu_32bit_(fpu_32bit), mips_isa_gte2_(mips_isa_gte2), r6_(r6)
- {}
+ : InstructionSetFeatures(smp),
+ fpu_32bit_(fpu_32bit),
+ mips_isa_gte2_(mips_isa_gte2),
+ r6_(r6) {
+ // Sanity checks.
+ if (r6) {
+ CHECK(mips_isa_gte2);
+ CHECK(!fpu_32bit);
+ }
+ if (!mips_isa_gte2) {
+ CHECK(fpu_32bit);
+ }
+ }
// Bitmap positions for encoding features as a bitmap.
enum {
diff --git a/runtime/arch/mips64/fault_handler_mips64.cc b/runtime/arch/mips64/fault_handler_mips64.cc
index c9a32ad..0bbb6e1 100644
--- a/runtime/arch/mips64/fault_handler_mips64.cc
+++ b/runtime/arch/mips64/fault_handler_mips64.cc
@@ -44,7 +44,7 @@
uintptr_t* out_return_pc, uintptr_t* out_sp) {
struct ucontext* uc = reinterpret_cast<struct ucontext*>(context);
struct sigcontext *sc = reinterpret_cast<struct sigcontext*>(&uc->uc_mcontext);
- *out_sp = static_cast<uintptr_t>(sc->sc_regs[29]); // SP register
+ *out_sp = static_cast<uintptr_t>(sc->sc_regs[mips64::SP]);
VLOG(signals) << "sp: " << *out_sp;
if (*out_sp == 0) {
return;
@@ -56,7 +56,7 @@
uintptr_t* overflow_addr = reinterpret_cast<uintptr_t*>(
reinterpret_cast<uint8_t*>(*out_sp) - GetStackOverflowReservedBytes(kMips64));
if (overflow_addr == fault_addr) {
- *out_method = reinterpret_cast<ArtMethod*>(sc->sc_regs[4]); // A0 register
+ *out_method = reinterpret_cast<ArtMethod*>(sc->sc_regs[mips64::A0]);
} else {
// The method is at the top of the stack.
*out_method = *reinterpret_cast<ArtMethod**>(*out_sp);
@@ -83,12 +83,12 @@
struct ucontext *uc = reinterpret_cast<struct ucontext*>(context);
struct sigcontext *sc = reinterpret_cast<struct sigcontext*>(&uc->uc_mcontext);
- sc->sc_regs[31] = sc->sc_pc + 4; // RA needs to point to gc map location
+ sc->sc_regs[mips64::RA] = sc->sc_pc + 4; // RA needs to point to gc map location
sc->sc_pc = reinterpret_cast<uintptr_t>(art_quick_throw_null_pointer_exception_from_signal);
- sc->sc_regs[25] = sc->sc_pc; // make sure T9 points to the function
+ sc->sc_regs[mips64::T9] = sc->sc_pc; // make sure T9 points to the function
// Pass the faulting address as the first argument of
// art_quick_throw_null_pointer_exception_from_signal.
- sc->sc_regs[0] = reinterpret_cast<uintptr_t>(info->si_addr);
+ sc->sc_regs[mips64::A0] = reinterpret_cast<uintptr_t>(info->si_addr);
VLOG(signals) << "Generating null pointer exception";
return true;
}
@@ -117,7 +117,7 @@
VLOG(signals) << "stack overflow handler with sp at " << std::hex << &uc;
VLOG(signals) << "sigcontext: " << std::hex << sc;
- uintptr_t sp = sc->sc_regs[29]; // SP register
+ uintptr_t sp = sc->sc_regs[mips64::SP];
VLOG(signals) << "sp: " << std::hex << sp;
uintptr_t fault_addr = reinterpret_cast<uintptr_t>(info->si_addr); // BVA addr
@@ -140,7 +140,7 @@
// caused this fault. This will be inserted into a callee save frame by
// the function to which this handler returns (art_quick_throw_stack_overflow).
sc->sc_pc = reinterpret_cast<uintptr_t>(art_quick_throw_stack_overflow);
- sc->sc_regs[25] = sc->sc_pc; // make sure T9 points to the function
+ sc->sc_regs[mips64::T9] = sc->sc_pc; // make sure T9 points to the function
// The kernel will now return to the address in sc->arm_pc.
return true;
diff --git a/runtime/art_method.h b/runtime/art_method.h
index 2b025f8..90b2406 100644
--- a/runtime/art_method.h
+++ b/runtime/art_method.h
@@ -99,6 +99,22 @@
return GetMethod(index * kMethodCount + kMethodImplementation, pointer_size);
}
+ // Return true if two conflict tables are the same.
+ bool Equals(ImtConflictTable* other, size_t pointer_size) const {
+ size_t num = NumEntries(pointer_size);
+ if (num != other->NumEntries(pointer_size)) {
+ return false;
+ }
+ for (size_t i = 0; i < num; ++i) {
+ if (GetInterfaceMethod(i, pointer_size) != other->GetInterfaceMethod(i, pointer_size) ||
+ GetImplementationMethod(i, pointer_size) !=
+ other->GetImplementationMethod(i, pointer_size)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
// Visit all of the entries.
// NO_THREAD_SAFETY_ANALYSIS for calling with held locks. Visitor is passed a pair of ArtMethod*
// and also returns one. The order is <interface, implementation>.
diff --git a/runtime/asm_support.h b/runtime/asm_support.h
index 2d702f6..da68923 100644
--- a/runtime/asm_support.h
+++ b/runtime/asm_support.h
@@ -140,7 +140,7 @@
ADD_TEST_EQ(THREAD_LOCAL_OBJECTS_OFFSET,
art::Thread::ThreadLocalObjectsOffset<__SIZEOF_POINTER__>().Int32Value())
// Offset of field Thread::tlsPtr_.mterp_current_ibase.
-#define THREAD_CURRENT_IBASE_OFFSET (THREAD_LOCAL_OBJECTS_OFFSET + __SIZEOF_POINTER__)
+#define THREAD_CURRENT_IBASE_OFFSET (THREAD_LOCAL_OBJECTS_OFFSET + __SIZEOF_SIZE_T__)
ADD_TEST_EQ(THREAD_CURRENT_IBASE_OFFSET,
art::Thread::MterpCurrentIBaseOffset<__SIZEOF_POINTER__>().Int32Value())
// Offset of field Thread::tlsPtr_.mterp_default_ibase.
diff --git a/runtime/class_linker.cc b/runtime/class_linker.cc
index fe7448f..cb97faa 100644
--- a/runtime/class_linker.cc
+++ b/runtime/class_linker.cc
@@ -857,11 +857,13 @@
if (vtable != nullptr) {
SanityCheckArtMethodPointerArray(vtable, nullptr, pointer_size, image_spaces);
}
- if (klass->ShouldHaveEmbeddedImtAndVTable()) {
- for (size_t i = 0; i < mirror::Class::kImtSize; ++i) {
- SanityCheckArtMethod(
- klass->GetEmbeddedImTableEntry(i, pointer_size), nullptr, image_spaces);
+ if (klass->ShouldHaveImt()) {
+ ImTable* imt = klass->GetImt(pointer_size);
+ for (size_t i = 0; i < ImTable::kSize; ++i) {
+ SanityCheckArtMethod(imt->Get(i, pointer_size), nullptr, image_spaces);
}
+ }
+ if (klass->ShouldHaveEmbeddedVTable()) {
for (int32_t i = 0; i < klass->GetEmbeddedVTableLength(); ++i) {
SanityCheckArtMethod(klass->GetEmbeddedVTableEntry(i, pointer_size), nullptr, image_spaces);
}
@@ -2536,6 +2538,10 @@
CHECK(h_new_class.Get() != nullptr) << descriptor;
CHECK(h_new_class->IsResolved()) << descriptor;
+ // Update the dex cache of where the class is defined. Inlining depends on having
+ // this filled.
+ h_new_class->GetDexCache()->SetResolvedType(h_new_class->GetDexTypeIndex(), h_new_class.Get());
+
// Instrumentation may have updated entrypoints for all methods of all
// classes. However it could not update methods of this class while we
// were loading it. Now the class is resolved, we can update entrypoints
@@ -3456,16 +3462,13 @@
new_class->SetClassFlags(mirror::kClassFlagObjectArray);
}
mirror::Class::SetStatus(new_class, mirror::Class::kStatusLoaded, self);
- {
- ArtMethod* imt[mirror::Class::kImtSize];
- std::fill_n(imt, arraysize(imt), Runtime::Current()->GetImtUnimplementedMethod());
- new_class->PopulateEmbeddedImtAndVTable(imt, image_pointer_size_);
- }
+ new_class->PopulateEmbeddedVTable(image_pointer_size_);
+ ImTable* object_imt = java_lang_Object->GetImt(image_pointer_size_);
+ new_class->SetImt(object_imt, image_pointer_size_);
mirror::Class::SetStatus(new_class, mirror::Class::kStatusInitialized, self);
// don't need to set new_class->SetObjectSize(..)
// because Object::SizeOf delegates to Array::SizeOf
-
// All arrays have java/lang/Cloneable and java/io/Serializable as
// interfaces. We need to set that up here, so that stuff like
// "instanceof" works right.
@@ -5026,6 +5029,17 @@
return class_loader == nullptr ? &boot_class_table_ : class_loader->GetClassTable();
}
+static ImTable* FindSuperImt(mirror::Class* klass, size_t pointer_size)
+ SHARED_REQUIRES(Locks::mutator_lock_) {
+ while (klass->HasSuperClass()) {
+ klass = klass->GetSuperClass();
+ if (klass->ShouldHaveImt()) {
+ return klass->GetImt(pointer_size);
+ }
+ }
+ return nullptr;
+}
+
bool ClassLinker::LinkClass(Thread* self,
const char* descriptor,
Handle<mirror::Class> klass,
@@ -5036,9 +5050,11 @@
if (!LinkSuperClass(klass)) {
return false;
}
- ArtMethod* imt[mirror::Class::kImtSize];
- std::fill_n(imt, arraysize(imt), Runtime::Current()->GetImtUnimplementedMethod());
- if (!LinkMethods(self, klass, interfaces, imt)) {
+ ArtMethod* imt_data[ImTable::kSize];
+ // If there are any new conflicts compared to super class.
+ bool new_conflict = false;
+ std::fill_n(imt_data, arraysize(imt_data), Runtime::Current()->GetImtUnimplementedMethod());
+ if (!LinkMethods(self, klass, interfaces, &new_conflict, imt_data)) {
return false;
}
if (!LinkInstanceFields(self, klass)) {
@@ -5051,15 +5067,47 @@
CreateReferenceInstanceOffsets(klass);
CHECK_EQ(mirror::Class::kStatusLoaded, klass->GetStatus());
+ ImTable* imt = nullptr;
+ if (klass->ShouldHaveImt()) {
+ // If there are any new conflicts compared to the super class we can not make a copy. There
+ // can be cases where both will have a conflict method at the same slot without having the same
+ // set of conflicts. In this case, we can not share the IMT since the conflict table slow path
+ // will possibly create a table that is incorrect for either of the classes.
+ // Same IMT with new_conflict does not happen very often.
+ if (!new_conflict) {
+ ImTable* super_imt = FindSuperImt(klass.Get(), image_pointer_size_);
+ if (super_imt != nullptr) {
+ bool imt_equals = true;
+ for (size_t i = 0; i < ImTable::kSize && imt_equals; ++i) {
+ imt_equals = imt_equals && (super_imt->Get(i, image_pointer_size_) == imt_data[i]);
+ }
+ if (imt_equals) {
+ imt = super_imt;
+ }
+ }
+ }
+ if (imt == nullptr) {
+ LinearAlloc* allocator = GetAllocatorForClassLoader(klass->GetClassLoader());
+ imt = reinterpret_cast<ImTable*>(
+ allocator->Alloc(self, ImTable::SizeInBytes(image_pointer_size_)));
+ if (imt == nullptr) {
+ return false;
+ }
+ imt->Populate(imt_data, image_pointer_size_);
+ }
+ }
+
if (!klass->IsTemp() || (!init_done_ && klass->GetClassSize() == class_size)) {
// We don't need to retire this class as it has no embedded tables or it was created the
// correct size during class linker initialization.
CHECK_EQ(klass->GetClassSize(), class_size) << PrettyDescriptor(klass.Get());
- if (klass->ShouldHaveEmbeddedImtAndVTable()) {
- klass->PopulateEmbeddedImtAndVTable(imt, image_pointer_size_);
+ if (klass->ShouldHaveEmbeddedVTable()) {
+ klass->PopulateEmbeddedVTable(image_pointer_size_);
}
-
+ if (klass->ShouldHaveImt()) {
+ klass->SetImt(imt, image_pointer_size_);
+ }
// This will notify waiters on klass that saw the not yet resolved
// class in the class_table_ during EnsureResolved.
mirror::Class::SetStatus(klass, mirror::Class::kStatusResolved, self);
@@ -5451,6 +5499,7 @@
bool ClassLinker::LinkMethods(Thread* self,
Handle<mirror::Class> klass,
Handle<mirror::ObjectArray<mirror::Class>> interfaces,
+ bool* out_new_conflict,
ArtMethod** out_imt) {
self->AllowThreadSuspension();
// A map from vtable indexes to the method they need to be updated to point to. Used because we
@@ -5462,7 +5511,7 @@
// any vtable entries with new default method implementations.
return SetupInterfaceLookupTable(self, klass, interfaces)
&& LinkVirtualMethods(self, klass, /*out*/ &default_translations)
- && LinkInterfaceMethods(self, klass, default_translations, out_imt);
+ && LinkInterfaceMethods(self, klass, default_translations, out_new_conflict, out_imt);
}
// Comparator for name and signature of a method, used in finding overriding methods. Implementation
@@ -5620,7 +5669,7 @@
StackHandleScope<2> hs(self);
Handle<mirror::Class> super_class(hs.NewHandle(klass->GetSuperClass()));
MutableHandle<mirror::PointerArray> vtable;
- if (super_class->ShouldHaveEmbeddedImtAndVTable()) {
+ if (super_class->ShouldHaveEmbeddedVTable()) {
vtable = hs.NewHandle(AllocPointerArray(self, max_count));
if (UNLIKELY(vtable.Get() == nullptr)) {
self->AssertPendingOOMException();
@@ -6020,6 +6069,7 @@
void ClassLinker::SetIMTRef(ArtMethod* unimplemented_method,
ArtMethod* imt_conflict_method,
ArtMethod* current_method,
+ /*out*/bool* new_conflict,
/*out*/ArtMethod** imt_ref) {
// Place method in imt if entry is empty, place conflict otherwise.
if (*imt_ref == unimplemented_method) {
@@ -6036,40 +6086,82 @@
*imt_ref = current_method;
} else {
*imt_ref = imt_conflict_method;
+ *new_conflict = true;
}
} else {
// Place the default conflict method. Note that there may be an existing conflict
// method in the IMT, but it could be one tailored to the super class, with a
// specific ImtConflictTable.
*imt_ref = imt_conflict_method;
+ *new_conflict = true;
}
}
void ClassLinker::FillIMTAndConflictTables(mirror::Class* klass) {
- DCHECK(klass->ShouldHaveEmbeddedImtAndVTable()) << PrettyClass(klass);
+ DCHECK(klass->ShouldHaveImt()) << PrettyClass(klass);
DCHECK(!klass->IsTemp()) << PrettyClass(klass);
- ArtMethod* imt[mirror::Class::kImtSize];
+ ArtMethod* imt_data[ImTable::kSize];
Runtime* const runtime = Runtime::Current();
ArtMethod* const unimplemented_method = runtime->GetImtUnimplementedMethod();
ArtMethod* const conflict_method = runtime->GetImtConflictMethod();
- std::fill_n(imt, arraysize(imt), unimplemented_method);
+ std::fill_n(imt_data, arraysize(imt_data), unimplemented_method);
if (klass->GetIfTable() != nullptr) {
+ bool new_conflict = false;
FillIMTFromIfTable(klass->GetIfTable(),
unimplemented_method,
conflict_method,
klass,
- true,
- false,
- &imt[0]);
+ /*create_conflict_tables*/true,
+ /*ignore_copied_methods*/false,
+ &new_conflict,
+ &imt_data[0]);
}
- for (size_t i = 0; i < mirror::Class::kImtSize; ++i) {
- klass->SetEmbeddedImTableEntry(i, imt[i], image_pointer_size_);
+ if (!klass->ShouldHaveImt()) {
+ return;
+ }
+ // Compare the IMT with the super class including the conflict methods. If they are equivalent,
+ // we can just use the same pointer.
+ ImTable* imt = nullptr;
+ mirror::Class* super_class = klass->GetSuperClass();
+ if (super_class != nullptr && super_class->ShouldHaveImt()) {
+ ImTable* super_imt = super_class->GetImt(image_pointer_size_);
+ bool same = true;
+ for (size_t i = 0; same && i < ImTable::kSize; ++i) {
+ ArtMethod* method = imt_data[i];
+ ArtMethod* super_method = super_imt->Get(i, image_pointer_size_);
+ if (method != super_method) {
+ bool is_conflict_table = method->IsRuntimeMethod() &&
+ method != unimplemented_method &&
+ method != conflict_method;
+ // Verify conflict contents.
+ bool super_conflict_table = super_method->IsRuntimeMethod() &&
+ super_method != unimplemented_method &&
+ super_method != conflict_method;
+ if (!is_conflict_table || !super_conflict_table) {
+ same = false;
+ } else {
+ ImtConflictTable* table1 = method->GetImtConflictTable(image_pointer_size_);
+ ImtConflictTable* table2 = super_method->GetImtConflictTable(image_pointer_size_);
+ same = same && table1->Equals(table2, image_pointer_size_);
+ }
+ }
+ }
+ if (same) {
+ imt = super_imt;
+ }
+ }
+ if (imt == nullptr) {
+ imt = klass->GetImt(image_pointer_size_);
+ DCHECK(imt != nullptr);
+ imt->Populate(imt_data, image_pointer_size_);
+ } else {
+ klass->SetImt(imt, image_pointer_size_);
}
}
static inline uint32_t GetIMTIndex(ArtMethod* interface_method)
SHARED_REQUIRES(Locks::mutator_lock_) {
- return interface_method->GetDexMethodIndex() % mirror::Class::kImtSize;
+ return interface_method->GetDexMethodIndex() % ImTable::kSize;
}
ImtConflictTable* ClassLinker::CreateImtConflictTable(size_t count,
@@ -6091,8 +6183,9 @@
mirror::Class* klass,
bool create_conflict_tables,
bool ignore_copied_methods,
- ArtMethod** imt) {
- uint32_t conflict_counts[mirror::Class::kImtSize] = {};
+ /*out*/bool* new_conflict,
+ /*out*/ArtMethod** imt) {
+ uint32_t conflict_counts[ImTable::kSize] = {};
for (size_t i = 0, length = if_table->Count(); i < length; ++i) {
mirror::Class* interface = if_table->GetInterface(i);
const size_t num_virtuals = interface->NumVirtualMethods();
@@ -6134,6 +6227,7 @@
SetIMTRef(unimplemented_method,
imt_conflict_method,
implementation_method,
+ /*out*/new_conflict,
/*out*/&imt[imt_index]);
}
}
@@ -6141,7 +6235,7 @@
if (create_conflict_tables) {
// Create the conflict tables.
LinearAlloc* linear_alloc = GetAllocatorForClassLoader(klass->GetClassLoader());
- for (size_t i = 0; i < mirror::Class::kImtSize; ++i) {
+ for (size_t i = 0; i < ImTable::kSize; ++i) {
size_t conflicts = conflict_counts[i];
if (imt[i] == imt_conflict_method) {
ImtConflictTable* new_table = CreateImtConflictTable(conflicts, linear_alloc);
@@ -6428,12 +6522,14 @@
void ClassLinker::FillImtFromSuperClass(Handle<mirror::Class> klass,
ArtMethod* unimplemented_method,
ArtMethod* imt_conflict_method,
+ bool* new_conflict,
ArtMethod** imt) {
DCHECK(klass->HasSuperClass());
mirror::Class* super_class = klass->GetSuperClass();
- if (super_class->ShouldHaveEmbeddedImtAndVTable()) {
- for (size_t i = 0; i < mirror::Class::kImtSize; ++i) {
- imt[i] = super_class->GetEmbeddedImTableEntry(i, image_pointer_size_);
+ if (super_class->ShouldHaveImt()) {
+ ImTable* super_imt = super_class->GetImt(image_pointer_size_);
+ for (size_t i = 0; i < ImTable::kSize; ++i) {
+ imt[i] = super_imt->Get(i, image_pointer_size_);
}
} else {
// No imt in the super class, need to reconstruct from the iftable.
@@ -6446,6 +6542,7 @@
klass.Get(),
/*create_conflict_table*/false,
/*ignore_copied_methods*/true,
+ /*out*/new_conflict,
/*out*/imt);
}
}
@@ -6456,6 +6553,7 @@
Thread* self,
Handle<mirror::Class> klass,
const std::unordered_map<size_t, ClassLinker::MethodTranslation>& default_translations,
+ bool* out_new_conflict,
ArtMethod** out_imt) {
StackHandleScope<3> hs(self);
Runtime* const runtime = Runtime::Current();
@@ -6491,6 +6589,7 @@
FillImtFromSuperClass(klass,
unimplemented_method,
imt_conflict_method,
+ out_new_conflict,
out_imt);
}
// Allocate method arrays before since we don't want miss visiting miranda method roots due to
@@ -6622,6 +6721,7 @@
SetIMTRef(unimplemented_method,
imt_conflict_method,
vtable_method,
+ /*out*/out_new_conflict,
/*out*/imt_ptr);
}
break;
@@ -6764,6 +6864,7 @@
SetIMTRef(unimplemented_method,
imt_conflict_method,
current_method,
+ /*out*/out_new_conflict,
/*out*/imt_ptr);
}
}
@@ -6963,7 +7064,7 @@
}
// Fix up IMT next
- for (size_t i = 0; i < mirror::Class::kImtSize; ++i) {
+ for (size_t i = 0; i < ImTable::kSize; ++i) {
auto it = move_table.find(out_imt[i]);
if (it != move_table.end()) {
out_imt[i] = it->second;
diff --git a/runtime/class_linker.h b/runtime/class_linker.h
index ca5af19..d6822c5 100644
--- a/runtime/class_linker.h
+++ b/runtime/class_linker.h
@@ -833,6 +833,7 @@
bool LinkMethods(Thread* self,
Handle<mirror::Class> klass,
Handle<mirror::ObjectArray<mirror::Class>> interfaces,
+ bool* out_new_conflict,
ArtMethod** out_imt)
SHARED_REQUIRES(Locks::mutator_lock_);
@@ -968,19 +969,20 @@
// * kDefaultConflict - Conflicting method implementations were found when searching for
// target_method. The value of *out_default_method is null.
DefaultMethodSearchResult FindDefaultMethodImplementation(
- Thread* self,
- ArtMethod* target_method,
- Handle<mirror::Class> klass,
- /*out*/ArtMethod** out_default_method) const
+ Thread* self,
+ ArtMethod* target_method,
+ Handle<mirror::Class> klass,
+ /*out*/ArtMethod** out_default_method) const
SHARED_REQUIRES(Locks::mutator_lock_);
// Sets the imt entries and fixes up the vtable for the given class by linking all the interface
// methods. See LinkVirtualMethods for an explanation of what default_translations is.
bool LinkInterfaceMethods(
- Thread* self,
- Handle<mirror::Class> klass,
- const std::unordered_map<size_t, MethodTranslation>& default_translations,
- ArtMethod** out_imt)
+ Thread* self,
+ Handle<mirror::Class> klass,
+ const std::unordered_map<size_t, MethodTranslation>& default_translations,
+ bool* out_new_conflict,
+ ArtMethod** out_imt)
SHARED_REQUIRES(Locks::mutator_lock_);
bool LinkStaticFields(Thread* self, Handle<mirror::Class> klass, size_t* class_size)
@@ -1096,6 +1098,7 @@
void SetIMTRef(ArtMethod* unimplemented_method,
ArtMethod* imt_conflict_method,
ArtMethod* current_method,
+ /*out*/bool* new_conflict,
/*out*/ArtMethod** imt_ref) SHARED_REQUIRES(Locks::mutator_lock_);
void FillIMTFromIfTable(mirror::IfTable* if_table,
@@ -1104,11 +1107,13 @@
mirror::Class* klass,
bool create_conflict_tables,
bool ignore_copied_methods,
- ArtMethod** imt) SHARED_REQUIRES(Locks::mutator_lock_);
+ /*out*/bool* new_conflict,
+ /*out*/ArtMethod** imt) SHARED_REQUIRES(Locks::mutator_lock_);
void FillImtFromSuperClass(Handle<mirror::Class> klass,
ArtMethod* unimplemented_method,
ArtMethod* imt_conflict_method,
+ bool* new_conflict,
ArtMethod** imt) SHARED_REQUIRES(Locks::mutator_lock_);
std::vector<const DexFile*> boot_class_path_;
diff --git a/runtime/class_linker_test.cc b/runtime/class_linker_test.cc
index 488826b..48b6316 100644
--- a/runtime/class_linker_test.cc
+++ b/runtime/class_linker_test.cc
@@ -100,6 +100,62 @@
EXPECT_EQ(kAccPublic | kAccFinal | kAccAbstract, primitive->GetAccessFlags());
}
+ void AssertObjectClass(mirror::Class* JavaLangObject)
+ SHARED_REQUIRES(Locks::mutator_lock_) {
+ ASSERT_TRUE(JavaLangObject != nullptr);
+ ASSERT_TRUE(JavaLangObject->GetClass() != nullptr);
+ ASSERT_EQ(JavaLangObject->GetClass(),
+ JavaLangObject->GetClass()->GetClass());
+ EXPECT_EQ(JavaLangObject, JavaLangObject->GetClass()->GetSuperClass());
+ std::string temp;
+ ASSERT_STREQ(JavaLangObject->GetDescriptor(&temp), "Ljava/lang/Object;");
+ EXPECT_TRUE(JavaLangObject->GetSuperClass() == nullptr);
+ EXPECT_FALSE(JavaLangObject->HasSuperClass());
+ EXPECT_TRUE(JavaLangObject->GetClassLoader() == nullptr);
+ EXPECT_EQ(mirror::Class::kStatusInitialized, JavaLangObject->GetStatus());
+ EXPECT_FALSE(JavaLangObject->IsErroneous());
+ EXPECT_TRUE(JavaLangObject->IsLoaded());
+ EXPECT_TRUE(JavaLangObject->IsResolved());
+ EXPECT_TRUE(JavaLangObject->IsVerified());
+ EXPECT_TRUE(JavaLangObject->IsInitialized());
+ EXPECT_FALSE(JavaLangObject->IsArrayInstance());
+ EXPECT_FALSE(JavaLangObject->IsArrayClass());
+ EXPECT_TRUE(JavaLangObject->GetComponentType() == nullptr);
+ EXPECT_FALSE(JavaLangObject->IsInterface());
+ EXPECT_TRUE(JavaLangObject->IsPublic());
+ EXPECT_FALSE(JavaLangObject->IsFinal());
+ EXPECT_FALSE(JavaLangObject->IsPrimitive());
+ EXPECT_FALSE(JavaLangObject->IsSynthetic());
+ EXPECT_EQ(2U, JavaLangObject->NumDirectMethods());
+ EXPECT_EQ(11U, JavaLangObject->NumVirtualMethods());
+ if (!kUseBrooksReadBarrier) {
+ EXPECT_EQ(2U, JavaLangObject->NumInstanceFields());
+ } else {
+ EXPECT_EQ(4U, JavaLangObject->NumInstanceFields());
+ }
+ EXPECT_STREQ(JavaLangObject->GetInstanceField(0)->GetName(),
+ "shadow$_klass_");
+ EXPECT_STREQ(JavaLangObject->GetInstanceField(1)->GetName(),
+ "shadow$_monitor_");
+ if (kUseBrooksReadBarrier) {
+ EXPECT_STREQ(JavaLangObject->GetInstanceField(2)->GetName(),
+ "shadow$_x_rb_ptr_");
+ EXPECT_STREQ(JavaLangObject->GetInstanceField(3)->GetName(),
+ "shadow$_x_xpadding_");
+ }
+
+ EXPECT_EQ(0U, JavaLangObject->NumStaticFields());
+ EXPECT_EQ(0U, JavaLangObject->NumDirectInterfaces());
+
+ size_t pointer_size = class_linker_->GetImagePointerSize();
+ ArtMethod* unimplemented = runtime_->GetImtUnimplementedMethod();
+ ImTable* imt = JavaLangObject->GetImt(pointer_size);
+ ASSERT_NE(nullptr, imt);
+ for (size_t i = 0; i < ImTable::kSize; ++i) {
+ ASSERT_EQ(unimplemented, imt->Get(i, pointer_size));
+ }
+ }
+
void AssertArrayClass(const std::string& array_descriptor,
const std::string& component_type,
mirror::ClassLoader* class_loader)
@@ -148,7 +204,8 @@
EXPECT_EQ(0U, array->NumInstanceFields());
EXPECT_EQ(0U, array->NumStaticFields());
EXPECT_EQ(2U, array->NumDirectInterfaces());
- EXPECT_TRUE(array->ShouldHaveEmbeddedImtAndVTable());
+ EXPECT_TRUE(array->ShouldHaveImt());
+ EXPECT_TRUE(array->ShouldHaveEmbeddedVTable());
EXPECT_EQ(2, array->GetIfTableCount());
ASSERT_TRUE(array->GetIfTable() != nullptr);
mirror::Class* direct_interface0 = mirror::Class::GetDirectInterface(self, array, 0);
@@ -158,6 +215,13 @@
EXPECT_STREQ(direct_interface1->GetDescriptor(&temp), "Ljava/io/Serializable;");
mirror::Class* array_ptr = array->GetComponentType();
EXPECT_EQ(class_linker_->FindArrayClass(self, &array_ptr), array.Get());
+
+ size_t pointer_size = class_linker_->GetImagePointerSize();
+ mirror::Class* JavaLangObject =
+ class_linker_->FindSystemClass(self, "Ljava/lang/Object;");
+ ImTable* JavaLangObject_imt = JavaLangObject->GetImt(pointer_size);
+ // IMT of a array class should be shared with the IMT of the java.lag.Object
+ ASSERT_EQ(JavaLangObject_imt, array->GetImt(pointer_size));
}
void AssertMethod(ArtMethod* method) SHARED_REQUIRES(Locks::mutator_lock_) {
@@ -713,45 +777,7 @@
TEST_F(ClassLinkerTest, FindClass) {
ScopedObjectAccess soa(Thread::Current());
mirror::Class* JavaLangObject = class_linker_->FindSystemClass(soa.Self(), "Ljava/lang/Object;");
- ASSERT_TRUE(JavaLangObject != nullptr);
- ASSERT_TRUE(JavaLangObject->GetClass() != nullptr);
- ASSERT_EQ(JavaLangObject->GetClass(), JavaLangObject->GetClass()->GetClass());
- EXPECT_EQ(JavaLangObject, JavaLangObject->GetClass()->GetSuperClass());
- std::string temp;
- ASSERT_STREQ(JavaLangObject->GetDescriptor(&temp), "Ljava/lang/Object;");
- EXPECT_TRUE(JavaLangObject->GetSuperClass() == nullptr);
- EXPECT_FALSE(JavaLangObject->HasSuperClass());
- EXPECT_TRUE(JavaLangObject->GetClassLoader() == nullptr);
- EXPECT_EQ(mirror::Class::kStatusInitialized, JavaLangObject->GetStatus());
- EXPECT_FALSE(JavaLangObject->IsErroneous());
- EXPECT_TRUE(JavaLangObject->IsLoaded());
- EXPECT_TRUE(JavaLangObject->IsResolved());
- EXPECT_TRUE(JavaLangObject->IsVerified());
- EXPECT_TRUE(JavaLangObject->IsInitialized());
- EXPECT_FALSE(JavaLangObject->IsArrayInstance());
- EXPECT_FALSE(JavaLangObject->IsArrayClass());
- EXPECT_TRUE(JavaLangObject->GetComponentType() == nullptr);
- EXPECT_FALSE(JavaLangObject->IsInterface());
- EXPECT_TRUE(JavaLangObject->IsPublic());
- EXPECT_FALSE(JavaLangObject->IsFinal());
- EXPECT_FALSE(JavaLangObject->IsPrimitive());
- EXPECT_FALSE(JavaLangObject->IsSynthetic());
- EXPECT_EQ(2U, JavaLangObject->NumDirectMethods());
- EXPECT_EQ(11U, JavaLangObject->NumVirtualMethods());
- if (!kUseBrooksReadBarrier) {
- EXPECT_EQ(2U, JavaLangObject->NumInstanceFields());
- } else {
- EXPECT_EQ(4U, JavaLangObject->NumInstanceFields());
- }
- EXPECT_STREQ(JavaLangObject->GetInstanceField(0)->GetName(), "shadow$_klass_");
- EXPECT_STREQ(JavaLangObject->GetInstanceField(1)->GetName(), "shadow$_monitor_");
- if (kUseBrooksReadBarrier) {
- EXPECT_STREQ(JavaLangObject->GetInstanceField(2)->GetName(), "shadow$_x_rb_ptr_");
- EXPECT_STREQ(JavaLangObject->GetInstanceField(3)->GetName(), "shadow$_x_xpadding_");
- }
-
- EXPECT_EQ(0U, JavaLangObject->NumStaticFields());
- EXPECT_EQ(0U, JavaLangObject->NumDirectInterfaces());
+ AssertObjectClass(JavaLangObject);
StackHandleScope<1> hs(soa.Self());
Handle<mirror::ClassLoader> class_loader(
@@ -762,6 +788,7 @@
ASSERT_TRUE(MyClass->GetClass() != nullptr);
ASSERT_EQ(MyClass->GetClass(), MyClass->GetClass()->GetClass());
EXPECT_EQ(JavaLangObject, MyClass->GetClass()->GetSuperClass());
+ std::string temp;
ASSERT_STREQ(MyClass->GetDescriptor(&temp), "LMyClass;");
EXPECT_TRUE(MyClass->GetSuperClass() == JavaLangObject);
EXPECT_TRUE(MyClass->HasSuperClass());
diff --git a/runtime/entrypoints/entrypoint_utils-inl.h b/runtime/entrypoints/entrypoint_utils-inl.h
index fc62573..ab14655 100644
--- a/runtime/entrypoints/entrypoint_utils-inl.h
+++ b/runtime/entrypoints/entrypoint_utils-inl.h
@@ -39,45 +39,83 @@
namespace art {
-template <bool kResolve = true>
inline ArtMethod* GetResolvedMethod(ArtMethod* outer_method,
const InlineInfo& inline_info,
const InlineInfoEncoding& encoding,
uint8_t inlining_depth)
- SHARED_REQUIRES(Locks::mutator_lock_) {
+ SHARED_REQUIRES(Locks::mutator_lock_) {
+ // This method is being used by artQuickResolutionTrampoline, before it sets up
+ // the passed parameters in a GC friendly way. Therefore we must never be
+ // suspended while executing it.
+ ScopedAssertNoThreadSuspension sants(Thread::Current(), __FUNCTION__);
+
uint32_t method_index = inline_info.GetMethodIndexAtDepth(encoding, inlining_depth);
InvokeType invoke_type = static_cast<InvokeType>(
inline_info.GetInvokeTypeAtDepth(encoding, inlining_depth));
- ArtMethod* caller = outer_method->GetDexCacheResolvedMethod(method_index, sizeof(void*));
- if (!caller->IsRuntimeMethod()) {
- return caller;
- }
- if (!kResolve) {
- return nullptr;
+ ArtMethod* inlined_method = outer_method->GetDexCacheResolvedMethod(method_index, sizeof(void*));
+ if (!inlined_method->IsRuntimeMethod()) {
+ return inlined_method;
}
- // The method in the dex cache can be the runtime method responsible for invoking
+ // The method in the dex cache is the runtime method responsible for invoking
// the stub that will then update the dex cache. Therefore, we need to do the
// resolution ourselves.
- // We first find the class loader of our caller. If it is the outer method, we can directly
- // use its class loader. Otherwise, we also need to resolve our caller.
- StackHandleScope<2> hs(Thread::Current());
- ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
- MutableHandle<mirror::ClassLoader> class_loader(hs.NewHandle<mirror::Class>(nullptr));
- Handle<mirror::DexCache> dex_cache(hs.NewHandle(outer_method->GetDexCache()));
- if (inlining_depth == 0) {
- class_loader.Assign(outer_method->GetClassLoader());
+ // We first find the dex cache of our caller. If it is the outer method, we can directly
+ // use its dex cache. Otherwise, we also need to resolve our caller.
+ ArtMethod* caller = outer_method;
+ if (inlining_depth != 0) {
+ caller = GetResolvedMethod(outer_method,
+ inline_info,
+ encoding,
+ inlining_depth - 1);
+ }
+ DCHECK_EQ(caller->GetDexCache(), outer_method->GetDexCache())
+ << "Compiler only supports inlining calls within the same dex cache";
+ const DexFile* dex_file = outer_method->GetDexFile();
+ const DexFile::MethodId& method_id = dex_file->GetMethodId(method_index);
+
+ if (inline_info.GetDexPcAtDepth(encoding, inlining_depth) == static_cast<uint32_t>(-1)) {
+ // "charAt" special case. It is the only non-leaf method we inline across dex files.
+ if (kIsDebugBuild) {
+ const char* name = dex_file->StringDataByIdx(method_id.name_idx_);
+ DCHECK_EQ(std::string(name), "charAt");
+ DCHECK_EQ(std::string(dex_file->GetMethodShorty(method_id)), "CI")
+ << std::string(dex_file->GetMethodShorty(method_id));
+ DCHECK_EQ(std::string(dex_file->StringByTypeIdx(method_id.class_idx_)), "Ljava/lang/String;")
+ << std::string(dex_file->StringByTypeIdx(method_id.class_idx_));
+ }
+ mirror::Class* cls =
+ Runtime::Current()->GetClassLinker()->GetClassRoot(ClassLinker::kJavaLangString);
+ // Update the dex cache for future lookups.
+ caller->GetDexCache()->SetResolvedType(method_id.class_idx_, cls);
+ inlined_method = cls->FindVirtualMethod("charAt", "(I)C", sizeof(void*));
} else {
- caller = GetResolvedMethod<kResolve>(outer_method,
- inline_info,
- encoding,
- inlining_depth - 1);
- class_loader.Assign(caller->GetClassLoader());
+ mirror::Class* klass = caller->GetDexCache()->GetResolvedType(method_id.class_idx_);
+ DCHECK_EQ(klass->GetDexCache(), caller->GetDexCache())
+ << "Compiler only supports inlining calls within the same dex cache";
+ switch (invoke_type) {
+ case kDirect:
+ case kStatic:
+ inlined_method =
+ klass->FindDirectMethod(klass->GetDexCache(), method_index, sizeof(void*));
+ break;
+ case kSuper:
+ case kVirtual:
+ inlined_method =
+ klass->FindVirtualMethod(klass->GetDexCache(), method_index, sizeof(void*));
+ break;
+ default:
+ LOG(FATAL) << "Unimplemented inlined invocation type: " << invoke_type;
+ UNREACHABLE();
+ }
}
- return class_linker->ResolveMethod<ClassLinker::kNoICCECheckForCache>(
- *outer_method->GetDexFile(), method_index, dex_cache, class_loader, nullptr, invoke_type);
+ // Update the dex cache for future lookups. Note that for static methods, this is safe
+ // when the class is being initialized, as the entrypoint for the ArtMethod is at
+ // this point still the resolution trampoline.
+ outer_method->SetDexCacheResolvedMethod(method_index, inlined_method, sizeof(void*));
+ return inlined_method;
}
inline ArtMethod* GetCalleeSaveMethodCaller(Thread* self, Runtime::CalleeSaveType type)
@@ -448,23 +486,10 @@
: ClassLinker::kNoICCECheckForCache;
resolved_method = class_linker->ResolveMethod<resolve_mode>(self, method_idx, referrer, type);
}
+ // Resolution and access check.
if (UNLIKELY(resolved_method == nullptr)) {
DCHECK(self->IsExceptionPending()); // Throw exception and unwind.
return nullptr; // Failure.
- } else if (UNLIKELY(*this_object == nullptr && type != kStatic)) {
- if (UNLIKELY(resolved_method->GetDeclaringClass()->IsStringClass() &&
- resolved_method->IsConstructor())) {
- // Hack for String init:
- //
- // We assume that the input of String.<init> in verified code is always
- // an unitialized reference. If it is a null constant, it must have been
- // optimized out by the compiler. Do not throw NullPointerException.
- } else {
- // Maintain interpreter-like semantics where NullPointerException is thrown
- // after potential NoSuchMethodError from class linker.
- ThrowNullPointerExceptionForMethodAccess(method_idx, type);
- return nullptr; // Failure.
- }
} else if (access_check) {
mirror::Class* methods_class = resolved_method->GetDeclaringClass();
bool can_access_resolved_method =
@@ -482,6 +507,22 @@
return nullptr; // Failure.
}
}
+ // Next, null pointer check.
+ if (UNLIKELY(*this_object == nullptr && type != kStatic)) {
+ if (UNLIKELY(resolved_method->GetDeclaringClass()->IsStringClass() &&
+ resolved_method->IsConstructor())) {
+ // Hack for String init:
+ //
+ // We assume that the input of String.<init> in verified code is always
+ // an unitialized reference. If it is a null constant, it must have been
+ // optimized out by the compiler. Do not throw NullPointerException.
+ } else {
+ // Maintain interpreter-like semantics where NullPointerException is thrown
+ // after potential NoSuchMethodError from class linker.
+ ThrowNullPointerExceptionForMethodAccess(method_idx, type);
+ return nullptr; // Failure.
+ }
+ }
switch (type) {
case kStatic:
case kDirect:
@@ -559,9 +600,10 @@
}
}
case kInterface: {
- uint32_t imt_index = resolved_method->GetDexMethodIndex() % mirror::Class::kImtSize;
- ArtMethod* imt_method = (*this_object)->GetClass()->GetEmbeddedImTableEntry(
- imt_index, class_linker->GetImagePointerSize());
+ uint32_t imt_index = resolved_method->GetDexMethodIndex() % ImTable::kSize;
+ size_t pointer_size = class_linker->GetImagePointerSize();
+ ArtMethod* imt_method = (*this_object)->GetClass()->GetImt(pointer_size)->
+ Get(imt_index, pointer_size);
if (!imt_method->IsRuntimeMethod()) {
if (kIsDebugBuild) {
mirror::Class* klass = (*this_object)->GetClass();
diff --git a/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc b/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc
index 03771aa..1152b94 100644
--- a/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc
+++ b/runtime/entrypoints/quick/quick_trampoline_entrypoints.cc
@@ -2141,11 +2141,7 @@
StackHandleScope<1> hs(self);
Handle<mirror::Class> cls(hs.NewHandle(this_object->GetClass()));
- // The optimizing compiler currently does not inline methods that have an interface
- // invocation. We use the outer method directly to avoid fetching a stack map, which is
- // more expensive.
- ArtMethod* caller_method = QuickArgumentVisitor::GetOuterMethod(sp);
- DCHECK_EQ(caller_method, QuickArgumentVisitor::GetCallingMethod(sp));
+ ArtMethod* caller_method = QuickArgumentVisitor::GetCallingMethod(sp);
// Fetch the dex_method_idx of the target interface method from the caller.
uint32_t dex_pc = QuickArgumentVisitor::GetCallingDexPc(sp);
@@ -2169,13 +2165,13 @@
dex_method_idx, sizeof(void*));
DCHECK(interface_method != nullptr) << dex_method_idx << " " << PrettyMethod(caller_method);
ArtMethod* method = nullptr;
+ ImTable* imt = cls->GetImt(sizeof(void*));
if (LIKELY(interface_method->GetDexMethodIndex() != DexFile::kDexNoIndex)) {
// If the dex cache already resolved the interface method, look whether we have
// a match in the ImtConflictTable.
uint32_t imt_index = interface_method->GetDexMethodIndex();
- ArtMethod* conflict_method = cls->GetEmbeddedImTableEntry(
- imt_index % mirror::Class::kImtSize, sizeof(void*));
+ ArtMethod* conflict_method = imt->Get(imt_index % ImTable::kSize, sizeof(void*));
if (LIKELY(conflict_method->IsRuntimeMethod())) {
ImtConflictTable* current_table = conflict_method->GetImtConflictTable(sizeof(void*));
DCHECK(current_table != nullptr);
@@ -2227,8 +2223,7 @@
// We arrive here if we have found an implementation, and it is not in the ImtConflictTable.
// We create a new table with the new pair { interface_method, method }.
uint32_t imt_index = interface_method->GetDexMethodIndex();
- ArtMethod* conflict_method = cls->GetEmbeddedImTableEntry(
- imt_index % mirror::Class::kImtSize, sizeof(void*));
+ ArtMethod* conflict_method = imt->Get(imt_index % ImTable::kSize, sizeof(void*));
if (conflict_method->IsRuntimeMethod()) {
ArtMethod* new_conflict_method = Runtime::Current()->GetClassLinker()->AddMethodToConflictTable(
cls.Get(),
@@ -2239,9 +2234,9 @@
if (new_conflict_method != conflict_method) {
// Update the IMT if we create a new conflict method. No fence needed here, as the
// data is consistent.
- cls->SetEmbeddedImTableEntry(imt_index % mirror::Class::kImtSize,
- new_conflict_method,
- sizeof(void*));
+ imt->Set(imt_index % ImTable::kSize,
+ new_conflict_method,
+ sizeof(void*));
}
}
diff --git a/runtime/gc/allocation_record.cc b/runtime/gc/allocation_record.cc
index d9f1507..6489a39 100644
--- a/runtime/gc/allocation_record.cc
+++ b/runtime/gc/allocation_record.cc
@@ -187,7 +187,7 @@
public:
AllocRecordStackVisitor(Thread* thread, size_t max_depth, AllocRecordStackTrace* trace_out)
SHARED_REQUIRES(Locks::mutator_lock_)
- : StackVisitor(thread, nullptr, StackVisitor::StackWalkKind::kIncludeInlinedFramesNoResolve),
+ : StackVisitor(thread, nullptr, StackVisitor::StackWalkKind::kIncludeInlinedFrames),
max_depth_(max_depth),
trace_(trace_out) {}
diff --git a/runtime/gc/collector/concurrent_copying-inl.h b/runtime/gc/collector/concurrent_copying-inl.h
index 64fa434..3011112 100644
--- a/runtime/gc/collector/concurrent_copying-inl.h
+++ b/runtime/gc/collector/concurrent_copying-inl.h
@@ -28,7 +28,7 @@
namespace gc {
namespace collector {
-inline mirror::Object* ConcurrentCopying::MarkUnevacFromSpaceRegionOrImmuneSpace(
+inline mirror::Object* ConcurrentCopying::MarkUnevacFromSpaceRegion(
mirror::Object* ref, accounting::ContinuousSpaceBitmap* bitmap) {
// For the Baker-style RB, in a rare case, we could incorrectly change the object from white
// to gray even though the object has already been marked through. This happens if a mutator
@@ -69,6 +69,37 @@
return ref;
}
+template<bool kGrayImmuneObject>
+inline mirror::Object* ConcurrentCopying::MarkImmuneSpace(mirror::Object* ref) {
+ if (kUseBakerReadBarrier) {
+ // The GC-running thread doesn't (need to) gray immune objects except when updating thread roots
+ // in the thread flip on behalf of suspended threads (when gc_grays_immune_objects_ is
+ // true). Also, a mutator doesn't (need to) gray an immune object after GC has updated all
+ // immune space objects (when updated_all_immune_objects_ is true).
+ if (kIsDebugBuild) {
+ if (Thread::Current() == thread_running_gc_) {
+ DCHECK(!kGrayImmuneObject ||
+ updated_all_immune_objects_.LoadRelaxed() ||
+ gc_grays_immune_objects_);
+ } else {
+ DCHECK(kGrayImmuneObject);
+ }
+ }
+ if (!kGrayImmuneObject || updated_all_immune_objects_.LoadRelaxed()) {
+ return ref;
+ }
+ // This may or may not succeed, which is ok because the object may already be gray.
+ bool success = ref->AtomicSetReadBarrierPointer(ReadBarrier::WhitePtr(),
+ ReadBarrier::GrayPtr());
+ if (success) {
+ MutexLock mu(Thread::Current(), immune_gray_stack_lock_);
+ immune_gray_stack_.push_back(ref);
+ }
+ }
+ return ref;
+}
+
+template<bool kGrayImmuneObject>
inline mirror::Object* ConcurrentCopying::Mark(mirror::Object* from_ref) {
if (from_ref == nullptr) {
return nullptr;
@@ -109,10 +140,14 @@
return to_ref;
}
case space::RegionSpace::RegionType::kRegionTypeUnevacFromSpace: {
- return MarkUnevacFromSpaceRegionOrImmuneSpace(from_ref, region_space_bitmap_);
+ return MarkUnevacFromSpaceRegion(from_ref, region_space_bitmap_);
}
case space::RegionSpace::RegionType::kRegionTypeNone:
- return MarkNonMoving(from_ref);
+ if (immune_spaces_.ContainsObject(from_ref)) {
+ return MarkImmuneSpace<kGrayImmuneObject>(from_ref);
+ } else {
+ return MarkNonMoving(from_ref);
+ }
default:
UNREACHABLE();
}
diff --git a/runtime/gc/collector/concurrent_copying.cc b/runtime/gc/collector/concurrent_copying.cc
index dd75006..b7b5aa0 100644
--- a/runtime/gc/collector/concurrent_copying.cc
+++ b/runtime/gc/collector/concurrent_copying.cc
@@ -50,14 +50,16 @@
mark_stack_lock_("concurrent copying mark stack lock", kMarkSweepMarkStackLock),
thread_running_gc_(nullptr),
is_marking_(false), is_active_(false), is_asserting_to_space_invariant_(false),
+ region_space_bitmap_(nullptr),
heap_mark_bitmap_(nullptr), live_stack_freeze_size_(0), mark_stack_mode_(kMarkStackModeOff),
weak_ref_access_enabled_(true),
skipped_blocks_lock_("concurrent copying bytes blocks lock", kMarkSweepMarkStackLock),
rb_table_(heap_->GetReadBarrierTable()),
- force_evacuate_all_(false) {
+ force_evacuate_all_(false),
+ immune_gray_stack_lock_("concurrent copying immune gray stack lock",
+ kMarkSweepMarkStackLock) {
static_assert(space::RegionSpace::kRegionSize == accounting::ReadBarrierTable::kRegionSize,
"The region space size and the read barrier table region size must match");
- cc_heap_bitmap_.reset(new accounting::HeapBitmap(heap));
Thread* self = Thread::Current();
{
ReaderMutexLock mu(self, *Locks::heap_bitmap_lock_);
@@ -139,19 +141,10 @@
space->GetGcRetentionPolicy() == space::kGcRetentionPolicyFullCollect) {
CHECK(space->IsZygoteSpace() || space->IsImageSpace());
immune_spaces_.AddSpace(space);
- const char* bitmap_name = space->IsImageSpace() ? "cc image space bitmap" :
- "cc zygote space bitmap";
- // TODO: try avoiding using bitmaps for image/zygote to save space.
- accounting::ContinuousSpaceBitmap* bitmap =
- accounting::ContinuousSpaceBitmap::Create(bitmap_name, space->Begin(), space->Capacity());
- cc_heap_bitmap_->AddContinuousSpaceBitmap(bitmap);
- cc_bitmaps_.push_back(bitmap);
} else if (space == region_space_) {
accounting::ContinuousSpaceBitmap* bitmap =
accounting::ContinuousSpaceBitmap::Create("cc region space bitmap",
space->Begin(), space->Capacity());
- cc_heap_bitmap_->AddContinuousSpaceBitmap(bitmap);
- cc_bitmaps_.push_back(bitmap);
region_space_bitmap_ = bitmap;
}
}
@@ -179,6 +172,15 @@
} else {
force_evacuate_all_ = false;
}
+ if (kUseBakerReadBarrier) {
+ updated_all_immune_objects_.StoreRelaxed(false);
+ // GC may gray immune objects in the thread flip.
+ gc_grays_immune_objects_ = true;
+ if (kIsDebugBuild) {
+ MutexLock mu(Thread::Current(), immune_gray_stack_lock_);
+ DCHECK(immune_gray_stack_.empty());
+ }
+ }
BindBitmaps();
if (kVerboseMode) {
LOG(INFO) << "force_evacuate_all=" << force_evacuate_all_;
@@ -303,30 +305,6 @@
live_stack_freeze_size_ = heap_->GetLiveStack()->Size();
}
-// Used to visit objects in the immune spaces.
-class ConcurrentCopying::ImmuneSpaceObjVisitor {
- public:
- explicit ImmuneSpaceObjVisitor(ConcurrentCopying* cc) : collector_(cc) {}
-
- void operator()(mirror::Object* obj) const SHARED_REQUIRES(Locks::mutator_lock_)
- SHARED_REQUIRES(Locks::heap_bitmap_lock_) {
- DCHECK(obj != nullptr);
- DCHECK(collector_->immune_spaces_.ContainsObject(obj));
- accounting::ContinuousSpaceBitmap* cc_bitmap =
- collector_->cc_heap_bitmap_->GetContinuousSpaceBitmap(obj);
- DCHECK(cc_bitmap != nullptr)
- << "An immune space object must have a bitmap";
- if (kIsDebugBuild) {
- DCHECK(collector_->heap_->GetMarkBitmap()->Test(obj))
- << "Immune space object must be already marked";
- }
- collector_->MarkUnevacFromSpaceRegionOrImmuneSpace(obj, cc_bitmap);
- }
-
- private:
- ConcurrentCopying* const collector_;
-};
-
class EmptyCheckpoint : public Closure {
public:
explicit EmptyCheckpoint(ConcurrentCopying* concurrent_copying)
@@ -347,6 +325,27 @@
ConcurrentCopying* const concurrent_copying_;
};
+// Used to visit objects in the immune spaces.
+inline void ConcurrentCopying::ScanImmuneObject(mirror::Object* obj) {
+ DCHECK(obj != nullptr);
+ DCHECK(immune_spaces_.ContainsObject(obj));
+ // Update the fields without graying it or pushing it onto the mark stack.
+ Scan(obj);
+}
+
+class ConcurrentCopying::ImmuneSpaceScanObjVisitor {
+ public:
+ explicit ImmuneSpaceScanObjVisitor(ConcurrentCopying* cc)
+ : collector_(cc) {}
+
+ void operator()(mirror::Object* obj) const SHARED_REQUIRES(Locks::mutator_lock_) {
+ collector_->ScanImmuneObject(obj);
+ }
+
+ private:
+ ConcurrentCopying* const collector_;
+};
+
// Concurrently mark roots that are guarded by read barriers and process the mark stack.
void ConcurrentCopying::MarkingPhase() {
TimingLogger::ScopedTiming split("MarkingPhase", GetTimings());
@@ -354,25 +353,46 @@
LOG(INFO) << "GC MarkingPhase";
}
CHECK(weak_ref_access_enabled_);
- {
- // Mark the image root. The WB-based collectors do not need to
- // scan the image objects from roots by relying on the card table,
- // but it's necessary for the RB to-space invariant to hold.
- TimingLogger::ScopedTiming split1("VisitImageRoots", GetTimings());
- for (space::ContinuousSpace* space : heap_->GetContinuousSpaces()) {
- if (space->IsImageSpace()) {
- gc::space::ImageSpace* image = space->AsImageSpace();
- if (image != nullptr) {
- mirror::ObjectArray<mirror::Object>* image_root = image->GetImageHeader().GetImageRoots();
- mirror::Object* marked_image_root = Mark(image_root);
- CHECK_EQ(image_root, marked_image_root) << "An image object does not move";
- if (ReadBarrier::kEnableToSpaceInvariantChecks) {
- AssertToSpaceInvariant(nullptr, MemberOffset(0), marked_image_root);
- }
- }
- }
- }
+
+ // Scan immune spaces.
+ // Update all the fields in the immune spaces first without graying the objects so that we
+ // minimize dirty pages in the immune spaces. Note mutators can concurrently access and gray some
+ // of the objects.
+ if (kUseBakerReadBarrier) {
+ gc_grays_immune_objects_ = false;
}
+ for (auto& space : immune_spaces_.GetSpaces()) {
+ DCHECK(space->IsImageSpace() || space->IsZygoteSpace());
+ accounting::ContinuousSpaceBitmap* live_bitmap = space->GetLiveBitmap();
+ ImmuneSpaceScanObjVisitor visitor(this);
+ live_bitmap->VisitMarkedRange(reinterpret_cast<uintptr_t>(space->Begin()),
+ reinterpret_cast<uintptr_t>(space->Limit()),
+ visitor);
+ }
+ if (kUseBakerReadBarrier) {
+ // This release fence makes the field updates in the above loop visible before allowing mutator
+ // getting access to immune objects without graying it first.
+ updated_all_immune_objects_.StoreRelease(true);
+ // Now whiten immune objects concurrently accessed and grayed by mutators. We can't do this in
+ // the above loop because we would incorrectly disable the read barrier by whitening an object
+ // which may point to an unscanned, white object, breaking the to-space invariant.
+ //
+ // Make sure no mutators are in the middle of marking an immune object before whitening immune
+ // objects.
+ IssueEmptyCheckpoint();
+ MutexLock mu(Thread::Current(), immune_gray_stack_lock_);
+ if (kVerboseMode) {
+ LOG(INFO) << "immune gray stack size=" << immune_gray_stack_.size();
+ }
+ for (mirror::Object* obj : immune_gray_stack_) {
+ DCHECK(obj->GetReadBarrierPointer() == ReadBarrier::GrayPtr());
+ bool success = obj->AtomicSetReadBarrierPointer(ReadBarrier::GrayPtr(),
+ ReadBarrier::WhitePtr());
+ DCHECK(success);
+ }
+ immune_gray_stack_.clear();
+ }
+
{
TimingLogger::ScopedTiming split2("VisitConcurrentRoots", GetTimings());
Runtime::Current()->VisitConcurrentRoots(this, kVisitRootFlagAllRoots);
@@ -383,16 +403,6 @@
Runtime::Current()->VisitNonThreadRoots(this);
}
- // Immune spaces.
- for (auto& space : immune_spaces_.GetSpaces()) {
- DCHECK(space->IsImageSpace() || space->IsZygoteSpace());
- accounting::ContinuousSpaceBitmap* live_bitmap = space->GetLiveBitmap();
- ImmuneSpaceObjVisitor visitor(this);
- live_bitmap->VisitMarkedRange(reinterpret_cast<uintptr_t>(space->Begin()),
- reinterpret_cast<uintptr_t>(space->Limit()),
- visitor);
- }
-
Thread* self = Thread::Current();
{
TimingLogger::ScopedTiming split7("ProcessMarkStack", GetTimings());
@@ -1239,6 +1249,9 @@
IssueEmptyCheckpoint();
// Disable the check.
is_mark_stack_push_disallowed_.StoreSequentiallyConsistent(0);
+ if (kUseBakerReadBarrier) {
+ updated_all_immune_objects_.StoreSequentiallyConsistent(false);
+ }
CheckEmptyMarkStack();
}
@@ -1288,13 +1301,9 @@
SwapBitmaps();
heap_->UnBindBitmaps();
- // Remove bitmaps for the immune spaces.
- while (!cc_bitmaps_.empty()) {
- accounting::ContinuousSpaceBitmap* cc_bitmap = cc_bitmaps_.back();
- cc_heap_bitmap_->RemoveContinuousSpaceBitmap(cc_bitmap);
- delete cc_bitmap;
- cc_bitmaps_.pop_back();
- }
+ // Delete the region bitmap.
+ DCHECK(region_space_bitmap_ != nullptr);
+ delete region_space_bitmap_;
region_space_bitmap_ = nullptr;
}
@@ -1410,15 +1419,6 @@
// In a non-moving space.
if (immune_spaces_.ContainsObject(obj)) {
LOG(INFO) << "holder is in an immune image or the zygote space.";
- accounting::ContinuousSpaceBitmap* cc_bitmap =
- cc_heap_bitmap_->GetContinuousSpaceBitmap(obj);
- CHECK(cc_bitmap != nullptr)
- << "An immune space object must have a bitmap.";
- if (cc_bitmap->Test(obj)) {
- LOG(INFO) << "holder is marked in the bit map.";
- } else {
- LOG(INFO) << "holder is NOT marked in the bit map.";
- }
} else {
LOG(INFO) << "holder is in a non-immune, non-moving (or main) space.";
accounting::ContinuousSpaceBitmap* mark_bitmap =
@@ -1449,17 +1449,17 @@
mirror::Object* ref) {
// In a non-moving spaces. Check that the ref is marked.
if (immune_spaces_.ContainsObject(ref)) {
- accounting::ContinuousSpaceBitmap* cc_bitmap =
- cc_heap_bitmap_->GetContinuousSpaceBitmap(ref);
- CHECK(cc_bitmap != nullptr)
- << "An immune space ref must have a bitmap. " << ref;
if (kUseBakerReadBarrier) {
- CHECK(cc_bitmap->Test(ref))
+ // Immune object may not be gray if called from the GC.
+ if (Thread::Current() == thread_running_gc_ && !gc_grays_immune_objects_) {
+ return;
+ }
+ bool updated_all_immune_objects = updated_all_immune_objects_.LoadSequentiallyConsistent();
+ CHECK(updated_all_immune_objects || ref->GetReadBarrierPointer() == ReadBarrier::GrayPtr())
<< "Unmarked immune space ref. obj=" << obj << " rb_ptr="
- << obj->GetReadBarrierPointer() << " ref=" << ref;
- } else {
- CHECK(cc_bitmap->Test(ref))
- << "Unmarked immune space ref. obj=" << obj << " ref=" << ref;
+ << (obj != nullptr ? obj->GetReadBarrierPointer() : nullptr)
+ << " ref=" << ref << " ref rb_ptr=" << ref->GetReadBarrierPointer()
+ << " updated_all_immune_objects=" << updated_all_immune_objects;
}
} else {
accounting::ContinuousSpaceBitmap* mark_bitmap =
@@ -1510,7 +1510,7 @@
void VisitRoot(mirror::CompressedReference<mirror::Object>* root) const
ALWAYS_INLINE
SHARED_REQUIRES(Locks::mutator_lock_) {
- collector_->MarkRoot(root);
+ collector_->MarkRoot</*kGrayImmuneObject*/false>(root);
}
private:
@@ -1520,6 +1520,7 @@
// Scan ref fields of an object.
inline void ConcurrentCopying::Scan(mirror::Object* to_ref) {
DCHECK(!region_space_->IsInFromSpace(to_ref));
+ DCHECK_EQ(Thread::Current(), thread_running_gc_);
RefFieldsVisitor visitor(this);
// Disable the read barrier for a performance reason.
to_ref->VisitReferences</*kVisitNativeRoots*/true, kDefaultVerifyFlags, kWithoutReadBarrier>(
@@ -1528,9 +1529,10 @@
// Process a field.
inline void ConcurrentCopying::Process(mirror::Object* obj, MemberOffset offset) {
+ DCHECK_EQ(Thread::Current(), thread_running_gc_);
mirror::Object* ref = obj->GetFieldObject<
mirror::Object, kVerifyNone, kWithoutReadBarrier, false>(offset);
- mirror::Object* to_ref = Mark(ref);
+ mirror::Object* to_ref = Mark</*kGrayImmuneObject*/false>(ref);
if (to_ref == ref) {
return;
}
@@ -1569,10 +1571,11 @@
}
}
+template<bool kGrayImmuneObject>
inline void ConcurrentCopying::MarkRoot(mirror::CompressedReference<mirror::Object>* root) {
DCHECK(!root->IsNull());
mirror::Object* const ref = root->AsMirrorPtr();
- mirror::Object* to_ref = Mark(ref);
+ mirror::Object* to_ref = Mark<kGrayImmuneObject>(ref);
if (to_ref != ref) {
auto* addr = reinterpret_cast<Atomic<mirror::CompressedReference<mirror::Object>>*>(root);
auto expected_ref = mirror::CompressedReference<mirror::Object>::FromMirrorPtr(ref);
@@ -1593,14 +1596,46 @@
for (size_t i = 0; i < count; ++i) {
mirror::CompressedReference<mirror::Object>* const root = roots[i];
if (!root->IsNull()) {
- MarkRoot(root);
+ // kGrayImmuneObject is true because this is used for the thread flip.
+ MarkRoot</*kGrayImmuneObject*/true>(root);
}
}
}
+// Temporary set gc_grays_immune_objects_ to true in a scope if the current thread is GC.
+class ConcurrentCopying::ScopedGcGraysImmuneObjects {
+ public:
+ explicit ScopedGcGraysImmuneObjects(ConcurrentCopying* collector)
+ : collector_(collector), enabled_(false) {
+ if (kUseBakerReadBarrier &&
+ collector_->thread_running_gc_ == Thread::Current() &&
+ !collector_->gc_grays_immune_objects_) {
+ collector_->gc_grays_immune_objects_ = true;
+ enabled_ = true;
+ }
+ }
+
+ ~ScopedGcGraysImmuneObjects() {
+ if (kUseBakerReadBarrier &&
+ collector_->thread_running_gc_ == Thread::Current() &&
+ enabled_) {
+ DCHECK(collector_->gc_grays_immune_objects_);
+ collector_->gc_grays_immune_objects_ = false;
+ }
+ }
+
+ private:
+ ConcurrentCopying* const collector_;
+ bool enabled_;
+};
+
// Fill the given memory block with a dummy object. Used to fill in a
// copy of objects that was lost in race.
void ConcurrentCopying::FillWithDummyObject(mirror::Object* dummy_obj, size_t byte_size) {
+ // GC doesn't gray immune objects while scanning immune objects. But we need to trigger the read
+ // barriers here because we need the updated reference to the int array class, etc. Temporary set
+ // gc_grays_immune_objects_ to true so that we won't cause a DCHECK failure in MarkImmuneSpace().
+ ScopedGcGraysImmuneObjects scoped_gc_gray_immune_objects(this);
CHECK_ALIGNED(byte_size, kObjectAlignment);
memset(dummy_obj, 0, byte_size);
mirror::Class* int_array_class = mirror::IntArray::GetArrayClass();
@@ -1836,21 +1871,8 @@
} else {
// from_ref is in a non-moving space.
if (immune_spaces_.ContainsObject(from_ref)) {
- accounting::ContinuousSpaceBitmap* cc_bitmap =
- cc_heap_bitmap_->GetContinuousSpaceBitmap(from_ref);
- DCHECK(cc_bitmap != nullptr)
- << "An immune space object must have a bitmap";
- if (kIsDebugBuild) {
- DCHECK(heap_mark_bitmap_->GetContinuousSpaceBitmap(from_ref)->Test(from_ref))
- << "Immune space object must be already marked";
- }
- if (cc_bitmap->Test(from_ref)) {
- // Already marked.
- to_ref = from_ref;
- } else {
- // Newly marked.
- to_ref = nullptr;
- }
+ // An immune object is alive.
+ to_ref = from_ref;
} else {
// Non-immune non-moving space. Use the mark bitmap.
accounting::ContinuousSpaceBitmap* mark_bitmap =
@@ -1889,85 +1911,74 @@
mirror::Object* ConcurrentCopying::MarkNonMoving(mirror::Object* ref) {
// ref is in a non-moving space (from_ref == to_ref).
DCHECK(!region_space_->HasAddress(ref)) << ref;
- if (immune_spaces_.ContainsObject(ref)) {
- accounting::ContinuousSpaceBitmap* cc_bitmap =
- cc_heap_bitmap_->GetContinuousSpaceBitmap(ref);
- DCHECK(cc_bitmap != nullptr)
- << "An immune space object must have a bitmap";
- if (kIsDebugBuild) {
- DCHECK(heap_mark_bitmap_->GetContinuousSpaceBitmap(ref)->Test(ref))
- << "Immune space object must be already marked";
+ DCHECK(!immune_spaces_.ContainsObject(ref));
+ // Use the mark bitmap.
+ accounting::ContinuousSpaceBitmap* mark_bitmap =
+ heap_mark_bitmap_->GetContinuousSpaceBitmap(ref);
+ accounting::LargeObjectBitmap* los_bitmap =
+ heap_mark_bitmap_->GetLargeObjectBitmap(ref);
+ CHECK(los_bitmap != nullptr) << "LOS bitmap covers the entire address range";
+ bool is_los = mark_bitmap == nullptr;
+ if (!is_los && mark_bitmap->Test(ref)) {
+ // Already marked.
+ if (kUseBakerReadBarrier) {
+ DCHECK(ref->GetReadBarrierPointer() == ReadBarrier::GrayPtr() ||
+ ref->GetReadBarrierPointer() == ReadBarrier::WhitePtr());
}
- MarkUnevacFromSpaceRegionOrImmuneSpace(ref, cc_bitmap);
+ } else if (is_los && los_bitmap->Test(ref)) {
+ // Already marked in LOS.
+ if (kUseBakerReadBarrier) {
+ DCHECK(ref->GetReadBarrierPointer() == ReadBarrier::GrayPtr() ||
+ ref->GetReadBarrierPointer() == ReadBarrier::WhitePtr());
+ }
} else {
- // Use the mark bitmap.
- accounting::ContinuousSpaceBitmap* mark_bitmap =
- heap_mark_bitmap_->GetContinuousSpaceBitmap(ref);
- accounting::LargeObjectBitmap* los_bitmap =
- heap_mark_bitmap_->GetLargeObjectBitmap(ref);
- CHECK(los_bitmap != nullptr) << "LOS bitmap covers the entire address range";
- bool is_los = mark_bitmap == nullptr;
- if (!is_los && mark_bitmap->Test(ref)) {
- // Already marked.
- if (kUseBakerReadBarrier) {
- DCHECK(ref->GetReadBarrierPointer() == ReadBarrier::GrayPtr() ||
- ref->GetReadBarrierPointer() == ReadBarrier::WhitePtr());
+ // Not marked.
+ if (IsOnAllocStack(ref)) {
+ // If it's on the allocation stack, it's considered marked. Keep it white.
+ // Objects on the allocation stack need not be marked.
+ if (!is_los) {
+ DCHECK(!mark_bitmap->Test(ref));
+ } else {
+ DCHECK(!los_bitmap->Test(ref));
}
- } else if (is_los && los_bitmap->Test(ref)) {
- // Already marked in LOS.
if (kUseBakerReadBarrier) {
- DCHECK(ref->GetReadBarrierPointer() == ReadBarrier::GrayPtr() ||
- ref->GetReadBarrierPointer() == ReadBarrier::WhitePtr());
+ DCHECK_EQ(ref->GetReadBarrierPointer(), ReadBarrier::WhitePtr());
}
} else {
- // Not marked.
- if (IsOnAllocStack(ref)) {
- // If it's on the allocation stack, it's considered marked. Keep it white.
- // Objects on the allocation stack need not be marked.
- if (!is_los) {
- DCHECK(!mark_bitmap->Test(ref));
- } else {
- DCHECK(!los_bitmap->Test(ref));
+ // For the baker-style RB, we need to handle 'false-gray' cases. See the
+ // kRegionTypeUnevacFromSpace-case comment in Mark().
+ if (kUseBakerReadBarrier) {
+ // Test the bitmap first to reduce the chance of false gray cases.
+ if ((!is_los && mark_bitmap->Test(ref)) ||
+ (is_los && los_bitmap->Test(ref))) {
+ return ref;
}
- if (kUseBakerReadBarrier) {
- DCHECK_EQ(ref->GetReadBarrierPointer(), ReadBarrier::WhitePtr());
+ }
+ // Not marked or on the allocation stack. Try to mark it.
+ // This may or may not succeed, which is ok.
+ bool cas_success = false;
+ if (kUseBakerReadBarrier) {
+ cas_success = ref->AtomicSetReadBarrierPointer(ReadBarrier::WhitePtr(),
+ ReadBarrier::GrayPtr());
+ }
+ if (!is_los && mark_bitmap->AtomicTestAndSet(ref)) {
+ // Already marked.
+ if (kUseBakerReadBarrier && cas_success &&
+ ref->GetReadBarrierPointer() == ReadBarrier::GrayPtr()) {
+ PushOntoFalseGrayStack(ref);
+ }
+ } else if (is_los && los_bitmap->AtomicTestAndSet(ref)) {
+ // Already marked in LOS.
+ if (kUseBakerReadBarrier && cas_success &&
+ ref->GetReadBarrierPointer() == ReadBarrier::GrayPtr()) {
+ PushOntoFalseGrayStack(ref);
}
} else {
- // For the baker-style RB, we need to handle 'false-gray' cases. See the
- // kRegionTypeUnevacFromSpace-case comment in Mark().
+ // Newly marked.
if (kUseBakerReadBarrier) {
- // Test the bitmap first to reduce the chance of false gray cases.
- if ((!is_los && mark_bitmap->Test(ref)) ||
- (is_los && los_bitmap->Test(ref))) {
- return ref;
- }
+ DCHECK_EQ(ref->GetReadBarrierPointer(), ReadBarrier::GrayPtr());
}
- // Not marked or on the allocation stack. Try to mark it.
- // This may or may not succeed, which is ok.
- bool cas_success = false;
- if (kUseBakerReadBarrier) {
- cas_success = ref->AtomicSetReadBarrierPointer(ReadBarrier::WhitePtr(),
- ReadBarrier::GrayPtr());
- }
- if (!is_los && mark_bitmap->AtomicTestAndSet(ref)) {
- // Already marked.
- if (kUseBakerReadBarrier && cas_success &&
- ref->GetReadBarrierPointer() == ReadBarrier::GrayPtr()) {
- PushOntoFalseGrayStack(ref);
- }
- } else if (is_los && los_bitmap->AtomicTestAndSet(ref)) {
- // Already marked in LOS.
- if (kUseBakerReadBarrier && cas_success &&
- ref->GetReadBarrierPointer() == ReadBarrier::GrayPtr()) {
- PushOntoFalseGrayStack(ref);
- }
- } else {
- // Newly marked.
- if (kUseBakerReadBarrier) {
- DCHECK_EQ(ref->GetReadBarrierPointer(), ReadBarrier::GrayPtr());
- }
- PushOntoMarkStack(ref);
- }
+ PushOntoMarkStack(ref);
}
}
}
diff --git a/runtime/gc/collector/concurrent_copying.h b/runtime/gc/collector/concurrent_copying.h
index a986a7a..166a1f0 100644
--- a/runtime/gc/collector/concurrent_copying.h
+++ b/runtime/gc/collector/concurrent_copying.h
@@ -61,10 +61,12 @@
ConcurrentCopying(Heap* heap, const std::string& name_prefix = "");
~ConcurrentCopying();
- virtual void RunPhases() OVERRIDE REQUIRES(!mark_stack_lock_, !skipped_blocks_lock_);
- void InitializePhase() SHARED_REQUIRES(Locks::mutator_lock_) REQUIRES(!mark_stack_lock_);
+ virtual void RunPhases() OVERRIDE
+ REQUIRES(!mark_stack_lock_, !skipped_blocks_lock_, !immune_gray_stack_lock_);
+ void InitializePhase() SHARED_REQUIRES(Locks::mutator_lock_)
+ REQUIRES(!mark_stack_lock_, !immune_gray_stack_lock_);
void MarkingPhase() SHARED_REQUIRES(Locks::mutator_lock_)
- REQUIRES(!mark_stack_lock_, !skipped_blocks_lock_);
+ REQUIRES(!mark_stack_lock_, !skipped_blocks_lock_, !immune_gray_stack_lock_);
void ReclaimPhase() SHARED_REQUIRES(Locks::mutator_lock_) REQUIRES(!mark_stack_lock_);
void FinishPhase() REQUIRES(!mark_stack_lock_, !skipped_blocks_lock_);
@@ -92,8 +94,9 @@
DCHECK(ref != nullptr);
return IsMarked(ref) == ref;
}
+ template<bool kGrayImmuneObject = true>
ALWAYS_INLINE mirror::Object* Mark(mirror::Object* from_ref) SHARED_REQUIRES(Locks::mutator_lock_)
- REQUIRES(!mark_stack_lock_, !skipped_blocks_lock_);
+ REQUIRES(!mark_stack_lock_, !skipped_blocks_lock_, !immune_gray_stack_lock_);
bool IsMarking() const {
return is_marking_;
}
@@ -117,16 +120,19 @@
void Scan(mirror::Object* to_ref) SHARED_REQUIRES(Locks::mutator_lock_)
REQUIRES(!mark_stack_lock_);
void Process(mirror::Object* obj, MemberOffset offset)
- SHARED_REQUIRES(Locks::mutator_lock_) REQUIRES(!mark_stack_lock_ , !skipped_blocks_lock_);
+ SHARED_REQUIRES(Locks::mutator_lock_)
+ REQUIRES(!mark_stack_lock_ , !skipped_blocks_lock_, !immune_gray_stack_lock_);
virtual void VisitRoots(mirror::Object*** roots, size_t count, const RootInfo& info)
OVERRIDE SHARED_REQUIRES(Locks::mutator_lock_)
- REQUIRES(!mark_stack_lock_, !skipped_blocks_lock_);
+ REQUIRES(!mark_stack_lock_, !skipped_blocks_lock_, !immune_gray_stack_lock_);
+ template<bool kGrayImmuneObject>
void MarkRoot(mirror::CompressedReference<mirror::Object>* root)
- SHARED_REQUIRES(Locks::mutator_lock_) REQUIRES(!mark_stack_lock_, !skipped_blocks_lock_);
+ SHARED_REQUIRES(Locks::mutator_lock_)
+ REQUIRES(!mark_stack_lock_, !skipped_blocks_lock_, !immune_gray_stack_lock_);
virtual void VisitRoots(mirror::CompressedReference<mirror::Object>** roots, size_t count,
const RootInfo& info)
OVERRIDE SHARED_REQUIRES(Locks::mutator_lock_)
- REQUIRES(!mark_stack_lock_, !skipped_blocks_lock_);
+ REQUIRES(!mark_stack_lock_, !skipped_blocks_lock_, !immune_gray_stack_lock_);
void VerifyNoFromSpaceReferences() REQUIRES(Locks::mutator_lock_);
accounting::ObjectStack* GetAllocationStack();
accounting::ObjectStack* GetLiveStack();
@@ -146,9 +152,11 @@
SHARED_REQUIRES(Locks::mutator_lock_);
void ProcessReferences(Thread* self) SHARED_REQUIRES(Locks::mutator_lock_);
virtual mirror::Object* MarkObject(mirror::Object* from_ref) OVERRIDE
- SHARED_REQUIRES(Locks::mutator_lock_) REQUIRES(!mark_stack_lock_, !skipped_blocks_lock_);
+ SHARED_REQUIRES(Locks::mutator_lock_)
+ REQUIRES(!mark_stack_lock_, !skipped_blocks_lock_, !immune_gray_stack_lock_);
virtual void MarkHeapReference(mirror::HeapReference<mirror::Object>* from_ref) OVERRIDE
- SHARED_REQUIRES(Locks::mutator_lock_) REQUIRES(!mark_stack_lock_, !skipped_blocks_lock_);
+ SHARED_REQUIRES(Locks::mutator_lock_)
+ REQUIRES(!mark_stack_lock_, !skipped_blocks_lock_, !immune_gray_stack_lock_);
virtual mirror::Object* IsMarked(mirror::Object* from_ref) OVERRIDE
SHARED_REQUIRES(Locks::mutator_lock_);
virtual bool IsMarkedHeapReference(mirror::HeapReference<mirror::Object>* field) OVERRIDE
@@ -182,14 +190,19 @@
void ExpandGcMarkStack() SHARED_REQUIRES(Locks::mutator_lock_);
mirror::Object* MarkNonMoving(mirror::Object* from_ref) SHARED_REQUIRES(Locks::mutator_lock_)
REQUIRES(!mark_stack_lock_, !skipped_blocks_lock_);
- ALWAYS_INLINE mirror::Object* MarkUnevacFromSpaceRegionOrImmuneSpace(mirror::Object* from_ref,
+ ALWAYS_INLINE mirror::Object* MarkUnevacFromSpaceRegion(mirror::Object* from_ref,
accounting::SpaceBitmap<kObjectAlignment>* bitmap)
SHARED_REQUIRES(Locks::mutator_lock_)
REQUIRES(!mark_stack_lock_, !skipped_blocks_lock_);
+ template<bool kGrayImmuneObject>
+ ALWAYS_INLINE mirror::Object* MarkImmuneSpace(mirror::Object* from_ref)
+ SHARED_REQUIRES(Locks::mutator_lock_) REQUIRES(!immune_gray_stack_lock_);
void PushOntoFalseGrayStack(mirror::Object* obj) SHARED_REQUIRES(Locks::mutator_lock_)
REQUIRES(!mark_stack_lock_);
void ProcessFalseGrayStack() SHARED_REQUIRES(Locks::mutator_lock_)
REQUIRES(!mark_stack_lock_);
+ void ScanImmuneObject(mirror::Object* obj)
+ SHARED_REQUIRES(Locks::mutator_lock_) REQUIRES(!mark_stack_lock_);
space::RegionSpace* region_space_; // The underlying region space.
std::unique_ptr<Barrier> gc_barrier_;
@@ -207,8 +220,6 @@
bool is_active_; // True while the collection is ongoing.
bool is_asserting_to_space_invariant_; // True while asserting the to-space invariant.
ImmuneSpaces immune_spaces_;
- std::unique_ptr<accounting::HeapBitmap> cc_heap_bitmap_;
- std::vector<accounting::SpaceBitmap<kObjectAlignment>*> cc_bitmaps_;
accounting::SpaceBitmap<kObjectAlignment>* region_space_bitmap_;
// A cache of Heap::GetMarkBitmap().
accounting::HeapBitmap* heap_mark_bitmap_;
@@ -242,6 +253,10 @@
accounting::ReadBarrierTable* rb_table_;
bool force_evacuate_all_; // True if all regions are evacuated.
+ Atomic<bool> updated_all_immune_objects_;
+ bool gc_grays_immune_objects_;
+ Mutex immune_gray_stack_lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
+ std::vector<mirror::Object*> immune_gray_stack_ GUARDED_BY(immune_gray_stack_lock_);
class AssertToSpaceInvariantFieldVisitor;
class AssertToSpaceInvariantObjectVisitor;
@@ -250,14 +265,15 @@
class ComputeUnevacFromSpaceLiveRatioVisitor;
class DisableMarkingCheckpoint;
class FlipCallback;
- class ImmuneSpaceObjVisitor;
+ class ImmuneSpaceScanObjVisitor;
class LostCopyVisitor;
class RefFieldsVisitor;
class RevokeThreadLocalMarkStackCheckpoint;
+ class ScopedGcGraysImmuneObjects;
+ class ThreadFlipVisitor;
class VerifyNoFromSpaceRefsFieldVisitor;
class VerifyNoFromSpaceRefsObjectVisitor;
class VerifyNoFromSpaceRefsVisitor;
- class ThreadFlipVisitor;
DISALLOW_IMPLICIT_CONSTRUCTORS(ConcurrentCopying);
};
diff --git a/runtime/gc/space/image_space.cc b/runtime/gc/space/image_space.cc
index e896c7a..8cadc2e 100644
--- a/runtime/gc/space/image_space.cc
+++ b/runtime/gc/space/image_space.cc
@@ -1130,6 +1130,10 @@
image_header.VisitPackedArtFields(&field_visitor, target_base);
}
{
+ TimingLogger::ScopedTiming timing("Fixup imt", &logger);
+ image_header.VisitPackedImTables(fixup_adapter, target_base, pointer_size);
+ }
+ {
TimingLogger::ScopedTiming timing("Fixup conflict tables", &logger);
image_header.VisitPackedImtConflictTables(fixup_adapter, target_base, pointer_size);
}
diff --git a/runtime/image-inl.h b/runtime/image-inl.h
index ea75a62..cd0557a 100644
--- a/runtime/image-inl.h
+++ b/runtime/image-inl.h
@@ -20,6 +20,7 @@
#include "image.h"
#include "art_method.h"
+#include "imtable.h"
namespace art {
@@ -45,6 +46,24 @@
}
template <typename Visitor>
+inline void ImageHeader::VisitPackedImTables(const Visitor& visitor,
+ uint8_t* base,
+ size_t pointer_size) const {
+ const ImageSection& section = GetImageSection(kSectionImTables);
+ for (size_t pos = 0; pos < section.Size();) {
+ ImTable* imt = reinterpret_cast<ImTable*>(base + section.Offset() + pos);
+ for (size_t i = 0; i < ImTable::kSize; ++i) {
+ ArtMethod* orig = imt->Get(i, pointer_size);
+ ArtMethod* updated = visitor(orig);
+ if (updated != orig) {
+ imt->Set(i, updated, pointer_size);
+ }
+ }
+ pos += ImTable::SizeInBytes(pointer_size);
+ }
+}
+
+template <typename Visitor>
inline void ImageHeader::VisitPackedImtConflictTables(const Visitor& visitor,
uint8_t* base,
size_t pointer_size) const {
diff --git a/runtime/image.cc b/runtime/image.cc
index a9552c2..2362a92 100644
--- a/runtime/image.cc
+++ b/runtime/image.cc
@@ -24,7 +24,7 @@
namespace art {
const uint8_t ImageHeader::kImageMagic[] = { 'a', 'r', 't', '\n' };
-const uint8_t ImageHeader::kImageVersion[] = { '0', '2', '9', '\0' };
+const uint8_t ImageHeader::kImageVersion[] = { '0', '3', '0', '\0' };
ImageHeader::ImageHeader(uint32_t image_begin,
uint32_t image_size,
diff --git a/runtime/image.h b/runtime/image.h
index 2ea9af7..06f06ee 100644
--- a/runtime/image.h
+++ b/runtime/image.h
@@ -195,6 +195,7 @@
kSectionArtFields,
kSectionArtMethods,
kSectionRuntimeMethods,
+ kSectionImTables,
kSectionIMTConflictTables,
kSectionDexCacheArrays,
kSectionInternedStrings,
@@ -279,6 +280,11 @@
void VisitPackedArtFields(ArtFieldVisitor* visitor, uint8_t* base) const;
template <typename Visitor>
+ void VisitPackedImTables(const Visitor& visitor,
+ uint8_t* base,
+ size_t pointer_size) const;
+
+ template <typename Visitor>
void VisitPackedImtConflictTables(const Visitor& visitor,
uint8_t* base,
size_t pointer_size) const;
diff --git a/runtime/imtable.h b/runtime/imtable.h
new file mode 100644
index 0000000..51faf70
--- /dev/null
+++ b/runtime/imtable.h
@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ART_RUNTIME_IMTABLE_H_
+#define ART_RUNTIME_IMTABLE_H_
+
+#ifndef IMT_SIZE
+#error IMT_SIZE not defined
+#endif
+
+namespace art {
+
+class ArtMethod;
+
+class ImTable {
+ public:
+ // Interface method table size. Increasing this value reduces the chance of two interface methods
+ // colliding in the interface method table but increases the size of classes that implement
+ // (non-marker) interfaces.
+ static constexpr size_t kSize = IMT_SIZE;
+
+ ArtMethod* Get(size_t index, size_t pointer_size) {
+ DCHECK_LT(index, kSize);
+ uint8_t* ptr = reinterpret_cast<uint8_t*>(this) + OffsetOfElement(index, pointer_size);
+ if (pointer_size == 4) {
+ uint32_t value = *reinterpret_cast<uint32_t*>(ptr);
+ return reinterpret_cast<ArtMethod*>(value);
+ } else {
+ uint64_t value = *reinterpret_cast<uint64_t*>(ptr);
+ return reinterpret_cast<ArtMethod*>(value);
+ }
+ }
+
+ void Set(size_t index, ArtMethod* method, size_t pointer_size) {
+ DCHECK_LT(index, kSize);
+ uint8_t* ptr = reinterpret_cast<uint8_t*>(this) + OffsetOfElement(index, pointer_size);
+ if (pointer_size == 4) {
+ uintptr_t value = reinterpret_cast<uintptr_t>(method);
+ DCHECK_EQ(static_cast<uint32_t>(value), value); // Check that we dont lose any non 0 bits.
+ *reinterpret_cast<uint32_t*>(ptr) = static_cast<uint32_t>(value);
+ } else {
+ *reinterpret_cast<uint64_t*>(ptr) = reinterpret_cast<uint64_t>(method);
+ }
+ }
+
+ static size_t OffsetOfElement(size_t index, size_t pointer_size) {
+ return index * pointer_size;
+ }
+
+ void Populate(ArtMethod** data, size_t pointer_size) {
+ for (size_t i = 0; i < kSize; ++i) {
+ Set(i, data[i], pointer_size);
+ }
+ }
+
+ constexpr static size_t SizeInBytes(size_t pointer_size) {
+ return kSize * pointer_size;
+ }
+};
+
+} // namespace art
+
+#endif // ART_RUNTIME_IMTABLE_H_
+
diff --git a/runtime/interpreter/interpreter_common.h b/runtime/interpreter/interpreter_common.h
index cc470f3..7dfa6e2 100644
--- a/runtime/interpreter/interpreter_common.h
+++ b/runtime/interpreter/interpreter_common.h
@@ -679,7 +679,7 @@
return false;
}
const uint32_t vtable_idx = (is_range) ? inst->VRegB_3rc() : inst->VRegB_35c();
- CHECK(receiver->GetClass()->ShouldHaveEmbeddedImtAndVTable());
+ CHECK(receiver->GetClass()->ShouldHaveEmbeddedVTable());
ArtMethod* const called_method = receiver->GetClass()->GetEmbeddedVTableEntry(
vtable_idx, sizeof(void*));
if (UNLIKELY(called_method == nullptr)) {
@@ -979,15 +979,13 @@
__attribute__((cold))
SHARED_REQUIRES(Locks::mutator_lock_);
-static inline bool TraceExecutionEnabled() {
- // Return true if you want TraceExecution invocation before each bytecode execution.
- return false;
-}
+// Set true if you want TraceExecution invocation before each bytecode execution.
+constexpr bool kTraceExecutionEnabled = false;
static inline void TraceExecution(const ShadowFrame& shadow_frame, const Instruction* inst,
const uint32_t dex_pc)
SHARED_REQUIRES(Locks::mutator_lock_) {
- if (TraceExecutionEnabled()) {
+ if (kTraceExecutionEnabled) {
#define TRACE_LOG std::cerr
std::ostringstream oss;
oss << PrettyMethod(shadow_frame.GetMethod())
diff --git a/runtime/interpreter/mterp/arm/alt_stub.S b/runtime/interpreter/mterp/arm/alt_stub.S
index 92ae0c6..9db5bf7 100644
--- a/runtime/interpreter/mterp/arm/alt_stub.S
+++ b/runtime/interpreter/mterp/arm/alt_stub.S
@@ -4,9 +4,9 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (${opnum} * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
diff --git a/runtime/interpreter/mterp/arm64/alt_stub.S b/runtime/interpreter/mterp/arm64/alt_stub.S
index 9b8b16d..3a463fe 100644
--- a/runtime/interpreter/mterp/arm64/alt_stub.S
+++ b/runtime/interpreter/mterp/arm64/alt_stub.S
@@ -4,9 +4,9 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (${opnum} * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
diff --git a/runtime/interpreter/mterp/mips/alt_stub.S b/runtime/interpreter/mterp/mips/alt_stub.S
index 4598061..de13313 100644
--- a/runtime/interpreter/mterp/mips/alt_stub.S
+++ b/runtime/interpreter/mterp/mips/alt_stub.S
@@ -4,10 +4,10 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (${opnum} * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
diff --git a/runtime/interpreter/mterp/mips64/alt_stub.S b/runtime/interpreter/mterp/mips64/alt_stub.S
index bd76a1b..12fa84d 100644
--- a/runtime/interpreter/mterp/mips64/alt_stub.S
+++ b/runtime/interpreter/mterp/mips64/alt_stub.S
@@ -4,11 +4,11 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (${opnum} * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
diff --git a/runtime/interpreter/mterp/mterp.cc b/runtime/interpreter/mterp/mterp.cc
index bd1af04..8aa87b1 100644
--- a/runtime/interpreter/mterp/mterp.cc
+++ b/runtime/interpreter/mterp/mterp.cc
@@ -46,7 +46,7 @@
void InitMterpTls(Thread* self) {
self->SetMterpDefaultIBase(artMterpAsmInstructionStart);
self->SetMterpAltIBase(artMterpAsmAltInstructionStart);
- self->SetMterpCurrentIBase(TraceExecutionEnabled() ?
+ self->SetMterpCurrentIBase((kTraceExecutionEnabled || kTestExportPC) ?
artMterpAsmAltInstructionStart :
artMterpAsmInstructionStart);
}
@@ -430,16 +430,23 @@
return true;
}
-extern "C" void MterpCheckBefore(Thread* self, ShadowFrame* shadow_frame)
+extern "C" void MterpCheckBefore(Thread* self, ShadowFrame* shadow_frame, uint16_t* dex_pc_ptr)
SHARED_REQUIRES(Locks::mutator_lock_) {
- const Instruction* inst = Instruction::At(shadow_frame->GetDexPCPtr());
+ const Instruction* inst = Instruction::At(dex_pc_ptr);
uint16_t inst_data = inst->Fetch16(0);
if (inst->Opcode(inst_data) == Instruction::MOVE_EXCEPTION) {
self->AssertPendingException();
} else {
self->AssertNoPendingException();
}
- TraceExecution(*shadow_frame, inst, shadow_frame->GetDexPC());
+ if (kTraceExecutionEnabled) {
+ uint32_t dex_pc = dex_pc_ptr - shadow_frame->GetCodeItem()->insns_;
+ TraceExecution(*shadow_frame, inst, dex_pc);
+ }
+ if (kTestExportPC) {
+ // Save invalid dex pc to force segfault if improperly used.
+ shadow_frame->SetDexPCPtr(reinterpret_cast<uint16_t*>(kExportPCPoison));
+ }
}
extern "C" void MterpLogDivideByZeroException(Thread* self, ShadowFrame* shadow_frame)
diff --git a/runtime/interpreter/mterp/mterp.h b/runtime/interpreter/mterp/mterp.h
index 8d24641..88e17bc 100644
--- a/runtime/interpreter/mterp/mterp.h
+++ b/runtime/interpreter/mterp/mterp.h
@@ -32,6 +32,13 @@
void CheckMterpAsmConstants();
extern "C" bool MterpShouldSwitchInterpreters();
+// Poison value for TestExportPC. If we segfault with this value, it means that a mterp
+// handler for a recent opcode failed to export the Dalvik PC prior to a possible exit from
+// the mterp environment.
+constexpr uintptr_t kExportPCPoison = 0xdead00ff;
+// Set true to enable poison testing of ExportPC. Uses Alt interpreter.
+constexpr bool kTestExportPC = false;
+
} // namespace interpreter
} // namespace art
diff --git a/runtime/interpreter/mterp/out/mterp_arm.S b/runtime/interpreter/mterp/out/mterp_arm.S
index a38a87b..df25767 100644
--- a/runtime/interpreter/mterp/out/mterp_arm.S
+++ b/runtime/interpreter/mterp/out/mterp_arm.S
@@ -7441,12 +7441,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (0 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -7458,12 +7458,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (1 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -7475,12 +7475,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (2 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -7492,12 +7492,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (3 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -7509,12 +7509,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (4 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -7526,12 +7526,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (5 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -7543,12 +7543,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (6 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -7560,12 +7560,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (7 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -7577,12 +7577,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (8 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -7594,12 +7594,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (9 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -7611,12 +7611,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (10 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -7628,12 +7628,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (11 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -7645,12 +7645,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (12 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -7662,12 +7662,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (13 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -7679,12 +7679,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (14 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -7696,12 +7696,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (15 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -7713,12 +7713,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (16 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -7730,12 +7730,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (17 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -7747,12 +7747,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (18 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -7764,12 +7764,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (19 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -7781,12 +7781,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (20 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -7798,12 +7798,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (21 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -7815,12 +7815,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (22 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -7832,12 +7832,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (23 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -7849,12 +7849,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (24 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -7866,12 +7866,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (25 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -7883,12 +7883,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (26 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -7900,12 +7900,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (27 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -7917,12 +7917,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (28 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -7934,12 +7934,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (29 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -7951,12 +7951,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (30 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -7968,12 +7968,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (31 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -7985,12 +7985,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (32 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8002,12 +8002,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (33 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8019,12 +8019,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (34 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8036,12 +8036,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (35 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8053,12 +8053,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (36 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8070,12 +8070,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (37 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8087,12 +8087,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (38 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8104,12 +8104,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (39 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8121,12 +8121,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (40 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8138,12 +8138,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (41 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8155,12 +8155,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (42 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8172,12 +8172,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (43 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8189,12 +8189,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (44 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8206,12 +8206,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (45 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8223,12 +8223,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (46 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8240,12 +8240,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (47 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8257,12 +8257,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (48 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8274,12 +8274,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (49 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8291,12 +8291,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (50 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8308,12 +8308,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (51 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8325,12 +8325,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (52 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8342,12 +8342,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (53 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8359,12 +8359,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (54 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8376,12 +8376,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (55 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8393,12 +8393,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (56 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8410,12 +8410,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (57 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8427,12 +8427,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (58 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8444,12 +8444,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (59 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8461,12 +8461,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (60 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8478,12 +8478,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (61 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8495,12 +8495,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (62 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8512,12 +8512,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (63 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8529,12 +8529,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (64 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8546,12 +8546,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (65 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8563,12 +8563,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (66 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8580,12 +8580,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (67 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8597,12 +8597,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (68 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8614,12 +8614,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (69 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8631,12 +8631,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (70 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8648,12 +8648,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (71 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8665,12 +8665,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (72 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8682,12 +8682,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (73 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8699,12 +8699,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (74 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8716,12 +8716,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (75 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8733,12 +8733,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (76 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8750,12 +8750,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (77 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8767,12 +8767,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (78 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8784,12 +8784,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (79 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8801,12 +8801,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (80 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8818,12 +8818,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (81 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8835,12 +8835,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (82 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8852,12 +8852,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (83 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8869,12 +8869,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (84 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8886,12 +8886,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (85 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8903,12 +8903,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (86 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8920,12 +8920,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (87 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8937,12 +8937,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (88 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8954,12 +8954,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (89 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8971,12 +8971,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (90 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -8988,12 +8988,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (91 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9005,12 +9005,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (92 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9022,12 +9022,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (93 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9039,12 +9039,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (94 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9056,12 +9056,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (95 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9073,12 +9073,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (96 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9090,12 +9090,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (97 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9107,12 +9107,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (98 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9124,12 +9124,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (99 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9141,12 +9141,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (100 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9158,12 +9158,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (101 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9175,12 +9175,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (102 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9192,12 +9192,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (103 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9209,12 +9209,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (104 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9226,12 +9226,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (105 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9243,12 +9243,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (106 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9260,12 +9260,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (107 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9277,12 +9277,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (108 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9294,12 +9294,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (109 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9311,12 +9311,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (110 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9328,12 +9328,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (111 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9345,12 +9345,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (112 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9362,12 +9362,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (113 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9379,12 +9379,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (114 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9396,12 +9396,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (115 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9413,12 +9413,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (116 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9430,12 +9430,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (117 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9447,12 +9447,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (118 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9464,12 +9464,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (119 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9481,12 +9481,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (120 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9498,12 +9498,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (121 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9515,12 +9515,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (122 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9532,12 +9532,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (123 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9549,12 +9549,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (124 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9566,12 +9566,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (125 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9583,12 +9583,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (126 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9600,12 +9600,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (127 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9617,12 +9617,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (128 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9634,12 +9634,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (129 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9651,12 +9651,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (130 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9668,12 +9668,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (131 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9685,12 +9685,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (132 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9702,12 +9702,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (133 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9719,12 +9719,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (134 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9736,12 +9736,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (135 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9753,12 +9753,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (136 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9770,12 +9770,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (137 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9787,12 +9787,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (138 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9804,12 +9804,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (139 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9821,12 +9821,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (140 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9838,12 +9838,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (141 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9855,12 +9855,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (142 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9872,12 +9872,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (143 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9889,12 +9889,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (144 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9906,12 +9906,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (145 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9923,12 +9923,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (146 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9940,12 +9940,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (147 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9957,12 +9957,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (148 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9974,12 +9974,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (149 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -9991,12 +9991,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (150 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10008,12 +10008,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (151 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10025,12 +10025,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (152 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10042,12 +10042,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (153 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10059,12 +10059,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (154 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10076,12 +10076,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (155 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10093,12 +10093,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (156 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10110,12 +10110,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (157 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10127,12 +10127,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (158 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10144,12 +10144,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (159 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10161,12 +10161,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (160 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10178,12 +10178,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (161 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10195,12 +10195,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (162 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10212,12 +10212,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (163 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10229,12 +10229,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (164 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10246,12 +10246,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (165 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10263,12 +10263,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (166 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10280,12 +10280,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (167 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10297,12 +10297,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (168 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10314,12 +10314,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (169 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10331,12 +10331,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (170 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10348,12 +10348,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (171 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10365,12 +10365,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (172 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10382,12 +10382,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (173 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10399,12 +10399,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (174 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10416,12 +10416,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (175 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10433,12 +10433,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (176 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10450,12 +10450,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (177 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10467,12 +10467,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (178 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10484,12 +10484,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (179 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10501,12 +10501,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (180 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10518,12 +10518,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (181 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10535,12 +10535,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (182 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10552,12 +10552,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (183 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10569,12 +10569,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (184 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10586,12 +10586,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (185 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10603,12 +10603,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (186 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10620,12 +10620,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (187 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10637,12 +10637,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (188 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10654,12 +10654,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (189 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10671,12 +10671,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (190 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10688,12 +10688,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (191 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10705,12 +10705,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (192 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10722,12 +10722,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (193 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10739,12 +10739,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (194 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10756,12 +10756,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (195 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10773,12 +10773,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (196 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10790,12 +10790,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (197 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10807,12 +10807,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (198 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10824,12 +10824,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (199 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10841,12 +10841,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (200 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10858,12 +10858,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (201 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10875,12 +10875,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (202 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10892,12 +10892,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (203 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10909,12 +10909,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (204 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10926,12 +10926,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (205 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10943,12 +10943,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (206 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10960,12 +10960,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (207 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10977,12 +10977,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (208 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -10994,12 +10994,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (209 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11011,12 +11011,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (210 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11028,12 +11028,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (211 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11045,12 +11045,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (212 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11062,12 +11062,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (213 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11079,12 +11079,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (214 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11096,12 +11096,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (215 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11113,12 +11113,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (216 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11130,12 +11130,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (217 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11147,12 +11147,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (218 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11164,12 +11164,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (219 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11181,12 +11181,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (220 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11198,12 +11198,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (221 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11215,12 +11215,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (222 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11232,12 +11232,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (223 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11249,12 +11249,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (224 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11266,12 +11266,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (225 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11283,12 +11283,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (226 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11300,12 +11300,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (227 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11317,12 +11317,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (228 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11334,12 +11334,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (229 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11351,12 +11351,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (230 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11368,12 +11368,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (231 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11385,12 +11385,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (232 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11402,12 +11402,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (233 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11419,12 +11419,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (234 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11436,12 +11436,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (235 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11453,12 +11453,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (236 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11470,12 +11470,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (237 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11487,12 +11487,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (238 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11504,12 +11504,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (239 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11521,12 +11521,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (240 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11538,12 +11538,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (241 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11555,12 +11555,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (242 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11572,12 +11572,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (243 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11589,12 +11589,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (244 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11606,12 +11606,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (245 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11623,12 +11623,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (246 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11640,12 +11640,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (247 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11657,12 +11657,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (248 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11674,12 +11674,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (249 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11691,12 +11691,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (250 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11708,12 +11708,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (251 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11725,12 +11725,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (252 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11742,12 +11742,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (253 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11759,12 +11759,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (254 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
/* ------------------------------ */
.balign 128
@@ -11776,12 +11776,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr rIBASE, [rSELF, #THREAD_CURRENT_IBASE_OFFSET] @ refresh IBASE.
adrl lr, artMterpAsmInstructionStart + (255 * 128) @ Addr of primary handler.
mov r0, rSELF
add r1, rFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore @ (self, shadow_frame) @ Tail call.
+ mov r2, rPC
+ b MterpCheckBefore @ (self, shadow_frame, dex_pc_ptr) @ Tail call.
.balign 128
.size artMterpAsmAltInstructionStart, .-artMterpAsmAltInstructionStart
diff --git a/runtime/interpreter/mterp/out/mterp_arm64.S b/runtime/interpreter/mterp/out/mterp_arm64.S
index 55797e6..df0b686 100644
--- a/runtime/interpreter/mterp/out/mterp_arm64.S
+++ b/runtime/interpreter/mterp/out/mterp_arm64.S
@@ -6938,12 +6938,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (0 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -6955,12 +6955,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (1 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -6972,12 +6972,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (2 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -6989,12 +6989,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (3 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7006,12 +7006,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (4 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7023,12 +7023,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (5 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7040,12 +7040,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (6 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7057,12 +7057,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (7 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7074,12 +7074,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (8 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7091,12 +7091,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (9 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7108,12 +7108,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (10 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7125,12 +7125,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (11 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7142,12 +7142,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (12 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7159,12 +7159,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (13 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7176,12 +7176,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (14 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7193,12 +7193,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (15 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7210,12 +7210,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (16 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7227,12 +7227,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (17 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7244,12 +7244,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (18 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7261,12 +7261,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (19 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7278,12 +7278,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (20 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7295,12 +7295,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (21 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7312,12 +7312,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (22 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7329,12 +7329,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (23 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7346,12 +7346,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (24 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7363,12 +7363,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (25 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7380,12 +7380,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (26 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7397,12 +7397,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (27 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7414,12 +7414,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (28 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7431,12 +7431,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (29 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7448,12 +7448,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (30 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7465,12 +7465,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (31 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7482,12 +7482,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (32 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7499,12 +7499,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (33 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7516,12 +7516,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (34 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7533,12 +7533,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (35 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7550,12 +7550,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (36 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7567,12 +7567,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (37 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7584,12 +7584,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (38 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7601,12 +7601,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (39 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7618,12 +7618,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (40 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7635,12 +7635,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (41 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7652,12 +7652,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (42 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7669,12 +7669,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (43 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7686,12 +7686,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (44 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7703,12 +7703,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (45 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7720,12 +7720,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (46 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7737,12 +7737,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (47 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7754,12 +7754,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (48 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7771,12 +7771,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (49 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7788,12 +7788,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (50 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7805,12 +7805,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (51 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7822,12 +7822,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (52 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7839,12 +7839,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (53 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7856,12 +7856,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (54 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7873,12 +7873,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (55 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7890,12 +7890,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (56 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7907,12 +7907,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (57 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7924,12 +7924,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (58 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7941,12 +7941,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (59 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7958,12 +7958,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (60 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7975,12 +7975,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (61 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7992,12 +7992,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (62 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8009,12 +8009,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (63 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8026,12 +8026,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (64 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8043,12 +8043,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (65 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8060,12 +8060,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (66 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8077,12 +8077,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (67 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8094,12 +8094,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (68 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8111,12 +8111,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (69 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8128,12 +8128,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (70 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8145,12 +8145,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (71 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8162,12 +8162,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (72 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8179,12 +8179,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (73 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8196,12 +8196,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (74 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8213,12 +8213,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (75 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8230,12 +8230,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (76 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8247,12 +8247,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (77 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8264,12 +8264,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (78 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8281,12 +8281,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (79 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8298,12 +8298,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (80 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8315,12 +8315,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (81 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8332,12 +8332,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (82 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8349,12 +8349,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (83 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8366,12 +8366,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (84 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8383,12 +8383,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (85 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8400,12 +8400,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (86 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8417,12 +8417,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (87 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8434,12 +8434,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (88 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8451,12 +8451,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (89 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8468,12 +8468,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (90 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8485,12 +8485,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (91 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8502,12 +8502,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (92 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8519,12 +8519,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (93 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8536,12 +8536,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (94 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8553,12 +8553,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (95 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8570,12 +8570,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (96 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8587,12 +8587,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (97 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8604,12 +8604,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (98 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8621,12 +8621,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (99 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8638,12 +8638,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (100 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8655,12 +8655,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (101 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8672,12 +8672,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (102 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8689,12 +8689,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (103 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8706,12 +8706,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (104 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8723,12 +8723,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (105 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8740,12 +8740,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (106 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8757,12 +8757,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (107 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8774,12 +8774,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (108 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8791,12 +8791,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (109 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8808,12 +8808,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (110 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8825,12 +8825,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (111 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8842,12 +8842,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (112 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8859,12 +8859,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (113 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8876,12 +8876,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (114 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8893,12 +8893,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (115 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8910,12 +8910,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (116 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8927,12 +8927,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (117 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8944,12 +8944,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (118 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8961,12 +8961,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (119 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8978,12 +8978,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (120 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8995,12 +8995,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (121 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9012,12 +9012,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (122 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9029,12 +9029,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (123 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9046,12 +9046,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (124 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9063,12 +9063,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (125 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9080,12 +9080,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (126 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9097,12 +9097,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (127 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9114,12 +9114,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (128 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9131,12 +9131,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (129 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9148,12 +9148,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (130 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9165,12 +9165,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (131 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9182,12 +9182,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (132 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9199,12 +9199,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (133 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9216,12 +9216,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (134 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9233,12 +9233,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (135 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9250,12 +9250,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (136 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9267,12 +9267,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (137 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9284,12 +9284,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (138 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9301,12 +9301,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (139 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9318,12 +9318,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (140 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9335,12 +9335,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (141 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9352,12 +9352,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (142 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9369,12 +9369,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (143 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9386,12 +9386,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (144 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9403,12 +9403,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (145 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9420,12 +9420,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (146 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9437,12 +9437,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (147 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9454,12 +9454,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (148 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9471,12 +9471,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (149 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9488,12 +9488,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (150 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9505,12 +9505,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (151 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9522,12 +9522,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (152 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9539,12 +9539,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (153 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9556,12 +9556,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (154 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9573,12 +9573,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (155 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9590,12 +9590,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (156 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9607,12 +9607,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (157 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9624,12 +9624,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (158 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9641,12 +9641,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (159 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9658,12 +9658,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (160 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9675,12 +9675,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (161 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9692,12 +9692,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (162 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9709,12 +9709,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (163 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9726,12 +9726,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (164 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9743,12 +9743,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (165 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9760,12 +9760,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (166 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9777,12 +9777,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (167 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9794,12 +9794,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (168 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9811,12 +9811,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (169 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9828,12 +9828,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (170 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9845,12 +9845,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (171 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9862,12 +9862,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (172 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9879,12 +9879,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (173 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9896,12 +9896,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (174 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9913,12 +9913,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (175 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9930,12 +9930,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (176 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9947,12 +9947,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (177 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9964,12 +9964,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (178 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9981,12 +9981,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (179 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9998,12 +9998,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (180 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10015,12 +10015,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (181 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10032,12 +10032,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (182 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10049,12 +10049,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (183 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10066,12 +10066,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (184 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10083,12 +10083,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (185 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10100,12 +10100,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (186 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10117,12 +10117,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (187 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10134,12 +10134,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (188 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10151,12 +10151,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (189 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10168,12 +10168,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (190 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10185,12 +10185,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (191 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10202,12 +10202,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (192 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10219,12 +10219,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (193 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10236,12 +10236,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (194 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10253,12 +10253,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (195 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10270,12 +10270,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (196 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10287,12 +10287,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (197 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10304,12 +10304,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (198 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10321,12 +10321,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (199 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10338,12 +10338,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (200 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10355,12 +10355,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (201 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10372,12 +10372,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (202 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10389,12 +10389,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (203 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10406,12 +10406,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (204 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10423,12 +10423,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (205 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10440,12 +10440,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (206 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10457,12 +10457,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (207 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10474,12 +10474,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (208 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10491,12 +10491,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (209 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10508,12 +10508,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (210 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10525,12 +10525,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (211 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10542,12 +10542,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (212 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10559,12 +10559,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (213 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10576,12 +10576,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (214 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10593,12 +10593,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (215 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10610,12 +10610,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (216 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10627,12 +10627,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (217 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10644,12 +10644,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (218 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10661,12 +10661,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (219 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10678,12 +10678,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (220 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10695,12 +10695,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (221 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10712,12 +10712,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (222 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10729,12 +10729,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (223 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10746,12 +10746,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (224 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10763,12 +10763,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (225 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10780,12 +10780,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (226 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10797,12 +10797,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (227 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10814,12 +10814,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (228 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10831,12 +10831,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (229 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10848,12 +10848,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (230 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10865,12 +10865,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (231 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10882,12 +10882,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (232 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10899,12 +10899,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (233 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10916,12 +10916,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (234 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10933,12 +10933,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (235 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10950,12 +10950,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (236 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10967,12 +10967,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (237 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10984,12 +10984,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (238 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11001,12 +11001,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (239 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11018,12 +11018,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (240 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11035,12 +11035,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (241 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11052,12 +11052,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (242 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11069,12 +11069,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (243 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11086,12 +11086,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (244 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11103,12 +11103,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (245 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11120,12 +11120,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (246 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11137,12 +11137,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (247 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11154,12 +11154,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (248 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11171,12 +11171,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (249 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11188,12 +11188,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (250 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11205,12 +11205,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (251 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11222,12 +11222,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (252 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11239,12 +11239,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (253 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11256,12 +11256,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (254 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11273,12 +11273,12 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
ldr xIBASE, [xSELF, #THREAD_CURRENT_IBASE_OFFSET] // refresh IBASE.
adr lr, artMterpAsmInstructionStart + (255 * 128) // Addr of primary handler.
mov x0, xSELF
add x1, xFP, #OFF_FP_SHADOWFRAME
- b MterpCheckBefore // (self, shadow_frame) Note: tail call.
+ mov x2, xPC
+ b MterpCheckBefore // (self, shadow_frame, dex_pc_ptr) Note: tail call.
.balign 128
.size artMterpAsmAltInstructionStart, .-artMterpAsmAltInstructionStart
diff --git a/runtime/interpreter/mterp/out/mterp_mips.S b/runtime/interpreter/mterp/out/mterp_mips.S
index daa6f2a..5e0c19f 100644
--- a/runtime/interpreter/mterp/out/mterp_mips.S
+++ b/runtime/interpreter/mterp/out/mterp_mips.S
@@ -8015,13 +8015,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (0 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8033,13 +8033,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (1 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8051,13 +8051,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (2 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8069,13 +8069,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (3 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8087,13 +8087,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (4 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8105,13 +8105,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (5 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8123,13 +8123,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (6 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8141,13 +8141,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (7 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8159,13 +8159,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (8 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8177,13 +8177,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (9 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8195,13 +8195,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (10 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8213,13 +8213,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (11 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8231,13 +8231,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (12 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8249,13 +8249,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (13 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8267,13 +8267,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (14 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8285,13 +8285,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (15 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8303,13 +8303,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (16 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8321,13 +8321,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (17 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8339,13 +8339,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (18 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8357,13 +8357,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (19 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8375,13 +8375,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (20 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8393,13 +8393,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (21 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8411,13 +8411,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (22 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8429,13 +8429,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (23 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8447,13 +8447,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (24 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8465,13 +8465,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (25 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8483,13 +8483,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (26 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8501,13 +8501,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (27 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8519,13 +8519,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (28 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8537,13 +8537,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (29 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8555,13 +8555,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (30 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8573,13 +8573,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (31 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8591,13 +8591,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (32 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8609,13 +8609,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (33 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8627,13 +8627,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (34 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8645,13 +8645,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (35 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8663,13 +8663,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (36 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8681,13 +8681,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (37 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8699,13 +8699,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (38 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8717,13 +8717,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (39 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8735,13 +8735,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (40 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8753,13 +8753,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (41 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8771,13 +8771,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (42 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8789,13 +8789,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (43 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8807,13 +8807,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (44 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8825,13 +8825,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (45 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8843,13 +8843,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (46 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8861,13 +8861,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (47 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8879,13 +8879,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (48 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8897,13 +8897,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (49 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8915,13 +8915,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (50 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8933,13 +8933,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (51 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8951,13 +8951,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (52 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8969,13 +8969,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (53 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -8987,13 +8987,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (54 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9005,13 +9005,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (55 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9023,13 +9023,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (56 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9041,13 +9041,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (57 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9059,13 +9059,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (58 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9077,13 +9077,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (59 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9095,13 +9095,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (60 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9113,13 +9113,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (61 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9131,13 +9131,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (62 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9149,13 +9149,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (63 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9167,13 +9167,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (64 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9185,13 +9185,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (65 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9203,13 +9203,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (66 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9221,13 +9221,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (67 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9239,13 +9239,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (68 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9257,13 +9257,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (69 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9275,13 +9275,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (70 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9293,13 +9293,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (71 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9311,13 +9311,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (72 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9329,13 +9329,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (73 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9347,13 +9347,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (74 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9365,13 +9365,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (75 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9383,13 +9383,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (76 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9401,13 +9401,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (77 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9419,13 +9419,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (78 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9437,13 +9437,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (79 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9455,13 +9455,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (80 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9473,13 +9473,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (81 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9491,13 +9491,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (82 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9509,13 +9509,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (83 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9527,13 +9527,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (84 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9545,13 +9545,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (85 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9563,13 +9563,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (86 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9581,13 +9581,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (87 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9599,13 +9599,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (88 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9617,13 +9617,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (89 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9635,13 +9635,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (90 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9653,13 +9653,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (91 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9671,13 +9671,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (92 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9689,13 +9689,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (93 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9707,13 +9707,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (94 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9725,13 +9725,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (95 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9743,13 +9743,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (96 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9761,13 +9761,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (97 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9779,13 +9779,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (98 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9797,13 +9797,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (99 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9815,13 +9815,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (100 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9833,13 +9833,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (101 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9851,13 +9851,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (102 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9869,13 +9869,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (103 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9887,13 +9887,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (104 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9905,13 +9905,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (105 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9923,13 +9923,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (106 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9941,13 +9941,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (107 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9959,13 +9959,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (108 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9977,13 +9977,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (109 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -9995,13 +9995,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (110 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10013,13 +10013,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (111 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10031,13 +10031,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (112 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10049,13 +10049,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (113 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10067,13 +10067,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (114 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10085,13 +10085,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (115 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10103,13 +10103,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (116 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10121,13 +10121,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (117 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10139,13 +10139,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (118 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10157,13 +10157,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (119 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10175,13 +10175,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (120 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10193,13 +10193,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (121 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10211,13 +10211,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (122 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10229,13 +10229,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (123 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10247,13 +10247,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (124 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10265,13 +10265,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (125 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10283,13 +10283,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (126 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10301,13 +10301,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (127 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10319,13 +10319,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (128 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10337,13 +10337,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (129 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10355,13 +10355,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (130 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10373,13 +10373,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (131 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10391,13 +10391,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (132 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10409,13 +10409,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (133 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10427,13 +10427,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (134 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10445,13 +10445,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (135 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10463,13 +10463,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (136 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10481,13 +10481,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (137 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10499,13 +10499,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (138 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10517,13 +10517,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (139 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10535,13 +10535,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (140 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10553,13 +10553,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (141 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10571,13 +10571,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (142 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10589,13 +10589,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (143 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10607,13 +10607,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (144 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10625,13 +10625,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (145 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10643,13 +10643,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (146 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10661,13 +10661,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (147 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10679,13 +10679,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (148 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10697,13 +10697,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (149 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10715,13 +10715,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (150 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10733,13 +10733,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (151 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10751,13 +10751,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (152 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10769,13 +10769,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (153 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10787,13 +10787,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (154 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10805,13 +10805,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (155 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10823,13 +10823,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (156 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10841,13 +10841,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (157 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10859,13 +10859,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (158 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10877,13 +10877,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (159 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10895,13 +10895,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (160 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10913,13 +10913,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (161 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10931,13 +10931,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (162 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10949,13 +10949,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (163 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10967,13 +10967,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (164 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -10985,13 +10985,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (165 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11003,13 +11003,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (166 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11021,13 +11021,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (167 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11039,13 +11039,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (168 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11057,13 +11057,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (169 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11075,13 +11075,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (170 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11093,13 +11093,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (171 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11111,13 +11111,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (172 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11129,13 +11129,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (173 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11147,13 +11147,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (174 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11165,13 +11165,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (175 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11183,13 +11183,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (176 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11201,13 +11201,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (177 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11219,13 +11219,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (178 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11237,13 +11237,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (179 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11255,13 +11255,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (180 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11273,13 +11273,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (181 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11291,13 +11291,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (182 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11309,13 +11309,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (183 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11327,13 +11327,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (184 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11345,13 +11345,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (185 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11363,13 +11363,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (186 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11381,13 +11381,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (187 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11399,13 +11399,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (188 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11417,13 +11417,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (189 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11435,13 +11435,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (190 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11453,13 +11453,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (191 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11471,13 +11471,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (192 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11489,13 +11489,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (193 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11507,13 +11507,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (194 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11525,13 +11525,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (195 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11543,13 +11543,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (196 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11561,13 +11561,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (197 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11579,13 +11579,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (198 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11597,13 +11597,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (199 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11615,13 +11615,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (200 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11633,13 +11633,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (201 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11651,13 +11651,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (202 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11669,13 +11669,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (203 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11687,13 +11687,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (204 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11705,13 +11705,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (205 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11723,13 +11723,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (206 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11741,13 +11741,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (207 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11759,13 +11759,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (208 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11777,13 +11777,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (209 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11795,13 +11795,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (210 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11813,13 +11813,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (211 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11831,13 +11831,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (212 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11849,13 +11849,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (213 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11867,13 +11867,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (214 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11885,13 +11885,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (215 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11903,13 +11903,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (216 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11921,13 +11921,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (217 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11939,13 +11939,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (218 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11957,13 +11957,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (219 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11975,13 +11975,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (220 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -11993,13 +11993,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (221 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -12011,13 +12011,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (222 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -12029,13 +12029,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (223 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -12047,13 +12047,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (224 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -12065,13 +12065,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (225 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -12083,13 +12083,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (226 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -12101,13 +12101,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (227 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -12119,13 +12119,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (228 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -12137,13 +12137,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (229 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -12155,13 +12155,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (230 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -12173,13 +12173,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (231 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -12191,13 +12191,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (232 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -12209,13 +12209,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (233 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -12227,13 +12227,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (234 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -12245,13 +12245,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (235 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -12263,13 +12263,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (236 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -12281,13 +12281,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (237 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -12299,13 +12299,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (238 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -12317,13 +12317,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (239 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -12335,13 +12335,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (240 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -12353,13 +12353,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (241 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -12371,13 +12371,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (242 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -12389,13 +12389,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (243 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -12407,13 +12407,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (244 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -12425,13 +12425,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (245 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -12443,13 +12443,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (246 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -12461,13 +12461,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (247 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -12479,13 +12479,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (248 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -12497,13 +12497,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (249 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -12515,13 +12515,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (250 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -12533,13 +12533,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (251 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -12551,13 +12551,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (252 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -12569,13 +12569,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (253 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -12587,13 +12587,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (254 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
/* ------------------------------ */
.balign 128
@@ -12605,13 +12605,13 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC()
la ra, artMterpAsmInstructionStart + (255 * 128) # Addr of primary handler
lw rIBASE, THREAD_CURRENT_IBASE_OFFSET(rSELF) # refresh IBASE
move a0, rSELF # arg0
addu a1, rFP, OFF_FP_SHADOWFRAME # arg1
- la a2, MterpCheckBefore
- jalr zero, a2 # Tail call to Mterp(self, shadow_frame)
+ move a2, rPC
+ la t9, MterpCheckBefore
+ jalr zero, t9 # Tail call to Mterp(self, shadow_frame, dex_pc_ptr)
.balign 128
.size artMterpAsmAltInstructionStart, .-artMterpAsmAltInstructionStart
diff --git a/runtime/interpreter/mterp/out/mterp_mips64.S b/runtime/interpreter/mterp/out/mterp_mips64.S
index 29a12bf..35fbe94 100644
--- a/runtime/interpreter/mterp/out/mterp_mips64.S
+++ b/runtime/interpreter/mterp/out/mterp_mips64.S
@@ -7190,14 +7190,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (0 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7209,14 +7209,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (1 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7228,14 +7228,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (2 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7247,14 +7247,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (3 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7266,14 +7266,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (4 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7285,14 +7285,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (5 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7304,14 +7304,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (6 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7323,14 +7323,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (7 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7342,14 +7342,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (8 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7361,14 +7361,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (9 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7380,14 +7380,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (10 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7399,14 +7399,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (11 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7418,14 +7418,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (12 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7437,14 +7437,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (13 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7456,14 +7456,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (14 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7475,14 +7475,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (15 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7494,14 +7494,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (16 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7513,14 +7513,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (17 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7532,14 +7532,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (18 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7551,14 +7551,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (19 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7570,14 +7570,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (20 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7589,14 +7589,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (21 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7608,14 +7608,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (22 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7627,14 +7627,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (23 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7646,14 +7646,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (24 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7665,14 +7665,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (25 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7684,14 +7684,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (26 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7703,14 +7703,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (27 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7722,14 +7722,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (28 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7741,14 +7741,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (29 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7760,14 +7760,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (30 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7779,14 +7779,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (31 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7798,14 +7798,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (32 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7817,14 +7817,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (33 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7836,14 +7836,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (34 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7855,14 +7855,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (35 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7874,14 +7874,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (36 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7893,14 +7893,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (37 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7912,14 +7912,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (38 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7931,14 +7931,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (39 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7950,14 +7950,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (40 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7969,14 +7969,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (41 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -7988,14 +7988,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (42 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8007,14 +8007,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (43 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8026,14 +8026,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (44 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8045,14 +8045,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (45 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8064,14 +8064,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (46 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8083,14 +8083,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (47 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8102,14 +8102,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (48 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8121,14 +8121,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (49 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8140,14 +8140,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (50 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8159,14 +8159,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (51 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8178,14 +8178,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (52 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8197,14 +8197,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (53 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8216,14 +8216,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (54 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8235,14 +8235,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (55 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8254,14 +8254,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (56 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8273,14 +8273,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (57 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8292,14 +8292,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (58 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8311,14 +8311,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (59 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8330,14 +8330,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (60 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8349,14 +8349,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (61 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8368,14 +8368,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (62 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8387,14 +8387,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (63 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8406,14 +8406,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (64 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8425,14 +8425,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (65 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8444,14 +8444,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (66 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8463,14 +8463,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (67 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8482,14 +8482,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (68 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8501,14 +8501,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (69 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8520,14 +8520,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (70 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8539,14 +8539,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (71 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8558,14 +8558,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (72 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8577,14 +8577,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (73 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8596,14 +8596,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (74 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8615,14 +8615,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (75 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8634,14 +8634,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (76 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8653,14 +8653,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (77 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8672,14 +8672,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (78 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8691,14 +8691,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (79 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8710,14 +8710,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (80 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8729,14 +8729,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (81 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8748,14 +8748,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (82 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8767,14 +8767,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (83 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8786,14 +8786,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (84 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8805,14 +8805,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (85 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8824,14 +8824,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (86 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8843,14 +8843,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (87 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8862,14 +8862,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (88 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8881,14 +8881,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (89 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8900,14 +8900,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (90 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8919,14 +8919,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (91 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8938,14 +8938,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (92 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8957,14 +8957,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (93 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8976,14 +8976,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (94 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -8995,14 +8995,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (95 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9014,14 +9014,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (96 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9033,14 +9033,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (97 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9052,14 +9052,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (98 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9071,14 +9071,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (99 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9090,14 +9090,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (100 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9109,14 +9109,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (101 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9128,14 +9128,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (102 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9147,14 +9147,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (103 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9166,14 +9166,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (104 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9185,14 +9185,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (105 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9204,14 +9204,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (106 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9223,14 +9223,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (107 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9242,14 +9242,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (108 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9261,14 +9261,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (109 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9280,14 +9280,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (110 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9299,14 +9299,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (111 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9318,14 +9318,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (112 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9337,14 +9337,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (113 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9356,14 +9356,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (114 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9375,14 +9375,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (115 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9394,14 +9394,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (116 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9413,14 +9413,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (117 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9432,14 +9432,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (118 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9451,14 +9451,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (119 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9470,14 +9470,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (120 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9489,14 +9489,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (121 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9508,14 +9508,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (122 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9527,14 +9527,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (123 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9546,14 +9546,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (124 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9565,14 +9565,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (125 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9584,14 +9584,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (126 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9603,14 +9603,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (127 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9622,14 +9622,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (128 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9641,14 +9641,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (129 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9660,14 +9660,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (130 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9679,14 +9679,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (131 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9698,14 +9698,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (132 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9717,14 +9717,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (133 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9736,14 +9736,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (134 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9755,14 +9755,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (135 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9774,14 +9774,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (136 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9793,14 +9793,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (137 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9812,14 +9812,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (138 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9831,14 +9831,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (139 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9850,14 +9850,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (140 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9869,14 +9869,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (141 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9888,14 +9888,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (142 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9907,14 +9907,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (143 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9926,14 +9926,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (144 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9945,14 +9945,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (145 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9964,14 +9964,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (146 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -9983,14 +9983,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (147 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10002,14 +10002,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (148 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10021,14 +10021,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (149 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10040,14 +10040,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (150 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10059,14 +10059,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (151 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10078,14 +10078,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (152 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10097,14 +10097,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (153 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10116,14 +10116,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (154 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10135,14 +10135,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (155 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10154,14 +10154,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (156 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10173,14 +10173,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (157 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10192,14 +10192,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (158 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10211,14 +10211,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (159 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10230,14 +10230,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (160 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10249,14 +10249,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (161 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10268,14 +10268,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (162 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10287,14 +10287,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (163 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10306,14 +10306,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (164 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10325,14 +10325,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (165 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10344,14 +10344,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (166 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10363,14 +10363,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (167 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10382,14 +10382,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (168 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10401,14 +10401,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (169 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10420,14 +10420,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (170 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10439,14 +10439,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (171 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10458,14 +10458,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (172 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10477,14 +10477,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (173 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10496,14 +10496,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (174 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10515,14 +10515,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (175 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10534,14 +10534,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (176 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10553,14 +10553,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (177 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10572,14 +10572,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (178 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10591,14 +10591,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (179 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10610,14 +10610,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (180 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10629,14 +10629,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (181 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10648,14 +10648,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (182 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10667,14 +10667,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (183 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10686,14 +10686,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (184 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10705,14 +10705,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (185 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10724,14 +10724,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (186 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10743,14 +10743,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (187 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10762,14 +10762,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (188 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10781,14 +10781,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (189 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10800,14 +10800,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (190 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10819,14 +10819,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (191 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10838,14 +10838,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (192 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10857,14 +10857,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (193 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10876,14 +10876,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (194 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10895,14 +10895,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (195 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10914,14 +10914,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (196 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10933,14 +10933,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (197 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10952,14 +10952,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (198 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10971,14 +10971,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (199 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -10990,14 +10990,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (200 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11009,14 +11009,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (201 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11028,14 +11028,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (202 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11047,14 +11047,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (203 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11066,14 +11066,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (204 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11085,14 +11085,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (205 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11104,14 +11104,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (206 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11123,14 +11123,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (207 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11142,14 +11142,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (208 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11161,14 +11161,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (209 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11180,14 +11180,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (210 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11199,14 +11199,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (211 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11218,14 +11218,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (212 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11237,14 +11237,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (213 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11256,14 +11256,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (214 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11275,14 +11275,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (215 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11294,14 +11294,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (216 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11313,14 +11313,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (217 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11332,14 +11332,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (218 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11351,14 +11351,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (219 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11370,14 +11370,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (220 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11389,14 +11389,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (221 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11408,14 +11408,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (222 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11427,14 +11427,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (223 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11446,14 +11446,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (224 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11465,14 +11465,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (225 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11484,14 +11484,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (226 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11503,14 +11503,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (227 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11522,14 +11522,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (228 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11541,14 +11541,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (229 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11560,14 +11560,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (230 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11579,14 +11579,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (231 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11598,14 +11598,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (232 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11617,14 +11617,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (233 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11636,14 +11636,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (234 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11655,14 +11655,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (235 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11674,14 +11674,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (236 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11693,14 +11693,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (237 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11712,14 +11712,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (238 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11731,14 +11731,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (239 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11750,14 +11750,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (240 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11769,14 +11769,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (241 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11788,14 +11788,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (242 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11807,14 +11807,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (243 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11826,14 +11826,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (244 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11845,14 +11845,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (245 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11864,14 +11864,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (246 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11883,14 +11883,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (247 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11902,14 +11902,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (248 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11921,14 +11921,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (249 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11940,14 +11940,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (250 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11959,14 +11959,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (251 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11978,14 +11978,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (252 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -11997,14 +11997,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (253 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -12016,14 +12016,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (254 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
/* ------------------------------ */
.balign 128
@@ -12035,14 +12035,14 @@
* handler. Note that the call to MterpCheckBefore is done as a tail call.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
dla ra, artMterpAsmInstructionStart
dla t9, MterpCheckBefore
move a0, rSELF
daddu a1, rFP, OFF_FP_SHADOWFRAME
+ move a2, rPC
daddu ra, ra, (255 * 128) # Addr of primary handler.
- jalr zero, t9 # (self, shadow_frame) Note: tail call.
+ jalr zero, t9 # (self, shadow_frame, dex_pc_ptr) Note: tail call.
.balign 128
.size artMterpAsmAltInstructionStart, .-artMterpAsmAltInstructionStart
diff --git a/runtime/interpreter/mterp/out/mterp_x86.S b/runtime/interpreter/mterp/out/mterp_x86.S
index f78e1bc..5caaa80 100644
--- a/runtime/interpreter/mterp/out/mterp_x86.S
+++ b/runtime/interpreter/mterp/out/mterp_x86.S
@@ -6359,13 +6359,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(0*128)
@@ -6384,13 +6383,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(1*128)
@@ -6409,13 +6407,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(2*128)
@@ -6434,13 +6431,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(3*128)
@@ -6459,13 +6455,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(4*128)
@@ -6484,13 +6479,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(5*128)
@@ -6509,13 +6503,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(6*128)
@@ -6534,13 +6527,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(7*128)
@@ -6559,13 +6551,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(8*128)
@@ -6584,13 +6575,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(9*128)
@@ -6609,13 +6599,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(10*128)
@@ -6634,13 +6623,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(11*128)
@@ -6659,13 +6647,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(12*128)
@@ -6684,13 +6671,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(13*128)
@@ -6709,13 +6695,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(14*128)
@@ -6734,13 +6719,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(15*128)
@@ -6759,13 +6743,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(16*128)
@@ -6784,13 +6767,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(17*128)
@@ -6809,13 +6791,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(18*128)
@@ -6834,13 +6815,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(19*128)
@@ -6859,13 +6839,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(20*128)
@@ -6884,13 +6863,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(21*128)
@@ -6909,13 +6887,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(22*128)
@@ -6934,13 +6911,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(23*128)
@@ -6959,13 +6935,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(24*128)
@@ -6984,13 +6959,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(25*128)
@@ -7009,13 +6983,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(26*128)
@@ -7034,13 +7007,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(27*128)
@@ -7059,13 +7031,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(28*128)
@@ -7084,13 +7055,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(29*128)
@@ -7109,13 +7079,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(30*128)
@@ -7134,13 +7103,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(31*128)
@@ -7159,13 +7127,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(32*128)
@@ -7184,13 +7151,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(33*128)
@@ -7209,13 +7175,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(34*128)
@@ -7234,13 +7199,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(35*128)
@@ -7259,13 +7223,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(36*128)
@@ -7284,13 +7247,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(37*128)
@@ -7309,13 +7271,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(38*128)
@@ -7334,13 +7295,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(39*128)
@@ -7359,13 +7319,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(40*128)
@@ -7384,13 +7343,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(41*128)
@@ -7409,13 +7367,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(42*128)
@@ -7434,13 +7391,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(43*128)
@@ -7459,13 +7415,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(44*128)
@@ -7484,13 +7439,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(45*128)
@@ -7509,13 +7463,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(46*128)
@@ -7534,13 +7487,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(47*128)
@@ -7559,13 +7511,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(48*128)
@@ -7584,13 +7535,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(49*128)
@@ -7609,13 +7559,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(50*128)
@@ -7634,13 +7583,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(51*128)
@@ -7659,13 +7607,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(52*128)
@@ -7684,13 +7631,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(53*128)
@@ -7709,13 +7655,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(54*128)
@@ -7734,13 +7679,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(55*128)
@@ -7759,13 +7703,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(56*128)
@@ -7784,13 +7727,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(57*128)
@@ -7809,13 +7751,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(58*128)
@@ -7834,13 +7775,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(59*128)
@@ -7859,13 +7799,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(60*128)
@@ -7884,13 +7823,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(61*128)
@@ -7909,13 +7847,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(62*128)
@@ -7934,13 +7871,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(63*128)
@@ -7959,13 +7895,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(64*128)
@@ -7984,13 +7919,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(65*128)
@@ -8009,13 +7943,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(66*128)
@@ -8034,13 +7967,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(67*128)
@@ -8059,13 +7991,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(68*128)
@@ -8084,13 +8015,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(69*128)
@@ -8109,13 +8039,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(70*128)
@@ -8134,13 +8063,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(71*128)
@@ -8159,13 +8087,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(72*128)
@@ -8184,13 +8111,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(73*128)
@@ -8209,13 +8135,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(74*128)
@@ -8234,13 +8159,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(75*128)
@@ -8259,13 +8183,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(76*128)
@@ -8284,13 +8207,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(77*128)
@@ -8309,13 +8231,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(78*128)
@@ -8334,13 +8255,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(79*128)
@@ -8359,13 +8279,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(80*128)
@@ -8384,13 +8303,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(81*128)
@@ -8409,13 +8327,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(82*128)
@@ -8434,13 +8351,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(83*128)
@@ -8459,13 +8375,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(84*128)
@@ -8484,13 +8399,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(85*128)
@@ -8509,13 +8423,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(86*128)
@@ -8534,13 +8447,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(87*128)
@@ -8559,13 +8471,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(88*128)
@@ -8584,13 +8495,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(89*128)
@@ -8609,13 +8519,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(90*128)
@@ -8634,13 +8543,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(91*128)
@@ -8659,13 +8567,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(92*128)
@@ -8684,13 +8591,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(93*128)
@@ -8709,13 +8615,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(94*128)
@@ -8734,13 +8639,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(95*128)
@@ -8759,13 +8663,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(96*128)
@@ -8784,13 +8687,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(97*128)
@@ -8809,13 +8711,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(98*128)
@@ -8834,13 +8735,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(99*128)
@@ -8859,13 +8759,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(100*128)
@@ -8884,13 +8783,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(101*128)
@@ -8909,13 +8807,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(102*128)
@@ -8934,13 +8831,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(103*128)
@@ -8959,13 +8855,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(104*128)
@@ -8984,13 +8879,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(105*128)
@@ -9009,13 +8903,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(106*128)
@@ -9034,13 +8927,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(107*128)
@@ -9059,13 +8951,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(108*128)
@@ -9084,13 +8975,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(109*128)
@@ -9109,13 +8999,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(110*128)
@@ -9134,13 +9023,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(111*128)
@@ -9159,13 +9047,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(112*128)
@@ -9184,13 +9071,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(113*128)
@@ -9209,13 +9095,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(114*128)
@@ -9234,13 +9119,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(115*128)
@@ -9259,13 +9143,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(116*128)
@@ -9284,13 +9167,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(117*128)
@@ -9309,13 +9191,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(118*128)
@@ -9334,13 +9215,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(119*128)
@@ -9359,13 +9239,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(120*128)
@@ -9384,13 +9263,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(121*128)
@@ -9409,13 +9287,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(122*128)
@@ -9434,13 +9311,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(123*128)
@@ -9459,13 +9335,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(124*128)
@@ -9484,13 +9359,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(125*128)
@@ -9509,13 +9383,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(126*128)
@@ -9534,13 +9407,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(127*128)
@@ -9559,13 +9431,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(128*128)
@@ -9584,13 +9455,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(129*128)
@@ -9609,13 +9479,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(130*128)
@@ -9634,13 +9503,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(131*128)
@@ -9659,13 +9527,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(132*128)
@@ -9684,13 +9551,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(133*128)
@@ -9709,13 +9575,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(134*128)
@@ -9734,13 +9599,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(135*128)
@@ -9759,13 +9623,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(136*128)
@@ -9784,13 +9647,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(137*128)
@@ -9809,13 +9671,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(138*128)
@@ -9834,13 +9695,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(139*128)
@@ -9859,13 +9719,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(140*128)
@@ -9884,13 +9743,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(141*128)
@@ -9909,13 +9767,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(142*128)
@@ -9934,13 +9791,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(143*128)
@@ -9959,13 +9815,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(144*128)
@@ -9984,13 +9839,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(145*128)
@@ -10009,13 +9863,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(146*128)
@@ -10034,13 +9887,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(147*128)
@@ -10059,13 +9911,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(148*128)
@@ -10084,13 +9935,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(149*128)
@@ -10109,13 +9959,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(150*128)
@@ -10134,13 +9983,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(151*128)
@@ -10159,13 +10007,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(152*128)
@@ -10184,13 +10031,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(153*128)
@@ -10209,13 +10055,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(154*128)
@@ -10234,13 +10079,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(155*128)
@@ -10259,13 +10103,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(156*128)
@@ -10284,13 +10127,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(157*128)
@@ -10309,13 +10151,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(158*128)
@@ -10334,13 +10175,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(159*128)
@@ -10359,13 +10199,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(160*128)
@@ -10384,13 +10223,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(161*128)
@@ -10409,13 +10247,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(162*128)
@@ -10434,13 +10271,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(163*128)
@@ -10459,13 +10295,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(164*128)
@@ -10484,13 +10319,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(165*128)
@@ -10509,13 +10343,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(166*128)
@@ -10534,13 +10367,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(167*128)
@@ -10559,13 +10391,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(168*128)
@@ -10584,13 +10415,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(169*128)
@@ -10609,13 +10439,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(170*128)
@@ -10634,13 +10463,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(171*128)
@@ -10659,13 +10487,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(172*128)
@@ -10684,13 +10511,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(173*128)
@@ -10709,13 +10535,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(174*128)
@@ -10734,13 +10559,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(175*128)
@@ -10759,13 +10583,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(176*128)
@@ -10784,13 +10607,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(177*128)
@@ -10809,13 +10631,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(178*128)
@@ -10834,13 +10655,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(179*128)
@@ -10859,13 +10679,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(180*128)
@@ -10884,13 +10703,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(181*128)
@@ -10909,13 +10727,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(182*128)
@@ -10934,13 +10751,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(183*128)
@@ -10959,13 +10775,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(184*128)
@@ -10984,13 +10799,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(185*128)
@@ -11009,13 +10823,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(186*128)
@@ -11034,13 +10847,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(187*128)
@@ -11059,13 +10871,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(188*128)
@@ -11084,13 +10895,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(189*128)
@@ -11109,13 +10919,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(190*128)
@@ -11134,13 +10943,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(191*128)
@@ -11159,13 +10967,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(192*128)
@@ -11184,13 +10991,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(193*128)
@@ -11209,13 +11015,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(194*128)
@@ -11234,13 +11039,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(195*128)
@@ -11259,13 +11063,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(196*128)
@@ -11284,13 +11087,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(197*128)
@@ -11309,13 +11111,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(198*128)
@@ -11334,13 +11135,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(199*128)
@@ -11359,13 +11159,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(200*128)
@@ -11384,13 +11183,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(201*128)
@@ -11409,13 +11207,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(202*128)
@@ -11434,13 +11231,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(203*128)
@@ -11459,13 +11255,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(204*128)
@@ -11484,13 +11279,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(205*128)
@@ -11509,13 +11303,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(206*128)
@@ -11534,13 +11327,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(207*128)
@@ -11559,13 +11351,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(208*128)
@@ -11584,13 +11375,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(209*128)
@@ -11609,13 +11399,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(210*128)
@@ -11634,13 +11423,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(211*128)
@@ -11659,13 +11447,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(212*128)
@@ -11684,13 +11471,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(213*128)
@@ -11709,13 +11495,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(214*128)
@@ -11734,13 +11519,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(215*128)
@@ -11759,13 +11543,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(216*128)
@@ -11784,13 +11567,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(217*128)
@@ -11809,13 +11591,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(218*128)
@@ -11834,13 +11615,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(219*128)
@@ -11859,13 +11639,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(220*128)
@@ -11884,13 +11663,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(221*128)
@@ -11909,13 +11687,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(222*128)
@@ -11934,13 +11711,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(223*128)
@@ -11959,13 +11735,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(224*128)
@@ -11984,13 +11759,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(225*128)
@@ -12009,13 +11783,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(226*128)
@@ -12034,13 +11807,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(227*128)
@@ -12059,13 +11831,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(228*128)
@@ -12084,13 +11855,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(229*128)
@@ -12109,13 +11879,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(230*128)
@@ -12134,13 +11903,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(231*128)
@@ -12159,13 +11927,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(232*128)
@@ -12184,13 +11951,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(233*128)
@@ -12209,13 +11975,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(234*128)
@@ -12234,13 +11999,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(235*128)
@@ -12259,13 +12023,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(236*128)
@@ -12284,13 +12047,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(237*128)
@@ -12309,13 +12071,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(238*128)
@@ -12334,13 +12095,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(239*128)
@@ -12359,13 +12119,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(240*128)
@@ -12384,13 +12143,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(241*128)
@@ -12409,13 +12167,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(242*128)
@@ -12434,13 +12191,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(243*128)
@@ -12459,13 +12215,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(244*128)
@@ -12484,13 +12239,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(245*128)
@@ -12509,13 +12263,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(246*128)
@@ -12534,13 +12287,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(247*128)
@@ -12559,13 +12311,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(248*128)
@@ -12584,13 +12335,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(249*128)
@@ -12609,13 +12359,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(250*128)
@@ -12634,13 +12383,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(251*128)
@@ -12659,13 +12407,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(252*128)
@@ -12684,13 +12431,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(253*128)
@@ -12709,13 +12455,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(254*128)
@@ -12734,13 +12479,12 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(255*128)
diff --git a/runtime/interpreter/mterp/out/mterp_x86_64.S b/runtime/interpreter/mterp/out/mterp_x86_64.S
index 031cec8..9e2dcea 100644
--- a/runtime/interpreter/mterp/out/mterp_x86_64.S
+++ b/runtime/interpreter/mterp/out/mterp_x86_64.S
@@ -6124,11 +6124,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(0*128)
/* ------------------------------ */
@@ -6146,11 +6146,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(1*128)
/* ------------------------------ */
@@ -6168,11 +6168,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(2*128)
/* ------------------------------ */
@@ -6190,11 +6190,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(3*128)
/* ------------------------------ */
@@ -6212,11 +6212,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(4*128)
/* ------------------------------ */
@@ -6234,11 +6234,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(5*128)
/* ------------------------------ */
@@ -6256,11 +6256,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(6*128)
/* ------------------------------ */
@@ -6278,11 +6278,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(7*128)
/* ------------------------------ */
@@ -6300,11 +6300,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(8*128)
/* ------------------------------ */
@@ -6322,11 +6322,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(9*128)
/* ------------------------------ */
@@ -6344,11 +6344,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(10*128)
/* ------------------------------ */
@@ -6366,11 +6366,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(11*128)
/* ------------------------------ */
@@ -6388,11 +6388,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(12*128)
/* ------------------------------ */
@@ -6410,11 +6410,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(13*128)
/* ------------------------------ */
@@ -6432,11 +6432,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(14*128)
/* ------------------------------ */
@@ -6454,11 +6454,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(15*128)
/* ------------------------------ */
@@ -6476,11 +6476,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(16*128)
/* ------------------------------ */
@@ -6498,11 +6498,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(17*128)
/* ------------------------------ */
@@ -6520,11 +6520,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(18*128)
/* ------------------------------ */
@@ -6542,11 +6542,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(19*128)
/* ------------------------------ */
@@ -6564,11 +6564,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(20*128)
/* ------------------------------ */
@@ -6586,11 +6586,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(21*128)
/* ------------------------------ */
@@ -6608,11 +6608,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(22*128)
/* ------------------------------ */
@@ -6630,11 +6630,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(23*128)
/* ------------------------------ */
@@ -6652,11 +6652,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(24*128)
/* ------------------------------ */
@@ -6674,11 +6674,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(25*128)
/* ------------------------------ */
@@ -6696,11 +6696,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(26*128)
/* ------------------------------ */
@@ -6718,11 +6718,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(27*128)
/* ------------------------------ */
@@ -6740,11 +6740,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(28*128)
/* ------------------------------ */
@@ -6762,11 +6762,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(29*128)
/* ------------------------------ */
@@ -6784,11 +6784,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(30*128)
/* ------------------------------ */
@@ -6806,11 +6806,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(31*128)
/* ------------------------------ */
@@ -6828,11 +6828,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(32*128)
/* ------------------------------ */
@@ -6850,11 +6850,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(33*128)
/* ------------------------------ */
@@ -6872,11 +6872,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(34*128)
/* ------------------------------ */
@@ -6894,11 +6894,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(35*128)
/* ------------------------------ */
@@ -6916,11 +6916,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(36*128)
/* ------------------------------ */
@@ -6938,11 +6938,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(37*128)
/* ------------------------------ */
@@ -6960,11 +6960,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(38*128)
/* ------------------------------ */
@@ -6982,11 +6982,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(39*128)
/* ------------------------------ */
@@ -7004,11 +7004,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(40*128)
/* ------------------------------ */
@@ -7026,11 +7026,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(41*128)
/* ------------------------------ */
@@ -7048,11 +7048,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(42*128)
/* ------------------------------ */
@@ -7070,11 +7070,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(43*128)
/* ------------------------------ */
@@ -7092,11 +7092,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(44*128)
/* ------------------------------ */
@@ -7114,11 +7114,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(45*128)
/* ------------------------------ */
@@ -7136,11 +7136,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(46*128)
/* ------------------------------ */
@@ -7158,11 +7158,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(47*128)
/* ------------------------------ */
@@ -7180,11 +7180,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(48*128)
/* ------------------------------ */
@@ -7202,11 +7202,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(49*128)
/* ------------------------------ */
@@ -7224,11 +7224,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(50*128)
/* ------------------------------ */
@@ -7246,11 +7246,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(51*128)
/* ------------------------------ */
@@ -7268,11 +7268,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(52*128)
/* ------------------------------ */
@@ -7290,11 +7290,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(53*128)
/* ------------------------------ */
@@ -7312,11 +7312,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(54*128)
/* ------------------------------ */
@@ -7334,11 +7334,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(55*128)
/* ------------------------------ */
@@ -7356,11 +7356,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(56*128)
/* ------------------------------ */
@@ -7378,11 +7378,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(57*128)
/* ------------------------------ */
@@ -7400,11 +7400,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(58*128)
/* ------------------------------ */
@@ -7422,11 +7422,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(59*128)
/* ------------------------------ */
@@ -7444,11 +7444,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(60*128)
/* ------------------------------ */
@@ -7466,11 +7466,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(61*128)
/* ------------------------------ */
@@ -7488,11 +7488,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(62*128)
/* ------------------------------ */
@@ -7510,11 +7510,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(63*128)
/* ------------------------------ */
@@ -7532,11 +7532,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(64*128)
/* ------------------------------ */
@@ -7554,11 +7554,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(65*128)
/* ------------------------------ */
@@ -7576,11 +7576,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(66*128)
/* ------------------------------ */
@@ -7598,11 +7598,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(67*128)
/* ------------------------------ */
@@ -7620,11 +7620,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(68*128)
/* ------------------------------ */
@@ -7642,11 +7642,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(69*128)
/* ------------------------------ */
@@ -7664,11 +7664,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(70*128)
/* ------------------------------ */
@@ -7686,11 +7686,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(71*128)
/* ------------------------------ */
@@ -7708,11 +7708,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(72*128)
/* ------------------------------ */
@@ -7730,11 +7730,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(73*128)
/* ------------------------------ */
@@ -7752,11 +7752,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(74*128)
/* ------------------------------ */
@@ -7774,11 +7774,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(75*128)
/* ------------------------------ */
@@ -7796,11 +7796,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(76*128)
/* ------------------------------ */
@@ -7818,11 +7818,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(77*128)
/* ------------------------------ */
@@ -7840,11 +7840,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(78*128)
/* ------------------------------ */
@@ -7862,11 +7862,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(79*128)
/* ------------------------------ */
@@ -7884,11 +7884,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(80*128)
/* ------------------------------ */
@@ -7906,11 +7906,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(81*128)
/* ------------------------------ */
@@ -7928,11 +7928,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(82*128)
/* ------------------------------ */
@@ -7950,11 +7950,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(83*128)
/* ------------------------------ */
@@ -7972,11 +7972,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(84*128)
/* ------------------------------ */
@@ -7994,11 +7994,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(85*128)
/* ------------------------------ */
@@ -8016,11 +8016,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(86*128)
/* ------------------------------ */
@@ -8038,11 +8038,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(87*128)
/* ------------------------------ */
@@ -8060,11 +8060,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(88*128)
/* ------------------------------ */
@@ -8082,11 +8082,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(89*128)
/* ------------------------------ */
@@ -8104,11 +8104,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(90*128)
/* ------------------------------ */
@@ -8126,11 +8126,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(91*128)
/* ------------------------------ */
@@ -8148,11 +8148,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(92*128)
/* ------------------------------ */
@@ -8170,11 +8170,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(93*128)
/* ------------------------------ */
@@ -8192,11 +8192,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(94*128)
/* ------------------------------ */
@@ -8214,11 +8214,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(95*128)
/* ------------------------------ */
@@ -8236,11 +8236,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(96*128)
/* ------------------------------ */
@@ -8258,11 +8258,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(97*128)
/* ------------------------------ */
@@ -8280,11 +8280,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(98*128)
/* ------------------------------ */
@@ -8302,11 +8302,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(99*128)
/* ------------------------------ */
@@ -8324,11 +8324,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(100*128)
/* ------------------------------ */
@@ -8346,11 +8346,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(101*128)
/* ------------------------------ */
@@ -8368,11 +8368,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(102*128)
/* ------------------------------ */
@@ -8390,11 +8390,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(103*128)
/* ------------------------------ */
@@ -8412,11 +8412,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(104*128)
/* ------------------------------ */
@@ -8434,11 +8434,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(105*128)
/* ------------------------------ */
@@ -8456,11 +8456,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(106*128)
/* ------------------------------ */
@@ -8478,11 +8478,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(107*128)
/* ------------------------------ */
@@ -8500,11 +8500,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(108*128)
/* ------------------------------ */
@@ -8522,11 +8522,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(109*128)
/* ------------------------------ */
@@ -8544,11 +8544,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(110*128)
/* ------------------------------ */
@@ -8566,11 +8566,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(111*128)
/* ------------------------------ */
@@ -8588,11 +8588,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(112*128)
/* ------------------------------ */
@@ -8610,11 +8610,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(113*128)
/* ------------------------------ */
@@ -8632,11 +8632,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(114*128)
/* ------------------------------ */
@@ -8654,11 +8654,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(115*128)
/* ------------------------------ */
@@ -8676,11 +8676,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(116*128)
/* ------------------------------ */
@@ -8698,11 +8698,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(117*128)
/* ------------------------------ */
@@ -8720,11 +8720,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(118*128)
/* ------------------------------ */
@@ -8742,11 +8742,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(119*128)
/* ------------------------------ */
@@ -8764,11 +8764,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(120*128)
/* ------------------------------ */
@@ -8786,11 +8786,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(121*128)
/* ------------------------------ */
@@ -8808,11 +8808,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(122*128)
/* ------------------------------ */
@@ -8830,11 +8830,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(123*128)
/* ------------------------------ */
@@ -8852,11 +8852,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(124*128)
/* ------------------------------ */
@@ -8874,11 +8874,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(125*128)
/* ------------------------------ */
@@ -8896,11 +8896,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(126*128)
/* ------------------------------ */
@@ -8918,11 +8918,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(127*128)
/* ------------------------------ */
@@ -8940,11 +8940,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(128*128)
/* ------------------------------ */
@@ -8962,11 +8962,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(129*128)
/* ------------------------------ */
@@ -8984,11 +8984,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(130*128)
/* ------------------------------ */
@@ -9006,11 +9006,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(131*128)
/* ------------------------------ */
@@ -9028,11 +9028,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(132*128)
/* ------------------------------ */
@@ -9050,11 +9050,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(133*128)
/* ------------------------------ */
@@ -9072,11 +9072,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(134*128)
/* ------------------------------ */
@@ -9094,11 +9094,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(135*128)
/* ------------------------------ */
@@ -9116,11 +9116,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(136*128)
/* ------------------------------ */
@@ -9138,11 +9138,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(137*128)
/* ------------------------------ */
@@ -9160,11 +9160,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(138*128)
/* ------------------------------ */
@@ -9182,11 +9182,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(139*128)
/* ------------------------------ */
@@ -9204,11 +9204,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(140*128)
/* ------------------------------ */
@@ -9226,11 +9226,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(141*128)
/* ------------------------------ */
@@ -9248,11 +9248,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(142*128)
/* ------------------------------ */
@@ -9270,11 +9270,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(143*128)
/* ------------------------------ */
@@ -9292,11 +9292,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(144*128)
/* ------------------------------ */
@@ -9314,11 +9314,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(145*128)
/* ------------------------------ */
@@ -9336,11 +9336,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(146*128)
/* ------------------------------ */
@@ -9358,11 +9358,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(147*128)
/* ------------------------------ */
@@ -9380,11 +9380,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(148*128)
/* ------------------------------ */
@@ -9402,11 +9402,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(149*128)
/* ------------------------------ */
@@ -9424,11 +9424,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(150*128)
/* ------------------------------ */
@@ -9446,11 +9446,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(151*128)
/* ------------------------------ */
@@ -9468,11 +9468,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(152*128)
/* ------------------------------ */
@@ -9490,11 +9490,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(153*128)
/* ------------------------------ */
@@ -9512,11 +9512,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(154*128)
/* ------------------------------ */
@@ -9534,11 +9534,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(155*128)
/* ------------------------------ */
@@ -9556,11 +9556,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(156*128)
/* ------------------------------ */
@@ -9578,11 +9578,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(157*128)
/* ------------------------------ */
@@ -9600,11 +9600,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(158*128)
/* ------------------------------ */
@@ -9622,11 +9622,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(159*128)
/* ------------------------------ */
@@ -9644,11 +9644,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(160*128)
/* ------------------------------ */
@@ -9666,11 +9666,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(161*128)
/* ------------------------------ */
@@ -9688,11 +9688,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(162*128)
/* ------------------------------ */
@@ -9710,11 +9710,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(163*128)
/* ------------------------------ */
@@ -9732,11 +9732,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(164*128)
/* ------------------------------ */
@@ -9754,11 +9754,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(165*128)
/* ------------------------------ */
@@ -9776,11 +9776,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(166*128)
/* ------------------------------ */
@@ -9798,11 +9798,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(167*128)
/* ------------------------------ */
@@ -9820,11 +9820,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(168*128)
/* ------------------------------ */
@@ -9842,11 +9842,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(169*128)
/* ------------------------------ */
@@ -9864,11 +9864,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(170*128)
/* ------------------------------ */
@@ -9886,11 +9886,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(171*128)
/* ------------------------------ */
@@ -9908,11 +9908,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(172*128)
/* ------------------------------ */
@@ -9930,11 +9930,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(173*128)
/* ------------------------------ */
@@ -9952,11 +9952,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(174*128)
/* ------------------------------ */
@@ -9974,11 +9974,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(175*128)
/* ------------------------------ */
@@ -9996,11 +9996,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(176*128)
/* ------------------------------ */
@@ -10018,11 +10018,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(177*128)
/* ------------------------------ */
@@ -10040,11 +10040,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(178*128)
/* ------------------------------ */
@@ -10062,11 +10062,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(179*128)
/* ------------------------------ */
@@ -10084,11 +10084,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(180*128)
/* ------------------------------ */
@@ -10106,11 +10106,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(181*128)
/* ------------------------------ */
@@ -10128,11 +10128,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(182*128)
/* ------------------------------ */
@@ -10150,11 +10150,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(183*128)
/* ------------------------------ */
@@ -10172,11 +10172,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(184*128)
/* ------------------------------ */
@@ -10194,11 +10194,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(185*128)
/* ------------------------------ */
@@ -10216,11 +10216,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(186*128)
/* ------------------------------ */
@@ -10238,11 +10238,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(187*128)
/* ------------------------------ */
@@ -10260,11 +10260,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(188*128)
/* ------------------------------ */
@@ -10282,11 +10282,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(189*128)
/* ------------------------------ */
@@ -10304,11 +10304,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(190*128)
/* ------------------------------ */
@@ -10326,11 +10326,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(191*128)
/* ------------------------------ */
@@ -10348,11 +10348,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(192*128)
/* ------------------------------ */
@@ -10370,11 +10370,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(193*128)
/* ------------------------------ */
@@ -10392,11 +10392,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(194*128)
/* ------------------------------ */
@@ -10414,11 +10414,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(195*128)
/* ------------------------------ */
@@ -10436,11 +10436,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(196*128)
/* ------------------------------ */
@@ -10458,11 +10458,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(197*128)
/* ------------------------------ */
@@ -10480,11 +10480,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(198*128)
/* ------------------------------ */
@@ -10502,11 +10502,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(199*128)
/* ------------------------------ */
@@ -10524,11 +10524,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(200*128)
/* ------------------------------ */
@@ -10546,11 +10546,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(201*128)
/* ------------------------------ */
@@ -10568,11 +10568,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(202*128)
/* ------------------------------ */
@@ -10590,11 +10590,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(203*128)
/* ------------------------------ */
@@ -10612,11 +10612,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(204*128)
/* ------------------------------ */
@@ -10634,11 +10634,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(205*128)
/* ------------------------------ */
@@ -10656,11 +10656,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(206*128)
/* ------------------------------ */
@@ -10678,11 +10678,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(207*128)
/* ------------------------------ */
@@ -10700,11 +10700,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(208*128)
/* ------------------------------ */
@@ -10722,11 +10722,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(209*128)
/* ------------------------------ */
@@ -10744,11 +10744,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(210*128)
/* ------------------------------ */
@@ -10766,11 +10766,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(211*128)
/* ------------------------------ */
@@ -10788,11 +10788,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(212*128)
/* ------------------------------ */
@@ -10810,11 +10810,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(213*128)
/* ------------------------------ */
@@ -10832,11 +10832,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(214*128)
/* ------------------------------ */
@@ -10854,11 +10854,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(215*128)
/* ------------------------------ */
@@ -10876,11 +10876,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(216*128)
/* ------------------------------ */
@@ -10898,11 +10898,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(217*128)
/* ------------------------------ */
@@ -10920,11 +10920,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(218*128)
/* ------------------------------ */
@@ -10942,11 +10942,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(219*128)
/* ------------------------------ */
@@ -10964,11 +10964,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(220*128)
/* ------------------------------ */
@@ -10986,11 +10986,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(221*128)
/* ------------------------------ */
@@ -11008,11 +11008,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(222*128)
/* ------------------------------ */
@@ -11030,11 +11030,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(223*128)
/* ------------------------------ */
@@ -11052,11 +11052,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(224*128)
/* ------------------------------ */
@@ -11074,11 +11074,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(225*128)
/* ------------------------------ */
@@ -11096,11 +11096,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(226*128)
/* ------------------------------ */
@@ -11118,11 +11118,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(227*128)
/* ------------------------------ */
@@ -11140,11 +11140,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(228*128)
/* ------------------------------ */
@@ -11162,11 +11162,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(229*128)
/* ------------------------------ */
@@ -11184,11 +11184,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(230*128)
/* ------------------------------ */
@@ -11206,11 +11206,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(231*128)
/* ------------------------------ */
@@ -11228,11 +11228,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(232*128)
/* ------------------------------ */
@@ -11250,11 +11250,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(233*128)
/* ------------------------------ */
@@ -11272,11 +11272,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(234*128)
/* ------------------------------ */
@@ -11294,11 +11294,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(235*128)
/* ------------------------------ */
@@ -11316,11 +11316,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(236*128)
/* ------------------------------ */
@@ -11338,11 +11338,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(237*128)
/* ------------------------------ */
@@ -11360,11 +11360,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(238*128)
/* ------------------------------ */
@@ -11382,11 +11382,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(239*128)
/* ------------------------------ */
@@ -11404,11 +11404,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(240*128)
/* ------------------------------ */
@@ -11426,11 +11426,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(241*128)
/* ------------------------------ */
@@ -11448,11 +11448,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(242*128)
/* ------------------------------ */
@@ -11470,11 +11470,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(243*128)
/* ------------------------------ */
@@ -11492,11 +11492,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(244*128)
/* ------------------------------ */
@@ -11514,11 +11514,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(245*128)
/* ------------------------------ */
@@ -11536,11 +11536,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(246*128)
/* ------------------------------ */
@@ -11558,11 +11558,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(247*128)
/* ------------------------------ */
@@ -11580,11 +11580,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(248*128)
/* ------------------------------ */
@@ -11602,11 +11602,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(249*128)
/* ------------------------------ */
@@ -11624,11 +11624,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(250*128)
/* ------------------------------ */
@@ -11646,11 +11646,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(251*128)
/* ------------------------------ */
@@ -11668,11 +11668,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(252*128)
/* ------------------------------ */
@@ -11690,11 +11690,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(253*128)
/* ------------------------------ */
@@ -11712,11 +11712,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(254*128)
/* ------------------------------ */
@@ -11734,11 +11734,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(255*128)
.balign 128
diff --git a/runtime/interpreter/mterp/x86/alt_stub.S b/runtime/interpreter/mterp/x86/alt_stub.S
index 5a91167..a5b39b8 100644
--- a/runtime/interpreter/mterp/x86/alt_stub.S
+++ b/runtime/interpreter/mterp/x86/alt_stub.S
@@ -9,12 +9,11 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
-
movl rSELF, %ecx
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movl rPC, OUT_ARG2(%esp)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
REFRESH_IBASE
jmp .L_op_nop+(${opnum}*${handler_size_bytes})
diff --git a/runtime/interpreter/mterp/x86_64/alt_stub.S b/runtime/interpreter/mterp/x86_64/alt_stub.S
index 6fcebbb..24cd1a8 100644
--- a/runtime/interpreter/mterp/x86_64/alt_stub.S
+++ b/runtime/interpreter/mterp/x86_64/alt_stub.S
@@ -9,9 +9,9 @@
* return.
*/
.extern MterpCheckBefore
- EXPORT_PC
REFRESH_IBASE
movq rSELF, OUT_ARG0
leaq OFF_FP_SHADOWFRAME(rFP), OUT_ARG1
- call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
+ movq rPC, OUT_ARG2
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame, dex_pc_ptr)
jmp .L_op_nop+(${opnum}*${handler_size_bytes})
diff --git a/runtime/mirror/class-inl.h b/runtime/mirror/class-inl.h
index cefd9f0..b783a01 100644
--- a/runtime/mirror/class-inl.h
+++ b/runtime/mirror/class-inl.h
@@ -247,38 +247,19 @@
SetFieldObject<false>(OFFSET_OF_OBJECT_MEMBER(Class, vtable_), new_vtable);
}
-inline MemberOffset Class::EmbeddedImTableEntryOffset(uint32_t i, size_t pointer_size) {
- DCHECK_LT(i, kImtSize);
- return MemberOffset(
- EmbeddedImTableOffset(pointer_size).Uint32Value() + i * ImTableEntrySize(pointer_size));
-}
-
-template <VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption>
-inline ArtMethod* Class::GetEmbeddedImTableEntry(uint32_t i, size_t pointer_size) {
- DCHECK((ShouldHaveEmbeddedImtAndVTable<kVerifyFlags, kReadBarrierOption>()));
- return GetFieldPtrWithSize<ArtMethod*>(
- EmbeddedImTableEntryOffset(i, pointer_size), pointer_size);
-}
-
-template <VerifyObjectFlags kVerifyFlags, ReadBarrierOption kReadBarrierOption>
-inline void Class::SetEmbeddedImTableEntry(uint32_t i, ArtMethod* method, size_t pointer_size) {
- DCHECK((ShouldHaveEmbeddedImtAndVTable<kVerifyFlags, kReadBarrierOption>()));
- SetFieldPtrWithSize<false>(EmbeddedImTableEntryOffset(i, pointer_size), method, pointer_size);
-}
-
inline bool Class::HasVTable() {
- return GetVTable() != nullptr || ShouldHaveEmbeddedImtAndVTable();
+ return GetVTable() != nullptr || ShouldHaveEmbeddedVTable();
}
inline int32_t Class::GetVTableLength() {
- if (ShouldHaveEmbeddedImtAndVTable()) {
+ if (ShouldHaveEmbeddedVTable()) {
return GetEmbeddedVTableLength();
}
return GetVTable() != nullptr ? GetVTable()->GetLength() : 0;
}
inline ArtMethod* Class::GetVTableEntry(uint32_t i, size_t pointer_size) {
- if (ShouldHaveEmbeddedImtAndVTable()) {
+ if (ShouldHaveEmbeddedVTable()) {
return GetEmbeddedVTableEntry(i, pointer_size);
}
auto* vtable = GetVTable();
@@ -294,6 +275,14 @@
SetField32<false>(MemberOffset(EmbeddedVTableLengthOffset()), len);
}
+inline ImTable* Class::GetImt(size_t pointer_size) {
+ return GetFieldPtrWithSize<ImTable*>(MemberOffset(ImtPtrOffset(pointer_size)), pointer_size);
+}
+
+inline void Class::SetImt(ImTable* imt, size_t pointer_size) {
+ return SetFieldPtrWithSize<false>(MemberOffset(ImtPtrOffset(pointer_size)), imt, pointer_size);
+}
+
inline MemberOffset Class::EmbeddedVTableEntryOffset(uint32_t i, size_t pointer_size) {
return MemberOffset(
EmbeddedVTableOffset(pointer_size).Uint32Value() + i * VTableEntrySize(pointer_size));
@@ -541,7 +530,7 @@
inline MemberOffset Class::GetFirstReferenceStaticFieldOffset(size_t pointer_size) {
DCHECK(IsResolved());
uint32_t base = sizeof(mirror::Class); // Static fields come after the class.
- if (ShouldHaveEmbeddedImtAndVTable<kVerifyFlags, kReadBarrierOption>()) {
+ if (ShouldHaveEmbeddedVTable<kVerifyFlags, kReadBarrierOption>()) {
// Static fields come after the embedded tables.
base = mirror::Class::ComputeClassSize(
true, GetEmbeddedVTableLength(), 0, 0, 0, 0, 0, pointer_size);
@@ -552,7 +541,7 @@
inline MemberOffset Class::GetFirstReferenceStaticFieldOffsetDuringLinking(size_t pointer_size) {
DCHECK(IsLoaded());
uint32_t base = sizeof(mirror::Class); // Static fields come after the class.
- if (ShouldHaveEmbeddedImtAndVTable()) {
+ if (ShouldHaveEmbeddedVTable()) {
// Static fields come after the embedded tables.
base = mirror::Class::ComputeClassSize(true, GetVTableDuringLinking()->GetLength(),
0, 0, 0, 0, 0, pointer_size);
@@ -711,7 +700,7 @@
return Alloc<true>(self, Runtime::Current()->GetHeap()->GetCurrentNonMovingAllocator());
}
-inline uint32_t Class::ComputeClassSize(bool has_embedded_tables,
+inline uint32_t Class::ComputeClassSize(bool has_embedded_vtable,
uint32_t num_vtable_entries,
uint32_t num_8bit_static_fields,
uint32_t num_16bit_static_fields,
@@ -722,11 +711,10 @@
// Space used by java.lang.Class and its instance fields.
uint32_t size = sizeof(Class);
// Space used by embedded tables.
- if (has_embedded_tables) {
- const uint32_t embedded_imt_size = kImtSize * ImTableEntrySize(pointer_size);
- const uint32_t embedded_vtable_size = num_vtable_entries * VTableEntrySize(pointer_size);
- size = RoundUp(size + sizeof(uint32_t) /* embedded vtable len */, pointer_size) +
- embedded_imt_size + embedded_vtable_size;
+ if (has_embedded_vtable) {
+ size = RoundUp(size + sizeof(uint32_t), pointer_size);
+ size += pointer_size; // size of pointer to IMT
+ size += num_vtable_entries * VTableEntrySize(pointer_size);
}
// Space used by reference statics.
@@ -990,18 +978,9 @@
return MakeIterationRangeFromLengthPrefixedArray(GetSFieldsPtrUnchecked());
}
-inline MemberOffset Class::EmbeddedImTableOffset(size_t pointer_size) {
- CheckPointerSize(pointer_size);
- // Round up since we want the embedded imt and vtable to be pointer size aligned in case 64 bits.
- // Add 32 bits for embedded vtable length.
- return MemberOffset(
- RoundUp(EmbeddedVTableLengthOffset().Uint32Value() + sizeof(uint32_t), pointer_size));
-}
-
inline MemberOffset Class::EmbeddedVTableOffset(size_t pointer_size) {
CheckPointerSize(pointer_size);
- return MemberOffset(EmbeddedImTableOffset(pointer_size).Uint32Value() +
- kImtSize * ImTableEntrySize(pointer_size));
+ return MemberOffset(ImtPtrOffset(pointer_size).Uint32Value() + pointer_size);
}
inline void Class::CheckPointerSize(size_t pointer_size) {
@@ -1086,7 +1065,7 @@
dest->SetDexCacheStrings(new_strings);
}
// Fix up embedded tables.
- if (!IsTemp() && ShouldHaveEmbeddedImtAndVTable<kVerifyNone, kReadBarrierOption>()) {
+ if (!IsTemp() && ShouldHaveEmbeddedVTable<kVerifyNone, kReadBarrierOption>()) {
for (int32_t i = 0, count = GetEmbeddedVTableLength(); i < count; ++i) {
ArtMethod* method = GetEmbeddedVTableEntry(i, pointer_size);
ArtMethod* new_method = visitor(method);
@@ -1094,16 +1073,9 @@
dest->SetEmbeddedVTableEntryUnchecked(i, new_method, pointer_size);
}
}
- for (size_t i = 0; i < mirror::Class::kImtSize; ++i) {
- ArtMethod* method = GetEmbeddedImTableEntry<kVerifyFlags, kReadBarrierOption>(i,
- pointer_size);
- ArtMethod* new_method = visitor(method);
- if (method != new_method) {
- dest->SetEmbeddedImTableEntry<kVerifyFlags, kReadBarrierOption>(i,
- new_method,
- pointer_size);
- }
- }
+ }
+ if (!IsTemp() && ShouldHaveImt<kVerifyNone, kReadBarrierOption>()) {
+ dest->SetImt(visitor(GetImt(pointer_size)), pointer_size);
}
}
diff --git a/runtime/mirror/class.cc b/runtime/mirror/class.cc
index b4a23ba..9c77d38 100644
--- a/runtime/mirror/class.cc
+++ b/runtime/mirror/class.cc
@@ -914,13 +914,7 @@
return GetDexFile().GetInterfacesList(*class_def);
}
-void Class::PopulateEmbeddedImtAndVTable(ArtMethod* const (&methods)[kImtSize],
- size_t pointer_size) {
- for (size_t i = 0; i < kImtSize; i++) {
- auto method = methods[i];
- DCHECK(method != nullptr);
- SetEmbeddedImTableEntry(i, method, pointer_size);
- }
+void Class::PopulateEmbeddedVTable(size_t pointer_size) {
PointerArray* table = GetVTableDuringLinking();
CHECK(table != nullptr) << PrettyClass(this);
const size_t table_length = table->GetLength();
@@ -967,7 +961,7 @@
class CopyClassVisitor {
public:
CopyClassVisitor(Thread* self, Handle<mirror::Class>* orig, size_t new_length,
- size_t copy_bytes, ArtMethod* const (&imt)[mirror::Class::kImtSize],
+ size_t copy_bytes, ImTable* imt,
size_t pointer_size)
: self_(self), orig_(orig), new_length_(new_length),
copy_bytes_(copy_bytes), imt_(imt), pointer_size_(pointer_size) {
@@ -979,7 +973,8 @@
Handle<mirror::Class> h_new_class_obj(hs.NewHandle(obj->AsClass()));
mirror::Object::CopyObject(self_, h_new_class_obj.Get(), orig_->Get(), copy_bytes_);
mirror::Class::SetStatus(h_new_class_obj, Class::kStatusResolving, self_);
- h_new_class_obj->PopulateEmbeddedImtAndVTable(imt_, pointer_size_);
+ h_new_class_obj->PopulateEmbeddedVTable(pointer_size_);
+ h_new_class_obj->SetImt(imt_, pointer_size_);
h_new_class_obj->SetClassSize(new_length_);
// Visit all of the references to make sure there is no from space references in the native
// roots.
@@ -992,13 +987,13 @@
Handle<mirror::Class>* const orig_;
const size_t new_length_;
const size_t copy_bytes_;
- ArtMethod* const (&imt_)[mirror::Class::kImtSize];
+ ImTable* imt_;
const size_t pointer_size_;
DISALLOW_COPY_AND_ASSIGN(CopyClassVisitor);
};
Class* Class::CopyOf(Thread* self, int32_t new_length,
- ArtMethod* const (&imt)[mirror::Class::kImtSize], size_t pointer_size) {
+ ImTable* imt, size_t pointer_size) {
DCHECK_GE(new_length, static_cast<int32_t>(sizeof(Class)));
// We may get copied by a compacting GC.
StackHandleScope<1> hs(self);
diff --git a/runtime/mirror/class.h b/runtime/mirror/class.h
index 5235a3e..f044b59 100644
--- a/runtime/mirror/class.h
+++ b/runtime/mirror/class.h
@@ -22,6 +22,7 @@
#include "class_flags.h"
#include "gc_root.h"
#include "gc/allocator_type.h"
+#include "imtable.h"
#include "invoke_type.h"
#include "modifiers.h"
#include "object.h"
@@ -33,10 +34,6 @@
#include "thread.h"
#include "utils.h"
-#ifndef IMT_SIZE
-#error IMT_SIZE not defined
-#endif
-
namespace art {
class ArtField;
@@ -66,11 +63,6 @@
// 2 ref instance fields.]
static constexpr uint32_t kClassWalkSuper = 0xC0000000;
- // Interface method table size. Increasing this value reduces the chance of two interface methods
- // colliding in the interface method table but increases the size of classes that implement
- // (non-marker) interfaces.
- static constexpr size_t kImtSize = IMT_SIZE;
-
// Class Status
//
// kStatusRetired: Class that's temporarily used till class linking time
@@ -351,7 +343,7 @@
// be replaced with a class with the right size for embedded imt/vtable.
bool IsTemp() SHARED_REQUIRES(Locks::mutator_lock_) {
Status s = GetStatus();
- return s < Status::kStatusResolving && ShouldHaveEmbeddedImtAndVTable();
+ return s < Status::kStatusResolving && ShouldHaveEmbeddedVTable();
}
String* GetName() SHARED_REQUIRES(Locks::mutator_lock_); // Returns the cached name.
@@ -557,7 +549,7 @@
SHARED_REQUIRES(Locks::mutator_lock_);
// Compute how many bytes would be used a class with the given elements.
- static uint32_t ComputeClassSize(bool has_embedded_tables,
+ static uint32_t ComputeClassSize(bool has_embedded_vtable,
uint32_t num_vtable_entries,
uint32_t num_8bit_static_fields,
uint32_t num_16bit_static_fields,
@@ -830,28 +822,27 @@
return MemberOffset(sizeof(Class));
}
+ static MemberOffset ImtPtrOffset(size_t pointer_size) {
+ return MemberOffset(
+ RoundUp(EmbeddedVTableLengthOffset().Uint32Value() + sizeof(uint32_t), pointer_size));
+ }
+
template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
- bool ShouldHaveEmbeddedImtAndVTable() SHARED_REQUIRES(Locks::mutator_lock_) {
+ bool ShouldHaveImt() SHARED_REQUIRES(Locks::mutator_lock_) {
+ return ShouldHaveEmbeddedVTable<kVerifyFlags, kReadBarrierOption>();
+ }
+
+ template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
+ ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
+ bool ShouldHaveEmbeddedVTable() SHARED_REQUIRES(Locks::mutator_lock_) {
return IsInstantiable<kVerifyFlags, kReadBarrierOption>();
}
bool HasVTable() SHARED_REQUIRES(Locks::mutator_lock_);
- static MemberOffset EmbeddedImTableEntryOffset(uint32_t i, size_t pointer_size);
-
static MemberOffset EmbeddedVTableEntryOffset(uint32_t i, size_t pointer_size);
- template <VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
- ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
- ArtMethod* GetEmbeddedImTableEntry(uint32_t i, size_t pointer_size)
- SHARED_REQUIRES(Locks::mutator_lock_);
-
- template <VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
- ReadBarrierOption kReadBarrierOption = kWithReadBarrier>
- void SetEmbeddedImTableEntry(uint32_t i, ArtMethod* method, size_t pointer_size)
- SHARED_REQUIRES(Locks::mutator_lock_);
-
int32_t GetVTableLength() SHARED_REQUIRES(Locks::mutator_lock_);
ArtMethod* GetVTableEntry(uint32_t i, size_t pointer_size)
@@ -861,6 +852,10 @@
void SetEmbeddedVTableLength(int32_t len) SHARED_REQUIRES(Locks::mutator_lock_);
+ ImTable* GetImt(size_t pointer_size) SHARED_REQUIRES(Locks::mutator_lock_);
+
+ void SetImt(ImTable* imt, size_t pointer_size) SHARED_REQUIRES(Locks::mutator_lock_);
+
ArtMethod* GetEmbeddedVTableEntry(uint32_t i, size_t pointer_size)
SHARED_REQUIRES(Locks::mutator_lock_);
@@ -870,7 +865,7 @@
inline void SetEmbeddedVTableEntryUnchecked(uint32_t i, ArtMethod* method, size_t pointer_size)
SHARED_REQUIRES(Locks::mutator_lock_);
- void PopulateEmbeddedImtAndVTable(ArtMethod* const (&methods)[kImtSize], size_t pointer_size)
+ void PopulateEmbeddedVTable(size_t pointer_size)
SHARED_REQUIRES(Locks::mutator_lock_);
// Given a method implemented by this class but potentially from a super class, return the
@@ -1195,7 +1190,7 @@
void AssertInitializedOrInitializingInThread(Thread* self)
SHARED_REQUIRES(Locks::mutator_lock_);
- Class* CopyOf(Thread* self, int32_t new_length, ArtMethod* const (&imt)[mirror::Class::kImtSize],
+ Class* CopyOf(Thread* self, int32_t new_length, ImTable* imt,
size_t pointer_size)
SHARED_REQUIRES(Locks::mutator_lock_) REQUIRES(!Roles::uninterruptible_);
@@ -1322,10 +1317,7 @@
// Check that the pointer size matches the one in the class linker.
ALWAYS_INLINE static void CheckPointerSize(size_t pointer_size);
-
- static MemberOffset EmbeddedImTableOffset(size_t pointer_size);
static MemberOffset EmbeddedVTableOffset(size_t pointer_size);
-
template <bool kVisitNativeRoots,
VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags,
ReadBarrierOption kReadBarrierOption = kWithReadBarrier,
diff --git a/runtime/monitor.cc b/runtime/monitor.cc
index 71c866f..396c946 100644
--- a/runtime/monitor.cc
+++ b/runtime/monitor.cc
@@ -220,7 +220,7 @@
struct NthCallerWithDexPcVisitor FINAL : public StackVisitor {
explicit NthCallerWithDexPcVisitor(Thread* thread, size_t frame)
SHARED_REQUIRES(Locks::mutator_lock_)
- : StackVisitor(thread, nullptr, StackVisitor::StackWalkKind::kIncludeInlinedFramesNoResolve),
+ : StackVisitor(thread, nullptr, StackVisitor::StackWalkKind::kIncludeInlinedFrames),
method_(nullptr),
dex_pc_(0),
current_frame_number_(0),
diff --git a/runtime/stack.cc b/runtime/stack.cc
index a5ca527..1d913f2 100644
--- a/runtime/stack.cc
+++ b/runtime/stack.cc
@@ -131,16 +131,10 @@
const OatQuickMethodHeader* method_header = GetCurrentOatQuickMethodHeader();
CodeInfoEncoding encoding = method_header->GetOptimizedCodeInfo().ExtractEncoding();
DCHECK(walk_kind_ != StackWalkKind::kSkipInlinedFrames);
- bool allow_resolve = walk_kind_ != StackWalkKind::kIncludeInlinedFramesNoResolve;
- return allow_resolve
- ? GetResolvedMethod<true>(*GetCurrentQuickFrame(),
- inline_info,
- encoding.inline_info_encoding,
- depth_in_stack_map)
- : GetResolvedMethod<false>(*GetCurrentQuickFrame(),
- inline_info,
- encoding.inline_info_encoding,
- depth_in_stack_map);
+ return GetResolvedMethod(*GetCurrentQuickFrame(),
+ inline_info,
+ encoding.inline_info_encoding,
+ depth_in_stack_map);
} else {
return *cur_quick_frame_;
}
@@ -791,8 +785,7 @@
cur_oat_quick_method_header_ = method->GetOatQuickMethodHeader(cur_quick_frame_pc_);
SanityCheckFrame();
- if ((walk_kind_ == StackWalkKind::kIncludeInlinedFrames ||
- walk_kind_ == StackWalkKind::kIncludeInlinedFramesNoResolve)
+ if ((walk_kind_ == StackWalkKind::kIncludeInlinedFrames)
&& (cur_oat_quick_method_header_ != nullptr)
&& cur_oat_quick_method_header_->IsOptimized()) {
CodeInfo code_info = cur_oat_quick_method_header_->GetOptimizedCodeInfo();
diff --git a/runtime/stack.h b/runtime/stack.h
index e77ab46..c594ec6 100644
--- a/runtime/stack.h
+++ b/runtime/stack.h
@@ -210,6 +210,10 @@
code_item_ = code_item;
}
+ const DexFile::CodeItem* GetCodeItem() const {
+ return code_item_;
+ }
+
float GetVRegFloat(size_t i) const {
DCHECK_LT(i, NumberOfVRegs());
// NOTE: Strict-aliasing?
@@ -407,6 +411,10 @@
return dex_pc_ptr_;
}
+ void SetDexPCPtr(uint16_t* dex_pc_ptr) {
+ dex_pc_ptr_ = dex_pc_ptr;
+ }
+
JValue* GetResultRegister() {
return result_register_;
}
@@ -568,7 +576,6 @@
// when walking the stack.
enum class StackWalkKind {
kIncludeInlinedFrames,
- kIncludeInlinedFramesNoResolve,
kSkipInlinedFrames,
};
diff --git a/runtime/thread_list.cc b/runtime/thread_list.cc
index 97bcb7d..16ef0ff 100644
--- a/runtime/thread_list.cc
+++ b/runtime/thread_list.cc
@@ -613,11 +613,7 @@
PLOG(FATAL) << "futex wait failed for SuspendAllInternal()";
}
}
- } else {
- cur_val = pending_threads.LoadRelaxed();
- CHECK_EQ(cur_val, 0);
- break;
- }
+ } // else re-check pending_threads in the next iteration (this may be a spurious wake-up).
#else
// Spin wait. This is likely to be slow, but on most architecture ART_USE_FUTEXES is set.
#endif
diff --git a/test/082-inline-execute/src/Main.java b/test/082-inline-execute/src/Main.java
index bf561e9..06f193a 100644
--- a/test/082-inline-execute/src/Main.java
+++ b/test/082-inline-execute/src/Main.java
@@ -808,11 +808,21 @@
Assert.assertEquals(Math.round(-2.9d), -3l);
Assert.assertEquals(Math.round(-3.0d), -3l);
Assert.assertEquals(Math.round(0.49999999999999994d), 0l);
+ Assert.assertEquals(Math.round(4503599627370495.0d), 4503599627370495l); // 2^52 - 1
+ Assert.assertEquals(Math.round(4503599627370495.5d), 4503599627370496l); // 2^52 - 0.5
+ Assert.assertEquals(Math.round(4503599627370496.0d), 4503599627370496l); // 2^52
+ Assert.assertEquals(Math.round(-4503599627370495.0d), -4503599627370495l); // -(2^52 - 1)
+ Assert.assertEquals(Math.round(-4503599627370495.5d), -4503599627370495l); // -(2^52 - 0.5)
+ Assert.assertEquals(Math.round(-4503599627370496.0d), -4503599627370496l); // -2^52
Assert.assertEquals(Math.round(9007199254740991.0d), 9007199254740991l); // 2^53 - 1
Assert.assertEquals(Math.round(-9007199254740991.0d), -9007199254740991l); // -(2^53 - 1)
Assert.assertEquals(Math.round(Double.NaN), (long)+0.0d);
Assert.assertEquals(Math.round(Long.MAX_VALUE + 1.0d), Long.MAX_VALUE);
Assert.assertEquals(Math.round(Long.MIN_VALUE - 1.0d), Long.MIN_VALUE);
+ Assert.assertEquals(Math.round(Double.longBitsToDouble(0x43F0000000000000l)),
+ Long.MAX_VALUE); // 2^64
+ Assert.assertEquals(Math.round(Double.longBitsToDouble(0xC3F0000000000000l)),
+ Long.MIN_VALUE); // -2^64
Assert.assertEquals(Math.round(Double.POSITIVE_INFINITY), Long.MAX_VALUE);
Assert.assertEquals(Math.round(Double.NEGATIVE_INFINITY), Long.MIN_VALUE);
}
@@ -846,6 +856,10 @@
Assert.assertEquals(Math.round(Float.NaN), (int)+0.0f);
Assert.assertEquals(Math.round(Integer.MAX_VALUE + 1.0f), Integer.MAX_VALUE);
Assert.assertEquals(Math.round(Integer.MIN_VALUE - 1.0f), Integer.MIN_VALUE);
+ Assert.assertEquals(Math.round(Float.intBitsToFloat(0x4F800000)),
+ Integer.MAX_VALUE); // 2^32
+ Assert.assertEquals(Math.round(Float.intBitsToFloat(0xCF800000)),
+ Integer.MIN_VALUE); // -2^32
Assert.assertEquals(Math.round(Float.POSITIVE_INFINITY), Integer.MAX_VALUE);
Assert.assertEquals(Math.round(Float.NEGATIVE_INFINITY), Integer.MIN_VALUE);
}
@@ -1153,11 +1167,21 @@
Assert.assertEquals(StrictMath.round(-2.9d), -3l);
Assert.assertEquals(StrictMath.round(-3.0d), -3l);
Assert.assertEquals(StrictMath.round(0.49999999999999994d), 0l);
+ Assert.assertEquals(StrictMath.round(4503599627370495.0d), 4503599627370495l); // 2^52 - 1
+ Assert.assertEquals(StrictMath.round(4503599627370495.5d), 4503599627370496l); // 2^52 - 0.5
+ Assert.assertEquals(StrictMath.round(4503599627370496.0d), 4503599627370496l); // 2^52
+ Assert.assertEquals(StrictMath.round(-4503599627370495.0d), -4503599627370495l); // -(2^52 - 1)
+ Assert.assertEquals(StrictMath.round(-4503599627370495.5d), -4503599627370495l); // -(2^52 - 0.5)
+ Assert.assertEquals(StrictMath.round(-4503599627370496.0d), -4503599627370496l); // -2^52
Assert.assertEquals(StrictMath.round(9007199254740991.0d), 9007199254740991l); // 2^53 - 1
Assert.assertEquals(StrictMath.round(-9007199254740991.0d), -9007199254740991l); // -(2^53 - 1)
Assert.assertEquals(StrictMath.round(Double.NaN), (long)+0.0d);
Assert.assertEquals(StrictMath.round(Long.MAX_VALUE + 1.0d), Long.MAX_VALUE);
Assert.assertEquals(StrictMath.round(Long.MIN_VALUE - 1.0d), Long.MIN_VALUE);
+ Assert.assertEquals(StrictMath.round(Double.longBitsToDouble(0x43F0000000000000l)),
+ Long.MAX_VALUE); // 2^64
+ Assert.assertEquals(StrictMath.round(Double.longBitsToDouble(0xC3F0000000000000l)),
+ Long.MIN_VALUE); // -2^64
Assert.assertEquals(StrictMath.round(Double.POSITIVE_INFINITY), Long.MAX_VALUE);
Assert.assertEquals(StrictMath.round(Double.NEGATIVE_INFINITY), Long.MIN_VALUE);
}
@@ -1191,6 +1215,10 @@
Assert.assertEquals(StrictMath.round(Float.NaN), (int)+0.0f);
Assert.assertEquals(StrictMath.round(Integer.MAX_VALUE + 1.0f), Integer.MAX_VALUE);
Assert.assertEquals(StrictMath.round(Integer.MIN_VALUE - 1.0f), Integer.MIN_VALUE);
+ Assert.assertEquals(StrictMath.round(Float.intBitsToFloat(0x4F800000)),
+ Integer.MAX_VALUE); // 2^32
+ Assert.assertEquals(StrictMath.round(Float.intBitsToFloat(0xCF800000)),
+ Integer.MIN_VALUE); // -2^32
Assert.assertEquals(StrictMath.round(Float.POSITIVE_INFINITY), Integer.MAX_VALUE);
Assert.assertEquals(StrictMath.round(Float.NEGATIVE_INFINITY), Integer.MIN_VALUE);
}
diff --git a/test/141-class-unload/expected.txt b/test/141-class-unload/expected.txt
index 11de660..2b77b29 100644
--- a/test/141-class-unload/expected.txt
+++ b/test/141-class-unload/expected.txt
@@ -12,7 +12,6 @@
JNI_OnUnload called
null
loader null false
-loader null false
JNI_OnLoad called
JNI_OnUnload called
null
diff --git a/test/141-class-unload/src/Main.java b/test/141-class-unload/src/Main.java
index 17a6049..9ed8d28 100644
--- a/test/141-class-unload/src/Main.java
+++ b/test/141-class-unload/src/Main.java
@@ -37,8 +37,6 @@
try {
testUnloadClass(constructor);
testUnloadLoader(constructor);
- // Test that we don't unload if we have a Method keeping the class live.
- testNoUnloadInvoke(constructor);
// Test that we don't unload if we have an instance.
testNoUnloadInstance(constructor);
// Test JNI_OnLoad and JNI_OnUnload.
@@ -79,10 +77,10 @@
}
private static void testUnloadClass(Constructor constructor) throws Exception {
- WeakReference<Class> klass = setUpUnloadClass(constructor);
+ WeakReference<Class> klass = setUpUnloadClassWeak(constructor);
// No strong references to class loader, should get unloaded.
Runtime.getRuntime().gc();
- WeakReference<Class> klass2 = setUpUnloadClass(constructor);
+ WeakReference<Class> klass2 = setUpUnloadClassWeak(constructor);
Runtime.getRuntime().gc();
// If the weak reference is cleared, then it was unloaded.
System.out.println(klass.get());
@@ -99,12 +97,14 @@
}
private static void testStackTrace(Constructor constructor) throws Exception {
- WeakReference<Class> klass = setUpUnloadClass(constructor);
- Method stackTraceMethod = klass.get().getDeclaredMethod("generateStackTrace");
- Throwable throwable = (Throwable) stackTraceMethod.invoke(klass.get());
+ Class klass = setUpUnloadClass(constructor);
+ WeakReference<Class> weak_klass = new WeakReference(klass);
+ Method stackTraceMethod = klass.getDeclaredMethod("generateStackTrace");
+ Throwable throwable = (Throwable) stackTraceMethod.invoke(klass);
stackTraceMethod = null;
+ klass = null;
Runtime.getRuntime().gc();
- boolean isNull = klass.get() == null;
+ boolean isNull = weak_klass.get() == null;
System.out.println("class null " + isNull + " " + throwable.getMessage());
}
@@ -116,28 +116,37 @@
System.out.println(loader.get());
}
- private static void testNoUnloadInvoke(Constructor constructor) throws Exception {
- WeakReference<ClassLoader> loader =
- new WeakReference((ClassLoader) constructor.newInstance(
- DEX_FILE, LIBRARY_SEARCH_PATH, ClassLoader.getSystemClassLoader()));
- WeakReference<Class> intHolder = new WeakReference(loader.get().loadClass("IntHolder"));
- intHolder.get().getDeclaredMethod("runGC").invoke(intHolder.get());
- boolean isNull = loader.get() == null;
- System.out.println("loader null " + isNull);
+ private static Object testNoUnloadHelper(ClassLoader loader) throws Exception {
+ Class intHolder = loader.loadClass("IntHolder");
+ return intHolder.newInstance();
+ }
+
+ static class Pair {
+ public Pair(Object o, ClassLoader l) {
+ object = o;
+ classLoader = new WeakReference<ClassLoader>(l);
+ }
+
+ public Object object;
+ public WeakReference<ClassLoader> classLoader;
+ }
+
+ private static Pair testNoUnloadInstanceHelper(Constructor constructor) throws Exception {
+ ClassLoader loader = (ClassLoader) constructor.newInstance(
+ DEX_FILE, LIBRARY_SEARCH_PATH, ClassLoader.getSystemClassLoader());
+ Object o = testNoUnloadHelper(loader);
+ return new Pair(o, loader);
}
private static void testNoUnloadInstance(Constructor constructor) throws Exception {
- WeakReference<ClassLoader> loader =
- new WeakReference((ClassLoader) constructor.newInstance(
- DEX_FILE, LIBRARY_SEARCH_PATH, ClassLoader.getSystemClassLoader()));
- WeakReference<Class> intHolder = new WeakReference(loader.get().loadClass("IntHolder"));
- Object o = intHolder.get().newInstance();
+ Pair p = testNoUnloadInstanceHelper(constructor);
Runtime.getRuntime().gc();
- boolean isNull = loader.get() == null;
+ // If the class loader was unloded too early due to races, just pass the test.
+ boolean isNull = p.classLoader.get() == null;
System.out.println("loader null " + isNull);
}
- private static WeakReference<Class> setUpUnloadClass(Constructor constructor) throws Exception {
+ private static Class setUpUnloadClass(Constructor constructor) throws Exception {
ClassLoader loader = (ClassLoader) constructor.newInstance(
DEX_FILE, LIBRARY_SEARCH_PATH, ClassLoader.getSystemClassLoader());
Class intHolder = loader.loadClass("IntHolder");
@@ -149,7 +158,12 @@
setValue.invoke(intHolder, 2);
System.out.println((int) getValue.invoke(intHolder));
waitForCompilation(intHolder);
- return new WeakReference(intHolder);
+ return intHolder;
+ }
+
+ private static WeakReference<Class> setUpUnloadClassWeak(Constructor constructor)
+ throws Exception {
+ return new WeakReference<Class>(setUpUnloadClass(constructor));
}
private static WeakReference<ClassLoader> setUpUnloadLoader(Constructor constructor,
diff --git a/test/458-checker-instruction-simplification/smali/SmaliTests.smali b/test/458-checker-instruction-simplification/smali/SmaliTests.smali
index ede599b..6845961 100644
--- a/test/458-checker-instruction-simplification/smali/SmaliTests.smali
+++ b/test/458-checker-instruction-simplification/smali/SmaliTests.smali
@@ -191,3 +191,139 @@
.end method
+## CHECK-START: int SmaliTests.AddSubConst(int) instruction_simplifier (before)
+## CHECK-DAG: <<ArgValue:i\d+>> ParameterValue
+## CHECK-DAG: <<Const7:i\d+>> IntConstant 7
+## CHECK-DAG: <<Const8:i\d+>> IntConstant 8
+## CHECK-DAG: <<Add:i\d+>> Add [<<ArgValue>>,<<Const7>>]
+## CHECK-DAG: <<Sub:i\d+>> Sub [<<Add>>,<<Const8>>]
+## CHECK-DAG: Return [<<Sub>>]
+
+## CHECK-START: int SmaliTests.AddSubConst(int) instruction_simplifier (after)
+## CHECK-DAG: <<ArgValue:i\d+>> ParameterValue
+## CHECK-DAG: <<ConstM1:i\d+>> IntConstant -1
+## CHECK-DAG: <<Add:i\d+>> Add [<<ArgValue>>,<<ConstM1>>]
+## CHECK-DAG: Return [<<Add>>]
+
+.method public static AddSubConst(I)I
+ .registers 3
+
+ .prologue
+ add-int/lit8 v0, p0, 7
+
+ const/16 v1, 8
+
+ sub-int v0, v0, v1
+
+ return v0
+.end method
+
+## CHECK-START: int SmaliTests.SubAddConst(int) instruction_simplifier (before)
+## CHECK-DAG: <<ArgValue:i\d+>> ParameterValue
+## CHECK-DAG: <<Const3:i\d+>> IntConstant 3
+## CHECK-DAG: <<Const4:i\d+>> IntConstant 4
+## CHECK-DAG: <<Sub:i\d+>> Sub [<<ArgValue>>,<<Const3>>]
+## CHECK-DAG: <<Add:i\d+>> Add [<<Sub>>,<<Const4>>]
+## CHECK-DAG: Return [<<Add>>]
+
+## CHECK-START: int SmaliTests.SubAddConst(int) instruction_simplifier (after)
+## CHECK-DAG: <<ArgValue:i\d+>> ParameterValue
+## CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+## CHECK-DAG: <<Add:i\d+>> Add [<<ArgValue>>,<<Const1>>]
+## CHECK-DAG: Return [<<Add>>]
+
+.method public static SubAddConst(I)I
+ .registers 2
+
+ .prologue
+ const/4 v0, 3
+
+ sub-int v0, p0, v0
+
+ add-int/lit8 v0, v0, 4
+
+ return v0
+.end method
+
+## CHECK-START: int SmaliTests.SubSubConst1(int) instruction_simplifier (before)
+## CHECK-DAG: <<ArgValue:i\d+>> ParameterValue
+## CHECK-DAG: <<Const9:i\d+>> IntConstant 9
+## CHECK-DAG: <<Const10:i\d+>> IntConstant 10
+## CHECK-DAG: <<Sub1:i\d+>> Sub [<<ArgValue>>,<<Const9>>]
+## CHECK-DAG: <<Sub2:i\d+>> Sub [<<Sub1>>,<<Const10>>]
+## CHECK-DAG: Return [<<Sub2>>]
+
+## CHECK-START: int SmaliTests.SubSubConst1(int) instruction_simplifier (after)
+## CHECK-DAG: <<ArgValue:i\d+>> ParameterValue
+## CHECK-DAG: <<ConstM19:i\d+>> IntConstant -19
+## CHECK-DAG: <<Add:i\d+>> Add [<<ArgValue>>,<<ConstM19>>]
+## CHECK-DAG: Return [<<Add>>]
+
+.method public static SubSubConst1(I)I
+ .registers 3
+
+ .prologue
+ const/16 v1, 9
+
+ sub-int v0, p0, v1
+
+ const/16 v1, 10
+
+ sub-int v0, v0, v1
+
+ return v0
+.end method
+
+## CHECK-START: int SmaliTests.SubSubConst2(int) instruction_simplifier (before)
+## CHECK-DAG: <<ArgValue:i\d+>> ParameterValue
+## CHECK-DAG: <<Const11:i\d+>> IntConstant 11
+## CHECK-DAG: <<Const12:i\d+>> IntConstant 12
+## CHECK-DAG: <<Sub1:i\d+>> Sub [<<Const11>>,<<ArgValue>>]
+## CHECK-DAG: <<Sub2:i\d+>> Sub [<<Sub1>>,<<Const12>>]
+## CHECK-DAG: Return [<<Sub2>>]
+
+## CHECK-START: int SmaliTests.SubSubConst2(int) instruction_simplifier (after)
+## CHECK-DAG: <<ArgValue:i\d+>> ParameterValue
+## CHECK-DAG: <<ConstM1:i\d+>> IntConstant -1
+## CHECK-DAG: <<Sub:i\d+>> Sub [<<ConstM1>>,<<ArgValue>>]
+## CHECK-DAG: Return [<<Sub>>]
+
+.method public static SubSubConst2(I)I
+ .registers 3
+
+ .prologue
+ rsub-int/lit8 v0, p0, 11
+
+ const/16 v1, 12
+
+ sub-int v0, v0, v1
+
+ return v0
+.end method
+
+## CHECK-START: int SmaliTests.SubSubConst3(int) instruction_simplifier (before)
+## CHECK-DAG: <<ArgValue:i\d+>> ParameterValue
+## CHECK-DAG: <<Const15:i\d+>> IntConstant 15
+## CHECK-DAG: <<Const16:i\d+>> IntConstant 16
+## CHECK-DAG: <<Sub1:i\d+>> Sub [<<ArgValue>>,<<Const16>>]
+## CHECK-DAG: <<Sub2:i\d+>> Sub [<<Const15>>,<<Sub1>>]
+## CHECK-DAG: Return [<<Sub2>>]
+
+## CHECK-START: int SmaliTests.SubSubConst3(int) instruction_simplifier (after)
+## CHECK-DAG: <<ArgValue:i\d+>> ParameterValue
+## CHECK-DAG: <<Const31:i\d+>> IntConstant 31
+## CHECK-DAG: <<Sub:i\d+>> Sub [<<Const31>>,<<ArgValue>>]
+## CHECK-DAG: Return [<<Sub>>]
+
+.method public static SubSubConst3(I)I
+ .registers 2
+
+ .prologue
+ const/16 v0, 16
+
+ sub-int v0, p0, v0
+
+ rsub-int/lit8 v0, v0, 15
+
+ return v0
+.end method
diff --git a/test/458-checker-instruction-simplification/src/Main.java b/test/458-checker-instruction-simplification/src/Main.java
index ffce49d..c717eaa 100644
--- a/test/458-checker-instruction-simplification/src/Main.java
+++ b/test/458-checker-instruction-simplification/src/Main.java
@@ -78,6 +78,29 @@
return 0 + arg;
}
+ /// CHECK-START: int Main.$noinline$AddAddSubAddConst(int) instruction_simplifier (before)
+ /// CHECK-DAG: <<ArgValue:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: <<Const2:i\d+>> IntConstant 2
+ /// CHECK-DAG: <<ConstM3:i\d+>> IntConstant -3
+ /// CHECK-DAG: <<Const4:i\d+>> IntConstant 4
+ /// CHECK-DAG: <<Add1:i\d+>> Add [<<ArgValue>>,<<Const1>>]
+ /// CHECK-DAG: <<Add2:i\d+>> Add [<<Add1>>,<<Const2>>]
+ /// CHECK-DAG: <<Add3:i\d+>> Add [<<Add2>>,<<ConstM3>>]
+ /// CHECK-DAG: <<Add4:i\d+>> Add [<<Add3>>,<<Const4>>]
+ /// CHECK-DAG: Return [<<Add4>>]
+
+ /// CHECK-START: int Main.$noinline$AddAddSubAddConst(int) instruction_simplifier (after)
+ /// CHECK-DAG: <<ArgValue:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const4:i\d+>> IntConstant 4
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<ArgValue>>,<<Const4>>]
+ /// CHECK-DAG: Return [<<Add>>]
+
+ public static int $noinline$AddAddSubAddConst(int arg) {
+ if (doThrow) { throw new Error(); }
+ return arg + 1 + 2 - 3 + 4;
+ }
+
/// CHECK-START: int Main.$noinline$AndAllOnes(int) instruction_simplifier (before)
/// CHECK-DAG: <<Arg:i\d+>> ParameterValue
/// CHECK-DAG: <<ConstF:i\d+>> IntConstant -1
@@ -364,6 +387,27 @@
return arg * 128;
}
+ /// CHECK-START: long Main.$noinline$MulMulMulConst(long) instruction_simplifier (before)
+ /// CHECK-DAG: <<ArgValue:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Const10:j\d+>> LongConstant 10
+ /// CHECK-DAG: <<Const11:j\d+>> LongConstant 11
+ /// CHECK-DAG: <<Const12:j\d+>> LongConstant 12
+ /// CHECK-DAG: <<Mul1:j\d+>> Mul [<<Const10>>,<<ArgValue>>]
+ /// CHECK-DAG: <<Mul2:j\d+>> Mul [<<Mul1>>,<<Const11>>]
+ /// CHECK-DAG: <<Mul3:j\d+>> Mul [<<Mul2>>,<<Const12>>]
+ /// CHECK-DAG: Return [<<Mul3>>]
+
+ /// CHECK-START: long Main.$noinline$MulMulMulConst(long) instruction_simplifier (after)
+ /// CHECK-DAG: <<ArgValue:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Const1320:j\d+>> LongConstant 1320
+ /// CHECK-DAG: <<Mul:j\d+>> Mul [<<ArgValue>>,<<Const1320>>]
+ /// CHECK-DAG: Return [<<Mul>>]
+
+ public static long $noinline$MulMulMulConst(long arg) {
+ if (doThrow) { throw new Error(); }
+ return 10 * arg * 11 * 12;
+ }
+
/// CHECK-START: int Main.$noinline$Or0(int) instruction_simplifier (before)
/// CHECK-DAG: <<Arg:i\d+>> ParameterValue
/// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
@@ -490,6 +534,63 @@
return 0 - arg;
}
+ /// CHECK-START: int Main.$noinline$SubAddConst1(int) instruction_simplifier (before)
+ /// CHECK-DAG: <<ArgValue:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const5:i\d+>> IntConstant 5
+ /// CHECK-DAG: <<Const6:i\d+>> IntConstant 6
+ /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Const5>>,<<ArgValue>>]
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<Sub>>,<<Const6>>]
+ /// CHECK-DAG: Return [<<Add>>]
+
+ /// CHECK-START: int Main.$noinline$SubAddConst1(int) instruction_simplifier (after)
+ /// CHECK-DAG: <<ArgValue:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const11:i\d+>> IntConstant 11
+ /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Const11>>,<<ArgValue>>]
+ /// CHECK-DAG: Return [<<Sub>>]
+
+ public static int $noinline$SubAddConst1(int arg) {
+ if (doThrow) { throw new Error(); }
+ return 5 - arg + 6;
+ }
+
+ /// CHECK-START: int Main.$noinline$SubAddConst2(int) instruction_simplifier (before)
+ /// CHECK-DAG: <<ArgValue:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const14:i\d+>> IntConstant 14
+ /// CHECK-DAG: <<Const13:i\d+>> IntConstant 13
+ /// CHECK-DAG: <<Add:i\d+>> Add [<<ArgValue>>,<<Const13>>]
+ /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Const14>>,<<Add>>]
+ /// CHECK-DAG: Return [<<Sub>>]
+
+ /// CHECK-START: int Main.$noinline$SubAddConst2(int) instruction_simplifier (after)
+ /// CHECK-DAG: <<ArgValue:i\d+>> ParameterValue
+ /// CHECK-DAG: <<Const1:i\d+>> IntConstant 1
+ /// CHECK-DAG: <<Sub:i\d+>> Sub [<<Const1>>,<<ArgValue>>]
+ /// CHECK-DAG: Return [<<Sub>>]
+
+ public static int $noinline$SubAddConst2(int arg) {
+ if (doThrow) { throw new Error(); }
+ return 14 - (arg + 13);
+ }
+
+ /// CHECK-START: long Main.$noinline$SubSubConst(long) instruction_simplifier (before)
+ /// CHECK-DAG: <<ArgValue:j\d+>> ParameterValue
+ /// CHECK-DAG: <<Const17:j\d+>> LongConstant 17
+ /// CHECK-DAG: <<Const18:j\d+>> LongConstant 18
+ /// CHECK-DAG: <<Sub1:j\d+>> Sub [<<Const18>>,<<ArgValue>>]
+ /// CHECK-DAG: <<Sub2:j\d+>> Sub [<<Const17>>,<<Sub1>>]
+ /// CHECK-DAG: Return [<<Sub2>>]
+
+ /// CHECK-START: long Main.$noinline$SubSubConst(long) instruction_simplifier (after)
+ /// CHECK-DAG: <<ArgValue:j\d+>> ParameterValue
+ /// CHECK-DAG: <<ConstM1:j\d+>> LongConstant -1
+ /// CHECK-DAG: <<Add:j\d+>> Add [<<ArgValue>>,<<ConstM1>>]
+ /// CHECK-DAG: Return [<<Add>>]
+
+ public static long $noinline$SubSubConst(long arg) {
+ if (doThrow) { throw new Error(); }
+ return 17 - (18 - arg);
+ }
+
/// CHECK-START: long Main.$noinline$UShr0(long) instruction_simplifier (before)
/// CHECK-DAG: <<Arg:j\d+>> ParameterValue
/// CHECK-DAG: <<Const0:i\d+>> IntConstant 0
@@ -1757,6 +1858,17 @@
}
}
+ public static int $noinline$runSmaliTestConst(String name, int arg) {
+ if (doThrow) { throw new Error(); }
+ try {
+ Class<?> c = Class.forName("SmaliTests");
+ Method m = c.getMethod(name, int.class);
+ return (Integer) m.invoke(null, arg);
+ } catch (Exception ex) {
+ throw new Error(ex);
+ }
+ }
+
/// CHECK-START: int Main.$noinline$intUnnecessaryShiftMasking(int, int) instruction_simplifier (before)
/// CHECK: <<Value:i\d+>> ParameterValue
/// CHECK: <<Shift:i\d+>> ParameterValue
@@ -1863,12 +1975,14 @@
int arg = 123456;
assertLongEquals(arg, $noinline$Add0(arg));
+ assertIntEquals(5, $noinline$AddAddSubAddConst(1));
assertIntEquals(arg, $noinline$AndAllOnes(arg));
assertLongEquals(arg, $noinline$Div1(arg));
assertIntEquals(-arg, $noinline$DivN1(arg));
assertLongEquals(arg, $noinline$Mul1(arg));
assertIntEquals(-arg, $noinline$MulN1(arg));
assertLongEquals((128 * arg), $noinline$MulPowerOfTwo128(arg));
+ assertLongEquals(2640, $noinline$MulMulMulConst(2));
assertIntEquals(arg, $noinline$Or0(arg));
assertLongEquals(arg, $noinline$OrSame(arg));
assertIntEquals(arg, $noinline$Shl0(arg));
@@ -1876,6 +1990,9 @@
assertLongEquals(arg, $noinline$Shr64(arg));
assertLongEquals(arg, $noinline$Sub0(arg));
assertIntEquals(-arg, $noinline$SubAliasNeg(arg));
+ assertIntEquals(9, $noinline$SubAddConst1(2));
+ assertIntEquals(-2, $noinline$SubAddConst2(3));
+ assertLongEquals(3, $noinline$SubSubConst(4));
assertLongEquals(arg, $noinline$UShr0(arg));
assertIntEquals(arg, $noinline$Xor0(arg));
assertIntEquals(~arg, $noinline$XorAllOnes(arg));
@@ -2011,6 +2128,11 @@
}
}
+ assertIntEquals(0, $noinline$runSmaliTestConst("AddSubConst", 1));
+ assertIntEquals(3, $noinline$runSmaliTestConst("SubAddConst", 2));
+ assertIntEquals(-16, $noinline$runSmaliTestConst("SubSubConst1", 3));
+ assertIntEquals(-5, $noinline$runSmaliTestConst("SubSubConst2", 4));
+ assertIntEquals(26, $noinline$runSmaliTestConst("SubSubConst3", 5));
assertIntEquals(0x5e6f7808, $noinline$intUnnecessaryShiftMasking(0xabcdef01, 3));
assertIntEquals(0x5e6f7808, $noinline$intUnnecessaryShiftMasking(0xabcdef01, 3 + 32));
assertLongEquals(0xffffffffffffeaf3L, $noinline$longUnnecessaryShiftMasking(0xabcdef0123456789L, 50));
diff --git a/test/478-checker-clinit-check-pruning/src/Main.java b/test/478-checker-clinit-check-pruning/src/Main.java
index 6fc12f1..c2982b4 100644
--- a/test/478-checker-clinit-check-pruning/src/Main.java
+++ b/test/478-checker-clinit-check-pruning/src/Main.java
@@ -103,10 +103,8 @@
static boolean doThrow = false;
static void $noinline$staticMethod() {
- if (doThrow) {
- // Try defeating inlining.
- throw new Error();
- }
+ // Try defeating inlining.
+ if (doThrow) { throw new Error(); }
}
}
@@ -181,10 +179,8 @@
static boolean doThrow = false;
static void $noinline$staticMethod() {
- if (doThrow) {
// Try defeating inlining.
- throw new Error();
- }
+ if (doThrow) { throw new Error(); }
}
}
@@ -245,10 +241,8 @@
static boolean doThrow = false;
static void $noinline$staticMethod() {
- if (doThrow) {
// Try defeating inlining.
- throw new Error();
- }
+ if (doThrow) { throw new Error(); }
}
static {
@@ -314,7 +308,7 @@
static void constClassAndInvokeStatic(Iterable<?> it) {
$opt$inline$ignoreClass(ClassWithClinit7.class);
- ClassWithClinit7.someStaticMethod(it);
+ ClassWithClinit7.$noinline$someStaticMethod(it);
}
static void $opt$inline$ignoreClass(Class<?> c) {
@@ -325,10 +319,10 @@
System.out.println("Main$ClassWithClinit7's static initializer");
}
- // Note: not inlined from constClassAndInvokeStatic() but fully inlined from main().
- static void someStaticMethod(Iterable<?> it) {
- // We're not inlining invoke-interface at the moment.
+ static void $noinline$someStaticMethod(Iterable<?> it) {
it.iterator();
+ // We're not inlining throw at the moment.
+ if (doThrow) { throw new Error(""); }
}
}
@@ -345,7 +339,7 @@
static void sgetAndInvokeStatic(Iterable<?> it) {
$opt$inline$ignoreInt(ClassWithClinit8.value);
- ClassWithClinit8.someStaticMethod(it);
+ ClassWithClinit8.$noinline$someStaticMethod(it);
}
static void $opt$inline$ignoreInt(int i) {
@@ -357,10 +351,10 @@
System.out.println("Main$ClassWithClinit8's static initializer");
}
- // Note: not inlined from sgetAndInvokeStatic() but fully inlined from main().
- static void someStaticMethod(Iterable<?> it) {
- // We're not inlining invoke-interface at the moment.
+ static void $noinline$someStaticMethod(Iterable<?> it) {
it.iterator();
+ // We're not inlining throw at the moment.
+ if (doThrow) { throw new Error(""); }
}
}
@@ -377,7 +371,7 @@
static void constClassSgetAndInvokeStatic(Iterable<?> it) {
$opt$inline$ignoreClass(ClassWithClinit9.class);
$opt$inline$ignoreInt(ClassWithClinit9.value);
- ClassWithClinit9.someStaticMethod(it);
+ ClassWithClinit9.$noinline$someStaticMethod(it);
}
static class ClassWithClinit9 {
@@ -386,10 +380,10 @@
System.out.println("Main$ClassWithClinit9's static initializer");
}
- // Note: not inlined from constClassSgetAndInvokeStatic() but fully inlined from main().
- static void someStaticMethod(Iterable<?> it) {
- // We're not inlining invoke-interface at the moment.
+ static void $noinline$someStaticMethod(Iterable<?> it) {
it.iterator();
+ // We're not inlining throw at the moment.
+ if (doThrow) { throw new Error(""); }
}
}
@@ -422,8 +416,9 @@
static void inlinedForNull(Iterable<?> it) {
if (it != null) {
- // We're not inlining invoke-interface at the moment.
it.iterator();
+ // We're not inlining throw at the moment.
+ if (doThrow) { throw new Error(""); }
}
}
}
@@ -460,8 +455,11 @@
}
static void inlinedForNull(Iterable<?> it) {
- // We're not inlining invoke-interface at the moment.
it.iterator();
+ if (it != null) {
+ // We're not inlining throw at the moment.
+ if (doThrow) { throw new Error(""); }
+ }
}
}
@@ -494,8 +492,8 @@
static void inlinedForNull(Iterable<?> it) {
if (it != null) {
- // We're not inlining invoke-interface at the moment.
- it.iterator();
+ // We're not inlining throw at the moment.
+ if (doThrow) { throw new Error(""); }
}
}
}
@@ -510,8 +508,9 @@
}
public static void $noinline$getIterator(Iterable<?> it) {
- // We're not inlining invoke-interface at the moment.
it.iterator();
+ // We're not inlining throw at the moment.
+ if (doThrow) { throw new Error(""); }
}
}
diff --git a/test/530-checker-loops1/src/Main.java b/test/530-checker-loops1/src/Main.java
index 948a7b7..dde4d62 100644
--- a/test/530-checker-loops1/src/Main.java
+++ b/test/530-checker-loops1/src/Main.java
@@ -562,7 +562,7 @@
//
/// CHECK-START: void Main.linearTriangularOnTwoArrayLengths(int) BCE (after)
/// CHECK-NOT: BoundsCheck
- // TODO: also CHECK-NOT: Deoptimize, see b/27151190
+ /// CHECK-NOT: Deoptimize
private static void linearTriangularOnTwoArrayLengths(int n) {
int[] a = new int[n];
for (int i = 0; i < a.length; i++) {
@@ -604,7 +604,7 @@
//
/// CHECK-START: void Main.linearTriangularOnParameter(int) BCE (after)
/// CHECK-NOT: BoundsCheck
- // TODO: also CHECK-NOT: Deoptimize, see b/27151190
+ /// CHECK-NOT: Deoptimize
private static void linearTriangularOnParameter(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++) {
@@ -619,56 +619,56 @@
}
}
- /// CHECK-START: void Main.linearTriangularVariationsInnerStrict(int) BCE (before)
+ /// CHECK-START: void Main.linearTriangularStrictLower(int) BCE (before)
/// CHECK-DAG: BoundsCheck
/// CHECK-DAG: BoundsCheck
/// CHECK-DAG: BoundsCheck
/// CHECK-DAG: BoundsCheck
//
- /// CHECK-START: void Main.linearTriangularVariationsInnerStrict(int) BCE (after)
+ /// CHECK-START: void Main.linearTriangularStrictLower(int) BCE (after)
/// CHECK-NOT: BoundsCheck
- // TODO: also CHECK-NOT: Deoptimize, see b/27151190
- private static void linearTriangularVariationsInnerStrict(int n) {
+ /// CHECK-NOT: Deoptimize
+ private static void linearTriangularStrictLower(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++) {
a[j] += 1;
}
- for (int j = i - 1; j > -1; j--) {
+ for (int j = i - 1; j >= 0; j--) {
a[j] += 1;
}
for (int j = i; j < n; j++) {
a[j] += 1;
}
- for (int j = n - 1; j > i - 1; j--) {
+ for (int j = n - 1; j >= i; j--) {
a[j] += 1;
}
}
verifyTriangular(a);
}
- /// CHECK-START: void Main.linearTriangularVariationsInnerNonStrict(int) BCE (before)
+ /// CHECK-START: void Main.linearTriangularStrictUpper(int) BCE (before)
/// CHECK-DAG: BoundsCheck
/// CHECK-DAG: BoundsCheck
/// CHECK-DAG: BoundsCheck
/// CHECK-DAG: BoundsCheck
//
- /// CHECK-START: void Main.linearTriangularVariationsInnerNonStrict(int) BCE (after)
+ /// CHECK-START: void Main.linearTriangularStrictUpper(int) BCE (after)
/// CHECK-NOT: BoundsCheck
- // TODO: also CHECK-NOT: Deoptimize, see b/27151190
- private static void linearTriangularVariationsInnerNonStrict(int n) {
+ /// CHECK-NOT: Deoptimize
+ private static void linearTriangularStrictUpper(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++) {
- for (int j = 0; j <= i - 1; j++) {
+ for (int j = 0; j <= i; j++) {
a[j] += 1;
}
- for (int j = i - 1; j >= 0; j--) {
+ for (int j = i; j >= 0; j--) {
a[j] += 1;
}
- for (int j = i; j <= n - 1; j++) {
+ for (int j = i + 1; j < n; j++) {
a[j] += 1;
}
- for (int j = n - 1; j >= i; j--) {
+ for (int j = n - 1; j >= i + 1; j--) {
a[j] += 1;
}
}
@@ -802,8 +802,8 @@
linearTriangularOnTwoArrayLengths(10);
linearTriangularOnOneArrayLength(10);
linearTriangularOnParameter(10);
- linearTriangularVariationsInnerStrict(10);
- linearTriangularVariationsInnerNonStrict(10);
+ linearTriangularStrictLower(10);
+ linearTriangularStrictUpper(10);
{
int[] t = linearTriangularOOB();
for (int i = 0; i < 200; i++) {
diff --git a/test/530-checker-loops2/src/Main.java b/test/530-checker-loops2/src/Main.java
index b12fbd6..7acf008 100644
--- a/test/530-checker-loops2/src/Main.java
+++ b/test/530-checker-loops2/src/Main.java
@@ -31,7 +31,7 @@
//
/// CHECK-START: void Main.bubble(int[]) BCE (after)
/// CHECK-NOT: BoundsCheck
- // TODO: also CHECK-NOT: Deoptimize, see b/27151190
+ /// CHECK-NOT: Deoptimize
private static void bubble(int[] a) {
for (int i = a.length; --i >= 0;) {
for (int j = 0; j < i; j++) {
@@ -301,6 +301,53 @@
} while (-1 <= i);
}
+ /// CHECK-START: void Main.justRightTriangular1() BCE (before)
+ /// CHECK-DAG: BoundsCheck
+ //
+ /// CHECK-START: void Main.justRightTriangular1() BCE (after)
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK-NOT: Deoptimize
+ private static void justRightTriangular1() {
+ int[] a = { 1 } ;
+ for (int i = Integer.MIN_VALUE + 5; i <= Integer.MIN_VALUE + 10; i++) {
+ for (int j = Integer.MIN_VALUE + 4; j < i - 5; j++) {
+ sResult += a[j - (Integer.MIN_VALUE + 4)];
+ }
+ }
+ }
+
+ /// CHECK-START: void Main.justRightTriangular2() BCE (before)
+ /// CHECK-DAG: BoundsCheck
+ //
+ /// CHECK-START: void Main.justRightTriangular2() BCE (after)
+ /// CHECK-NOT: BoundsCheck
+ /// CHECK-NOT: Deoptimize
+ private static void justRightTriangular2() {
+ int[] a = { 1 } ;
+ for (int i = Integer.MIN_VALUE + 5; i <= 10; i++) {
+ for (int j = 4; j < i - 5; j++) {
+ sResult += a[j - 4];
+ }
+ }
+ }
+
+ /// CHECK-START: void Main.justOOBTriangular() BCE (before)
+ /// CHECK-DAG: BoundsCheck
+ //
+ /// CHECK-START: void Main.justOOBTriangular() BCE (after)
+ /// CHECK-DAG: Deoptimize
+ //
+ /// CHECK-START: void Main.justOOBTriangular() BCE (after)
+ /// CHECK-NOT: BoundsCheck
+ private static void justOOBTriangular() {
+ int[] a = { 1 } ;
+ for (int i = Integer.MIN_VALUE + 4; i <= 10; i++) {
+ for (int j = 4; j < i - 5; j++) {
+ sResult += a[j - 4];
+ }
+ }
+ }
+
/// CHECK-START: void Main.hiddenOOB1(int) BCE (before)
/// CHECK-DAG: BoundsCheck
//
@@ -315,7 +362,6 @@
// Dangerous loop where careless static range analysis would yield strict upper bound
// on index j of 5. When, for instance, lo and thus i = -2147483648, the upper bound
// becomes really positive due to arithmetic wrap-around, causing OOB.
- // Dynamic BCE is feasible though, since it checks the range.
for (int j = 4; j < i - 5; j++) {
sResult += a[j - 4];
}
@@ -336,13 +382,32 @@
// Dangerous loop where careless static range analysis would yield strict lower bound
// on index j of 5. When, for instance, hi and thus i = 2147483647, the upper bound
// becomes really negative due to arithmetic wrap-around, causing OOB.
- // Dynamic BCE is feasible though, since it checks the range.
for (int j = 6; j > i + 5; j--) {
sResult += a[j - 6];
}
}
}
+ /// CHECK-START: void Main.hiddenOOB3(int) BCE (before)
+ /// CHECK-DAG: BoundsCheck
+ //
+ /// CHECK-START: void Main.hiddenOOB3(int) BCE (after)
+ /// CHECK-DAG: Deoptimize
+ //
+ /// CHECK-START: void Main.hiddenOOB3(int) BCE (after)
+ /// CHECK-NOT: BoundsCheck
+ private static void hiddenOOB3(int hi) {
+ int[] a = { 11 } ;
+ for (int i = -1; i <= hi; i++) {
+ // Dangerous loop where careless static range analysis would yield strict lower bound
+ // on index j of 0. For large i, the initial value of j becomes really negative due
+ // to arithmetic wrap-around, causing OOB.
+ for (int j = i + 1; j < 1; j++) {
+ sResult += a[j];
+ }
+ }
+ }
+
/// CHECK-START: void Main.hiddenInfiniteOOB() BCE (before)
/// CHECK-DAG: BoundsCheck
//
@@ -376,7 +441,6 @@
for (int i = -1; i <= 0; i++) {
// Dangerous loop similar as above where the loop is now finite, but the
// loop still goes out of bounds for i = -1 due to the large upper bound.
- // Dynamic BCE is feasible though, since it checks the range.
for (int j = -4; j < 2147483646 * i - 3; j++) {
sResult += a[j + 4];
}
@@ -432,6 +496,25 @@
}
}
+ /// CHECK-START: int Main.doNotHoist(int[]) BCE (before)
+ /// CHECK-DAG: BoundsCheck
+ //
+ /// CHECK-START: int Main.doNotHoist(int[]) BCE (after)
+ /// CHECK-NOT: BoundsCheck
+ public static int doNotHoist(int[] a) {
+ int n = a.length;
+ int x = 0;
+ // BCE applies, but hoisting would crash the loop.
+ for (int i = -10000; i < 10000; i++) {
+ for (int j = 0; j <= 1; j++) {
+ if (0 <= i && i < n)
+ x += a[i];
+ }
+ }
+ return x;
+ }
+
+
/// CHECK-START: int[] Main.add() BCE (before)
/// CHECK-DAG: BoundsCheck
//
@@ -687,7 +770,7 @@
/// CHECK-START: int Main.dynamicBCEAndConstantIndices(int[], int[][], int, int) BCE (after)
// Order matters:
/// CHECK: Deoptimize loop:<<Loop:B\d+>>
- // CHECK-NOT: Goto loop:<<Loop>>
+ /// CHECK-NOT: Goto loop:<<Loop>>
/// CHECK-DAG: {{l\d+}} ArrayGet loop:<<Loop>>
/// CHECK-DAG: {{l\d+}} ArrayGet loop:<<Loop>>
/// CHECK-DAG: {{l\d+}} ArrayGet loop:<<Loop>>
@@ -839,6 +922,8 @@
expectEquals(55, justRightDown1());
expectEquals(55, justRightDown2());
expectEquals(55, justRightDown3());
+
+ // Large bounds OOB.
sResult = 0;
try {
justOOBUp();
@@ -890,6 +975,23 @@
}
expectEquals(1055, sResult);
+ // Triangular.
+ sResult = 0;
+ justRightTriangular1();
+ expectEquals(1, sResult);
+ if (HEAVY) {
+ sResult = 0;
+ justRightTriangular2();
+ expectEquals(1, sResult);
+ }
+ sResult = 0;
+ try {
+ justOOBTriangular();
+ } catch (ArrayIndexOutOfBoundsException e) {
+ sResult += 1000;
+ }
+ expectEquals(1001, sResult);
+
// Hidden OOB.
sResult = 0;
try {
@@ -912,6 +1014,15 @@
sResult += 1000;
}
expectEquals(1, sResult);
+ sResult = 0;
+ try {
+ hiddenOOB3(-1); // no OOB
+ } catch (ArrayIndexOutOfBoundsException e) {
+ sResult += 1000;
+ }
+ expectEquals(11, sResult);
+
+ // Expensive hidden OOB test.
if (HEAVY) {
sResult = 0;
try {
@@ -920,7 +1031,16 @@
sResult += 1000;
}
expectEquals(1002, sResult);
+ sResult = 0;
+ try {
+ hiddenOOB3(2147483647); // OOB
+ } catch (ArrayIndexOutOfBoundsException e) {
+ sResult += 1000;
+ }
+ expectEquals(1011, sResult);
}
+
+ // More hidden OOB.
sResult = 0;
try {
hiddenInfiniteOOB();
@@ -966,6 +1086,9 @@
expectEquals(i < 128 ? i : 0, a200[i]);
}
+ // No hoisting after BCE.
+ expectEquals(110, doNotHoist(x));
+
// Addition.
{
int[] e1 ={ 1, 2, 3, 4, 4, 4, 4, 3, 2, 1 };
diff --git a/test/537-checker-arraycopy/src/Main.java b/test/537-checker-arraycopy/src/Main.java
index 30ccc56..7c124ca 100644
--- a/test/537-checker-arraycopy/src/Main.java
+++ b/test/537-checker-arraycopy/src/Main.java
@@ -50,7 +50,7 @@
}
/// CHECK-START-X86_64: void Main.arraycopy() disassembly (after)
- /// CHECK: InvokeStaticOrDirect
+ /// CHECK: InvokeStaticOrDirect intrinsic:SystemArrayCopy
/// CHECK-NOT: test
/// CHECK-NOT: call
/// CHECK: ReturnVoid
@@ -65,7 +65,36 @@
System.arraycopy(obj, 1, obj, 0, 1);
}
+ // Test case for having enough registers on x86 for the arraycopy intrinsic.
+ /// CHECK-START-X86: void Main.arraycopy(java.lang.Object[], int) disassembly (after)
+ /// CHECK: InvokeStaticOrDirect intrinsic:SystemArrayCopy
+ /// CHECK-NOT: mov {{[a-z]+}}, [esp + {{[0-9]+}}]
+ /// CHECK: ReturnVoid
public static void arraycopy(Object[] obj, int pos) {
System.arraycopy(obj, pos, obj, 0, obj.length);
}
+
+ // Test case for having enough registers on x86 for the arraycopy intrinsic
+ // when an input is passed twice.
+ /// CHECK-START-X86: int Main.arraycopy2(java.lang.Object[], int) disassembly (after)
+ /// CHECK: InvokeStaticOrDirect intrinsic:SystemArrayCopy
+ /// CHECK-NOT: mov {{[a-z]+}}, [esp + {{[0-9]+}}]
+ /// CHECK: Return
+ public static int arraycopy2(Object[] obj, int pos) {
+ System.arraycopy(obj, pos, obj, pos - 1, obj.length);
+ return pos;
+ }
+
+ // Test case for not having enough registers on x86. The arraycopy intrinsic
+ // will ask for length to be in stack and load it.
+ /// CHECK-START-X86: int Main.arraycopy3(java.lang.Object[], java.lang.Object[], int, int, int) disassembly (after)
+ /// CHECK: InvokeStaticOrDirect intrinsic:SystemArrayCopy
+ /// CHECK: mov {{[a-z]+}}, [esp + {{[0-9]+}}]
+ /// CHECK: Return
+ public static int arraycopy3(Object[] obj1, Object[] obj2, int input1, int input3, int input4) {
+ System.arraycopy(obj1, input1, obj2, input3, input4);
+ System.out.println(obj1);
+ System.out.println(obj2);
+ return input1 + input3 + input4;
+ }
}
diff --git a/test/548-checker-inlining-and-dce/src/Main.java b/test/548-checker-inlining-and-dce/src/Main.java
index 38fdcc0..bf64c3b 100644
--- a/test/548-checker-inlining-and-dce/src/Main.java
+++ b/test/548-checker-inlining-and-dce/src/Main.java
@@ -16,17 +16,19 @@
public class Main {
+ static boolean doThrow = false;
+
private void inlinedForNull(Iterable it) {
if (it != null) {
- // We're not inlining invoke-interface at the moment.
- it.iterator();
+ // We're not inlining throw at the moment.
+ if (doThrow) { throw new Error(""); }
}
}
private void inlinedForFalse(boolean value, Iterable it) {
if (value) {
- // We're not inlining invoke-interface at the moment.
- it.iterator();
+ // We're not inlining throw at the moment.
+ if (doThrow) { throw new Error(""); }
}
}
diff --git a/test/600-verifier-fails/expected.txt b/test/600-verifier-fails/expected.txt
index 8399969..eaa0c93 100644
--- a/test/600-verifier-fails/expected.txt
+++ b/test/600-verifier-fails/expected.txt
@@ -2,3 +2,4 @@
passed B
passed C
passed D
+passed E
diff --git a/test/600-verifier-fails/src/Main.java b/test/600-verifier-fails/src/Main.java
index 64c3d5c..fa25d58 100644
--- a/test/600-verifier-fails/src/Main.java
+++ b/test/600-verifier-fails/src/Main.java
@@ -38,7 +38,6 @@
test("B");
test("C");
test("D");
- // TODO: enable again
- // test("E");
+ test("E");
}
}
diff --git a/test/609-checker-inline-interface/expected.txt b/test/609-checker-inline-interface/expected.txt
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/test/609-checker-inline-interface/expected.txt
diff --git a/test/609-checker-inline-interface/info.txt b/test/609-checker-inline-interface/info.txt
new file mode 100644
index 0000000..35eee08
--- /dev/null
+++ b/test/609-checker-inline-interface/info.txt
@@ -0,0 +1,2 @@
+Checker test that we inline interface calls and if we can't inline
+them, we can turn them into a virtual invoke.
diff --git a/test/609-checker-inline-interface/src/Main.java b/test/609-checker-inline-interface/src/Main.java
new file mode 100644
index 0000000..413f2dd
--- /dev/null
+++ b/test/609-checker-inline-interface/src/Main.java
@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+public final class Main implements Interface {
+
+ static void methodWithInvokeInterface(Interface interf) {
+ interf.doCall();
+ }
+
+ public void doCall() {
+ if (doThrow) throw new Error("");
+ }
+
+ public static void main(String[] args) {
+ testInlineInterfaceCall();
+ testInterfaceToVirtualCall();
+ }
+
+ /// CHECK-START: void Main.testInlineInterfaceCall() inliner (before)
+ /// CHECK: InvokeStaticOrDirect method_name:Main.methodWithInvokeInterface
+
+ /// CHECK-START: void Main.testInlineInterfaceCall() inliner (before)
+ /// CHECK-NOT: InvokeInterface
+
+ /// CHECK-START: void Main.testInlineInterfaceCall() inliner (after)
+ /// CHECK: InvokeInterface method_name:Interface.doCall
+
+ /// CHECK-START: void Main.testInlineInterfaceCall() inliner (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
+ public static void testInlineInterfaceCall() {
+ methodWithInvokeInterface(itf);
+ }
+
+ /// CHECK-START: void Main.testInterfaceToVirtualCall() inliner (before)
+ /// CHECK: InvokeStaticOrDirect method_name:Main.methodWithInvokeInterface
+
+ /// CHECK-START: void Main.testInterfaceToVirtualCall() inliner (before)
+ /// CHECK-NOT: InvokeInterface
+
+ /// CHECK-START: void Main.testInterfaceToVirtualCall() inliner (after)
+ /// CHECK: InvokeVirtual method_name:Main.doCall
+
+ /// CHECK-START: void Main.testInterfaceToVirtualCall() inliner (after)
+ /// CHECK-NOT: InvokeStaticOrDirect
+ /// CHECK-NOT: InvokeInterface
+ public static void testInterfaceToVirtualCall() {
+ methodWithInvokeInterface(m);
+ }
+
+ static Interface itf = new Main();
+ static Main m = new Main();
+ static boolean doThrow = false;
+}
+
+interface Interface {
+ public void doCall();
+}
diff --git a/test/610-arraycopy/expected.txt b/test/610-arraycopy/expected.txt
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/test/610-arraycopy/expected.txt
diff --git a/test/610-arraycopy/info.txt b/test/610-arraycopy/info.txt
new file mode 100644
index 0000000..a77190d
--- /dev/null
+++ b/test/610-arraycopy/info.txt
@@ -0,0 +1,2 @@
+Regression test for the System.arraycopy intrinsic, which had a bug
+when doing the copy on the same array.
diff --git a/test/610-arraycopy/src/Main.java b/test/610-arraycopy/src/Main.java
new file mode 100644
index 0000000..ee11c8e
--- /dev/null
+++ b/test/610-arraycopy/src/Main.java
@@ -0,0 +1,44 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+public class Main {
+ public static void main(String[] args) {
+ Object[] a = new Object[5];
+ for (int i = 0; i < 5; i++) {
+ a[i] = new Integer(i);
+ }
+ $noinline$callArrayCopy(a, a);
+
+ expectEquals(0, ((Integer)a[0]).intValue());
+ expectEquals(0, ((Integer)a[1]).intValue());
+ expectEquals(1, ((Integer)a[2]).intValue());
+ expectEquals(2, ((Integer)a[3]).intValue());
+ expectEquals(4, ((Integer)a[4]).intValue());
+ }
+
+ public static void expectEquals(int expected, int actual) {
+ if (expected != actual) {
+ throw new Error("Expected " + expected + ", got " + actual);
+ }
+ }
+
+ public static void $noinline$callArrayCopy(Object[] a, Object[] b) {
+ System.arraycopy(a, 0, b, 1, 3);
+ if (doThrow) { throw new Error(); }
+ }
+
+ static boolean doThrow = false;
+}
diff --git a/test/800-smali/expected.txt b/test/800-smali/expected.txt
index 11150c2..8473e06 100644
--- a/test/800-smali/expected.txt
+++ b/test/800-smali/expected.txt
@@ -67,4 +67,6 @@
b/27799205 (5)
b/27799205 (6)
b/28187158
+b/29778499 (1)
+b/29778499 (2)
Done!
diff --git a/test/800-smali/smali/b_29778499_1.smali b/test/800-smali/smali/b_29778499_1.smali
new file mode 100644
index 0000000..6cc0731
--- /dev/null
+++ b/test/800-smali/smali/b_29778499_1.smali
@@ -0,0 +1,19 @@
+.class public LB29778499_1;
+.super Ljava/lang/Object;
+
+# Test returning an object that doesn't implement the declared output interface.
+
+.method public static run()V
+.registers 2
+ invoke-static {}, LB29778499_1;->test()Ljava/lang/Runnable;
+ move-result-object v0
+ invoke-interface {v0}, Ljava/lang/Runnable;->run()V
+ return-void
+.end method
+
+.method public static test()Ljava/lang/Runnable;
+.registers 1
+ new-instance v0, LB29778499_1;
+ invoke-direct {v0}, LB29778499_1;-><init>()V
+ return-object v0
+.end method
diff --git a/test/800-smali/smali/b_29778499_2.smali b/test/800-smali/smali/b_29778499_2.smali
new file mode 100644
index 0000000..ad24d2f
--- /dev/null
+++ b/test/800-smali/smali/b_29778499_2.smali
@@ -0,0 +1,13 @@
+.class public LB29778499_2;
+.super Ljava/lang/Object;
+
+# Test invoking an interface method on an object that doesn't implement any interface.
+# This is testing an edge case (not implementing any interface) for b/18116999.
+
+.method public static run()V
+.registers 1
+ new-instance v0, Ljava/lang/Object;
+ invoke-direct {v0}, Ljava/lang/Object;-><init>()V
+ invoke-interface {v0}, Ljava/lang/Runnable;->run()V
+ return-void
+.end method
diff --git a/test/800-smali/src/Main.java b/test/800-smali/src/Main.java
index b2fc005..bf50879 100644
--- a/test/800-smali/src/Main.java
+++ b/test/800-smali/src/Main.java
@@ -176,6 +176,10 @@
testCases.add(new TestCase("b/27799205 (6)", "B27799205Helper", "run6", null, null, null));
testCases.add(new TestCase("b/28187158", "B28187158", "run", new Object[] { null },
new VerifyError(), null));
+ testCases.add(new TestCase("b/29778499 (1)", "B29778499_1", "run", null,
+ new IncompatibleClassChangeError(), null));
+ testCases.add(new TestCase("b/29778499 (2)", "B29778499_2", "run", null,
+ new IncompatibleClassChangeError(), null));
}
public void runTests() {
diff --git a/tools/ahat/Android.mk b/tools/ahat/Android.mk
index cfbafde..834426d 100644
--- a/tools/ahat/Android.mk
+++ b/tools/ahat/Android.mk
@@ -66,9 +66,10 @@
# Run ahat-test-dump.jar to generate test-dump.hprof
AHAT_TEST_DUMP_DEPENDENCIES := \
- $(ART_HOST_EXECUTABLES) \
- $(HOST_OUT_EXECUTABLES)/art \
- $(HOST_CORE_IMG_OUT_BASE)-optimizing-pic$(CORE_IMG_SUFFIX)
+ $(ART_HOST_EXECUTABLES) \
+ $(ART_HOST_SHARED_LIBRARY_DEPENDENCIES) \
+ $(HOST_OUT_EXECUTABLES)/art \
+ $(HOST_CORE_IMG_OUT_BASE)-optimizing-pic$(CORE_IMG_SUFFIX)
$(AHAT_TEST_DUMP_HPROF): PRIVATE_AHAT_TEST_ART := $(HOST_OUT_EXECUTABLES)/art
$(AHAT_TEST_DUMP_HPROF): PRIVATE_AHAT_TEST_DUMP_JAR := $(AHAT_TEST_DUMP_JAR)
diff --git a/tools/ahat/src/AhatSnapshot.java b/tools/ahat/src/AhatSnapshot.java
index d088e8c..e6f8411 100644
--- a/tools/ahat/src/AhatSnapshot.java
+++ b/tools/ahat/src/AhatSnapshot.java
@@ -16,6 +16,7 @@
package com.android.ahat;
+import com.android.tools.perflib.captures.MemoryMappedFileBuffer;
import com.android.tools.perflib.heap.ClassObj;
import com.android.tools.perflib.heap.Heap;
import com.android.tools.perflib.heap.Instance;
@@ -24,9 +25,11 @@
import com.android.tools.perflib.heap.Snapshot;
import com.android.tools.perflib.heap.StackFrame;
import com.android.tools.perflib.heap.StackTrace;
-import com.android.tools.perflib.captures.MemoryMappedFileBuffer;
+
import com.google.common.collect.Lists;
+
import gnu.trove.TObjectProcedure;
+
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
diff --git a/tools/ahat/src/InstanceUtils.java b/tools/ahat/src/InstanceUtils.java
index 8defba2..3cdb40c 100644
--- a/tools/ahat/src/InstanceUtils.java
+++ b/tools/ahat/src/InstanceUtils.java
@@ -19,9 +19,10 @@
import com.android.tools.perflib.heap.ArrayInstance;
import com.android.tools.perflib.heap.ClassInstance;
import com.android.tools.perflib.heap.ClassObj;
-import com.android.tools.perflib.heap.Instance;
import com.android.tools.perflib.heap.Heap;
+import com.android.tools.perflib.heap.Instance;
import com.android.tools.perflib.heap.Type;
+
import java.awt.image.BufferedImage;
/**
@@ -42,11 +43,11 @@
* Returns null if the instance is not a byte array.
*/
private static byte[] asByteArray(Instance inst) {
- if (! (inst instanceof ArrayInstance)) {
+ if (!(inst instanceof ArrayInstance)) {
return null;
}
- ArrayInstance array = (ArrayInstance)inst;
+ ArrayInstance array = (ArrayInstance) inst;
if (array.getArrayType() != Type.BYTE) {
return null;
}
@@ -54,7 +55,7 @@
Object[] objs = array.getValues();
byte[] bytes = new byte[objs.length];
for (int i = 0; i < objs.length; i++) {
- Byte b = (Byte)objs[i];
+ Byte b = (Byte) objs[i];
bytes[i] = b.byteValue();
}
return bytes;
@@ -143,10 +144,10 @@
int[] abgr = new int[height * width];
for (int i = 0; i < abgr.length; i++) {
abgr[i] = (
- (((int)buffer[i * 4 + 3] & 0xFF) << 24) +
- (((int)buffer[i * 4 + 0] & 0xFF) << 16) +
- (((int)buffer[i * 4 + 1] & 0xFF) << 8) +
- ((int)buffer[i * 4 + 2] & 0xFF));
+ (((int) buffer[i * 4 + 3] & 0xFF) << 24)
+ + (((int) buffer[i * 4 + 0] & 0xFF) << 16)
+ + (((int) buffer[i * 4 + 1] & 0xFF) << 8)
+ + ((int) buffer[i * 4 + 2] & 0xFF));
}
BufferedImage bitmap = new BufferedImage(
@@ -185,7 +186,7 @@
if (!(value instanceof Instance)) {
return null;
}
- return (Instance)value;
+ return (Instance) value;
}
/**
@@ -199,7 +200,7 @@
if (!(value instanceof Integer)) {
return def;
}
- return (Integer)value;
+ return (Integer) value;
}
/**
@@ -213,7 +214,7 @@
if (!(value instanceof Long)) {
return def;
}
- return (Long)value;
+ return (Long) value;
}
/**
@@ -226,7 +227,7 @@
if (!(value instanceof Instance)) {
return null;
}
- return asByteArray((Instance)value);
+ return asByteArray((Instance) value);
}
// Return the bitmap instance associated with this object, or null if there
@@ -243,7 +244,7 @@
}
if (inst instanceof ArrayInstance) {
- ArrayInstance array = (ArrayInstance)inst;
+ ArrayInstance array = (ArrayInstance) inst;
if (array.getArrayType() == Type.BYTE && inst.getHardReverseReferences().size() == 1) {
Instance ref = inst.getHardReverseReferences().get(0);
ClassObj clsref = ref.getClassObj();
@@ -323,10 +324,10 @@
// Note: We know inst as an instance of ClassInstance because we already
// read the nativePtr field from it.
Instance registry = null;
- for (ClassInstance.FieldValue field : ((ClassInstance)inst).getValues()) {
+ for (ClassInstance.FieldValue field : ((ClassInstance) inst).getValues()) {
Object fieldValue = field.getValue();
if (fieldValue instanceof Instance) {
- Instance fieldInst = (Instance)fieldValue;
+ Instance fieldInst = (Instance) fieldValue;
if (isInstanceOfClass(fieldInst, "libcore.util.NativeAllocationRegistry")) {
registry = fieldInst;
break;
diff --git a/tools/ahat/src/Site.java b/tools/ahat/src/Site.java
index d504096..dbb84f6 100644
--- a/tools/ahat/src/Site.java
+++ b/tools/ahat/src/Site.java
@@ -20,6 +20,7 @@
import com.android.tools.perflib.heap.Heap;
import com.android.tools.perflib.heap.Instance;
import com.android.tools.perflib.heap.StackFrame;
+
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
diff --git a/tools/ahat/src/Sort.java b/tools/ahat/src/Sort.java
index c5f89c3..8a3d9f2 100644
--- a/tools/ahat/src/Sort.java
+++ b/tools/ahat/src/Sort.java
@@ -16,13 +16,14 @@
package com.android.ahat;
-import com.android.tools.perflib.heap.Instance;
import com.android.tools.perflib.heap.Heap;
+import com.android.tools.perflib.heap.Instance;
+
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
-import java.util.List;
import java.util.Iterator;
+import java.util.List;
/**
* Provides Comparators and helper functions for sorting Instances, Sites, and