in opt/remove-builders/RemoveBuilders.cpp [226:414]
void RemoveBuildersPass::run_pass(DexStoresVector& stores,
ConfigFiles& conf,
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 = type::java_lang_Object();
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",
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);
init_classes::InitClassesWithSideEffects init_classes_with_side_effects(
scope, conf.create_init_class_insns());
BuilderTransform b_transform(init_classes_with_side_effects,
conf.get_inliner_config(),
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;
}
if (m_blocklist.find(builder) != m_blocklist.end()) {
TRACE(BUILDERS, 2, "Skipping excluded type %s", SHOW(builder));
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: %zu", m_builders.size());
TRACE(BUILDERS, 1, "Stack-only builders: %zu", stack_only_builders.size());
TRACE(BUILDERS,
1,
"Stack-only builders that don't let `this` escape: %zu",
no_escapes.size());
TRACE(BUILDERS, 1, "Stats for unescaping builders:");
TRACE(BUILDERS, 1, "\tdmethods: %zu", dmethod_count);
TRACE(BUILDERS, 1, "\tvmethods: %zu", vmethod_count);
TRACE(BUILDERS, 1, "\tbuild methods: %zu", build_count);
TRACE(BUILDERS, 1, "Trivial builders: %zu", trivial_builders.size());
TRACE(BUILDERS, 1, "Classes removed: %zu", b_counter.classes_removed);
TRACE(BUILDERS, 1, "Methods removed: %zu", b_counter.methods_removed);
TRACE(BUILDERS, 1, "Fields removed: %zu", b_counter.fields_removed);
TRACE(BUILDERS, 1, "Methods cleared: %zu", b_counter.methods_cleared);
}