1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
|
package scala.tools.partest
import scala.collection.JavaConverters._
import scala.tools.asm
import asm.tree.{ClassNode, MethodNode, InsnList}
/** Makes using ASM from ByteCodeTests more convenient.
*
* Wraps ASM instructions in case classes so that equals and toString work
* for the purpose of bytecode diffing and pretty printing.
*/
trait ASMConverters {
// wrap ASM's instructions so we get case class-style `equals` and `toString`
object instructions {
def fromMethod(meth: MethodNode): List[Instruction] = {
val insns = meth.instructions
val asmToScala = new AsmToScala{ def labelIndex(l: asm.tree.AbstractInsnNode) = insns.indexOf(l) }
asmToScala.mapOver(insns.iterator.asScala.toList).asInstanceOf[List[Instruction]]
}
sealed abstract class Instruction { def opcode: String }
case class Field (opcode: String, desc: String, name: String, owner: String) extends Instruction
case class Incr (opcode: String, incr: Int, `var`: Int) extends Instruction
case class Op (opcode: String) extends Instruction
case class IntOp (opcode: String, operand: Int) extends Instruction
case class Jump (opcode: String, label: Label) extends Instruction
case class Ldc (opcode: String, cst: Any) extends Instruction
case class LookupSwitch (opcode: String, dflt: Label, keys: List[Integer], labels: List[Label]) extends Instruction
case class TableSwitch (opcode: String, dflt: Label, max: Int, min: Int, labels: List[Label]) extends Instruction
case class Method (opcode: String, desc: String, name: String, owner: String) extends Instruction
case class NewArray (opcode: String, desc: String, dims: Int) extends Instruction
case class TypeOp (opcode: String, desc: String) extends Instruction
case class VarOp (opcode: String, `var`: Int) extends Instruction
case class Label (offset: Int) extends Instruction { def opcode: String = "" }
case class FrameEntry (local: List[Any], stack: List[Any]) extends Instruction { def opcode: String = "" }
case class LineNumber (line: Int, start: Label) extends Instruction { def opcode: String = "" }
}
abstract class AsmToScala {
import instructions._
def labelIndex(l: asm.tree.AbstractInsnNode): Int
def mapOver(is: List[Any]): List[Any] = is map {
case i: asm.tree.AbstractInsnNode => apply(i)
case x => x
}
def op(i: asm.tree.AbstractInsnNode) = if (asm.util.Printer.OPCODES.isDefinedAt(i.getOpcode)) asm.util.Printer.OPCODES(i.getOpcode) else "?"
def lst[T](xs: java.util.List[T]): List[T] = if (xs == null) Nil else xs.asScala.toList
def apply(l: asm.tree.LabelNode): Label = this(l: asm.tree.AbstractInsnNode).asInstanceOf[Label]
def apply(x: asm.tree.AbstractInsnNode): Instruction = x match {
case i: asm.tree.FieldInsnNode => Field (op(i), i.desc: String, i.name: String, i.owner: String)
case i: asm.tree.IincInsnNode => Incr (op(i), i.incr: Int, i.`var`: Int)
case i: asm.tree.InsnNode => Op (op(i))
case i: asm.tree.IntInsnNode => IntOp (op(i), i.operand: Int)
case i: asm.tree.JumpInsnNode => Jump (op(i), this(i.label))
case i: asm.tree.LdcInsnNode => Ldc (op(i), i.cst: Any)
case i: asm.tree.LookupSwitchInsnNode => LookupSwitch (op(i), this(i.dflt), lst(i.keys), mapOver(lst(i.labels)).asInstanceOf[List[Label]])
case i: asm.tree.TableSwitchInsnNode => TableSwitch (op(i), this(i.dflt), i.max: Int, i.min: Int, mapOver(lst(i.labels)).asInstanceOf[List[Label]])
case i: asm.tree.MethodInsnNode => Method (op(i), i.desc: String, i.name: String, i.owner: String)
case i: asm.tree.MultiANewArrayInsnNode => NewArray (op(i), i.desc: String, i.dims: Int)
case i: asm.tree.TypeInsnNode => TypeOp (op(i), i.desc: String)
case i: asm.tree.VarInsnNode => VarOp (op(i), i.`var`: Int)
case i: asm.tree.LabelNode => Label (labelIndex(x))
case i: asm.tree.FrameNode => FrameEntry (mapOver(lst(i.local)), mapOver(lst(i.stack)))
case i: asm.tree.LineNumberNode => LineNumber (i.line: Int, this(i.start): Label)
}
}
}
|
