[clang] Do not extend i8 return values to i16 on AVR.

[benshi001]

This patch fixes https://github.com/llvm/llvm-project/issues/58877 .

[benshi001]

On 32-bit / 64-bit machines, a function returning lower types (via a register) should an explicit sign/zero extension to full fill the register.

But on AVR, a 8-bit register is used to return 8-bit values, so the sign/zero extension is unnecessary, which leads to extra useless assembly.

[Miss_Grape]

LGTM

clang/lib/CodeGen/TargetInfo.cpp

if (isAggregateTypeForABI(Ty) &&
         getContext().getTypeSize(Ty) <= RetRegs * 8)
       return ABIArgInfo::getDirect();
     // A return value (struct or scalar) with larger size is returned via a
     // stack slot, along with a pointer as the function's implicit argument.
     if (getContext().getTypeSize(Ty) > RetRegs * 8) {
       LargeRet = true;
       return getNaturalAlignIndirect(Ty);
     }
+    // An i8 return value should not be extended to i16, since AVR has 8-bit
+    // registers.
+    if (Ty->isIntegralOrEnumerationType() && getContext().getTypeSize(Ty) <= 8)
+      return ABIArgInfo::getDirect();
     // Otherwise we follow the default way which is compatible.
     return DefaultABIInfo::classifyReturnType(Ty);
   }
 
   ABIArgInfo classifyArgumentType(QualType Ty, unsigned &NumRegs) const {
     unsigned TySize = getContext().getTypeSize(Ty);
 
     // An int8 type argument always costs two registers like an int16.

clang/test/CodeGen/avr/avr-builtins.c

 // RUN: %clang_cc1 -triple avr-unknown-unknown -emit-llvm -o - %s | FileCheck %s
 
 // Check that the parameter types match. This verifies pr43309.
 // RUN: %clang_cc1 -triple avr-unknown-unknown -Wconversion -verify %s
 // expected-no-diagnostics
 
 unsigned char bitrev8(unsigned char data) {
     return __builtin_bitreverse8(data);
 }
 
-// CHECK: define{{.*}} zeroext i8 @bitrev8
+// CHECK: define{{.*}} i8 @bitrev8
 // CHECK: i8 @llvm.bitreverse.i8(i8
 
 unsigned int bitrev16(unsigned int data) {
     return __builtin_bitreverse16(data);
 }
 
 // CHECK: define{{.*}} i16 @bitrev16
 // CHECK: i16 @llvm.bitreverse.i16(i16

 
 // CHECK: define{{.*}} i64 @bitrev64
 // CHECK: i64 @llvm.bitreverse.i64(i64
 
 unsigned char rotleft8(unsigned char x, unsigned char y) {
     return __builtin_rotateleft8(x, y);
 }
 
-// CHECK: define{{.*}} zeroext i8 @rotleft8
+// CHECK: define{{.*}} i8 @rotleft8
 // CHECK: i8 @llvm.fshl.i8(i8
 
 unsigned int rotleft16(unsigned int x, unsigned int y) {
     return __builtin_rotateleft16(x, y);
 }
 
 // CHECK: define{{.*}} i16 @rotleft16
 // CHECK: i16 @llvm.fshl.i16(i16

 
 // CHECK: define{{.*}} i64 @rotleft64
 // CHECK: i64 @llvm.fshl.i64(i64
 
 unsigned char rotright8(unsigned char x, unsigned char y) {
     return __builtin_rotateright8(x, y);
 }
 
-// CHECK: define{{.*}} zeroext i8 @rotright8
+// CHECK: define{{.*}} i8 @rotright8
 // CHECK: i8 @llvm.fshr.i8(i8
 
 unsigned int rotright16(unsigned int x, unsigned int y) {
     return __builtin_rotateright16(x, y);
 }
 
 // CHECK: define{{.*}} i16 @rotright16
 // CHECK: i16 @llvm.fshr.i16(i16