[clang][Interp] Reject reinterpret_cast expressions

[tbaeder]

Summary

Add a new InvalidCast op for this purpose and emit a diagnostic.

[aaron.ballman]

clang/lib/AST/Interp/Interp.h

1761

Should this be doing the cast? The overloaded operator accepts an interp::CastKind already?

clang/lib/AST/Interp/PrimType.h

48

Should we bother adding this right now given it's not used or tested?

[tbaeder]

clang/lib/AST/Interp/Interp.h

1761

The streaming operator there is for our dump() support, and the note_constexpr_invalid_cast diagnostic needs an integer to select the right string.

clang/lib/AST/Interp/PrimType.h

48

No strong opinion from my side, I can definitely remove it.

[aaron.ballman]

LGTM with the Dynamic bit pulled.

clang/lib/AST/Interp/Interp.h

1761

Ah, that's right, this isn't calling the diagnostic streaming operator. Nevermind. :-)

clang/lib/AST/Interp/PrimType.h

48

Let's yank it for the moment.

[jplehr]

Hi,
this seems to have broken the OpenMP AMDGPU buildbot (https://lab.llvm.org/buildbot/#/builders/193/builds/35471)
I'm happy to help if needed.

[tbaeder]

Yeah sorry about that, but should already be fixed by https://github.com/llvm/llvm-project/commit/47446939e0e60cf52ffdd3fa671949ff3183a4c

[jplehr]

Wow, thanks for the quick fix!
[edit]: Buildbot green again [/edit]

[probinson]

clang/lib/AST/Interp/Interp.h

1761

Would you mind changing this cast from uint8_t to unsigned? We have an internal bot using a pickier mode of MSVC and it complains about ambiguous overloads, as the operator<< doesn't have anything smaller than int and unsigned.

[tbaeder]

clang/lib/AST/Interp/Interp.h

1761

Feel free to push that change, I'm currently working on something else.

[aaron.ballman]

clang/lib/AST/Interp/Interp.h

1761

Yeah, that's a perfectly reasonable NFC commit to make -- go for it!

[probinson]

clang/lib/AST/Interp/Interp.h

1761

https://github.com/llvm/llvm-project/commit/4e8cae4aec6590ca13ec65ed38d6da55c6031755

clang/lib/AST/Interp/ByteCodeExprGen.h

public:
   bool VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *E);
   bool VisitCXXBindTemporaryExpr(const CXXBindTemporaryExpr *E);
   bool VisitCXXTemporaryObjectExpr(const CXXTemporaryObjectExpr *E);
   bool VisitCompoundLiteralExpr(const CompoundLiteralExpr *E);
   bool VisitTypeTraitExpr(const TypeTraitExpr *E);
   bool VisitLambdaExpr(const LambdaExpr *E);
   bool VisitPredefinedExpr(const PredefinedExpr *E);
   bool VisitCXXThrowExpr(const CXXThrowExpr *E);
+  bool VisitCXXReinterpretCastExpr(const CXXReinterpretCastExpr *E);
 
 protected:
   bool visitExpr(const Expr *E) override;
   bool visitDecl(const VarDecl *VD) override;
 
 protected:
   /// Emits scope cleanup instructions.
   void emitCleanup();

clang/lib/AST/Interp/ByteCodeExprGen.cpp

 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitCXXThrowExpr(const CXXThrowExpr *E) {
   if (!this->discard(E->getSubExpr()))
     return false;
 
   return this->emitInvalid(E);
 }
 
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitCXXReinterpretCastExpr(
+    const CXXReinterpretCastExpr *E) {
+  if (!this->discard(E->getSubExpr()))
+    return false;
+
+  return this->emitInvalidCast(CastKind::Reinterpret, E);
+}
+
 template <class Emitter> bool ByteCodeExprGen<Emitter>::discard(const Expr *E) {
   if (E->containsErrors())
     return false;
 
   OptionScope<Emitter> Scope(this, /*NewDiscardResult=*/true);
   return this->Visit(E);
 }
 

clang/lib/AST/Interp/Disasm.cpp

LLVM_DUMP_METHOD void Program::dump(llvm::raw_ostream &OS) const {
   OS << "\n";
   for (auto &Func : Funcs) {
     Func.second->dump();
   }
   for (auto &Anon : AnonFuncs) {
     Anon->dump();
   }
 }
+
+llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, interp::CastKind CK) {
+  switch (CK) {
+  case interp::CastKind::Reinterpret:
+    OS << "reinterpret_cast";
+    break;
+  }
+  return OS;
+}

clang/lib/AST/Interp/Interp.h

 /// op is not valid in a constant context.
 inline bool Invalid(InterpState &S, CodePtr OpPC) {
   const SourceLocation &Loc = S.Current->getLocation(OpPC);
   S.FFDiag(Loc, diag::note_invalid_subexpr_in_const_expr)
       << S.Current->getRange(OpPC);
   return false;
 }
 
+/// Same here, but only for casts.
+inline bool InvalidCast(InterpState &S, CodePtr OpPC, CastKind Kind) {
+  const SourceLocation &Loc = S.Current->getLocation(OpPC);
+  S.FFDiag(Loc, diag::note_constexpr_invalid_cast)
+      << static_cast<uint8_t>(Kind) << S.Current->getRange(OpPC);
+  return false;
+}
+
 //===----------------------------------------------------------------------===//
 // Read opcode arguments
 //===----------------------------------------------------------------------===//
 
 template <typename T> inline T ReadArg(InterpState &S, CodePtr &OpPC) {
   if constexpr (std::is_pointer<T>::value) {
     uint32_t ID = OpPC.read<uint32_t>();
     return reinterpret_cast<T>(S.P.getNativePointer(ID));

clang/lib/AST/Interp/Opcodes.td

 def ArgBool : ArgType { let Name = "bool"; }
 
 def ArgFunction : ArgType { let Name = "const Function *"; }
 def ArgRecordDecl : ArgType { let Name = "const RecordDecl *"; }
 def ArgRecordField : ArgType { let Name = "const Record::Field *"; }
 def ArgFltSemantics : ArgType { let Name = "const llvm::fltSemantics *"; }
 def ArgRoundingMode : ArgType { let Name = "llvm::RoundingMode"; }
 def ArgLETD: ArgType { let Name = "const LifetimeExtendedTemporaryDecl *"; }
+def ArgCastKind : ArgType { let Name = "CastKind"; }
 
 //===----------------------------------------------------------------------===//
 // Classes of types instructions operate on.
 //===----------------------------------------------------------------------===//
 
 class TypeClass {
   list<Type> Types;
 }

 // [Value] -> [Value, Value]
 def Dup : Opcode {
   let Types = [AllTypeClass];
   let HasGroup = 1;
 }
 
 // [] -> []
 def Invalid : Opcode {}
+def InvalidCast : Opcode {
+  let Args = [ArgCastKind];
+}

clang/lib/AST/Interp/PrimType.h

 //===--- PrimType.h - Types for the constexpr VM --------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Defines the VM types and helpers operating on types.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_AST_INTERP_TYPE_H
 #define LLVM_CLANG_AST_INTERP_TYPE_H
 
+#include "llvm/Support/raw_ostream.h"
 #include <climits>
 #include <cstddef>
 #include <cstdint>
 
 namespace clang {
 namespace interp {
 
 class Pointer;
enum PrimType : unsigned {
   PT_Sint64,
   PT_Uint64,
   PT_Bool,
   PT_Float,
   PT_Ptr,
   PT_FnPtr,
 };
 
+enum class CastKind : uint8_t {
+  Reinterpret,
+};
+llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, interp::CastKind CK);
+
 constexpr bool isIntegralType(PrimType T) { return T <= PT_Uint64; }
 
 /// Mapping from primitive types to their representation.
 template <PrimType T> struct PrimConv;
 template <> struct PrimConv<PT_Sint8> { using T = Integral<8, true>; };
 template <> struct PrimConv<PT_Uint8> { using T = Integral<8, false>; };
 template <> struct PrimConv<PT_Sint16> { using T = Integral<16, true>; };
 template <> struct PrimConv<PT_Uint16> { using T = Integral<16, false>; };

clang/test/AST/Interp/unsupported.cpp

namespace Asm {
 
   constexpr int Asm() { // expected-error {{never produces a constant expression}} \
                         // ref-error {{never produces a constant expression}}
     __asm volatile(""); // expected-note {{subexpression not valid in a constant expression}} \
                         // ref-note {{subexpression not valid in a constant expression}}
     return 0;
   }
 }
+
+namespace Casts {
+  constexpr int a = reinterpret_cast<int>(12); // expected-error {{must be initialized by a constant expression}} \
+                                               // expected-note {{reinterpret_cast is not allowed}} \
+                                               // ref-error {{must be initialized by a constant expression}} \
+                                               // ref-note {{reinterpret_cast is not allowed}}
+
+}