[Draft] [clang] Add builtin_unspecified_value

[aqjune]

Summary

This patch adds a builtin constant that lowers to freeze(poison).
This is necessary to patch the intrinsics like e.g., mm256_castsi128_si256 to be lowered to the following sequence:

%a1 = freeze <2 x double> poison // <- would like to represent this as '__builtin_unspecified_value' in C/C++.
%res = shufflevector <2 x double> %a0, <2 x double> %a1, <4 x i32> <i32 0, i32 1, i32 2, i32 3>

Currently it is being lowered to:

%res = shufflevector <2x  double> %a0, undef, <4 x i32> <i32 0, i32 1, i32 -1, i32 -1>

The current lowering may incorrectly introduce undefined behavior.

A related, previous patch was here: https://reviews.llvm.org/D130339

[aqjune]

The updates are analogous to how GNUNullExprClass is processed because UnspecifiedValueExprClass and it is similar (have no operand).

[erichkeane]

It doesn't really make sense to me why this is an AST node expr-node-type rather than just being a call to a builtin (that'll likely need to take a var as a parameter)? We can make that builtin result in a freeze/poison value if necessary.

So something like:
_si128 x = __builtin_magic_unspecified(x);

[erichkeane]

Also, as discussed with @aaron.ballman, 'unspecified' has VERY specific meaning in C/C++, and you don't seem to mean that here.

[aaron.ballman]

It looks like this is missing parsing logic and test cases.

clang/include/clang-c/Index.h

1534–1539

I'm not certain we want to expose this via the C APIs. Those APIs are stable APIs and this is exposing an LLVM IR implementation detail (in an area that's traditionally been rather unclear and actively worked on in LLVM IR). I don't know that we're ready to commit to never changing the behavior from LLVM's side.

clang/include/clang/AST/Expr.h

4637–4639

I don't think we should be using unspecified for the terms here -- that has a specific meaning which is not modeled by freeze(poison).

3.19.3
unspecified value
valid value of the relevant type where this document imposes no requirements on which value is chosen in any instance

specifically, freeze causes us to return the same value every time and the interesting property about unspecified values is that each read may give you a different value regardless of whether there's an intervening store (so it's sort of like volatile in that regard).

(FWIW, I think exposing a builtin for generating actually unspecified values [where you get a different value on every execution] would be a more compelling builtin for general use.)

4647

This is incorrect -- you should be calling computeDependence() and implementing the correct logic there. For example, consider calling this builtin on a (partially) dependent type -- we don't want to say the value has no dependence given that we don't know what type it has, right?

clang/lib/Sema/TreeTransform.h

11725

@erichkeane -- is this correct, or does work need to be done to instantiate the underlying type if the expression is dependent?

[erichkeane]

clang/lib/Sema/TreeTransform.h

11725

No, a transform on the type does need to happen.

[aqjune]

Closing this as D142388 added a function that can be used instead

clang/include/clang-c/Index.h

enum CXCursorKind {
    */
   CXCursor_ConceptSpecializationExpr = 153,
 
   /**
    * Expression that references a C++20 concept.
    */
   CXCursor_RequiresExpr = 154,
 
-  CXCursor_LastExpr = CXCursor_RequiresExpr,
+  /**
+   * A clang-builtin of unspecified value.
+   */
+  CXCursor_UnspecifiedValueExpr = 155,
+
+  CXCursor_LastExpr = CXCursor_UnspecifiedValueExpr,
 
   /* Statements */
   CXCursor_FirstStmt = 200,
   /**
    * A statement whose specific kind is not exposed via this
    * interface.
    *
    * Unexposed statements have the same operations as any other kind of

clang/include/clang/AST/Expr.h

public:
   child_range children() {
     return child_range(child_iterator(), child_iterator());
   }
   const_child_range children() const {
     return const_child_range(const_child_iterator(), const_child_iterator());
   }
 };
 
+/// UnspecifiedValueExpr - clang-specific value __builtin_unspecified_value.
+/// This AST node represents freeze(poison) in LLVM IR.
+class UnspecifiedValueExpr : public Expr {
+  /// TokenLoc - The location of the __builtin_specified_value keyword.
+  SourceLocation TokenLoc;
+
+public:
+  UnspecifiedValueExpr(QualType Ty, SourceLocation Loc)
+      : Expr(UnspecifiedValueExprClass, Ty, VK_PRValue, OK_Ordinary),
+        TokenLoc(Loc) {
+    setDependence(ExprDependence::None);
+  }
+
+  /// Build an empty GNU __null expression.
+  explicit UnspecifiedValueExpr(EmptyShell Empty) :
+      Expr(UnspecifiedValueExprClass, Empty) { }
+
+  /// getTokenLocation - The location of the __null token.
+  SourceLocation getTokenLocation() const { return TokenLoc; }
+  void setTokenLocation(SourceLocation L) { TokenLoc = L; }
+
+  SourceLocation getBeginLoc() const LLVM_READONLY { return TokenLoc; }
+  SourceLocation getEndLoc() const LLVM_READONLY { return TokenLoc; }
+
+  static bool classof(const Stmt *T) {
+    return T->getStmtClass() == UnspecifiedValueExprClass;
+  }
+
+  // Iterators
+  child_range children() {
+    return child_range(child_iterator(), child_iterator());
+  }
+  const_child_range children() const {
+    return const_child_range(const_child_iterator(), const_child_iterator());
+  }
+};
+
 /// Represents a call to the builtin function \c __builtin_va_arg.
 class VAArgExpr : public Expr {
   Stmt *Val;
   llvm::PointerIntPair<TypeSourceInfo *, 1, bool> TInfo;
   SourceLocation BuiltinLoc, RParenLoc;
 public:
   VAArgExpr(SourceLocation BLoc, Expr *e, TypeSourceInfo *TInfo,
             SourceLocation RPLoc, QualType t, bool IsMS)

clang/include/clang/AST/RecursiveASTVisitor.h

 DEF_TRAVERSE_STMT(SYCLUniqueStableNameExpr, {
   TRY_TO(TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc()));
 })
 DEF_TRAVERSE_STMT(PredefinedExpr, {})
 DEF_TRAVERSE_STMT(ShuffleVectorExpr, {})
 DEF_TRAVERSE_STMT(ConvertVectorExpr, {})
 DEF_TRAVERSE_STMT(StmtExpr, {})
 DEF_TRAVERSE_STMT(SourceLocExpr, {})
+DEF_TRAVERSE_STMT(UnspecifiedValueExpr, {})
 
 DEF_TRAVERSE_STMT(UnresolvedLookupExpr, {
   TRY_TO(TraverseNestedNameSpecifierLoc(S->getQualifierLoc()));
   if (S->hasExplicitTemplateArgs()) {
     TRY_TO(TraverseTemplateArgumentLocsHelper(S->getTemplateArgs(),
                                               S->getNumTemplateArgs()));
   }
 })

clang/include/clang/Basic/StmtNodes.td

 // Clang Extensions.
 def ShuffleVectorExpr : StmtNode<Expr>;
 def ConvertVectorExpr : StmtNode<Expr>;
 def BlockExpr : StmtNode<Expr>;
 def OpaqueValueExpr : StmtNode<Expr>;
 def TypoExpr : StmtNode<Expr>;
 def RecoveryExpr : StmtNode<Expr>;
 def BuiltinBitCastExpr : StmtNode<ExplicitCastExpr>;
+def UnspecifiedValueExpr : StmtNode<Expr>;
 
 // Microsoft Extensions.
 def MSPropertyRefExpr : StmtNode<Expr>;
 def MSPropertySubscriptExpr : StmtNode<Expr>;
 def CXXUuidofExpr : StmtNode<Expr>;
 def SEHTryStmt : StmtNode<Stmt>;
 def SEHExceptStmt : StmtNode<Stmt>;
 def SEHFinallyStmt : StmtNode<Stmt>;

clang/include/clang/Serialization/ASTBitCodes.h

enum StmtCode {
   EXPR_STMT,
 
   /// A ChooseExpr record.
   EXPR_CHOOSE,
 
   /// A GNUNullExpr record.
   EXPR_GNU_NULL,
 
+  // An UnspecifiedValueExpr record.
+  EXPR_UNSPECIFIED_VALUE,
+
   /// A SourceLocExpr record.
   EXPR_SOURCE_LOC,
 
   /// A ShuffleVectorExpr record.
   EXPR_SHUFFLE_VECTOR,
 
   /// A ConvertVectorExpr record.
   EXPR_CONVERT_VECTOR,

clang/lib/AST/ASTImporter.cpp

public:
 
     // Importing expressions
     ExpectedStmt VisitExpr(Expr *E);
     ExpectedStmt VisitSourceLocExpr(SourceLocExpr *E);
     ExpectedStmt VisitVAArgExpr(VAArgExpr *E);
     ExpectedStmt VisitChooseExpr(ChooseExpr *E);
     ExpectedStmt VisitShuffleVectorExpr(ShuffleVectorExpr *E);
     ExpectedStmt VisitGNUNullExpr(GNUNullExpr *E);
+    ExpectedStmt VisitUnspecifiedValueExpr(UnspecifiedValueExpr *E);
     ExpectedStmt VisitGenericSelectionExpr(GenericSelectionExpr *E);
     ExpectedStmt VisitPredefinedExpr(PredefinedExpr *E);
     ExpectedStmt VisitDeclRefExpr(DeclRefExpr *E);
     ExpectedStmt VisitImplicitValueInitExpr(ImplicitValueInitExpr *E);
     ExpectedStmt VisitDesignatedInitExpr(DesignatedInitExpr *E);
     ExpectedStmt VisitCXXNullPtrLiteralExpr(CXXNullPtrLiteralExpr *E);
     ExpectedStmt VisitIntegerLiteral(IntegerLiteral *E);
     ExpectedStmt VisitFloatingLiteral(FloatingLiteral *E);
ExpectedStmt ASTNodeImporter::VisitGNUNullExpr(GNUNullExpr *E) {
 
   ExpectedSLoc BeginLocOrErr = import(E->getBeginLoc());
   if (!BeginLocOrErr)
     return BeginLocOrErr.takeError();
 
   return new (Importer.getToContext()) GNUNullExpr(*TypeOrErr, *BeginLocOrErr);
 }
 
+ExpectedStmt ASTNodeImporter::VisitUnspecifiedValueExpr(
+    UnspecifiedValueExpr *E) {
+  ExpectedType TypeOrErr = import(E->getType());
+  if (!TypeOrErr)
+    return TypeOrErr.takeError();
+
+  ExpectedSLoc BeginLocOrErr = import(E->getBeginLoc());
+  if (!BeginLocOrErr)
+    return BeginLocOrErr.takeError();
+
+  return new (Importer.getToContext()) UnspecifiedValueExpr(*TypeOrErr,
+                                                            *BeginLocOrErr);
+}
+
 ExpectedStmt
 ASTNodeImporter::VisitGenericSelectionExpr(GenericSelectionExpr *E) {
   Error Err = Error::success();
   auto ToGenericLoc = importChecked(Err, E->getGenericLoc());
   auto *ToControllingExpr = importChecked(Err, E->getControllingExpr());
   auto ToDefaultLoc = importChecked(Err, E->getDefaultLoc());
   auto ToRParenLoc = importChecked(Err, E->getRParenLoc());
   if (Err)

clang/lib/AST/Expr.cpp

bool Expr::HasSideEffects(const ASTContext &Ctx,
   case ArrayInitLoopExprClass:
   case ParenListExprClass:
   case CXXPseudoDestructorExprClass:
   case CXXRewrittenBinaryOperatorClass:
   case CXXStdInitializerListExprClass:
   case SubstNonTypeTemplateParmExprClass:
   case MaterializeTemporaryExprClass:
   case ShuffleVectorExprClass:
+  case UnspecifiedValueExprClass:
   case ConvertVectorExprClass:
   case AsTypeExprClass:
     // These have a side-effect if any subexpression does.
     break;
 
   case UnaryOperatorClass:
     if (cast<UnaryOperator>(this)->isIncrementDecrementOp())
       return true;

clang/lib/AST/ExprClassification.cpp

#include "clang/AST/StmtNodes.inc"
   case Expr::CXXNewExprClass:
   case Expr::CXXThisExprClass:
   case Expr::CXXNullPtrLiteralExprClass:
   case Expr::ImaginaryLiteralClass:
   case Expr::GNUNullExprClass:
   case Expr::OffsetOfExprClass:
   case Expr::CXXThrowExprClass:
   case Expr::ShuffleVectorExprClass:
+  case Expr::UnspecifiedValueExprClass:
   case Expr::ConvertVectorExprClass:
   case Expr::IntegerLiteralClass:
   case Expr::FixedPointLiteralClass:
   case Expr::CharacterLiteralClass:
   case Expr::AddrLabelExprClass:
   case Expr::CXXDeleteExprClass:
   case Expr::ImplicitValueInitExprClass:
   case Expr::BlockExprClass:

clang/lib/AST/StmtPrinter.cpp

void StmtPrinter::VisitChooseExpr(ChooseExpr *Node) {
   PrintExpr(Node->getRHS());
   OS << ")";
 }
 
 void StmtPrinter::VisitGNUNullExpr(GNUNullExpr *) {
   OS << "__null";
 }
 
+void StmtPrinter::VisitUnspecifiedValueExpr(UnspecifiedValueExpr *) {
+  OS << "__builtin_unspecified_value";
+}
+
 void StmtPrinter::VisitShuffleVectorExpr(ShuffleVectorExpr *Node) {
   OS << "__builtin_shufflevector(";
   for (unsigned i = 0, e = Node->getNumSubExprs(); i != e; ++i) {
     if (i) OS << ", ";
     PrintExpr(Node->getExpr(i));
   }
   OS << ")";
 }

clang/lib/AST/StmtProfile.cpp

 void StmtProfiler::VisitChooseExpr(const ChooseExpr *S) {
   VisitExpr(S);
 }
 
 void StmtProfiler::VisitGNUNullExpr(const GNUNullExpr *S) {
   VisitExpr(S);
 }
 
+void StmtProfiler::VisitUnspecifiedValueExpr(const UnspecifiedValueExpr *S) {
+  VisitExpr(S);
+}
+
 void StmtProfiler::VisitVAArgExpr(const VAArgExpr *S) {
   VisitExpr(S);
 }
 
 void StmtProfiler::VisitInitListExpr(const InitListExpr *S) {
   if (S->getSyntacticForm()) {
     VisitInitListExpr(S->getSyntacticForm());
     return;

clang/lib/Sema/SemaExceptionSpec.cpp

CanThrowResult Sema::canThrow(const Stmt *S) {
   case Expr::ObjCBoolLiteralExprClass:
   case Expr::OpaqueValueExprClass:
   case Expr::PredefinedExprClass:
   case Expr::SizeOfPackExprClass:
   case Expr::StringLiteralClass:
   case Expr::SourceLocExprClass:
   case Expr::ConceptSpecializationExprClass:
   case Expr::RequiresExprClass:
+  case Expr::UnspecifiedValueExprClass:
     // These expressions can never throw.
     return CT_Cannot;
 
   case Expr::MSPropertyRefExprClass:
   case Expr::MSPropertySubscriptExprClass:
     llvm_unreachable("Invalid class for expression");
 
     // Most statements can throw if any substatement can throw.

clang/lib/Sema/TreeTransform.h

 template<typename Derived>
 ExprResult
 TreeTransform<Derived>::TransformGNUNullExpr(GNUNullExpr *E) {
   return E;
 }
 
 template<typename Derived>
 ExprResult
+TreeTransform<Derived>::TransformUnspecifiedValueExpr(UnspecifiedValueExpr *E) {
+  return E;
+}
+
+template<typename Derived>
+ExprResult
 TreeTransform<Derived>::TransformCXXOperatorCallExpr(CXXOperatorCallExpr *E) {
   switch (E->getOperator()) {
   case OO_New:
   case OO_Delete:
   case OO_Array_New:
   case OO_Array_Delete:
     llvm_unreachable("new and delete operators cannot use CXXOperatorCallExpr");
 

clang/lib/Serialization/ASTReaderStmt.cpp

void ASTStmtReader::VisitChooseExpr(ChooseExpr *E) {
   E->setIsConditionTrue(Record.readInt());
 }
 
 void ASTStmtReader::VisitGNUNullExpr(GNUNullExpr *E) {
   VisitExpr(E);
   E->setTokenLocation(readSourceLocation());
 }
 
+void ASTStmtReader::VisitUnspecifiedValueExpr(UnspecifiedValueExpr *E) {
+  VisitExpr(E);
+  E->setTokenLocation(readSourceLocation());
+}
+
 void ASTStmtReader::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
   VisitExpr(E);
   SmallVector<Expr *, 16> Exprs;
   unsigned NumExprs = Record.readInt();
   while (NumExprs--)
     Exprs.push_back(Record.readSubExpr());
   E->setExprs(Record.getContext(), Exprs);
   E->setBuiltinLoc(readSourceLocation());
while (true) {
     case EXPR_CHOOSE:
       S = new (Context) ChooseExpr(Empty);
       break;
 
     case EXPR_GNU_NULL:
       S = new (Context) GNUNullExpr(Empty);
       break;
 
+    case EXPR_UNSPECIFIED_VALUE:
+      S = new (Context) UnspecifiedValueExpr(Empty);
+      break;
+
     case EXPR_SHUFFLE_VECTOR:
       S = new (Context) ShuffleVectorExpr(Empty);
       break;
 
     case EXPR_CONVERT_VECTOR:
       S = new (Context) ConvertVectorExpr(Empty);
       break;
 

clang/lib/Serialization/ASTWriterStmt.cpp

 }
 
 void ASTStmtWriter::VisitGNUNullExpr(GNUNullExpr *E) {
   VisitExpr(E);
   Record.AddSourceLocation(E->getTokenLocation());
   Code = serialization::EXPR_GNU_NULL;
 }
 
+void ASTStmtWriter::VisitUnspecifiedValueExpr(UnspecifiedValueExpr *E) {
+  VisitExpr(E);
+  Record.AddSourceLocation(E->getTokenLocation());
+  Code = serialization::EXPR_UNSPECIFIED_VALUE;
+}
+
 void ASTStmtWriter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) {
   VisitExpr(E);
   Record.push_back(E->getNumSubExprs());
   for (unsigned I = 0, N = E->getNumSubExprs(); I != N; ++I)
     Record.AddStmt(E->getExpr(I));
   Record.AddSourceLocation(E->getBuiltinLoc());
   Record.AddSourceLocation(E->getRParenLoc());
   Code = serialization::EXPR_SHUFFLE_VECTOR;

clang/lib/StaticAnalyzer/Core/ExprEngine.cpp

switch (S->getStmtClass()) {
     case Stmt::ObjCAtTryStmtClass:
     case Stmt::ObjCAutoreleasePoolStmtClass:
     case Stmt::ObjCEncodeExprClass:
     case Stmt::ObjCIsaExprClass:
     case Stmt::ObjCProtocolExprClass:
     case Stmt::ObjCSelectorExprClass:
     case Stmt::ParenListExprClass:
     case Stmt::ShuffleVectorExprClass:
+    case Stmt::UnspecifiedValueExprClass:
     case Stmt::ConvertVectorExprClass:
     case Stmt::VAArgExprClass:
     case Stmt::CUDAKernelCallExprClass:
     case Stmt::OpaqueValueExprClass:
     case Stmt::AsTypeExprClass:
     case Stmt::ConceptSpecializationExprClass:
     case Stmt::CXXRewrittenBinaryOperatorClass:
     case Stmt::RequiresExprClass:

clang/tools/libclang/CXCursor.cpp

CXCursor cxcursor::MakeCXCursor(const Stmt *S, const Decl *Parent,
   case Stmt::GenericSelectionExprClass:
     K = CXCursor_GenericSelectionExpr;
     break;
 
   case Stmt::GNUNullExprClass:
     K = CXCursor_GNUNullExpr;
     break;
 
+  case Stmt::UnspecifiedValueExprClass:
+    K = CXCursor_UnspecifiedValueExpr;
+    break;
+
   case Stmt::CXXStaticCastExprClass:
     K = CXCursor_CXXStaticCastExpr;
     break;
 
   case Stmt::CXXDynamicCastExprClass:
     K = CXCursor_CXXDynamicCastExpr;
     break;