[clang][bytecode] Refine diagnostics for volatile reads (#136857)

Differentiate between a volarile read via a lvalue-to-rvalue cast of a volatile qualified subexpression and a read from a pointer with a volatile base object.

Author: tbaederr

clang/lib/AST/ByteCode/Compiler.cpp

@@ -210,6 +210,9 @@ bool Compiler<Emitter>::VisitCastExpr(const CastExpr *CE) {
 
 switch (CE->getCastKind()) {
 case CK_LValueToRValue: {
+if (SubExpr->getType().isVolatileQualified())
+returnthis->emitInvalidCast(CastKind::Volatile, /*Fatal=*/true, CE);
+
  std::optional<PrimType> SubExprT = classify(SubExpr->getType());
 // Prepare storage for the result.
 if (!Initializing && !SubExprT) {

clang/lib/AST/ByteCode/Interp.cpp

@@ -641,11 +641,30 @@ static bool CheckVolatile(InterpState &S, CodePtr OpPC, const Pointer &Ptr,
 if (!PtrType.isVolatileQualified())
 returntrue;
 
-const SourceInfo &Loc = S.Current->getSource(OpPC);
-if (S.getLangOpts().CPlusPlus)
- S.FFDiag(Loc, diag::note_constexpr_access_volatile_type) << AK << PtrType;
-else
- S.FFDiag(Loc);
+if (!S.getLangOpts().CPlusPlus)
+returnInvalid(S, OpPC);
+
+const NamedDecl *ND = nullptr;
+int DiagKind;
+ SourceLocation Loc;
+if (constauto *F = Ptr.getField()) {
+ DiagKind = 2;
+ Loc = F->getLocation();
+ ND = F;
+ } elseif (auto *VD = Ptr.getFieldDesc()->asValueDecl()) {
+ DiagKind = 1;
+ Loc = VD->getLocation();
+ ND = VD;
+ } else {
+ DiagKind = 0;
+if (constauto *E = Ptr.getFieldDesc()->asExpr())
+ Loc = E->getExprLoc();
+ }
+
+ S.FFDiag(S.Current->getLocation(OpPC),
+ diag::note_constexpr_access_volatile_obj, 1)
+ << AK << DiagKind << ND;
+ S.Note(Loc, diag::note_constexpr_volatile_here) << DiagKind;
 returnfalse;
 }
 

clang/lib/AST/ByteCode/Interp.h

@@ -2885,12 +2885,22 @@ inline bool InvalidCast(InterpState &S, CodePtr OpPC, CastKind Kind,
 bool Fatal) {
 const SourceLocation &Loc = S.Current->getLocation(OpPC);
 
-// FIXME: Support diagnosing other invalid cast kinds.
 if (Kind == CastKind::Reinterpret) {
  S.CCEDiag(Loc, diag::note_constexpr_invalid_cast)
  << static_cast<unsigned>(Kind) << S.Current->getRange(OpPC);
 return !Fatal;
+ } elseif (Kind == CastKind::Volatile) {
+// FIXME: Technically not a cast.
+constauto *E = cast<CastExpr>(S.Current->getExpr(OpPC));
+if (S.getLangOpts().CPlusPlus)
+ S.FFDiag(E, diag::note_constexpr_access_volatile_type)
+ << AK_Read << E->getSubExpr()->getType();
+else
+ S.FFDiag(E);
+
+returnfalse;
  }
+
 returnfalse;
 }
 

clang/lib/AST/ByteCode/PrimType.h

@@ -55,16 +55,17 @@ inline constexpr bool isPtrType(PrimType T) {
 
 enumclassCastKind : uint8_t {
  Reinterpret,
-Atomic,
+Volatile,
 };
+
 inline llvm::raw_ostream &operator<<(llvm::raw_ostream &OS,
  interp::CastKind CK) {
 switch (CK) {
 case interp::CastKind::Reinterpret:
  OS << "reinterpret_cast";
 break;
-case interp::CastKind::Atomic:
- OS << "atomic";
+case interp::CastKind::Volatile:
+ OS << "volatile";
 break;
  }
 return OS;

clang/test/AST/ByteCode/literals.cpp

@@ -1357,6 +1357,22 @@ namespace VolatileReads {
 constvolatileint b = 1;
 static_assert(b, ""); // both-error {{not an integral constant expression}} \
  // both-note {{read of volatile-qualified type 'const volatile int' is not allowed in a constant expression}}
+
+
+constexprint a = 12;
+constexprvolatileint c = (volatileint&)a; // both-error {{must be initialized by a constant expression}} \
+ // both-note {{read of volatile-qualified type 'volatile int'}}
+
+volatileconstexprint n1 = 0; // both-note {{here}}
+volatileconstint n2 = 0; // both-note {{here}}
+constexprint m1 = n1; // both-error {{constant expression}} \
+ // both-note {{read of volatile-qualified type 'const volatile int'}}
+constexprint m2 = n2; // both-error {{constant expression}} \
+ // both-note {{read of volatile-qualified type 'const volatile int'}}
+constexprint m1b = const_cast<constint&>(n1); // both-error {{constant expression}} \
+ // both-note {{read of volatile object 'n1'}}
+constexprint m2b = const_cast<constint&>(n2); // both-error {{constant expression}} \
+ // both-note {{read of volatile object 'n2'}}
 }
 #if __cplusplus >= 201703L
 namespace {