king
/
v811_spc009
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'main'
${ noResults }
v811_spc009/art/tools/dexanalyze/dexanalyze_bytecode.cc

598 lines
22 KiB
Raw Permalink Blame History

/*
* Copyright (C) 2018 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "dexanalyze_bytecode.h"
#include <algorithm>
#include <iomanip>
#include <iostream>
#include "dex/class_accessor-inl.h"
#include "dex/code_item_accessors-inl.h"
#include "dex/dex_instruction-inl.h"
namespace art {
namespace dexanalyze {
// Given a map of <key, usage count>, sort by most used and assign index <key, index in most used>
enum class Order {
kMostUsed,
kNormal,
};
template <typename T, typename U>
static inline SafeMap<T, U> SortByOrder(const SafeMap<T, U>& usage, Order order) {
std::vector<std::pair<U, T>> most_used;
for (const auto& pair : usage) {
most_used.emplace_back(pair.second, pair.first);
}
if (order == Order::kMostUsed) {
std::sort(most_used.rbegin(), most_used.rend());
}
U current_index = 0u;
SafeMap<T, U> ret;
for (auto&& pair : most_used) {
CHECK(ret.emplace(pair.second, current_index++).second);
}
return ret;
}
template <typename A, typename B>
std::ostream& operator <<(std::ostream& os, const std::pair<A, B>& pair) {
return os << "{" << pair.first << ", " << pair.second << "}";
}
template <typename T, typename... Args, template <typename...> class ArrayType>
SafeMap<size_t, T> MakeUsageMap(const ArrayType<T, Args...>& array) {
SafeMap<size_t, T> ret;
for (size_t i = 0; i < array.size(); ++i) {
if (array[i] > 0) {
ret.Put(i, array[i]);
}
}
return ret;
}
template <typename T, typename U, typename... Args, template <typename...> class Map>
void PrintMostUsed(std::ostream& os,
const Map<T, U, Args...>& usage,
size_t max_count,
std::function<void(std::ostream& os, T)> printer =
[](std::ostream& os, T v) {
os << v;
}) {
std::vector<std::pair<U, T>> sorted;
uint64_t total = 0u;
for (const auto& pair : usage) {
sorted.emplace_back(pair.second, pair.first);
total += pair.second;
}
std::sort(sorted.rbegin(), sorted.rend());
uint64_t other = 0u;
for (auto&& pair : sorted) {
if (max_count > 0) {
os << Percent(pair.first, total) << " : ";
printer(os, pair.second);
os << "\n";
--max_count;
} else {
other += pair.first;
}
}
if (other != 0u) {
os << "other: " << Percent(other, total) << "\n";
}
}
static inline std::ostream& operator<<(std::ostream& os, const std::vector<uint8_t>& bytes) {
os << std::hex;
for (const uint8_t& c : bytes) {
os << std::setw(2) << std::setfill('0') << static_cast<uint32_t>(c)
<< (&c != &bytes.back() ? " " : "");
}
os << std::dec;
return os;
}
void NewRegisterInstructions::ProcessDexFiles(
const std::vector<std::unique_ptr<const DexFile>>& dex_files) {
std::set<std::vector<uint8_t>> deduped;
for (const std::unique_ptr<const DexFile>& dex_file : dex_files) {
std::map<size_t, TypeLinkage> types;
std::set<const void*> visited;
for (ClassAccessor accessor : dex_file->GetClasses()) {
for (const ClassAccessor::Method& method : accessor.GetMethods()) {
ProcessCodeItem(*dex_file,
method.GetInstructionsAndData(),
accessor.GetClassIdx(),
/*count_types=*/ true,
types);
}
}
// Reorder to get an index for each map instead of a count.
for (auto&& pair : types) {
pair.second.types_ = SortByOrder(pair.second.types_, Order::kMostUsed);
pair.second.fields_ = SortByOrder(pair.second.fields_, Order::kMostUsed);
pair.second.methods_ = SortByOrder(pair.second.methods_, Order::kMostUsed);
pair.second.strings_ = SortByOrder(pair.second.strings_, Order::kMostUsed);
}
// Visit classes and convert code items.
for (ClassAccessor accessor : dex_file->GetClasses()) {
for (const ClassAccessor::Method& method : accessor.GetMethods()) {
if (method.GetCodeItem() == nullptr || !visited.insert(method.GetCodeItem()).second) {
continue;
}
if (verbose_level_ >= VerboseLevel::kEverything) {
std::cout << std::endl
<< "Processing " << dex_file->PrettyMethod(method.GetIndex(), true);
}
CodeItemDataAccessor data = method.GetInstructionsAndData();
ProcessCodeItem(*dex_file,
data,
accessor.GetClassIdx(),
/*count_types=*/ false,
types);
std::vector<uint8_t> buffer = std::move(buffer_);
buffer_.clear();
const size_t buffer_size = buffer.size();
dex_code_bytes_ += data.InsnsSizeInBytes();
output_size_ += buffer_size;
// Add extra data at the end to have fair dedupe.
EncodeUnsignedLeb128(&buffer, data.RegistersSize());
EncodeUnsignedLeb128(&buffer, data.InsSize());
EncodeUnsignedLeb128(&buffer, data.OutsSize());
EncodeUnsignedLeb128(&buffer, data.TriesSize());
EncodeUnsignedLeb128(&buffer, data.InsnsSizeInCodeUnits());
if (deduped.insert(buffer).second) {
deduped_size_ += buffer_size;
}
}
}
}
}
void NewRegisterInstructions::Dump(std::ostream& os, uint64_t total_size) const {
os << "Enabled experiments " << experiments_ << std::endl;
os << "Total Dex code bytes: " << Percent(dex_code_bytes_, total_size) << "\n";
os << "Total output code bytes: " << Percent(output_size_, total_size) << "\n";
os << "Total deduped code bytes: " << Percent(deduped_size_, total_size) << "\n";
std::vector<std::pair<size_t, std::vector<uint8_t>>> pairs;
for (auto&& pair : instruction_freq_) {
if (pair.second > 0 && !pair.first.empty()) {
// Savings exclude one byte per occurrence and one occurrence from having the macro
// dictionary.
pairs.emplace_back((pair.second - 1) * (pair.first.size() - 1), pair.first);
}
}
std::sort(pairs.rbegin(), pairs.rend());
static constexpr size_t kMaxMacros = 128;
static constexpr size_t kMaxPrintedMacros = 32;
uint64_t top_instructions_savings = 0u;
for (size_t i = 0; i < kMaxMacros && i < pairs.size(); ++i) {
top_instructions_savings += pairs[i].first;
}
if (verbose_level_ >= VerboseLevel::kNormal) {
os << "Move result register distribution" << "\n";
PrintMostUsed(os, MakeUsageMap(move_result_reg_), 16);
os << "First arg register usage\n";
std::function<void(std::ostream& os, size_t)> printer = [&](std::ostream& os, size_t idx) {
os << Instruction::Name(static_cast<Instruction::Code>(idx));
};
PrintMostUsed(os, MakeUsageMap(first_arg_reg_count_), 16, printer);
os << "Most used field linkage pairs\n";
PrintMostUsed(os, field_linkage_counts_, 32);
os << "Current extended " << extended_field_ << "\n";
os << "Most used method linkage pairs\n";
PrintMostUsed(os, method_linkage_counts_, 32);
os << "Current extended " << extended_method_ << "\n";
os << "Top " << kMaxMacros << " instruction bytecode sizes and hex dump" << "\n";
for (size_t i = 0; i < kMaxMacros && i < pairs.size(); ++i) {
auto bytes = pairs[i].second;
// Remove opcode bytes.
bytes.erase(bytes.begin());
if (i < kMaxPrintedMacros) {
os << Percent(pairs[i].first, total_size) << " "
<< Instruction::Name(static_cast<Instruction::Code>(pairs[i].second[0]))
<< "(" << bytes << ")\n";
}
}
}
os << "Top instructions 1b macro savings "
<< Percent(top_instructions_savings, total_size) << "\n";
}
void NewRegisterInstructions::ProcessCodeItem(const DexFile& dex_file,
const CodeItemDataAccessor& code_item,
dex::TypeIndex current_class_type,
bool count_types,
std::map<size_t, TypeLinkage>& types) {
TypeLinkage& current_type = types[current_class_type.index_];
bool skip_next = false;
for (auto inst = code_item.begin(); inst != code_item.end(); ++inst) {
if (verbose_level_ >= VerboseLevel::kEverything) {
std::cout << std::endl;
std::cout << inst->DumpString(nullptr);
if (skip_next) {
std::cout << " (SKIPPED)";
}
}
if (skip_next) {
skip_next = false;
continue;
}
bool is_iget = false;
const Instruction::Code opcode = inst->Opcode();
Instruction::Code new_opcode = opcode;
++opcode_count_[opcode];
switch (opcode) {
case Instruction::IGET:
case Instruction::IGET_WIDE:
case Instruction::IGET_OBJECT:
case Instruction::IGET_BOOLEAN:
case Instruction::IGET_BYTE:
case Instruction::IGET_CHAR:
case Instruction::IGET_SHORT:
is_iget = true;
FALLTHROUGH_INTENDED;
case Instruction::IPUT:
case Instruction::IPUT_WIDE:
case Instruction::IPUT_OBJECT:
case Instruction::IPUT_BOOLEAN:
case Instruction::IPUT_BYTE:
case Instruction::IPUT_CHAR:
case Instruction::IPUT_SHORT: {
const uint32_t dex_field_idx = inst->VRegC_22c();
if (Enabled(kExperimentSingleGetSet)) {
// Test deduplication improvements from replacing all iget/set with the same opcode.
new_opcode = is_iget ? Instruction::IGET : Instruction::IPUT;
}
CHECK_LT(dex_field_idx, dex_file.NumFieldIds());
dex::TypeIndex holder_type = dex_file.GetFieldId(dex_field_idx).class_idx_;
uint32_t receiver = inst->VRegB_22c();
uint32_t first_arg_reg = code_item.RegistersSize() - code_item.InsSize();
uint32_t out_reg = inst->VRegA_22c();
if (Enabled(kExperimentInstanceFieldSelf) &&
first_arg_reg == receiver &&
holder_type == current_class_type) {
if (count_types) {
++current_type.fields_.FindOrAdd(dex_field_idx)->second;
} else {
uint32_t field_idx = types[holder_type.index_].fields_.Get(dex_field_idx);
ExtendPrefix(&out_reg, &field_idx);
CHECK(InstNibbles(new_opcode, {out_reg, field_idx}));
continue;
}
} else if (Enabled(kExperimentInstanceField)) {
if (count_types) {
++current_type.types_.FindOrAdd(holder_type.index_)->second;
++types[holder_type.index_].fields_.FindOrAdd(dex_field_idx)->second;
} else {
uint32_t type_idx = current_type.types_.Get(holder_type.index_);
uint32_t field_idx = types[holder_type.index_].fields_.Get(dex_field_idx);
ExtendPrefix(&type_idx, &field_idx);
CHECK(InstNibbles(new_opcode, {out_reg, receiver, type_idx, field_idx}));
continue;
}
}
break;
}
case Instruction::CONST_STRING:
case Instruction::CONST_STRING_JUMBO: {
const bool is_jumbo = opcode == Instruction::CONST_STRING_JUMBO;
const uint16_t str_idx = is_jumbo ? inst->VRegB_31c() : inst->VRegB_21c();
uint32_t out_reg = is_jumbo ? inst->VRegA_31c() : inst->VRegA_21c();
if (Enabled(kExperimentString)) {
new_opcode = Instruction::CONST_STRING;
if (count_types) {
++current_type.strings_.FindOrAdd(str_idx)->second;
} else {
uint32_t idx = current_type.strings_.Get(str_idx);
ExtendPrefix(&out_reg, &idx);
CHECK(InstNibbles(opcode, {out_reg, idx}));
continue;
}
}
break;
}
case Instruction::SGET:
case Instruction::SGET_WIDE:
case Instruction::SGET_OBJECT:
case Instruction::SGET_BOOLEAN:
case Instruction::SGET_BYTE:
case Instruction::SGET_CHAR:
case Instruction::SGET_SHORT:
case Instruction::SPUT:
case Instruction::SPUT_WIDE:
case Instruction::SPUT_OBJECT:
case Instruction::SPUT_BOOLEAN:
case Instruction::SPUT_BYTE:
case Instruction::SPUT_CHAR:
case Instruction::SPUT_SHORT: {
uint32_t out_reg = inst->VRegA_21c();
const uint32_t dex_field_idx = inst->VRegB_21c();
CHECK_LT(dex_field_idx, dex_file.NumFieldIds());
dex::TypeIndex holder_type = dex_file.GetFieldId(dex_field_idx).class_idx_;
if (Enabled(kExperimentStaticField)) {
if (holder_type == current_class_type) {
if (count_types) {
++types[holder_type.index_].fields_.FindOrAdd(dex_field_idx)->second;
} else {
uint32_t field_idx = types[holder_type.index_].fields_.Get(dex_field_idx);
ExtendPrefix(&out_reg, &field_idx);
if (InstNibbles(new_opcode, {out_reg, field_idx})) {
continue;
}
}
} else {
if (count_types) {
++types[current_class_type.index_].types_.FindOrAdd(holder_type.index_)->second;
++types[holder_type.index_].fields_.FindOrAdd(dex_field_idx)->second;
} else {
uint32_t type_idx = current_type.types_.Get(holder_type.index_);
uint32_t field_idx = types[holder_type.index_].fields_.Get(dex_field_idx);
++field_linkage_counts_[std::make_pair(type_idx, field_idx)];
extended_field_ += ExtendPrefix(&type_idx, &field_idx) ? 1u : 0u;
if (InstNibbles(new_opcode, {out_reg >> 4, out_reg & 0xF, type_idx, field_idx})) {
continue;
}
}
}
}
break;
}
// Invoke cases.
case Instruction::INVOKE_VIRTUAL:
case Instruction::INVOKE_DIRECT:
case Instruction::INVOKE_STATIC:
case Instruction::INVOKE_INTERFACE:
case Instruction::INVOKE_SUPER: {
const uint32_t method_idx = DexMethodIndex(inst.Inst());
const dex::MethodId& method = dex_file.GetMethodId(method_idx);
const dex::TypeIndex receiver_type = method.class_idx_;
if (Enabled(kExperimentInvoke)) {
if (count_types) {
++current_type.types_.FindOrAdd(receiver_type.index_)->second;
++types[receiver_type.index_].methods_.FindOrAdd(method_idx)->second;
} else {
uint32_t args[6] = {};
uint32_t arg_count = inst->GetVarArgs(args);
const uint32_t first_arg_reg = code_item.RegistersSize() - code_item.InsSize();
bool next_move_result = false;
uint32_t dest_reg = 0;
auto next = std::next(inst);
if (next != code_item.end()) {
next_move_result =
next->Opcode() == Instruction::MOVE_RESULT ||
next->Opcode() == Instruction::MOVE_RESULT_WIDE ||
next->Opcode() == Instruction::MOVE_RESULT_OBJECT;
if (next_move_result) {
dest_reg = next->VRegA_11x();
++move_result_reg_[dest_reg];
}
}
uint32_t type_idx = current_type.types_.Get(receiver_type.index_);
uint32_t local_idx = types[receiver_type.index_].methods_.Get(method_idx);
++method_linkage_counts_[std::make_pair(type_idx, local_idx)];
// If true, we always put the return value in r0.
static constexpr bool kMoveToDestReg = true;
std::vector<uint32_t> new_args;
if (kMoveToDestReg && arg_count % 2 == 1) {
// Use the extra nibble to sneak in part of the type index.
new_args.push_back(local_idx >> 4);
local_idx &= ~0xF0;
}
extended_method_ += ExtendPrefix(&type_idx, &local_idx) ? 1u : 0u;
new_args.push_back(type_idx);
new_args.push_back(local_idx);
if (!kMoveToDestReg) {
ExtendPrefix(&dest_reg, &local_idx);
new_args.push_back(dest_reg);
}
for (size_t i = 0; i < arg_count; ++i) {
if (args[i] == first_arg_reg) {
++first_arg_reg_count_[opcode];
break;
}
}
new_args.insert(new_args.end(), args, args + arg_count);
if (InstNibbles(opcode, new_args)) {
skip_next = next_move_result;
if (kMoveToDestReg && dest_reg != 0u) {
CHECK(InstNibbles(Instruction::MOVE, {dest_reg >> 4, dest_reg & 0xF}));
}
continue;
}
}
}
break;
}
case Instruction::IF_EQZ:
case Instruction::IF_NEZ: {
uint32_t reg = inst->VRegA_21t();
int16_t offset = inst->VRegB_21t();
if (!count_types &&
Enabled(kExperimentSmallIf) &&
InstNibbles(opcode, {reg, static_cast<uint16_t>(offset)})) {
continue;
}
break;
}
case Instruction::INSTANCE_OF: {
uint32_t type_idx = inst->VRegC_22c();
uint32_t in_reg = inst->VRegB_22c();
uint32_t out_reg = inst->VRegA_22c();
if (count_types) {
++current_type.types_.FindOrAdd(type_idx)->second;
} else {
uint32_t local_type = current_type.types_.Get(type_idx);
ExtendPrefix(&in_reg, &local_type);
CHECK(InstNibbles(new_opcode, {in_reg, out_reg, local_type}));
continue;
}
break;
}
case Instruction::NEW_ARRAY: {
uint32_t len_reg = inst->VRegB_22c();
uint32_t type_idx = inst->VRegC_22c();
uint32_t out_reg = inst->VRegA_22c();
if (count_types) {
++current_type.types_.FindOrAdd(type_idx)->second;
} else {
uint32_t local_type = current_type.types_.Get(type_idx);
ExtendPrefix(&out_reg, &local_type);
CHECK(InstNibbles(new_opcode, {len_reg, out_reg, local_type}));
continue;
}
break;
}
case Instruction::CONST_CLASS:
case Instruction::CHECK_CAST:
case Instruction::NEW_INSTANCE: {
uint32_t type_idx = inst->VRegB_21c();
uint32_t out_reg = inst->VRegA_21c();
if (Enabled(kExperimentLocalType)) {
if (count_types) {
++current_type.types_.FindOrAdd(type_idx)->second;
} else {
bool next_is_init = false;
if (opcode == Instruction::NEW_INSTANCE) {
auto next = std::next(inst);
if (next != code_item.end() && next->Opcode() == Instruction::INVOKE_DIRECT) {
uint32_t args[6] = {};
uint32_t arg_count = next->GetVarArgs(args);
uint32_t method_idx = DexMethodIndex(next.Inst());
if (arg_count == 1u &&
args[0] == out_reg &&
dex_file.GetMethodName(dex_file.GetMethodId(method_idx)) ==
std::string("<init>")) {
next_is_init = true;
}
}
}
uint32_t local_type = current_type.types_.Get(type_idx);
ExtendPrefix(&out_reg, &local_type);
CHECK(InstNibbles(opcode, {out_reg, local_type}));
skip_next = next_is_init;
continue;
}
}
break;
}
case Instruction::RETURN:
case Instruction::RETURN_OBJECT:
case Instruction::RETURN_WIDE:
case Instruction::RETURN_VOID: {
if (!count_types && Enabled(kExperimentReturn)) {
if (opcode == Instruction::RETURN_VOID || inst->VRegA_11x() == 0) {
if (InstNibbles(opcode, {})) {
continue;
}
}
}
break;
}
default:
break;
}
if (!count_types) {
Add(new_opcode, inst.Inst());
}
}
if (verbose_level_ >= VerboseLevel::kEverything) {
std::cout << std::endl
<< "Bytecode size " << code_item.InsnsSizeInBytes() << " -> " << buffer_.size();
std::cout << std::endl;
}
}
void NewRegisterInstructions::Add(Instruction::Code opcode, const Instruction& inst) {
const uint8_t* start = reinterpret_cast<const uint8_t*>(&inst);
const size_t buffer_start = buffer_.size();
buffer_.push_back(opcode);
buffer_.insert(buffer_.end(), start + 1, start + 2 * inst.SizeInCodeUnits());
// Register the instruction blob.
++instruction_freq_[std::vector<uint8_t>(buffer_.begin() + buffer_start, buffer_.end())];
}
bool NewRegisterInstructions::ExtendPrefix(uint32_t* value1, uint32_t* value2) {
if (*value1 < 16 && *value2 < 16) {
return false;
}
if ((*value1 >> 4) == 1 && *value2 < 16) {
InstNibbles(0xE5, {});
*value1 ^= 1u << 4;
return true;
} else if ((*value2 >> 4) == 1 && *value1 < 16) {
InstNibbles(0xE6, {});
*value2 ^= 1u << 4;
return true;
}
if (*value1 < 256 && *value2 < 256) {
// Extend each value by 4 bits.
CHECK(InstNibbles(0xE3, {*value1 >> 4, *value2 >> 4}));
} else {
// Extend each value by 12 bits.
CHECK(InstNibbles(0xE4, {
(*value1 >> 12) & 0xF,
(*value1 >> 8) & 0xF,
(*value1 >> 4) & 0xF,
(*value2 >> 12) & 0xF,
(*value2 >> 8) & 0xF,
(*value2 >> 4) & 0xF}));
}
*value1 &= 0xF;
*value2 &= 0XF;
return true;
}
bool NewRegisterInstructions::InstNibbles(uint8_t opcode, const std::vector<uint32_t>& args) {
if (verbose_level_ >= VerboseLevel::kEverything) {
std::cout << " ==> " << Instruction::Name(static_cast<Instruction::Code>(opcode)) << " ";
for (int v : args) {
std::cout << v << ", ";
}
}
for (int v : args) {
if (v >= 16) {
if (verbose_level_ >= VerboseLevel::kEverything) {
std::cout << "(OUT_OF_RANGE)";
}
return false;
}
}
const size_t buffer_start = buffer_.size();
buffer_.push_back(opcode);
for (size_t i = 0; i < args.size(); i += 2) {
buffer_.push_back(args[i] << 4);
if (i + 1 < args.size()) {
buffer_.back() |= args[i + 1];
}
}
while (buffer_.size() % alignment_ != 0) {
buffer_.push_back(0);
}
// Register the instruction blob.
++instruction_freq_[std::vector<uint8_t>(buffer_.begin() + buffer_start, buffer_.end())];
return true;
}
} // namespace dexanalyze
} // namespace art
Reference in new issue View Git Blame Copy Permalink