[clang][Interp] Implement IntegralToPointer casts

[tbaeder]

Summary

The pointers created through such a cast are not usable in a constant expression as far as I know, but we need to be able to express them. Do that via a Pointer with a nullptr pointee and an Offset that is the given integer.

[tbaeder]

clang/lib/AST/Interp/ByteCodeExprGen.cpp

189–193

This is a tiny hack to get the C test working.

[aaron.ballman]

I'd expect more test coverage for these changes. Like a C-style cast and a reinterpret_cast in C++ code

[shafik]

I agree with @aaron.ballman I expect some more tests for this.

clang/lib/AST/Interp/Pointer.h

70

Is the only cast we have a Pointer that is a nullptr but has an Offset is from a integral to pointer cast?

[tbaeder]

Note that according to https://clang.llvm.org/docs/ConstantInterpreter.html#pointers, such pointers had their own pointer type (TargetPointer), so I'm not sure if the approach here is the right one.

[tbaeder]

I've already abandoned this locally, pretty sure I'll end up taking another approach.

clang/lib/AST/Interp/ByteCodeExprGen.cpp

if (!ToT)
       return false;
 
     if (!this->visit(SubExpr))
       return false;
 
     return this->emitCastFloatingIntegral(*ToT, RM, CE);
   }
 
+  case CK_NullToPointer:
+  case CK_IntegralToPointer: {
+    if (isa<CXXNullPtrLiteralExpr>(SubExpr))
+      return this->visit(SubExpr);
+
+    if (!this->visit(SubExpr))
+      return false;
+
+    return this->emitCastIntegralPointer(classifyPrim(SubExpr->getType()), CE);
+  }
+
   case CK_ArrayToPointerDecay:
   case CK_AtomicToNonAtomic:
   case CK_ConstructorConversion:
   case CK_FunctionToPointerDecay:
   case CK_NonAtomicToAtomic:
   case CK_NoOp:
   case CK_UserDefinedConversion:
-  case CK_NullToPointer:
     return this->visit(SubExpr);
 
   case CK_IntegralToBoolean:
+    // == in C
+    if (const auto *BOP = dyn_cast<BinaryOperator>(SubExpr);
+        BOP && BOP->isEqualityOp())
+      return this->visit(SubExpr);
+    [[fallthrough]];
   case CK_IntegralCast: {
     Optional<PrimType> FromT = classify(SubExpr->getType());
     Optional<PrimType> ToT = classify(CE->getType());
     if (!FromT || !ToT)
       return false;
 
     if (!this->visit(SubExpr))
       return false;

clang/lib/AST/Interp/Interp.h

if constexpr (std::is_same_v<T, Boolean>) {
     }
 
     S.Stk.push<T>(T(Result));
   }
 
   return CheckFloatResult(S, OpPC, Status);
 }
 
+template <PrimType Name, class T = typename PrimConv<Name>::T>
+bool CastIntegralPointer(InterpState &S, CodePtr OpPC) {
+  const T &Src = S.Stk.pop<T>();
+  S.Stk.push<Pointer>(Pointer(static_cast<unsigned>(Src)));
+  return true;
+}
+
 //===----------------------------------------------------------------------===//
 // Zero, Nullptr
 //===----------------------------------------------------------------------===//
 
 template <PrimType Name, class T = typename PrimConv<Name>::T>
 bool Zero(InterpState &S, CodePtr OpPC) {
   S.Stk.push<T>(T::zero());
   return true;

clang/lib/AST/Interp/Opcodes.td

 
 // Cast a floating to an integer type
 def CastFloatingIntegral : Opcode {
   let Types = [AluTypeClass];
   let Args = [ArgRoundingMode];
   let HasGroup = 1;
 }
 
+def CastIntegralPointer : Opcode {
+  let Types = [AluTypeClass];
+  let HasGroup = 1;
+}
+
 //===----------------------------------------------------------------------===//
 // Comparison opcodes.
 //===----------------------------------------------------------------------===//
 
 class EqualityOpcode : Opcode {
   let Types = [AllTypeClass];
   let HasGroup = 1;
 }

clang/lib/AST/Interp/Pointer.h

 private:
   static constexpr unsigned PastEndMark = (unsigned)-1;
   static constexpr unsigned RootPtrMark = (unsigned)-1;
 
 public:
   Pointer() {}
   Pointer(Block *B);
   Pointer(Block *B, unsigned BaseAndOffset);
+  Pointer(unsigned Offset);
   Pointer(const Pointer &P);
   Pointer(Pointer &&P);
   ~Pointer();
 
   void operator=(const Pointer &P);
   void operator=(Pointer &&P);
 
   /// Converts the pointer to an APValue.
   APValue toAPValue() const;
 
   /// Offsets a pointer inside an array.
   Pointer atIndex(unsigned Idx) const {
+    if (!Pointee)
+      return Pointer(nullptr, 0, Offset + Idx);
     if (Base == RootPtrMark)
       return Pointer(Pointee, RootPtrMark, getDeclDesc()->getSize());
     unsigned Off = Idx * elemSize();
     if (getFieldDesc()->ElemDesc)
       Off += sizeof(InlineDescriptor);
     else
       Off += sizeof(InitMap *);
     return Pointer(Pointee, Base, Base + Off);
Pointer expand() const {
     unsigned Next = Base - getInlineDesc()->Offset;
     Descriptor *Desc = Next == 0 ? getDeclDesc() : getDescriptor(Next)->Desc;
     if (!Desc->IsArray)
       return *this;
     return Pointer(Pointee, Next, Offset);
   }
 
   /// Checks if the pointer is null.
-  bool isZero() const { return Pointee == nullptr; }
+  bool isZero() const { return Pointee == nullptr && Offset == 0; }
   /// Checks if the pointer is live.
   bool isLive() const { return Pointee && !Pointee->IsDead; }
   /// Checks if the item is a field in an object.
   bool isField() const { return Base != 0 && Base != RootPtrMark; }
 
   /// Accessor for information about the declaration site.
-  Descriptor *getDeclDesc() const { return Pointee->Desc; }
+  Descriptor *getDeclDesc() const {
+    assert(Pointee);
+    return Pointee->Desc;
+  }
   SourceLocation getDeclLoc() const { return getDeclDesc()->getLocation(); }
 
   /// Returns a pointer to the object of which this pointer is a field.
   Pointer getBase() const {
     if (Base == RootPtrMark) {
       assert(Offset == PastEndMark && "cannot get base of a block");
       return Pointer(Pointee, Base, 0);
     }
public:
 
   /// Whether this array refers to an array, but not
   /// to the first element.
   bool isArrayRoot() const {
     return inArray() && Offset == Base;
   }
 
   /// Checks if the innermost field is an array.
-  bool inArray() const { return getFieldDesc()->IsArray; }
+  bool inArray() const { return Pointee ? getFieldDesc()->IsArray : false; }
   /// Checks if the structure is a primitive array.
   bool inPrimitiveArray() const { return getFieldDesc()->isPrimitiveArray(); }
   /// Checks if the structure is an array of unknown size.
   bool isUnknownSizeArray() const {
-    return getFieldDesc()->isUnknownSizeArray();
+    return Pointee ? getFieldDesc()->isUnknownSizeArray() : false;
   }
   /// Checks if the pointer points to an array.
   bool isArrayElement() const { return Base != Offset; }
   /// Pointer points directly to a block.
   bool isRoot() const {
     return (Base == 0 || Base == RootPtrMark) && Offset == 0;
   }
 
public:
   llvm::Optional<unsigned> getDeclID() const { return Pointee->getDeclID(); }
 
   /// Returns the byte offset from the start.
   unsigned getByteOffset() const {
     return Offset;
   }
 
   /// Returns the number of elements.
-  unsigned getNumElems() const { return getSize() / elemSize(); }
+  unsigned getNumElems() const {
+    if (Pointee)
+      return getSize() / elemSize();
+
+    return std::numeric_limits<unsigned>::max();
+  }
 
   Block *block() const { return Pointee; }
 
   /// Returns the index into an array.
   int64_t getIndex() const {
+    if (!Pointee)
+      return 0;
+
     if (isElementPastEnd())
       return 1;
     if (auto ElemSize = elemSize())
       return getOffset() / ElemSize;
     return 0;
   }
 
   /// Checks if the index is one past end.
   bool isOnePastEnd() const {
     return isElementPastEnd() || getSize() == getOffset();
   }
 
   /// Checks if the pointer is an out-of-bounds element pointer.
-  bool isElementPastEnd() const { return Offset == PastEndMark; }
+  bool isElementPastEnd() const { return Pointee && Offset == PastEndMark; }
 
   /// Dereferences the pointer, if it's live.
   template <typename T> T &deref() const {
     assert(isLive() && "Invalid pointer");
     if (isArrayRoot())
       return *reinterpret_cast<T *>(Pointee->rawData() + Base + sizeof(InitMap*));
 
     return *reinterpret_cast<T *>(Pointee->rawData() + Offset);

clang/lib/AST/Interp/Pointer.cpp

 using namespace clang;
 using namespace clang::interp;
 
 Pointer::Pointer(Block *Pointee) : Pointer(Pointee, 0, 0) {}
 
 Pointer::Pointer(Block *Pointee, unsigned BaseAndOffset)
     : Pointer(Pointee, BaseAndOffset, BaseAndOffset) {}
 
+Pointer::Pointer(unsigned Offset) : Pointer(nullptr, 0, Offset) {}
+
 Pointer::Pointer(const Pointer &P) : Pointer(P.Pointee, P.Base, P.Offset) {}
 
 Pointer::Pointer(Pointer &&P)
     : Pointee(P.Pointee), Base(P.Base), Offset(P.Offset) {
   if (Pointee)
     Pointee->movePointer(&P, this);
 }
 

clang/test/Sema/const-eval-64.c

 // RUN: %clang_cc1 -fsyntax-only -verify -triple x86_64-linux %s
+// RUN: %clang_cc1 -fsyntax-only -verify -triple x86_64-linux -fexperimental-new-constant-interpreter %s
 
 #define EVAL_EXPR(testno, expr) int test##testno = sizeof(struct{char qq[expr];});
 
 // <rdar://problem/10962435>
 EVAL_EXPR(1, ((char*)-1LL) + 1 == 0 ? 1 : -1) // expected-warning {{folded}}
 EVAL_EXPR(2, ((char*)-1LL) + 1 < (char*) -1 ? 1 : -1) // expected-warning {{folded}}