[CodeGen] Use poison instead of undef as placeholder in AtomicExpandPass [NFC]

[ManuelJBrito]

Summary

Replacing instances of undef with poison, where it is used as a placeholder for struct construction.

[nlopes]

Manuel: there are quite a few test cases failing in the build bots: https://lab.llvm.org/buildbot/#/builders/16/builds/38352

[thakis]

This breaks tests everywhere: http://45.33.8.238/linux/92107/step_12.txt

Please take a look and revert for now if it takes a while to fix.

[ManuelJBrito]

Sorry, I overlooked a bunch of tests. Can you revert please @nlopes?

[ManuelJBrito]

Reopening with the fixed tests

[ManuelJBrito]

Fixed tests

llvm/lib/CodeGen/AtomicExpandPass.cpp

bool AtomicExpand::expandPartwordCmpXchg(AtomicCmpXchgInst *CI) {
 
   // Add the second value to the phi from above
   Loaded_MaskOut->addIncoming(OldVal_MaskOut, FailureBB);
 
   // partword.cmpxchg.end:
   Builder.SetInsertPoint(CI);
 
   Value *FinalOldVal = extractMaskedValue(Builder, OldVal, PMV);
-  Value *Res = UndefValue::get(CI->getType());
+  Value *Res = PoisonValue::get(CI->getType());
   Res = Builder.CreateInsertValue(Res, FinalOldVal, 0);
   Res = Builder.CreateInsertValue(Res, Success, 1);
 
   CI->replaceAllUsesWith(Res);
   CI->eraseFromParent();
   return true;
 }
 
Value *CmpVal_Shifted = Builder.CreateShl(
       "CmpVal_Shifted");
   Value *NewVal_Shifted = Builder.CreateShl(
       Builder.CreateZExt(CI->getNewValOperand(), PMV.WordType), PMV.ShiftAmt,
       "NewVal_Shifted");
   Value *OldVal = TLI->emitMaskedAtomicCmpXchgIntrinsic(
       Builder, CI, PMV.AlignedAddr, CmpVal_Shifted, NewVal_Shifted, PMV.Mask,
       CI->getMergedOrdering());
   Value *FinalOldVal = extractMaskedValue(Builder, OldVal, PMV);
-  Value *Res = UndefValue::get(CI->getType());
+  Value *Res = PoisonValue::get(CI->getType());
   Res = Builder.CreateInsertValue(Res, FinalOldVal, 0);
   Value *Success = Builder.CreateICmpEQ(
       CmpVal_Shifted, Builder.CreateAnd(OldVal, PMV.Mask), "Success");
   Res = Builder.CreateInsertValue(Res, Success, 1);
 
   CI->replaceAllUsesWith(Res);
   CI->eraseFromParent();
 }
AtomicExpand::convertCmpXchgToIntegerType(AtomicCmpXchgInst *CI) {
   NewCI->setWeak(CI->isWeak());
   LLVM_DEBUG(dbgs() << "Replaced " << *CI << " with " << *NewCI << "\n");
 
   Value *OldVal = Builder.CreateExtractValue(NewCI, 0);
   Value *Succ = Builder.CreateExtractValue(NewCI, 1);
 
   OldVal = Builder.CreateIntToPtr(OldVal, CI->getCompareOperand()->getType());
 
-  Value *Res = UndefValue::get(CI->getType());
+  Value *Res = PoisonValue::get(CI->getType());
   Res = Builder.CreateInsertValue(Res, OldVal, 0);
   Res = Builder.CreateInsertValue(Res, Succ, 1);
 
   CI->replaceAllUsesWith(Res);
   CI->eraseFromParent();
   return NewCI;
 }
 
bool AtomicExpand::expandAtomicCmpXchg(AtomicCmpXchgInst *CI) {
   // We can remove the instructions now we're no longer iterating through them.
   for (auto *EV : PrunedInsts)
     EV->eraseFromParent();
 
   if (!CI->use_empty()) {
     // Some use of the full struct return that we don't understand has happened,
     // so we've got to reconstruct it properly.
     Value *Res;
-    Res = Builder.CreateInsertValue(UndefValue::get(CI->getType()), Loaded, 0);
+    Res = Builder.CreateInsertValue(PoisonValue::get(CI->getType()), Loaded, 0);
     Res = Builder.CreateInsertValue(Res, Success, 1);
 
     CI->replaceAllUsesWith(Res);
   }
 
   CI->eraseFromParent();
   return true;
 }
bool AtomicExpand::expandAtomicOpToLibcall(
   // And then, extract the results...
   if (ValueOperand && !UseSizedLibcall)
     Builder.CreateLifetimeEnd(AllocaValue_i8, SizeVal64);
 
   if (CASExpected) {
     // The final result from the CAS is {load of 'expected' alloca, bool result
     // from call}
     Type *FinalResultTy = I->getType();
-    Value *V = UndefValue::get(FinalResultTy);
+    Value *V = PoisonValue::get(FinalResultTy);
     Value *ExpectedOut = Builder.CreateAlignedLoad(
         CASExpected->getType(), AllocaCASExpected, AllocaAlignment);
     Builder.CreateLifetimeEnd(AllocaCASExpected_i8, SizeVal64);
     V = Builder.CreateInsertValue(V, ExpectedOut, 0);
     V = Builder.CreateInsertValue(V, Result, 1);
     I->replaceAllUsesWith(V);
   } else if (HasResult) {
     Value *V;

llvm/test/Transforms/AtomicExpand/X86/expand-atomic-non-integer.ll

 define void @pointer_cmpxchg_expand(i8** %ptr, i8* %v) {
 ; CHECK-LABEL: @pointer_cmpxchg_expand
 ; CHECK: %1 = bitcast i8** %ptr to i64*
 ; CHECK: %2 = ptrtoint i8* %v to i64
 ; CHECK: %3 = cmpxchg i64* %1, i64 0, i64 %2 seq_cst monotonic
 ; CHECK: %4 = extractvalue { i64, i1 } %3, 0
 ; CHECK: %5 = extractvalue { i64, i1 } %3, 1
 ; CHECK: %6 = inttoptr i64 %4 to i8*
-; CHECK: %7 = insertvalue { i8*, i1 } undef, i8* %6, 0
+; CHECK: %7 = insertvalue { i8*, i1 } poison, i8* %6, 0
 ; CHECK: %8 = insertvalue { i8*, i1 } %7, i1 %5, 1
   cmpxchg i8** %ptr, i8* null, i8* %v seq_cst monotonic
   ret void
 }
 
 define void @pointer_cmpxchg_expand2(i8** %ptr, i8* %v) {
 ; CHECK-LABEL: @pointer_cmpxchg_expand2
 ; CHECK: %1 = bitcast i8** %ptr to i64*
 ; CHECK: %2 = ptrtoint i8* %v to i64
 ; CHECK: %3 = cmpxchg i64* %1, i64 0, i64 %2 release monotonic
 ; CHECK: %4 = extractvalue { i64, i1 } %3, 0
 ; CHECK: %5 = extractvalue { i64, i1 } %3, 1
 ; CHECK: %6 = inttoptr i64 %4 to i8*
-; CHECK: %7 = insertvalue { i8*, i1 } undef, i8* %6, 0
+; CHECK: %7 = insertvalue { i8*, i1 } poison, i8* %6, 0
 ; CHECK: %8 = insertvalue { i8*, i1 } %7, i1 %5, 1
   cmpxchg i8** %ptr, i8* null, i8* %v release monotonic
   ret void
 }
 
 define void @pointer_cmpxchg_expand3(i8** %ptr, i8* %v) {
 ; CHECK-LABEL: @pointer_cmpxchg_expand3
 ; CHECK: %1 = bitcast i8** %ptr to i64*
 ; CHECK: %2 = ptrtoint i8* %v to i64
 ; CHECK: %3 = cmpxchg i64* %1, i64 0, i64 %2 seq_cst seq_cst
 ; CHECK: %4 = extractvalue { i64, i1 } %3, 0
 ; CHECK: %5 = extractvalue { i64, i1 } %3, 1
 ; CHECK: %6 = inttoptr i64 %4 to i8*
-; CHECK: %7 = insertvalue { i8*, i1 } undef, i8* %6, 0
+; CHECK: %7 = insertvalue { i8*, i1 } poison, i8* %6, 0
 ; CHECK: %8 = insertvalue { i8*, i1 } %7, i1 %5, 1
   cmpxchg i8** %ptr, i8* null, i8* %v seq_cst seq_cst
   ret void
 }
 
 define void @pointer_cmpxchg_expand4(i8** %ptr, i8* %v) {
 ; CHECK-LABEL: @pointer_cmpxchg_expand4
 ; CHECK: %1 = bitcast i8** %ptr to i64*
 ; CHECK: %2 = ptrtoint i8* %v to i64
 ; CHECK: %3 = cmpxchg weak i64* %1, i64 0, i64 %2 seq_cst seq_cst
 ; CHECK: %4 = extractvalue { i64, i1 } %3, 0
 ; CHECK: %5 = extractvalue { i64, i1 } %3, 1
 ; CHECK: %6 = inttoptr i64 %4 to i8*
-; CHECK: %7 = insertvalue { i8*, i1 } undef, i8* %6, 0
+; CHECK: %7 = insertvalue { i8*, i1 } poison, i8* %6, 0
 ; CHECK: %8 = insertvalue { i8*, i1 } %7, i1 %5, 1
   cmpxchg weak i8** %ptr, i8* null, i8* %v seq_cst seq_cst
   ret void
 }
 
 define void @pointer_cmpxchg_expand5(i8** %ptr, i8* %v) {
 ; CHECK-LABEL: @pointer_cmpxchg_expand5
 ; CHECK: %1 = bitcast i8** %ptr to i64*
 ; CHECK: %2 = ptrtoint i8* %v to i64
 ; CHECK: %3 = cmpxchg volatile i64* %1, i64 0, i64 %2 seq_cst seq_cst
 ; CHECK: %4 = extractvalue { i64, i1 } %3, 0
 ; CHECK: %5 = extractvalue { i64, i1 } %3, 1
 ; CHECK: %6 = inttoptr i64 %4 to i8*
-; CHECK: %7 = insertvalue { i8*, i1 } undef, i8* %6, 0
+; CHECK: %7 = insertvalue { i8*, i1 } poison, i8* %6, 0
 ; CHECK: %8 = insertvalue { i8*, i1 } %7, i1 %5, 1
   cmpxchg volatile i8** %ptr, i8* null, i8* %v seq_cst seq_cst
   ret void
 }
 
 define void @pointer_cmpxchg_expand6(i8 addrspace(2)* addrspace(1)* %ptr, 
                                      i8 addrspace(2)* %v) {
 ; CHECK-LABEL: @pointer_cmpxchg_expand6
 ; CHECK: %1 = bitcast i8 addrspace(2)* addrspace(1)* %ptr to i64 addrspace(1)*
 ; CHECK: %2 = ptrtoint i8 addrspace(2)* %v to i64
 ; CHECK: %3 = cmpxchg i64 addrspace(1)* %1, i64 0, i64 %2 seq_cst seq_cst
 ; CHECK: %4 = extractvalue { i64, i1 } %3, 0
 ; CHECK: %5 = extractvalue { i64, i1 } %3, 1
 ; CHECK: %6 = inttoptr i64 %4 to i8 addrspace(2)*
-; CHECK: %7 = insertvalue { i8 addrspace(2)*, i1 } undef, i8 addrspace(2)* %6, 0
+; CHECK: %7 = insertvalue { i8 addrspace(2)*, i1 } poison, i8 addrspace(2)* %6, 0
 ; CHECK: %8 = insertvalue { i8 addrspace(2)*, i1 } %7, i1 %5, 1
   cmpxchg i8 addrspace(2)* addrspace(1)* %ptr, i8 addrspace(2)* null, i8 addrspace(2)* %v seq_cst seq_cst
   ret void
 }