[FuzzMutate] Avoid zero sized aggregates

[igor-laevsky]

Summary

insertvalue/extractvalue instructions expect aggregate index to be in bounds. There is no way we can generate valid index for the zero sized aggregate. This changes excludes them from the set of available sources.

llvm/trunk/include/llvm/FuzzMutate/OpDescriptor.h

auto Make = [](ArrayRef<Value *>, ArrayRef<Type *> Ts) {
 
     return Result;
   };
   return {Pred, Make};
 }
 
 static inline SourcePred anyAggregateType() {
   auto Pred = [](ArrayRef<Value *>, const Value *V) {
+    // We can't index zero sized arrays.
+    if (isa<ArrayType>(V->getType()))
+      return V->getType()->getArrayNumElements() > 0;
+
+    // Structs can also be zero sized. I.e opaque types.
+    if (isa<StructType>(V->getType()))
+      return V->getType()->getStructNumElements() > 0;
+
     return V->getType()->isAggregateType();
   };
   // TODO: For now we only find aggregates in BaseTypes. It might be better to
   // manufacture them out of the base types in some cases.
   auto Find = None;
   return {Pred, Find};
 }
 

llvm/trunk/unittests/FuzzMutate/OperationsTest.cpp

TEST(OperationsTest, ExtractAndInsertValue) {
   LLVMContext Ctx;
 
   Type *Int8PtrTy = Type::getInt8PtrTy(Ctx);
   Type *Int32Ty = Type::getInt32Ty(Ctx);
   Type *Int64Ty = Type::getInt64Ty(Ctx);
 
   Type *StructTy = StructType::create(Ctx, {Int8PtrTy, Int32Ty});
   Type *OpaqueTy = StructType::create(Ctx, "OpaqueStruct");
+  Type *ZeroSizedArrayTy = ArrayType::get(Int64Ty, 0);
   Type *ArrayTy = ArrayType::get(Int64Ty, 4);
   Type *VectorTy = VectorType::get(Int32Ty, 2);
 
   auto EVOp = fuzzerop::extractValueDescriptor(1);
   auto IVOp = fuzzerop::insertValueDescriptor(1);
 
   // Sanity check the source preds.
   Constant *SVal = UndefValue::get(StructTy);
   Constant *OVal = UndefValue::get(OpaqueTy);
   Constant *AVal = UndefValue::get(ArrayTy);
+  Constant *ZAVal = UndefValue::get(ZeroSizedArrayTy);
   Constant *VVal = UndefValue::get(VectorTy);
 
   EXPECT_TRUE(EVOp.SourcePreds[0].matches({}, SVal));
-  EXPECT_TRUE(EVOp.SourcePreds[0].matches({}, OVal));
+  EXPECT_FALSE(EVOp.SourcePreds[0].matches({}, OVal));
   EXPECT_TRUE(EVOp.SourcePreds[0].matches({}, AVal));
   EXPECT_FALSE(EVOp.SourcePreds[0].matches({}, VVal));
   EXPECT_TRUE(IVOp.SourcePreds[0].matches({}, SVal));
-  EXPECT_TRUE(IVOp.SourcePreds[0].matches({}, OVal));
+  EXPECT_FALSE(IVOp.SourcePreds[0].matches({}, OVal));
   EXPECT_TRUE(IVOp.SourcePreds[0].matches({}, AVal));
   EXPECT_FALSE(IVOp.SourcePreds[0].matches({}, VVal));
 
+  // Don't consider zero sized arrays as viable sources
+  EXPECT_FALSE(EVOp.SourcePreds[0].matches({}, ZAVal));
+  EXPECT_FALSE(IVOp.SourcePreds[0].matches({}, ZAVal));
+
   // Make sure we're range checking appropriately.
   EXPECT_TRUE(
       EVOp.SourcePreds[1].matches({SVal}, ConstantInt::get(Int32Ty, 0)));
   EXPECT_TRUE(
       EVOp.SourcePreds[1].matches({SVal}, ConstantInt::get(Int32Ty, 1)));
   EXPECT_FALSE(
       EVOp.SourcePreds[1].matches({SVal}, ConstantInt::get(Int32Ty, 2)));
   EXPECT_FALSE(