Remove code related to quicken
It was obsolete (and in some cases dead code).
Update our code to use `verify` instead of `quicken`
for compiler filters.
Bug: 289199192
Change-Id: I39048d50b4d8a3f48e0e88e752a2fd7ad73559a7
diff --git a/compiler/optimizing/block_builder.cc b/compiler/optimizing/block_builder.cc
index 703584c..9da2bfb 100644
--- a/compiler/optimizing/block_builder.cc
+++ b/compiler/optimizing/block_builder.cc
@@ -20,7 +20,6 @@
#include "dex/bytecode_utils.h"
#include "dex/code_item_accessors-inl.h"
#include "dex/dex_file_exception_helpers.h"
-#include "quicken_info.h"
namespace art HIDDEN {
@@ -40,9 +39,7 @@
local_allocator->Adapter(kArenaAllocGraphBuilder)),
throwing_blocks_(kDefaultNumberOfThrowingBlocks,
local_allocator->Adapter(kArenaAllocGraphBuilder)),
- number_of_branches_(0u),
- quicken_index_for_dex_pc_(std::less<uint32_t>(),
- local_allocator->Adapter(kArenaAllocGraphBuilder)) {}
+ number_of_branches_(0u) {}
HBasicBlock* HBasicBlockBuilder::MaybeCreateBlockAt(uint32_t dex_pc) {
return MaybeCreateBlockAt(dex_pc, dex_pc);
@@ -147,7 +144,6 @@
HBasicBlock* block = graph_->GetEntryBlock();
graph_->AddBlock(block);
- size_t quicken_index = 0;
bool is_throwing_block = false;
// Calculate the qucikening index here instead of CreateBranchTargets since it's easier to
// calculate in dex_pc order.
@@ -158,8 +154,6 @@
// Check if this dex_pc address starts a new basic block.
HBasicBlock* next_block = GetBlockAt(dex_pc);
if (next_block != nullptr) {
- // We only need quicken index entries for basic block boundaries.
- quicken_index_for_dex_pc_.Put(dex_pc, quicken_index);
if (block != nullptr) {
// Last instruction did not end its basic block but a new one starts here.
// It must have been a block falling through into the next one.
@@ -169,10 +163,6 @@
is_throwing_block = false;
graph_->AddBlock(block);
}
- // Make sure to increment this before the continues.
- if (QuickenInfoTable::NeedsIndexForInstruction(&instruction)) {
- ++quicken_index;
- }
if (block == nullptr) {
// Ignore dead code.
@@ -483,8 +473,4 @@
body->AddSuccessor(exit_block);
}
-size_t HBasicBlockBuilder::GetQuickenIndex(uint32_t dex_pc) const {
- return quicken_index_for_dex_pc_.Get(dex_pc);
-}
-
} // namespace art
diff --git a/compiler/optimizing/block_builder.h b/compiler/optimizing/block_builder.h
index 8668ef8..1aa9375 100644
--- a/compiler/optimizing/block_builder.h
+++ b/compiler/optimizing/block_builder.h
@@ -45,8 +45,6 @@
size_t GetNumberOfBranches() const { return number_of_branches_; }
HBasicBlock* GetBlockAt(uint32_t dex_pc) const { return branch_targets_[dex_pc]; }
- size_t GetQuickenIndex(uint32_t dex_pc) const;
-
private:
// Creates a basic block starting at given `dex_pc`.
HBasicBlock* MaybeCreateBlockAt(uint32_t dex_pc);
@@ -83,9 +81,6 @@
ScopedArenaVector<HBasicBlock*> throwing_blocks_;
size_t number_of_branches_;
- // A table to quickly find the quicken index for the first instruction of a basic block.
- ScopedArenaSafeMap<uint32_t, uint32_t> quicken_index_for_dex_pc_;
-
static constexpr size_t kDefaultNumberOfThrowingBlocks = 2u;
DISALLOW_COPY_AND_ASSIGN(HBasicBlockBuilder);
diff --git a/dex2oat/dex/quick_compiler_callbacks.cc b/dex2oat/dex/quick_compiler_callbacks.cc
index 7611374..c3b1c9b 100644
--- a/dex2oat/dex/quick_compiler_callbacks.cc
+++ b/dex2oat/dex/quick_compiler_callbacks.cc
@@ -47,8 +47,6 @@
return ClassStatus::kNotReady;
}
DCHECK(compiler_driver_ != nullptr);
- // In the case of the quicken filter: avoiding verification of quickened instructions, which the
- // verifier doesn't currently support.
// In the case of the verify filter, avoiding verifiying twice.
return compiler_driver_->GetClassStatus(ref);
}
diff --git a/dex2oat/linker/oat_writer.cc b/dex2oat/linker/oat_writer.cc
index b290c34..41e9cdb 100644
--- a/dex2oat/linker/oat_writer.cc
+++ b/dex2oat/linker/oat_writer.cc
@@ -69,7 +69,6 @@
#include "oat.h"
#include "oat_quick_method_header.h"
#include "profile/profile_compilation_info.h"
-#include "quicken_info.h"
#include "scoped_thread_state_change-inl.h"
#include "stack_map.h"
#include "stream/buffered_output_stream.h"
@@ -338,7 +337,6 @@
vdex_dex_files_offset_(0u),
vdex_dex_shared_data_offset_(0u),
vdex_verifier_deps_offset_(0u),
- vdex_quickening_info_offset_(0u),
vdex_lookup_tables_offset_(0u),
oat_checksum_(adler32(0L, Z_NULL, 0)),
code_size_(0u),
@@ -361,15 +359,12 @@
size_vdex_header_(0),
size_vdex_checksums_(0),
size_dex_file_alignment_(0),
- size_quickening_table_offset_(0),
size_executable_offset_alignment_(0),
size_oat_header_(0),
size_oat_header_key_value_store_(0),
size_dex_file_(0),
size_verifier_deps_(0),
size_verifier_deps_alignment_(0),
- size_quickening_info_(0),
- size_quickening_info_alignment_(0),
size_vdex_lookup_table_alignment_(0),
size_vdex_lookup_table_(0),
size_interpreter_to_interpreter_bridge_(0),
@@ -1276,7 +1271,7 @@
offset_ += code_size;
}
- // Exclude quickened dex methods (code_size == 0) since they have no native code.
+ // Exclude dex methods without native code.
if (generate_debug_info_ && code_size != 0) {
DCHECK(has_debug_info);
const uint8_t* code_info = compiled_method->GetVmapTable().data();
@@ -2508,12 +2503,6 @@
return true;
}
-void OatWriter::WriteQuickeningInfo([[maybe_unused]] /*out*/ std::vector<uint8_t>*) {
- // Nothing to write. Leave `vdex_size_` untouched and unaligned.
- vdex_quickening_info_offset_ = vdex_size_;
- size_quickening_info_alignment_ = 0;
-}
-
void OatWriter::WriteVerifierDeps(verifier::VerifierDeps* verifier_deps,
/*out*/std::vector<uint8_t>* buffer) {
if (verifier_deps == nullptr) {
@@ -2621,7 +2610,6 @@
DO_STAT(size_vdex_header_);
DO_STAT(size_vdex_checksums_);
DO_STAT(size_dex_file_alignment_);
- DO_STAT(size_quickening_table_offset_);
DO_STAT(size_executable_offset_alignment_);
DO_STAT(size_oat_header_);
DO_STAT(size_oat_header_key_value_store_);
@@ -2630,8 +2618,6 @@
DO_STAT(size_verifier_deps_alignment_);
DO_STAT(size_vdex_lookup_table_);
DO_STAT(size_vdex_lookup_table_alignment_);
- DO_STAT(size_quickening_info_);
- DO_STAT(size_quickening_info_alignment_);
DO_STAT(size_interpreter_to_interpreter_bridge_);
DO_STAT(size_interpreter_to_compiled_code_bridge_);
DO_STAT(size_jni_dlsym_lookup_trampoline_);
diff --git a/dex2oat/linker/oat_writer.h b/dex2oat/linker/oat_writer.h
index 79ec47e..a10572a 100644
--- a/dex2oat/linker/oat_writer.h
+++ b/dex2oat/linker/oat_writer.h
@@ -93,7 +93,7 @@
// ...
// MethodBssMapping
//
-// VmapTable one variable sized VmapTable blob (CodeInfo or QuickeningInfo).
+// VmapTable one variable sized VmapTable blob (CodeInfo).
// VmapTable VmapTables are deduplicated.
// ...
// VmapTable
@@ -286,7 +286,6 @@
bool OpenDexFiles(File* file,
/*inout*/ std::vector<MemMap>* opened_dex_files_map,
/*out*/ std::vector<std::unique_ptr<const DexFile>>* opened_dex_files);
- void WriteQuickeningInfo(/*out*/std::vector<uint8_t>* buffer);
void WriteTypeLookupTables(/*out*/std::vector<uint8_t>* buffer);
void WriteVerifierDeps(verifier::VerifierDeps* verifier_deps,
/*out*/std::vector<uint8_t>* buffer);
@@ -397,9 +396,6 @@
// Offset of section holding VerifierDeps inside Vdex.
size_t vdex_verifier_deps_offset_;
- // Offset of section holding quickening info inside Vdex.
- size_t vdex_quickening_info_offset_;
-
// Offset of type lookup tables inside Vdex.
size_t vdex_lookup_tables_offset_;
@@ -500,15 +496,12 @@
uint32_t size_vdex_header_;
uint32_t size_vdex_checksums_;
uint32_t size_dex_file_alignment_;
- uint32_t size_quickening_table_offset_;
uint32_t size_executable_offset_alignment_;
uint32_t size_oat_header_;
uint32_t size_oat_header_key_value_store_;
uint32_t size_dex_file_;
uint32_t size_verifier_deps_;
uint32_t size_verifier_deps_alignment_;
- uint32_t size_quickening_info_;
- uint32_t size_quickening_info_alignment_;
uint32_t size_vdex_lookup_table_alignment_;
uint32_t size_vdex_lookup_table_;
uint32_t size_interpreter_to_interpreter_bridge_;
diff --git a/libartbase/base/compiler_filter.cc b/libartbase/base/compiler_filter.cc
index b4f924d..5f86256 100644
--- a/libartbase/base/compiler_filter.cc
+++ b/libartbase/base/compiler_filter.cc
@@ -163,7 +163,7 @@
*filter = kAssumeVerified;
} else if (strcmp(option, "interpret-only") == 0) {
LOG(WARNING) << "'interpret-only' is an obsolete compiler filter name that will be "
- << "removed in future releases, please use 'quicken' instead.";
+ << "removed in future releases, please use 'verify' instead.";
*filter = kVerify;
} else if (strcmp(option, "verify-profile") == 0) {
LOG(WARNING) << "'verify-profile' is an obsolete compiler filter name that will be "
diff --git a/runtime/art_method.cc b/runtime/art_method.cc
index b500d9b..c7be2dc 100644
--- a/runtime/art_method.cc
+++ b/runtime/art_method.cc
@@ -49,7 +49,6 @@
#include "mirror/object_array-inl.h"
#include "mirror/string.h"
#include "oat_file-inl.h"
-#include "quicken_info.h"
#include "runtime_callbacks.h"
#include "scoped_thread_state_change-inl.h"
#include "vdex_file.h"
diff --git a/runtime/dex/dex_file_annotations.cc b/runtime/dex/dex_file_annotations.cc
index 7c1dd1e..827ced9 100644
--- a/runtime/dex/dex_file_annotations.cc
+++ b/runtime/dex/dex_file_annotations.cc
@@ -37,7 +37,6 @@
#include "mirror/object_array-inl.h"
#include "oat_file.h"
#include "obj_ptr-inl.h"
-#include "quicken_info.h"
#include "reflection.h"
#include "thread.h"
#include "well_known_classes.h"
diff --git a/runtime/native/dalvik_system_ZygoteHooks.cc b/runtime/native/dalvik_system_ZygoteHooks.cc
index a052b62..49e5188 100644
--- a/runtime/native/dalvik_system_ZygoteHooks.cc
+++ b/runtime/native/dalvik_system_ZygoteHooks.cc
@@ -187,8 +187,8 @@
const bool safe_mode = (runtime_flags & DEBUG_ENABLE_SAFEMODE) != 0;
if (safe_mode) {
- // Only quicken oat files.
- runtime->AddCompilerOption("--compiler-filter=quicken");
+ // Only verify oat files.
+ runtime->AddCompilerOption("--compiler-filter=verify");
runtime->SetSafeMode(true);
runtime_flags &= ~DEBUG_ENABLE_SAFEMODE;
}
diff --git a/runtime/oat_file_assistant.h b/runtime/oat_file_assistant.h
index 922dbf3..402e9ae 100644
--- a/runtime/oat_file_assistant.h
+++ b/runtime/oat_file_assistant.h
@@ -204,10 +204,8 @@
// compiler filter is at least as good as an oat file generated with the
// given compiler filter otherwise, if its set to true, it checks whether
// the oat file generated with the target filter will be downgraded as
- // compared to the current state. For example, if the current compiler filter is
- // quicken, and target filter is verify, it will recommend to dexopt, while
- // if the target filter is speed profile, it will recommend to keep it in its
- // current state.
+ // compared to the current state. For example, if the current compiler filter is verify and the
+ // target filter is speed profile it will recommend to keep it in its current state.
// profile_changed should be true to indicate the profile has recently changed
// for this dex location.
// If the purpose of the dexopt is to downgrade the compiler filter,
diff --git a/runtime/quicken_info.h b/runtime/quicken_info.h
deleted file mode 100644
index 83dc5f1..0000000
--- a/runtime/quicken_info.h
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- * 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.
- */
-
-#ifndef ART_RUNTIME_QUICKEN_INFO_H_
-#define ART_RUNTIME_QUICKEN_INFO_H_
-
-#include "base/array_ref.h"
-#include "base/leb128.h"
-#include "dex/compact_offset_table.h"
-#include "dex/dex_instruction.h"
-
-namespace art {
-
-// QuickenInfoTable is a table of 16 bit dex indices. There is one slot for every instruction that
-// is possibly dequickenable.
-class QuickenInfoTable {
- public:
- class Builder {
- public:
- Builder(std::vector<uint8_t>* out_data, size_t num_elements) : out_data_(out_data) {
- EncodeUnsignedLeb128(out_data_, num_elements);
- }
-
- void AddIndex(uint16_t index) {
- out_data_->push_back(static_cast<uint8_t>(index));
- out_data_->push_back(static_cast<uint8_t>(index >> 8));
- }
-
- private:
- std::vector<uint8_t>* const out_data_;
- };
-
- explicit QuickenInfoTable(ArrayRef<const uint8_t> data)
- : data_(data.data()),
- num_elements_(!data.empty() ? DecodeUnsignedLeb128(&data_) : 0u) {}
-
- bool IsNull() const {
- return data_ == nullptr;
- }
-
- uint16_t GetData(size_t index) const {
- return data_[index * 2] | (static_cast<uint16_t>(data_[index * 2 + 1]) << 8);
- }
-
- // Returns true if the dex instruction has an index in the table. (maybe dequickenable).
- static bool NeedsIndexForInstruction(const Instruction* inst) {
- return inst->IsQuickened();
- }
-
- static size_t NumberOfIndices(size_t bytes) {
- return bytes / sizeof(uint16_t);
- }
-
- static size_t SizeInBytes(ArrayRef<const uint8_t> data) {
- QuickenInfoTable table(data);
- return table.data_ + table.NumIndices() * 2 - data.data();
- }
-
- uint32_t NumIndices() const {
- return num_elements_;
- }
-
- private:
- const uint8_t* data_;
- const uint32_t num_elements_;
-
- DISALLOW_COPY_AND_ASSIGN(QuickenInfoTable);
-};
-
-} // namespace art
-
-#endif // ART_RUNTIME_QUICKEN_INFO_H_
diff --git a/runtime/runtime.cc b/runtime/runtime.cc
index f3bd4dd..62f6a13 100644
--- a/runtime/runtime.cc
+++ b/runtime/runtime.cc
@@ -3014,7 +3014,7 @@
void Runtime::AddCurrentRuntimeFeaturesAsDex2OatArguments(std::vector<std::string>* argv)
const {
if (GetInstrumentation()->InterpretOnly()) {
- argv->push_back("--compiler-filter=quicken");
+ argv->push_back("--compiler-filter=verify");
}
// Make the dex2oat instruction set match that of the launching runtime. If we have multiple
diff --git a/runtime/vdex_file.cc b/runtime/vdex_file.cc
index 5a5d3bc..ef4fb5e 100644
--- a/runtime/vdex_file.cc
+++ b/runtime/vdex_file.cc
@@ -40,7 +40,6 @@
#include "gc/heap.h"
#include "gc/space/image_space.h"
#include "mirror/class-inl.h"
-#include "quicken_info.h"
#include "handle_scope-inl.h"
#include "runtime.h"
#include "verifier/verifier_deps.h"
diff --git a/runtime/vdex_file.h b/runtime/vdex_file.h
index fe65c07..2a5655f 100644
--- a/runtime/vdex_file.h
+++ b/runtime/vdex_file.h
@@ -27,7 +27,6 @@
#include "class_status.h"
#include "dex/compact_offset_table.h"
#include "dex/dex_file.h"
-#include "quicken_info.h"
#include "handle.h"
namespace art {
diff --git a/test/595-profile-saving/run.py b/test/595-profile-saving/run.py
index 96de281..599f76a 100644
--- a/test/595-profile-saving/run.py
+++ b/test/595-profile-saving/run.py
@@ -17,16 +17,16 @@
def run(ctx, args):
# Use
- # --compiler-filter=quicken to make sure that the test is not compiled AOT
+ # --compiler-filter=verify to make sure that the test is not compiled AOT
# and to make sure the test is not compiled when loaded (by PathClassLoader)
# -Xjitsaveprofilinginfo to enable profile saving
# -Xusejit:false to disable jit and only test profiles.
# -Xjitinitialsize:32M to prevent profiling info creation failure.
ctx.default_run(
args,
- Xcompiler_option=["--compiler-filter=quicken"],
+ Xcompiler_option=["--compiler-filter=verify"],
runtime_option=[
- "-Xcompiler-option --compiler-filter=quicken",
+ "-Xcompiler-option --compiler-filter=verify",
"-Xjitinitialsize:32M",
"-Xjitsaveprofilinginfo",
"-Xusejit:false",
diff --git a/tools/dexfuzz/src/dexfuzz/executors/Executor.java b/tools/dexfuzz/src/dexfuzz/executors/Executor.java
index 0367a83..1706d5b 100644
--- a/tools/dexfuzz/src/dexfuzz/executors/Executor.java
+++ b/tools/dexfuzz/src/dexfuzz/executors/Executor.java
@@ -115,7 +115,7 @@
commandBuilder.append("--oat-file=output.oat ");
commandBuilder.append("--android-root=").append(device.getAndroidHostOut()).append(" ");
commandBuilder.append("--dex-file=").append(programName).append(" ");
- commandBuilder.append("--compiler-filter=quicken --runtime-arg -Xnorelocate ");
+ commandBuilder.append("--compiler-filter=verify --runtime-arg -Xnorelocate ");
ExecutionResult verificationResult = device.executeCommand(commandBuilder.toString(), true,
outputConsumer, errorConsumer);
diff --git a/tools/run-jdwp-tests.sh b/tools/run-jdwp-tests.sh
index fec969c..699a2e5 100755
--- a/tools/run-jdwp-tests.sh
+++ b/tools/run-jdwp-tests.sh
@@ -386,9 +386,9 @@
if [[ $mode != "ri" ]]; then
# Because we're running debuggable, we discard any AOT code.
- # Therefore we run de2oat with 'quicken' to avoid spending time compiling.
- vm_args="$vm_args --vm-arg -Xcompiler-option --vm-arg --compiler-filter=quicken"
- debuggee_args="$debuggee_args -Xcompiler-option --compiler-filter=quicken"
+ # Therefore we run dex2oat with 'verify' to avoid spending time compiling.
+ vm_args="$vm_args --vm-arg -Xcompiler-option --vm-arg --compiler-filter=verify"
+ debuggee_args="$debuggee_args -Xcompiler-option --compiler-filter=verify"
if $instant_jit; then
debuggee_args="$debuggee_args -Xjitthreshold:0"
diff --git a/tools/run-libcore-tests.py b/tools/run-libcore-tests.py
index c6958f1..e5ece24 100755
--- a/tools/run-libcore-tests.py
+++ b/tools/run-libcore-tests.py
@@ -446,7 +446,7 @@
cmd.append("--timeout {}".format(get_timeout_secs()))
cmd.append("--toolchain d8 --language CUR")
if args.jit:
- cmd.append("--vm-arg -Xcompiler-option --vm-arg --compiler-filter=quicken")
+ cmd.append("--vm-arg -Xcompiler-option --vm-arg --compiler-filter=verify")
cmd.append("--vm-arg -Xusejit:{}".format(str(args.jit).lower()))
if args.verbose: