[clang][Interp] Check This pointer without creating InterpFrame

[tbaeder]

Summary

The InterpFrame was only created so early so we could use getThis().
However, we need to know the Function when creating the InterpFrame and
in the case of virtual functions, we need to determine what function to
call at interpretation time.

Get the This pointer ourselves and just create the InterpFrame later.

This is of course in preparation for virtual function calls.

[tbaeder]

Ping

[tbaeder]

Ping

[aaron.ballman]

clang/lib/AST/Interp/InterpStack.h

75–77

Ooofda, this only differs from peek() on line 97 because this function has a templated return type, but otherwise the signatures only differ based on return type. This doesn't feel like the most clean overload set...

Also, should this be worrying about alignment of T compared to the offset we find it at? (Should there be an assert that the offset is sensible for a T?)

[tbaeder]

Added an aligned() assertion and renamed the old peek(unsigned Offset) returning a void* to peekData(), so both peek overloads are now public member functions.

[aaron.ballman]

LGTM!

[shafik]

LGTM

clang/lib/AST/Interp/Interp.h

 }
 
 inline bool CheckGlobalCtor(InterpState &S, CodePtr &PC) {
   const Pointer &Obj = S.Stk.peek<Pointer>();
   return CheckCtorCall(S, PC, Obj);
 }
 
 inline bool Call(InterpState &S, CodePtr &PC, const Function *Func) {
-  auto NewFrame = std::make_unique<InterpFrame>(S, Func, PC);
-  Pointer ThisPtr;
   if (Func->hasThisPointer()) {
-    ThisPtr = NewFrame->getThis();
+    size_t ThisOffset =
+        Func->getArgSize() + (Func->hasRVO() ? primSize(PT_Ptr) : 0);
+    const Pointer &ThisPtr = S.Stk.peek<Pointer>(ThisOffset);
+
     if (!CheckInvoke(S, PC, ThisPtr))
       return false;
 
     if (S.checkingPotentialConstantExpression())
       return false;
   }
 
   if (!CheckCallable(S, PC, Func))
     return false;
 
+  auto NewFrame = std::make_unique<InterpFrame>(S, Func, PC);
   InterpFrame *FrameBefore = S.Current;
   S.Current = NewFrame.get();
 
   APValue CallResult;
   // Note that we cannot assert(CallResult.hasValue()) here since
   // Ret() above only sets the APValue if the curent frame doesn't
   // have a caller set.
   if (Interpret(S, CallResult)) {

clang/lib/AST/Interp/InterpStack.h

 #endif
     auto *Ptr = &peek<T>();
     Ptr->~T();
     shrink(aligned_size<T>());
   }
 
   /// Returns a reference to the value on the top of the stack.
   template <typename T> T &peek() const {
-    return *reinterpret_cast<T *>(peek(aligned_size<T>()));
+    return *reinterpret_cast<T *>(peekData(aligned_size<T>()));
+  }
+
+  template <typename T> T &peek(size_t Offset) const {
+    assert(aligned(Offset));
+    return *reinterpret_cast<T *>(peekData(Offset));
   }
 
   /// Returns a pointer to the top object.
-  void *top() const { return Chunk ? peek(0) : nullptr; }
+  void *top() const { return Chunk ? peekData(0) : nullptr; }
 
   /// Returns the size of the stack in bytes.
   size_t size() const { return StackSize; }
 
   /// Clears the stack without calling any destructors.
   void clear();
 
   // Returns whether the stack is empty.
   bool empty() const { return StackSize == 0; }
 
 private:
   /// All stack slots are aligned to the native pointer alignment for storage.
   /// The size of an object is rounded up to a pointer alignment multiple.
   template <typename T> constexpr size_t aligned_size() const {
     constexpr size_t PtrAlign = alignof(void *);
     return ((sizeof(T) + PtrAlign - 1) / PtrAlign) * PtrAlign;
   }
 
   /// Grows the stack to accommodate a value and returns a pointer to it.
   void *grow(size_t Size);
   /// Returns a pointer from the top of the stack.
-  void *peek(size_t Size) const;
+  void *peekData(size_t Size) const;
   /// Shrinks the stack.
   void shrink(size_t Size);
 
   /// Allocate stack space in 1Mb chunks.
   static constexpr size_t ChunkSize = 1024 * 1024;
 
   /// Metadata for each stack chunk.
   ///

clang/lib/AST/Interp/InterpStack.cpp

void *InterpStack::grow(size_t Size) {
   }
 
   auto *Object = reinterpret_cast<void *>(Chunk->End);
   Chunk->End += Size;
   StackSize += Size;
   return Object;
 }
 
-void *InterpStack::peek(size_t Size) const {
+void *InterpStack::peekData(size_t Size) const {
   assert(Chunk && "Stack is empty!");
 
   StackChunk *Ptr = Chunk;
   while (Size > Ptr->size()) {
     Size -= Ptr->size();
     Ptr = Ptr->Prev;
     assert(Ptr && "Offset too large");
   }