[InstCombine] Don't unpack arrays that are too large

[davide]

Summary

https://reviews.llvm.org/D15890 introduces a transformation to unpack arrays. This unfortunately causes some fundamental compile time regression, so, let's set a limit on the max size of array we consider for unpacking. Fixes https://llvm.org/bugs/show_bug.cgi?id=30608

[davide]

Side note: I'm in general not a huge fan of threshold-based optimisations, but I wasn't able to think of a better solution for now.

[majnemer]

LGTM

[majnemer]

I think we need the same check in unpackStoreToAggregate

[davide]

In D25376#564886, @majnemer wrote:

I think we need the same check in unpackStoreToAggregate

Oh, sure. Submitting another patch soon.

llvm/trunk/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp

if (auto *AT = dyn_cast<ArrayType>(T)) {
     auto *ET = AT->getElementType();
     auto NumElements = AT->getNumElements();
     if (NumElements == 1) {
       LoadInst *NewLoad = combineLoadToNewType(IC, LI, ET, ".unpack");
       return IC.replaceInstUsesWith(LI, IC.Builder->CreateInsertValue(
         UndefValue::get(T), NewLoad, 0, Name));
     }
 
+    // Bail out if the array is too large. Ideally we would like to optimize
+    // arrays of arbitrary size but this has a terrible impact on compile time.
+    // The threshold here is chosen arbitrarily, maybe needs a little bit of
+    // tuning.
+    if (NumElements > 1024)
+      return nullptr;
+
     const DataLayout &DL = IC.getDataLayout();
     auto EltSize = DL.getTypeAllocSize(ET);
     auto Align = LI.getAlignment();
     if (!Align)
       Align = DL.getABITypeAlignment(T);
 
     auto *Addr = LI.getPointerOperand();
     auto *IdxType = Type::getInt64Ty(T->getContext());

llvm/trunk/test/Transforms/InstCombine/unpack-fca.ll

 ; CHECK-NEXT: [[LOAD4:%[a-z0-9\.]+]] = load i64, i64* [[GEP4]], align 8
 ; CHECK-NEXT: [[IV5:%[a-z0-9\.]+]] = insertvalue %B [[IV4]], i64 [[LOAD4]], 1
 ; CHECK-NEXT: [[IV6:%[a-z0-9\.]+]] = insertvalue [2 x %B] [[IV3]], %B [[IV5]], 1
 ; CHECK-NEXT: ret [2 x %B] [[IV6]]
   %1 = load [2 x %B], [2 x %B]* %ab.ptr, align 8
   ret [2 x %B] %1
 }
 
+define [2000 x %B] @loadLargeArrayOfB([2000 x %B]* %ab.ptr) {
+; CHECK-LABEL: loadLargeArrayOfB
+; CHECK-NEXT: load [2000 x %B], [2000 x %B]* %ab.ptr, align 8
+; CHECK-NEXT: ret [2000 x %B]
+  %1 = load [2000 x %B], [2000 x %B]* %ab.ptr, align 8
+  ret [2000 x %B] %1
+}
+
 %struct.S = type <{ i8, %struct.T }>
 %struct.T = type { i32, i32 }
 
 ; Make sure that we do not increase alignment of packed struct element
 define i32 @packed_alignment(%struct.S* dereferenceable(9) %s) {
 ; CHECK-LABEL: packed_alignment
 ; CHECK-NEXT: %tv.elt1 = getelementptr inbounds %struct.S, %struct.S* %s, i64 0, i32 1, i32 1
 ; CHECK-NEXT: %tv.unpack2 = load i32, i32* %tv.elt1, align 1