void LayoutReachabilityPass::run_pass(DexStoresVector& stores,
ConfigFiles& conf,
PassManager& mgr) {
TRACE(PGR, 1, "Recomputing layout classes\n");
std::string apk_dir;
conf.get_json_config().get("apk_dir", "", apk_dir);
always_assert(apk_dir.size());
auto scope = build_class_scope(stores);
// Update the m_byresources rstate flags on classes/methods
recompute_reachable_from_xml_layouts(scope, apk_dir);
}
void AddRedexTxtToApkPass::run_pass(DexStoresVector& /* unused */,
ConfigFiles& conf,
PassManager& /* unused */) {
std::string apk_dir;
conf.get_json_config().get("apk_dir", "", apk_dir);
if (!apk_dir.size()) {
TRACE(ADD_REDEX_TXT, 2, "apk_dir not set, so not writing redex.txt\n");
return;
}
std::string out_file_name = apk_dir + "/redex.txt";
std::ofstream redex_txt(out_file_name);
if (redex_txt.is_open()) {
redex_txt << "Optimized by Redex" << std::endl
<< "http://fbredex.com/" << std::endl;
redex_txt.close();
} else {
opt_warn(CANT_WRITE_FILE, "Unable to write file %s\n", out_file_name.c_str());
}
}
void RenameClassesPass::run_pass(DexStoresVector& stores,
ConfigFiles& cfg,
PassManager& mgr) {
const JsonWrapper& json_cfg = cfg.get_json_config();
if (json_cfg.get("emit_name_based_locators", false)) {
// TODO: Purge the old RenameClassesPass entirely everywhere.
fprintf(stderr,
"[RenameClassesPass] error: Configuration option "
"emit_locator_strings is not compatible with RenameClassesPass. "
"Upgrade to RenameClassesPassV2 instead.\n");
exit(EXIT_FAILURE);
}
auto scope = build_class_scope(stores);
ClassHierarchy ch = build_type_hierarchy(scope);
std::unordered_set<const DexType*> untouchables;
for (const auto& base : m_untouchable_hierarchies) {
auto base_type = DexType::get_type(base.c_str());
if (base_type != nullptr) {
untouchables.insert(base_type);
TypeSet children;
get_all_children(ch, base_type, children);
untouchables.insert(children.begin(), children.end());
}
}
mgr.incr_metric(METRIC_CLASSES_IN_SCOPE, scope.size());
rename_classes(
scope, m_pre_filter_whitelist, m_post_filter_whitelist,
untouchables, m_rename_annotations, mgr);
TRACE(RENAME, 1,
"renamed classes: %d anon classes, %d from single char patterns, "
"%d from multi char patterns\n",
match_inner,
match_short,
match_long);
TRACE(RENAME, 1, "String savings, at least %d bytes \n",
base_strings_size - ren_strings_size);
}
void PassManager::run_passes(DexStoresVector& stores, ConfigFiles& cfg) {
DexStoreClassesIterator it(stores);
Scope scope = build_class_scope(it);
{
Timer t("API Level Checker");
api::LevelChecker::init(m_redex_options.min_sdk, scope);
}
char* seeds_output_file = std::getenv("REDEX_SEEDS_FILE");
if (seeds_output_file) {
std::string seed_filename = seeds_output_file;
Timer t("Writing seeds file " + seed_filename);
std::ofstream seeds_file(seed_filename);
redex::print_seeds(seeds_file, cfg.get_proguard_map(), scope, false, false);
}
if (!cfg.get_printseeds().empty()) {
Timer t("Writing seeds to file " + cfg.get_printseeds());
std::ofstream seeds_file(cfg.get_printseeds());
redex::print_seeds(seeds_file, cfg.get_proguard_map(), scope);
std::ofstream config_file(cfg.get_printseeds() + ".pro");
redex::show_configuration(config_file, scope, *m_pg_config);
std::ofstream incoming(cfg.get_printseeds() + ".incoming");
redex::print_classes(incoming, cfg.get_proguard_map(), scope);
std::ofstream shrinking_file(cfg.get_printseeds() + ".allowshrinking");
redex::print_seeds(shrinking_file, cfg.get_proguard_map(), scope, true,
false);
std::ofstream obfuscation_file(cfg.get_printseeds() + ".allowobfuscation");
redex::print_seeds(obfuscation_file, cfg.get_proguard_map(), scope, false,
true);
}
// Enable opt decision logging if specified in config.
const Json::Value& opt_decisions_args =
cfg.get_json_config()["opt_decisions"];
if (opt_decisions_args.get("enable_logs", false).asBool()) {
opt_metadata::OptDataMapper::get_instance().enable_logs();
}
// TODO(fengliu) : Remove Pass::eval_pass API
for (size_t i = 0; i < m_activated_passes.size(); ++i) {
Pass* pass = m_activated_passes[i];
TRACE(PM, 1, "Evaluating %s...\n", pass->name().c_str());
Timer t(pass->name() + " (eval)");
m_current_pass_info = &m_pass_info[i];
pass->eval_pass(stores, cfg, *this);
m_current_pass_info = nullptr;
}
// Retrieve the type checker's settings.
const Json::Value& type_checker_args =
cfg.get_json_config()["ir_type_checker"];
bool run_after_each_pass =
type_checker_args.get("run_after_each_pass", false).asBool();
// When verify_none is enabled, it's OK to have polymorphic constants.
bool polymorphic_constants =
type_checker_args.get("polymorphic_constants", false).asBool() ||
get_redex_options().verify_none_enabled;
bool verify_moves = type_checker_args.get("verify_moves", false).asBool();
bool check_no_overwrite_this =
type_checker_args.get("check_no_overwrite_this", false).asBool();
std::unordered_set<std::string> trigger_passes;
for (auto& trigger_pass : type_checker_args["run_after_passes"]) {
trigger_passes.insert(trigger_pass.asString());
}
for (size_t i = 0; i < m_activated_passes.size(); ++i) {
Pass* pass = m_activated_passes[i];
TRACE(PM, 1, "Running %s...\n", pass->name().c_str());
Timer t(pass->name() + " (run)");
m_current_pass_info = &m_pass_info[i];
{
ScopedCommandProfiling cmd_prof(
m_profiler_info && m_profiler_info->pass == pass
? boost::make_optional(m_profiler_info->command)
: boost::none);
jemalloc_util::ScopedProfiling malloc_prof(m_malloc_profile_pass == pass);
pass->run_pass(stores, cfg, *this);
}
if (run_after_each_pass || trigger_passes.count(pass->name()) > 0) {
scope = build_class_scope(it);
// It's OK to overwrite the `this` register if we are not yet at the
// output phase -- the register allocator can fix it up later.
run_type_checker(scope, polymorphic_constants, verify_moves,
/* check_no_overwrite_this */ false);
}
m_current_pass_info = nullptr;
}
// Always run the type checker before generating the optimized dex code.
scope = build_class_scope(it);
run_type_checker(scope, polymorphic_constants, verify_moves,
check_no_overwrite_this);
if (!cfg.get_printseeds().empty()) {
Timer t("Writing outgoing classes to file " + cfg.get_printseeds() +
".outgoing");
// Recompute the scope.
scope = build_class_scope(it);
std::ofstream outgoing(cfg.get_printseeds() + ".outgoing");
redex::print_classes(outgoing, cfg.get_proguard_map(), scope);
}
}