[Clang][CodeGen] Use poison instead of undef for dummy values in CGExpr [NFC]

[ManuelJBrito]

Summary

Replace the following uses of poison with undef where undef is used as a dummy value.

[nlopes]

LGTM, thank you!

[ManuelJBrito]

This comment was removed by ManuelJBrito.

[ManuelJBrito]

Fix demangle test

[ManuelJBrito]

Ping

[nikic]

The demangling test shouldn't be modified at all.

[ldionne]

Ping. This should be updated to avoid touching libcxxabi.

libcxxabi/test/test_demangle.pass.cpp

3172 ↗

(On Diff #485072)

This doesn't need to change at all. This is just a test for demangling symbols.

[ManuelJBrito]

Remove changes to demangle test

clang/lib/CodeGen/CGBuiltin.cpp

if (Value *V = EmitTargetBuiltinExpr(BuiltinID, E, ReturnValue)) {
     case TEK_Complex:
       llvm_unreachable("No current target builtin returns complex");
     }
     llvm_unreachable("Bad evaluation kind in EmitBuiltinExpr");
   }
 
   ErrorUnsupported(E, "builtin function");
 
-  // Unknown builtin, for now just dump it out and return undef.
-  return GetUndefRValue(E->getType());
+  // Unknown builtin, for now just dump it out and return poison.
+  return GetPoisonRValue(E->getType());
 }
 
 static Value *EmitTargetArchBuiltinExpr(CodeGenFunction *CGF,
                                         unsigned BuiltinID, const CallExpr *E,
                                         ReturnValueSlot ReturnValue,
                                         llvm::Triple::ArchType Arch) {
   switch (Arch) {
   case llvm::Triple::arm:

clang/lib/CodeGen/CGCall.cpp

if (CI->doesNotReturn()) {
     Builder.ClearInsertionPoint();
 
     // FIXME: For now, emit a dummy basic block because expr emitters in
     // generally are not ready to handle emitting expressions at unreachable
     // points.
     EnsureInsertPoint();
 
     // Return a reasonable RValue.
-    return GetUndefRValue(RetTy);
+    return GetPoisonRValue(RetTy);
   }
 
   // If this is a musttail call, return immediately. We do not branch to the
   // epilogue in this case.
   if (IsMustTail) {
     for (auto it = EHStack.find(CurrentCleanupScopeDepth); it != EHStack.end();
          ++it) {
       EHCleanupScope *Cleanup = dyn_cast<EHCleanupScope>(&*it);
       if (!(Cleanup && Cleanup->getCleanup()->isRedundantBeforeReturn()))
         CGM.ErrorUnsupported(MustTailCall, "tail call skipping over cleanups");
     }
     if (CI->getType()->isVoidTy())
       Builder.CreateRetVoid();
     else
       Builder.CreateRet(CI);
     Builder.ClearInsertionPoint();
     EnsureInsertPoint();
-    return GetUndefRValue(RetTy);
+    return GetPoisonRValue(RetTy);
   }
 
   // Perform the swifterror writeback.
   if (swiftErrorTemp.isValid()) {
     llvm::Value *errorResult = Builder.CreateLoad(swiftErrorTemp);
     Builder.CreateStore(errorResult, swiftErrorArg);
   }
 
case ABIArgInfo::Indirect: {
       if (UnusedReturnSizePtr)
         PopCleanupBlock();
       return ret;
     }
 
     case ABIArgInfo::Ignore:
       // If we are ignoring an argument that had a result, make sure to
       // construct the appropriate return value for our caller.
-      return GetUndefRValue(RetTy);
+      return GetPoisonRValue(RetTy);
 
     case ABIArgInfo::Extend:
     case ABIArgInfo::Direct: {
       llvm::Type *RetIRTy = ConvertType(RetTy);
       if (RetAI.getCoerceToType() == RetIRTy && RetAI.getDirectOffset() == 0) {
         switch (getEvaluationKind(RetTy)) {
         case TEK_Complex: {
           llvm::Value *Real = Builder.CreateExtractValue(CI, 0);

clang/lib/CodeGen/CGExpr.cpp

 
 llvm::Value *CodeGenFunction::EmitNonNullRValueCheck(RValue RV, QualType T) {
   llvm::Value *V = RV.getScalarVal();
   if (auto MPT = T->getAs<MemberPointerType>())
     return CGM.getCXXABI().EmitMemberPointerIsNotNull(*this, V, MPT);
   return Builder.CreateICmpNE(V, llvm::Constant::getNullValue(V->getType()));
 }
 
-RValue CodeGenFunction::GetUndefRValue(QualType Ty) {
+RValue CodeGenFunction::GetPoisonRValue(QualType Ty) {
   if (Ty->isVoidType())
     return RValue::get(nullptr);
 
   switch (getEvaluationKind(Ty)) {
   case TEK_Complex: {
     llvm::Type *EltTy =
       ConvertType(Ty->castAs<ComplexType>()->getElementType());
-    llvm::Value *U = llvm::UndefValue::get(EltTy);
+    llvm::Value *U = llvm::PoisonValue::get(EltTy);
     return RValue::getComplex(std::make_pair(U, U));
   }
 
   // If this is a use of an undefined aggregate type, the aggregate must have an
   // identifiable address.  Just because the contents of the value are undefined
   // doesn't mean that the address can't be taken and compared.
   case TEK_Aggregate: {
     Address DestPtr = CreateMemTemp(Ty, "undef.agg.tmp");
     return RValue::getAggregate(DestPtr);
   }
 
   case TEK_Scalar:
-    return RValue::get(llvm::UndefValue::get(ConvertType(Ty)));
+    return RValue::get(llvm::PoisonValue::get(ConvertType(Ty)));
   }
   llvm_unreachable("bad evaluation kind");
 }
 
 RValue CodeGenFunction::EmitUnsupportedRValue(const Expr *E,
                                               const char *Name) {
   ErrorUnsupported(E, Name);
-  return GetUndefRValue(E->getType());
+  return GetPoisonRValue(E->getType());
 }
 
 LValue CodeGenFunction::EmitUnsupportedLValue(const Expr *E,
                                               const char *Name) {
   ErrorUnsupported(E, Name);
   llvm::Type *ElTy = ConvertType(E->getType());
   llvm::Type *Ty = llvm::PointerType::getUnqual(ElTy);
   return MakeAddrLValue(
-      Address(llvm::UndefValue::get(Ty), ElTy, CharUnits::One()), E->getType());
+      Address(llvm::PoisonValue::get(Ty), ElTy, CharUnits::One()), E->getType());
 }
 
 bool CodeGenFunction::IsWrappedCXXThis(const Expr *Obj) {
   const Expr *Base = Obj;
   while (!isa<CXXThisExpr>(Base)) {
     // The result of a dynamic_cast can be null.
     if (isa<CXXDynamicCastExpr>(Base))
       return false;

clang/lib/CodeGen/CGExprComplex.cpp

 //===----------------------------------------------------------------------===//
 //                            Visitor Methods
 //===----------------------------------------------------------------------===//
 
 ComplexPairTy ComplexExprEmitter::VisitExpr(Expr *E) {
   CGF.ErrorUnsupported(E, "complex expression");
   llvm::Type *EltTy =
     CGF.ConvertType(getComplexType(E->getType())->getElementType());
-  llvm::Value *U = llvm::UndefValue::get(EltTy);
+  llvm::Value *U = llvm::PoisonValue::get(EltTy);
   return ComplexPairTy(U, U);
 }
 
 ComplexPairTy ComplexExprEmitter::
 VisitImaginaryLiteral(const ImaginaryLiteral *IL) {
   llvm::Value *Imag = CGF.EmitScalarExpr(IL->getSubExpr());
   return ComplexPairTy(llvm::Constant::getNullValue(Imag->getType()), Imag);
 }

 ComplexPairTy ComplexExprEmitter::VisitVAArgExpr(VAArgExpr *E) {
   Address ArgValue = Address::invalid();
   Address ArgPtr = CGF.EmitVAArg(E, ArgValue);
 
   if (!ArgPtr.isValid()) {
     CGF.ErrorUnsupported(E, "complex va_arg expression");
     llvm::Type *EltTy =
       CGF.ConvertType(E->getType()->castAs<ComplexType>()->getElementType());
-    llvm::Value *U = llvm::UndefValue::get(EltTy);
+    llvm::Value *U = llvm::PoisonValue::get(EltTy);
     return ComplexPairTy(U, U);
   }
 
   return EmitLoadOfLValue(CGF.MakeAddrLValue(ArgPtr, E->getType()),
                           E->getExprLoc());
 }
 
 //===----------------------------------------------------------------------===//

clang/lib/CodeGen/CGExprScalar.cpp

 //===----------------------------------------------------------------------===//
 //                            Visitor Methods
 //===----------------------------------------------------------------------===//
 
 Value *ScalarExprEmitter::VisitExpr(Expr *E) {
   CGF.ErrorUnsupported(E, "scalar expression");
   if (E->getType()->isVoidType())
     return nullptr;
-  return llvm::UndefValue::get(CGF.ConvertType(E->getType()));
+  return llvm::PoisonValue::get(CGF.ConvertType(E->getType()));
 }
 
 Value *
 ScalarExprEmitter::VisitSYCLUniqueStableNameExpr(SYCLUniqueStableNameExpr *E) {
   ASTContext &Context = CGF.getContext();
   unsigned AddrSpace =
       Context.getTargetAddressSpace(CGF.CGM.GetGlobalConstantAddressSpace());
   llvm::Constant *GlobalConstStr = Builder.CreateGlobalStringPtr(
Value *ScalarExprEmitter::VisitVAArgExpr(VAArgExpr *VE) {
   Address ArgValue = Address::invalid();
   Address ArgPtr = CGF.EmitVAArg(VE, ArgValue);
 
   llvm::Type *ArgTy = ConvertType(VE->getType());
 
   // If EmitVAArg fails, emit an error.
   if (!ArgPtr.isValid()) {
     CGF.ErrorUnsupported(VE, "va_arg expression");
-    return llvm::UndefValue::get(ArgTy);
+    return llvm::PoisonValue::get(ArgTy);
   }
 
   // FIXME Volatility.
   llvm::Value *Val = Builder.CreateLoad(ArgPtr);
 
   // If EmitVAArg promoted the type, we must truncate it.
   if (ArgTy != Val->getType()) {
     if (ArgTy->isPointerTy() && !Val->getType()->isPointerTy())

clang/lib/CodeGen/CodeGenFunction.h

public:
 
   //===--------------------------------------------------------------------===//
   //                         LValue Expression Emission
   //===--------------------------------------------------------------------===//
 
   /// Create a check that a scalar RValue is non-null.
   llvm::Value *EmitNonNullRValueCheck(RValue RV, QualType T);
 
-  /// GetUndefRValue - Get an appropriate 'undef' rvalue for the given type.
-  RValue GetUndefRValue(QualType Ty);
+  /// GetPoisonRValue - Get an appropriate 'poison' rvalue for the given type.
+  RValue GetPoisonRValue(QualType Ty);
 
   /// EmitUnsupportedRValue - Emit a dummy r-value using the type of E
   /// and issue an ErrorUnsupported style diagnostic (using the
   /// provided Name).
   RValue EmitUnsupportedRValue(const Expr *E,
                                const char *Name);
 
   /// EmitUnsupportedLValue - Emit a dummy l-value using the type of E and issue