How to Rename Anonymous Threads Using ASM Tree API – A Hands‑On Guide

Background

Many developers are familiar with ASM instrumentation via the core API, but most modern instrumentation libraries use the tree API because of its simplicity and clarity.

ASM Overview

ASM is a tool for compiling and editing Java bytecode. It allows you to modify generated class files, which is useful for large projects or when you need to apply uniform changes such as privacy compliance.

This chapter focuses on the tree API; all ASM references below refer to tree‑API operations.

Class Files

A class file consists of several binary sections, which ASM abstracts into a ClassNode structure.

Key identifiers for a class are version, access, name, signature, superName, interfaces, fields, and methods. Modifying a class means modifying its corresponding ClassNode.

Fields

Fields are represented by FieldNode. Each field is uniquely identified by access, name, descriptor, signature, and value.

Methods

Methods are more complex, consisting of a method header and a method body.

Method header : access, name, descriptor, signature, exceptions.

Method body : instructions, try‑catch blocks, maxStack, maxLocals.

InsnList

public class InsnList implements Iterable<AbstractInsnNode> {
    private int size;
    private AbstractInsnNode firstInsn;
    private AbstractInsnNode lastInsn;
    AbstractInsnNode[] cache;
    ...
}

The list is anchored by firstInsn and lastInsn, each instruction being an AbstractInsnNode subclass.

One commonly used subclass is MethodInsnNode:

public class MethodInsnNode extends AbstractInsnNode {
    /** The internal name of the method's owner class. */
    public String owner;
    /** The method's name. */
    public String name;
    /** The method's descriptor. */
    public String desc;
    /** Whether the owner class is an interface. */
    public boolean itf;
}

Signature

Since JDK 1.5, the optional Signature attribute stores generic type information for classes, fields, and methods, enabling runtime reflection of generics that would otherwise be erased.

Practical Example

The goal is to rename “anonymous” threads (e.g., Thread‑1) by inserting the caller’s name into the thread’s constructor.

Solve Anonymous Thread

Thread constructors accept a String name parameter. By modifying the bytecode of the default Thread() constructor to call the Thread(String) variant, we can assign a meaningful name.

public Thread(String name) {
    init(null, null, name, 0);
}

public Thread(ThreadGroup group, String name) {
    init(group, null, name, 0);
}

We change the method descriptor to include a String argument and insert an LdcInsnNode that pushes the caller’s class name onto the stack before the init call.

node.desc = "${node.desc.substring(0, r)}Ljava/lang/String;${node.desc.substring(r)}";
method.instructions.insertBefore(node, new LdcInsnNode(klass.name));

The insertion is performed in the Transform phase (e.g., Android Gradle Transform). We filter out non‑Thread classes and non‑constructor invocations to avoid unnecessary modifications.

static void transform(ClassNode klass) {
    klass.methods?.forEach { methodNode ->
        methodNode.instructions.each { it ->
            if (it.opcode == Opcodes.INVOKESPECIAL) {
                transformInvokeSpecial((MethodInsnNode) it, klass, methodNode)
            }
        }
    }
}

private static void transformInvokeSpecial(MethodInsnNode node, ClassNode klass, MethodNode method) {
    if (node.name != "<init>" || node.owner != THREAD) return;
    transformThreadInvokeSpecial(node, klass, method);
}

private static void transformThreadInvokeSpecial(MethodInsnNode node, ClassNode klass, MethodNode method) {
    switch (node.desc) {
        case "()V":
        case "(Ljava/lang/Runnable;)V":
            method.instructions.insertBefore(node, new LdcInsnNode(klass.name));
            int r = node.desc.lastIndexOf(')');
            String desc = "${node.desc.substring(0, r)}Ljava/lang/String;${node.desc.substring(r)}";
            node.desc = desc;
            break;
    }
}

Conclusion

By understanding ASM’s tree API and applying targeted bytecode transformations, you can effectively rename anonymous threads and gain deeper control over Java class manipulation.