void SimplifyCFGPass::run_pass(DexStoresVector& stores, ConfigFiles& /* unused */, PassManager& mgr) { const auto& scope = build_class_scope(stores); auto total_insns_removed = walk::parallel::reduce_methods<int64_t, Scope>( scope, [](DexMethod* m) -> int64_t { auto code = m->get_code(); if (code == nullptr) { return 0; } int64_t before_insns = code->count_opcodes(); // build and linearize the CFG code->build_cfg(/* editable */ true); code->clear_cfg(); int64_t after_insns = code->count_opcodes(); return before_insns - after_insns; }, [](int64_t a, int64_t b) { return a + b; }); mgr.set_metric("insns_removed", total_insns_removed); }
void RemoveRedundantCheckCastsPass::run_pass(DexStoresVector& stores, ConfigFiles&, PassManager& mgr) { auto scope = build_class_scope(stores); size_t num_redundant_check_casts = walk::parallel::reduce_methods<size_t>( scope, [&](DexMethod* method) -> size_t { return remove_redundant_check_casts(method); }, std::plus<size_t>()); mgr.set_metric("num_redundant_check_casts", num_redundant_check_casts); }
void RemoveBuildersPass::run_pass(DexStoresVector& stores, ConfigFiles&, PassManager& mgr) { if (mgr.no_proguard_rules()) { TRACE(BUILDERS, 1, "RemoveBuildersPass did not run because no Proguard configuration " "was provided."); return; } // Initialize couters. b_counter = {0, 0, 0, 0}; auto obj_type = get_object_type(); auto scope = build_class_scope(stores); for (DexClass* cls : scope) { if (is_annotation(cls) || is_interface(cls) || cls->get_super_class() != obj_type) { continue; } if (has_builder_name(cls->get_type())) { m_builders.emplace(cls->get_type()); } } std::unordered_set<DexType*> escaped_builders; walk::methods(scope, [&](DexMethod* m) { auto builders = created_builders(m); for (DexType* builder : builders) { if (escapes_stack(builder, m)) { TRACE(BUILDERS, 3, "%s escapes in %s\n", SHOW(builder), m->get_deobfuscated_name().c_str()); escaped_builders.emplace(builder); } } }); std::unordered_set<DexType*> stack_only_builders; for (DexType* builder : m_builders) { if (escaped_builders.find(builder) == escaped_builders.end()) { stack_only_builders.emplace(builder); } } std::unordered_set<DexType*> builders_and_supers; for (DexType* builder : stack_only_builders) { DexType* cls = builder; while (cls != nullptr && cls != obj_type) { builders_and_supers.emplace(cls); cls = type_class(cls)->get_super_class(); } } std::unordered_set<DexType*> this_escapes; for (DexType* cls_ty : builders_and_supers) { DexClass* cls = type_class(cls_ty); if (cls->is_external() || this_arg_escapes(cls, m_enable_buildee_constr_change)) { this_escapes.emplace(cls_ty); } } // set of builders that neither escape the stack nor pass their 'this' arg // to another function std::unordered_set<DexType*> no_escapes; for (DexType* builder : stack_only_builders) { DexType* cls = builder; bool hierarchy_has_escape = false; while (cls != nullptr) { if (this_escapes.find(cls) != this_escapes.end()) { hierarchy_has_escape = true; break; } cls = type_class(cls)->get_super_class(); } if (!hierarchy_has_escape) { no_escapes.emplace(builder); } } size_t dmethod_count = 0; size_t vmethod_count = 0; size_t build_count = 0; for (DexType* builder : no_escapes) { auto cls = type_class(builder); auto buildee = get_buildee(builder); dmethod_count += cls->get_dmethods().size(); vmethod_count += cls->get_vmethods().size(); for (DexMethod* m : cls->get_vmethods()) { if (m->get_proto()->get_rtype() == buildee) { build_count++; } } } std::unordered_set<DexClass*> trivial_builders = get_trivial_builders(m_builders, no_escapes); std::unordered_set<DexClass*> kept_builders = get_builders_with_subclasses(scope); PassConfig pc(mgr.get_config()); BuilderTransform b_transform(pc, scope, stores, false); // Inline non init methods. std::unordered_set<DexClass*> removed_builders; walk::methods(scope, [&](DexMethod* method) { auto builders = created_builders(method); for (DexType* builder : builders) { if (method->get_class() == builder) { continue; } DexClass* builder_cls = type_class(builder); // Filter out builders that we cannot remove. if (kept_builders.find(builder_cls) != kept_builders.end()) { continue; } // Check it is a trivial one. if (trivial_builders.find(builder_cls) != trivial_builders.end()) { DexMethod* method_copy = DexMethod::make_method_from( method, method->get_class(), DexString::make_string(method->get_name()->str() + "$redex_builders")); bool was_not_removed = !b_transform.inline_methods( method, builder, &get_non_init_methods) || !remove_builder_from(method, builder_cls, b_transform); if (was_not_removed) { kept_builders.emplace(builder_cls); method->set_code(method_copy->release_code()); } else { b_counter.methods_cleared++; removed_builders.emplace(builder_cls); } DexMethod::erase_method(method_copy); } } }); // No need to remove the builders here, since `RemoveUnreachable` will // take care of it. gather_removal_builder_stats(removed_builders, kept_builders); mgr.set_metric("total_builders", m_builders.size()); mgr.set_metric("stack_only_builders", stack_only_builders.size()); mgr.set_metric("no_escapes", no_escapes.size()); mgr.incr_metric(METRIC_CLASSES_REMOVED, b_counter.classes_removed); mgr.incr_metric(METRIC_METHODS_REMOVED, b_counter.methods_removed); mgr.incr_metric(METRIC_FIELDS_REMOVED, b_counter.fields_removed); mgr.incr_metric(METRIC_METHODS_CLEARED, b_counter.methods_cleared); TRACE(BUILDERS, 1, "Total builders: %d\n", m_builders.size()); TRACE(BUILDERS, 1, "Stack-only builders: %d\n", stack_only_builders.size()); TRACE(BUILDERS, 1, "Stack-only builders that don't let `this` escape: %d\n", no_escapes.size()); TRACE(BUILDERS, 1, "Stats for unescaping builders:\n"); TRACE(BUILDERS, 1, "\tdmethods: %d\n", dmethod_count); TRACE(BUILDERS, 1, "\tvmethods: %d\n", vmethod_count); TRACE(BUILDERS, 1, "\tbuild methods: %d\n", build_count); TRACE(BUILDERS, 1, "Trivial builders: %d\n", trivial_builders.size()); TRACE(BUILDERS, 1, "Classes removed: %d\n", b_counter.classes_removed); TRACE(BUILDERS, 1, "Methods removed: %d\n", b_counter.methods_removed); TRACE(BUILDERS, 1, "Fields removed: %d\n", b_counter.fields_removed); TRACE(BUILDERS, 1, "Methods cleared: %d\n", b_counter.methods_cleared); }