avail/avail.optimizer.jvm/JVMTranslator

JVMTranslator

class JVMTranslator(val code: A_RawFunction?, chunkName: String, sourceFileName: String?, controlFlowGraph: L2ControlFlowGraph, instructions: List<L2Instruction>)

A JVMTranslator converts a single L2Chunk into a JVMChunk in a naive fashion. Instruction selection is optimized, but no other optimizations are attempted; all significant optimizations should occur on the L2Chunk's control flow graph and be reflected in the L2Chunk to be translated.

Author

Todd L Smith

Parameters

code

The source L1 code, or null for the unoptimized chunk.

chunkName

The descriptive (non-unique) name of the chunk being translated.

sourceFileName

The name of the Avail source file that produced the code. Use null if no such file exists.

controlFlowGraph

The L2ControlFlowGraph which produced the sequence of instructions.

instructions

The source L2Instructions to translate to JVM bytecodes.

Constructors

JVMTranslator

constructor(code: A_RawFunction?, chunkName: String, sourceFileName: String?, controlFlowGraph: L2ControlFlowGraph, instructions: List<L2Instruction>)

Construct a new JVMTranslator to translate the specified array of L2Instructions to a JVMChunk.

Types

Companion

object Companion

LiteralAccessor

class LiteralAccessor(val classLoaderIndex: Int, val fieldName: String?, val getter: (MethodVisitor) -> Unit, val setter: (MethodVisitor) -> Unit?)

A LiteralAccessor aggregates means of accessing a literal Object in various contexts.

Properties

classInternalName

val classInternalName: String

The internal name of the generated class.

className

val className: String

The name of the generated class, formed from a UUID to ensure that no collisions occur.

classNode

val classNode: ClassNode

The ClassWriter responsible for writing the JVMChunk subclass. The ClassWriter is configured to automatically compute stack map frames and method limits (e.g., stack depths).

code

val code: A_RawFunction?

The source L1 code.

jumper

val jumper: Label

An entry point near the end of the method, which jumps back to the methodHead for the purpose of performing a jump to a specified L2 offset without having the Fernflower Java decompiler produce tons of spurious nested blocks, breaks, and duplicated code. It's not very good.

labels

val labels: MutableMap<Int, Label>

The L2PcOperand's encapsulated program counters, mapped to their labels.

literals

val literals: MutableMap<Any, JVMTranslator.LiteralAccessor>

The literals used by the L2Chunk that must be embedded into the translated JVMChunk, mapped to their accessors.

liveLocalNumbersByKindPerEntryPoint

val liveLocalNumbersByKindPerEntryPoint: MutableMap<L2Instruction, EnumMap<L2Register.RegisterKind, MutableList<Int>>>

As the code is being generated and we encounter an L2_SAVE_ALL_AND_PC_TO_INT, we examine its corresponding target block to figure out which registers actually have to be captured at the save, and restored at the L2_ENTER_L2_CHUNK. At that point, we look up the local numbers from the JVMTranslator and record them by RegisterKind in this field.

locals

val locals: EnumMap<L2Register.RegisterKind, MutableMap<Int, Int>>

The mapping of registers to locals, partitioned by kind.

methodHead

val methodHead: Label

The start of the runChunk method, where the offset is used to jump to the start of the control flow graph, or the specified entry point.

Functions

branch

fun branch(method: MethodVisitor, instruction: L2Instruction, opcode: Int, success: L2PcOperand, failure: L2PcOperand, successCounter: LongAdder, failureCounter: LongAdder)

Emit code to conditionally branch to one of the specified program counters.

classVisitEnd

fun classVisitEnd()

The final phase of JVM code generation.

createClassBytes

fun createClassBytes()

Populate classBytes, dumping to a file for debugging if indicated.

doubleConstant

fun doubleConstant(method: MethodVisitor, value: Double)

Emit the effect of loading a constant double to the specified MethodVisitor.

endLocal

fun endLocal(localNumber: Int, type: Type)

A local variable has just ended scope. Ensure it was the most recently allocated local, and deallocate the slot(s) that were used for it.

floatConstant

fun floatConstant(method: MethodVisitor, value: Float)

Emit the effect of loading a constant float to the specified MethodVisitor.

generateConstructorV

fun generateConstructorV()

Generate the default constructor `()V` of the target JVMChunk.

generateName

fun generateName()

Generate the JVMChunk.name method of the target JVMChunk.

generateReificationPreamble

fun generateReificationPreamble(method: MethodVisitor, onReification: L2PcOperand)

We're at a point where reification has been requested. A StackReifier has already been stashed in the Interpreter, and already-popped calls may have already queued actions in the reifier, to be executed in reverse order.

generateRunChunk

fun generateRunChunk()

Generate the JVMChunk.runChunk method of the target JVMChunk.

generateStaticInitializer

fun generateStaticInitializer()

Generate the static initializer of the target JVMChunk. The static initializer is responsible for moving any of the parameters of the JVMChunk subclass's JVMChunkClassLoader into appropriate private static final fields.

intConstant

fun intConstant(method: MethodVisitor, value: Int)

Emit the effect of loading a constant int to the specified MethodVisitor.

jump

fun jump(method: MethodVisitor, operand: L2PcOperand)

Emit code to unconditionally branch to the specified program counter.

fun jump(method: MethodVisitor, instruction: L2Instruction, operand: L2PcOperand)

Emit code to unconditionally branch to the specified program counter. Skip if the edge indicates it follows the given instruction.

jumpIf

fun jumpIf(method: MethodVisitor, branchOpcode: Int, edge: L2PcOperand)

Emit code to jump to the target of the supplied edge conditionally, based on the supplied JVM branch opcode and the value on top of the stack. program counter. If condition is not satisfied, control continues at the next JVM instruction.

jvmChunk

fun jvmChunk(): JVMChunk

Answer the generated JVMChunk.

labelFor

fun labelFor(offset: Int): Label

Answer the Label for the specified L2Instruction L2Instruction.offset.

literal

fun literal(method: MethodVisitor, any: Any)

Emit code to push the specified literal on top of the stack.

fun ~~literal~~(method: MethodVisitor?, operand: L2Operand)

Throw an UnsupportedOperationException. It is never valid to treat an L2Operand as a JVM literal, so this method is marked as Deprecated to protect against code cloning and refactoring errors by a programmer.

fun ~~literal~~(method: MethodVisitor?, reg: L2Register?)

Throw an UnsupportedOperationException. It is never valid to treat an L2Register as a Java literal, so this method is marked as Deprecated to protect against code cloning and refactoring errors by a programmer.

load

fun load(method: MethodVisitor, register: L2Register)

Generate a load of the local associated with the specified L2Register.

loadClass

fun loadClass()

Actually load the generated class into the running JVM. Note that a special JVMChunkClassLoader must be used, so that the static initialization has access to the necessary constants referenced from the bytecodes.

loadInterpreter

fun loadInterpreter(method: MethodVisitor)

Generate access to the JVM local for the Interpreter formal parameter of a generated implementation of JVMChunk.runChunk.

loadReceiver

fun loadReceiver(method: MethodVisitor)

Generate access of the receiver (i.e., this).

localNumberFromRegister

fun localNumberFromRegister(register: L2Register): Int

Answer the JVM local number for this register. This is the position within the actual JVM stack frame layout.

longConstant

fun longConstant(method: MethodVisitor, value: Long)

Emit the effect of loading a constant long to the specified MethodVisitor.

nextLocal

fun nextLocal(type: Type): Int

Answer the next JVM local for use within generated code produced by generateRunChunk.

objectArray

fun objectArray(method: MethodVisitor, operands: List<L2ReadBoxedOperand>, arrayClass: Class<out A_BasicObject>)

Emit code to store each of the L2BoxedRegisters into a new array. Leave the new array on top of the stack.

offsetLocal

fun offsetLocal(): Int

Answer the JVM local for the offset formal parameter of a generated implementation of JVMChunk.runChunk.

prepare

fun prepare()

Prepare for JVM translation by visiting each of the L2Instructions to be translated.

reifierLocal

fun reifierLocal(): Int

Answer the JVM local for the StackReifier local variable of a generated implementation of JVMChunk.runChunk.

reverseOpcode

fun reverseOpcode(opcode: Int): Int

Answer the JVM branch opcode with the reversed sense.

store

fun store(method: MethodVisitor, register: L2Register)

Generate a store into the local associated with the specified L2Register. The value to be stored should already be on top of the stack and correctly typed.

translate

fun translate()

Translate the embedded L2Chunk into a JVMChunk.