KAREARL
/
openrs2
forked from openrs2/openrs2
0
0
Fork 0
Code Issues 1 Pull Requests Releases Activity

Simplify static field scrambling

Browse Source 
By moving all the static fields in a single class in one go, we can just
combine the <clinit> methods together. This allows us to remove all the
really complicated logic for extracting initializers, and also allows us
to move the last few array fields with complex initializers.
bzip2
Graham 5 years ago
parent c70d810057
commit b6bba95435
1 changed files with 57 additions and 103 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 156
      deob/src/main/java/dev/openrs2/deob/transform/StaticScramblingTransformer.kt

156
deob/src/main/java/dev/openrs2/deob/transform/StaticScramblingTransformer.kt
Unescape View File

@ -2,35 +2,33 @@ package dev.openrs2.deob.transform
import com.github.michaelbull.logging.InlineLogger
import dev.openrs2.asm.ClassVersionUtils
import dev.openrs2.asm.MemberDesc
import dev.openrs2.asm.MemberRef
import dev.openrs2.asm.classpath.ClassPath
import dev.openrs2.asm.classpath.Library
import dev.openrs2.asm.getExpression
import dev.openrs2.asm.sequential
import dev.openrs2.asm.transform.Transformer
import dev.openrs2.deob.remap.TypedRemapper
import org.objectweb.asm.Opcodes
import org.objectweb.asm.tree.AbstractInsnNode
import org.objectweb.asm.tree.ClassNode
import org.objectweb.asm.tree.FieldInsnNode
import org.objectweb.asm.tree.FieldNode
import org.objectweb.asm.tree.InsnList
import org.objectweb.asm.tree.InsnNode
import org.objectweb.asm.tree.JumpInsnNode
import org.objectweb.asm.tree.LabelNode
import org.objectweb.asm.tree.MethodInsnNode
import org.objectweb.asm.tree.MethodNode
import kotlin.math.max
class StaticScramblingTransformer : Transformer() {
private data class Field(val node: FieldNode, val initializer: InsnList, val version: Int, val maxStack: Int) {
val dependencies = initializer.asSequence()
.filterIsInstance<FieldInsnNode>()
.filter { it.opcode == Opcodes.GETSTATIC }
.map(::MemberRef)
.toSet()
private class FieldSet(val owner: ClassNode, val fields: List<FieldNode>, val clinit: MethodNode?) {
val dependencies = clinit?.instructions
?.filterIsInstance<FieldInsnNode>()
?.filter { it.opcode == Opcodes.GETSTATIC && it.owner != owner.name }
?.map(::MemberRef)
?.toSet() ?: emptySet()
}
private val fields = mutableMapOf<MemberRef, Field>()
private val fieldSets = mutableMapOf<MemberRef, FieldSet>()
private val fieldClasses = mutableMapOf<MemberRef, String>()
private val methodClasses = mutableMapOf<MemberRef, String>()
private var nextStaticClass: ClassNode? = null
@ -70,94 +68,61 @@ class StaticScramblingTransformer : Transformer() {
return Pair(clazz, clinit)
}
private fun MethodNode.extractEntryExitBlocks(): List<AbstractInsnNode> {
/*
* Most (or all?) of the <clinit> methods have "simple" initializers
* that we're capable of moving in the first and last basic blocks of
* the method. The last basic block is always at the end of the code
* and ends in a RETURN. This allows us to avoid worrying about making
* a full basic block control flow graph here.
*/
val entry = instructions.takeWhile { it.sequential }
val last = instructions.lastOrNull()
if (last == null || last.opcode != Opcodes.RETURN) {
return entry
private fun spliceFields() {
val done = mutableSetOf<FieldSet>()
for (fieldSet in fieldSets.values) {
spliceFields(done, fieldSet)
}
val exit = instructions.toList()
.dropLast(1)
.takeLastWhile { it.sequential }
return entry.plus(exit)
}
private fun MethodNode.extractInitializers(owner: String): Pair<Map<MemberDesc, InsnList>, Set<MemberDesc>> {
val entryExitBlocks = extractEntryExitBlocks()
val simpleInitializers = mutableMapOf<MemberDesc, InsnList>()
val complexInitializers = instructions.asSequence()
.filter { !entryExitBlocks.contains(it) }
.filterIsInstance<FieldInsnNode>()
.filter { it.opcode == Opcodes.GETSTATIC && it.owner == owner && it.name !in TypedRemapper.EXCLUDED_FIELDS }
.map(::MemberDesc)
.toSet()
val putstatics = entryExitBlocks
.filterIsInstance<FieldInsnNode>()
.filter { it.opcode == Opcodes.PUTSTATIC && it.owner == owner && it.name !in TypedRemapper.EXCLUDED_FIELDS }
for (putstatic in putstatics) {
val desc = MemberDesc(putstatic)
if (simpleInitializers.containsKey(desc) || complexInitializers.contains(desc)) {
continue
private fun spliceFields(done: MutableSet<FieldSet>, fieldSet: FieldSet) {
if (!done.add(fieldSet)) {
return
}
// TODO(gpe): use a filter here (pure with no *LOADs?)
val expr = getExpression(putstatic) ?: continue
val initializer = InsnList()
for (insn in expr) {
instructions.remove(insn)
initializer.add(insn)
for (dependency in fieldSet.dependencies) {
val dependencyFieldSet = fieldSets[dependency] ?: continue
spliceFields(done, dependencyFieldSet)
}
instructions.remove(putstatic)
initializer.add(putstatic)
simpleInitializers[desc] = initializer
}
val (staticClass, staticClinit) = nextClass()
staticClass.fields.addAll(fieldSet.fields)
staticClass.version = ClassVersionUtils.maxVersion(staticClass.version, fieldSet.owner.version)
return Pair(simpleInitializers, complexInitializers)
if (fieldSet.clinit != null) {
// remove tail RETURN
val insns = fieldSet.clinit.instructions
val last = insns.lastOrNull()
if (last != null && last.opcode == Opcodes.RETURN) {
insns.remove(last)
}
private fun spliceInitializers() {
val done = mutableSetOf<MemberRef>()
for ((ref, field) in fields) {
spliceInitializers(done, ref, field)
// replace any remaining RETURNs with a GOTO to the end of the method
val end = LabelNode()
insns.add(end)
for (insn in insns) {
if (insn.opcode == Opcodes.RETURN) {
insns.set(insn, JumpInsnNode(Opcodes.GOTO, end))
}
}
private fun spliceInitializers(done: MutableSet<MemberRef>, ref: MemberRef, field: Field) {
if (!done.add(ref)) {
return
}
// append just before the end of the static <clinit> RETURN
staticClinit.instructions.insertBefore(staticClinit.instructions.last, insns)
for (dependency in field.dependencies) {
val dependencyField = fields[dependency] ?: continue
spliceInitializers(done, dependency, dependencyField)
staticClinit.tryCatchBlocks.addAll(fieldSet.clinit.tryCatchBlocks)
staticClinit.maxStack = max(staticClinit.maxStack, fieldSet.clinit.maxStack)
staticClinit.maxLocals = max(staticClinit.maxLocals, fieldSet.clinit.maxLocals)
}
val (clazz, clinit) = nextClass()
clazz.fields.add(field.node)
clazz.version = ClassVersionUtils.maxVersion(clazz.version, field.version)
clinit.instructions.insertBefore(clinit.instructions.last, field.initializer)
clinit.maxStack = max(clinit.maxStack, field.maxStack)
fieldClasses[ref] = clazz.name
for (field in fieldSet.fields) {
val ref = MemberRef(fieldSet.owner, field)
fieldClasses[ref] = staticClass.name
}
}
override fun preTransform(classPath: ClassPath) {
fields.clear()
fieldSets.clear()
fieldClasses.clear()
methodClasses.clear()
nextStaticClass = null
@ -171,33 +136,22 @@ class StaticScramblingTransformer : Transformer() {
for (clazz in library) {
// TODO(gpe): exclude the JSObject class
if (clazz.name in TypedRemapper.EXCLUDED_CLASSES) {
if (clazz.name == "jagex3/jagmisc/jagmisc") {
continue
}
val clinit = clazz.methods.find { it.name == "<clinit>" }
val (simpleInitializers, complexInitializers) = clinit?.extractInitializers(clazz.name)
?: Pair(emptyMap(), emptySet())
clazz.fields.removeIf { field ->
if (field.access and Opcodes.ACC_STATIC == 0) {
return@removeIf false
} else if (field.name in TypedRemapper.EXCLUDED_METHODS) {
return@removeIf false
}
val fields = clazz.fields.filter { it.access and Opcodes.ACC_STATIC != 0 }
clazz.fields.removeAll(fields)
val desc = MemberDesc(field)
if (complexInitializers.contains(desc)) {
return@removeIf false
val clinit = clazz.methods.find { it.name == "<clinit>" }
if (clinit != null) {
clazz.methods.remove(clinit)
}
val initializer = simpleInitializers[desc] ?: InsnList()
val maxStack = clinit?.maxStack ?: 0
val fieldSet = FieldSet(clazz, fields, clinit)
for (field in fields) {
val ref = MemberRef(clazz, field)
fields[ref] = Field(field, initializer, clazz.version, maxStack)
return@removeIf true
fieldSets[ref] = fieldSet
}
clazz.methods.removeIf { method ->
@ -218,7 +172,7 @@ class StaticScramblingTransformer : Transformer() {
}
}
spliceInitializers()
spliceFields()
for (clazz in staticClasses) {
library.add(clazz)

Write Preview
Loading…
Cancel
Save