How to disassemble instruction that takes string literal as param

[hippietrail]

I'm working on just the disassembler for now for a bytecode from 1979 by Texas Instruments called "GPL".
It has an instruction called htex or htext that prints a string on the screen but its operand is a string literal. Here's an example from xdg99, which I'm using as the reference disassembler to compare my work against:

6138 call  >657f
613b st    @key, @>834c
613e st    >33, @>830d
6141 fmt
6142 row   >06
6144 col   >12
6146 htext 'GAME SPEED'

So it mostly looks like an assembly language. But I've never seen string literals as operands so I'm wondering if there's a way to achieve this in Sleigh? If not, what would be my next-best options?

The instruction format for htext is 000x xxxx which gives us a 5-bit number that we add one to to get the length of the string, and that number of ASCII bytes of the string follow immediately, before the next instruction.

Interpreting the bits I can figure out. I'm a bit fuzzy on how to deal with the variable length operand of up to 32 bytes. But I have no idea if or how I can actually make it render as an operand.
I suppose I can add 32 versions, one for each length. But aren't operands always expected to be numbers?

[hippietrail]

Interpreting the bits I can figure out. I'm a bit fuzzy on how to deal with the variable length operand of up to 32 bytes. But I have no idea if or how I can actually make it render as an operand. I suppose I can add 32 versions, one for each length. But aren't operands always expected to be numbers?

So far I managed to get it working as arrays of hex bytes using a line of Sleigh for each length. Not ideal but useful while I wait to see if there's a better way:

:HTEX p1s             is in_fmt>0 & op57=0x0 &op05=0x00 ;p1s { }
:HTEX [p1s, p2s]      is in_fmt>0 & op57=0x0 &op05=0x01 ;p1s ;p2s { }
:HTEX [p1s, p2s, p3s] is in_fmt>0 & op57=0x0 &op05=0x02 ;p1s ;p2s ;p3s { }

etc. example output:

61c9 0b 42 41 54 54 4c 45 47 52 4f     HTEX            [0x42,0x41,0x54,0x54,0x4c,0x45,0x47,0x
     55 4e 44
61d6 94                                COL+            >0x15
61d7 09 4d 49 4e 45 20 46 49 45 4c     HTEX            [0x4d,0x49,0x4e,0x45,0x20,0x46,0x49,0x
     44
61e2 95                                COL+            >0x16
61e3 08 4f 42 53 54 41 43 4c 45 53     HTEX            [0x4f,0x42,0x53,0x54,0x41,0x43,0x4c,0x
61ed fe 12                             ROW             0x12
61ef ff 0f                             COL             0xf
61f1 fb                                FEND

[Nemoumbra]

Related: #5070

[GhidorahRex]

Since it's fixed string ASCII, the best way may be to have a sub-constructor for the characters, along with context to track the length. Unfortunately, no matter what, it doesn't represent spaces very well.

define register offset=0x80 size=4 contextreg;
define context contextreg
    strlen= (0,3)
;

define token opcode (8)
    ophi = (5,7)
    sSz = (0,4)
;

define token immed (8)
    imm8 = (0,7)
;

char: "\n" is imm8=0xa {}
char: " " is imm8=0x20 {}
char: "!" is imm8=0x21 {}
char: "d" is imm8=0x64 {}
char: "e" is imm8=0x65 {}
char: "l" is imm8=0x6c {}
char: "o" is imm8=0x6f {}
char: "r" is imm8=0x72 {}
char: "H" is imm8=0x48 {}
char: "W" is imm8=0x57 {}


charList: char is char & strlen=1 [strlen=0;] {}
charList: char^charList is char; charList [strlen=strlen-1;]{
    build charList;
}

strBuilder: charList is sSz; charList [ strlen=sSz; ]{ }

define pcodeop write;
:HTEX [strBuilder] is ophi=0 ... & strBuilder {
    local strAddr:4 = inst_start + 1;
    write(*:1 strAddr);
}

possibly a simpler way is to handle this is:

strAddr:addr is sSz [addr=inst_start+1;] { local tmp:4 = addr; export tmp; }
:HTEX [strAddr] is ophi=0 & sSz & strAddr {
	local skip:4 = inst_start+sSz;
	write(*:1 strAddr, sSz:1);
	goto [skip];
}

Then you can define the data skipped over as a string and create a memory reference on the HTEX instruction to the data immediately following it. This could be handled in an analyzer. It doesn't look incredibly beautiful, but you can see the writes and it's very simple.

[hippietrail]

I haven't even started learning p-code yet. Is it needed for the disassembly to work? Will try this idea out hopefully tomorrow.

[GhidorahRex]

The pcodeop is just there to get something showing in the decompiler