diff --git a/lib/src/commonMain/kotlin/world/phantasmal/lib/asm/AsmTokenization.kt b/lib/src/commonMain/kotlin/world/phantasmal/lib/asm/AsmTokenization.kt index d6b877c1..d56d1a4f 100644 --- a/lib/src/commonMain/kotlin/world/phantasmal/lib/asm/AsmTokenization.kt +++ b/lib/src/commonMain/kotlin/world/phantasmal/lib/asm/AsmTokenization.kt @@ -296,6 +296,7 @@ private class LineTokenizer(private var line: String) { var prevWasBackSpace = false var terminated = false + loop@ // Use label as workaround for https://youtrack.jetbrains.com/issue/KT-43943. while (hasNext()) { when (peek()) { '\\' -> { @@ -304,7 +305,7 @@ private class LineTokenizer(private var line: String) { '"' -> { if (!prevWasBackSpace) { terminated = true - break + break@loop } prevWasBackSpace = false @@ -317,13 +318,14 @@ private class LineTokenizer(private var line: String) { next() } + val lenWithoutQuotes = markedLen() val value = slice().replace("\\\"", "\"").replace("\\n", "\n") return if (terminated) { next() - Token.Str(col, markedLen() + 2, value) + Token.Str(col, lenWithoutQuotes + 2, value) } else { - Token.UnterminatedString(col, markedLen() + 1, value) + Token.UnterminatedString(col, lenWithoutQuotes + 1, value) } } diff --git a/lib/src/commonMain/kotlin/world/phantasmal/lib/asm/Assembly.kt b/lib/src/commonMain/kotlin/world/phantasmal/lib/asm/Assembly.kt index 03297ea4..eccbf69d 100644 --- a/lib/src/commonMain/kotlin/world/phantasmal/lib/asm/Assembly.kt +++ b/lib/src/commonMain/kotlin/world/phantasmal/lib/asm/Assembly.kt @@ -121,7 +121,6 @@ private class Assembler(private val asm: List, private val inlineStackAr private fun addInstruction( opcode: Opcode, args: List, - stackArgs: List, token: Token?, argTokens: List, stackArgTokens: List, @@ -150,8 +149,8 @@ private class Assembler(private val asm: List, private val inlineStackAr args = argTokens.map { SrcLoc(lineNo, it.col, it.len) }, - stackArgs = stackArgTokens.mapIndexed { i, sat -> - StackArgSrcLoc(lineNo, sat.col, sat.len, stackArgs[i].value) + stackArgs = stackArgTokens.map { sat -> + SrcLoc(lineNo, sat.col, sat.len) }, ) ) @@ -386,7 +385,7 @@ private class Assembler(private val asm: List, private val inlineStackAr addError( identToken.col, errorLength, - "Expected at least $paramCount argument ${if (paramCount == 1) "" else "s"}, got $argCount.", + "Expected at least $paramCount argument${if (paramCount == 1) "" else "s"}, got $argCount.", ) return @@ -411,7 +410,6 @@ private class Assembler(private val asm: List, private val inlineStackAr addInstruction( OP_ARG_PUSHB, listOf(arg), - emptyList(), null, listOf(argToken), emptyList(), @@ -420,7 +418,6 @@ private class Assembler(private val asm: List, private val inlineStackAr addInstruction( OP_ARG_PUSHR, listOf(arg), - emptyList(), null, listOf(argToken), emptyList(), @@ -435,7 +432,6 @@ private class Assembler(private val asm: List, private val inlineStackAr addInstruction( OP_ARG_PUSHB, listOf(arg), - emptyList(), null, listOf(argToken), emptyList(), @@ -451,7 +447,6 @@ private class Assembler(private val asm: List, private val inlineStackAr addInstruction( OP_ARG_PUSHW, listOf(arg), - emptyList(), null, listOf(argToken), emptyList(), @@ -462,7 +457,6 @@ private class Assembler(private val asm: List, private val inlineStackAr addInstruction( OP_ARG_PUSHL, listOf(arg), - emptyList(), null, listOf(argToken), emptyList(), @@ -473,7 +467,6 @@ private class Assembler(private val asm: List, private val inlineStackAr addInstruction( OP_ARG_PUSHL, listOf(Arg((arg.value as Float).toRawBits())), - emptyList(), null, listOf(argToken), emptyList(), @@ -484,7 +477,6 @@ private class Assembler(private val asm: List, private val inlineStackAr addInstruction( OP_ARG_PUSHS, listOf(arg), - emptyList(), null, listOf(argToken), emptyList(), @@ -502,12 +494,11 @@ private class Assembler(private val asm: List, private val inlineStackAr } val (args, argTokens) = insArgAndTokens.unzip() - val (stackArgs, stackArgTokens) = stackArgAndTokens.unzip() + val stackArgTokens = stackArgAndTokens.map { it.second } addInstruction( opcode, args, - stackArgs, identToken, argTokens, stackArgTokens, diff --git a/lib/src/commonMain/kotlin/world/phantasmal/lib/asm/BytecodeIr.kt b/lib/src/commonMain/kotlin/world/phantasmal/lib/asm/BytecodeIr.kt index 8655fee3..52b2ff42 100644 --- a/lib/src/commonMain/kotlin/world/phantasmal/lib/asm/BytecodeIr.kt +++ b/lib/src/commonMain/kotlin/world/phantasmal/lib/asm/BytecodeIr.kt @@ -32,19 +32,19 @@ sealed class Segment( class InstructionSegment( labels: MutableList, val instructions: MutableList, - srcLoc: SegmentSrcLoc, + srcLoc: SegmentSrcLoc = SegmentSrcLoc(mutableListOf()), ) : Segment(SegmentType.Instructions, labels, srcLoc) class DataSegment( labels: MutableList, val data: Buffer, - srcLoc: SegmentSrcLoc, + srcLoc: SegmentSrcLoc = SegmentSrcLoc(mutableListOf()), ) : Segment(SegmentType.Data, labels, srcLoc) class StringSegment( labels: MutableList, var value: String, - srcLoc: SegmentSrcLoc, + srcLoc: SegmentSrcLoc = SegmentSrcLoc(mutableListOf()), ) : Segment(SegmentType.String, labels, srcLoc) /** @@ -55,8 +55,8 @@ class Instruction( /** * Immediate arguments for the opcode. */ - val args: List, - val srcLoc: InstructionSrcLoc?, + val args: List = emptyList(), + val srcLoc: InstructionSrcLoc? = null, ) { /** * Maps each parameter by index to its immediate arguments. @@ -114,7 +114,7 @@ class Instruction( /** * Returns the source locations of the stack arguments for the parameter at the given index. */ - fun getStackArgSrcLocs(paramIndex: Int): List { + fun getStackArgSrcLocs(paramIndex: Int): List { val argSrcLocs = srcLoc?.stackArgs if (argSrcLocs == null || paramIndex > argSrcLocs.lastIndex) { @@ -189,7 +189,7 @@ data class Arg(val value: Any) /** * Position and length of related source assembly code. */ -open class SrcLoc( +class SrcLoc( val lineNo: Int, val col: Int, val len: Int, @@ -200,15 +200,10 @@ open class SrcLoc( */ class InstructionSrcLoc( val mnemonic: SrcLoc?, - val args: List, - val stackArgs: List, + val args: List = emptyList(), + val stackArgs: List = emptyList(), ) -/** - * Locations of an instruction's stack arguments in the source assembly code. - */ -class StackArgSrcLoc(lineNo: Int, col: Int, len: Int, val value: Any) : SrcLoc(lineNo, col, len) - /** * Locations of a segment's labels in the source assembly code. */ diff --git a/lib/src/commonMain/kotlin/world/phantasmal/lib/asm/dataFlowAnalysis/ControlFlowGraph.kt b/lib/src/commonMain/kotlin/world/phantasmal/lib/asm/dataFlowAnalysis/ControlFlowGraph.kt index 583728a4..327b391e 100644 --- a/lib/src/commonMain/kotlin/world/phantasmal/lib/asm/dataFlowAnalysis/ControlFlowGraph.kt +++ b/lib/src/commonMain/kotlin/world/phantasmal/lib/asm/dataFlowAnalysis/ControlFlowGraph.kt @@ -89,6 +89,9 @@ class ControlFlowGraph( } companion object { + fun create(bytecodeIr: BytecodeIr): ControlFlowGraph = + create(bytecodeIr.instructionSegments()) + fun create(segments: List): ControlFlowGraph { val cfg = ControlFlowGraphBuilder() diff --git a/lib/src/commonMain/kotlin/world/phantasmal/lib/asm/dataFlowAnalysis/GetMapDesignations.kt b/lib/src/commonMain/kotlin/world/phantasmal/lib/asm/dataFlowAnalysis/GetMapDesignations.kt index 85661a7b..871e904b 100644 --- a/lib/src/commonMain/kotlin/world/phantasmal/lib/asm/dataFlowAnalysis/GetMapDesignations.kt +++ b/lib/src/commonMain/kotlin/world/phantasmal/lib/asm/dataFlowAnalysis/GetMapDesignations.kt @@ -9,8 +9,8 @@ import world.phantasmal.lib.asm.OP_MAP_DESIGNATE_EX private val logger = KotlinLogging.logger {} fun getMapDesignations( - instructionSegments: List, func0Segment: InstructionSegment, + createCfg: () -> ControlFlowGraph, ): Map { val mapDesignations = mutableMapOf() var cfg: ControlFlowGraph? = null @@ -21,7 +21,7 @@ fun getMapDesignations( OP_MAP_DESIGNATE_EX.code, -> { if (cfg == null) { - cfg = ControlFlowGraph.create(instructionSegments) + cfg = createCfg() } val areaId = getRegisterValue(cfg, inst, inst.args[0].value as Int) diff --git a/lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/Bytecode.kt b/lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/Bytecode.kt index 07655b0f..a5a0f884 100644 --- a/lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/Bytecode.kt +++ b/lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/Bytecode.kt @@ -393,13 +393,13 @@ private fun parseInstructionsSegment( // Parse the arguments. try { val args = parseInstructionArguments(cursor, opcode, dcGcFormat) - instructions.add(Instruction(opcode, args, null)) + instructions.add(Instruction(opcode, args)) } catch (e: Exception) { if (lenient) { logger.error(e) { "Exception occurred while parsing arguments for instruction ${opcode.mnemonic}." } - instructions.add(Instruction(opcode, emptyList(), null)) + instructions.add(Instruction(opcode, emptyList())) } else { throw e } diff --git a/lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/Quest.kt b/lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/Quest.kt index a4cf255a..9ffcd1ec 100644 --- a/lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/Quest.kt +++ b/lib/src/commonMain/kotlin/world/phantasmal/lib/fileFormats/quest/Quest.kt @@ -9,6 +9,7 @@ import world.phantasmal.lib.Episode import world.phantasmal.lib.asm.BytecodeIr import world.phantasmal.lib.asm.InstructionSegment import world.phantasmal.lib.asm.OP_SET_EPISODE +import world.phantasmal.lib.asm.dataFlowAnalysis.ControlFlowGraph import world.phantasmal.lib.asm.dataFlowAnalysis.getMapDesignations import world.phantasmal.lib.compression.prs.prsDecompress import world.phantasmal.lib.cursor.Cursor @@ -105,7 +106,8 @@ fun parseBinDatToQuest( npc.episode = episode } - mapDesignations = getMapDesignations(instructionSegments, label0Segment) + mapDesignations = + getMapDesignations(label0Segment) { ControlFlowGraph.create(bytecodeIr) } } else { result.addProblem(Severity.Warning, "No instruction segment for label 0 found.") } diff --git a/lib/src/commonTest/kotlin/world/phantasmal/lib/asm/AsmTokenizationTests.kt b/lib/src/commonTest/kotlin/world/phantasmal/lib/asm/AsmTokenizationTests.kt index 40f7a387..51f7a435 100644 --- a/lib/src/commonTest/kotlin/world/phantasmal/lib/asm/AsmTokenizationTests.kt +++ b/lib/src/commonTest/kotlin/world/phantasmal/lib/asm/AsmTokenizationTests.kt @@ -55,4 +55,31 @@ class AsmTokenizationTests : LibTestSuite() { assertEquals(4, tokens4[0].col) assertEquals(2, tokens4[0].len) } + + @Test + fun strings_are_parsed_as_Str_tokens() { + val tokens0 = tokenizeLine(""" "one line" """) + + assertEquals(1, tokens0.size) + assertEquals(Token.Str::class, tokens0[0]::class) + assertEquals("one line", (tokens0[0] as Token.Str).value) + assertEquals(2, tokens0[0].col) + assertEquals(10, tokens0[0].len) + + val tokens1 = tokenizeLine(""" "two\nlines" """) + + assertEquals(1, tokens1.size) + assertEquals(Token.Str::class, tokens1[0]::class) + assertEquals("two\nlines", (tokens1[0] as Token.Str).value) + assertEquals(2, tokens1[0].col) + assertEquals(12, tokens1[0].len) + + val tokens2 = tokenizeLine(""" "is \"this\" escaped?" """) + + assertEquals(1, tokens2.size) + assertEquals(Token.Str::class, tokens2[0]::class) + assertEquals("is \"this\" escaped?", (tokens2[0] as Token.Str).value) + assertEquals(2, tokens2[0].col) + assertEquals(22, tokens2[0].len) + } } diff --git a/lib/src/commonTest/kotlin/world/phantasmal/lib/asm/AssemblyTests.kt b/lib/src/commonTest/kotlin/world/phantasmal/lib/asm/AssemblyTests.kt index 1401ac4d..b6e32dda 100644 --- a/lib/src/commonTest/kotlin/world/phantasmal/lib/asm/AssemblyTests.kt +++ b/lib/src/commonTest/kotlin/world/phantasmal/lib/asm/AssemblyTests.kt @@ -2,35 +2,252 @@ package world.phantasmal.lib.asm import world.phantasmal.core.Success import world.phantasmal.lib.test.LibTestSuite +import world.phantasmal.lib.test.assertDeepEquals import kotlin.test.Test -import kotlin.test.assertEquals import kotlin.test.assertTrue class AssemblyTests : LibTestSuite() { @Test - fun assemble_basic_script() { + fun basic_script() { val result = assemble(""" 0: set_episode 0 + bb_map_designate 1, 2, 3, 4 set_floor_handler 0, 150 - set_floor_handler 1, 151 - set_qt_success 250 - bb_map_designate 0, 0, 0, 0 - bb_map_designate 1, 1, 0, 0 ret - 1: - ret - 250: - gset 101 - window_msg "You've been awarded 500 Meseta." - bgm 1 - winend - pl_add_meseta 0, 500 + 150: + set_mainwarp 1 ret """.trimIndent().split('\n')) assertTrue(result is Success) assertTrue(result.problems.isEmpty()) - assertEquals(3, result.value.segments.size) + + assertDeepEquals(BytecodeIr(listOf( + InstructionSegment( + labels = mutableListOf(0), + instructions = mutableListOf( + Instruction( + opcode = OP_SET_EPISODE, + args = listOf(Arg(0)), + srcLoc = InstructionSrcLoc( + mnemonic = SrcLoc(2, 5, 11), + args = listOf(SrcLoc(2, 17, 1)), + stackArgs = emptyList(), + ), + ), + Instruction( + opcode = OP_BB_MAP_DESIGNATE, + args = listOf(Arg(1), Arg(2), Arg(3), Arg(4)), + srcLoc = InstructionSrcLoc( + mnemonic = SrcLoc(3, 5, 16), + args = listOf( + SrcLoc(3, 22, 1), + SrcLoc(3, 25, 1), + SrcLoc(3, 28, 1), + SrcLoc(3, 31, 1), + ), + stackArgs = emptyList(), + ), + ), + Instruction( + opcode = OP_ARG_PUSHL, + args = listOf(Arg(0)), + srcLoc = InstructionSrcLoc( + mnemonic = null, + args = listOf(SrcLoc(4, 23, 1)), + stackArgs = emptyList(), + ), + ), + Instruction( + opcode = OP_ARG_PUSHW, + args = listOf(Arg(150)), + srcLoc = InstructionSrcLoc( + mnemonic = null, + args = listOf(SrcLoc(4, 26, 3)), + stackArgs = emptyList(), + ), + ), + Instruction( + opcode = OP_SET_FLOOR_HANDLER, + args = emptyList(), + srcLoc = InstructionSrcLoc( + mnemonic = SrcLoc(4, 5, 17), + args = emptyList(), + stackArgs = listOf( + SrcLoc(4, 23, 1), + SrcLoc(4, 26, 3), + ), + ), + ), + Instruction( + opcode = OP_RET, + args = emptyList(), + srcLoc = InstructionSrcLoc( + mnemonic = SrcLoc(5, 5, 3), + args = emptyList(), + stackArgs = emptyList(), + ), + ), + ), + srcLoc = SegmentSrcLoc(labels = mutableListOf(SrcLoc(1, 1, 2))), + ), + InstructionSegment( + labels = mutableListOf(150), + instructions = mutableListOf( + Instruction( + opcode = OP_ARG_PUSHL, + args = listOf(Arg(1)), + srcLoc = InstructionSrcLoc( + mnemonic = null, + args = listOf(SrcLoc(7, 18, 1)), + stackArgs = emptyList(), + ), + ), + Instruction( + opcode = OP_SET_MAINWARP, + args = emptyList(), + srcLoc = InstructionSrcLoc( + mnemonic = SrcLoc(7, 5, 12), + args = emptyList(), + stackArgs = listOf(SrcLoc(7, 18, 1)), + ), + ), + Instruction( + opcode = OP_RET, + args = emptyList(), + srcLoc = InstructionSrcLoc( + mnemonic = SrcLoc(8, 5, 3), + args = emptyList(), + stackArgs = emptyList(), + ), + ), + ), + srcLoc = SegmentSrcLoc(labels = mutableListOf(SrcLoc(6, 1, 4))), + ) + )), result.value) + } + + @Test + fun pass_register_value_via_stack_with_inline_args() { + val result = assemble(""" + 0: + leti r255, 7 + exit r255 + ret + """.trimIndent().split('\n')) + + assertTrue(result is Success) + assertTrue(result.problems.isEmpty()) + + assertDeepEquals(BytecodeIr( + listOf( + InstructionSegment( + labels = mutableListOf(0), + instructions = mutableListOf( + Instruction( + opcode = OP_LETI, + args = listOf(Arg(255), Arg(7)), + srcLoc = InstructionSrcLoc( + mnemonic = SrcLoc(2, 5, 4), + args = listOf(SrcLoc(2, 10, 4), SrcLoc(2, 16, 1)), + stackArgs = emptyList(), + ), + ), + Instruction( + opcode = OP_ARG_PUSHR, + args = listOf(Arg(255)), + srcLoc = InstructionSrcLoc( + mnemonic = null, + args = listOf(SrcLoc(3, 10, 4)), + stackArgs = emptyList(), + ), + ), + Instruction( + opcode = OP_EXIT, + args = emptyList(), + srcLoc = InstructionSrcLoc( + mnemonic = SrcLoc(3, 5, 4), + args = emptyList(), + stackArgs = listOf(SrcLoc(3, 10, 4)), + ), + ), + Instruction( + opcode = OP_RET, + args = emptyList(), + srcLoc = InstructionSrcLoc( + mnemonic = SrcLoc(4, 5, 3), + args = emptyList(), + stackArgs = emptyList(), + ), + ), + ), + srcLoc = SegmentSrcLoc( + labels = mutableListOf(SrcLoc(1, 1, 2)) + ), + ) + ) + ), result.value) + } + + @Test + fun pass_register_reference_via_stack_with_inline_args() { + val result = assemble(""" + 0: + p_dead_v3 r200, 3 + ret + """.trimIndent().split('\n')) + + assertTrue(result is Success) + assertTrue(result.problems.isEmpty()) + + assertDeepEquals(BytecodeIr( + listOf( + InstructionSegment( + labels = mutableListOf(0), + instructions = mutableListOf( + Instruction( + opcode = OP_ARG_PUSHB, + args = listOf(Arg(200)), + srcLoc = InstructionSrcLoc( + mnemonic = null, + args = listOf(SrcLoc(2, 15, 4)), + stackArgs = emptyList(), + ), + ), + Instruction( + opcode = OP_ARG_PUSHL, + args = listOf(Arg(3)), + srcLoc = InstructionSrcLoc( + mnemonic = null, + args = listOf(SrcLoc(2, 21, 1)), + stackArgs = emptyList(), + ), + ), + Instruction( + opcode = OP_P_DEAD_V3, + args = emptyList(), + srcLoc = InstructionSrcLoc( + mnemonic = SrcLoc(2, 5, 9), + args = emptyList(), + stackArgs = listOf(SrcLoc(2, 15, 4), SrcLoc(2, 21, 1)), + ), + ), + Instruction( + opcode = OP_RET, + args = emptyList(), + srcLoc = InstructionSrcLoc( + mnemonic = SrcLoc(3, 5, 3), + args = emptyList(), + stackArgs = emptyList(), + ), + ), + ), + srcLoc = SegmentSrcLoc( + labels = mutableListOf(SrcLoc(1, 1, 2)) + ), + ) + ) + ), result.value) } } diff --git a/lib/src/commonTest/kotlin/world/phantasmal/lib/asm/DisassemblyAssemblyRoundTripTests.kt b/lib/src/commonTest/kotlin/world/phantasmal/lib/asm/DisassemblyAssemblyRoundTripTests.kt new file mode 100644 index 00000000..a172dcf6 --- /dev/null +++ b/lib/src/commonTest/kotlin/world/phantasmal/lib/asm/DisassemblyAssemblyRoundTripTests.kt @@ -0,0 +1,72 @@ +package world.phantasmal.lib.asm + +import world.phantasmal.core.Success +import world.phantasmal.lib.fileFormats.quest.parseBin +import world.phantasmal.lib.fileFormats.quest.parseBytecode +import world.phantasmal.lib.test.LibTestSuite +import world.phantasmal.lib.test.assertDeepEquals +import world.phantasmal.lib.test.readFile +import kotlin.test.Test +import kotlin.test.assertEquals +import kotlin.test.assertTrue + +class DisassemblyAssemblyRoundTripTests : LibTestSuite() { + @Test + fun assembling_disassembled_bytecode_should_result_in_the_same_IR() = asyncTest { + assembling_disassembled_bytecode_should_result_in_the_same_IR(inlineStackArgs = false) + } + + @Test + fun assembling_disassembled_bytecode_should_result_in_the_same_IR_inline_args() = asyncTest { + assembling_disassembled_bytecode_should_result_in_the_same_IR(inlineStackArgs = true) + } + + private suspend fun assembling_disassembled_bytecode_should_result_in_the_same_IR( + inlineStackArgs: Boolean, + ) { + val bin = parseBin(readFile("/quest27_e_decompressed.bin")) + val expectedIr = parseBytecode( + bin.bytecode, + bin.labelOffsets, + setOf(0), + dcGcFormat = false, + lenient = false, + ).unwrap() + + val assemblyResult = + assemble(disassemble(expectedIr, inlineStackArgs), inlineStackArgs) + + assertTrue(assemblyResult.problems.isEmpty()) + assertTrue(assemblyResult is Success) + assertDeepEquals(expectedIr, assemblyResult.value, ignoreSrcLocs = true) + } + + @Test + fun disassembling_assembled_bytecode_should_result_in_the_same_ASM() = asyncTest { + disassembling_assembled_bytecode_should_result_in_the_same_ASM(inlineStackArgs = false) + } + + @Test + fun disassembling_assembled_bytecode_should_result_in_the_same_ASM_inline_args() = asyncTest { + disassembling_assembled_bytecode_should_result_in_the_same_ASM(inlineStackArgs = true) + } + + private suspend fun disassembling_assembled_bytecode_should_result_in_the_same_ASM( + inlineStackArgs: Boolean, + ) { + val bin = parseBin(readFile("/quest27_e_decompressed.bin")) + val ir = parseBytecode( + bin.bytecode, + bin.labelOffsets, + setOf(0), + dcGcFormat = false, + lenient = false, + ).unwrap() + + val expectedAsm = disassemble(ir, inlineStackArgs) + val actualAsm = + disassemble(assemble(expectedAsm, inlineStackArgs).unwrap(), inlineStackArgs) + + assertDeepEquals(expectedAsm, actualAsm, ::assertEquals) + } +} diff --git a/lib/src/commonTest/kotlin/world/phantasmal/lib/asm/DisassemblyTests.kt b/lib/src/commonTest/kotlin/world/phantasmal/lib/asm/DisassemblyTests.kt new file mode 100644 index 00000000..4289480c --- /dev/null +++ b/lib/src/commonTest/kotlin/world/phantasmal/lib/asm/DisassemblyTests.kt @@ -0,0 +1,108 @@ +package world.phantasmal.lib.asm + +import world.phantasmal.lib.test.LibTestSuite +import kotlin.test.Test +import kotlin.test.assertEquals + +class DisassemblyTests : LibTestSuite() { + @Test + fun vararg_instructions() { + val ir = BytecodeIr(listOf( + InstructionSegment( + labels = mutableListOf(0), + instructions = mutableListOf( + Instruction( + opcode = OP_SWITCH_JMP, + args = listOf( + Arg(90), + Arg(100), + Arg(101), + Arg(102), + ), + ), + Instruction( + opcode = OP_RET, + args = emptyList() + ), + ), + ) + )) + + val asm = """ + |.code + | + |0: + | switch_jmp r90, 100, 101, 102 + | ret + | + """.trimMargin() + + testWithAllOptions(ir, asm, asm) + } + + // arg_push* instructions should always be output when in a va list whether inline stack + // arguments is on or off. + @Test + fun va_list_instructions() { + val ir = BytecodeIr(listOf( + InstructionSegment( + labels = mutableListOf(0), + instructions = mutableListOf( + Instruction( + opcode = OP_VA_START, + ), + Instruction( + opcode = OP_ARG_PUSHW, + args = listOf(Arg(1337)), + ), + Instruction( + opcode = OP_VA_CALL, + args = listOf(Arg(100)), + ), + Instruction( + opcode = OP_VA_END, + ), + Instruction( + opcode = OP_RET, + ), + ), + ) + )) + + val asm = """ + |.code + | + |0: + | va_start + | arg_pushw 1337 + | va_call 100 + | va_end + | ret + | + """.trimMargin() + + testWithAllOptions(ir, asm, asm) + } + + private fun testWithAllOptions( + ir: BytecodeIr, + expectedInlineAsm: String, + expectedManualAsm: String, + ) { + val asmInline = disassemble(ir, inlineStackArgs = true) + + assertEquals( + expectedInlineAsm.split('\n'), + asmInline, + "With inlineStackArgs", + ) + + val asmManual = disassemble(ir, inlineStackArgs = false) + + assertEquals( + expectedManualAsm.split('\n'), + asmManual, + "Without inlineStackArgs", + ) + } +} diff --git a/lib/src/commonTest/kotlin/world/phantasmal/lib/test/BytecodeIrAssertions.kt b/lib/src/commonTest/kotlin/world/phantasmal/lib/test/BytecodeIrAssertions.kt new file mode 100644 index 00000000..15de707d --- /dev/null +++ b/lib/src/commonTest/kotlin/world/phantasmal/lib/test/BytecodeIrAssertions.kt @@ -0,0 +1,81 @@ +package world.phantasmal.lib.test + +import world.phantasmal.lib.asm.* +import kotlin.test.assertEquals +import kotlin.test.assertNotNull +import kotlin.test.assertNull + +fun assertDeepEquals(expected: BytecodeIr, actual: BytecodeIr, ignoreSrcLocs: Boolean = false) { + assertDeepEquals(expected.segments, + actual.segments + ) { a, b -> assertDeepEquals(a, b, ignoreSrcLocs) } +} + +fun assertDeepEquals(expected: Segment, actual: Segment, ignoreSrcLocs: Boolean = false) { + assertEquals(expected::class, actual::class) + assertDeepEquals(expected.labels, actual.labels, ::assertEquals) + + if (!ignoreSrcLocs) { + assertDeepEquals(expected.srcLoc, actual.srcLoc) + } + + when (expected) { + is InstructionSegment -> { + actual as InstructionSegment + assertDeepEquals(expected.instructions, actual.instructions) { a, b -> + assertDeepEquals(a, b, ignoreSrcLocs) + } + } + is DataSegment -> { + actual as DataSegment + assertDeepEquals(expected.data, actual.data) + } + is StringSegment -> { + actual as StringSegment + assertEquals(expected.value, actual.value) + } + } +} + +fun assertDeepEquals(expected: Instruction, actual: Instruction, ignoreSrcLocs: Boolean = false) { + assertEquals(expected.opcode, actual.opcode) + assertDeepEquals(expected.args, actual.args, ::assertEquals) + + if (!ignoreSrcLocs) { + assertDeepEquals(expected.srcLoc, actual.srcLoc) + } +} + +fun assertDeepEquals(expected: SrcLoc?, actual: SrcLoc?) { + if (expected == null) { + assertNull(actual) + return + } + + assertNotNull(actual) + assertEquals(expected.lineNo, actual.lineNo) + assertEquals(expected.col, actual.col) + assertEquals(expected.len, actual.len) +} + +fun assertDeepEquals(expected: InstructionSrcLoc?, actual: InstructionSrcLoc?) { + if (expected == null) { + assertNull(actual) + return + } + + assertNotNull(actual) + assertDeepEquals(expected.mnemonic, actual.mnemonic) + assertDeepEquals(expected.args, actual.args, ::assertDeepEquals) + assertDeepEquals(expected.stackArgs, actual.stackArgs, ::assertDeepEquals) +} + +fun assertDeepEquals(expected: SegmentSrcLoc?, actual: SegmentSrcLoc?) { + if (expected == null) { + assertNull(actual) + return + } + + assertNotNull(actual) + assertDeepEquals(expected.labels, actual.labels, ::assertDeepEquals) +} diff --git a/lib/src/commonTest/kotlin/world/phantasmal/lib/test/TestUtils.kt b/lib/src/commonTest/kotlin/world/phantasmal/lib/test/TestUtils.kt index 91835e45..5bf99985 100644 --- a/lib/src/commonTest/kotlin/world/phantasmal/lib/test/TestUtils.kt +++ b/lib/src/commonTest/kotlin/world/phantasmal/lib/test/TestUtils.kt @@ -3,7 +3,9 @@ package world.phantasmal.lib.test import world.phantasmal.core.Success import world.phantasmal.lib.asm.InstructionSegment import world.phantasmal.lib.asm.assemble +import world.phantasmal.lib.buffer.Buffer import world.phantasmal.lib.cursor.Cursor +import kotlin.test.assertEquals import kotlin.test.assertTrue expect suspend fun readFile(path: String): Cursor @@ -16,3 +18,21 @@ fun toInstructions(assembly: String): List { return result.value.instructionSegments() } + +fun assertDeepEquals(expected: List, actual: List, assertDeepEquals: (T, T) -> Unit) { + assertEquals(expected.size, actual.size) + + for (i in actual.indices) { + assertDeepEquals(expected[i], actual[i]) + } +} + +fun assertDeepEquals(expected: Buffer, actual: Buffer): Boolean { + if (expected.size != actual.size) return false + + for (i in 0 until expected.size) { + if (expected.getByte(i) != actual.getByte(i)) return false + } + + return true +} diff --git a/lib/src/commonTest/resources/quest27_e.bin b/lib/src/commonTest/resources/quest27_e.bin new file mode 100644 index 00000000..2d72d20a Binary files /dev/null and b/lib/src/commonTest/resources/quest27_e.bin differ diff --git a/lib/src/commonTest/resources/quest27_e_decompressed.bin b/lib/src/commonTest/resources/quest27_e_decompressed.bin new file mode 100644 index 00000000..1aa95623 Binary files /dev/null and b/lib/src/commonTest/resources/quest27_e_decompressed.bin differ diff --git a/observable/src/commonMain/kotlin/world/phantasmal/observable/value/ValExtensions.kt b/observable/src/commonMain/kotlin/world/phantasmal/observable/value/ValExtensions.kt index 95756781..f75675ba 100644 --- a/observable/src/commonMain/kotlin/world/phantasmal/observable/value/ValExtensions.kt +++ b/observable/src/commonMain/kotlin/world/phantasmal/observable/value/ValExtensions.kt @@ -33,8 +33,8 @@ infix fun Val.and(other: Val): Val = infix fun Val.or(other: Val): Val = map(this, other) { a, b -> a || b } -// Use != because of https://youtrack.jetbrains.com/issue/KT-31277. infix fun Val.xor(other: Val): Val = + // Use != because of https://youtrack.jetbrains.com/issue/KT-31277. map(this, other) { a, b -> a != b } operator fun Val.not(): Val = map { !it } @@ -42,6 +42,9 @@ operator fun Val.not(): Val = map { !it } operator fun Val.plus(other: Int): Val = map { it + other } +operator fun Val.minus(other: Int): Val = + map { it - other } + fun Val.isEmpty(): Val = map { it.isEmpty() } diff --git a/web/assembly-worker/src/main/kotlin/world/phantasmal/web/assemblyWorker/AssemblyWorker.kt b/web/assembly-worker/src/main/kotlin/world/phantasmal/web/assemblyWorker/AssemblyWorker.kt index 0afe35b8..0d02afcc 100644 --- a/web/assembly-worker/src/main/kotlin/world/phantasmal/web/assemblyWorker/AssemblyWorker.kt +++ b/web/assembly-worker/src/main/kotlin/world/phantasmal/web/assemblyWorker/AssemblyWorker.kt @@ -2,16 +2,31 @@ package world.phantasmal.web.assemblyWorker import world.phantasmal.core.* import world.phantasmal.lib.asm.* +import world.phantasmal.lib.asm.dataFlowAnalysis.ControlFlowGraph import world.phantasmal.lib.asm.dataFlowAnalysis.getMapDesignations +import world.phantasmal.lib.asm.dataFlowAnalysis.getStackValue import world.phantasmal.web.shared.* import world.phantasmal.web.shared.AssemblyProblem import kotlin.math.min import world.phantasmal.lib.asm.AssemblyProblem as AssemblerAssemblyProblem class AssemblyWorker(private val sendMessage: (ServerMessage) -> Unit) { + // User input. private var inlineStackArgs: Boolean = true private val asm: JsArray = jsArrayOf() + + // Output. private var bytecodeIr = BytecodeIr(emptyList()) + private var problems: List? = null + + // Derived data. + private var _cfg: ControlFlowGraph? = null + private val cfg: ControlFlowGraph + get() { + if (_cfg == null) _cfg = ControlFlowGraph.create(bytecodeIr) + return _cfg!! + } + private var mapDesignations: Map? = null fun receiveMessage(message: ClientMessage) = @@ -137,6 +152,8 @@ class AssemblyWorker(private val sendMessage: (ServerMessage) -> Unit) { } private fun processAsm() { + _cfg = null + val assemblyResult = assemble(asm.asArray().toList(), inlineStackArgs) @Suppress("UNCHECKED_CAST") @@ -144,7 +161,10 @@ class AssemblyWorker(private val sendMessage: (ServerMessage) -> Unit) { AssemblyProblem(it.severity, it.uiMessage) } - sendMessage(ServerNotification.Problems(problems)) + if (problems != this.problems) { + this.problems = problems + sendMessage(ServerNotification.Problems(problems)) + } if (assemblyResult is Success) { bytecodeIr = assemblyResult.value @@ -152,9 +172,9 @@ class AssemblyWorker(private val sendMessage: (ServerMessage) -> Unit) { val instructionSegments = bytecodeIr.instructionSegments() instructionSegments.find { 0 in it.labels }?.let { label0Segment -> - val designations = getMapDesignations(instructionSegments, label0Segment) + val designations = getMapDesignations(label0Segment) { cfg } - if (mapDesignations != designations) { + if (designations != mapDesignations) { mapDesignations = designations sendMessage(ServerNotification.MapDesignations( designations @@ -349,10 +369,14 @@ class AssemblyWorker(private val sendMessage: (ServerMessage) -> Unit) { // Stack arguments. val argSrcLocs = inst.getStackArgSrcLocs(paramIdx) - for (argSrcLoc in argSrcLocs) { + for ((i, argSrcLoc) in argSrcLocs.withIndex()) { if (positionInside(lineNo, col, argSrcLoc)) { - val label = argSrcLoc.value as Int - result = getLabelDefinitions(label) + val labelValues = getStackValue(cfg, inst, argSrcLocs.lastIndex - i) + + if (labelValues.size <= 5) { + result = labelValues.flatMap(::getLabelDefinitions) + } + break@loop } } diff --git a/web/build.gradle.kts b/web/build.gradle.kts index a9d3092e..9981f852 100644 --- a/web/build.gradle.kts +++ b/web/build.gradle.kts @@ -53,10 +53,12 @@ dependencies { testImplementation(project(":test-utils")) } -// TODO: Figure out how to trigger this task automatically. -tasks.register("copyAssemblyWorkerJs") { +val copyAssemblyWorkerJsTask = tasks.register("copyAssemblyWorkerJs") { val workerDist = project(":web:assembly-worker").buildDir.resolve("distributions") from(workerDist.resolve("assembly-worker.js"), workerDist.resolve("assembly-worker.js.map")) into(buildDir.resolve("processedResources/js/main")) dependsOn(":web:assembly-worker:build") } + +// TODO: Figure out how to make this work with --continuous. +tasks.getByName("processResources").dependsOn(copyAssemblyWorkerJsTask)