[AVR] Select 16-bit LDS/STS for load/store on AVRTiny.

[benshi001]

Summary

The 32-bit LDS/STS are not available on AVRTiny, so we have
to use their compact 16-bit form for memory access.

[benshi001]

fixes https://github.com/llvm/llvm-project/issues/58876

[aykevl]

Looks good to me

llvm/lib/Target/AVR/AVRInstrInfo.td

216

It would have been a bit cleaner to include this in the previous patch but it's fine now.

llvm/lib/Target/AVR/AVRInstrInfo.td

def call_target : Operand<iPTR> {
   let EncoderMethod = "encodeCallTarget";
   let DecoderMethod = "decodeCallTarget";
 }
 
 // A 16-bit address (which can lead to an R_AVR_16 relocation).
 def imm16 : Operand<i16> { let EncoderMethod = "encodeImm<AVR::fixup_16, 2>"; }
 
 // A 7-bit address (which can lead to an R_AVR_LDS_STS_16 relocation).
-def imm7tiny : Operand<i8> {
+def imm7tiny : Operand<i16> {
   let EncoderMethod = "encodeImm<AVR::fixup_lds_sts_16, 0>";
 }
 
 /// A 6-bit immediate used in the ADIW/SBIW instructions.
 def imm_arith6 : Operand<i16> {
   let EncoderMethod = "encodeImm<AVR::fixup_6_adiw, 0>";
 }
 
def LDSRdK : F32DM<0b0,
                       : $k),
                      "lds\t$rd, $k", [(set i8
                                        : $rd, (load imm
                                                : $k))]>,
                Requires<[HasSRAM, HasNonTinyEncoding]>;
 
   // Load from data space into register, which is only available on AVRTiny.
   def LDSRdKTiny : FLDSSTSTINY<0b0, (outs LD8:$rd), (ins imm7tiny:$k),
-                               "lds\t$rd, $k", []>,
+                               "lds\t$rd, $k",
+                               [(set i8:$rd, (load imm:$k))]>,
                    Requires<[HasSRAM, HasTinyEncoding]>;
 
   // LDSW Rd+1:Rd, K+1:K
   //
   // Expands to:
   // lds Rd,  (K+1:K)
   // lds Rd+1 (K+1:K) + 1
   def LDSWRdK : Pseudo<(outs DREGS
def STSKRr : F32DM<0b1, (outs),
                     : $rd),
                    "sts\t$k, $rd", [(store i8
                                      : $rd, imm
                                      : $k)]>,
              Requires<[HasSRAM, HasNonTinyEncoding]>;
 
 // Store from register to data space, which is only available on AVRTiny.
 def STSKRrTiny : FLDSSTSTINY<0b1, (outs), (ins imm7tiny:$k, LD8:$rd),
-                             "sts\t$k, $rd", []>,
+                             "sts\t$k, $rd", [(store i8:$rd, imm:$k)]>,
                  Requires<[HasSRAM, HasTinyEncoding]>;
 
 // STSW K+1:K, Rr+1:Rr
 //
 // Expands to:
 // sts Rr+1, (K+1:K) + 1
 // sts Rr,   (K+1:K)
 def STSWKRr : Pseudo<(outs),
def : Pat<(add i16
            : $src, (AVRWrapper tglobaladdr
                     : $src2)),
           (SUBIWRdK i16
            : $src, tglobaladdr
            : $src2)>;
 def : Pat<(i8(load(AVRWrapper tglobaladdr:$dst))),
           (LDSRdK tglobaladdr:$dst)>,
           Requires<[HasSRAM, HasNonTinyEncoding]>;
+def : Pat<(i8(load(AVRWrapper tglobaladdr:$dst))),
+          (LDSRdKTiny tglobaladdr:$dst)>,
+          Requires<[HasSRAM, HasTinyEncoding]>;
 def : Pat<(i16(load(AVRWrapper tglobaladdr:$dst))),
           (LDSWRdK tglobaladdr:$dst)>,
           Requires<[HasSRAM, HasNonTinyEncoding]>;
 def : Pat<(store i8:$src, (i16(AVRWrapper tglobaladdr:$dst))),
           (STSKRr tglobaladdr:$dst, i8:$src)>,
           Requires<[HasSRAM, HasNonTinyEncoding]>;
+def : Pat<(store i8:$src, (i16(AVRWrapper tglobaladdr:$dst))),
+          (STSKRrTiny tglobaladdr:$dst, i8:$src)>,
+          Requires<[HasSRAM, HasTinyEncoding]>;
 def : Pat<(store i16:$src, (i16(AVRWrapper tglobaladdr:$dst))),
           (STSWKRr tglobaladdr:$dst, i16:$src)>,
           Requires<[HasSRAM, HasNonTinyEncoding]>;
 
 // BlockAddress
 def : Pat<(i16(AVRWrapper tblockaddress
                : $dst)),
           (LDIWRdK tblockaddress

llvm/test/CodeGen/AVR/directmem.ll

 @longlong = common global i64 0
 @longlong.array = common global [3 x i64] zeroinitializer
 @longlong.static = internal global i64 0
 
 define void @global8_store() {
 ; CHECK-LABEL: global8_store:
 ; CHECK: ldi [[REG:r[0-9]+]], 6
 ; CHECK: sts char, [[REG]]
+;
 ; CHECK-TINY-LABEL: global8_store:
-; CHECK-TINY: ldi [[REG1:r[0-9]+]], 6
-; CHECK-TINY: ldi [[REG2:r[0-9]+]], lo8(char)
-; CHECK-TINY: ldi [[REG3:r[0-9]+]], hi8(char)
-; CHECK-TINY: st [[REG4:[X-Z]]], [[REG1]]
+; CHECK-TINY: ldi [[REG:r[0-9]+]], 6
+; CHECK-TINY: sts char, [[REG]]
   store i8 6, i8* @char
   ret void
 }
 
 define i8 @global8_load() {
 ; CHECK-LABEL: global8_load:
 ; CHECK: lds r24, char
+;
 ; CHECK-TINY-LABEL: global8_load:
-; CHECK-TINY: ldi [[REG1:r[0-9]+]], lo8(char)
-; CHECK-TINY: ldi [[REG2:r[0-9]+]], hi8(char)
-; CHECK-TINY: ld [[REG3:r[0-9]+]], [[REG4:[X-Z]]]
+; CHECK-TINY: lds r24, char
   %result = load i8, i8* @char
   ret i8 %result
 }
 
 define void @array8_store() {
 ; CHECK-LABEL: array8_store:
 ; CHECK: ldi [[REG1:r[0-9]+]], 3
 ; CHECK: sts char.array+2, [[REG1]]
 ; CHECK: ldi [[REG3:r[0-9]+]], 1
 ; CHECK: ldi [[REG2:r[0-9]+]], 2
 ; CHECK: sts char.array+1, [[REG2]]
 ; CHECK: sts char.array, [[REG3]]
+;
+; CHECK-TINY-LABEL: array8_store:
+; CHECK-TINY: ldi [[REG1:r[0-9]+]], 3
+; CHECK-TINY: sts char.array+2, [[REG1]]
   store i8 1, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @char.array, i32 0, i64 0)
   store i8 2, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @char.array, i32 0, i64 1)
   store i8 3, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @char.array, i32 0, i64 2)
   ret void
 }
 
 define i8 @array8_load() {
 ; CHECK-LABEL: array8_load:
 ; CHECK: lds r24, char.array+2
+;
+; CHECK-TINY-LABEL: array8_load:
+; CHECK-TINY: lds r24, char.array+2
   %result = load i8, i8* getelementptr inbounds ([3 x i8], [3 x i8]* @char.array, i32 0, i64 2)
   ret i8 %result
 }
 
 define i8 @static8_inc() {
 ; CHECK-LABEL: static8_inc:
 ; CHECK: lds r24, char.static
 ; CHECK: inc r24
 ; CHECK: sts char.static, r24
+;
+; CHECK-TINY-LABEL: static8_inc:
+; CHECK-TINY: lds r24, char.static
+; CHECK-TINY: inc r24
+; CHECK-TINY: sts char.static, r24
   %1 = load i8, i8* @char.static
   %inc = add nsw i8 %1, 1
   store i8 %inc, i8* @char.static
   ret i8 %inc
 }
 
 define void @global16_store() {
 ; CHECK-LABEL: global16_store: