Add support for one element array load in InstCombine

[deadalnix]

Summary

As per title

[majnemer]

LGTM

lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp

if (auto *ST = dyn_cast<StructType>(T)) {
     if (ST->getNumElements() == 1) {
       LoadInst *NewLoad = combineLoadToNewType(IC, LI, ST->getTypeAtIndex(0U),
                                                ".unpack");
       return IC.ReplaceInstUsesWith(LI, IC.Builder->CreateInsertValue(
         UndefValue::get(T), NewLoad, 0, LI.getName()));
     }
   }
 
+  if (auto *AT = dyn_cast<ArrayType>(T)) {
+    // If the array only have one element, we unpack.
+    if (AT->getNumElements() == 1) {
+      LoadInst *NewLoad = combineLoadToNewType(IC, LI, AT->getElementType(),
+                                               ".unpack");
+      return IC.ReplaceInstUsesWith(LI, IC.Builder->CreateInsertValue(
+        UndefValue::get(T), NewLoad, 0, LI.getName()));
+    }
+  }
+
   return nullptr;
 }
 
 // If we can determine that all possible objects pointed to by the provided
 // pointer value are, not only dereferenceable, but also definitively less than
 // or equal to the provided maximum size, then return true. Otherwise, return
 // false (constant global values and allocas fall into this category).
 //

test/Transforms/InstCombine/unpack-fca.ll

 ; CHECK-LABEL: loadStructOfA
 ; CHECK: load %A__vtbl*,
 ; CHECK: insertvalue %A undef, %A__vtbl* {{.*}}, 0
 ; CHECK: insertvalue { %A } undef, %A {{.*}}, 0
   %2 = load { %A }, { %A }* %1, align 8
   ret { %A } %2
 }
 
+define [1 x %A] @loadArrayOfA() {
+body:
+  %0 = tail call i8* @allocmemory(i64 32)
+  %1 = bitcast i8* %0 to [1 x %A]*
+; CHECK-LABEL: loadArrayOfA
+; CHECK: load %A__vtbl*,
+; CHECK: insertvalue %A undef, %A__vtbl* {{.*}}, 0
+; CHECK: insertvalue [1 x %A] undef, %A {{.*}}, 0
+  %2 = load [1 x %A], [1 x %A]* %1, align 8
+  ret [1 x %A] %2
+}
+
+define { [1 x %A] } @loadStructOfArrayOfA() {
+body:
+  %0 = tail call i8* @allocmemory(i64 32)
+  %1 = bitcast i8* %0 to { [1 x %A] }*
+; CHECK-LABEL: loadStructOfArrayOfA
+; CHECK: load %A__vtbl*,
+; CHECK: insertvalue %A undef, %A__vtbl* {{.*}}, 0
+; CHECK: insertvalue [1 x %A] undef, %A {{.*}}, 0
+; CHECK: insertvalue { [1 x %A] } undef, [1 x %A] {{.*}}, 0
+  %2 = load { [1 x %A] }, { [1 x %A] }* %1, align 8
+  ret { [1 x %A] } %2
+}
+
 define { %A } @structOfA() {
 body:
   %0 = tail call i8* @allocmemory(i64 32)
   %1 = bitcast i8* %0 to { %A }*
 ; CHECK-LABEL: structOfA
 ; CHECK: store %A__vtbl* @A__vtblZ
   store { %A } { %A { %A__vtbl* @A__vtblZ } }, { %A }* %1, align 8
   %2 = load { %A }, { %A }* %1, align 8
 ; CHECK-NOT: load
 ; CHECK: ret { %A } { %A { %A__vtbl* @A__vtblZ } }
   ret { %A } %2
 }