Use poison instead of undef where its used as a placeholder [NFC]

[ManuelJBrito]

Summary

The following instances of undef are used as placeholders for aggregate construction so this patch intends to replace them with poison.

[nlopes]

LGTM

llvm/lib/Analysis/ValueTracking.cpp

 // insertvalue instruction somewhere).
 //
 // All inserted insertvalue instructions are inserted before InsertBefore
 static Value *BuildSubAggregate(Value *From, ArrayRef<unsigned> idx_range,
                                 Instruction *InsertBefore) {
   assert(InsertBefore && "Must have someplace to insert!");
   Type *IndexedType = ExtractValueInst::getIndexedType(From->getType(),
                                                              idx_range);
-  Value *To = UndefValue::get(IndexedType);
+  Value *To = PoisonValue::get(IndexedType);
   SmallVector<unsigned, 10> Idxs(idx_range.begin(), idx_range.end());
   unsigned IdxSkip = Idxs.size();
 
   return BuildSubAggregate(From, To, IndexedType, Idxs, IdxSkip, InsertBefore);
 }
 
 /// Given an aggregate and a sequence of indices, see if the scalar value
 /// indexed is already around as a register, for example if it was inserted

llvm/lib/CodeGen/SjLjEHPrepare.cpp

void SjLjEHPrepare::substituteLPadValues(LandingPadInst *LPI, Value *ExnVal,
   }
 
   if (LPI->use_empty())
     return;
 
   // There are still some uses of LPI. Construct an aggregate with the exception
   // values and replace the LPI with that aggregate.
   Type *LPadType = LPI->getType();
-  Value *LPadVal = UndefValue::get(LPadType);
+  Value *LPadVal = PoisonValue::get(LPadType);
   auto *SelI = cast<Instruction>(SelVal);
   IRBuilder<> Builder(SelI->getParent(), std::next(SelI->getIterator()));
   LPadVal = Builder.CreateInsertValue(LPadVal, ExnVal, 0, "lpad.val");
   LPadVal = Builder.CreateInsertValue(LPadVal, SelVal, 1, "lpad.val");
 
   LPI->replaceAllUsesWith(LPadVal);
 }
 

llvm/lib/Target/SPIRV/SPIRVPrepareFunctions.cpp

static void buildUMulWithOverflowFunc(Module *M, Function *UMulFunc) {
   // then overflow has happened.
   Value *Mul = IRB.CreateNUWMul(UMulFunc->getArg(0), UMulFunc->getArg(1));
   Value *Div = IRB.CreateUDiv(Mul, UMulFunc->getArg(0));
   Value *Overflow = IRB.CreateICmpNE(UMulFunc->getArg(0), Div);
 
   // umul.with.overflow intrinsic return a structure, where the first element
   // is the multiplication result, and the second is an overflow bit.
   Type *StructTy = UMulFunc->getReturnType();
-  Value *Agg = IRB.CreateInsertValue(UndefValue::get(StructTy), Mul, {0});
+  Value *Agg = IRB.CreateInsertValue(PoisonValue::get(StructTy), Mul, {0});
   Value *Res = IRB.CreateInsertValue(Agg, Overflow, {1});
   IRB.CreateRet(Res);
 }
 
 static void lowerUMulWithOverflow(Module *M, IntrinsicInst *UMulIntrinsic) {
   // Get a separate function - otherwise, we'd have to rework the CFG of the
   // current one. Then simply replace the intrinsic uses with a call to the new
   // function.

llvm/lib/Transforms/Instrumentation/ThreadSanitizer.cpp

if (LoadInst *LI = dyn_cast<LoadInst>(I)) {
     Value *Success = IRB.CreateICmpEQ(C, CmpOperand);
     Value *OldVal = C;
     if (Ty != OrigOldValTy) {
       // The value is a pointer, so we need to cast the return value.
       OldVal = IRB.CreateIntToPtr(C, OrigOldValTy);
     }
 
     Value *Res =
-      IRB.CreateInsertValue(UndefValue::get(CASI->getType()), OldVal, 0);
+      IRB.CreateInsertValue(PoisonValue::get(CASI->getType()), OldVal, 0);
     Res = IRB.CreateInsertValue(Res, Success, 1);
 
     I->replaceAllUsesWith(Res);
     I->eraseFromParent();
   } else if (FenceInst *FI = dyn_cast<FenceInst>(I)) {
     Value *Args[] = {createOrdering(&IRB, FI->getOrdering())};
     FunctionCallee F = FI->getSyncScopeID() == SyncScope::SingleThread
                            ? TsanAtomicSignalFence

llvm/test/Instrumentation/ThreadSanitizer/atomic.ll

entry:
   ret void
 }
 ; CHECK-LABEL: atomic64_cas_seq_cst
 ; CHECK: {{.*}} = ptrtoint ptr %v1 to i64
 ; CHECK-NEXT: {{.*}} = ptrtoint ptr %v2 to i64
 ; CHECK-NEXT: {{.*}} = call i64 @__tsan_atomic64_compare_exchange_val(ptr {{.*}}, i64 {{.*}}, i64 {{.*}}, i32 5, i32 5), !dbg
 ; CHECK-NEXT: {{.*}} = icmp eq i64
 ; CHECK-NEXT: {{.*}} = inttoptr i64 {{.*}} to ptr
-; CHECK-NEXT: {{.*}} = insertvalue { ptr, i1 } undef, ptr {{.*}}, 0
+; CHECK-NEXT: {{.*}} = insertvalue { ptr, i1 } poison, ptr {{.*}}, 0
 ; CHECK-NEXT: {{.*}} = insertvalue { ptr, i1 } {{.*}}, i1 {{.*}}, 1
 
 define i128 @atomic128_load_unordered(ptr %a) nounwind uwtable {
 entry:
   %0 = load atomic i128, ptr %a unordered, align 16, !dbg !7
   ret i128 %0, !dbg !7
 }
 ; CHECK-LABEL: atomic128_load_unordered