Decompiler handling of variables made of two registers?

[hwrobel]

If a variable is exceeding the CPU's register size and is therefore handled by using two registers, does the decompiler have support for this?

For example, you have registers A:1,B:1 on an 8b CPU holding a 16b value, would the decompiler be able to translate common
sequences for lo/hi parts like this from multiple register handling use into common C use:

• LSR/ROR ==> ">>"
• ASL/ROL ==> "<<"
• ADD/ADDC ==> "+"
• SUB/SUBC ==> "-"

If the decompiler can do that, is any special help needed in the Sleigh spec to help the decompiler see such patterns?
I would like to avoid the numerous "CONCAT11", ".0_1" , and ".1_1" references that I get.

My question is in a way generic though, i.e., if you, e.g., had a 64b value on a 32b CPU in two registers R4/R5, the question would remain the same.

[astrelsky]

If a variable is exceeding the CPU's register size and is therefore handled by using two registers, does the decompiler have support for this?

Yes

If the decompiler can do that, is any special help needed in the Sleigh spec to help the decompiler see such patterns?

Also yes, kind of. If the registers overlap and you have instructions that operate on them as such, create larger pseudo registers that overlap the smaller ones.

ghidra/Ghidra/Processors/MIPS/data/languages/mips.sinc

Lines 182 to 223 in 58e19e9

	# General purpose registers
	define register offset=0 size=$(REGSIZE) [
	zero at v0 v1
	a0 a1 a2 a3
	t0 t1 t2 t3
	t4 t5 t6 t7
	s0 s1 s2 s3
	s4 s5 s6 s7
	t8 t9 k0 k1
	gp sp s8 ra
	pc
	];
	@ifdef MIPS64
	# We need the 32-bit pieces of the main registers for the 32-bit instructions
	@if ENDIAN == "big"
	define register offset=0 size=4 [
	zero_hi zero_lo at_hi at_lo v0_hi v0_lo v1_hi v1_lo
	a0_hi a0_lo a1_hi a1_lo a2_hi a2_lo a3_hi a3_lo
	t0_hi t0_lo t1_hi t1_lo t2_hi t2_lo t3_hi t3_lo
	t4_hi t4_lo t5_hi t5_lo t6_hi t6_lo t7_hi t7_lo
	s0_hi s0_lo s1_hi s1_lo s2_hi s2_lo s3_hi s3_lo
	s4_hi s4_lo s5_hi s5_lo s6_hi s6_lo s7_hi s7_lo
	t8_hi t8_lo t9_hi t9_lo k0_hi k0_lo k1_hi k1_lo
	gp_hi gp_lo sp_hi sp_lo s8_hi s8_lo ra_hi ra_lo
	pc_hi pc_lo
	];
	@else
	define register offset=0 size=4 [
	zero_lo zero_hi at_lo at_hi v0_lo v0_hi v1_lo v1_hi
	a0_lo a0_hi a1_lo a1_hi a2_lo a2_hi a3_lo a3_hi
	t0_lo t0_hi t1_lo t1_hi t2_lo t2_hi t3_lo t3_hi
	t4_lo t4_hi t5_lo t5_hi t6_lo t6_hi t7_lo t7_hi
	s0_lo s0_hi s1_lo s1_hi s2_lo s2_hi s3_lo s3_hi
	s4_lo s4_hi s5_lo s5_hi s6_lo s6_hi s7_lo s7_hi
	t8_lo t8_hi t9_lo t9_hi k0_lo k0_hi k1_lo k1_hi
	gp_lo gp_hi sp_lo sp_hi s8_lo s8_hi ra_lo ra_hi
	pc_lo pc_hi
	];
	@endif # ENDIAN
	@endif # MIPS64

[hwrobel]

Hmm. Thanks for the hint about overlapping registers, but I can't get it to work.

This piece of code of four instructions shifting a 16b value twice to the right:

                             **************************************************************
                             *                          FUNCTION                          *
                             **************************************************************
                             word registercall Div_AB_by_4(word dividend)
             word              AB:2           <RETURN>
             word              AB:2           dividend
                             Div_AB_by_4                                     XREF[8]: 
            801a 44              LSR        A
                                                      $U5d80:1 = COPY A
                                                      $U5e00:1 = INT_AND $U5d80:1, 1:1
                                                      C = INT_NOTEQUAL $U5e00:1, 0:1
                                                      $U5d80:1 = INT_RIGHT $U5d80:1, 1:4
                                                      A = COPY $U5d80:1
                                                      Z = INT_EQUAL $U5d80:1, 0:1
                                                      N = INT_SLESS $U5d80:1, 0:1
                                                      V = BOOL_XOR N, C
            801b 56              ROR        B
                                                      $U6880:1 = INT_LEFT C, 7:4
                                                      $U6900:1 = COPY B
                                                      $U6980:1 = INT_AND $U6900:1, 1:1
                                                      C = INT_NOTEQUAL $U6980:1, 0:1
                                                      $U6900:1 = INT_RIGHT $U6900:1, 1:4
                                                      $U6900:1 = INT_OR $U6900:1, $U6880:1
                                                      B = COPY $U6900:1
                                                      Z = INT_EQUAL $U6900:1, 0:1
                                                      N = INT_SLESS $U6900:1, 0:1
                                                      V = BOOL_XOR N, C
            801c 44              LSR        A
                                                      $U5d80:1 = COPY A
                                                      $U5e00:1 = INT_AND $U5d80:1, 1:1
                                                      C = INT_NOTEQUAL $U5e00:1, 0:1
                                                      $U5d80:1 = INT_RIGHT $U5d80:1, 1:4
                                                      A = COPY $U5d80:1
                                                      Z = INT_EQUAL $U5d80:1, 0:1
                                                      N = INT_SLESS $U5d80:1, 0:1
                                                      V = BOOL_XOR N, C
            801d 56              ROR        B
                                                      $U6880:1 = INT_LEFT C, 7:4
                                                      $U6900:1 = COPY B
                                                      $U6980:1 = INT_AND $U6900:1, 1:1
                                                      C = INT_NOTEQUAL $U6980:1, 0:1
                                                      $U6900:1 = INT_RIGHT $U6900:1, 1:4
                                                      $U6900:1 = INT_OR $U6900:1, $U6880:1
                                                      B = COPY $U6900:1
                                                      Z = INT_EQUAL $U6900:1, 0:1
                                                      N = INT_SLESS $U6900:1, 0:1
                                                      V = BOOL_XOR N, C
            801e 39              RTS
                                                      SP = INT_ADD SP, 1:2
                                                      $U7380:2 = LOAD RAM(SP)
                                                      SP = INT_ADD SP, 1:2
                                                      RETURN $U7380:2

results in:

word Div_AB_by_4(word dividend)

{
  byte bVar1;
  
  bVar1 = (byte)(dividend >> 8);
  return CONCAT11(bVar1 >> 2,
                  (byte)((byte)dividend >> 1 | ((dividend & 0x100) != 0) << 7) >> 1 |
                  ((bVar1 >> 1 & 1) != 0) << 7);
}

Somehow the carry handling is done in a very, very literal way, rather than collapsing to something like "return (word >> 2)" in this case

The .slaspec is homegrown for an 8b 6802 with concepts liberated from the included 6502.

[hwrobel]

I got it to work partially. This is a fascinating topic, as the P-Code has to be "just right" apparently. Is there a way to look at the recognized pattern to adjust the .slaspec accordingly?

The rotate right carry must not be calculated with INT_NOTEQUAL. It must be a direct calculation of & only and the decompiler pattern then works for the code I am looking at which has up to 6 LSR/ROR combinations as fall through functions.

For shift left, the decompiler seems a bit more sensitive. Doing "C = tmp >> 7" to avoid any INT_NOTEQUAL magic works for up to two ASL/ROL combinations. But for four of them in a row I am back to the weirdness.

                             **************************************************************
                             *                          FUNCTION                          *
                             **************************************************************
                             word registercall Mul_AB_16(word param_1)
             word              AB:2           <RETURN>
             word              AB:2           param_1
                             Mul_AB_16                                       XREF[3]: 
            801f 58              ASL        B
                                                      $U3380:1 = COPY B
                                                      C = INT_RIGHT $U3380:1, 7:4
                                                      $U3380:1 = INT_LEFT $U3380:1, 1:4
                                                      B = COPY $U3380:1
                                                      Z = INT_EQUAL $U3380:1, 0:1
                                                      N = INT_SLESS $U3380:1, 0:1
                                                      V = BOOL_XOR N, C
            8020 49              ROL        A
                                                      $U6280:1 = COPY C
                                                      $U6300:1 = COPY A
                                                      C = INT_RIGHT $U6300:1, 7:4
                                                      $U6480:1 = INT_LEFT $U6300:1, 1:4
                                                      $U6480:1 = INT_OR $U6480:1, $U6280:1
                                                      A = COPY $U6480:1
                                                      Z = INT_EQUAL $U6480:1, 0:1
                                                      N = INT_SLESS $U6480:1, 0:1
                                                      V = BOOL_XOR N, C
            8021 58              ASL        B
                                                      $U3380:1 = COPY B
                                                      C = INT_RIGHT $U3380:1, 7:4
                                                      $U3380:1 = INT_LEFT $U3380:1, 1:4
                                                      B = COPY $U3380:1
                                                      Z = INT_EQUAL $U3380:1, 0:1
                                                      N = INT_SLESS $U3380:1, 0:1
                                                      V = BOOL_XOR N, C
            8022 49              ROL        A
                                                      $U6280:1 = COPY C
                                                      $U6300:1 = COPY A
                                                      C = INT_RIGHT $U6300:1, 7:4
                                                      $U6480:1 = INT_LEFT $U6300:1, 1:4
                                                      $U6480:1 = INT_OR $U6480:1, $U6280:1
                                                      A = COPY $U6480:1
                                                      Z = INT_EQUAL $U6480:1, 0:1
                                                      N = INT_SLESS $U6480:1, 0:1
                                                      V = BOOL_XOR N, C
                             **************************************************************
                             *                          FUNCTION                          *
                             **************************************************************
                             word registercall Mul_AB_4(word param_1)
             word              AB:2           <RETURN>
             word              AB:2           param_1
                             Mul_AB_14                                       XREF[4]: 
                             Mul_AB_4
            8023 58              ASL        B
                                                      $U3380:1 = COPY B
                                                      C = INT_RIGHT $U3380:1, 7:4
                                                      $U3380:1 = INT_LEFT $U3380:1, 1:4
                                                      B = COPY $U3380:1
                                                      Z = INT_EQUAL $U3380:1, 0:1
                                                      N = INT_SLESS $U3380:1, 0:1
                                                      V = BOOL_XOR N, C
            8024 49              ROL        A
                                                      $U6280:1 = COPY C
                                                      $U6300:1 = COPY A
                                                      C = INT_RIGHT $U6300:1, 7:4
                                                      $U6480:1 = INT_LEFT $U6300:1, 1:4
                                                      $U6480:1 = INT_OR $U6480:1, $U6280:1
                                                      A = COPY $U6480:1
                                                      Z = INT_EQUAL $U6480:1, 0:1
                                                      N = INT_SLESS $U6480:1, 0:1
                                                      V = BOOL_XOR N, C
            8025 58              ASL        B
                                                      $U3380:1 = COPY B
                                                      C = INT_RIGHT $U3380:1, 7:4
                                                      $U3380:1 = INT_LEFT $U3380:1, 1:4
                                                      B = COPY $U3380:1
                                                      Z = INT_EQUAL $U3380:1, 0:1
                                                      N = INT_SLESS $U3380:1, 0:1
                                                      V = BOOL_XOR N, C
            8026 49              ROL        A
                                                      $U6280:1 = COPY C
                                                      $U6300:1 = COPY A
                                                      C = INT_RIGHT $U6300:1, 7:4
                                                      $U6480:1 = INT_LEFT $U6300:1, 1:4
                                                      $U6480:1 = INT_OR $U6480:1, $U6280:1
                                                      A = COPY $U6480:1
                                                      Z = INT_EQUAL $U6480:1, 0:1
                                                      N = INT_SLESS $U6480:1, 0:1
                                                      V = BOOL_XOR N, C
            8027 39              RTS
                                                      SP = INT_ADD SP, 1:2
                                                      $U7100:2 = LOAD RAM(SP)
                                                      SP = INT_ADD SP, 1:2
                                                      RETURN $U7100:2

looks different, depending on which function you look at for the decompile:

The nice one is:

word Mul_AB_4(word param_1)

{
  return param_1 << 2;
}

The weird one is:

word Mul_AB_16(word param_1)

{
  char cVar1;
  
  cVar1 = (char)(param_1 << 1);
  return CONCAT11(((char)((param_1 << 2) >> 8) << 1 | (byte)(param_1 << 2) >> 7) << 1 |
                  (byte)(cVar1 << 2) >> 7,cVar1 << 3);
}```


Next will be addition and subtraction. This is going to be fun. :-)

[astrelsky]

If your compiler has functions for multiplication and stuff like that, you can create call fixups for them to make the decompiler emit multiplication instead.

There is no documentation, it's hit and miss for good results unfortunately.