Sancaros/phantasmal-world
1
0
Fork 0
mirror of https://github.com/DaanVandenBosch/phantasmal-world.git synced 2025-04-05 15:28:29 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Fixed bugs in ASM editor signature help. The bytecode IR now contains all ASM instruction arguments, even when they are the wrong type or there are too many.

Browse Source
This commit is contained in:
Daan Vanden Bosch 2021-04-25 16:53:26 +02:00
parent b973c99c6a
commit 797c5a298e
19 changed files with 549 additions and 467 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
core/src/commonMain/kotlin/world/phantasmal/core/PrimitiveExtensions.kt
View File

@ -30,9 +30,3 @@ fun Int.setBit(bit: Int, value: Boolean): Int =
} else { } else {
this and (1 shl bit).inv() this and (1 shl bit).inv()
} }
expect fun Int.reinterpretAsFloat(): Float
expect fun Float.reinterpretAsInt(): Int
expect fun Float.reinterpretAsUInt(): UInt

20
core/src/jsMain/kotlin/world/phantasmal/core/PrimitiveExtensions.kt
View File

@ -1,10 +1,5 @@
package world.phantasmal.core package world.phantasmal.core
import org.khronos.webgl.ArrayBuffer
import org.khronos.webgl.DataView
private val dataView = DataView(ArrayBuffer(4))
@Suppress("NOTHING_TO_INLINE") @Suppress("NOTHING_TO_INLINE")
actual inline fun Char.fastIsWhitespace(): Boolean = actual inline fun Char.fastIsWhitespace(): Boolean =
asDynamic() == 0x20 || (asDynamic() >= 0x09 && asDynamic() <= 0x0D) asDynamic() == 0x20 || (asDynamic() >= 0x09 && asDynamic() <= 0x0D)
@ -12,18 +7,3 @@ actual inline fun Char.fastIsWhitespace(): Boolean =
@Suppress("NOTHING_TO_INLINE") @Suppress("NOTHING_TO_INLINE")
actual inline fun Char.isDigit(): Boolean = actual inline fun Char.isDigit(): Boolean =
asDynamic() >= 0x30 && asDynamic() <= 0x39 asDynamic() >= 0x30 && asDynamic() <= 0x39
actual fun Int.reinterpretAsFloat(): Float {
dataView.setInt32(0, this)
return dataView.getFloat32(0)
}
actual fun Float.reinterpretAsInt(): Int {
dataView.setFloat32(0, this)
return dataView.getInt32(0)
}
actual fun Float.reinterpretAsUInt(): UInt {
dataView.setFloat32(0, this)
return dataView.getUint32(0).toUInt()
}

9
core/src/jvmMain/kotlin/world/phantasmal/core/PrimitiveExtensions.kt
View File

@ -2,17 +2,8 @@
package world.phantasmal.core package world.phantasmal.core
import java.lang.Float.floatToIntBits
import java.lang.Float.intBitsToFloat
@Suppress("NOTHING_TO_INLINE") @Suppress("NOTHING_TO_INLINE")
actual inline fun Char.fastIsWhitespace(): Boolean = isWhitespace() actual inline fun Char.fastIsWhitespace(): Boolean = isWhitespace()
@Suppress("NOTHING_TO_INLINE") @Suppress("NOTHING_TO_INLINE")
actual inline fun Char.isDigit(): Boolean = this in '0'..'9' actual inline fun Char.isDigit(): Boolean = this in '0'..'9'
actual fun Int.reinterpretAsFloat(): Float = intBitsToFloat(this)
actual fun Float.reinterpretAsInt(): Int = floatToIntBits(this)
actual fun Float.reinterpretAsUInt(): UInt = reinterpretAsInt().toUInt()

507
lib/src/commonMain/kotlin/world/phantasmal/lib/asm/Assembly.kt
View File

@ -131,8 +131,9 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
opcode: Opcode, opcode: Opcode,
args: List<Arg>, args: List<Arg>,
mnemonicSrcLoc: SrcLoc?, mnemonicSrcLoc: SrcLoc?,
valid: Boolean,
argSrcLocs: List<ArgSrcLoc>, argSrcLocs: List<ArgSrcLoc>,
stackArgSrcLocs: List<ArgSrcLoc>, trailingArgSeparator: Boolean,
) { ) {
when (val seg = segment) { when (val seg = segment) {
null -> { null -> {
@ -151,11 +152,12 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
Instruction( Instruction(
opcode, opcode,
args, args,
valid,
InstructionSrcLoc( InstructionSrcLoc(
mnemonic = mnemonicSrcLoc, mnemonic = mnemonicSrcLoc,
args = argSrcLocs, args = argSrcLocs,
stackArgs = stackArgSrcLocs, trailingArgSeparator,
) ),
) )
) )
} }
@ -359,200 +361,169 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
if (opcode == null) { if (opcode == null) {
addError("Unknown opcode.") addError("Unknown opcode.")
} else { } else {
// Inline arguments.
val inlineArgs = mutableListOf<Arg>()
val inlineArgSrcLocs = mutableListOf<ArgSrcLoc>()
// Stack arguments.
val stackArgs = mutableListOf<Arg>()
val stackArgSrcLocs = mutableListOf<ArgSrcLoc>()
if (opcode.stack !== StackInteraction.Pop) { if (opcode.stack !== StackInteraction.Pop) {
// Arguments should be inlined right after the opcode. // Arguments should be inlined immediately after the opcode.
if (!parseArgs( parseArgs(
opcode, opcode,
mnemonicSrcLoc.col, mnemonicSrcLoc,
inlineArgs, stack = false,
inlineArgSrcLocs, )
stack = false,
)
) {
return
}
} else { } else {
// Arguments should be passed to the opcode via the stack. // Arguments should be passed to the opcode via the stack.
if (!parseArgs( parseArgs(
opcode, opcode,
mnemonicSrcLoc.col, mnemonicSrcLoc,
stackArgs, stack = true,
stackArgSrcLocs, )
stack = true,
)
) {
return
}
} }
addInstruction(
opcode,
inlineArgs,
mnemonicSrcLoc,
inlineArgSrcLocs,
stackArgSrcLocs,
)
} }
} }
/** private fun parseArgs(opcode: Opcode, mnemonicSrcLoc: SrcLoc, stack: Boolean) {
* Returns true iff arguments can be translated to byte code, possibly after truncation. val immediateArgs = mutableListOf<Arg>()
*/ val srcLocs = mutableListOf<ArgSrcLoc>()
private fun parseArgs(
opcode: Opcode,
startCol: Int,
args: MutableList<Arg>,
srcLocs: MutableList<ArgSrcLoc>,
stack: Boolean,
): Boolean {
var argCount = 0 var argCount = 0
var semiValid = true var valid = true
var shouldBeArg = true var shouldBeArg = true
var paramI = 0 var paramI = 0
var prevToken: Token?
var prevCol: Int var prevCol: Int
var prevLen: Int var prevLen: Int
var token = tokenizer.type
var col = tokenizer.col var col = tokenizer.col
var len = tokenizer.len var len = tokenizer.len
tokenizer.nextToken() tokenizer.nextToken()
while (true) { while (true) {
// Previous token data.
prevToken = token
prevCol = col prevCol = col
prevLen = len prevLen = len
val token = tokenizer.type // Current token data.
val value = tokenizer.value token = tokenizer.type
col = tokenizer.col col = tokenizer.col
len = tokenizer.len len = tokenizer.len
val value = tokenizer.value
if (token == null) { if (token == null) {
break break
} }
// Next token data.
tokenizer.nextToken() tokenizer.nextToken()
val nextToken = tokenizer.type
val nextCol = tokenizer.col
val nextLen = tokenizer.len
val param = opcode.params.getOrNull(paramI)
val paramType = param?.type
// Coarse source position, including surrounding whitespace.
val coarseCol = prevCol + prevLen val coarseCol = prevCol + prevLen
val coarseLen = val coarseLen =
if (tokenizer.type === Token.ArgSeparator) tokenizer.col + tokenizer.len - coarseCol if (nextToken === Token.ArgSeparator) nextCol + nextLen - coarseCol
else tokenizer.col - coarseCol else nextCol - coarseCol
if (token === Token.ArgSeparator) {
if (shouldBeArg) {
addError("Expected an argument.")
} else if (param == null || !param.varargs) {
paramI++
}
shouldBeArg = true
} else {
if (!shouldBeArg) {
addError(coarseCol, col - coarseCol, "Expected a comma.")
}
shouldBeArg = false
if (token !== Token.ArgSeparator) {
argCount++ argCount++
}
if (paramI < opcode.params.size) { // Try to match token type to parameter type.
val param = opcode.params[paramI] var typeMatch: Boolean
if (token === Token.ArgSeparator) { // If arg is nonnull, types match and argument is syntactically valid.
if (shouldBeArg) { val arg: Arg = when (token) {
addError("Expected an argument.") Token.Int32 -> {
} else if (!param.varargs) { value as Int
paramI++
}
shouldBeArg = true when (paramType) {
} else { ByteType -> {
if (!shouldBeArg) { typeMatch = true
addError(coarseCol, col - coarseCol, "Expected a comma.") checkIntValue(col, len, value, 1)
}
shouldBeArg = false
// Try to match token type parameter type.
var typeMatch: Boolean
// If arg is nonnull, types match and argument is syntactically valid.
val arg: Arg? = when (token) {
Token.Int32 -> {
value as Int
when (param.type) {
ByteType -> {
typeMatch = true
intValueToArg(value, 1)
}
ShortType,
is LabelType,
-> {
typeMatch = true
intValueToArg(value, 2)
}
IntType -> {
typeMatch = true
intValueToArg(value, 4)
}
FloatType -> {
typeMatch = true
Arg(value.toFloat())
}
else -> {
typeMatch = false
null
}
} }
} ShortType,
is LabelType,
Token.Float32 -> { -> {
typeMatch = param.type === FloatType typeMatch = true
checkIntValue(col, len, value, 2)
if (typeMatch) {
Arg(value as Float)
} else {
null
} }
} IntType -> {
typeMatch = true
Token.Register -> { checkIntValue(col, len, value, 4)
value as Int
typeMatch = stack ||
param.type === RegVarType ||
param.type is RegType
if (value > 255) {
addError("Invalid register reference, expected r0-r255.")
null
} else {
Arg(value)
} }
} FloatType -> {
typeMatch = true
Token.Str -> { FloatArg(value.toFloat())
typeMatch = param.type === StringType }
else -> {
if (typeMatch) { typeMatch = false
Arg(value as String) IntArg(value)
} else {
null
} }
}
else -> {
typeMatch = false
null
} }
} }
val srcLoc = ArgSrcLoc( Token.Float32 -> {
precise = SrcLoc(lineNo, col, len), typeMatch = paramType === FloatType
coarse = SrcLoc(lineNo, coarseCol, coarseLen), FloatArg(value as Float)
)
if (arg != null) {
args.add(arg)
srcLocs.add(srcLoc)
} }
if (!typeMatch) { Token.Register -> {
semiValid = false typeMatch = stack ||
paramType === RegVarType ||
paramType is RegType
val typeStr: String? = when (param.type) { value as Int
if (value > 255) {
addError(col, len, "Invalid register reference, expected r0-r255.")
}
IntArg(value)
}
Token.Str -> {
typeMatch = paramType === StringType
StringArg(value as String)
}
else -> {
typeMatch = false
UnknownArg(value!!)
}
}
val srcLoc = ArgSrcLoc(
precise = SrcLoc(lineNo, col, len),
coarse = SrcLoc(lineNo, coarseCol, coarseLen),
)
if (!stack) {
immediateArgs.add(arg)
}
srcLocs.add(srcLoc)
if (!typeMatch) {
valid = false
// Don't add a type errors for surplus arguments.
if (param != null) {
val typeStr = when (param.type) {
ByteType -> "an 8-bit integer" ByteType -> "an 8-bit integer"
ShortType -> "a 16-bit integer" ShortType -> "a 16-bit integer"
IntType -> "a 32-bit integer" IntType -> "a 32-bit integer"
@ -573,93 +544,103 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
is RegType, is RegType,
-> "a register reference" -> "a register reference"
else -> null PointerType -> "a pointer" // No known opcodes directly take a pointer.
AnyType.Instance -> "an argument" // Should never happen.
} }
addError( addError(col, len, "Expected ${typeStr}.")
if (typeStr == null) "Unexpected token." else "Expected ${typeStr}." }
) } else if (stack) {
} else if (stack && arg != null) { // Inject stack push instructions if necessary.
// Inject stack push instructions if necessary. checkNotNull(paramType)
// If the token is a register, push it as a register, otherwise coerce type.
if (token === Token.Register) { // If the token is a register, push it as a register, otherwise coerce type.
if (param.type is RegType) { if (token === Token.Register) {
if (paramType is RegType) {
addInstruction(
OP_ARG_PUSHB,
listOf(arg),
mnemonicSrcLoc = null,
valid = true,
listOf(srcLoc),
trailingArgSeparator = false,
)
} else {
addInstruction(
OP_ARG_PUSHR,
listOf(arg),
mnemonicSrcLoc = null,
valid = true,
listOf(srcLoc),
trailingArgSeparator = false,
)
}
} else {
when (paramType) {
ByteType,
is RegType,
-> {
addInstruction( addInstruction(
OP_ARG_PUSHB, OP_ARG_PUSHB,
listOf(arg), listOf(arg),
null, mnemonicSrcLoc = null,
valid = true,
listOf(srcLoc), listOf(srcLoc),
emptyList(), trailingArgSeparator = false,
)
} else {
addInstruction(
OP_ARG_PUSHR,
listOf(arg),
null,
listOf(srcLoc),
emptyList(),
) )
} }
} else {
when (param.type) {
ByteType,
is RegType,
-> {
addInstruction(
OP_ARG_PUSHB,
listOf(arg),
null,
listOf(srcLoc),
emptyList(),
)
}
ShortType, ShortType,
is LabelType, is LabelType,
-> { -> {
addInstruction( addInstruction(
OP_ARG_PUSHW, OP_ARG_PUSHW,
listOf(arg), listOf(arg),
null, mnemonicSrcLoc = null,
listOf(srcLoc), valid = true,
emptyList(), listOf(srcLoc),
) trailingArgSeparator = false,
} )
}
IntType -> { IntType -> {
addInstruction( addInstruction(
OP_ARG_PUSHL, OP_ARG_PUSHL,
listOf(arg), listOf(arg),
null, mnemonicSrcLoc = null,
listOf(srcLoc), valid = true,
emptyList(), listOf(srcLoc),
) trailingArgSeparator = false,
} )
}
FloatType -> { // Floats are pushed as ints.
addInstruction( FloatType -> {
OP_ARG_PUSHL, addInstruction(
listOf(Arg((arg.value as Float).toRawBits())), OP_ARG_PUSHL,
null, listOf(IntArg((arg as FloatArg).value.toRawBits())),
listOf(srcLoc), mnemonicSrcLoc = null,
emptyList(), valid = true,
) listOf(srcLoc),
} trailingArgSeparator = false,
)
}
StringType -> { StringType -> {
addInstruction( addInstruction(
OP_ARG_PUSHS, OP_ARG_PUSHS,
listOf(arg), listOf(arg),
null, mnemonicSrcLoc = null,
listOf(srcLoc), valid = true,
emptyList(), listOf(srcLoc),
) trailingArgSeparator = false,
} )
}
else -> { else -> {
logger.error { logger.error {
"Line $lineNo: Type ${param.type::class} not implemented." "Line $lineNo: Type ${paramType::class} not implemented."
}
} }
} }
} }
@ -672,59 +653,67 @@ private class Assembler(private val asm: List<String>, private val inlineStackAr
if (!inlineStackArgs && opcode.stack === StackInteraction.Pop) 0 if (!inlineStackArgs && opcode.stack === StackInteraction.Pop) 0
else opcode.params.size else opcode.params.size
val errorLength = prevCol + prevLen - startCol val trailingArgSeparator = prevToken === Token.ArgSeparator
if (!opcode.varargs && argCount != paramCount) { // Length from the start of the mnemonic until the end of the last token.
semiValid = argCount >= paramCount val errorLength = prevCol + prevLen - mnemonicSrcLoc.col
addError(
startCol, if (opcode.varargs) {
errorLength, // Argument count should be equal to or greater than the amount of parameters for variadic
"Expected $paramCount argument${ // opcodes.
if (paramCount == 1) "" else "s" if (argCount < paramCount) {
}, got $argCount.", valid = false
) addError(
} else if (opcode.varargs && argCount < paramCount) { mnemonicSrcLoc.col,
semiValid = argCount >= paramCount - 1 errorLength,
// TODO: This check assumes we want at least 1 argument for a vararg parameter. "Expected at least $paramCount argument${
// Is this correct? if (paramCount == 1) "" else "s"
addError( }, got $argCount.",
startCol, )
errorLength, }
"Expected at least $paramCount argument${ } else {
if (paramCount == 1) "" else "s" // Argument count should match parameter count exactly for non-variadic opcodes.
}, got $argCount.", if (argCount != paramCount) {
) valid = false
addError(
mnemonicSrcLoc.col,
errorLength,
"Expected $paramCount argument${
if (paramCount == 1) "" else "s"
}, got $argCount.",
)
}
} }
return semiValid // Trailing argument separators are not allowed.
if (trailingArgSeparator) {
addError(prevCol, prevLen, "Unexpected comma.")
}
addInstruction(opcode, immediateArgs, mnemonicSrcLoc, valid, srcLocs, trailingArgSeparator)
} }
private fun intValueToArg(value: Int, size: Int): Arg? { private fun checkIntValue(col: Int, len: Int, value: Int, size: Int): Arg {
// Fast-path 32-bit ints for improved JS perf. Otherwise maxValue would have to be a Long // Fast-path 32-bit ints for improved JS perf. Otherwise maxValue would have to be a Long
// or UInt, which incurs a perf hit in JS. // or UInt, which incurs a perf hit in JS.
if (size == 4) { if (size != 4) {
return Arg(value)
} else {
val bitSize = 8 * size val bitSize = 8 * size
// Minimum of the signed version of this integer type. // Minimum of the signed version of this integer type.
val minValue = -(1 shl (bitSize - 1)) val minValue = -(1 shl (bitSize - 1))
// Maximum of the unsigned version of this integer type. // Maximum of the unsigned version of this integer type.
val maxValue = (1 shl (bitSize)) - 1 val maxValue = (1 shl (bitSize)) - 1
return when { when {
value < minValue -> { value < minValue -> {
addError("${bitSize}-Bit integer can't be less than ${minValue}.") addError(col, len, "${bitSize}-Bit integer can't be less than ${minValue}.")
null
} }
value > maxValue -> { value > maxValue -> {
addError("${bitSize}-Bit integer can't be greater than ${maxValue}.") addError(col, len, "${bitSize}-Bit integer can't be greater than ${maxValue}.")
null
}
else -> {
Arg(value)
} }
} }
} }
return IntArg(value)
} }
private fun parseBytes() { private fun parseBytes() {

82
lib/src/commonMain/kotlin/world/phantasmal/lib/asm/BytecodeIr.kt
View File

@ -103,6 +103,7 @@ class Instruction(
* Immediate arguments for the opcode. * Immediate arguments for the opcode.
*/ */
val args: List<Arg>, val args: List<Arg>,
val valid: Boolean,
val srcLoc: InstructionSrcLoc?, val srcLoc: InstructionSrcLoc?,
) { ) {
/** /**
@ -144,41 +145,19 @@ class Instruction(
} }
/** /**
* Returns the source locations of the immediate arguments for the parameter at the given index. * Returns the source locations of the (immediate or stack) arguments for the parameter at the
* given index.
*/ */
fun getArgSrcLocs(paramIndex: Int): List<ArgSrcLoc> { fun getArgSrcLocs(paramIndex: Int): List<ArgSrcLoc> {
val argSrcLocs = srcLoc?.args val argSrcLocs = srcLoc?.args
?: return emptyList() ?: return emptyList()
val param = opcode.params[paramIndex] return if (opcode.params[paramIndex].varargs) {
// Variadic parameters are always last, so we can just gobble up all SrcLocs from
// Variable length arguments are always last, so we can just gobble up all SrcLocs from // paramIndex onward.
// paramIndex onward.
return if (param.varargs) {
argSrcLocs.drop(paramIndex) argSrcLocs.drop(paramIndex)
} else { } else {
listOf(argSrcLocs[paramIndex]) listOfNotNull(argSrcLocs.getOrNull(paramIndex))
}
}
/**
* Returns the source locations of the stack arguments for the parameter at the given index.
*/
fun getStackArgSrcLocs(paramIndex: Int): List<ArgSrcLoc> {
val argSrcLocs = srcLoc?.stackArgs
if (argSrcLocs == null || paramIndex > argSrcLocs.lastIndex) {
return emptyList()
}
val param = opcode.params[paramIndex]
// Variable length arguments are always last, so we can just gobble up all SrcLocs from
// paramIndex onward.
return if (param.varargs) {
argSrcLocs.drop(paramIndex)
} else {
listOf(argSrcLocs[paramIndex])
} }
} }
@ -210,9 +189,9 @@ class Instruction(
StringType -> { StringType -> {
if (dcGcFormat) { if (dcGcFormat) {
(args[0].value as String).length + 1 (args[0] as StringArg).value.length + 1
} else { } else {
2 * (args[0].value as String).length + 2 2 * (args[0] as StringArg).value.length + 2
} }
} }
@ -232,13 +211,43 @@ class Instruction(
} }
fun copy(): Instruction = fun copy(): Instruction =
Instruction(opcode, args, srcLoc) Instruction(opcode, args, valid, srcLoc).also { it.paramToArgs = paramToArgs }
} }
/** /**
* Instruction argument. * Instruction argument.
*/ */
data class Arg(val value: Any) sealed class Arg {
abstract val value: Any?
abstract fun coerceInt(): Int
abstract fun coerceFloat(): Float
abstract fun coerceString(): String
}
data class IntArg(override val value: Int) : Arg() {
override fun coerceInt(): Int = value
override fun coerceFloat(): Float = Float.fromBits(value)
override fun coerceString(): String = value.toString()
}
data class FloatArg(override val value: Float) : Arg() {
override fun coerceInt(): Int = value.toRawBits()
override fun coerceFloat(): Float = value
override fun coerceString(): String = value.toString()
}
data class StringArg(override val value: String) : Arg() {
override fun coerceInt(): Int = 0
override fun coerceFloat(): Float = 0f
override fun coerceString(): String = value
}
data class UnknownArg(override val value: Any?) : Arg() {
override fun coerceInt(): Int = 0
override fun coerceFloat(): Float = 0f
override fun coerceString(): String = ""
}
/** /**
* Position and length of related source assembly code. * Position and length of related source assembly code.
@ -254,8 +263,15 @@ class SrcLoc(
*/ */
class InstructionSrcLoc( class InstructionSrcLoc(
val mnemonic: SrcLoc?, val mnemonic: SrcLoc?,
/**
* Immediate or stack argument locations.
*/
val args: List<ArgSrcLoc> = emptyList(), val args: List<ArgSrcLoc> = emptyList(),
val stackArgs: List<ArgSrcLoc> = emptyList(), /**
* Does the instruction end with a comma? This can be the case when a user has partially typed
* an instruction.
*/
val trailingArgSeparator: Boolean,
) )
/** /**

5
lib/src/commonMain/kotlin/world/phantasmal/lib/asm/Disassembly.kt
View File

@ -1,7 +1,6 @@
package world.phantasmal.lib.asm package world.phantasmal.lib.asm
import mu.KotlinLogging import mu.KotlinLogging
import world.phantasmal.core.reinterpretAsFloat
import kotlin.math.min import kotlin.math.min
private val logger = KotlinLogging.logger {} private val logger = KotlinLogging.logger {}
@ -212,7 +211,7 @@ private fun StringBuilder.appendArgs(params: List<Param>, args: List<ArgWithType
FloatType -> { FloatType -> {
// Floats are pushed onto the stack as integers with arg_pushl. // Floats are pushed onto the stack as integers with arg_pushl.
if (stack) { if (stack) {
append((arg.value as Int).reinterpretAsFloat()) append(Float.fromBits((arg as IntArg).value))
} else { } else {
append(arg.value) append(arg.value)
} }
@ -241,7 +240,7 @@ private fun StringBuilder.appendArgs(params: List<Param>, args: List<ArgWithType
} }
StringType -> { StringType -> {
appendStringArg(arg.value as String) appendStringArg((arg as StringArg).value)
} }
else -> { else -> {

12
lib/src/commonMain/kotlin/world/phantasmal/lib/asm/dataFlowAnalysis/ControlFlowGraph.kt
View File

@ -167,7 +167,7 @@ private fun createBasicBlocks(cfg: ControlFlowGraphBuilder, segment: Instruction
// Unconditional jump. // Unconditional jump.
OP_JMP.code -> { OP_JMP.code -> {
branchType = BranchType.Jump branchType = BranchType.Jump
branchLabels = listOf(inst.args[0].value as Int) branchLabels = listOf((inst.args[0] as IntArg).value)
} }
// Conditional jumps. // Conditional jumps.
@ -175,7 +175,7 @@ private fun createBasicBlocks(cfg: ControlFlowGraphBuilder, segment: Instruction
OP_JMP_OFF.code, OP_JMP_OFF.code,
-> { -> {
branchType = BranchType.ConditionalJump branchType = BranchType.ConditionalJump
branchLabels = listOf(inst.args[0].value as Int) branchLabels = listOf((inst.args[0] as IntArg).value)
} }
OP_JMP_E.code, OP_JMP_E.code,
OP_JMPI_E.code, OP_JMPI_E.code,
@ -199,11 +199,11 @@ private fun createBasicBlocks(cfg: ControlFlowGraphBuilder, segment: Instruction
OP_JMPI_LE.code, OP_JMPI_LE.code,
-> { -> {
branchType = BranchType.ConditionalJump branchType = BranchType.ConditionalJump
branchLabels = listOf(inst.args[2].value as Int) branchLabels = listOf((inst.args[2] as IntArg).value)
} }
OP_SWITCH_JMP.code -> { OP_SWITCH_JMP.code -> {
branchType = BranchType.ConditionalJump branchType = BranchType.ConditionalJump
branchLabels = inst.args.drop(1).map { it.value as Int } branchLabels = inst.args.drop(1).map { (it as IntArg).value }
} }
// Calls. // Calls.
@ -211,11 +211,11 @@ private fun createBasicBlocks(cfg: ControlFlowGraphBuilder, segment: Instruction
OP_VA_CALL.code, OP_VA_CALL.code,
-> { -> {
branchType = BranchType.Call branchType = BranchType.Call
branchLabels = listOf(inst.args[0].value as Int) branchLabels = listOf((inst.args[0] as IntArg).value)
} }
OP_SWITCH_CALL.code -> { OP_SWITCH_CALL.code -> {
branchType = BranchType.Call branchType = BranchType.Call
branchLabels = inst.args.drop(1).map { it.value as Int } branchLabels = inst.args.drop(1).map { (it as IntArg).value }
} }
// All other opcodes. // All other opcodes.

11
lib/src/commonMain/kotlin/world/phantasmal/lib/asm/dataFlowAnalysis/GetMapDesignations.kt
View File

@ -1,10 +1,7 @@
package world.phantasmal.lib.asm.dataFlowAnalysis package world.phantasmal.lib.asm.dataFlowAnalysis
import mu.KotlinLogging import mu.KotlinLogging
import world.phantasmal.lib.asm.InstructionSegment import world.phantasmal.lib.asm.*
import world.phantasmal.lib.asm.OP_BB_MAP_DESIGNATE
import world.phantasmal.lib.asm.OP_MAP_DESIGNATE
import world.phantasmal.lib.asm.OP_MAP_DESIGNATE_EX
private val logger = KotlinLogging.logger {} private val logger = KotlinLogging.logger {}
@ -24,7 +21,7 @@ fun getMapDesignations(
cfg = createCfg() cfg = createCfg()
} }
val areaId = getRegisterValue(cfg, inst, inst.args[0].value as Int) val areaId = getRegisterValue(cfg, inst, (inst.args[0] as IntArg).value)
if (areaId.size > 1) { if (areaId.size > 1) {
logger.warn { logger.warn {
@ -34,7 +31,7 @@ fun getMapDesignations(
} }
val variantIdRegister = val variantIdRegister =
inst.args[0].value as Int + (if (inst.opcode == OP_MAP_DESIGNATE) 2 else 3) (inst.args[0] as IntArg).value + (if (inst.opcode == OP_MAP_DESIGNATE) 2 else 3)
val variantId = getRegisterValue(cfg, inst, variantIdRegister) val variantId = getRegisterValue(cfg, inst, variantIdRegister)
if (variantId.size > 1) { if (variantId.size > 1) {
@ -48,7 +45,7 @@ fun getMapDesignations(
} }
OP_BB_MAP_DESIGNATE.code -> { OP_BB_MAP_DESIGNATE.code -> {
mapDesignations[inst.args[0].value as Int] = inst.args[2].value as Int mapDesignations[(inst.args[0] as IntArg).value] = (inst.args[2] as IntArg).value
} }
} }
} }

29
lib/src/commonMain/kotlin/world/phantasmal/lib/asm/dataFlowAnalysis/GetRegisterValue.kt
View File

@ -58,7 +58,7 @@ private class RegisterValueFinder {
OP_LET.code -> { OP_LET.code -> {
if (args[0].value == register) { if (args[0].value == register) {
return find(LinkedHashSet(path), block, i, args[1].value as Int) return find(LinkedHashSet(path), block, i, (args[1] as IntArg).value)
} }
} }
@ -68,7 +68,7 @@ private class RegisterValueFinder {
OP_SYNC_LETI.code, OP_SYNC_LETI.code,
-> { -> {
if (args[0].value == register) { if (args[0].value == register) {
return ValueSet.of(args[1].value as Int) return ValueSet.of((args[1] as IntArg).value)
} }
} }
@ -101,7 +101,7 @@ private class RegisterValueFinder {
OP_ADDI.code -> { OP_ADDI.code -> {
if (args[0].value == register) { if (args[0].value == register) {
val prevVals = find(LinkedHashSet(path), block, i, register) val prevVals = find(LinkedHashSet(path), block, i, register)
prevVals += args[1].value as Int prevVals += (args[1] as IntArg).value
return prevVals return prevVals
} }
} }
@ -109,7 +109,7 @@ private class RegisterValueFinder {
OP_SUBI.code -> { OP_SUBI.code -> {
if (args[0].value == register) { if (args[0].value == register) {
val prevVals = find(LinkedHashSet(path), block, i, register) val prevVals = find(LinkedHashSet(path), block, i, register)
prevVals -= args[1].value as Int prevVals -= (args[1] as IntArg).value
return prevVals return prevVals
} }
} }
@ -117,7 +117,7 @@ private class RegisterValueFinder {
OP_MULI.code -> { OP_MULI.code -> {
if (args[0].value == register) { if (args[0].value == register) {
val prevVals = find(LinkedHashSet(path), block, i, register) val prevVals = find(LinkedHashSet(path), block, i, register)
prevVals *= args[1].value as Int prevVals *= (args[1] as IntArg).value
return prevVals return prevVals
} }
} }
@ -125,7 +125,7 @@ private class RegisterValueFinder {
OP_DIVI.code -> { OP_DIVI.code -> {
if (args[0].value == register) { if (args[0].value == register) {
val prevVals = find(LinkedHashSet(path), block, i, register) val prevVals = find(LinkedHashSet(path), block, i, register)
prevVals /= args[1].value as Int prevVals /= (args[1] as IntArg).value
return prevVals return prevVals
} }
} }
@ -155,7 +155,7 @@ private class RegisterValueFinder {
LinkedHashSet(path), LinkedHashSet(path),
block, block,
i, i,
args[0].value as Int (args[0] as IntArg).value
).minOrNull()!! ).minOrNull()!!
val max = max( val max = max(
@ -163,7 +163,7 @@ private class RegisterValueFinder {
LinkedHashSet(path), LinkedHashSet(path),
block, block,
i, i,
args[0].value as Int + 1 (args[0] as IntArg).value + 1
).maxOrNull()!!, ).maxOrNull()!!,
min + 1, min + 1,
) )
@ -175,8 +175,8 @@ private class RegisterValueFinder {
OP_STACK_PUSHM.code, OP_STACK_PUSHM.code,
OP_STACK_POPM.code, OP_STACK_POPM.code,
-> { -> {
val minReg = args[0].value as Int val minReg = (args[0] as IntArg).value
val maxReg = args[0].value as Int + args[1].value as Int val maxReg = (args[0] as IntArg).value + (args[1] as IntArg).value
if (register in minReg until maxReg) { if (register in minReg until maxReg) {
return ValueSet.all() return ValueSet.all()
@ -192,7 +192,7 @@ private class RegisterValueFinder {
val param = params[j] val param = params[j]
if (param.type is RegType && param.type.registers != null) { if (param.type is RegType && param.type.registers != null) {
val regRef = args[j].value as Int val regRef = (args[j] as IntArg).value
for ((k, regParam) in param.type.registers.withIndex()) { for ((k, regParam) in param.type.registers.withIndex()) {
if (regParam.write && regRef + k == register) { if (regParam.write && regRef + k == register) {
@ -274,14 +274,15 @@ private class RegisterValueFinder {
return if (register in 1..stack.size) { return if (register in 1..stack.size) {
val instruction = stack[register - 1] val instruction = stack[register - 1]
val value = instruction.args.first().value val arg = instruction.args.first()
when (instruction.opcode.code) { when (instruction.opcode.code) {
OP_ARG_PUSHR.code -> find(LinkedHashSet(path), block, vaStartIdx, value as Int) OP_ARG_PUSHR.code ->
find(LinkedHashSet(path), block, vaStartIdx, (arg as IntArg).value)
OP_ARG_PUSHL.code, OP_ARG_PUSHL.code,
OP_ARG_PUSHB.code, OP_ARG_PUSHB.code,
OP_ARG_PUSHW.code -> ValueSet.of(value as Int) OP_ARG_PUSHW.code -> ValueSet.of((arg as IntArg).value)
// TODO: Deal with strings. // TODO: Deal with strings.
else -> ValueSet.all() // String or pointer else -> ValueSet.all() // String or pointer

4
lib/src/commonMain/kotlin/world/phantasmal/lib/asm/dataFlowAnalysis/GetStackValue.kt
View File

@ -51,7 +51,7 @@ private class StackValueFinder {
when (instruction.opcode.code) { when (instruction.opcode.code) {
OP_ARG_PUSHR.code -> { OP_ARG_PUSHR.code -> {
if (pos == 0) { if (pos == 0) {
return getRegisterValue(cfg, instruction, args[0].value as Int) return getRegisterValue(cfg, instruction, (args[0] as IntArg).value)
} else { } else {
pos-- pos--
} }
@ -62,7 +62,7 @@ private class StackValueFinder {
OP_ARG_PUSHW.code, OP_ARG_PUSHW.code,
-> { -> {
if (pos == 0) { if (pos == 0) {
return ValueSet.of(args[0].value as Int) return ValueSet.of((args[0] as IntArg).value)
} else { } else {
pos-- pos--
} }

47
lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/Bytecode.kt
View File

@ -242,8 +242,9 @@ private fun findAndParseSegments(
// Never on the stack. // Never on the stack.
// Eat all remaining arguments. // Eat all remaining arguments.
while (i < instruction.args.size) { while (i < instruction.args.size) {
newLabels[instruction.args[i].value as Int] = newLabels[(instruction.args[i] as IntArg).value] =
SegmentType.Instructions SegmentType.Instructions
i++ i++
} }
} }
@ -347,7 +348,7 @@ private fun getArgLabelValues(
return true return true
} }
} else { } else {
val value = instruction.args[paramIdx].value as Int val value = (instruction.args[paramIdx] as IntArg).value
val oldType = labels[value] val oldType = labels[value]
if ( if (
@ -466,13 +467,13 @@ private fun parseInstructionsSegment(
// Parse the arguments. // Parse the arguments.
try { try {
val args = parseInstructionArguments(cursor, opcode, dcGcFormat) val args = parseInstructionArguments(cursor, opcode, dcGcFormat)
instructions.add(Instruction(opcode, args, srcLoc = null)) instructions.add(Instruction(opcode, args, srcLoc = null, valid = true))
} catch (e: Exception) { } catch (e: Exception) {
if (lenient) { if (lenient) {
logger.error(e) { logger.error(e) {
"Exception occurred while parsing arguments for instruction ${opcode.mnemonic}." "Exception occurred while parsing arguments for instruction ${opcode.mnemonic}."
} }
instructions.add(Instruction(opcode, emptyList(), srcLoc = null)) instructions.add(Instruction(opcode, emptyList(), srcLoc = null, valid = false))
} else { } else {
throw e throw e
} }
@ -565,33 +566,33 @@ private fun parseInstructionArguments(
for (param in opcode.params) { for (param in opcode.params) {
when (param.type) { when (param.type) {
is ByteType -> is ByteType ->
args.add(Arg(cursor.uByte().toInt())) args.add(IntArg(cursor.uByte().toInt()))
is ShortType -> is ShortType ->
args.add(Arg(cursor.uShort().toInt())) args.add(IntArg(cursor.uShort().toInt()))
is IntType -> is IntType ->
args.add(Arg(cursor.int())) args.add(IntArg(cursor.int()))
is FloatType -> is FloatType ->
args.add(Arg(cursor.float())) args.add(FloatArg(cursor.float()))
// Ensure this case is before the LabelType case because ILabelVarType extends // Ensure this case is before the LabelType case because ILabelVarType extends
// LabelType. // LabelType.
is ILabelVarType -> { is ILabelVarType -> {
varargCount++ varargCount++
val argSize = cursor.uByte() val argSize = cursor.uByte()
args.addAll(cursor.uShortArray(argSize.toInt()).map { Arg(it.toInt()) }) args.addAll(cursor.uShortArray(argSize.toInt()).map { IntArg(it.toInt()) })
} }
is LabelType -> { is LabelType -> {
args.add(Arg(cursor.uShort().toInt())) args.add(IntArg(cursor.uShort().toInt()))
} }
is StringType -> { is StringType -> {
val maxBytes = min(4096, cursor.bytesLeft) val maxBytes = min(4096, cursor.bytesLeft)
args.add( args.add(
Arg( StringArg(
if (dcGcFormat) { if (dcGcFormat) {
cursor.stringAscii( cursor.stringAscii(
maxBytes, maxBytes,
@ -610,13 +611,13 @@ private fun parseInstructionArguments(
} }
is RegType -> { is RegType -> {
args.add(Arg(cursor.uByte().toInt())) args.add(IntArg(cursor.uByte().toInt()))
} }
is RegVarType -> { is RegVarType -> {
varargCount++ varargCount++
val argSize = cursor.uByte() val argSize = cursor.uByte()
args.addAll(cursor.uByteArray(argSize.toInt()).map { Arg(it.toInt()) }) args.addAll(cursor.uByteArray(argSize.toInt()).map { IntArg(it.toInt()) })
} }
else -> error("Parameter type ${param.type} not implemented.") else -> error("Parameter type ${param.type} not implemented.")
@ -725,7 +726,7 @@ private fun tryParseInstructionsSegment(
for (arg in inst.getArgs(index)) { for (arg in inst.getArgs(index)) {
labelCount++ labelCount++
if (!labelHolder.hasLabel(arg.value as Int)) { if (!labelHolder.hasLabel((arg as IntArg).value)) {
unknownLabelCount++ unknownLabelCount++
} }
} }
@ -805,34 +806,34 @@ fun writeBytecode(bytecodeIr: BytecodeIr, dcGcFormat: Boolean): BytecodeAndLabel
} }
when (param.type) { when (param.type) {
ByteType -> cursor.writeByte((arg.value as Int).toByte()) ByteType -> cursor.writeByte(arg.coerceInt().toByte())
ShortType -> cursor.writeShort((arg.value as Int).toShort()) ShortType -> cursor.writeShort(arg.coerceInt().toShort())
IntType -> cursor.writeInt(arg.value as Int) IntType -> cursor.writeInt(arg.coerceInt())
FloatType -> cursor.writeFloat(arg.value as Float) FloatType -> cursor.writeFloat(arg.coerceFloat())
// Ensure this case is before the LabelType case because // Ensure this case is before the LabelType case because
// ILabelVarType extends LabelType. // ILabelVarType extends LabelType.
ILabelVarType -> { ILabelVarType -> {
cursor.writeByte(args.size.toByte()) cursor.writeByte(args.size.toByte())
for (a in args) { for (a in args) {
cursor.writeShort((a.value as Int).toShort()) cursor.writeShort(a.coerceInt().toShort())
} }
} }
is LabelType -> cursor.writeShort((arg.value as Int).toShort()) is LabelType -> cursor.writeShort(arg.coerceInt().toShort())
StringType -> { StringType -> {
val str = arg.value as String val str = arg.coerceString()
if (dcGcFormat) cursor.writeStringAscii(str, str.length + 1) if (dcGcFormat) cursor.writeStringAscii(str, str.length + 1)
else cursor.writeStringUtf16(str, 2 * str.length + 2) else cursor.writeStringUtf16(str, 2 * str.length + 2)
} }
is RegType -> { is RegType -> {
cursor.writeByte((arg.value as Int).toByte()) cursor.writeByte(arg.coerceInt().toByte())
} }
RegVarType -> { RegVarType -> {
cursor.writeByte(args.size.toByte()) cursor.writeByte(args.size.toByte())
for (a in args) { for (a in args) {
cursor.writeByte((a.value as Int).toByte()) cursor.writeByte(a.coerceInt().toByte())
} }
} }
else -> error( else -> error(

108
lib/src/commonTest/kotlin/world/phantasmal/lib/asm/AssemblyTests.kt
View File

@ -34,16 +34,17 @@ class AssemblyTests : LibTestSuite {
instructions = mutableListOf( instructions = mutableListOf(
Instruction( Instruction(
opcode = OP_SET_EPISODE, opcode = OP_SET_EPISODE,
args = listOf(Arg(0)), args = listOf(IntArg(0)),
srcLoc = InstructionSrcLoc( srcLoc = InstructionSrcLoc(
mnemonic = SrcLoc(2, 5, 11), mnemonic = SrcLoc(2, 5, 11),
args = listOf(ArgSrcLoc(SrcLoc(2, 17, 1), SrcLoc(2, 16, 2))), args = listOf(ArgSrcLoc(SrcLoc(2, 17, 1), SrcLoc(2, 16, 2))),
stackArgs = emptyList(), trailingArgSeparator = false,
), ),
valid = true,
), ),
Instruction( Instruction(
opcode = OP_BB_MAP_DESIGNATE, opcode = OP_BB_MAP_DESIGNATE,
args = listOf(Arg(1), Arg(2), Arg(3), Arg(4)), args = listOf(IntArg(1), IntArg(2), IntArg(3), IntArg(4)),
srcLoc = InstructionSrcLoc( srcLoc = InstructionSrcLoc(
mnemonic = SrcLoc(3, 5, 16), mnemonic = SrcLoc(3, 5, 16),
args = listOf( args = listOf(
@ -52,38 +53,42 @@ class AssemblyTests : LibTestSuite {
ArgSrcLoc(SrcLoc(3, 28, 1), SrcLoc(3, 27, 3)), ArgSrcLoc(SrcLoc(3, 28, 1), SrcLoc(3, 27, 3)),
ArgSrcLoc(SrcLoc(3, 31, 1), SrcLoc(3, 30, 2)), ArgSrcLoc(SrcLoc(3, 31, 1), SrcLoc(3, 30, 2)),
), ),
stackArgs = emptyList(), trailingArgSeparator = false,
), ),
valid = true,
), ),
Instruction( Instruction(
opcode = OP_ARG_PUSHL, opcode = OP_ARG_PUSHL,
args = listOf(Arg(0)), args = listOf(IntArg(0)),
srcLoc = InstructionSrcLoc( srcLoc = InstructionSrcLoc(
mnemonic = null, mnemonic = null,
args = listOf(ArgSrcLoc(SrcLoc(4, 23, 1), SrcLoc(4, 22, 3))), args = listOf(ArgSrcLoc(SrcLoc(4, 23, 1), SrcLoc(4, 22, 3))),
stackArgs = emptyList(), trailingArgSeparator = false,
), ),
valid = true,
), ),
Instruction( Instruction(
opcode = OP_ARG_PUSHW, opcode = OP_ARG_PUSHW,
args = listOf(Arg(150)), args = listOf(IntArg(150)),
srcLoc = InstructionSrcLoc( srcLoc = InstructionSrcLoc(
mnemonic = null, mnemonic = null,
args = listOf(ArgSrcLoc(SrcLoc(4, 26, 3), SrcLoc(4, 25, 4))), args = listOf(ArgSrcLoc(SrcLoc(4, 26, 3), SrcLoc(4, 25, 4))),
stackArgs = emptyList(), trailingArgSeparator = false,
), ),
valid = true,
), ),
Instruction( Instruction(
opcode = OP_SET_FLOOR_HANDLER, opcode = OP_SET_FLOOR_HANDLER,
args = emptyList(), args = emptyList(),
srcLoc = InstructionSrcLoc( srcLoc = InstructionSrcLoc(
mnemonic = SrcLoc(4, 5, 17), mnemonic = SrcLoc(4, 5, 17),
args = emptyList(), args = listOf(
stackArgs = listOf(
ArgSrcLoc(SrcLoc(4, 23, 1), SrcLoc(4, 22, 3)), ArgSrcLoc(SrcLoc(4, 23, 1), SrcLoc(4, 22, 3)),
ArgSrcLoc(SrcLoc(4, 26, 3), SrcLoc(4, 25, 4)), ArgSrcLoc(SrcLoc(4, 26, 3), SrcLoc(4, 25, 4)),
), ),
trailingArgSeparator = false,
), ),
valid = true,
), ),
Instruction( Instruction(
opcode = OP_RET, opcode = OP_RET,
@ -91,8 +96,9 @@ class AssemblyTests : LibTestSuite {
srcLoc = InstructionSrcLoc( srcLoc = InstructionSrcLoc(
mnemonic = SrcLoc(5, 5, 3), mnemonic = SrcLoc(5, 5, 3),
args = emptyList(), args = emptyList(),
stackArgs = emptyList(), trailingArgSeparator = false,
), ),
valid = true,
), ),
), ),
srcLoc = SegmentSrcLoc(labels = mutableListOf(SrcLoc(1, 1, 2))), srcLoc = SegmentSrcLoc(labels = mutableListOf(SrcLoc(1, 1, 2))),
@ -102,23 +108,25 @@ class AssemblyTests : LibTestSuite {
instructions = mutableListOf( instructions = mutableListOf(
Instruction( Instruction(
opcode = OP_ARG_PUSHL, opcode = OP_ARG_PUSHL,
args = listOf(Arg(1)), args = listOf(IntArg(1)),
srcLoc = InstructionSrcLoc( srcLoc = InstructionSrcLoc(
mnemonic = null, mnemonic = null,
args = listOf(ArgSrcLoc(SrcLoc(7, 18, 1), SrcLoc(7, 17, 2))), args = listOf(ArgSrcLoc(SrcLoc(7, 18, 1), SrcLoc(7, 17, 2))),
stackArgs = emptyList(), trailingArgSeparator = false,
), ),
valid = true,
), ),
Instruction( Instruction(
opcode = OP_SET_MAINWARP, opcode = OP_SET_MAINWARP,
args = emptyList(), args = emptyList(),
srcLoc = InstructionSrcLoc( srcLoc = InstructionSrcLoc(
mnemonic = SrcLoc(7, 5, 12), mnemonic = SrcLoc(7, 5, 12),
args = emptyList(), args = listOf(
stackArgs = listOf(
ArgSrcLoc(SrcLoc(7, 18, 1), SrcLoc(7, 17, 2)), ArgSrcLoc(SrcLoc(7, 18, 1), SrcLoc(7, 17, 2)),
), ),
trailingArgSeparator = false,
), ),
valid = true,
), ),
Instruction( Instruction(
opcode = OP_RET, opcode = OP_RET,
@ -126,8 +134,9 @@ class AssemblyTests : LibTestSuite {
srcLoc = InstructionSrcLoc( srcLoc = InstructionSrcLoc(
mnemonic = SrcLoc(8, 5, 3), mnemonic = SrcLoc(8, 5, 3),
args = emptyList(), args = emptyList(),
stackArgs = emptyList(), trailingArgSeparator = false,
), ),
valid = true,
), ),
), ),
srcLoc = SegmentSrcLoc(labels = mutableListOf(SrcLoc(6, 1, 4))), srcLoc = SegmentSrcLoc(labels = mutableListOf(SrcLoc(6, 1, 4))),
@ -160,35 +169,38 @@ class AssemblyTests : LibTestSuite {
instructions = mutableListOf( instructions = mutableListOf(
Instruction( Instruction(
opcode = OP_LETI, opcode = OP_LETI,
args = listOf(Arg(255), Arg(7)), args = listOf(IntArg(255), IntArg(7)),
srcLoc = InstructionSrcLoc( srcLoc = InstructionSrcLoc(
mnemonic = SrcLoc(2, 5, 4), mnemonic = SrcLoc(2, 5, 4),
args = listOf( args = listOf(
ArgSrcLoc(SrcLoc(2, 10, 4), SrcLoc(2, 9, 6)), ArgSrcLoc(SrcLoc(2, 10, 4), SrcLoc(2, 9, 6)),
ArgSrcLoc(SrcLoc(2, 16, 1), SrcLoc(2, 15, 2)), ArgSrcLoc(SrcLoc(2, 16, 1), SrcLoc(2, 15, 2)),
), ),
stackArgs = emptyList(), trailingArgSeparator = false,
), ),
valid = true,
), ),
Instruction( Instruction(
opcode = OP_ARG_PUSHR, opcode = OP_ARG_PUSHR,
args = listOf(Arg(255)), args = listOf(IntArg(255)),
srcLoc = InstructionSrcLoc( srcLoc = InstructionSrcLoc(
mnemonic = null, mnemonic = null,
args = listOf(ArgSrcLoc(SrcLoc(3, 10, 4), SrcLoc(3, 9, 5))), args = listOf(ArgSrcLoc(SrcLoc(3, 10, 4), SrcLoc(3, 9, 5))),
stackArgs = emptyList(), trailingArgSeparator = false,
), ),
valid = true,
), ),
Instruction( Instruction(
opcode = OP_EXIT, opcode = OP_EXIT,
args = emptyList(), args = emptyList(),
srcLoc = InstructionSrcLoc( srcLoc = InstructionSrcLoc(
mnemonic = SrcLoc(3, 5, 4), mnemonic = SrcLoc(3, 5, 4),
args = emptyList(), args = listOf(
stackArgs = listOf(
ArgSrcLoc(SrcLoc(3, 10, 4), SrcLoc(3, 9, 5)), ArgSrcLoc(SrcLoc(3, 10, 4), SrcLoc(3, 9, 5)),
), ),
trailingArgSeparator = false,
), ),
valid = true,
), ),
Instruction( Instruction(
opcode = OP_RET, opcode = OP_RET,
@ -196,8 +208,9 @@ class AssemblyTests : LibTestSuite {
srcLoc = InstructionSrcLoc( srcLoc = InstructionSrcLoc(
mnemonic = SrcLoc(4, 5, 3), mnemonic = SrcLoc(4, 5, 3),
args = emptyList(), args = emptyList(),
stackArgs = emptyList(), trailingArgSeparator = false,
), ),
valid = true,
), ),
), ),
srcLoc = SegmentSrcLoc( srcLoc = SegmentSrcLoc(
@ -231,33 +244,36 @@ class AssemblyTests : LibTestSuite {
instructions = mutableListOf( instructions = mutableListOf(
Instruction( Instruction(
opcode = OP_ARG_PUSHB, opcode = OP_ARG_PUSHB,
args = listOf(Arg(200)), args = listOf(IntArg(200)),
srcLoc = InstructionSrcLoc( srcLoc = InstructionSrcLoc(
mnemonic = null, mnemonic = null,
args = listOf(ArgSrcLoc(SrcLoc(2, 15, 4), SrcLoc(2, 14, 6))), args = listOf(ArgSrcLoc(SrcLoc(2, 15, 4), SrcLoc(2, 14, 6))),
stackArgs = emptyList(), trailingArgSeparator = false,
), ),
valid = true,
), ),
Instruction( Instruction(
opcode = OP_ARG_PUSHL, opcode = OP_ARG_PUSHL,
args = listOf(Arg(3)), args = listOf(IntArg(3)),
srcLoc = InstructionSrcLoc( srcLoc = InstructionSrcLoc(
mnemonic = null, mnemonic = null,
args = listOf(ArgSrcLoc(SrcLoc(2, 21, 1), SrcLoc(2, 20, 2))), args = listOf(ArgSrcLoc(SrcLoc(2, 21, 1), SrcLoc(2, 20, 2))),
stackArgs = emptyList(), trailingArgSeparator = false,
), ),
valid = true,
), ),
Instruction( Instruction(
opcode = OP_P_DEAD_V3, opcode = OP_P_DEAD_V3,
args = emptyList(), args = emptyList(),
srcLoc = InstructionSrcLoc( srcLoc = InstructionSrcLoc(
mnemonic = SrcLoc(2, 5, 9), mnemonic = SrcLoc(2, 5, 9),
args = emptyList(), args = listOf(
stackArgs = listOf(
ArgSrcLoc(SrcLoc(2, 15, 4), SrcLoc(2, 14, 6)), ArgSrcLoc(SrcLoc(2, 15, 4), SrcLoc(2, 14, 6)),
ArgSrcLoc(SrcLoc(2, 21, 1), SrcLoc(2, 20, 2)), ArgSrcLoc(SrcLoc(2, 21, 1), SrcLoc(2, 20, 2)),
), ),
trailingArgSeparator = false,
), ),
valid = true,
), ),
Instruction( Instruction(
opcode = OP_RET, opcode = OP_RET,
@ -265,8 +281,9 @@ class AssemblyTests : LibTestSuite {
srcLoc = InstructionSrcLoc( srcLoc = InstructionSrcLoc(
mnemonic = SrcLoc(3, 5, 3), mnemonic = SrcLoc(3, 5, 3),
args = emptyList(), args = emptyList(),
stackArgs = emptyList(), trailingArgSeparator = false,
), ),
valid = true,
), ),
), ),
srcLoc = SegmentSrcLoc( srcLoc = SegmentSrcLoc(
@ -289,6 +306,7 @@ class AssemblyTests : LibTestSuite {
) )
assertTrue(result is Success) assertTrue(result is Success)
// Bytecode contains one invalid instruction.
assertDeepEquals( assertDeepEquals(
BytecodeIr( BytecodeIr(
listOf( listOf(
@ -297,12 +315,13 @@ class AssemblyTests : LibTestSuite {
instructions = mutableListOf( instructions = mutableListOf(
Instruction( Instruction(
opcode = OP_RET, opcode = OP_RET,
args = emptyList(), args = listOf(IntArg(100)),
srcLoc = InstructionSrcLoc( srcLoc = InstructionSrcLoc(
mnemonic = SrcLoc(2, 5, 3), mnemonic = SrcLoc(2, 5, 3),
args = emptyList(), args = listOf(ArgSrcLoc(SrcLoc(2, 9, 3), SrcLoc(2, 8, 4))),
stackArgs = emptyList(), trailingArgSeparator = false,
), ),
valid = false,
), ),
), ),
srcLoc = SegmentSrcLoc( srcLoc = SegmentSrcLoc(
@ -333,14 +352,24 @@ class AssemblyTests : LibTestSuite {
) )
assertTrue(result is Success) assertTrue(result is Success)
// Bytecode contains one invalid instruction.
// Bytecode contains no instructions.
assertDeepEquals( assertDeepEquals(
BytecodeIr( BytecodeIr(
listOf( listOf(
InstructionSegment( InstructionSegment(
labels = mutableListOf(5000), labels = mutableListOf(5000),
instructions = mutableListOf(), instructions = mutableListOf(
Instruction(
opcode = OP_LETI,
args = listOf(IntArg(100)),
srcLoc = InstructionSrcLoc(
mnemonic = SrcLoc(2, 5, 4),
args = listOf(ArgSrcLoc(SrcLoc(2, 10, 4), SrcLoc(2, 9, 5))),
trailingArgSeparator = false,
),
valid = false,
),
),
srcLoc = SegmentSrcLoc( srcLoc = SegmentSrcLoc(
labels = mutableListOf(SrcLoc(1, 1, 5)), labels = mutableListOf(SrcLoc(1, 1, 5)),
), ),
@ -370,7 +399,7 @@ class AssemblyTests : LibTestSuite {
assertTrue(result is Success) assertTrue(result is Success)
// Bytecode contains an instruction, since it's technically valid. // Bytecode contains one invalid instruction.
assertDeepEquals( assertDeepEquals(
BytecodeIr( BytecodeIr(
listOf( listOf(
@ -379,12 +408,13 @@ class AssemblyTests : LibTestSuite {
instructions = mutableListOf( instructions = mutableListOf(
Instruction( Instruction(
opcode = OP_SWITCH_JMP, opcode = OP_SWITCH_JMP,
args = listOf(Arg(100)), args = listOf(IntArg(100)),
srcLoc = InstructionSrcLoc( srcLoc = InstructionSrcLoc(
mnemonic = SrcLoc(2, 5, 10), mnemonic = SrcLoc(2, 5, 10),
args = listOf(ArgSrcLoc(SrcLoc(2, 16, 4), SrcLoc(2, 15, 5))), args = listOf(ArgSrcLoc(SrcLoc(2, 16, 4), SrcLoc(2, 15, 5))),
stackArgs = emptyList(), trailingArgSeparator = false,
), ),
valid = false,
), ),
), ),
srcLoc = SegmentSrcLoc( srcLoc = SegmentSrcLoc(

19
lib/src/commonTest/kotlin/world/phantasmal/lib/asm/DisassemblyTests.kt
View File

@ -15,17 +15,19 @@ class DisassemblyTests : LibTestSuite {
Instruction( Instruction(
opcode = OP_SWITCH_JMP, opcode = OP_SWITCH_JMP,
args = listOf( args = listOf(
Arg(90), IntArg(90),
Arg(100), IntArg(100),
Arg(101), IntArg(101),
Arg(102), IntArg(102),
), ),
srcLoc = null, srcLoc = null,
valid = true,
), ),
Instruction( Instruction(
opcode = OP_RET, opcode = OP_RET,
args = emptyList(), args = emptyList(),
srcLoc = null, srcLoc = null,
valid = true,
), ),
), ),
) )
@ -57,26 +59,31 @@ class DisassemblyTests : LibTestSuite {
opcode = OP_VA_START, opcode = OP_VA_START,
args = emptyList(), args = emptyList(),
srcLoc = null, srcLoc = null,
valid = true,
), ),
Instruction( Instruction(
opcode = OP_ARG_PUSHW, opcode = OP_ARG_PUSHW,
args = listOf(Arg(1337)), args = listOf(IntArg(1337)),
srcLoc = null, srcLoc = null,
valid = true,
), ),
Instruction( Instruction(
opcode = OP_VA_CALL, opcode = OP_VA_CALL,
args = listOf(Arg(100)), args = listOf(IntArg(100)),
srcLoc = null, srcLoc = null,
valid = true,
), ),
Instruction( Instruction(
opcode = OP_VA_END, opcode = OP_VA_END,
args = emptyList(), args = emptyList(),
srcLoc = null, srcLoc = null,
valid = true,
), ),
Instruction( Instruction(
opcode = OP_RET, opcode = OP_RET,
args = emptyList(), args = emptyList(),
srcLoc = null, srcLoc = null,
valid = true,
), ),
), ),
) )

6
lib/src/commonTest/kotlin/world/phantasmal/lib/asm/OpcodeTests.kt
View File

@ -3,6 +3,7 @@ package world.phantasmal.lib.asm
import world.phantasmal.lib.test.LibTestSuite import world.phantasmal.lib.test.LibTestSuite
import kotlin.test.Test import kotlin.test.Test
import kotlin.test.assertEquals import kotlin.test.assertEquals
import kotlin.test.assertNotEquals
import kotlin.test.assertTrue import kotlin.test.assertTrue
class OpcodeTests : LibTestSuite { class OpcodeTests : LibTestSuite {
@ -28,10 +29,13 @@ class OpcodeTests : LibTestSuite {
assertTrue(!hasVarargs || opcode.params.lastOrNull()?.varargs == true) assertTrue(!hasVarargs || opcode.params.lastOrNull()?.varargs == true)
assertEquals(hasVarargs, opcode.varargs) assertEquals(hasVarargs, opcode.varargs)
// Register references.
for (param in opcode.params) { for (param in opcode.params) {
val type = param.type val type = param.type
// Any should only be used with register parameters.
assertNotEquals(AnyType.Instance, type)
// Register references.
if (type is RegType) { if (type is RegType) {
val registers = type.registers val registers = type.registers

3
lib/src/commonTest/kotlin/world/phantasmal/lib/test/BytecodeIrAssertions.kt
View File

@ -61,6 +61,7 @@ fun assertDeepEquals(
message: String? = null, message: String? = null,
) { ) {
assertEquals(expected.opcode, actual.opcode, message) assertEquals(expected.opcode, actual.opcode, message)
assertEquals(expected.valid, actual.valid, message)
assertDeepEquals(expected.args, actual.args, ::assertEquals, message) assertDeepEquals(expected.args, actual.args, ::assertEquals, message)
if (!ignoreSrcLocs) { if (!ignoreSrcLocs) {
@ -91,9 +92,9 @@ fun assertDeepEquals(
} }
assertNotNull(actual, message) assertNotNull(actual, message)
assertEquals(expected.trailingArgSeparator, actual.trailingArgSeparator, message)
assertDeepEquals(expected.mnemonic, actual.mnemonic, message) assertDeepEquals(expected.mnemonic, actual.mnemonic, message)
assertDeepEquals(expected.args, actual.args, ::assertDeepEquals, message) assertDeepEquals(expected.args, actual.args, ::assertDeepEquals, message)
assertDeepEquals(expected.stackArgs, actual.stackArgs, ::assertDeepEquals, message)
} }
fun assertDeepEquals(expected: ArgSrcLoc?, actual: ArgSrcLoc?, message: String? = null) { fun assertDeepEquals(expected: ArgSrcLoc?, actual: ArgSrcLoc?, message: String? = null) {

40
web/assembly-worker/src/main/kotlin/world/phantasmal/web/assemblyWorker/AsmAnalyser.kt
View File

@ -7,6 +7,7 @@ import world.phantasmal.lib.asm.dataFlowAnalysis.getMapDesignations
import world.phantasmal.lib.asm.dataFlowAnalysis.getStackValue import world.phantasmal.lib.asm.dataFlowAnalysis.getStackValue
import world.phantasmal.web.shared.messages.* import world.phantasmal.web.shared.messages.*
import world.phantasmal.web.shared.messages.AssemblyProblem import world.phantasmal.web.shared.messages.AssemblyProblem
import kotlin.math.max
import kotlin.math.min import kotlin.math.min
import world.phantasmal.lib.asm.AssemblyProblem as LibAssemblyProblem import world.phantasmal.lib.asm.AssemblyProblem as LibAssemblyProblem
@ -197,9 +198,9 @@ class AsmAnalyser {
var signature: Signature? = null var signature: Signature? = null
var activeParam = -1 var activeParam = -1
getInstructionForSrcLoc(lineNo, col)?.let { (inst, argIdx) -> getInstructionForSrcLoc(lineNo, col)?.let { (inst, paramIdx) ->
signature = getSignature(inst.opcode) signature = getSignature(inst.opcode)
activeParam = argIdx activeParam = paramIdx
} }
return signature?.let { sig -> return signature?.let { sig ->
@ -275,14 +276,14 @@ class AsmAnalyser {
val srcLoc = argSrcLocs[i].coarse val srcLoc = argSrcLocs[i].coarse
if (positionInside(lineNo, col, srcLoc)) { if (positionInside(lineNo, col, srcLoc)) {
val label = arg.value as Int val label = (arg as IntArg).value
result = getLabelDefinitions(label) result = getLabelDefinitions(label)
break@loop break@loop
} }
} }
} else { } else {
// Stack arguments. // Stack arguments.
val argSrcLocs = inst.getStackArgSrcLocs(paramIdx) val argSrcLocs = inst.getArgSrcLocs(paramIdx)
for ((i, argSrcLoc) in argSrcLocs.withIndex()) { for ((i, argSrcLoc) in argSrcLocs.withIndex()) {
if (positionInside(lineNo, col, argSrcLoc.coarse)) { if (positionInside(lineNo, col, argSrcLoc.coarse)) {
@ -332,7 +333,7 @@ class AsmAnalyser {
is Ir.Inst -> { is Ir.Inst -> {
val srcLoc = ir.inst.srcLoc?.mnemonic val srcLoc = ir.inst.srcLoc?.mnemonic
if (ir.argIdx == -1 || if (ir.paramIdx == -1 ||
// Also return this instruction if we're right past the mnemonic. E.g. at the // Also return this instruction if we're right past the mnemonic. E.g. at the
// first whitespace character preceding the first argument. // first whitespace character preceding the first argument.
(srcLoc != null && col <= srcLoc.col + srcLoc.len) (srcLoc != null && col <= srcLoc.col + srcLoc.len)
@ -373,7 +374,7 @@ class AsmAnalyser {
lastCol = mnemonicSrcLoc.col + mnemonicSrcLoc.len lastCol = mnemonicSrcLoc.col + mnemonicSrcLoc.len
if (positionInside(lineNo, col, mnemonicSrcLoc)) { if (positionInside(lineNo, col, mnemonicSrcLoc)) {
return Ir.Inst(inst, argIdx = -1) return Ir.Inst(inst, paramIdx = -1)
} }
} }
@ -386,26 +387,13 @@ class AsmAnalyser {
} }
} }
if (inlineStackArgs) {
for ((argIdx, argSrcLoc) in srcLoc.stackArgs.withIndex()) {
instLineNo = argSrcLoc.coarse.lineNo
lastCol = argSrcLoc.coarse.col + argSrcLoc.coarse.len
if (positionInside(lineNo, col, argSrcLoc.coarse)) {
return Ir.Inst(inst, argIdx)
}
}
}
if (lineNo == instLineNo && col >= lastCol) { if (lineNo == instLineNo && col >= lastCol) {
return Ir.Inst( val argIdx = max(0, srcLoc.args.lastIndex) +
inst, (if (srcLoc.trailingArgSeparator) 1 else 0)
if (inlineStackArgs && inst.opcode.stack === StackInteraction.Pop) {
srcLoc.stackArgs.lastIndex val paramIdx = min(argIdx, inst.opcode.params.lastIndex)
} else {
srcLoc.args.lastIndex return Ir.Inst(inst, paramIdx)
},
)
} }
} }
} }
@ -434,7 +422,7 @@ class AsmAnalyser {
) )
private sealed class Ir { private sealed class Ir {
data class Inst(val inst: Instruction, val argIdx: Int) : Ir() data class Inst(val inst: Instruction, val paramIdx: Int) : Ir()
} }
companion object { companion object {

74
web/assembly-worker/src/test/kotlin/world/phantasmal/web/assemblyWorker/AsmAnalyserTests.kt
View File

@ -53,6 +53,80 @@ class AsmAnalyserTests : AssemblyWorkerTestSuite() {
} }
} }
@Test
fun getSignatureHelp_incomplete_instruction() = test {
// Three kinds of incomplete instructions.
val analyser = createAsmAnalyser(
"""
.code
0:
leti
leti r0
leti r0,
""".trimIndent()
)
val requestId = 113
for (col in 1..4) {
val response = analyser.getSignatureHelp(requestId, lineNo = 3, col)
assertDeepEquals(Response.GetSignatureHelp(requestId, null), response)
}
fun sigHelp(activeParameter: Int) = Response.GetSignatureHelp(
requestId,
SignatureHelp(
Signature(
label = "leti Reg<out Int>, Int",
documentation = "Sets a register to the given value.",
listOf(
Parameter(labelStart = 5, labelEnd = 17, null),
Parameter(labelStart = 19, labelEnd = 22, null),
),
),
activeParameter,
),
)
// First instruction: leti
for ((colRange, sigHelp) in listOf(
5..8 to sigHelp(-1),
9..9 to sigHelp(0),
)) {
for (col in colRange) {
val response = analyser.getSignatureHelp(requestId, 3, col)
assertDeepEquals(sigHelp, response, "col = $col")
}
}
// Second instruction: leti r0
for ((colRange, sigHelp) in listOf(
5..8 to sigHelp(-1),
9..12 to sigHelp(0),
)) {
for (col in colRange) {
val response = analyser.getSignatureHelp(requestId, 4, col)
assertDeepEquals(sigHelp, response, "col = $col")
}
}
// Third instruction: leti r0,
for ((colRange, sigHelp) in listOf(
5..8 to sigHelp(-1),
9..12 to sigHelp(0),
13..13 to sigHelp(1),
)) {
for (col in colRange) {
val response = analyser.getSignatureHelp(requestId, 5, col)
assertDeepEquals(sigHelp, response, "col = $col")
}
}
}
@Test @Test
fun getHighlights_for_instruction() = test { fun getHighlights_for_instruction() = test {
val analyser = createAsmAnalyser( val analyser = createAsmAnalyser(

22
web/src/main/kotlin/world/phantasmal/web/core/rendering/conversion/NinjaGeometryConversion.kt
View File

@ -3,7 +3,10 @@ package world.phantasmal.web.core.rendering.conversion
import mu.KotlinLogging import mu.KotlinLogging
import org.khronos.webgl.Float32Array import org.khronos.webgl.Float32Array
import org.khronos.webgl.Uint16Array import org.khronos.webgl.Uint16Array
import world.phantasmal.core.* import world.phantasmal.core.JsArray
import world.phantasmal.core.asArray
import world.phantasmal.core.isBitSet
import world.phantasmal.core.jsArrayOf
import world.phantasmal.core.unsafe.UnsafeMap import world.phantasmal.core.unsafe.UnsafeMap
import world.phantasmal.lib.fileFormats.* import world.phantasmal.lib.fileFormats.*
import world.phantasmal.lib.fileFormats.ninja.* import world.phantasmal.lib.fileFormats.ninja.*
@ -11,6 +14,21 @@ import world.phantasmal.web.core.dot
import world.phantasmal.web.core.toQuaternion import world.phantasmal.web.core.toQuaternion
import world.phantasmal.web.externals.three.* import world.phantasmal.web.externals.three.*
import world.phantasmal.webui.obj import world.phantasmal.webui.obj
import kotlin.collections.List
import kotlin.collections.MutableList
import kotlin.collections.component1
import kotlin.collections.component2
import kotlin.collections.forEach
import kotlin.collections.forEachIndexed
import kotlin.collections.getOrPut
import kotlin.collections.indices
import kotlin.collections.iterator
import kotlin.collections.last
import kotlin.collections.map
import kotlin.collections.mutableListOf
import kotlin.collections.mutableMapOf
import kotlin.collections.sum
import kotlin.collections.withIndex
private val logger = KotlinLogging.logger {} private val logger = KotlinLogging.logger {}
@ -200,7 +218,7 @@ fun AreaObject.fingerPrint(): String =
append('_') append('_')
append(meshCount.toString(36)) append(meshCount.toString(36))
append('_') append('_')
append(radius.reinterpretAsUInt().toString(36)) append(radius.toRawBits().toUInt().toString(36))
} }
private fun areaObjectToMesh( private fun areaObjectToMesh(

12
web/src/test/kotlin/world/phantasmal/web/test/TestComponents.kt
View File

@ -68,7 +68,7 @@ class TestComponents(private val ctx: TestContext) {
// Rendering // Rendering
var createThreeRenderer: (HTMLCanvasElement) -> DisposableThreeRenderer by default { var createThreeRenderer: (HTMLCanvasElement) -> DisposableThreeRenderer by default {
{ _ -> {
object : DisposableThreeRenderer { object : DisposableThreeRenderer {
override val renderer = NopRenderer().unsafeCast<WebGLRenderer>() override val renderer = NopRenderer().unsafeCast<WebGLRenderer>()
override fun dispose() {} override fun dispose() {}
@ -76,15 +76,7 @@ class TestComponents(private val ctx: TestContext) {
} }
} }
private fun <T> default(defaultValue: () -> T) = LazyDefault { private fun <T> default(defaultValue: () -> T) = LazyDefault(defaultValue)
val value = defaultValue()
if (value is Disposable) {
ctx.disposer.add(value)
}
value
}
private inner class LazyDefault<T>(private val defaultValue: () -> T) { private inner class LazyDefault<T>(private val defaultValue: () -> T) {
private var initialized = false private var initialized = false