[Clang][AArch64] Disable rounding of return values for AArch64

[asavonic]

Summary

If a return value is explicitly rounded to 64 bits, an additional
zext instruction is emitted, and in some cases it prevents tail call
optimization.

As discussed in D100225, this rounding is not necessary and can be
disabled.

[asavonic]

clang/test/CodeGen/arm64-arguments.c

65–76

I'm not sure if i24 here is a problem or not. Let me know if we need to handle this differently.

[rjmccall]

Hmm. I think the right thing to do here is to recognize generally that we're emitting a mandatory tail call, and so suppress *all* the normal transformations on the return value. The conditions on mandatory tail calls should make that possible, and it seems like it would be necessary for a lot of types. Aggregates especially come to mind — if an aggregate is returned in registers, we're probably going to generate code like

%0 = alloca %struct.foo
%1 = call {i64,i64} @function()
%2 = bitcast %0 to {i64,i64}*
store %1, %2
%3 = bitcast %0 to {i64,i64}*
%4 = load %3
ret %4

(Actually, probably much worse, with a lot of extract_values and so on.) I assume that is going to completely break TCO, and we really need to generate

%0 = call {i64,i64} @function()
ret %0

The *only* way we can do that is to recognize that the call has to be done differently in IRGen.

[asavonic]

In D100591#2692599, @rjmccall wrote:

I think the right thing to do here is to recognize generally that we're emitting a mandatory tail call, and so suppress *all* the normal transformations on the return value.

I assume it can be tricky to detect such call. The final decision (tail call vs normal call) is made before instruction selection, after all LLVM IR optimization passes. So we can miss tail calls that are not obvious on non-optimized code, or get false-positive results for calls that a backend decides to emit as normal calls.

In any case, this patch can be useful not only for tail calls: trunc + zext sequence generated to round a return value can be problematic for other cases as well.

[rjmccall]

In D100591#2692978, @asavonic wrote:

In D100591#2692599, @rjmccall wrote:

I think the right thing to do here is to recognize generally that we're emitting a mandatory tail call, and so suppress *all* the normal transformations on the return value.

I assume it can be tricky to detect such call. The final decision (tail call vs normal call) is made before instruction selection, after all LLVM IR optimization passes. So we can miss tail calls that are not obvious on non-optimized code, or get false-positive results for calls that a backend decides to emit as normal calls.

Well, I mean in the frontend. I certainly wouldn't expect the backend to recognize the pattern I described and somehow turn it into a tail call!

In any case, this patch can be useful not only for tail calls: trunc + zext sequence generated to round a return value can be problematic for other cases as well.

Sure, I can imagine that it's hard to eliminate the extra zext in the backend. Maybe we should have an undef_extend?

You should get backend sign-off before making Swift generate non-target-legal return types.

[asavonic]

Ping.
Please let me know if the patch is acceptable for AArch64, or something else should be done to avoid overhead from rounding of return values.

[t.p.northover]

On big-endian targets the rounding up to 64-bits (specified in the AAPCS) is significant; it means that structs get passed in the high bits of x0 rather than low. E.g. https://godbolt.org/z/6v36oexsW. I think this patch would break that.

[asavonic]

In D100591#2711433, @t.p.northover wrote:

On big-endian targets the rounding up to 64-bits (specified in the AAPCS) is significant; it means that structs get passed in the high bits of x0 rather than low. E.g. https://godbolt.org/z/6v36oexsW. I think this patch would break that.

Thanks a lot! I've disabled the change for big-endian AArch64 targets.

[asavonic]

Keep rounding of return values for big-endian targets.

[t.p.northover]

Thanks for updating it. A little disappointing that we can't support BE first-class, but much more important that it's not broken and it's not actually that common. So I think this is OK now, the backend should cope fine with the oddly sized types.

clang/lib/CodeGen/TargetInfo.cpp

ABIArgInfo AArch64ABIInfo::classifyReturnType(QualType RetTy,
 
   // Aggregates <= 16 bytes are returned directly in registers or on the stack.
   if (Size <= 128) {
     // On RenderScript, coerce Aggregates <= 16 bytes to an integer array of
     // same size and alignment.
     if (getTarget().isRenderScriptTarget()) {
       return coerceToIntArray(RetTy, getContext(), getVMContext());
     }
+
+    if (Size <= 64 && getDataLayout().isLittleEndian()) {
+      // Composite types are returned in lower bits of a 64-bit register for LE,
+      // and in higher bits for BE. However, integer types are always returned
+      // in lower bits for both LE and BE, and they are not rounded up to
+      // 64-bits. We can skip rounding up of composite types for LE, but not for
+      // BE, otherwise composite types will be indistinguishable from integer
+      // types.
+      return ABIArgInfo::getDirect(
+          llvm::IntegerType::get(getVMContext(), Size));
+    }
+
     unsigned Alignment = getContext().getTypeAlign(RetTy);
     Size = llvm::alignTo(Size, 64); // round up to multiple of 8 bytes
 
     // We use a pair of i64 for 16-byte aggregate with 8-byte alignment.
     // For aggregates with 16-byte alignment, we use i128.
     if (Alignment < 128 && Size == 128) {
       llvm::Type *BaseTy = llvm::Type::getInt64Ty(getVMContext());
       return ABIArgInfo::getDirect(llvm::ArrayType::get(BaseTy, Size / 64));

clang/test/CodeGen/aarch64-varargs.c

 //    affect the alignment.
 // Additionally the alignment can't go below 8 or above 16, so it's only
 // __int128 that can be affected by a change in alignment.
 
 typedef struct __attribute__((packed,aligned(2))) {
   int val;
 } underaligned_int_struct;
 underaligned_int_struct underaligned_int_struct_test() {
-// CHECK-LABEL: define{{.*}} i64 @underaligned_int_struct_test()
+// CHECK-LE-LABEL: define{{.*}} i32 @underaligned_int_struct_test()
+// CHECK-BE-LABEL: define{{.*}} i64 @underaligned_int_struct_test()
   return va_arg(the_list, underaligned_int_struct);
 // CHECK: [[GR_OFFS:%[a-z_0-9]+]] = load i32, i32* getelementptr inbounds (%struct.__va_list, %struct.__va_list* @the_list, i32 0, i32 3)
 // CHECK: [[EARLY_ONSTACK:%[a-z_0-9]+]] = icmp sge i32 [[GR_OFFS]], 0
 // CHECK: br i1 [[EARLY_ONSTACK]], label %[[VAARG_ON_STACK:[a-z_.0-9]+]], label %[[VAARG_MAYBE_REG:[a-z_.0-9]+]]
 
 // CHECK: [[VAARG_MAYBE_REG]]
 // CHECK: [[NEW_REG_OFFS:%[a-z_0-9]+]] = add i32 [[GR_OFFS]], 8
 // CHECK: store i32 [[NEW_REG_OFFS]], i32* getelementptr inbounds (%struct.__va_list, %struct.__va_list* @the_list, i32 0, i32 3)

 
 // Overaligning or underaligning a struct member changes both its alignment and
 // size when passed as an argument.
 
 typedef struct {
   int val __attribute__((packed,aligned(2)));
 } underaligned_int_struct_member;
 underaligned_int_struct_member underaligned_int_struct_member_test() {
-// CHECK-LABEL: define{{.*}} i64 @underaligned_int_struct_member_test()
+// CHECK-LE-LABEL: define{{.*}} i32 @underaligned_int_struct_member_test()
+// CHECK-BE-LABEL: define{{.*}} i64 @underaligned_int_struct_member_test()
   return va_arg(the_list, underaligned_int_struct_member);
 // CHECK: [[GR_OFFS:%[a-z_0-9]+]] = load i32, i32* getelementptr inbounds (%struct.__va_list, %struct.__va_list* @the_list, i32 0, i32 3)
 // CHECK: [[EARLY_ONSTACK:%[a-z_0-9]+]] = icmp sge i32 [[GR_OFFS]], 0
 // CHECK: br i1 [[EARLY_ONSTACK]], label %[[VAARG_ON_STACK:[a-z_.0-9]+]], label %[[VAARG_MAYBE_REG:[a-z_.0-9]+]]
 
 // CHECK: [[VAARG_MAYBE_REG]]
 // CHECK: [[NEW_REG_OFFS:%[a-z_0-9]+]] = add i32 [[GR_OFFS]], 8
 // CHECK: store i32 [[NEW_REG_OFFS]], i32* getelementptr inbounds (%struct.__va_list, %struct.__va_list* @the_list, i32 0, i32 3)

clang/test/CodeGen/arm64-arguments.c

-// RUN: %clang_cc1 -triple arm64-apple-ios7 -target-feature +neon -target-abi darwinpcs -ffreestanding -emit-llvm -w -o - %s | FileCheck %s
+// RUN: %clang_cc1 -triple arm64-apple-ios7 -target-feature +neon -target-abi darwinpcs -ffreestanding -emit-llvm -w -o - %s | FileCheck %s --check-prefixes=CHECK,CHECK-LE
+// RUN: %clang_cc1 -triple aarch64_be-none-linux-gnu -target-feature +neon -target-abi darwinpcs -ffreestanding -emit-llvm -w -o - %s | FileCheck %s --check-prefixes=CHECK,CHECK-BE
 
 // CHECK: define{{.*}} signext i8 @f0()
 char f0(void) {
   return 0;
 }
 
-// Struct as return type. Aggregates <= 16 bytes are passed directly and round
-// up to multiple of 8 bytes.
-// CHECK: define{{.*}} i64 @f1()
+// Struct as return type. Aggregates <= 16 bytes are passed directly. For BE,
+// return values are round up to 64 bits.
+//
+// CHECK-LE: define{{.*}} i8 @f1()
+// CHECK-BE: define{{.*}} i64 @f1()
 struct s1 { char f0; };
 struct s1 f1(void) {}
 
-// CHECK: define{{.*}} i64 @f2()
+// CHECK-LE: define{{.*}} i16 @f2()
+// CHECK-BE: define{{.*}} i64 @f2()
 struct s2 { short f0; };
 struct s2 f2(void) {}
 
-// CHECK: define{{.*}} i64 @f3()
+// CHECK-LE: define{{.*}} i32 @f3()
+// CHECK-BE: define{{.*}} i64 @f3()
 struct s3 { int f0; };
 struct s3 f3(void) {}
 
-// CHECK: define{{.*}} i64 @f4()
+// CHECK-LE: define{{.*}} i32 @f4()
+// CHECK-BE: define{{.*}} i64 @f4()
 struct s4 { struct s4_0 { int f0; } f0; };
 struct s4 f4(void) {}
 
-// CHECK: define{{.*}} i64 @f5()
+// CHECK-LE: define{{.*}} i32 @f5()
+// CHECK-BE: define{{.*}} i64 @f5()
 struct s5 { struct { } f0; int f1; };
 struct s5 f5(void) {}
 
-// CHECK: define{{.*}} i64 @f6()
+// CHECK-LE: define{{.*}} i32 @f6()
+// CHECK-BE: define{{.*}} i64 @f6()
 struct s6 { int f0[1]; };
 struct s6 f6(void) {}
 
 // CHECK: define{{.*}} void @f7()
 struct s7 { struct { int : 0; } f0; };
 struct s7 f7(void) {}
 
 // CHECK: define{{.*}} void @f8()
 struct s8 { struct { int : 0; } f0[1]; };
 struct s8 f8(void) {}
 
-// CHECK: define{{.*}} i64 @f9()
+// CHECK-LE: define{{.*}} i32 @f9()
+// CHECK-BE: define{{.*}} i64 @f9()
 struct s9 { int f0; int : 0; };
 struct s9 f9(void) {}
 
-// CHECK: define{{.*}} i64 @f10()
+// CHECK-LE: define{{.*}} i32 @f10()
+// CHECK-BE: define{{.*}} i64 @f10()
 struct s10 { int f0; int : 0; int : 0; };
 struct s10 f10(void) {}
 
-// CHECK: define{{.*}} i64 @f11()
+// CHECK-LE: define{{.*}} i32 @f11()
+// CHECK-BE: define{{.*}} i64 @f11()
 struct s11 { int : 0; int f0; };
 struct s11 f11(void) {}
 
-// CHECK: define{{.*}} i64 @f12()
+// CHECK-LE: define{{.*}} i24 @f11_packed()
+// CHECK-BE: define{{.*}} i64 @f11_packed()
+struct s11_packed { char c; short s } __attribute__((packed));
+struct s11_packed f11_packed(void) { }
+
+// CHECK-LE: define{{.*}} i32 @f11_not_packed()
+// CHECK-BE: define{{.*}} i64 @f11_not_packed()
+struct s11_not_packed { char c; short s; };
+struct s11_not_packed f11_not_packed(void) { }
+
+// CHECK-LE: define{{.*}} i32 @f12()
+// CHECK-BE: define{{.*}} i64 @f12()
 union u12 { char f0; short f1; int f2; };
 union u12 f12(void) {}
 
 // Homogeneous Aggregate as return type will be passed directly.
 // CHECK: define{{.*}} %struct.s13 @f13()
 struct s13 { float f0; };
 struct s13 f13(void) {}
 // CHECK: define{{.*}} %union.u14 @f14()
 union u14 { float f0; };
 union u14 f14(void) {}
 
 // CHECK: define{{.*}} void @f15()
 void f15(struct s7 a0) {}
 
 // CHECK: define{{.*}} void @f16()
 void f16(struct s8 a0) {}
 
-// CHECK: define{{.*}} i64 @f17()
+// CHECK-LE: define{{.*}} i32 @f17()
+// CHECK-BE: define{{.*}} i64 @f17()
 struct s17 { short f0 : 13; char f1 : 4; };
 struct s17 f17(void) {}
 
-// CHECK: define{{.*}} i64 @f18()
+// CHECK-LE: define{{.*}} i32 @f18()
+// CHECK-BE: define{{.*}} i64 @f18()
 struct s18 { short f0; char f1 : 4; };
 struct s18 f18(void) {}
 
-// CHECK: define{{.*}} i64 @f19()
+// CHECK-LE: define{{.*}} i32 @f19()
+// CHECK-BE: define{{.*}} i64 @f19()
 struct s19 { int f0; struct s8 f1; };
 struct s19 f19(void) {}
 
-// CHECK: define{{.*}} i64 @f20()
+// CHECK-LE: define{{.*}} i32 @f20()
+// CHECK-BE: define{{.*}} i64 @f20()
 struct s20 { struct s8 f1; int f0; };
 struct s20 f20(void) {}
 
-// CHECK: define{{.*}} i64 @f21()
+// CHECK-LE: define{{.*}} i32 @f21()
+// CHECK-BE: define{{.*}} i64 @f21()
 struct s21 { struct {} f1; int f0 : 4; };
 struct s21 f21(void) {}
 
-// CHECK: define{{.*}} i64 @f22()
-// CHECK: define{{.*}} i64 @f23()
+// CHECK-LE: define{{.*}} i16 @f22()
+// CHECK-LE: define{{.*}} i32 @f23()
+// CHECK-BE: define{{.*}} i64 @f22()
+// CHECK-BE: define{{.*}} i64 @f23()
 // CHECK: define{{.*}} i64 @f24()
 // CHECK: define{{.*}} [2 x i64] @f25()
 // CHECK: define{{.*}} { float, float } @f26()
 // CHECK: define{{.*}} { double, double } @f27()
 _Complex char       f22(void) {}
 _Complex short      f23(void) {}
 _Complex int        f24(void) {}
 _Complex long long  f25(void) {}
 _Complex float      f26(void) {}
 _Complex double     f27(void) {}
 
-// CHECK: define{{.*}} i64 @f28()
+// CHECK-LE: define{{.*}} i16 @f28()
+// CHECK-BE: define{{.*}} i64 @f28()
 struct s28 { _Complex char f0; };
 struct s28 f28() {}
 
-// CHECK: define{{.*}} i64 @f29()
+// CHECK-LE: define{{.*}} i32 @f29()
+// CHECK-BE: define{{.*}} i64 @f29()
 struct s29 { _Complex short f0; };
 struct s29 f29() {}
 
 // CHECK: define{{.*}} i64 @f30()
 struct s30 { _Complex int f0; };
 struct s30 f30() {}
 
 struct s31 { char x; };
 void f31(struct s31 s) { }
 // CHECK: define{{.*}} void @f31(i64 %s.coerce)
 // CHECK: %s = alloca %struct.s31, align 1
-// CHECK: trunc i64 %s.coerce to i8
+// CHECK-BE: %coerce.highbits = lshr i64 %s.coerce, 56
+// CHECK-BE: trunc i64 %coerce.highbits to i8
+// CHECK-LE: trunc i64 %s.coerce to i8
 // CHECK: store i8 %{{.*}},
 
 struct s32 { double x; };
 void f32(struct s32 s) { }
 // CHECK: @f32([1 x double] %{{.*}})
 
 // A composite type larger than 16 bytes should be passed indirectly.
 struct s33 { char buf[32*32]; };

 }
 
 // Handle homogeneous aggregates properly in variadic functions.
 struct HFA {
   float a, b, c, d;
 };
 
 float test_hfa(int n, ...) {
-// CHECK-LABEL: define{{.*}} float @test_hfa(i32 %n, ...)
-// CHECK: [[THELIST:%.*]] = alloca i8*
-// CHECK: [[CURLIST:%.*]] = load i8*, i8** [[THELIST]]
+// CHECK-LE-LABEL: define{{.*}} float @test_hfa(i32 %n, ...)
+// CHECK-LE: [[THELIST:%.*]] = alloca i8*
+// CHECK-LE: [[CURLIST:%.*]] = load i8*, i8** [[THELIST]]
 
   // HFA is not indirect, so occupies its full 16 bytes on the stack.
-// CHECK: [[NEXTLIST:%.*]] = getelementptr inbounds i8, i8* [[CURLIST]], i64 16
-// CHECK: store i8* [[NEXTLIST]], i8** [[THELIST]]
+// CHECK-LE: [[NEXTLIST:%.*]] = getelementptr inbounds i8, i8* [[CURLIST]], i64 16
+// CHECK-LE: store i8* [[NEXTLIST]], i8** [[THELIST]]
 
-// CHECK: bitcast i8* [[CURLIST]] to %struct.HFA*
+// CHECK-LE: bitcast i8* [[CURLIST]] to %struct.HFA*
   __builtin_va_list thelist;
   __builtin_va_start(thelist, n);
   struct HFA h = __builtin_va_arg(thelist, struct HFA);
   return h.d;
 }
 
 float test_hfa_call(struct HFA *a) {
 // CHECK-LABEL: define{{.*}} float @test_hfa_call(%struct.HFA* %a)
 // CHECK: call float (i32, ...) @test_hfa(i32 1, [4 x float] {{.*}})
   test_hfa(1, *a);
 }
 
 struct TooBigHFA {
   float a, b, c, d, e;
 };
 
 float test_toobig_hfa(int n, ...) {
-// CHECK-LABEL: define{{.*}} float @test_toobig_hfa(i32 %n, ...)
-// CHECK: [[THELIST:%.*]] = alloca i8*
-// CHECK: [[CURLIST:%.*]] = load i8*, i8** [[THELIST]]
+// CHECK-LE-LABEL: define{{.*}} float @test_toobig_hfa(i32 %n, ...)
+// CHECK-LE: [[THELIST:%.*]] = alloca i8*
+// CHECK-LE: [[CURLIST:%.*]] = load i8*, i8** [[THELIST]]
 
   // TooBigHFA is not actually an HFA, so gets passed indirectly. Only 8 bytes
   // of stack consumed.
-// CHECK: [[NEXTLIST:%.*]] = getelementptr inbounds i8, i8* [[CURLIST]], i64 8
-// CHECK: store i8* [[NEXTLIST]], i8** [[THELIST]]
+// CHECK-LE: [[NEXTLIST:%.*]] = getelementptr inbounds i8, i8* [[CURLIST]], i64 8
+// CHECK-LE: store i8* [[NEXTLIST]], i8** [[THELIST]]
 
-// CHECK: [[HFAPTRPTR:%.*]] = bitcast i8* [[CURLIST]] to %struct.TooBigHFA**
-// CHECK: [[HFAPTR:%.*]] = load %struct.TooBigHFA*, %struct.TooBigHFA** [[HFAPTRPTR]]
+// CHECK-LE: [[HFAPTRPTR:%.*]] = bitcast i8* [[CURLIST]] to %struct.TooBigHFA**
+// CHECK-LE: [[HFAPTR:%.*]] = load %struct.TooBigHFA*, %struct.TooBigHFA** [[HFAPTRPTR]]
   __builtin_va_list thelist;
   __builtin_va_start(thelist, n);
   struct TooBigHFA h = __builtin_va_arg(thelist, struct TooBigHFA);
   return h.d;
 }
 
 struct HVA {
   int32x4_t a, b;
 };
 
 int32x4_t test_hva(int n, ...) {
-// CHECK-LABEL: define{{.*}} <4 x i32> @test_hva(i32 %n, ...)
-// CHECK: [[THELIST:%.*]] = alloca i8*
-// CHECK: [[CURLIST:%.*]] = load i8*, i8** [[THELIST]]
+// CHECK-LE-LABEL: define{{.*}} <4 x i32> @test_hva(i32 %n, ...)
+// CHECK-LE: [[THELIST:%.*]] = alloca i8*
+// CHECK-LE: [[CURLIST:%.*]] = load i8*, i8** [[THELIST]]
 
   // HVA is not indirect, so occupies its full 16 bytes on the stack. but it
   // must be properly aligned.
-// CHECK: [[ALIGN0:%.*]] = ptrtoint i8* [[CURLIST]] to i64
-// CHECK: [[ALIGN1:%.*]] = add i64 [[ALIGN0]], 15
-// CHECK: [[ALIGN2:%.*]] = and i64 [[ALIGN1]], -16
-// CHECK: [[ALIGNED_LIST:%.*]] = inttoptr i64 [[ALIGN2]] to i8*
+// CHECK-LE: [[ALIGN0:%.*]] = ptrtoint i8* [[CURLIST]] to i64
+// CHECK-LE: [[ALIGN1:%.*]] = add i64 [[ALIGN0]], 15
+// CHECK-LE: [[ALIGN2:%.*]] = and i64 [[ALIGN1]], -16
+// CHECK-LE: [[ALIGNED_LIST:%.*]] = inttoptr i64 [[ALIGN2]] to i8*
 
-// CHECK: [[NEXTLIST:%.*]] = getelementptr inbounds i8, i8* [[ALIGNED_LIST]], i64 32
-// CHECK: store i8* [[NEXTLIST]], i8** [[THELIST]]
+// CHECK-LE: [[NEXTLIST:%.*]] = getelementptr inbounds i8, i8* [[ALIGNED_LIST]], i64 32
+// CHECK-LE: store i8* [[NEXTLIST]], i8** [[THELIST]]
 
-// CHECK: bitcast i8* [[ALIGNED_LIST]] to %struct.HVA*
+// CHECK-LE: bitcast i8* [[ALIGNED_LIST]] to %struct.HVA*
   __builtin_va_list thelist;
   __builtin_va_start(thelist, n);
   struct HVA h = __builtin_va_arg(thelist, struct HVA);
   return h.b;
 }
 
 struct TooBigHVA {
   int32x4_t a, b, c, d, e;
 };
 
 int32x4_t test_toobig_hva(int n, ...) {
-// CHECK-LABEL: define{{.*}} <4 x i32> @test_toobig_hva(i32 %n, ...)
-// CHECK: [[THELIST:%.*]] = alloca i8*
-// CHECK: [[CURLIST:%.*]] = load i8*, i8** [[THELIST]]
+// CHECK-LE-LABEL: define{{.*}} <4 x i32> @test_toobig_hva(i32 %n, ...)
+// CHECK-LE: [[THELIST:%.*]] = alloca i8*
+// CHECK-LE: [[CURLIST:%.*]] = load i8*, i8** [[THELIST]]
 
   // TooBigHVA is not actually an HVA, so gets passed indirectly. Only 8 bytes
   // of stack consumed.
-// CHECK: [[NEXTLIST:%.*]] = getelementptr inbounds i8, i8* [[CURLIST]], i64 8
-// CHECK: store i8* [[NEXTLIST]], i8** [[THELIST]]
+// CHECK-LE: [[NEXTLIST:%.*]] = getelementptr inbounds i8, i8* [[CURLIST]], i64 8
+// CHECK-LE: store i8* [[NEXTLIST]], i8** [[THELIST]]
 
-// CHECK: [[HVAPTRPTR:%.*]] = bitcast i8* [[CURLIST]] to %struct.TooBigHVA**
-// CHECK: [[HVAPTR:%.*]] = load %struct.TooBigHVA*, %struct.TooBigHVA** [[HVAPTRPTR]]
+// CHECK-LE: [[HVAPTRPTR:%.*]] = bitcast i8* [[CURLIST]] to %struct.TooBigHVA**
+// CHECK-LE: [[HVAPTR:%.*]] = load %struct.TooBigHVA*, %struct.TooBigHVA** [[HVAPTRPTR]]
   __builtin_va_list thelist;
   __builtin_va_start(thelist, n);
   struct TooBigHVA h = __builtin_va_arg(thelist, struct TooBigHVA);
   return h.d;
 }
 
 typedef __attribute__((__ext_vector_type__(3))) float float32x3_t;
 typedef struct { float32x3_t arr[4]; } HFAv3;
 
 float32x3_t test_hva_v3(int n, ...) {
-// CHECK-LABEL: define{{.*}} <3 x float> @test_hva_v3(i32 %n, ...)
-// CHECK: [[THELIST:%.*]] = alloca i8*
-// CHECK: [[CURLIST:%.*]] = load i8*, i8** [[THELIST]]
+// CHECK-LE-LABEL: define{{.*}} <3 x float> @test_hva_v3(i32 %n, ...)
+// CHECK-LE: [[THELIST:%.*]] = alloca i8*
+// CHECK-LE: [[CURLIST:%.*]] = load i8*, i8** [[THELIST]]
 
   // HVA is not indirect, so occupies its full 16 bytes on the stack. but it
   // must be properly aligned.
-// CHECK: [[ALIGN0:%.*]] = ptrtoint i8* [[CURLIST]] to i64
-// CHECK: [[ALIGN1:%.*]] = add i64 [[ALIGN0]], 15
-// CHECK: [[ALIGN2:%.*]] = and i64 [[ALIGN1]], -16
-// CHECK: [[ALIGNED_LIST:%.*]] = inttoptr i64 [[ALIGN2]] to i8*
+// CHECK-LE: [[ALIGN0:%.*]] = ptrtoint i8* [[CURLIST]] to i64
+// CHECK-LE: [[ALIGN1:%.*]] = add i64 [[ALIGN0]], 15
+// CHECK-LE: [[ALIGN2:%.*]] = and i64 [[ALIGN1]], -16
+// CHECK-LE: [[ALIGNED_LIST:%.*]] = inttoptr i64 [[ALIGN2]] to i8*
 
-// CHECK: [[NEXTLIST:%.*]] = getelementptr inbounds i8, i8* [[ALIGNED_LIST]], i64 64
-// CHECK: store i8* [[NEXTLIST]], i8** [[THELIST]]
+// CHECK-LE: [[NEXTLIST:%.*]] = getelementptr inbounds i8, i8* [[ALIGNED_LIST]], i64 64
+// CHECK-LE: store i8* [[NEXTLIST]], i8** [[THELIST]]
 
-// CHECK: bitcast i8* [[ALIGNED_LIST]] to %struct.HFAv3*
+// CHECK-LE: bitcast i8* [[ALIGNED_LIST]] to %struct.HFAv3*
   __builtin_va_list l;
   __builtin_va_start(l, n);
   HFAv3 r = __builtin_va_arg(l, HFAv3);
   return r.arr[2];
 }
 
 float32x3_t test_hva_v3_call(HFAv3 *a) {
 // CHECK-LABEL: define{{.*}} <3 x float> @test_hva_v3_call(%struct.HFAv3* %a)
 // CHECK: call <3 x float> (i32, ...) @test_hva_v3(i32 1, [4 x <4 x float>] {{.*}})
   return test_hva_v3(1, *a);
 }

clang/test/CodeGen/arm64-microsoft-arguments.cpp

 S5 func5(S5 x);
 S5 f5() {
   S5 x;
   return func5(x);
 }
 
 // Pass and return an object with a non-trivial explicitly defaulted constructor
 // (passed directly, returned directly)
-// CHECK: define {{.*}} i64 @"?f6@@YA?AUS6@@XZ"()
-// CHECK: call i64 {{.*}}func6{{.*}}(i64 {{.*}})
+// CHECK: define {{.*}} i8 @"?f6@@YA?AUS6@@XZ"()
+// CHECK: call i8 {{.*}}func6{{.*}}(i64 {{.*}})
 struct S6a {
   S6a();
 };
 
 struct S6 {
   S6() = default;
   S6a x;
 };
 
 S6 func6(S6 x);
 S6 f6() {
   S6 x;
   return func6(x);
 }
 
 // Pass and return an object with a non-trivial implicitly defaulted constructor
 // (passed directly, returned directly)
-// CHECK: define {{.*}} i64 @"?f7@@YA?AUS7@@XZ"()
-// CHECK: call i64 {{.*}}func7{{.*}}(i64 {{.*}})
+// CHECK: define {{.*}} i8 @"?f7@@YA?AUS7@@XZ"()
+// CHECK: call i8 {{.*}}func7{{.*}}(i64 {{.*}})
 struct S7 {
   S6a x;
 };
 
 S7 func7(S7 x);
 S7 f7() {
   S7 x;
   return func7(x);

clang/test/CodeGen/attr-noundef.cpp

 // RUN: %clang -cc1 -triple x86_64-gnu-linux -x c++ -S -emit-llvm -enable-noundef-analysis %s -o - | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-INTEL
 // RUN: %clang -cc1 -triple aarch64-gnu-linux -x c++ -S -emit-llvm -enable-noundef-analysis %s -o - | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-AARCH
 
 //************ Passing structs by value
 // TODO: No structs may currently be marked noundef
 
 namespace check_structs {
 struct Trivial {
   int a;
 };
 Trivial ret_trivial() { return {}; }
 void pass_trivial(Trivial e) {}
 // CHECK-INTEL: [[DEFINE:define( dso_local)?]] i32 @{{.*}}ret_trivial
-// CHECK-AARCH: [[DEFINE:define( dso_local)?]] i64 @{{.*}}ret_trivial
+// CHECK-AARCH: [[DEFINE:define( dso_local)?]] i32 @{{.*}}ret_trivial
 // CHECK-INTEL: [[DEFINE]] void @{{.*}}pass_trivial{{.*}}(i32 %
 // CHECK-AARCH: [[DEFINE]] void @{{.*}}pass_trivial{{.*}}(i64 %
 
 struct NoCopy {
   int a;
   NoCopy(NoCopy &) = delete;
 };
 NoCopy ret_nocopy() { return {}; }

 
 namespace check_unions {
 union Trivial {
   int a;
 };
 Trivial ret_trivial() { return {}; }
 void pass_trivial(Trivial e) {}
 // CHECK-INTEL: [[DEFINE]] i32 @{{.*}}ret_trivial
-// CHECK-AARCH: [[DEFINE]] i64 @{{.*}}ret_trivial
+// CHECK-AARCH: [[DEFINE]] i32 @{{.*}}ret_trivial
 // CHECK-INTEL: [[DEFINE]] void @{{.*}}pass_trivial{{.*}}(i32 %
 // CHECK-AARCH: [[DEFINE]] void @{{.*}}pass_trivial{{.*}}(i64 %
 
 union NoCopy {
   int a;
   NoCopy(NoCopy &) = delete;
 };
 NoCopy ret_nocopy() { return {}; }

clang/test/CodeGenCXX/microsoft-abi-sret-and-byval.cpp

void call_bools_and_chars() {
   take_bools_and_chars('A', 'B', SmallWithDtor(), 'D', true, 13, false);
 }
 
 // Returning structs that fit into a register.
 Small small_return() { return Small(); }
 // LINUX-LABEL: define{{.*}} void @_Z12small_returnv(%struct.Small* noalias sret(%struct.Small) align 4 %agg.result)
 // WIN32: define dso_local i32 @"?small_return@@YA?AUSmall@@XZ"()
 // WIN64: define dso_local i32 @"?small_return@@YA?AUSmall@@XZ"()
-// WOA64: define dso_local i64 @"?small_return@@YA?AUSmall@@XZ"()
+// WOA64: define dso_local i32 @"?small_return@@YA?AUSmall@@XZ"()
 
 Medium medium_return() { return Medium(); }
 // LINUX-LABEL: define{{.*}} void @_Z13medium_returnv(%struct.Medium* noalias sret(%struct.Medium) align 4 %agg.result)
 // WIN32: define dso_local i64 @"?medium_return@@YA?AUMedium@@XZ"()
 // WIN64: define dso_local i64 @"?medium_return@@YA?AUMedium@@XZ"()
 // WOA64: define dso_local i64 @"?medium_return@@YA?AUMedium@@XZ"()
 
 // Returning structs that fit into a register but are not POD.

clang/test/CodeGenCXX/trivial_abi.cpp

 // CHECK: %[[CALL:.*]] = call %[[STRUCT_LARGE]]* @_ZN5LargeD1Ev(%[[STRUCT_LARGE]]* {{[^,]*}} %[[AGG_TMP_ENSURED]])
 // CHECK: ret void
 // CHECK: }
 
 void testIgnoredLarge() {
   testReturnLarge();
 }
 
-// CHECK: define{{.*}} i64 @_Z20testReturnHasTrivialv()
+// CHECK: define{{.*}} i32 @_Z20testReturnHasTrivialv()
 // CHECK: %[[RETVAL:.*]] = alloca %[[STRUCT_TRIVIAL:.*]], align 4
 // CHECK: %[[COERCE_DIVE:.*]] = getelementptr inbounds %[[STRUCT_TRIVIAL]], %[[STRUCT_TRIVIAL]]* %[[RETVAL]], i32 0, i32 0
 // CHECK: %[[V0:.*]] = load i32, i32* %[[COERCE_DIVE]], align 4
-// CHECK: %[[COERCE_VAL_II:.*]] = zext i32 %[[V0]] to i64
-// CHECK: ret i64 %[[COERCE_VAL_II]]
+// CHECK: ret i32 %[[V0]]
 // CHECK: }
 
 Trivial testReturnHasTrivial() {
   Trivial t;
   return t;
 }
 
 // CHECK: define{{.*}} void @_Z23testReturnHasNonTrivialv(%[[STRUCT_NONTRIVIAL:.*]]* noalias sret(%[[STRUCT_NONTRIVIAL]]) align 4 %[[AGG_RESULT:.*]])