Merge "signal_catcher: track tombstoned API changes."
diff --git a/build/Android.gtest.mk b/build/Android.gtest.mk
index 0a465c4..bcf48fd 100644
--- a/build/Android.gtest.mk
+++ b/build/Android.gtest.mk
@@ -40,6 +40,7 @@
Interfaces \
Lookup \
Main \
+ ManyMethods \
MethodTypes \
MultiDex \
MultiDexModifiedSecondary \
@@ -103,6 +104,7 @@
ART_GTEST_compiler_driver_test_DEX_DEPS := AbstractMethod StaticLeafMethods ProfileTestMultiDex
ART_GTEST_dex_cache_test_DEX_DEPS := Main Packages MethodTypes
ART_GTEST_dex_file_test_DEX_DEPS := GetMethodSignature Main Nested MultiDex
+ART_GTEST_dexlayout_test_DEX_DEPS := ManyMethods
ART_GTEST_dex2oat_test_DEX_DEPS := $(ART_GTEST_dex2oat_environment_tests_DEX_DEPS) Statics VerifierDeps
ART_GTEST_exception_test_DEX_DEPS := ExceptionHandle
ART_GTEST_image_test_DEX_DEPS := ImageLayoutA ImageLayoutB DefaultMethods
diff --git a/cmdline/cmdline_parser_test.cc b/cmdline/cmdline_parser_test.cc
index 1a2b9cd..9f12f64 100644
--- a/cmdline/cmdline_parser_test.cc
+++ b/cmdline/cmdline_parser_test.cc
@@ -22,6 +22,7 @@
#include <numeric>
#include "gtest/gtest.h"
#include "runtime/experimental_flags.h"
+#include "runtime/runtime.h"
#define EXPECT_NULL(expected) EXPECT_EQ(reinterpret_cast<const void*>(expected), \
reinterpret_cast<void*>(nullptr));
diff --git a/cmdline/cmdline_types.h b/cmdline/cmdline_types.h
index e33a207..0d2aed8 100644
--- a/cmdline/cmdline_types.h
+++ b/cmdline/cmdline_types.h
@@ -18,6 +18,8 @@
#define CMDLINE_NDEBUG 1 // Do not output any debugging information for parsing.
+#include <list>
+
#include "memory_representation.h"
#include "detail/cmdline_debug_detail.h"
#include "cmdline_type_parser.h"
diff --git a/compiler/compiler.h b/compiler/compiler.h
index 908d366..cd4c591 100644
--- a/compiler/compiler.h
+++ b/compiler/compiler.h
@@ -25,11 +25,11 @@
namespace jit {
class JitCodeCache;
-}
+} // namespace jit
namespace mirror {
class ClassLoader;
class DexCache;
-}
+} // namespace mirror
class ArtMethod;
class CompilerDriver;
diff --git a/compiler/debug/elf_debug_loc_writer.h b/compiler/debug/elf_debug_loc_writer.h
index cbfdbdd..bf47e8f 100644
--- a/compiler/debug/elf_debug_loc_writer.h
+++ b/compiler/debug/elf_debug_loc_writer.h
@@ -85,7 +85,7 @@
// The result will cover all ranges where the variable is in scope.
// PCs corresponding to stackmap with dex register map are accurate,
// all other PCs are best-effort only.
-std::vector<VariableLocation> GetVariableLocations(
+static std::vector<VariableLocation> GetVariableLocations(
const MethodDebugInfo* method_info,
const std::vector<DexRegisterMap>& dex_register_maps,
uint16_t vreg,
diff --git a/compiler/debug/elf_debug_writer.h b/compiler/debug/elf_debug_writer.h
index 07f7229..5d68810 100644
--- a/compiler/debug/elf_debug_writer.h
+++ b/compiler/debug/elf_debug_writer.h
@@ -29,7 +29,7 @@
class OatHeader;
namespace mirror {
class Class;
-}
+} // namespace mirror
namespace debug {
struct MethodDebugInfo;
diff --git a/compiler/driver/compiler_driver-inl.h b/compiler/driver/compiler_driver-inl.h
index 5823306..8cc1cc3 100644
--- a/compiler/driver/compiler_driver-inl.h
+++ b/compiler/driver/compiler_driver-inl.h
@@ -24,10 +24,11 @@
#include "base/enums.h"
#include "class_linker-inl.h"
#include "dex_compilation_unit.h"
+#include "handle_scope-inl.h"
#include "mirror/class_loader.h"
#include "mirror/dex_cache-inl.h"
+#include "runtime.h"
#include "scoped_thread_state_change-inl.h"
-#include "handle_scope-inl.h"
namespace art {
@@ -149,6 +150,11 @@
return resolved_method;
}
+inline VerificationResults* CompilerDriver::GetVerificationResults() const {
+ DCHECK(Runtime::Current()->IsAotCompiler());
+ return verification_results_;
+}
+
} // namespace art
#endif // ART_COMPILER_DRIVER_COMPILER_DRIVER_INL_H_
diff --git a/compiler/driver/compiler_driver.h b/compiler/driver/compiler_driver.h
index e0d97b7..17c20b4 100644
--- a/compiler/driver/compiler_driver.h
+++ b/compiler/driver/compiler_driver.h
@@ -38,7 +38,6 @@
#include "method_reference.h"
#include "mirror/class.h" // For mirror::Class::Status.
#include "os.h"
-#include "runtime.h"
#include "safe_map.h"
#include "thread_pool.h"
#include "utils/atomic_method_ref_map.h"
@@ -61,6 +60,7 @@
class DexCompilationUnit;
struct InlineIGetIPutData;
class InstructionSetFeatures;
+class InternTable;
class ParallelCompilationManager;
class ScopedObjectAccess;
template <class Allocator> class SrcMap;
@@ -131,10 +131,7 @@
REQUIRES_SHARED(Locks::mutator_lock_)
REQUIRES(!compiled_classes_lock_, !dex_to_dex_references_lock_);
- VerificationResults* GetVerificationResults() const {
- DCHECK(Runtime::Current()->IsAotCompiler());
- return verification_results_;
- }
+ VerificationResults* GetVerificationResults() const;
InstructionSet GetInstructionSet() const {
return instruction_set_;
diff --git a/compiler/driver/compiler_options.h b/compiler/driver/compiler_options.h
index 5a82021..89c2537 100644
--- a/compiler/driver/compiler_options.h
+++ b/compiler/driver/compiler_options.h
@@ -31,7 +31,7 @@
namespace verifier {
class VerifierDepsTest;
-}
+} // namespace verifier
class DexFile;
diff --git a/compiler/oat_writer.cc b/compiler/oat_writer.cc
index bc411df..fed2d34 100644
--- a/compiler/oat_writer.cc
+++ b/compiler/oat_writer.cc
@@ -33,7 +33,7 @@
#include "dex/verification_results.h"
#include "dex_file-inl.h"
#include "dexlayout.h"
-#include "driver/compiler_driver.h"
+#include "driver/compiler_driver-inl.h"
#include "driver/compiler_options.h"
#include "gc/space/image_space.h"
#include "gc/space/space.h"
diff --git a/compiler/optimizing/intrinsics_arm64.h b/compiler/optimizing/intrinsics_arm64.h
index 3c53517..ff59ce9 100644
--- a/compiler/optimizing/intrinsics_arm64.h
+++ b/compiler/optimizing/intrinsics_arm64.h
@@ -24,7 +24,8 @@
class MacroAssembler;
-}} // namespace vixl::aarch64
+} // namespace aarch64
+} // namespace vixl
namespace art {
diff --git a/compiler/utils/label.h b/compiler/utils/label.h
index 0f82ad5..4c6ae8e 100644
--- a/compiler/utils/label.h
+++ b/compiler/utils/label.h
@@ -29,24 +29,24 @@
namespace arm {
class ArmAssembler;
class Thumb2Assembler;
-}
+} // namespace arm
namespace arm64 {
class Arm64Assembler;
-}
+} // namespace arm64
namespace mips {
class MipsAssembler;
-}
+} // namespace mips
namespace mips64 {
class Mips64Assembler;
-}
+} // namespace mips64
namespace x86 {
class X86Assembler;
class NearLabel;
-}
+} // namespace x86
namespace x86_64 {
class X86_64Assembler;
class NearLabel;
-}
+} // namespace x86_64
class ExternalLabel {
public:
diff --git a/compiler/utils/managed_register.h b/compiler/utils/managed_register.h
index 184cdf5..2b7b2aa 100644
--- a/compiler/utils/managed_register.h
+++ b/compiler/utils/managed_register.h
@@ -26,24 +26,24 @@
namespace arm {
class ArmManagedRegister;
-}
+} // namespace arm
namespace arm64 {
class Arm64ManagedRegister;
-}
+} // namespace arm64
namespace mips {
class MipsManagedRegister;
-}
+} // namespace mips
namespace mips64 {
class Mips64ManagedRegister;
-}
+} // namespace mips64
namespace x86 {
class X86ManagedRegister;
-}
+} // namespace x86
namespace x86_64 {
class X86_64ManagedRegister;
-}
+} // namespace x86_64
class ManagedRegister : public ValueObject {
public:
diff --git a/compiler/verifier_deps_test.cc b/compiler/verifier_deps_test.cc
index 4d55eb0..dd09fed 100644
--- a/compiler/verifier_deps_test.cc
+++ b/compiler/verifier_deps_test.cc
@@ -25,8 +25,8 @@
#include "dex/verified_method.h"
#include "dex_file.h"
#include "dex_file_types.h"
+#include "driver/compiler_driver-inl.h"
#include "driver/compiler_options.h"
-#include "driver/compiler_driver.h"
#include "handle_scope-inl.h"
#include "indenter.h"
#include "mirror/class_loader.h"
diff --git a/dex2oat/include/dex2oat_return_codes.h b/dex2oat/include/dex2oat_return_codes.h
index cc5400f..ad09d47 100644
--- a/dex2oat/include/dex2oat_return_codes.h
+++ b/dex2oat/include/dex2oat_return_codes.h
@@ -21,9 +21,10 @@
namespace dex2oat {
enum class ReturnCode : int {
- kNoFailure = 0,
- kOther = 1,
- kCreateRuntime = 2,
+ kNoFailure = 0, // No failure, execution completed successfully.
+ kOther = 1, // Some other not closer specified error occurred.
+ kCreateRuntime = 2, // Dex2oat failed creating a runtime. This may be indicative
+ // of a missing or out of date boot image, for example.
};
} // namespace dex2oat
diff --git a/dexlayout/dexlayout_test.cc b/dexlayout/dexlayout_test.cc
index a0533f2..1d09a7f 100644
--- a/dexlayout/dexlayout_test.cc
+++ b/dexlayout/dexlayout_test.cc
@@ -23,7 +23,9 @@
#include "base/unix_file/fd_file.h"
#include "common_runtime_test.h"
+#include "dex_file-inl.h"
#include "exec_utils.h"
+#include "jit/profile_compilation_info.h"
#include "utils.h"
namespace art {
@@ -40,9 +42,6 @@
"qAAAAAYAAAACAAAAwAAAAAEgAAACAAAAAAEAAAIgAAAHAAAAMAEAAAMgAAACAAAAaQEAAAAgAAAC"
"AAAAdQEAAAAQAAABAAAAjAEAAA==";
-static const char kDexFileLayoutInputProfile[] =
- "cHJvADAwNwAAAAAAAAgAAAB4AQMAAAAAAQ==";
-
// Dex file with catch handler unreferenced by try blocks.
// Constructed by building a dex file with try/catch blocks and hex editing.
static const char kUnreferencedCatchHandlerInputDex[] =
@@ -317,6 +316,56 @@
return true;
}
+ // Create a profile with some subset of methods and classes.
+ void CreateProfile(const std::string& input_dex,
+ const std::string& out_profile,
+ const std::string& dex_location) {
+ std::vector<std::unique_ptr<const DexFile>> dex_files;
+ std::string error_msg;
+ bool result = DexFile::Open(input_dex.c_str(),
+ input_dex,
+ false,
+ &error_msg,
+ &dex_files);
+
+ ASSERT_TRUE(result) << error_msg;
+ ASSERT_GE(dex_files.size(), 1u);
+
+ size_t profile_methods = 0;
+ size_t profile_classes = 0;
+ ProfileCompilationInfo pfi;
+ std::vector<ProfileMethodInfo> pmis;
+ std::set<DexCacheResolvedClasses> classes;
+ for (const std::unique_ptr<const DexFile>& dex_file : dex_files) {
+ for (uint32_t i = 0; i < dex_file->NumMethodIds(); i += 2) {
+ if ((i & 3) != 0) {
+ pfi.AddMethodIndex(dex_location,
+ dex_file->GetLocationChecksum(),
+ i);
+ ++profile_methods;
+ }
+ }
+ DexCacheResolvedClasses cur_classes(dex_location,
+ dex_location,
+ dex_file->GetLocationChecksum());
+ // Add every even class too.
+ for (uint32_t i = 0; i < dex_file->NumClassDefs(); i += 1) {
+ cur_classes.AddClass(dex_file->GetClassDef(i).class_idx_);
+ ++profile_classes;
+ }
+ }
+ pfi.AddMethodsAndClasses(pmis, classes);
+ // Write to provided file.
+ std::unique_ptr<File> file(OS::CreateEmptyFile(out_profile.c_str()));
+ ASSERT_TRUE(file != nullptr);
+ pfi.Save(file->Fd());
+ if (file->FlushCloseOrErase() != 0) {
+ PLOG(FATAL) << "Could not flush and close test file.";
+ }
+ EXPECT_GE(profile_methods, 0u);
+ EXPECT_GE(profile_classes, 0u);
+ }
+
// Runs DexFileLayout test.
bool DexFileLayoutExec(std::string* error_msg) {
ScratchFile tmp_file;
@@ -328,7 +377,8 @@
std::string dex_file = tmp_dir + "classes.dex";
WriteFileBase64(kDexFileLayoutInputDex, dex_file.c_str());
std::string profile_file = tmp_dir + "primary.prof";
- WriteFileBase64(kDexFileLayoutInputProfile, profile_file.c_str());
+ CreateProfile(dex_file, profile_file, dex_file);
+ // WriteFileBase64(kDexFileLayoutInputProfile, profile_file.c_str());
std::string output_dex = tmp_dir + "classes.dex.new";
std::string dexlayout = GetTestAndroidRoot() + "/bin/dexlayout";
@@ -358,11 +408,24 @@
size_t tmp_last_slash = tmp_name.rfind("/");
std::string tmp_dir = tmp_name.substr(0, tmp_last_slash + 1);
- // Write inputs and expected outputs.
+ // Unzip the test dex file to the classes.dex destination. It is required to unzip since
+ // opening from jar recalculates the dex location checksum.
std::string dex_file = tmp_dir + "classes.dex";
- WriteFileBase64(kDexFileLayoutInputDex, dex_file.c_str());
+
+ std::vector<std::string> unzip_args = {
+ "/usr/bin/unzip",
+ GetTestDexFileName("ManyMethods"),
+ "classes.dex",
+ "-d",
+ tmp_dir,
+ };
+ if (!art::Exec(unzip_args, error_msg)) {
+ LOG(ERROR) << "Failed to unzip dex";
+ return false;
+ }
+
std::string profile_file = tmp_dir + "primary.prof";
- WriteFileBase64(kDexFileLayoutInputProfile, profile_file.c_str());
+ CreateProfile(dex_file, profile_file, dex_file);
std::string output_dex = tmp_dir + "classes.dex.new";
std::string second_output_dex = tmp_dir + "classes.dex.new.new";
@@ -371,14 +434,19 @@
// -v makes sure that the layout did not corrupt the dex file.
std::vector<std::string> dexlayout_exec_argv =
- { dexlayout, "-v", "-w", tmp_dir, "-o", tmp_name, "-p", profile_file, dex_file };
+ { dexlayout, "-i", "-v", "-w", tmp_dir, "-o", tmp_name, "-p", profile_file, dex_file };
if (!::art::Exec(dexlayout_exec_argv, error_msg)) {
return false;
}
+ // Recreate the profile with the new dex location. This is required so that the profile dex
+ // location matches.
+ CreateProfile(dex_file, profile_file, output_dex);
+
// -v makes sure that the layout did not corrupt the dex file.
+ // -i since the checksum won't match from the first layout.
std::vector<std::string> second_dexlayout_exec_argv =
- { dexlayout, "-v", "-w", tmp_dir, "-o", tmp_name, "-p", profile_file, output_dex };
+ { dexlayout, "-i", "-v", "-w", tmp_dir, "-o", tmp_name, "-p", profile_file, output_dex };
if (!::art::Exec(second_dexlayout_exec_argv, error_msg)) {
return false;
}
@@ -436,13 +504,11 @@
bool DexLayoutExec(ScratchFile* dex_file,
const char* dex_filename,
ScratchFile* profile_file,
- const char* profile_filename,
std::vector<std::string>& dexlayout_exec_argv) {
WriteBase64ToFile(dex_filename, dex_file->GetFile());
EXPECT_EQ(dex_file->GetFile()->Flush(), 0);
if (profile_file != nullptr) {
- WriteBase64ToFile(profile_filename, profile_file->GetFile());
- EXPECT_EQ(profile_file->GetFile()->Flush(), 0);
+ CreateProfile(dex_file->GetFilename(), profile_file->GetFilename(), dex_file->GetFilename());
}
std::string error_msg;
const bool result = ::art::Exec(dexlayout_exec_argv, &error_msg);
@@ -516,7 +582,6 @@
ASSERT_TRUE(DexLayoutExec(&temp_dex,
kDexFileDuplicateOffset,
nullptr /* profile_file */,
- nullptr /* profile_filename */,
dexlayout_exec_argv));
}
@@ -529,7 +594,6 @@
ASSERT_TRUE(DexLayoutExec(&temp_dex,
kNullSetRefListElementInputDex,
nullptr /* profile_file */,
- nullptr /* profile_filename */,
dexlayout_exec_argv));
}
@@ -543,7 +607,6 @@
ASSERT_TRUE(DexLayoutExec(&temp_dex,
kMultiClassDataInputDex,
&temp_profile,
- kDexFileLayoutInputProfile,
dexlayout_exec_argv));
}
@@ -557,7 +620,6 @@
ASSERT_TRUE(DexLayoutExec(&temp_dex,
kUnalignedCodeInfoInputDex,
&temp_profile,
- kDexFileLayoutInputProfile,
dexlayout_exec_argv));
}
@@ -571,7 +633,6 @@
ASSERT_TRUE(DexLayoutExec(&temp_dex,
kClassDataBeforeCodeInputDex,
&temp_profile,
- kDexFileLayoutInputProfile,
dexlayout_exec_argv));
}
@@ -584,7 +645,6 @@
ASSERT_TRUE(DexLayoutExec(&temp_dex,
kUnknownTypeDebugInfoInputDex,
nullptr /* profile_file */,
- nullptr /* profile_filename */,
dexlayout_exec_argv));
}
@@ -597,7 +657,6 @@
ASSERT_TRUE(DexLayoutExec(&temp_dex,
kDuplicateCodeItemInputDex,
nullptr /* profile_file */,
- nullptr /* profile_filename */,
dexlayout_exec_argv));
}
diff --git a/runtime/arch/instruction_set_features.cc b/runtime/arch/instruction_set_features.cc
index 00d22c4..43c1711 100644
--- a/runtime/arch/instruction_set_features.cc
+++ b/runtime/arch/instruction_set_features.cc
@@ -33,33 +33,26 @@
std::unique_ptr<const InstructionSetFeatures> InstructionSetFeatures::FromVariant(
InstructionSet isa, const std::string& variant, std::string* error_msg) {
- std::unique_ptr<const InstructionSetFeatures> result;
switch (isa) {
case kArm:
case kThumb2:
- result.reset(ArmInstructionSetFeatures::FromVariant(variant, error_msg).release());
- break;
+ return ArmInstructionSetFeatures::FromVariant(variant, error_msg);
case kArm64:
- result.reset(Arm64InstructionSetFeatures::FromVariant(variant, error_msg).release());
- break;
+ return Arm64InstructionSetFeatures::FromVariant(variant, error_msg);
case kMips:
- result.reset(MipsInstructionSetFeatures::FromVariant(variant, error_msg).release());
- break;
+ return MipsInstructionSetFeatures::FromVariant(variant, error_msg);
case kMips64:
- result = Mips64InstructionSetFeatures::FromVariant(variant, error_msg);
- break;
+ return Mips64InstructionSetFeatures::FromVariant(variant, error_msg);
case kX86:
- result.reset(X86InstructionSetFeatures::FromVariant(variant, error_msg).release());
- break;
+ return X86InstructionSetFeatures::FromVariant(variant, error_msg);
case kX86_64:
- result.reset(X86_64InstructionSetFeatures::FromVariant(variant, error_msg).release());
+ return X86_64InstructionSetFeatures::FromVariant(variant, error_msg);
+
+ case kNone:
break;
- default:
- UNIMPLEMENTED(FATAL) << isa;
- UNREACHABLE();
}
- CHECK_EQ(result == nullptr, error_msg->size() != 0);
- return result;
+ UNIMPLEMENTED(FATAL) << isa;
+ UNREACHABLE();
}
std::unique_ptr<const InstructionSetFeatures> InstructionSetFeatures::FromBitmap(InstructionSet isa,
@@ -68,23 +61,25 @@
switch (isa) {
case kArm:
case kThumb2:
- result.reset(ArmInstructionSetFeatures::FromBitmap(bitmap).release());
+ result = ArmInstructionSetFeatures::FromBitmap(bitmap);
break;
case kArm64:
- result.reset(Arm64InstructionSetFeatures::FromBitmap(bitmap).release());
+ result = Arm64InstructionSetFeatures::FromBitmap(bitmap);
break;
case kMips:
- result.reset(MipsInstructionSetFeatures::FromBitmap(bitmap).release());
+ result = MipsInstructionSetFeatures::FromBitmap(bitmap);
break;
case kMips64:
result = Mips64InstructionSetFeatures::FromBitmap(bitmap);
break;
case kX86:
- result.reset(X86InstructionSetFeatures::FromBitmap(bitmap).release());
+ result = X86InstructionSetFeatures::FromBitmap(bitmap);
break;
case kX86_64:
- result.reset(X86_64InstructionSetFeatures::FromBitmap(bitmap).release());
+ result = X86_64InstructionSetFeatures::FromBitmap(bitmap);
break;
+
+ case kNone:
default:
UNIMPLEMENTED(FATAL) << isa;
UNREACHABLE();
@@ -94,120 +89,96 @@
}
std::unique_ptr<const InstructionSetFeatures> InstructionSetFeatures::FromCppDefines() {
- std::unique_ptr<const InstructionSetFeatures> result;
switch (kRuntimeISA) {
case kArm:
case kThumb2:
- result.reset(ArmInstructionSetFeatures::FromCppDefines().release());
- break;
+ return ArmInstructionSetFeatures::FromCppDefines();
case kArm64:
- result.reset(Arm64InstructionSetFeatures::FromCppDefines().release());
- break;
+ return Arm64InstructionSetFeatures::FromCppDefines();
case kMips:
- result.reset(MipsInstructionSetFeatures::FromCppDefines().release());
- break;
+ return MipsInstructionSetFeatures::FromCppDefines();
case kMips64:
- result = Mips64InstructionSetFeatures::FromCppDefines();
- break;
+ return Mips64InstructionSetFeatures::FromCppDefines();
case kX86:
- result.reset(X86InstructionSetFeatures::FromCppDefines().release());
- break;
+ return X86InstructionSetFeatures::FromCppDefines();
case kX86_64:
- result.reset(X86_64InstructionSetFeatures::FromCppDefines().release());
+ return X86_64InstructionSetFeatures::FromCppDefines();
+
+ case kNone:
break;
- default:
- UNIMPLEMENTED(FATAL) << kRuntimeISA;
- UNREACHABLE();
}
- return result;
+ UNIMPLEMENTED(FATAL) << kRuntimeISA;
+ UNREACHABLE();
}
std::unique_ptr<const InstructionSetFeatures> InstructionSetFeatures::FromCpuInfo() {
- std::unique_ptr<const InstructionSetFeatures> result;
switch (kRuntimeISA) {
case kArm:
case kThumb2:
- result.reset(ArmInstructionSetFeatures::FromCpuInfo().release());
- break;
+ return ArmInstructionSetFeatures::FromCpuInfo();
case kArm64:
- result.reset(Arm64InstructionSetFeatures::FromCpuInfo().release());
- break;
+ return Arm64InstructionSetFeatures::FromCpuInfo();
case kMips:
- result.reset(MipsInstructionSetFeatures::FromCpuInfo().release());
- break;
+ return MipsInstructionSetFeatures::FromCpuInfo();
case kMips64:
- result = Mips64InstructionSetFeatures::FromCpuInfo();
- break;
+ return Mips64InstructionSetFeatures::FromCpuInfo();
case kX86:
- result.reset(X86InstructionSetFeatures::FromCpuInfo().release());
- break;
+ return X86InstructionSetFeatures::FromCpuInfo();
case kX86_64:
- result.reset(X86_64InstructionSetFeatures::FromCpuInfo().release());
+ return X86_64InstructionSetFeatures::FromCpuInfo();
+
+ case kNone:
break;
- default:
- UNIMPLEMENTED(FATAL) << kRuntimeISA;
- UNREACHABLE();
}
- return result;
+ UNIMPLEMENTED(FATAL) << kRuntimeISA;
+ UNREACHABLE();
}
std::unique_ptr<const InstructionSetFeatures> InstructionSetFeatures::FromHwcap() {
- std::unique_ptr<const InstructionSetFeatures> result;
switch (kRuntimeISA) {
case kArm:
case kThumb2:
- result.reset(ArmInstructionSetFeatures::FromHwcap().release());
- break;
+ return ArmInstructionSetFeatures::FromHwcap();
case kArm64:
- result.reset(Arm64InstructionSetFeatures::FromHwcap().release());
- break;
+ return Arm64InstructionSetFeatures::FromHwcap();
case kMips:
- result.reset(MipsInstructionSetFeatures::FromHwcap().release());
- break;
+ return MipsInstructionSetFeatures::FromHwcap();
case kMips64:
- result = Mips64InstructionSetFeatures::FromHwcap();
- break;
+ return Mips64InstructionSetFeatures::FromHwcap();
case kX86:
- result.reset(X86InstructionSetFeatures::FromHwcap().release());
- break;
+ return X86InstructionSetFeatures::FromHwcap();
case kX86_64:
- result.reset(X86_64InstructionSetFeatures::FromHwcap().release());
+ return X86_64InstructionSetFeatures::FromHwcap();
+
+ case kNone:
break;
- default:
- UNIMPLEMENTED(FATAL) << kRuntimeISA;
- UNREACHABLE();
}
- return result;
+ UNIMPLEMENTED(FATAL) << kRuntimeISA;
+ UNREACHABLE();
}
std::unique_ptr<const InstructionSetFeatures> InstructionSetFeatures::FromAssembly() {
- std::unique_ptr<const InstructionSetFeatures> result;
switch (kRuntimeISA) {
case kArm:
case kThumb2:
- result.reset(ArmInstructionSetFeatures::FromAssembly().release());
- break;
+ return ArmInstructionSetFeatures::FromAssembly();
case kArm64:
- result.reset(Arm64InstructionSetFeatures::FromAssembly().release());
- break;
+ return Arm64InstructionSetFeatures::FromAssembly();
case kMips:
- result.reset(MipsInstructionSetFeatures::FromAssembly().release());
- break;
+ return MipsInstructionSetFeatures::FromAssembly();
case kMips64:
- result = Mips64InstructionSetFeatures::FromAssembly();
- break;
+ return Mips64InstructionSetFeatures::FromAssembly();
case kX86:
- result.reset(X86InstructionSetFeatures::FromAssembly().release());
- break;
+ return X86InstructionSetFeatures::FromAssembly();
case kX86_64:
- result.reset(X86_64InstructionSetFeatures::FromAssembly().release());
+ return X86_64InstructionSetFeatures::FromAssembly();
+
+ case kNone:
break;
- default:
- UNIMPLEMENTED(FATAL) << kRuntimeISA;
- UNREACHABLE();
}
- return result;
+ UNIMPLEMENTED(FATAL) << kRuntimeISA;
+ UNREACHABLE();
}
std::unique_ptr<const InstructionSetFeatures> InstructionSetFeatures::AddFeaturesFromString(
diff --git a/runtime/arch/memcmp16.cc b/runtime/arch/memcmp16.cc
index 813df2f..e714cfc 100644
--- a/runtime/arch/memcmp16.cc
+++ b/runtime/arch/memcmp16.cc
@@ -37,7 +37,7 @@
return MemCmp16(s0, s1, count);
}
-}
+} // namespace testing
} // namespace art
diff --git a/runtime/arch/memcmp16.h b/runtime/arch/memcmp16.h
index c449a14..b051a1c 100644
--- a/runtime/arch/memcmp16.h
+++ b/runtime/arch/memcmp16.h
@@ -59,7 +59,7 @@
// implementation.
int32_t MemCmp16Testing(const uint16_t* s0, const uint16_t* s1, size_t count);
-}
+} // namespace testing
} // namespace art
diff --git a/runtime/class_linker.cc b/runtime/class_linker.cc
index 694c113..cffdfd3 100644
--- a/runtime/class_linker.cc
+++ b/runtime/class_linker.cc
@@ -352,7 +352,8 @@
}
ClassLinker::ClassLinker(InternTable* intern_table)
- : failed_dex_cache_class_lookups_(0),
+ : boot_class_table_(new ClassTable()),
+ failed_dex_cache_class_lookups_(0),
class_roots_(nullptr),
array_iftable_(nullptr),
find_array_class_cache_next_victim_(0),
@@ -1222,15 +1223,36 @@
}
}
-bool ClassLinker::UpdateAppImageClassLoadersAndDexCaches(
+// new_class_set is the set of classes that were read from the class table section in the image.
+// If there was no class table section, it is null.
+// Note: using a class here to avoid having to make ClassLinker internals public.
+class AppImageClassLoadersAndDexCachesHelper {
+ public:
+ static bool Update(
+ ClassLinker* class_linker,
+ gc::space::ImageSpace* space,
+ Handle<mirror::ClassLoader> class_loader,
+ Handle<mirror::ObjectArray<mirror::DexCache>> dex_caches,
+ ClassTable::ClassSet* new_class_set,
+ bool* out_forward_dex_cache_array,
+ std::string* out_error_msg)
+ REQUIRES(!Locks::dex_lock_)
+ REQUIRES_SHARED(Locks::mutator_lock_);
+};
+
+bool AppImageClassLoadersAndDexCachesHelper::Update(
+ ClassLinker* class_linker,
gc::space::ImageSpace* space,
Handle<mirror::ClassLoader> class_loader,
Handle<mirror::ObjectArray<mirror::DexCache>> dex_caches,
ClassTable::ClassSet* new_class_set,
bool* out_forward_dex_cache_array,
- std::string* out_error_msg) {
+ std::string* out_error_msg)
+ REQUIRES(!Locks::dex_lock_)
+ REQUIRES_SHARED(Locks::mutator_lock_) {
DCHECK(out_forward_dex_cache_array != nullptr);
DCHECK(out_error_msg != nullptr);
+ PointerSize image_pointer_size = class_linker->GetImagePointerSize();
Thread* const self = Thread::Current();
gc::Heap* const heap = Runtime::Current()->GetHeap();
const ImageHeader& header = space->GetImageHeader();
@@ -1295,7 +1317,7 @@
CHECK_EQ(num_fields, dex_cache->NumResolvedFields());
CHECK_EQ(num_method_types, dex_cache->NumResolvedMethodTypes());
CHECK_EQ(num_call_sites, dex_cache->NumResolvedCallSites());
- DexCacheArraysLayout layout(image_pointer_size_, dex_file);
+ DexCacheArraysLayout layout(image_pointer_size, dex_file);
uint8_t* const raw_arrays = oat_dex_file->GetDexCacheArrays();
if (num_strings != 0u) {
mirror::StringDexCacheType* const image_resolved_strings = dex_cache->GetStrings();
@@ -1331,17 +1353,17 @@
mirror::FieldDexCacheType* const fields =
reinterpret_cast<mirror::FieldDexCacheType*>(raw_arrays + layout.FieldsOffset());
for (size_t j = 0; j < num_fields; ++j) {
- DCHECK_EQ(mirror::DexCache::GetNativePairPtrSize(fields, j, image_pointer_size_).index,
+ DCHECK_EQ(mirror::DexCache::GetNativePairPtrSize(fields, j, image_pointer_size).index,
0u);
- DCHECK(mirror::DexCache::GetNativePairPtrSize(fields, j, image_pointer_size_).object ==
+ DCHECK(mirror::DexCache::GetNativePairPtrSize(fields, j, image_pointer_size).object ==
nullptr);
mirror::DexCache::SetNativePairPtrSize(
fields,
j,
mirror::DexCache::GetNativePairPtrSize(image_resolved_fields,
j,
- image_pointer_size_),
- image_pointer_size_);
+ image_pointer_size),
+ image_pointer_size);
}
dex_cache->SetResolvedFields(fields);
}
@@ -1379,8 +1401,8 @@
// Make sure to do this after we update the arrays since we store the resolved types array
// in DexCacheData in RegisterDexFileLocked. We need the array pointer to be the one in the
// BSS.
- CHECK(!FindDexCacheDataLocked(*dex_file).IsValid());
- RegisterDexFileLocked(*dex_file, dex_cache, class_loader.Get());
+ CHECK(!class_linker->FindDexCacheDataLocked(*dex_file).IsValid());
+ class_linker->RegisterDexFileLocked(*dex_file, dex_cache, class_loader.Get());
}
if (kIsDebugBuild) {
CHECK(new_class_set != nullptr);
@@ -1402,20 +1424,20 @@
}
for (ArtMethod& m : klass->GetDirectMethods(kRuntimePointerSize)) {
const void* code = m.GetEntryPointFromQuickCompiledCode();
- const void* oat_code = m.IsInvokable() ? GetQuickOatCodeFor(&m) : code;
- if (!IsQuickResolutionStub(code) &&
- !IsQuickGenericJniStub(code) &&
- !IsQuickToInterpreterBridge(code) &&
+ const void* oat_code = m.IsInvokable() ? class_linker->GetQuickOatCodeFor(&m) : code;
+ if (!class_linker->IsQuickResolutionStub(code) &&
+ !class_linker->IsQuickGenericJniStub(code) &&
+ !class_linker->IsQuickToInterpreterBridge(code) &&
!m.IsNative()) {
DCHECK_EQ(code, oat_code) << m.PrettyMethod();
}
}
for (ArtMethod& m : klass->GetVirtualMethods(kRuntimePointerSize)) {
const void* code = m.GetEntryPointFromQuickCompiledCode();
- const void* oat_code = m.IsInvokable() ? GetQuickOatCodeFor(&m) : code;
- if (!IsQuickResolutionStub(code) &&
- !IsQuickGenericJniStub(code) &&
- !IsQuickToInterpreterBridge(code) &&
+ const void* oat_code = m.IsInvokable() ? class_linker->GetQuickOatCodeFor(&m) : code;
+ if (!class_linker->IsQuickResolutionStub(code) &&
+ !class_linker->IsQuickGenericJniStub(code) &&
+ !class_linker->IsQuickToInterpreterBridge(code) &&
!m.IsNative()) {
DCHECK_EQ(code, oat_code) << m.PrettyMethod();
}
@@ -1875,12 +1897,13 @@
}
if (app_image) {
bool forward_dex_cache_arrays = false;
- if (!UpdateAppImageClassLoadersAndDexCaches(space,
- class_loader,
- dex_caches,
- &temp_set,
- /*out*/&forward_dex_cache_arrays,
- /*out*/error_msg)) {
+ if (!AppImageClassLoadersAndDexCachesHelper::Update(this,
+ space,
+ class_loader,
+ dex_caches,
+ &temp_set,
+ /*out*/&forward_dex_cache_arrays,
+ /*out*/error_msg)) {
return false;
}
// Update class loader and resolved strings. If added_class_table is false, the resolved
@@ -1979,7 +2002,7 @@
// ClassTable::TableSlot. The buffered root visiting would access a stale stack location for
// these objects.
UnbufferedRootVisitor root_visitor(visitor, RootInfo(kRootStickyClass));
- boot_class_table_.VisitRoots(root_visitor);
+ boot_class_table_->VisitRoots(root_visitor);
// If tracing is enabled, then mark all the class loaders to prevent unloading.
if ((flags & kVisitRootFlagClassLoader) != 0 || tracing_enabled) {
for (const ClassLoaderData& data : class_loaders_) {
@@ -2078,7 +2101,7 @@
};
void ClassLinker::VisitClassesInternal(ClassVisitor* visitor) {
- if (boot_class_table_.Visit(*visitor)) {
+ if (boot_class_table_->Visit(*visitor)) {
VisitClassLoaderClassesVisitor loader_visitor(visitor);
VisitClassLoaders(&loader_visitor);
}
@@ -3881,7 +3904,7 @@
void ClassLinker::MoveClassTableToPreZygote() {
WriterMutexLock mu(Thread::Current(), *Locks::classlinker_classes_lock_);
- boot_class_table_.FreezeSnapshot();
+ boot_class_table_->FreezeSnapshot();
MoveClassTableToPreZygoteVisitor visitor;
VisitClassLoaders(&visitor);
}
@@ -3918,7 +3941,7 @@
Thread* const self = Thread::Current();
ReaderMutexLock mu(self, *Locks::classlinker_classes_lock_);
const size_t hash = ComputeModifiedUtf8Hash(descriptor);
- ObjPtr<mirror::Class> klass = boot_class_table_.Lookup(descriptor, hash);
+ ObjPtr<mirror::Class> klass = boot_class_table_->Lookup(descriptor, hash);
if (klass != nullptr) {
DCHECK(klass->GetClassLoader() == nullptr);
result.push_back(klass);
@@ -5202,7 +5225,7 @@
ClassTable* ClassLinker::InsertClassTableForClassLoader(ObjPtr<mirror::ClassLoader> class_loader) {
if (class_loader == nullptr) {
- return &boot_class_table_;
+ return boot_class_table_.get();
}
ClassTable* class_table = class_loader->GetClassTable();
if (class_table == nullptr) {
@@ -5214,7 +5237,7 @@
}
ClassTable* ClassLinker::ClassTableForClassLoader(ObjPtr<mirror::ClassLoader> class_loader) {
- return class_loader == nullptr ? &boot_class_table_ : class_loader->GetClassTable();
+ return class_loader == nullptr ? boot_class_table_.get() : class_loader->GetClassTable();
}
static ImTable* FindSuperImt(ObjPtr<mirror::Class> klass, PointerSize pointer_size)
@@ -8571,13 +8594,13 @@
size_t ClassLinker::NumZygoteClasses() const {
CountClassesVisitor visitor;
VisitClassLoaders(&visitor);
- return visitor.num_zygote_classes + boot_class_table_.NumZygoteClasses(nullptr);
+ return visitor.num_zygote_classes + boot_class_table_->NumZygoteClasses(nullptr);
}
size_t ClassLinker::NumNonZygoteClasses() const {
CountClassesVisitor visitor;
VisitClassLoaders(&visitor);
- return visitor.num_non_zygote_classes + boot_class_table_.NumNonZygoteClasses(nullptr);
+ return visitor.num_non_zygote_classes + boot_class_table_->NumNonZygoteClasses(nullptr);
}
size_t ClassLinker::NumLoadedClasses() {
diff --git a/runtime/class_linker.h b/runtime/class_linker.h
index 7f652ec..205ea1e 100644
--- a/runtime/class_linker.h
+++ b/runtime/class_linker.h
@@ -27,7 +27,6 @@
#include "base/enums.h"
#include "base/macros.h"
#include "base/mutex.h"
-#include "class_table.h"
#include "dex_cache_resolved_classes.h"
#include "dex_file.h"
#include "dex_file_types.h"
@@ -35,7 +34,6 @@
#include "handle.h"
#include "jni.h"
#include "mirror/class.h"
-#include "object_callbacks.h"
#include "verifier/verifier_enums.h"
namespace art {
@@ -59,11 +57,13 @@
class StackTraceElement;
} // namespace mirror
+class ClassTable;
template<class T> class Handle;
class ImtConflictTable;
template<typename T> class LengthPrefixedArray;
template<class T> class MutableHandle;
class InternTable;
+class LinearAlloc;
class OatFile;
template<class T> class ObjectLock;
class Runtime;
@@ -640,8 +640,11 @@
REQUIRES_SHARED(Locks::mutator_lock_);
// Returns null if not found.
+ // This returns a pointer to the class-table, without requiring any locking - including the
+ // boot class-table. It is the caller's responsibility to access this under lock, if required.
ClassTable* ClassTableForClassLoader(ObjPtr<mirror::ClassLoader> class_loader)
- REQUIRES_SHARED(Locks::mutator_lock_);
+ REQUIRES_SHARED(Locks::mutator_lock_)
+ NO_THREAD_SAFETY_ANALYSIS;
void AppendToBootClassPath(Thread* self, const DexFile& dex_file)
REQUIRES_SHARED(Locks::mutator_lock_)
@@ -1110,18 +1113,6 @@
REQUIRES_SHARED(Locks::mutator_lock_)
REQUIRES(!Locks::classlinker_classes_lock_);
- // new_class_set is the set of classes that were read from the class table section in the image.
- // If there was no class table section, it is null.
- bool UpdateAppImageClassLoadersAndDexCaches(
- gc::space::ImageSpace* space,
- Handle<mirror::ClassLoader> class_loader,
- Handle<mirror::ObjectArray<mirror::DexCache>> dex_caches,
- ClassTable::ClassSet* new_class_set,
- bool* out_forward_dex_cache_array,
- std::string* out_error_msg)
- REQUIRES(!Locks::dex_lock_)
- REQUIRES_SHARED(Locks::mutator_lock_);
-
// Check that c1 == FindSystemClass(self, descriptor). Abort with class dumps otherwise.
void CheckSystemClass(Thread* self, Handle<mirror::Class> c1, const char* descriptor)
REQUIRES(!Locks::dex_lock_)
@@ -1171,7 +1162,7 @@
GUARDED_BY(Locks::classlinker_classes_lock_);
// Boot class path table. Since the class loader for this is null.
- ClassTable boot_class_table_ GUARDED_BY(Locks::classlinker_classes_lock_);
+ std::unique_ptr<ClassTable> boot_class_table_ GUARDED_BY(Locks::classlinker_classes_lock_);
// New class roots, only used by CMS since the GC needs to mark these in the pause.
std::vector<GcRoot<mirror::Class>> new_class_roots_ GUARDED_BY(Locks::classlinker_classes_lock_);
@@ -1212,12 +1203,14 @@
PointerSize image_pointer_size_;
class FindVirtualMethodHolderVisitor;
+
+ friend class AppImageClassLoadersAndDexCachesHelper;
friend struct CompilationHelper; // For Compile in ImageTest.
friend class ImageDumper; // for DexLock
friend class ImageWriter; // for GetClassRoots
- friend class VMClassLoader; // for LookupClass and FindClassInBaseDexClassLoader.
friend class JniCompilerTest; // for GetRuntimeQuickGenericJniStub
friend class JniInternalTest; // for GetRuntimeQuickGenericJniStub
+ friend class VMClassLoader; // for LookupClass and FindClassInBaseDexClassLoader.
ART_FRIEND_TEST(ClassLinkerTest, RegisterDexFileName); // for DexLock, and RegisterDexFileLocked
ART_FRIEND_TEST(mirror::DexCacheMethodHandlesTest, Open); // for AllocDexCache
ART_FRIEND_TEST(mirror::DexCacheTest, Open); // for AllocDexCache
diff --git a/runtime/class_table.h b/runtime/class_table.h
index 430edbb..8616dfb 100644
--- a/runtime/class_table.h
+++ b/runtime/class_table.h
@@ -25,18 +25,17 @@
#include "base/hash_set.h"
#include "base/macros.h"
#include "base/mutex.h"
-#include "dex_file.h"
#include "gc_root.h"
#include "obj_ptr.h"
-#include "object_callbacks.h"
-#include "runtime.h"
namespace art {
class OatFile;
namespace mirror {
+ class Class;
class ClassLoader;
+ class Object;
} // namespace mirror
// Each loader has a ClassTable
diff --git a/runtime/common_runtime_test.h b/runtime/common_runtime_test.h
index a29cc6c..24dbd05 100644
--- a/runtime/common_runtime_test.h
+++ b/runtime/common_runtime_test.h
@@ -98,9 +98,12 @@
// Returns bin directory which contains host's prebuild tools.
static std::string GetAndroidHostToolsDir();
- // Returns bin directory wahich contains target's prebuild tools.
+ // Returns bin directory which contains target's prebuild tools.
static std::string GetAndroidTargetToolsDir(InstructionSet isa);
+ // Retuerns the filename for a test dex (i.e. XandY or ManyMethods).
+ std::string GetTestDexFileName(const char* name) const;
+
protected:
// Allow subclases such as CommonCompilerTest to add extra options.
virtual void SetUpRuntimeOptions(RuntimeOptions* options ATTRIBUTE_UNUSED) {}
@@ -127,8 +130,6 @@
std::string GetTestAndroidRoot();
- std::string GetTestDexFileName(const char* name) const;
-
std::vector<std::unique_ptr<const DexFile>> OpenTestDexFiles(const char* name);
std::unique_ptr<const DexFile> OpenTestDexFile(const char* name)
diff --git a/runtime/dex_file.cc b/runtime/dex_file.cc
index 3d68af1..aace8eb 100644
--- a/runtime/dex_file.cc
+++ b/runtime/dex_file.cc
@@ -204,7 +204,7 @@
verify_checksum,
error_msg);
if (dex_file != nullptr) {
- dex_file->mem_map_.reset(map.release());
+ dex_file->mem_map_ = std::move(map);
}
return dex_file;
}
@@ -323,7 +323,7 @@
verify_checksum,
error_msg);
if (dex_file != nullptr) {
- dex_file->mem_map_.reset(map.release());
+ dex_file->mem_map_ = std::move(map);
}
return dex_file;
@@ -397,7 +397,7 @@
}
return nullptr;
}
- dex_file->mem_map_.reset(map.release());
+ dex_file->mem_map_ = std::move(map);
if (!dex_file->DisableWrite()) {
*error_msg = StringPrintf("Failed to make dex file '%s' read only", location.c_str());
*error_code = ZipOpenErrorCode::kMakeReadOnlyError;
diff --git a/runtime/entrypoints/quick/quick_default_init_entrypoints.h b/runtime/entrypoints/quick/quick_default_init_entrypoints.h
index 6481b97..267f384 100644
--- a/runtime/entrypoints/quick/quick_default_init_entrypoints.h
+++ b/runtime/entrypoints/quick/quick_default_init_entrypoints.h
@@ -26,7 +26,7 @@
namespace art {
-void DefaultInitEntryPoints(JniEntryPoints* jpoints, QuickEntryPoints* qpoints) {
+static void DefaultInitEntryPoints(JniEntryPoints* jpoints, QuickEntryPoints* qpoints) {
// JNI
jpoints->pDlsymLookup = art_jni_dlsym_lookup_stub;
diff --git a/runtime/gc/allocation_listener.h b/runtime/gc/allocation_listener.h
index f60bc0c..d694a68 100644
--- a/runtime/gc/allocation_listener.h
+++ b/runtime/gc/allocation_listener.h
@@ -30,7 +30,7 @@
namespace mirror {
class Object;
-}
+} // namespace mirror
class Thread;
diff --git a/runtime/gc/allocation_record.h b/runtime/gc/allocation_record.h
index 90cff6a..227c7ad 100644
--- a/runtime/gc/allocation_record.h
+++ b/runtime/gc/allocation_record.h
@@ -33,7 +33,7 @@
namespace mirror {
class Class;
class Object;
-}
+} // namespace mirror
namespace gc {
diff --git a/runtime/gc/space/image_space.cc b/runtime/gc/space/image_space.cc
index 748d378..b6bff5b 100644
--- a/runtime/gc/space/image_space.cc
+++ b/runtime/gc/space/image_space.cc
@@ -42,6 +42,7 @@
#include "mirror/object-refvisitor-inl.h"
#include "oat_file.h"
#include "os.h"
+#include "runtime.h"
#include "space-inl.h"
#include "utils.h"
diff --git a/runtime/gc/space/image_space.h b/runtime/gc/space/image_space.h
index aa3dd42..a4065bf 100644
--- a/runtime/gc/space/image_space.h
+++ b/runtime/gc/space/image_space.h
@@ -19,7 +19,6 @@
#include "arch/instruction_set.h"
#include "gc/accounting/space_bitmap.h"
-#include "runtime.h"
#include "space.h"
namespace art {
diff --git a/runtime/handle_scope.h b/runtime/handle_scope.h
index c43a482..f248a11 100644
--- a/runtime/handle_scope.h
+++ b/runtime/handle_scope.h
@@ -36,7 +36,7 @@
namespace mirror {
class Object;
-}
+} // namespace mirror
// Basic handle scope, tracked by a list. May be variable sized.
class PACKED(4) BaseHandleScope {
diff --git a/runtime/jit/profile_compilation_info.h b/runtime/jit/profile_compilation_info.h
index e903e2d..a9a5b13 100644
--- a/runtime/jit/profile_compilation_info.h
+++ b/runtime/jit/profile_compilation_info.h
@@ -276,6 +276,9 @@
ArenaAllocator* GetArena() { return &arena_; }
+ // Add a method index to the profile (without inline caches).
+ bool AddMethodIndex(const std::string& dex_location, uint32_t checksum, uint16_t method_idx);
+
private:
enum ProfileLoadSatus {
kProfileLoadWouldOverwiteData,
@@ -333,9 +336,6 @@
// already exists but has a different checksum
DexFileData* GetOrAddDexFileData(const std::string& profile_key, uint32_t checksum);
- // Add a method index to the profile (without inline caches).
- bool AddMethodIndex(const std::string& dex_location, uint32_t checksum, uint16_t method_idx);
-
// Add a method to the profile using its online representation (containing runtime structures).
bool AddMethod(const ProfileMethodInfo& pmi);
diff --git a/runtime/jit/profiling_info.h b/runtime/jit/profiling_info.h
index d6881aa..788fa1f 100644
--- a/runtime/jit/profiling_info.h
+++ b/runtime/jit/profiling_info.h
@@ -29,11 +29,11 @@
namespace jit {
class JitCodeCache;
-}
+} // namespace jit
namespace mirror {
class Class;
-}
+} // namespace mirror
// Structure to store the classes seen at runtime for a specific instruction.
// Once the classes_ array is full, we consider the INVOKE to be megamorphic.
diff --git a/runtime/jni_internal.h b/runtime/jni_internal.h
index 580a42b..24bee6f 100644
--- a/runtime/jni_internal.h
+++ b/runtime/jni_internal.h
@@ -19,7 +19,6 @@
#include <jni.h>
#include <iosfwd>
-#include "nativehelper/jni_macros.h"
#include "base/macros.h"
diff --git a/runtime/method_handles.h b/runtime/method_handles.h
index 5bea0ab..e8a2dce 100644
--- a/runtime/method_handles.h
+++ b/runtime/method_handles.h
@@ -29,7 +29,7 @@
namespace mirror {
class MethodHandle;
class MethodType;
-} // mirror
+} // namespace mirror
class ShadowFrame;
diff --git a/runtime/mirror/class_loader.h b/runtime/mirror/class_loader.h
index a62a460..6e1f44b 100644
--- a/runtime/mirror/class_loader.h
+++ b/runtime/mirror/class_loader.h
@@ -23,6 +23,7 @@
struct ClassLoaderOffsets;
class ClassTable;
+class LinearAlloc;
namespace mirror {
diff --git a/runtime/mirror/field-inl.h b/runtime/mirror/field-inl.h
index 2496989..d33df5c 100644
--- a/runtime/mirror/field-inl.h
+++ b/runtime/mirror/field-inl.h
@@ -21,7 +21,6 @@
#include "art_field-inl.h"
#include "mirror/dex_cache-inl.h"
-#include "runtime-inl.h"
namespace art {
diff --git a/runtime/mirror/reference.h b/runtime/mirror/reference.h
index f2fa589..cfcbd5a 100644
--- a/runtime/mirror/reference.h
+++ b/runtime/mirror/reference.h
@@ -22,10 +22,7 @@
#include "gc_root.h"
#include "obj_ptr.h"
#include "object.h"
-#include "object_callbacks.h"
#include "read_barrier_option.h"
-#include "runtime.h"
-#include "thread.h"
namespace art {
diff --git a/runtime/native/dalvik_system_DexFile.cc b/runtime/native/dalvik_system_DexFile.cc
index e618323..870402d 100644
--- a/runtime/native/dalvik_system_DexFile.cc
+++ b/runtime/native/dalvik_system_DexFile.cc
@@ -19,6 +19,7 @@
#include <sstream>
#include "android-base/stringprintf.h"
+#include "nativehelper/jni_macros.h"
#include "base/logging.h"
#include "base/stl_util.h"
diff --git a/runtime/native/dalvik_system_VMDebug.cc b/runtime/native/dalvik_system_VMDebug.cc
index 5c4e242..bb8233b9 100644
--- a/runtime/native/dalvik_system_VMDebug.cc
+++ b/runtime/native/dalvik_system_VMDebug.cc
@@ -21,6 +21,8 @@
#include <sstream>
+#include "nativehelper/jni_macros.h"
+
#include "base/histogram-inl.h"
#include "base/time_utils.h"
#include "class_linker.h"
diff --git a/runtime/native/dalvik_system_VMRuntime.cc b/runtime/native/dalvik_system_VMRuntime.cc
index ff4d931..18b871c 100644
--- a/runtime/native/dalvik_system_VMRuntime.cc
+++ b/runtime/native/dalvik_system_VMRuntime.cc
@@ -30,6 +30,7 @@
#pragma GCC diagnostic pop
#include "android-base/stringprintf.h"
+#include "nativehelper/jni_macros.h"
#include "art_method-inl.h"
#include "arch/instruction_set.h"
diff --git a/runtime/native/dalvik_system_VMStack.cc b/runtime/native/dalvik_system_VMStack.cc
index 0dfafa4..6c41d51 100644
--- a/runtime/native/dalvik_system_VMStack.cc
+++ b/runtime/native/dalvik_system_VMStack.cc
@@ -16,6 +16,8 @@
#include "dalvik_system_VMStack.h"
+#include "nativehelper/jni_macros.h"
+
#include "art_method-inl.h"
#include "gc/task_processor.h"
#include "jni_internal.h"
diff --git a/runtime/native/dalvik_system_ZygoteHooks.cc b/runtime/native/dalvik_system_ZygoteHooks.cc
index 0515ec6..4c6f530 100644
--- a/runtime/native/dalvik_system_ZygoteHooks.cc
+++ b/runtime/native/dalvik_system_ZygoteHooks.cc
@@ -19,6 +19,7 @@
#include <stdlib.h>
#include "android-base/stringprintf.h"
+#include "nativehelper/jni_macros.h"
#include "arch/instruction_set.h"
#include "art_method-inl.h"
diff --git a/runtime/native/java_lang_Class.cc b/runtime/native/java_lang_Class.cc
index 4f99947..9e07a5c 100644
--- a/runtime/native/java_lang_Class.cc
+++ b/runtime/native/java_lang_Class.cc
@@ -18,6 +18,8 @@
#include <iostream>
+#include "nativehelper/jni_macros.h"
+
#include "art_field-inl.h"
#include "art_method-inl.h"
#include "base/enums.h"
diff --git a/runtime/native/java_lang_Object.cc b/runtime/native/java_lang_Object.cc
index fb4f99a..c9841d1 100644
--- a/runtime/native/java_lang_Object.cc
+++ b/runtime/native/java_lang_Object.cc
@@ -16,6 +16,8 @@
#include "java_lang_Object.h"
+#include "nativehelper/jni_macros.h"
+
#include "jni_internal.h"
#include "mirror/object-inl.h"
#include "scoped_fast_native_object_access-inl.h"
diff --git a/runtime/native/java_lang_String.cc b/runtime/native/java_lang_String.cc
index bf33bf2..4928c01 100644
--- a/runtime/native/java_lang_String.cc
+++ b/runtime/native/java_lang_String.cc
@@ -16,6 +16,8 @@
#include "java_lang_String.h"
+#include "nativehelper/jni_macros.h"
+
#include "common_throws.h"
#include "jni_internal.h"
#include "mirror/array.h"
diff --git a/runtime/native/java_lang_StringFactory.cc b/runtime/native/java_lang_StringFactory.cc
index ec3c7c2..c1292ef 100644
--- a/runtime/native/java_lang_StringFactory.cc
+++ b/runtime/native/java_lang_StringFactory.cc
@@ -16,6 +16,8 @@
#include "java_lang_StringFactory.h"
+#include "nativehelper/jni_macros.h"
+
#include "common_throws.h"
#include "jni_internal.h"
#include "mirror/object-inl.h"
diff --git a/runtime/native/java_lang_System.cc b/runtime/native/java_lang_System.cc
index 2cabce8..264b427 100644
--- a/runtime/native/java_lang_System.cc
+++ b/runtime/native/java_lang_System.cc
@@ -16,6 +16,8 @@
#include "java_lang_System.h"
+#include "nativehelper/jni_macros.h"
+
#include "common_throws.h"
#include "gc/accounting/card_table-inl.h"
#include "jni_internal.h"
diff --git a/runtime/native/java_lang_Thread.cc b/runtime/native/java_lang_Thread.cc
index 346bd30..f3254c4 100644
--- a/runtime/native/java_lang_Thread.cc
+++ b/runtime/native/java_lang_Thread.cc
@@ -16,6 +16,8 @@
#include "java_lang_Thread.h"
+#include "nativehelper/jni_macros.h"
+
#include "common_throws.h"
#include "jni_internal.h"
#include "monitor.h"
diff --git a/runtime/native/java_lang_Throwable.cc b/runtime/native/java_lang_Throwable.cc
index 654b8a8..b69fbef 100644
--- a/runtime/native/java_lang_Throwable.cc
+++ b/runtime/native/java_lang_Throwable.cc
@@ -16,6 +16,8 @@
#include "java_lang_Throwable.h"
+#include "nativehelper/jni_macros.h"
+
#include "jni_internal.h"
#include "scoped_fast_native_object_access-inl.h"
#include "thread.h"
diff --git a/runtime/native/java_lang_VMClassLoader.cc b/runtime/native/java_lang_VMClassLoader.cc
index a9ba33e..55955e7 100644
--- a/runtime/native/java_lang_VMClassLoader.cc
+++ b/runtime/native/java_lang_VMClassLoader.cc
@@ -16,12 +16,15 @@
#include "java_lang_VMClassLoader.h"
+#include "nativehelper/jni_macros.h"
+
#include "class_linker.h"
#include "jni_internal.h"
#include "mirror/class_loader.h"
#include "mirror/object-inl.h"
#include "obj_ptr.h"
#include "scoped_fast_native_object_access-inl.h"
+#include "ScopedLocalRef.h"
#include "ScopedUtfChars.h"
#include "well_known_classes.h"
#include "zip_archive.h"
@@ -122,16 +125,24 @@
static jobjectArray VMClassLoader_getBootClassPathEntries(JNIEnv* env, jclass) {
const std::vector<const DexFile*>& path =
Runtime::Current()->GetClassLinker()->GetBootClassPath();
- jclass stringClass = env->FindClass("java/lang/String");
- jobjectArray array = env->NewObjectArray(path.size(), stringClass, nullptr);
+ jobjectArray array =
+ env->NewObjectArray(path.size(), WellKnownClasses::java_lang_String, nullptr);
+ if (array == nullptr) {
+ DCHECK(env->ExceptionCheck());
+ return nullptr;
+ }
for (size_t i = 0; i < path.size(); ++i) {
const DexFile* dex_file = path[i];
// For multidex locations, e.g., x.jar:classes2.dex, we want to look into x.jar.
const std::string& location(dex_file->GetBaseLocation());
- jstring javaPath = env->NewStringUTF(location.c_str());
- env->SetObjectArrayElement(array, i, javaPath);
+ ScopedLocalRef<jstring> javaPath(env, env->NewStringUTF(location.c_str()));
+ if (javaPath.get() == nullptr) {
+ DCHECK(env->ExceptionCheck());
+ return nullptr;
+ }
+ env->SetObjectArrayElement(array, i, javaPath.get());
}
return array;
}
diff --git a/runtime/native/java_lang_Void.cc b/runtime/native/java_lang_Void.cc
index e2b4b82..b0d63ef 100644
--- a/runtime/native/java_lang_Void.cc
+++ b/runtime/native/java_lang_Void.cc
@@ -16,6 +16,8 @@
#include "java_lang_Void.h"
+#include "nativehelper/jni_macros.h"
+
#include "class_linker-inl.h"
#include "jni_internal.h"
#include "runtime.h"
diff --git a/runtime/native/java_lang_invoke_MethodHandleImpl.cc b/runtime/native/java_lang_invoke_MethodHandleImpl.cc
index 9113841..63168ce 100644
--- a/runtime/native/java_lang_invoke_MethodHandleImpl.cc
+++ b/runtime/native/java_lang_invoke_MethodHandleImpl.cc
@@ -16,6 +16,8 @@
#include "java_lang_invoke_MethodHandleImpl.h"
+#include "nativehelper/jni_macros.h"
+
#include "art_method.h"
#include "handle_scope-inl.h"
#include "jni_internal.h"
diff --git a/runtime/native/java_lang_ref_FinalizerReference.cc b/runtime/native/java_lang_ref_FinalizerReference.cc
index afedc5e..c75837a 100644
--- a/runtime/native/java_lang_ref_FinalizerReference.cc
+++ b/runtime/native/java_lang_ref_FinalizerReference.cc
@@ -16,6 +16,8 @@
#include "java_lang_ref_FinalizerReference.h"
+#include "nativehelper/jni_macros.h"
+
#include "gc/heap.h"
#include "gc/reference_processor.h"
#include "jni_internal.h"
diff --git a/runtime/native/java_lang_ref_Reference.cc b/runtime/native/java_lang_ref_Reference.cc
index b1cb2f2..606e656 100644
--- a/runtime/native/java_lang_ref_Reference.cc
+++ b/runtime/native/java_lang_ref_Reference.cc
@@ -16,6 +16,8 @@
#include "java_lang_ref_Reference.h"
+#include "nativehelper/jni_macros.h"
+
#include "gc/heap.h"
#include "gc/reference_processor.h"
#include "jni_internal.h"
diff --git a/runtime/native/java_lang_reflect_Array.cc b/runtime/native/java_lang_reflect_Array.cc
index 54c2109..9662395 100644
--- a/runtime/native/java_lang_reflect_Array.cc
+++ b/runtime/native/java_lang_reflect_Array.cc
@@ -16,6 +16,8 @@
#include "java_lang_reflect_Array.h"
+#include "nativehelper/jni_macros.h"
+
#include "class_linker-inl.h"
#include "common_throws.h"
#include "dex_file-inl.h"
diff --git a/runtime/native/java_lang_reflect_Constructor.cc b/runtime/native/java_lang_reflect_Constructor.cc
index fb78046..d1953ad 100644
--- a/runtime/native/java_lang_reflect_Constructor.cc
+++ b/runtime/native/java_lang_reflect_Constructor.cc
@@ -16,6 +16,8 @@
#include "java_lang_reflect_Constructor.h"
+#include "nativehelper/jni_macros.h"
+
#include "art_method-inl.h"
#include "base/enums.h"
#include "class_linker.h"
diff --git a/runtime/native/java_lang_reflect_Executable.cc b/runtime/native/java_lang_reflect_Executable.cc
index 8f226ce..256a3d0 100644
--- a/runtime/native/java_lang_reflect_Executable.cc
+++ b/runtime/native/java_lang_reflect_Executable.cc
@@ -17,6 +17,7 @@
#include "java_lang_reflect_Executable.h"
#include "android-base/stringprintf.h"
+#include "nativehelper/jni_macros.h"
#include "art_method-inl.h"
#include "dex_file_annotations.h"
diff --git a/runtime/native/java_lang_reflect_Field.cc b/runtime/native/java_lang_reflect_Field.cc
index 0fb3903..e38bcd6 100644
--- a/runtime/native/java_lang_reflect_Field.cc
+++ b/runtime/native/java_lang_reflect_Field.cc
@@ -17,6 +17,7 @@
#include "java_lang_reflect_Field.h"
#include "android-base/stringprintf.h"
+#include "nativehelper/jni_macros.h"
#include "art_field-inl.h"
#include "class_linker.h"
diff --git a/runtime/native/java_lang_reflect_Method.cc b/runtime/native/java_lang_reflect_Method.cc
index 6f0130e..c9e8dba 100644
--- a/runtime/native/java_lang_reflect_Method.cc
+++ b/runtime/native/java_lang_reflect_Method.cc
@@ -16,6 +16,8 @@
#include "java_lang_reflect_Method.h"
+#include "nativehelper/jni_macros.h"
+
#include "art_method-inl.h"
#include "base/enums.h"
#include "class_linker.h"
diff --git a/runtime/native/java_lang_reflect_Parameter.cc b/runtime/native/java_lang_reflect_Parameter.cc
index 37aa16c..92a7ac9 100644
--- a/runtime/native/java_lang_reflect_Parameter.cc
+++ b/runtime/native/java_lang_reflect_Parameter.cc
@@ -17,6 +17,7 @@
#include "java_lang_reflect_Parameter.h"
#include "android-base/stringprintf.h"
+#include "nativehelper/jni_macros.h"
#include "art_method-inl.h"
#include "common_throws.h"
diff --git a/runtime/native/java_lang_reflect_Proxy.cc b/runtime/native/java_lang_reflect_Proxy.cc
index 0279b5f..518aaa7 100644
--- a/runtime/native/java_lang_reflect_Proxy.cc
+++ b/runtime/native/java_lang_reflect_Proxy.cc
@@ -16,6 +16,8 @@
#include "java_lang_reflect_Proxy.h"
+#include "nativehelper/jni_macros.h"
+
#include "class_linker.h"
#include "jni_internal.h"
#include "mirror/class_loader.h"
diff --git a/runtime/native/java_util_concurrent_atomic_AtomicLong.cc b/runtime/native/java_util_concurrent_atomic_AtomicLong.cc
index 4d2ea67..101f386 100644
--- a/runtime/native/java_util_concurrent_atomic_AtomicLong.cc
+++ b/runtime/native/java_util_concurrent_atomic_AtomicLong.cc
@@ -16,6 +16,8 @@
#include "java_util_concurrent_atomic_AtomicLong.h"
+#include "nativehelper/jni_macros.h"
+
#include "arch/instruction_set.h"
#include "atomic.h"
#include "jni_internal.h"
diff --git a/runtime/native/libcore_util_CharsetUtils.cc b/runtime/native/libcore_util_CharsetUtils.cc
index 4138ccc..c388ea1 100644
--- a/runtime/native/libcore_util_CharsetUtils.cc
+++ b/runtime/native/libcore_util_CharsetUtils.cc
@@ -14,15 +14,19 @@
* limitations under the License.
*/
+#include "libcore_util_CharsetUtils.h"
+
+#include <string.h>
+
+#include "nativehelper/jni_macros.h"
+
#include "jni_internal.h"
#include "mirror/string.h"
#include "mirror/string-inl.h"
-#include "native/libcore_util_CharsetUtils.h"
#include "scoped_fast_native_object_access-inl.h"
#include "ScopedPrimitiveArray.h"
#include "unicode/utf16.h"
-#include <string.h>
namespace art {
diff --git a/runtime/native/org_apache_harmony_dalvik_ddmc_DdmServer.cc b/runtime/native/org_apache_harmony_dalvik_ddmc_DdmServer.cc
index 5809708..a860977 100644
--- a/runtime/native/org_apache_harmony_dalvik_ddmc_DdmServer.cc
+++ b/runtime/native/org_apache_harmony_dalvik_ddmc_DdmServer.cc
@@ -16,6 +16,8 @@
#include "org_apache_harmony_dalvik_ddmc_DdmServer.h"
+#include "nativehelper/jni_macros.h"
+
#include "base/logging.h"
#include "debugger.h"
#include "jni_internal.h"
diff --git a/runtime/native/org_apache_harmony_dalvik_ddmc_DdmVmInternal.cc b/runtime/native/org_apache_harmony_dalvik_ddmc_DdmVmInternal.cc
index 69ef59e..ac504cc 100644
--- a/runtime/native/org_apache_harmony_dalvik_ddmc_DdmVmInternal.cc
+++ b/runtime/native/org_apache_harmony_dalvik_ddmc_DdmVmInternal.cc
@@ -16,6 +16,8 @@
#include "org_apache_harmony_dalvik_ddmc_DdmVmInternal.h"
+#include "nativehelper/jni_macros.h"
+
#include "base/logging.h"
#include "base/mutex.h"
#include "debugger.h"
diff --git a/runtime/native/sun_misc_Unsafe.cc b/runtime/native/sun_misc_Unsafe.cc
index cc5a41a..b42cedf 100644
--- a/runtime/native/sun_misc_Unsafe.cc
+++ b/runtime/native/sun_misc_Unsafe.cc
@@ -15,6 +15,14 @@
*/
#include "sun_misc_Unsafe.h"
+
+#include <atomic>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "nativehelper/jni_macros.h"
+
#include "common_throws.h"
#include "gc/accounting/card_table-inl.h"
#include "jni_internal.h"
@@ -23,10 +31,6 @@
#include "mirror/object-inl.h"
#include "scoped_fast_native_object_access-inl.h"
-#include <unistd.h>
-#include <stdlib.h>
-#include <string.h>
-#include <atomic>
namespace art {
diff --git a/runtime/openjdkjvmti/jvmti_weak_table.h b/runtime/openjdkjvmti/jvmti_weak_table.h
index a6fd247..be6edef 100644
--- a/runtime/openjdkjvmti/jvmti_weak_table.h
+++ b/runtime/openjdkjvmti/jvmti_weak_table.h
@@ -59,19 +59,19 @@
// Remove the mapping for the given object, returning whether such a mapping existed (and the old
// value).
- bool Remove(art::mirror::Object* obj, /* out */ T* tag)
+ ALWAYS_INLINE bool Remove(art::mirror::Object* obj, /* out */ T* tag)
REQUIRES_SHARED(art::Locks::mutator_lock_)
REQUIRES(!allow_disallow_lock_);
- bool RemoveLocked(art::mirror::Object* obj, /* out */ T* tag)
+ ALWAYS_INLINE bool RemoveLocked(art::mirror::Object* obj, /* out */ T* tag)
REQUIRES_SHARED(art::Locks::mutator_lock_)
REQUIRES(allow_disallow_lock_);
// Set the mapping for the given object. Returns true if this overwrites an already existing
// mapping.
- virtual bool Set(art::mirror::Object* obj, T tag)
+ ALWAYS_INLINE virtual bool Set(art::mirror::Object* obj, T tag)
REQUIRES_SHARED(art::Locks::mutator_lock_)
REQUIRES(!allow_disallow_lock_);
- virtual bool SetLocked(art::mirror::Object* obj, T tag)
+ ALWAYS_INLINE virtual bool SetLocked(art::mirror::Object* obj, T tag)
REQUIRES_SHARED(art::Locks::mutator_lock_)
REQUIRES(allow_disallow_lock_);
@@ -97,11 +97,12 @@
}
// Sweep the container. DO NOT CALL MANUALLY.
- void Sweep(art::IsMarkedVisitor* visitor)
+ ALWAYS_INLINE void Sweep(art::IsMarkedVisitor* visitor)
REQUIRES_SHARED(art::Locks::mutator_lock_)
REQUIRES(!allow_disallow_lock_);
// Return all objects that have a value mapping in tags.
+ ALWAYS_INLINE
jvmtiError GetTaggedObjects(jvmtiEnv* jvmti_env,
jint tag_count,
const T* tags,
@@ -112,11 +113,11 @@
REQUIRES(!allow_disallow_lock_);
// Locking functions, to allow coarse-grained locking and amortization.
- void Lock() ACQUIRE(allow_disallow_lock_);
- void Unlock() RELEASE(allow_disallow_lock_);
- void AssertLocked() ASSERT_CAPABILITY(allow_disallow_lock_);
+ ALWAYS_INLINE void Lock() ACQUIRE(allow_disallow_lock_);
+ ALWAYS_INLINE void Unlock() RELEASE(allow_disallow_lock_);
+ ALWAYS_INLINE void AssertLocked() ASSERT_CAPABILITY(allow_disallow_lock_);
- art::mirror::Object* Find(T tag)
+ ALWAYS_INLINE art::mirror::Object* Find(T tag)
REQUIRES_SHARED(art::Locks::mutator_lock_)
REQUIRES(!allow_disallow_lock_);
@@ -129,10 +130,12 @@
virtual void HandleNullSweep(T tag ATTRIBUTE_UNUSED) {}
private:
+ ALWAYS_INLINE
bool SetLocked(art::Thread* self, art::mirror::Object* obj, T tag)
REQUIRES_SHARED(art::Locks::mutator_lock_)
REQUIRES(allow_disallow_lock_);
+ ALWAYS_INLINE
bool RemoveLocked(art::Thread* self, art::mirror::Object* obj, /* out */ T* tag)
REQUIRES_SHARED(art::Locks::mutator_lock_)
REQUIRES(allow_disallow_lock_);
@@ -160,12 +163,14 @@
// Slow-path for GetTag. We didn't find the object, but we might be storing from-pointers and
// are asked to retrieve with a to-pointer.
+ ALWAYS_INLINE
bool GetTagSlowPath(art::Thread* self, art::mirror::Object* obj, /* out */ T* result)
REQUIRES_SHARED(art::Locks::mutator_lock_)
REQUIRES(allow_disallow_lock_);
// Update the table by doing read barriers on each element, ensuring that to-space pointers
// are stored.
+ ALWAYS_INLINE
void UpdateTableWithReadBarrier()
REQUIRES_SHARED(art::Locks::mutator_lock_)
REQUIRES(allow_disallow_lock_);
diff --git a/runtime/openjdkjvmti/ti_thread.h b/runtime/openjdkjvmti/ti_thread.h
index c7f75d8..939aea7 100644
--- a/runtime/openjdkjvmti/ti_thread.h
+++ b/runtime/openjdkjvmti/ti_thread.h
@@ -37,7 +37,7 @@
namespace art {
class ArtField;
-}
+} // namespace art
namespace openjdkjvmti {
diff --git a/runtime/runtime-inl.h b/runtime/runtime-inl.h
index 75c25dd..9281577 100644
--- a/runtime/runtime-inl.h
+++ b/runtime/runtime-inl.h
@@ -20,10 +20,8 @@
#include "runtime.h"
#include "art_method.h"
-#include "class_linker.h"
#include "gc_root-inl.h"
#include "obj_ptr-inl.h"
-#include "read_barrier-inl.h"
namespace art {
diff --git a/runtime/runtime.cc b/runtime/runtime.cc
index 968f02a..74e291e 100644
--- a/runtime/runtime.cc
+++ b/runtime/runtime.cc
@@ -134,6 +134,7 @@
#include "native_stack_dump.h"
#include "oat_file.h"
#include "oat_file_manager.h"
+#include "object_callbacks.h"
#include "os.h"
#include "parsed_options.h"
#include "jit/profile_saver.h"
diff --git a/runtime/runtime.h b/runtime/runtime.h
index 4e143e0..992c5c8 100644
--- a/runtime/runtime.h
+++ b/runtime/runtime.h
@@ -34,10 +34,7 @@
#include "experimental_flags.h"
#include "gc_root.h"
#include "instrumentation.h"
-#include "jobject_comparator.h"
-#include "method_reference.h"
#include "obj_ptr.h"
-#include "object_callbacks.h"
#include "offsets.h"
#include "process_state.h"
#include "quick/quick_method_frame_info.h"
@@ -79,6 +76,7 @@
class CompilerCallbacks;
class DexFile;
class InternTable;
+class IsMarkedVisitor;
class JavaVMExt;
class LinearAlloc;
class MemMap;
diff --git a/runtime/thread_list.h b/runtime/thread_list.h
index 3375746..0ce1d78 100644
--- a/runtime/thread_list.h
+++ b/runtime/thread_list.h
@@ -34,7 +34,7 @@
namespace gc {
namespace collector {
class GarbageCollector;
- } // namespac collector
+ } // namespace collector
class GcPauseListener;
} // namespace gc
class Closure;
diff --git a/runtime/ti/agent.h b/runtime/ti/agent.h
index b5ecba1..f98e387 100644
--- a/runtime/ti/agent.h
+++ b/runtime/ti/agent.h
@@ -20,8 +20,7 @@
#include <dlfcn.h>
#include <jni.h> // for jint, JavaVM* etc declarations
-#include "runtime.h"
-#include "utils.h"
+#include "base/logging.h"
namespace art {
namespace ti {
diff --git a/runtime/transaction.h b/runtime/transaction.h
index 0333fe8..921de03 100644
--- a/runtime/transaction.h
+++ b/runtime/transaction.h
@@ -36,7 +36,7 @@
class DexCache;
class Object;
class String;
-}
+} // namespace mirror
class InternTable;
class Transaction FINAL {
diff --git a/runtime/verifier/method_verifier.cc b/runtime/verifier/method_verifier.cc
index 81bf293..7490611 100644
--- a/runtime/verifier/method_verifier.cc
+++ b/runtime/verifier/method_verifier.cc
@@ -1258,7 +1258,7 @@
}
inline bool MethodVerifier::CheckRegisterIndex(uint32_t idx) {
- if (idx >= code_item_->registers_size_) {
+ if (UNLIKELY(idx >= code_item_->registers_size_)) {
Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "register index out of range (" << idx << " >= "
<< code_item_->registers_size_ << ")";
return false;
@@ -1267,7 +1267,7 @@
}
inline bool MethodVerifier::CheckWideRegisterIndex(uint32_t idx) {
- if (idx + 1 >= code_item_->registers_size_) {
+ if (UNLIKELY(idx + 1 >= code_item_->registers_size_)) {
Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "wide register index out of range (" << idx
<< "+1 >= " << code_item_->registers_size_ << ")";
return false;
@@ -1276,7 +1276,7 @@
}
inline bool MethodVerifier::CheckFieldIndex(uint32_t idx) {
- if (idx >= dex_file_->GetHeader().field_ids_size_) {
+ if (UNLIKELY(idx >= dex_file_->GetHeader().field_ids_size_)) {
Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "bad field index " << idx << " (max "
<< dex_file_->GetHeader().field_ids_size_ << ")";
return false;
@@ -1285,7 +1285,7 @@
}
inline bool MethodVerifier::CheckMethodIndex(uint32_t idx) {
- if (idx >= dex_file_->GetHeader().method_ids_size_) {
+ if (UNLIKELY(idx >= dex_file_->GetHeader().method_ids_size_)) {
Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "bad method index " << idx << " (max "
<< dex_file_->GetHeader().method_ids_size_ << ")";
return false;
@@ -1294,17 +1294,17 @@
}
inline bool MethodVerifier::CheckNewInstance(dex::TypeIndex idx) {
- if (idx.index_ >= dex_file_->GetHeader().type_ids_size_) {
+ if (UNLIKELY(idx.index_ >= dex_file_->GetHeader().type_ids_size_)) {
Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "bad type index " << idx.index_ << " (max "
<< dex_file_->GetHeader().type_ids_size_ << ")";
return false;
}
// We don't need the actual class, just a pointer to the class name.
const char* descriptor = dex_file_->StringByTypeIdx(idx);
- if (descriptor[0] != 'L') {
+ if (UNLIKELY(descriptor[0] != 'L')) {
Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "can't call new-instance on type '" << descriptor << "'";
return false;
- } else if (strcmp(descriptor, "Ljava/lang/Class;") == 0) {
+ } else if (UNLIKELY(strcmp(descriptor, "Ljava/lang/Class;") == 0)) {
// An unlikely new instance on Class is not allowed. Fall back to interpreter to ensure an
// exception is thrown when this statement is executed (compiled code would not do that).
Fail(VERIFY_ERROR_INSTANTIATION);
@@ -1313,7 +1313,7 @@
}
inline bool MethodVerifier::CheckPrototypeIndex(uint32_t idx) {
- if (idx >= dex_file_->GetHeader().proto_ids_size_) {
+ if (UNLIKELY(idx >= dex_file_->GetHeader().proto_ids_size_)) {
Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "bad prototype index " << idx << " (max "
<< dex_file_->GetHeader().proto_ids_size_ << ")";
return false;
@@ -1322,7 +1322,7 @@
}
inline bool MethodVerifier::CheckStringIndex(uint32_t idx) {
- if (idx >= dex_file_->GetHeader().string_ids_size_) {
+ if (UNLIKELY(idx >= dex_file_->GetHeader().string_ids_size_)) {
Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "bad string index " << idx << " (max "
<< dex_file_->GetHeader().string_ids_size_ << ")";
return false;
@@ -1331,7 +1331,7 @@
}
inline bool MethodVerifier::CheckTypeIndex(dex::TypeIndex idx) {
- if (idx.index_ >= dex_file_->GetHeader().type_ids_size_) {
+ if (UNLIKELY(idx.index_ >= dex_file_->GetHeader().type_ids_size_)) {
Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "bad type index " << idx.index_ << " (max "
<< dex_file_->GetHeader().type_ids_size_ << ")";
return false;
@@ -1340,7 +1340,7 @@
}
bool MethodVerifier::CheckNewArray(dex::TypeIndex idx) {
- if (idx.index_ >= dex_file_->GetHeader().type_ids_size_) {
+ if (UNLIKELY(idx.index_ >= dex_file_->GetHeader().type_ids_size_)) {
Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "bad type index " << idx.index_ << " (max "
<< dex_file_->GetHeader().type_ids_size_ << ")";
return false;
@@ -1351,12 +1351,12 @@
while (*cp++ == '[') {
bracket_count++;
}
- if (bracket_count == 0) {
+ if (UNLIKELY(bracket_count == 0)) {
/* The given class must be an array type. */
Fail(VERIFY_ERROR_BAD_CLASS_HARD)
<< "can't new-array class '" << descriptor << "' (not an array)";
return false;
- } else if (bracket_count > 255) {
+ } else if (UNLIKELY(bracket_count > 255)) {
/* It is illegal to create an array of more than 255 dimensions. */
Fail(VERIFY_ERROR_BAD_CLASS_HARD)
<< "can't new-array class '" << descriptor << "' (exceeds limit)";
@@ -1374,8 +1374,8 @@
DCHECK_LT(cur_offset, insn_count);
/* make sure the start of the array data table is in range */
array_data_offset = insns[1] | (static_cast<int32_t>(insns[2]) << 16);
- if (static_cast<int32_t>(cur_offset) + array_data_offset < 0 ||
- cur_offset + array_data_offset + 2 >= insn_count) {
+ if (UNLIKELY(static_cast<int32_t>(cur_offset) + array_data_offset < 0 ||
+ cur_offset + array_data_offset + 2 >= insn_count)) {
Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "invalid array data start: at " << cur_offset
<< ", data offset " << array_data_offset
<< ", count " << insn_count;
@@ -1384,14 +1384,14 @@
/* offset to array data table is a relative branch-style offset */
array_data = insns + array_data_offset;
// Make sure the table is at an even dex pc, that is, 32-bit aligned.
- if (!IsAligned<4>(array_data)) {
+ if (UNLIKELY(!IsAligned<4>(array_data))) {
Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "unaligned array data table: at " << cur_offset
<< ", data offset " << array_data_offset;
return false;
}
// Make sure the array-data is marked as an opcode. This ensures that it was reached when
// traversing the code item linearly. It is an approximation for a by-spec padding value.
- if (!GetInstructionFlags(cur_offset + array_data_offset).IsOpcode()) {
+ if (UNLIKELY(!GetInstructionFlags(cur_offset + array_data_offset).IsOpcode())) {
Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "array data table at " << cur_offset
<< ", data offset " << array_data_offset
<< " not correctly visited, probably bad padding.";
@@ -1402,7 +1402,7 @@
uint32_t value_count = *reinterpret_cast<const uint32_t*>(&array_data[2]);
uint32_t table_size = 4 + (value_width * value_count + 1) / 2;
/* make sure the end of the switch is in range */
- if (cur_offset + array_data_offset + table_size > insn_count) {
+ if (UNLIKELY(cur_offset + array_data_offset + table_size > insn_count)) {
Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "invalid array data end: at " << cur_offset
<< ", data offset " << array_data_offset << ", end "
<< cur_offset + array_data_offset + table_size
@@ -1418,23 +1418,23 @@
if (!GetBranchOffset(cur_offset, &offset, &isConditional, &selfOkay)) {
return false;
}
- if (!selfOkay && offset == 0) {
+ if (UNLIKELY(!selfOkay && offset == 0)) {
Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "branch offset of zero not allowed at"
<< reinterpret_cast<void*>(cur_offset);
return false;
}
// Check for 32-bit overflow. This isn't strictly necessary if we can depend on the runtime
// to have identical "wrap-around" behavior, but it's unwise to depend on that.
- if (((int64_t) cur_offset + (int64_t) offset) != (int64_t) (cur_offset + offset)) {
+ if (UNLIKELY(((int64_t) cur_offset + (int64_t) offset) != (int64_t) (cur_offset + offset))) {
Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "branch target overflow "
<< reinterpret_cast<void*>(cur_offset) << " +" << offset;
return false;
}
const uint32_t insn_count = code_item_->insns_size_in_code_units_;
int32_t abs_offset = cur_offset + offset;
- if (abs_offset < 0 ||
- (uint32_t) abs_offset >= insn_count ||
- !GetInstructionFlags(abs_offset).IsOpcode()) {
+ if (UNLIKELY(abs_offset < 0 ||
+ (uint32_t) abs_offset >= insn_count ||
+ !GetInstructionFlags(abs_offset).IsOpcode())) {
Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "invalid branch target " << offset << " (-> "
<< reinterpret_cast<void*>(abs_offset) << ") at "
<< reinterpret_cast<void*>(cur_offset);
@@ -1487,8 +1487,8 @@
const uint16_t* insns = code_item_->insns_ + cur_offset;
/* make sure the start of the switch is in range */
int32_t switch_offset = insns[1] | (static_cast<int32_t>(insns[2]) << 16);
- if (static_cast<int32_t>(cur_offset) + switch_offset < 0 ||
- cur_offset + switch_offset + 2 > insn_count) {
+ if (UNLIKELY(static_cast<int32_t>(cur_offset) + switch_offset < 0 ||
+ cur_offset + switch_offset + 2 > insn_count)) {
Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "invalid switch start: at " << cur_offset
<< ", switch offset " << switch_offset
<< ", count " << insn_count;
@@ -1497,14 +1497,14 @@
/* offset to switch table is a relative branch-style offset */
const uint16_t* switch_insns = insns + switch_offset;
// Make sure the table is at an even dex pc, that is, 32-bit aligned.
- if (!IsAligned<4>(switch_insns)) {
+ if (UNLIKELY(!IsAligned<4>(switch_insns))) {
Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "unaligned switch table: at " << cur_offset
<< ", switch offset " << switch_offset;
return false;
}
// Make sure the switch data is marked as an opcode. This ensures that it was reached when
// traversing the code item linearly. It is an approximation for a by-spec padding value.
- if (!GetInstructionFlags(cur_offset + switch_offset).IsOpcode()) {
+ if (UNLIKELY(!GetInstructionFlags(cur_offset + switch_offset).IsOpcode())) {
Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "switch table at " << cur_offset
<< ", switch offset " << switch_offset
<< " not correctly visited, probably bad padding.";
@@ -1526,14 +1526,14 @@
expected_signature = Instruction::kSparseSwitchSignature;
}
uint32_t table_size = targets_offset + switch_count * 2;
- if (switch_insns[0] != expected_signature) {
+ if (UNLIKELY(switch_insns[0] != expected_signature)) {
Fail(VERIFY_ERROR_BAD_CLASS_HARD)
<< StringPrintf("wrong signature for switch table (%x, wanted %x)",
switch_insns[0], expected_signature);
return false;
}
/* make sure the end of the switch is in range */
- if (cur_offset + switch_offset + table_size > (uint32_t) insn_count) {
+ if (UNLIKELY(cur_offset + switch_offset + table_size > (uint32_t) insn_count)) {
Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "invalid switch end: at " << cur_offset
<< ", switch offset " << switch_offset
<< ", end " << (cur_offset + switch_offset + table_size)
@@ -1548,7 +1548,7 @@
int32_t first_key = switch_insns[keys_offset] | (switch_insns[keys_offset + 1] << 16);
int32_t max_first_key =
std::numeric_limits<int32_t>::max() - (static_cast<int32_t>(switch_count) - 1);
- if (first_key > max_first_key) {
+ if (UNLIKELY(first_key > max_first_key)) {
Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "invalid packed switch: first_key=" << first_key
<< ", switch_count=" << switch_count;
return false;
@@ -1560,7 +1560,7 @@
int32_t key =
static_cast<int32_t>(switch_insns[keys_offset + targ * 2]) |
static_cast<int32_t>(switch_insns[keys_offset + targ * 2 + 1] << 16);
- if (key <= last_key) {
+ if (UNLIKELY(key <= last_key)) {
Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "invalid sparse switch: last key=" << last_key
<< ", this=" << key;
return false;
@@ -1574,9 +1574,9 @@
int32_t offset = static_cast<int32_t>(switch_insns[targets_offset + targ * 2]) |
static_cast<int32_t>(switch_insns[targets_offset + targ * 2 + 1] << 16);
int32_t abs_offset = cur_offset + offset;
- if (abs_offset < 0 ||
- abs_offset >= static_cast<int32_t>(insn_count) ||
- !GetInstructionFlags(abs_offset).IsOpcode()) {
+ if (UNLIKELY(abs_offset < 0 ||
+ abs_offset >= static_cast<int32_t>(insn_count) ||
+ !GetInstructionFlags(abs_offset).IsOpcode())) {
Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "invalid switch target " << offset
<< " (-> " << reinterpret_cast<void*>(abs_offset) << ") at "
<< reinterpret_cast<void*>(cur_offset)
@@ -1591,7 +1591,7 @@
bool MethodVerifier::CheckVarArgRegs(uint32_t vA, uint32_t arg[]) {
uint16_t registers_size = code_item_->registers_size_;
for (uint32_t idx = 0; idx < vA; idx++) {
- if (arg[idx] >= registers_size) {
+ if (UNLIKELY(arg[idx] >= registers_size)) {
Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "invalid reg index (" << arg[idx]
<< ") in non-range invoke (>= " << registers_size << ")";
return false;
@@ -1605,7 +1605,7 @@
uint16_t registers_size = code_item_->registers_size_;
// vA/vC are unsigned 8-bit/16-bit quantities for /range instructions, so there's no risk of
// integer overflow when adding them here.
- if (vA + vC > registers_size) {
+ if (UNLIKELY(vA + vC > registers_size)) {
Fail(VERIFY_ERROR_BAD_CLASS_HARD) << "invalid reg index " << vA << "+" << vC
<< " in range invoke (> " << registers_size << ")";
return false;
diff --git a/runtime/verifier/method_verifier.h b/runtime/verifier/method_verifier.h
index b34a3af..9ef98f7 100644
--- a/runtime/verifier/method_verifier.h
+++ b/runtime/verifier/method_verifier.h
@@ -37,12 +37,17 @@
namespace art {
+class ClassLinker;
class CompilerCallbacks;
class Instruction;
struct ReferenceMap2Visitor;
class Thread;
class VariableIndentationOutputStream;
+namespace mirror {
+class DexCache;
+} // namespace mirror
+
namespace verifier {
class MethodVerifier;
diff --git a/runtime/verifier/reg_type_cache-inl.h b/runtime/verifier/reg_type_cache-inl.h
index 68af62e..b57a2c8 100644
--- a/runtime/verifier/reg_type_cache-inl.h
+++ b/runtime/verifier/reg_type_cache-inl.h
@@ -43,6 +43,43 @@
return FromCat1NonSmallConstant(value, precise);
}
+inline const BooleanType& RegTypeCache::Boolean() {
+ return *BooleanType::GetInstance();
+}
+inline const ByteType& RegTypeCache::Byte() {
+ return *ByteType::GetInstance();
+}
+inline const CharType& RegTypeCache::Char() {
+ return *CharType::GetInstance();
+}
+inline const ShortType& RegTypeCache::Short() {
+ return *ShortType::GetInstance();
+}
+inline const IntegerType& RegTypeCache::Integer() {
+ return *IntegerType::GetInstance();
+}
+inline const FloatType& RegTypeCache::Float() {
+ return *FloatType::GetInstance();
+}
+inline const LongLoType& RegTypeCache::LongLo() {
+ return *LongLoType::GetInstance();
+}
+inline const LongHiType& RegTypeCache::LongHi() {
+ return *LongHiType::GetInstance();
+}
+inline const DoubleLoType& RegTypeCache::DoubleLo() {
+ return *DoubleLoType::GetInstance();
+}
+inline const DoubleHiType& RegTypeCache::DoubleHi() {
+ return *DoubleHiType::GetInstance();
+}
+inline const UndefinedType& RegTypeCache::Undefined() {
+ return *UndefinedType::GetInstance();
+}
+inline const ConflictType& RegTypeCache::Conflict() {
+ return *ConflictType::GetInstance();
+}
+
inline const ImpreciseConstType& RegTypeCache::ByteConstant() {
const ConstantType& result = FromCat1Const(std::numeric_limits<jbyte>::min(), false);
DCHECK(result.IsImpreciseConstant());
diff --git a/runtime/verifier/reg_type_cache.h b/runtime/verifier/reg_type_cache.h
index df0fe3d..37f8a1f 100644
--- a/runtime/verifier/reg_type_cache.h
+++ b/runtime/verifier/reg_type_cache.h
@@ -17,15 +17,14 @@
#ifndef ART_RUNTIME_VERIFIER_REG_TYPE_CACHE_H_
#define ART_RUNTIME_VERIFIER_REG_TYPE_CACHE_H_
+#include <stdint.h>
+#include <vector>
+
#include "base/casts.h"
#include "base/macros.h"
#include "base/scoped_arena_containers.h"
-#include "object_callbacks.h"
-#include "reg_type.h"
-#include "runtime.h"
-
-#include <stdint.h>
-#include <vector>
+#include "gc_root.h"
+#include "primitive.h"
namespace art {
namespace mirror {
@@ -37,7 +36,24 @@
namespace verifier {
+class BooleanType;
+class ByteType;
+class CharType;
+class ConflictType;
+class ConstantType;
+class DoubleHiType;
+class DoubleLoType;
+class FloatType;
+class ImpreciseConstType;
+class IntegerType;
+class LongHiType;
+class LongLoType;
+class PreciseConstType;
+class PreciseReferenceType;
class RegType;
+class ShortType;
+class UndefinedType;
+class UninitializedType;
// Use 8 bytes since that is the default arena allocator alignment.
static constexpr size_t kDefaultArenaBitVectorBytes = 8;
@@ -90,42 +106,18 @@
size_t GetCacheSize() {
return entries_.size();
}
- const BooleanType& Boolean() REQUIRES_SHARED(Locks::mutator_lock_) {
- return *BooleanType::GetInstance();
- }
- const ByteType& Byte() REQUIRES_SHARED(Locks::mutator_lock_) {
- return *ByteType::GetInstance();
- }
- const CharType& Char() REQUIRES_SHARED(Locks::mutator_lock_) {
- return *CharType::GetInstance();
- }
- const ShortType& Short() REQUIRES_SHARED(Locks::mutator_lock_) {
- return *ShortType::GetInstance();
- }
- const IntegerType& Integer() REQUIRES_SHARED(Locks::mutator_lock_) {
- return *IntegerType::GetInstance();
- }
- const FloatType& Float() REQUIRES_SHARED(Locks::mutator_lock_) {
- return *FloatType::GetInstance();
- }
- const LongLoType& LongLo() REQUIRES_SHARED(Locks::mutator_lock_) {
- return *LongLoType::GetInstance();
- }
- const LongHiType& LongHi() REQUIRES_SHARED(Locks::mutator_lock_) {
- return *LongHiType::GetInstance();
- }
- const DoubleLoType& DoubleLo() REQUIRES_SHARED(Locks::mutator_lock_) {
- return *DoubleLoType::GetInstance();
- }
- const DoubleHiType& DoubleHi() REQUIRES_SHARED(Locks::mutator_lock_) {
- return *DoubleHiType::GetInstance();
- }
- const UndefinedType& Undefined() REQUIRES_SHARED(Locks::mutator_lock_) {
- return *UndefinedType::GetInstance();
- }
- const ConflictType& Conflict() {
- return *ConflictType::GetInstance();
- }
+ const BooleanType& Boolean() REQUIRES_SHARED(Locks::mutator_lock_);
+ const ByteType& Byte() REQUIRES_SHARED(Locks::mutator_lock_);
+ const CharType& Char() REQUIRES_SHARED(Locks::mutator_lock_);
+ const ShortType& Short() REQUIRES_SHARED(Locks::mutator_lock_);
+ const IntegerType& Integer() REQUIRES_SHARED(Locks::mutator_lock_);
+ const FloatType& Float() REQUIRES_SHARED(Locks::mutator_lock_);
+ const LongLoType& LongLo() REQUIRES_SHARED(Locks::mutator_lock_);
+ const LongHiType& LongHi() REQUIRES_SHARED(Locks::mutator_lock_);
+ const DoubleLoType& DoubleLo() REQUIRES_SHARED(Locks::mutator_lock_);
+ const DoubleHiType& DoubleHi() REQUIRES_SHARED(Locks::mutator_lock_);
+ const UndefinedType& Undefined() REQUIRES_SHARED(Locks::mutator_lock_);
+ const ConflictType& Conflict();
const PreciseReferenceType& JavaLangClass() REQUIRES_SHARED(Locks::mutator_lock_);
const PreciseReferenceType& JavaLangString() REQUIRES_SHARED(Locks::mutator_lock_);
diff --git a/runtime/verifier/verifier_deps.h b/runtime/verifier/verifier_deps.h
index d69e4dc..70ce0c4 100644
--- a/runtime/verifier/verifier_deps.h
+++ b/runtime/verifier/verifier_deps.h
@@ -39,7 +39,7 @@
namespace mirror {
class Class;
class ClassLoader;
-}
+} // namespace mirror
namespace verifier {
diff --git a/test/137-cfi/cfi.cc b/test/137-cfi/cfi.cc
index 3b237f4..1ed1f5a 100644
--- a/test/137-cfi/cfi.cc
+++ b/test/137-cfi/cfi.cc
@@ -33,6 +33,7 @@
#include "gc/heap.h"
#include "gc/space/image_space.h"
#include "oat_file.h"
+#include "runtime.h"
#include "utils.h"
namespace art {
diff --git a/test/ManyMethods/ManyMethods.java b/test/ManyMethods/ManyMethods.java
new file mode 100644
index 0000000..b3a57f6
--- /dev/null
+++ b/test/ManyMethods/ManyMethods.java
@@ -0,0 +1,105 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+class ManyMethods {
+ static class Strings {
+ public static String msg0 = "Hello World";
+ public static String msg1 = "Hello World1";
+ public static String msg2 = "Hello World2";
+ public static String msg3 = "Hello World3";
+ public static String msg4 = "Hello World4";
+ public static String msg5 = "Hello World5";
+ public static String msg6 = "Hello World6";
+ public static String msg7 = "Hello World7";
+ public static String msg8 = "Hello World8";
+ public static String msg9 = "Hello World9";
+ }
+
+ static class Printer {
+ static void Print(String s) {
+ System.out.println(s);
+ }
+ }
+
+ static class Printer2 {
+ static void Print(String s) {
+ System.out.println("AAA" + s);
+ }
+ }
+
+ public static void Print0() {
+ Printer.Print(Strings.msg0);
+ }
+
+ public static void Print1() {
+ Printer.Print(Strings.msg1);
+ }
+
+ public static void Print2() {
+ Printer.Print(Strings.msg2);
+ }
+
+ public static void Print3() {
+ Printer.Print(Strings.msg1);
+ }
+
+ public static void Print4() {
+ Printer.Print(Strings.msg2);
+ }
+
+ public static void Print5() {
+ Printer.Print(Strings.msg3);
+ }
+
+ public static void Print6() {
+ Printer2.Print(Strings.msg4);
+ }
+
+ public static void Print7() {
+ Printer.Print(Strings.msg5);
+ }
+
+ public static void Print8() {
+ Printer.Print(Strings.msg6);
+ }
+
+ public static void Print9() {
+ Printer2.Print(Strings.msg7);
+ }
+
+ public static void Print10() {
+ Printer2.Print(Strings.msg8);
+ }
+
+ public static void Print11() {
+ Printer.Print(Strings.msg9);
+ }
+
+ public static void main(String args[]) {
+ Print0();
+ Print1();
+ Print2();
+ Print3();
+ Print4();
+ Print5();
+ Print6();
+ Print7();
+ Print8();
+ Print9();
+ Print10();
+ Print11();
+ }
+}
