Fix x86/x86_64 calling convention for _ExtInt

[erichkeane]

Summary

After speaking with Craig Topper about some recent defects, he pointed
out that _ExtInts should be passed indirectly if larger than the largest
int register, and like ints when smaller than that. This patch
implements that.

Note that this changed the way vaargs worked quite a bit, but they still
work.

[• Quuxplusone]

clang/lib/CodeGen/TargetInfo.cpp

2804

Asking silly questions because I don't stand a chance of understanding either the code or the tests...

In the x86-64 ABI, an ordinary 16-byte struct would be passed in rdi/rsi and returned in rdx/rax. An ordinary 17-byte struct would be passed by hidden reference and returned by hidden reference.

Is your intent here that _ExtInt will follow the same convention, i.e., _ExtInt(128) will be passed in rdi/rsi and returned in rdx/rax? and _ExtInt(129) will be passed and returned by hidden reference?

Clang trunk currently passes _ExtInt(256) in rdi/rsi/rdx/rcx/r8/r9/stack as if it were a series of uint64_ts. (I hadn't noticed until now.) That's kind of cute. Is the current PR motivated by performance concerns with the multi-uint64_t approach, or just trying to be consistent with the struct rules?

[craig.topper]

I think you're missing a check for ExtInt in X86_64ABIInfo::getIndirectReturnResult

[erichkeane]

clang/lib/CodeGen/TargetInfo.cpp

2804

Yes, that is my intent. The bug you filed apparently showed why putting it in registers is perhaps a bad idea (for something that large), AND gets us more consistent with structs.

As there is no official ABI for any of the 3 platforms, this seems more consistent and gives performance benefit. @craig.topper can explain this part better than me.

[erichkeane]

Handle indirect return as well. @craig.topper : Anything else you can think of?

[rjmccall]

Is there something currently restricting these types to just x86, or do you need to do a much broader audit?

clang/lib/CodeGen/TargetInfo.cpp

2981

Presumably *some* ExtInt types should be returned directly.

[erichkeane]

clang/lib/CodeGen/TargetInfo.cpp

2981

Right, and they are. This is only for cases where we request an 'indirect result', so cases where we've already decided that it cannot be passed direct.

At this point, the 'classify' step has already been done, which would have decided that <=128 bit values are passed 'direct', and we've requested an indirect. At least as far as I can tell from this code/debugging.

[rjmccall]

clang/lib/CodeGen/TargetInfo.cpp

2981

Oh, I see. So the current code is intentionally using a direct IR return in some cases and then allowing LLVM to lower it as an indirect return? I didn't think we ever did that, and I'm really not sure it's a good idea, so I definitely agree with not doing it for ExtInt types.

[erichkeane]

clang/lib/CodeGen/TargetInfo.cpp

2981

Right, exactly :) FWIW, this is my 3rd time looking into this TargetInfo code, and it is particularly convoluted. If I understood the calling conventions sufficiently, I'd take a run at trying to figure out how to make this not so messy.

[erichkeane]

@craig.topper Did this look OK/ Is there anything else you want from this?

[craig.topper]

LGTM

[rjmccall]

Could you answer my question up-thread about whether ExtInt is currently target-limited? If it isn't, we need to more broadly audit targets.

[erichkeane]

In D78785#2010546, @rjmccall wrote:

Could you answer my question up-thread about whether ExtInt is currently target-limited? If it isn't, we need to more broadly audit targets.

Yikes! I missed that question, I'm sorry :/

We aren't limiting it, as it is supposed to be a C language feature (and in fact, is more useful certain on non-x86 chips!). We likely need an audit, though in TargetInfo I didn't see any other 'classify' functions other than these 3 (X86, x86-64Win, x86-64-Linux).

[rjmccall]

Every target does something similar, they just all do it in different ways because they're mostly written by different people.

We should restrict this feature to targets where we've adequately audited the ABI. It's not a feature until the ABI work is done.

[erichkeane]

In D78785#2010654, @rjmccall wrote:

Every target does something similar, they just all do it in different ways because they're mostly written by different people.

We should restrict this feature to targets where we've adequately audited the ABI. It's not a feature until the ABI work is done.

I'm discovering that now :) I'm currently trying to do said audit by going down the ABIInfo inheritance tree. I believe we have at least a month until the next release branch date. If you can help keep me honest here, I'll disable _ExtInt for any platforms I haven't done by then at the branch.

Does that seem acceptable?

[rjmccall]

In D78785#2010738, @erichkeane wrote:

In D78785#2010654, @rjmccall wrote:

Every target does something similar, they just all do it in different ways because they're mostly written by different people.

We should restrict this feature to targets where we've adequately audited the ABI. It's not a feature until the ABI work is done.

I'm discovering that now :) I'm currently trying to do said audit by going down the ABIInfo inheritance tree. I believe we have at least a month until the next release branch date. If you can help keep me honest here, I'll disable _ExtInt for any platforms I haven't done by then at the branch.

Does that seem acceptable?

Yes, although, I think you ought to flip the default anyway just so we're doing the right thing for out-of-tree targets. It should then be very straightforward to flip it back target-by-target as you do your audit.

[erichkeane]

See my audit/WIP on calling conventions here: https://reviews.llvm.org/D79118

[erichkeane]

Alright then, I've disabled by default(911add149af563a5a61458de0dd730e3f5348623). I'll enable 1 at a time as I fix the calling conventions in D79118.

[rjmccall]

Thanks!

clang/lib/CodeGen/TargetInfo.cpp

ABIArgInfo X86_32ABIInfo::classifyArgumentType(QualType Ty,
   bool InReg = shouldPrimitiveUseInReg(Ty, State);
 
   if (Ty->isPromotableIntegerType()) {
     if (InReg)
       return ABIArgInfo::getExtendInReg(Ty);
     return ABIArgInfo::getExtend(Ty);
   }
 
+  if (const auto * EIT = Ty->getAs<ExtIntType>()) {
+    if (EIT->getNumBits() <= 64) {
+      if (InReg)
+        return ABIArgInfo::getDirectInReg();
+      return ABIArgInfo::getDirect();
+    }
+    return getIndirectResult(Ty, /*ByVal=*/false, State);
+  }
+
   if (InReg)
     return ABIArgInfo::getDirectInReg();
   return ABIArgInfo::getDirect();
 }
 
 void X86_32ABIInfo::computeInfo(CGFunctionInfo &FI) const {
   CCState State(FI);
   if (IsMCUABI)
if (const ComplexType *CT = Ty->getAs<ComplexType>()) {
     uint64_t EB_Real = (OffsetBase) / 64;
     uint64_t EB_Imag = (OffsetBase + getContext().getTypeSize(ET)) / 64;
     if (Hi == NoClass && EB_Real != EB_Imag)
       Hi = Lo;
 
     return;
   }
 
+  if (const auto *EITy = Ty->getAs<ExtIntType>()) {
+    if (EITy->getNumBits() <= 64)
+      Current = Integer;
+    else if (EITy->getNumBits() <= 128)
+      Lo = Hi = Integer;
+    // Larger values need to get passed in memory.
+    return;
+  }
+
   if (const ConstantArrayType *AT = getContext().getAsConstantArrayType(Ty)) {
     // Arrays are treated like structures.
 
     uint64_t Size = getContext().getTypeSize(Ty);
 
     // AMD64-ABI 3.2.3p2: Rule 1. If the size of an object is larger
     // than eight eightbytes, ..., it has class MEMORY.
     if (Size > 512)
ABIArgInfo X86_64ABIInfo::getIndirectReturnResult(QualType Ty) const {
   // If this is a scalar LLVM value then assume LLVM will pass it in the right
   // place naturally.
   if (!isAggregateTypeForABI(Ty)) {
     // Treat an enum type as its underlying type.
     if (const EnumType *EnumTy = Ty->getAs<EnumType>())
       Ty = EnumTy->getDecl()->getIntegerType();
 
     return (Ty->isPromotableIntegerType() ? ABIArgInfo::getExtend(Ty)
                                           : ABIArgInfo::getDirect());
   }
 
   return getNaturalAlignIndirect(Ty);
 }
 
 bool X86_64ABIInfo::IsIllegalVectorType(QualType Ty) const {
   if (const VectorType *VecTy = Ty->getAs<VectorType>()) {
     uint64_t Size = getContext().getTypeSize(VecTy);
ABIArgInfo X86_64ABIInfo::getIndirectResult(QualType Ty,
   // If this is a scalar LLVM value then assume LLVM will pass it in the right
   // place naturally.
   //
   // This assumption is optimistic, as there could be free registers available
   // when we need to pass this argument in memory, and LLVM could try to pass
   // the argument in the free register. This does not seem to happen currently,
   // but this code would be much safer if we could mark the argument with
   // 'onstack'. See PR12193.
-  if (!isAggregateTypeForABI(Ty) && !IsIllegalVectorType(Ty)) {
+  if (!isAggregateTypeForABI(Ty) && !IsIllegalVectorType(Ty) &&
+      !Ty->isExtIntType()) {
     // Treat an enum type as its underlying type.
     if (const EnumType *EnumTy = Ty->getAs<EnumType>())
       Ty = EnumTy->getDecl()->getIntegerType();
 
     return (Ty->isPromotableIntegerType() ? ABIArgInfo::getExtend(Ty)
                                           : ABIArgInfo::getDirect());
   }
 
case BuiltinType::UInt128:
       return ABIArgInfo::getDirect(
           llvm::VectorType::get(llvm::Type::getInt64Ty(getVMContext()), 2));
 
     default:
       break;
     }
   }
 
+  if (Ty->isExtIntType()) {
+    // MS x64 ABI requirement: "Any argument that doesn't fit in 8 bytes, or is
+    // not 1, 2, 4, or 8 bytes, must be passed by reference."
+    // However, non-power-of-two _ExtInts will be passed as 1,2,4 or 8 bytes
+    // anyway as long is it fits in them, so we don't have to check the power of
+    // 2.
+    if (Width <= 64)
+      return ABIArgInfo::getDirect();
+    return ABIArgInfo::getIndirect(Align, /*ByVal=*/false);
+  }
+
   return ABIArgInfo::getDirect();
 }
 
 void WinX86_64ABIInfo::computeVectorCallArgs(CGFunctionInfo &FI,
                                              unsigned FreeSSERegs,
                                              bool IsVectorCall,
                                              bool IsRegCall) const {
   unsigned Count = 0;

clang/test/CodeGen/ext-int-sanitizer.cpp

-// RUN: %clang_cc1 -triple x86_64-gnu-linux -fsanitize=array-bounds,enum,float-cast-overflow,integer-divide-by-zero,implicit-unsigned-integer-truncation,implicit-signed-integer-truncation,implicit-integer-sign-change,unsigned-integer-overflow,signed-integer-overflow,shift-base,shift-exponent -O3 -disable-llvm-passes -emit-llvm -o - %s | FileCheck %s 
+// RUN: %clang_cc1 -triple x86_64-gnu-linux -fsanitize=array-bounds,enum,float-cast-overflow,integer-divide-by-zero,implicit-unsigned-integer-truncation,implicit-signed-integer-truncation,implicit-integer-sign-change,unsigned-integer-overflow,signed-integer-overflow,shift-base,shift-exponent -O3 -disable-llvm-passes -emit-llvm -o - %s | FileCheck %s
 
 
 // CHECK: define void @_Z6BoundsRA10_KiU7_ExtIntILi15EEi
 void Bounds(const int (&Array)[10], _ExtInt(15) Index) {
   int I1 = Array[Index];
   // CHECK: %[[SEXT:.+]] = sext i15 %{{.+}} to i64
   // CHECK: %[[CMP:.+]] = icmp ult i64 %[[SEXT]], 10
   // CHECK: br i1 %[[CMP]]
void FloatOverflow(float f, double d) {
   // CHECK: fcmp olt double %{{.+}}, 6.400000e+01
 }
 
 // CHECK: define void @_Z14UIntTruncationU7_ExtIntILi35EEjjy
 void UIntTruncation(unsigned _ExtInt(35) E, unsigned int i, unsigned long long ll) {
 
   i = E;
   // CHECK: %[[LOADE:.+]] = load i35
-  // CHECK: %[[CONV:.+]] = trunc i35 %[[LOADE]] to i32
+  // CHECK: store i35 %[[LOADE]], i35* %[[EADDR:.+]]
+  // CHECK: %[[LOADE2:.+]] = load i35, i35* %[[EADDR]]
+  // CHECK: %[[CONV:.+]] = trunc i35 %[[LOADE2]] to i32
   // CHECK: %[[EXT:.+]] = zext i32 %[[CONV]] to i35
-  // CHECK: %[[CHECK:.+]] = icmp eq i35 %[[EXT]], %[[LOADE]]
+  // CHECK: %[[CHECK:.+]] = icmp eq i35 %[[EXT]], %[[LOADE2]]
   // CHECK: br i1 %[[CHECK]]
   // CHECK: call void @__ubsan_handle_implicit_conversion_abort
 
   E = ll;
   // CHECK: %[[LOADLL:.+]] = load i64
   // CHECK: %[[CONV:.+]] = trunc i64 %[[LOADLL]] to i35
   // CHECK: %[[EXT:.+]] = zext i35 %[[CONV]] to i64
   // CHECK: %[[CHECK:.+]] = icmp eq i64 %[[EXT]], %[[LOADLL]]
   // CHECK: br i1 %[[CHECK]]
   // CHECK: call void @__ubsan_handle_implicit_conversion_abort
 }
 
 // CHECK: define void @_Z13IntTruncationU7_ExtIntILi35EEiU7_ExtIntILi42EEjij
 void IntTruncation(_ExtInt(35) E, unsigned _ExtInt(42) UE, int i, unsigned j) {
 
   j = E;
   // CHECK: %[[LOADE:.+]] = load i35
-  // CHECK: %[[CONV:.+]] = trunc i35 %[[LOADE]] to i32
+  // CHECK: store i35 %[[LOADE]], i35* %[[EADDR:.+]]
+  // CHECK: %[[LOADE2:.+]] = load i35, i35* %[[EADDR]]
+  // CHECK: %[[CONV:.+]] = trunc i35 %[[LOADE2]] to i32
   // CHECK: %[[EXT:.+]] = zext i32 %[[CONV]] to i35
-  // CHECK: %[[CHECK:.+]] = icmp eq i35 %[[EXT]], %[[LOADE]]
+  // CHECK: %[[CHECK:.+]] = icmp eq i35 %[[EXT]], %[[LOADE2]]
   // CHECK: br i1 %[[CHECK]]
   // CHECK: call void @__ubsan_handle_implicit_conversion_abort
 
   j = UE;
   // CHECK: %[[LOADUE:.+]] = load i42
   // CHECK: %[[CONV:.+]] = trunc i42 %[[LOADUE]] to i32
   // CHECK: %[[EXT:.+]] = zext i32 %[[CONV]] to i42
   // CHECK: %[[CHECK:.+]] = icmp eq i42 %[[EXT]], %[[LOADUE]]
void IntTruncation(_ExtInt(35) E, unsigned _ExtInt(42) UE, int i, unsigned j) {
   // CHECK: %[[CHECKBOTH:.+]] = and i1 %[[SIGNCHECK]], %[[CHECK]]
   // CHECK: br i1 %[[CHECKBOTH]]
   // CHECK: call void @__ubsan_handle_implicit_conversion_abort
 }
 
 // CHECK: define void @_Z15SignChangeCheckU7_ExtIntILi39EEjU7_ExtIntILi39EEi
 void SignChangeCheck(unsigned _ExtInt(39) UE, _ExtInt(39) E) {
   UE = E;
+  // CHECK: %[[LOADEU:.+]] = load i39
   // CHECK: %[[LOADE:.+]] = load i39
-  // CHECK: %[[NEG:.+]] = icmp slt i39 %[[LOADE]], 0
+  // CHECK: store i39 %[[LOADE]], i39* %[[EADDR:.+]]
+  // CHECK: %[[LOADE2:.+]] = load i39, i39* %[[EADDR]]
+  // CHECK: %[[NEG:.+]] = icmp slt i39 %[[LOADE2]], 0
   // CHECK: %[[SIGNCHECK:.+]] = icmp eq i1 %[[NEG]], false
   // CHECK: br i1 %[[SIGNCHECK]]
   // CHECK: call void @__ubsan_handle_implicit_conversion_abort
 
-
   E = UE;
-  // CHECK: %[[LOADUE:.+]] = load i39
-  // CHECK: %[[NEG:.+]] = icmp slt i39 %[[LOADUE]], 0
+  // CHECK: store i39 %[[LOADE2]], i39* %[[UEADDR:.+]]
+  // CHECK: %[[LOADUE2:.+]] = load i39, i39* %[[UEADDR]]
+  // CHECK: %[[NEG:.+]] = icmp slt i39 %[[LOADUE2]], 0
   // CHECK: %[[SIGNCHECK:.+]] = icmp eq i1 false, %[[NEG]]
   // CHECK: br i1 %[[SIGNCHECK]]
   // CHECK: call void @__ubsan_handle_implicit_conversion_abort
 }
 
 // CHECK: define void @_Z9DivByZeroU7_ExtIntILi11EEii
 void DivByZero(_ExtInt(11) E, int i) {
 
   // Also triggers signed integer overflow.
   E / E;
-  // CHECK: %[[E:.+]] = load i11, i11*
-  // CHECK: %[[E2:.+]] = load i11, i11*
+  // CHECK: %[[E1LOAD:.+]] = load i11
+  // CHECK: store i11 %[[E1LOAD]], i11* %[[EADDR:.+]]
+  // CHECK: %[[E:.+]] = load i11, i11* %[[EADDR]]
+  // CHECK: %[[E2:.+]] = load i11, i11* %[[EADDR]]
   // CHECK: %[[NEZERO:.+]] = icmp ne i11 %[[E2]], 0
   // CHECK: %[[NEMIN:.+]] = icmp ne i11 %[[E]], -1024
   // CHECK: %[[NENEG1:.+]] = icmp ne i11 %[[E2]], -1
   // CHECK: %[[OR:.+]] = or i1 %[[NEMIN]], %[[NENEG1]]
   // CHECK: %[[AND:.+]] = and i1 %[[NEZERO]], %[[OR]]
   // CHECK: br i1 %[[AND]]
   // CHECK: call void @__ubsan_handle_divrem_overflow_abort
 }
 
 // TODO:
 //-fsanitize=shift: (shift-base, shift-exponent) Shift operators where the amount shifted is greater or equal to the promoted bit-width of the left hand side or less than zero, or where the left hand side is negative. For a signed left shift, also checks for signed overflow in C, and for unsigned overflow in C++. You can use -fsanitize=shift-base or -fsanitize=shift-exponent to check only left-hand side or right-hand side of shift operation, respectively.
 // CHECK: define void @_Z6ShiftsU7_ExtIntILi9EEi
 void Shifts(_ExtInt(9) E) {
   E >> E;
-  // CHECK: %[[LHSE:.+]] = load i9, i9*
-  // CHECK: %[[RHSE:.+]] = load i9, i9*
+  // CHECK: %[[E1LOAD:.+]] = load i9, i9*
+  // CHECK: store i9 %[[E1LOAD]], i9* %[[EADDR:.+]]
+  // CHECK: %[[LHSE:.+]] = load i9, i9* %[[EADDR]]
+  // CHECK: %[[RHSE:.+]] = load i9, i9* %[[EADDR]]
   // CHECK: %[[CMP:.+]] = icmp ule i9 %[[RHSE]], 8
   // CHECK: br i1 %[[CMP]]
   // CHECK: call void @__ubsan_handle_shift_out_of_bounds_abort
 
   E << E;
   // CHECK: %[[LHSE:.+]] = load i9, i9*
   // CHECK: %[[RHSE:.+]] = load i9, i9*
   // CHECK: %[[CMP:.+]] = icmp ule i9 %[[RHSE]], 8
   // CHECK: br i1 %[[CMP]]
   // CHECK: %[[ZEROS:.+]] = sub nuw nsw i9 8, %[[RHSE]]
   // CHECK: %[[CHECK:.+]] = lshr i9 %[[LHSE]], %[[ZEROS]]
   // CHECK: %[[SKIPSIGN:.+]] = lshr i9 %[[CHECK]], 1
   // CHECK: %[[CHECK:.+]] = icmp eq i9 %[[SKIPSIGN]]
   // CHECK: %[[PHI:.+]] = phi i1 [ true, %{{.+}} ], [ %[[CHECK]], %{{.+}} ]
   // CHECK: and i1 %[[CMP]], %[[PHI]]
   // CHECK: call void @__ubsan_handle_shift_out_of_bounds_abort
 }
 
 // CHECK: define void @_Z21SignedIntegerOverflowU7_ExtIntILi93EEiU7_ExtIntILi4EEiU7_ExtIntILi31EEi
 void SignedIntegerOverflow(_ExtInt(93) BiggestE,
                            _ExtInt(4) SmallestE,
                            _ExtInt(31) JustRightE) {
   BiggestE + BiggestE;
-  // CHECK: %[[LOAD1:.+]] = load i93, i93*
-  // CHECK: %[[LOAD2:.+]] = load i93, i93*
+  // CHECK: %[[LOADBIGGESTE2:.+]] = load i93
+  // CHECK: store i93 %[[LOADBIGGESTE2]], i93* %[[BIGGESTEADDR:.+]]
+  // CHECK: %[[LOAD1:.+]] = load i93, i93* %[[BIGGESTEADDR]]
+  // CHECK: %[[LOAD2:.+]] = load i93, i93* %[[BIGGESTEADDR]]
   // CHECK: %[[OFCALL:.+]] = call { i93, i1 } @llvm.sadd.with.overflow.i93(i93 %[[LOAD1]], i93 %[[LOAD2]])
   // CHECK: %[[EXRESULT:.+]] = extractvalue { i93, i1 } %[[OFCALL]], 0
   // CHECK: %[[OFRESULT:.+]] = extractvalue { i93, i1 } %[[OFCALL]], 1
   // CHECK: %[[CHECK:.+]] = xor i1 %[[OFRESULT]], true
   // CHECK: br i1 %[[CHECK]]
   // CHECK: call void @__ubsan_handle_add_overflow_abort
 
   SmallestE - SmallestE;
void SignedIntegerOverflow(_ExtInt(93) BiggestE,
   // CHECK: call void @__ubsan_handle_mul_overflow_abort
 }
 
 // CHECK: define void @_Z23UnsignedIntegerOverflowjU7_ExtIntILi23EEjU7_ExtIntILi35EEj
 void UnsignedIntegerOverflow(unsigned u,
                              unsigned _ExtInt(23) SmallE,
                              unsigned _ExtInt(35) BigE) {
   u = SmallE + SmallE;
-  // CHECK: %[[LOADE1:.+]] = load i23, i23*
-  // CHECK: %[[LOADE2:.+]] = load i23, i23*
+  // CHECK: %[[LOADBIGGESTE2:.+]] = load i23
+  // CHECK: store i23 %[[LOADBIGGESTE2]], i23* %[[BIGGESTEADDR:.+]]
+  // CHECK: %[[LOADE1:.+]] = load i23, i23* %[[BIGGESTEADDR]]
+  // CHECK: %[[LOADE2:.+]] = load i23, i23* %[[BIGGESTEADDR]]
   // CHECK: %[[OFCALL:.+]] = call { i23, i1 } @llvm.uadd.with.overflow.i23(i23 %[[LOADE1]], i23 %[[LOADE2]])
   // CHECK: %[[EXRESULT:.+]] = extractvalue { i23, i1 } %[[OFCALL]], 0
   // CHECK: %[[OFRESULT:.+]] = extractvalue { i23, i1 } %[[OFCALL]], 1
   // CHECK: %[[CHECK:.+]] = xor i1 %[[OFRESULT]], true
   // CHECK: br i1 %[[CHECK]]
   // CHECK: call void @__ubsan_handle_add_overflow_abort
 
   SmallE = u + u;

clang/test/CodeGen/ext-int.c

-// RUN: %clang_cc1 -triple x86_64-gnu-linux -O3 -disable-llvm-passes -emit-llvm -o - %s | FileCheck %s --check-prefixes=CHECK
-// RUN: %clang_cc1 -triple x86_64-windows-pc -O3 -disable-llvm-passes -emit-llvm -o - %s | FileCheck %s --check-prefixes=CHECK
+// RUN: %clang_cc1 -triple x86_64-gnu-linux -O3 -disable-llvm-passes -emit-llvm -o - %s | FileCheck %s --check-prefixes=CHECK,LIN64,CHECK64
+// RUN: %clang_cc1 -triple x86_64-windows-pc -O3 -disable-llvm-passes -emit-llvm -o - %s | FileCheck %s --check-prefixes=CHECK,WIN64,CHECK64
+// RUN: %clang_cc1 -triple i386-gnu-linux -O3 -disable-llvm-passes -emit-llvm -o - %s | FileCheck %s --check-prefixes=CHECK,LIN32,CHECK32
+// RUNX: %clang_cc1 -triple i386-windows-pc -O3 -disable-llvm-passes -emit-llvm -o - %s | FileCheck %s --check-prefixes=CHECK,WIN32,CHECK32
 
 
 void GenericTest(_ExtInt(3) a, unsigned _ExtInt(3) b, _ExtInt(4) c) {
   // CHECK: define {{.*}}void @GenericTest
   int which = _Generic(a, _ExtInt(3): 1, unsigned _ExtInt(3) : 2, _ExtInt(4) : 3);
   // CHECK: store i32 1
   int which2 = _Generic(b, _ExtInt(3): 1, unsigned _ExtInt(3) : 2, _ExtInt(4) : 3);
   // CHECK: store i32 2
   int which3 = _Generic(c, _ExtInt(3): 1, unsigned _ExtInt(3) : 2, _ExtInt(4) : 3);
   // CHECK: store i32 3
 }
 
 void VLATest(_ExtInt(3) A, _ExtInt(99) B, _ExtInt(123456) C) {
   // CHECK: define {{.*}}void @VLATest
   int AR1[A];
-  // CHECK: %[[A:.+]] = zext i3 %{{.+}} to i64
-  // CHECK: %[[VLA1:.+]] = alloca i32, i64 %[[A]]
+  // CHECK: %[[A:.+]] = zext i3 %{{.+}} to i[[INDXSIZE:[0-9]+]]
+  // CHECK: %[[VLA1:.+]] = alloca i32, i[[INDXSIZE]] %[[A]]
   int AR2[B];
-  // CHECK: %[[B:.+]] = trunc i99 %{{.+}} to i64
-  // CHECK: %[[VLA2:.+]] = alloca i32, i64 %[[B]]
+  // CHECK: %[[B:.+]] = trunc i99 %{{.+}} to i[[INDXSIZE]]
+  // CHECK: %[[VLA2:.+]] = alloca i32, i[[INDXSIZE]] %[[B]]
   int AR3[C];
-  // CHECK: %[[C:.+]] = trunc i123456 %{{.+}} to i64
-  // CHECK: %[[VLA3:.+]] = alloca i32, i64 %[[C]]
+  // CHECK: %[[C:.+]] = trunc i123456 %{{.+}} to i[[INDXSIZE]]
+  // CHECK: %[[VLA3:.+]] = alloca i32, i[[INDXSIZE]] %[[C]]
 }
 
 struct S {
   _ExtInt(17) A;
   _ExtInt(16777200) B;
   _ExtInt(17) C;
 };
 
 void OffsetOfTest() {
-  // CHECK: define {{.*}}void @OffsetOfTest 
+  // CHECK: define {{.*}}void @OffsetOfTest
   int A = __builtin_offsetof(struct S,A);
   // CHECK: store i32 0, i32* %{{.+}}
   int B = __builtin_offsetof(struct S,B);
-  // CHECK: store i32 8, i32* %{{.+}}
+  // CHECK64: store i32 8, i32* %{{.+}}
+  // CHECK32: store i32 4, i32* %{{.+}}
   int C = __builtin_offsetof(struct S,C);
-  // CHECK: store i32 2097160, i32* %{{.+}}
+  // CHECK64: store i32 2097160, i32* %{{.+}}
+  // CHECK32: store i32 2097156, i32* %{{.+}}
 }
 
+// Make sure 128 and 64 bit versions are passed like integers, and that >128
+// is passed indirectly.
+void ParamPassing(_ExtInt(129) a, _ExtInt(128) b, _ExtInt(64) c) {}
+// LIN64: define void @ParamPassing(i129* byval(i129) align 8 %{{.+}}, i64 %{{.+}}, i64 %{{.+}}, i64 %{{.+}})
+// WIN64: define dso_local void @ParamPassing(i129* %{{.+}}, i128* %{{.+}}, i64 %{{.+}})
+// LIN32: define void @ParamPassing(i129* %{{.+}}, i128* %{{.+}}, i64 %{{.+}})
+// WIN32: define dso_local void @ParamPassing(i129* %{{.+}}, i128* %{{.+}}, i64 %{{.+}})
+void ParamPassing2(_ExtInt(129) a, _ExtInt(127) b, _ExtInt(63) c) {}
+// LIN64: define void @ParamPassing2(i129* byval(i129) align 8 %{{.+}}, i64 %{{.+}}, i64 %{{.+}}, i64 %{{.+}})
+// WIN64: define dso_local void @ParamPassing2(i129* %{{.+}}, i127* %{{.+}}, i63 %{{.+}})
+// LIN32: define void @ParamPassing2(i129* %{{.+}}, i127* %{{.+}}, i63 %{{.+}})
+// WIN32: define dso_local void @ParamPassing2(i129* %{{.+}}, i127* %{{.+}}, i63 %{{.+}})
 

clang/test/CodeGenCXX/ext-int.cpp

void BitfieldAssignment() {
   // CHECK: %[[SETC:.+]] = or i8 %[[CLEARC]], 64
 }
 
 enum AsEnumUnderlyingType : _ExtInt(9) {
   A,B,C
 };
 
 void UnderlyingTypeUsage(AsEnumUnderlyingType Param) {
-  // LIN: define void @_Z19UnderlyingTypeUsage20AsEnumUnderlyingType(i9 %
+  // LIN: define void @_Z19UnderlyingTypeUsage20AsEnumUnderlyingType(i16 %
   // WIN: define dso_local void @"?UnderlyingTypeUsage@@YAXW4AsEnumUnderlyingType@@@Z"(i9 %
   AsEnumUnderlyingType Var;
   // CHECK: alloca i9, align 2
   // CHECK: store i9 %{{.*}}, align 2
 }
 
 unsigned _ExtInt(33) ManglingTestRetParam(unsigned _ExtInt(33) Param) {
-// LIN: define i33 @_Z20ManglingTestRetParamU7_ExtIntILi33EEj(i33 %
+// LIN: define i64 @_Z20ManglingTestRetParamU7_ExtIntILi33EEj(i64 %
 // WIN: define dso_local i33 @"?ManglingTestRetParam@@YAU?$_UExtInt@$0CB@@__clang@@U12@@Z"(i33
   return 0;
 }
 
 _ExtInt(33) ManglingTestRetParam(_ExtInt(33) Param) {
-// LIN: define i33 @_Z20ManglingTestRetParamU7_ExtIntILi33EEi(i33 %
+// LIN: define i64 @_Z20ManglingTestRetParamU7_ExtIntILi33EEi(i64 %
 // WIN: define dso_local i33 @"?ManglingTestRetParam@@YAU?$_ExtInt@$0CB@@__clang@@U12@@Z"(i33
   return 0;
 }
 
 template<typename T>
 void ManglingTestTemplateParam(T&);
 template<_ExtInt(99) T>
 void ManglingTestNTTP();
void TakesVarargs(int i, ...) {
   // LIN: %[[STARTAD1:.+]] = bitcast %struct.__va_list_tag* %[[STARTAD]] to i8*
   // LIN: call void @llvm.va_start(i8* %[[STARTAD1]])
   // WIN: %[[ARGSLLIFETIMESTART:.+]] = bitcast i8** %[[ARGS]] to i8*
   // WIN: %[[ARGSSTART:.+]] = bitcast i8** %[[ARGS]] to i8*
   // WIN: call void @llvm.va_start(i8* %[[ARGSSTART]])
 
   _ExtInt(92) A = __builtin_va_arg(args, _ExtInt(92));
   // LIN: %[[AD1:.+]] = getelementptr inbounds [1 x %struct.__va_list_tag], [1 x %struct.__va_list_tag]* %[[ARGS]]
-  // LIN: %[[OFA_P1:.+]] = getelementptr inbounds %struct.__va_list_tag, %struct.__va_list_tag* %[[AD1]], i32 0, i32 2
-  // LIN: %[[OFA1:.+]] = load i8*, i8** %[[OFA_P1]]
-  // LIN: %[[BC1:.+]] = bitcast i8* %[[OFA1]] to i92*
-  // LIN: %[[OFANEXT1:.+]] = getelementptr i8, i8* %[[OFA1]], i32 16
-  // LIN: store i8* %[[OFANEXT1]], i8** %[[OFA_P1]]
+  // LIN: %[[OFA_P1:.+]] = getelementptr inbounds %struct.__va_list_tag, %struct.__va_list_tag* %[[AD1]], i32 0, i32 0
+  // LIN: %[[GPOFFSET:.+]] = load i32, i32* %[[OFA_P1]]
+  // LIN: %[[FITSINGP:.+]] = icmp ule i32 %[[GPOFFSET]], 32
+  // LIN: br i1 %[[FITSINGP]]
+  // LIN: %[[BC1:.+]] = phi i92*
   // LIN: %[[LOAD1:.+]] = load i92, i92* %[[BC1]]
   // LIN: store i92 %[[LOAD1]], i92*
+
   // WIN: %[[CUR1:.+]] = load i8*, i8** %[[ARGS]]
   // WIN: %[[NEXT1:.+]] = getelementptr inbounds i8, i8* %[[CUR1]], i64 16
   // WIN: store i8* %[[NEXT1]], i8** %[[ARGS]]
   // WIN: %[[BC1:.+]] = bitcast i8* %[[CUR1]] to i92*
   // WIN: %[[LOADV1:.+]] = load i92, i92* %[[BC1]]
   // WIN: store i92 %[[LOADV1]], i92*
 
   _ExtInt(31) B = __builtin_va_arg(args, _ExtInt(31));
   // LIN: %[[AD2:.+]] = getelementptr inbounds [1 x %struct.__va_list_tag], [1 x %struct.__va_list_tag]* %[[ARGS]]
-  // LIN: %[[OFA_P2:.+]] = getelementptr inbounds %struct.__va_list_tag, %struct.__va_list_tag* %[[AD2]], i32 0, i32 2
-  // LIN: %[[OFA2:.+]] = load i8*, i8** %[[OFA_P2]]
-  // LIN: %[[BC2:.+]] = bitcast i8* %[[OFA2]] to i31*
-  // LIN: %[[OFANEXT2:.+]] = getelementptr i8, i8* %[[OFA2]], i32 8
-  // LIN: store i8* %[[OFANEXT2]], i8** %[[OFA_P2]]
-  // LIN: %[[LOAD2:.+]] = load i31, i31* %[[BC2]]
-  // LIN: store i31 %[[LOAD2]], i31*
+  // LIN: %[[OFA_P2:.+]] = getelementptr inbounds %struct.__va_list_tag, %struct.__va_list_tag* %[[AD2]], i32 0, i32 0
+  // LIN: %[[GPOFFSET:.+]] = load i32, i32* %[[OFA_P2]]
+  // LIN: %[[FITSINGP:.+]] = icmp ule i32 %[[GPOFFSET]], 40
+  // LIN: br i1 %[[FITSINGP]]
+  // LIN: %[[BC1:.+]] = phi i31*
+  // LIN: %[[LOAD1:.+]] = load i31, i31* %[[BC1]]
+  // LIN: store i31 %[[LOAD1]], i31*
+
   // WIN: %[[CUR2:.+]] = load i8*, i8** %[[ARGS]]
-  // WIN: %[[NEXT2:.+]] = getelementptr inbounds i8, i8* %[[CUR2]], i64 8 
+  // WIN: %[[NEXT2:.+]] = getelementptr inbounds i8, i8* %[[CUR2]], i64 8
   // WIN: store i8* %[[NEXT2]], i8** %[[ARGS]]
   // WIN: %[[BC2:.+]] = bitcast i8* %[[CUR2]] to i31*
   // WIN: %[[LOADV2:.+]] = load i31, i31* %[[BC2]]
   // WIN: store i31 %[[LOADV2]], i31*
 
   _ExtInt(16) C = __builtin_va_arg(args, _ExtInt(16));
   // LIN: %[[AD3:.+]] = getelementptr inbounds [1 x %struct.__va_list_tag], [1 x %struct.__va_list_tag]* %[[ARGS]]
-  // LIN: %[[OFA_P3:.+]] = getelementptr inbounds %struct.__va_list_tag, %struct.__va_list_tag* %[[AD3]], i32 0, i32 2
-  // LIN: %[[OFA3:.+]] = load i8*, i8** %[[OFA_P3]]
-  // LIN: %[[BC3:.+]] = bitcast i8* %[[OFA3]] to i16*
-  // LIN: %[[OFANEXT3:.+]] = getelementptr i8, i8* %[[OFA3]], i32 8
-  // LIN: store i8* %[[OFANEXT3]], i8** %[[OFA_P3]]
-  // LIN: %[[LOAD3:.+]] = load i16, i16* %[[BC3]]
-  // LIN: store i16 %[[LOAD3]], i16*
+  // LIN: %[[OFA_P3:.+]] = getelementptr inbounds %struct.__va_list_tag, %struct.__va_list_tag* %[[AD3]], i32 0, i32 0
+  // LIN: %[[GPOFFSET:.+]] = load i32, i32* %[[OFA_P3]]
+  // LIN: %[[FITSINGP:.+]] = icmp ule i32 %[[GPOFFSET]], 40
+  // LIN: br i1 %[[FITSINGP]]
+  // LIN: %[[BC1:.+]] = phi i16*
+  // LIN: %[[LOAD1:.+]] = load i16, i16* %[[BC1]]
+  // LIN: store i16 %[[LOAD1]], i16*
+
   // WIN: %[[CUR3:.+]] = load i8*, i8** %[[ARGS]]
   // WIN: %[[NEXT3:.+]] = getelementptr inbounds i8, i8* %[[CUR3]], i64 8
   // WIN: store i8* %[[NEXT3]], i8** %[[ARGS]]
   // WIN: %[[BC3:.+]] = bitcast i8* %[[CUR3]] to i16*
   // WIN: %[[LOADV3:.+]] = load i16, i16* %[[BC3]]
   // WIN: store i16 %[[LOADV3]], i16*
 
   _ExtInt(129) D = __builtin_va_arg(args, _ExtInt(129));
   // LIN: %[[AD4:.+]] = getelementptr inbounds [1 x %struct.__va_list_tag], [1 x %struct.__va_list_tag]* %[[ARGS]]
   // LIN: %[[OFA_P4:.+]] = getelementptr inbounds %struct.__va_list_tag, %struct.__va_list_tag* %[[AD4]], i32 0, i32 2
   // LIN: %[[OFA4:.+]] = load i8*, i8** %[[OFA_P4]]
   // LIN: %[[BC4:.+]] = bitcast i8* %[[OFA4]] to i129*
   // LIN: %[[OFANEXT4:.+]] = getelementptr i8, i8* %[[OFA4]], i32 24
   // LIN: store i8* %[[OFANEXT4]], i8** %[[OFA_P4]]
   // LIN: %[[LOAD4:.+]] = load i129, i129* %[[BC4]]
   // LIN: store i129 %[[LOAD4]], i129*
+
   // WIN: %[[CUR4:.+]] = load i8*, i8** %[[ARGS]]
-  // WIN: %[[NEXT4:.+]] = getelementptr inbounds i8, i8* %[[CUR4]], i64 24 
+  // WIN: %[[NEXT4:.+]] = getelementptr inbounds i8, i8* %[[CUR4]], i64 24
   // WIN: store i8* %[[NEXT4]], i8** %[[ARGS]]
   // WIN: %[[BC4:.+]] = bitcast i8* %[[CUR4]] to i129*
   // WIN: %[[LOADV4:.+]] = load i129, i129* %[[BC4]]
   // WIN: store i129 %[[LOADV4]], i129*
 
   _ExtInt(16777200) E = __builtin_va_arg(args, _ExtInt(16777200));
   // LIN: %[[AD5:.+]] = getelementptr inbounds [1 x %struct.__va_list_tag], [1 x %struct.__va_list_tag]* %[[ARGS]]
   // LIN: %[[OFA_P5:.+]] = getelementptr inbounds %struct.__va_list_tag, %struct.__va_list_tag* %[[AD5]], i32 0, i32 2
   // LIN: %[[OFA5:.+]] = load i8*, i8** %[[OFA_P5]]
   // LIN: %[[BC5:.+]] = bitcast i8* %[[OFA5]] to i16777200*
   // LIN: %[[OFANEXT5:.+]] = getelementptr i8, i8* %[[OFA5]], i32 2097152
   // LIN: store i8* %[[OFANEXT5]], i8** %[[OFA_P5]]
   // LIN: %[[LOAD5:.+]] = load i16777200, i16777200* %[[BC5]]
   // LIN: store i16777200 %[[LOAD5]], i16777200*
+
   // WIN: %[[CUR5:.+]] = load i8*, i8** %[[ARGS]]
   // WIN: %[[NEXT5:.+]] = getelementptr inbounds i8, i8* %[[CUR5]], i64 2097152
   // WIN: store i8* %[[NEXT5]], i8** %[[ARGS]]
   // WIN: %[[BC5:.+]] = bitcast i8* %[[CUR5]] to i16777200*
   // WIN: %[[LOADV5:.+]] = load i16777200, i16777200* %[[BC5]]
   // WIN: store i16777200 %[[LOADV5]], i16777200*
 
   __builtin_va_end(args);

  // LIN: call void @_ZNSt9type_infoC1ERKS_(%"class.std::type_info"* %{{.+}}, %"class.std::type_info"* dereferenceable(16) bitcast ({ i8*, i8* }* @_ZTIU7_ExtIntILi32EEi to %"class.std::type_info"*))
  // WIN:  call %"class.std::type_info"* @"??0type_info@std@@QEAA@AEBV01@@Z"(%"class.std::type_info"* %{{.+}}, %"class.std::type_info"* dereferenceable(16) bitcast (%rtti.TypeDescriptor27* @"??_R0U?$_ExtInt@$0CA@@__clang@@@8" to %"class.std::type_info"*))
  auto F = typeid(S32_2);
  // LIN: call void @_ZNSt9type_infoC1ERKS_(%"class.std::type_info"* %{{.+}}, %"class.std::type_info"* dereferenceable(16) bitcast ({ i8*, i8* }* @_ZTIU7_ExtIntILi32EEi to %"class.std::type_info"*))
  // WIN:  call %"class.std::type_info"* @"??0type_info@std@@QEAA@AEBV01@@Z"(%"class.std::type_info"* %{{.+}}, %"class.std::type_info"* dereferenceable(16) bitcast (%rtti.TypeDescriptor27* @"??_R0U?$_ExtInt@$0CA@@__clang@@@8" to %"class.std::type_info"*))
 }
 
 void ExplicitCasts() {
-  // LIN: define void @_Z13ExplicitCastsv() 
+  // LIN: define void @_Z13ExplicitCastsv()
   // WIN: define dso_local void @"?ExplicitCasts@@YAXXZ"()
 
   _ExtInt(33) a;
   _ExtInt(31) b;
   int i;
 
   a = i;
   // CHECK: %[[CONV:.+]] = sext i32 %{{.+}} to i33
   b = i;
   // CHECK: %[[CONV:.+]] = trunc i32 %{{.+}} to i31
   i = a;
   // CHECK: %[[CONV:.+]] = trunc i33 %{{.+}} to i32
   i = b;
   // CHECK: %[[CONV:.+]] = sext i31 %{{.+}} to i32
 }
 
 struct S {
   _ExtInt(17) A;
   _ExtInt(16777200) B;
   _ExtInt(17) C;
 };
 
 void OffsetOfTest() {
-  // LIN: define void @_Z12OffsetOfTestv() 
+  // LIN: define void @_Z12OffsetOfTestv()
   // WIN: define dso_local void @"?OffsetOfTest@@YAXXZ"()
 
   auto A = __builtin_offsetof(S,A);
   // CHECK: store i64 0, i64* %{{.+}}
   auto B = __builtin_offsetof(S,B);
   // CHECK: store i64 8, i64* %{{.+}}
   auto C = __builtin_offsetof(S,C);
   // CHECK: store i64 2097160, i64* %{{.+}}
// WIN: define dso_local void @"?ShiftExtIntByConstant@@YAXU?$_ExtInt@$0BM@@__clang@@@Z"
   // CHECK: ashr i28 %{{.+}}, 7
   Ext << -7;
   // CHECK: shl i28 %{{.+}}, -7
   Ext >> -7;
   // CHECK: ashr i28 %{{.+}}, -7
 
   // UB in C/C++, Defined in OpenCL.
   Ext << 29;
-  // CHECK: shl i28 %{{.+}}, 29 
+  // CHECK: shl i28 %{{.+}}, 29
   Ext >> 29;
   // CHECK: ashr i28 %{{.+}}, 29
 }
 
 void ConstantShiftByExtInt(_ExtInt(28) Ext, _ExtInt(65) LargeExt) {
   // LIN: define void @_Z21ConstantShiftByExtIntU7_ExtIntILi28EEiU7_ExtIntILi65EEi
   // WIN: define dso_local void @"?ConstantShiftByExtInt@@YAXU?$_ExtInt@$0BM@@__clang@@U?$_ExtInt@$0EB@@2@@Z"
   10 << Ext;