[clang][Interp] Handle global composite temporaries

[tbaeder]

Summary

We only did this for primitive temporaries.

Unfortunately, the existing Pointer::toAPValue() won't do here, since
we're expected to set an rvalue on the LifetimeExtendedTemporaryDecl.

[tbaeder]

Thinking about this some more, the new Pointer::toRValue() is probably just the same thing we're already doing in EvalEmitter::emtiRetValue().

[tbaeder]

Ping

[tbaeder]

Ping

[tbaeder]

Ping

[tbaeder]

Ping

[tbaeder]

Ping

[tbaeder]

Ping

[tbaeder]

Ping

[tbaeder]

Ping

[shafik]

I think it mostly makes sense but I want Aaron to also look at it.

clang/lib/AST/Interp/Pointer.cpp

10

Are all these headers really needed for the change below?

[tbaeder]

clang/lib/AST/Interp/Pointer.cpp

10

We access .toAPValue() on all of them in the TYPE_SWITCH below, so yes.

[tbaeder]

Ping

[tbaeder]

Ping

[tbaeder]

Ping

[tbaeder]

Ping

[tbaeder]

Ping

[tbaeder]

Ping

[tbaeder]

Ping

[aaron.ballman]

clang/lib/AST/Interp/ByteCodeExprGen.cpp

852

Should this still happen even if TempDecl is null? It looks like getLifetimeExtendedTemporaryDecl() can return a null pointer, but perhaps there's a reason we can't get that result here?

clang/lib/AST/Interp/Pointer.cpp

235–237

Pointer to a field? That means, I would like tests that involve bit-fields. :-)

236

241

clang/lib/AST/Interp/Record.h

90

It might make sense to add an assert to both getBase() functions to verify that I is within a valid range.

[tbaeder]

clang/lib/AST/Interp/ByteCodeExprGen.cpp

852

AFAIK it never returns null if the storage duration is SD_Static, but that's just based on what I was seeing. Could add an assertion to be sure.

clang/lib/AST/Interp/Pointer.cpp

236

const Pointer & instead? :)

[aaron.ballman]

LGTM!

clang/lib/AST/Interp/ByteCodeExprGen.cpp

bool ByteCodeExprGen<Emitter>::VisitMaterializeTemporaryExpr(
   std::optional<PrimType> SubExprT = classify(SubExpr);
 
   if (E->getStorageDuration() == SD_Static) {
     std::optional<unsigned> GlobalIndex = P.createGlobal(E);
 
     if (!GlobalIndex)
       return false;
 
+    const LifetimeExtendedTemporaryDecl *TempDecl =
+        E->getLifetimeExtendedTemporaryDecl();
+
     if (SubExprT) {
       if (!this->visitInitializer(SubExpr))
         return false;
-
-      const LifetimeExtendedTemporaryDecl *TempDecl =
-          E->getLifetimeExtendedTemporaryDecl();
       if (!this->emitInitGlobalTemp(*SubExprT, *GlobalIndex, TempDecl, E))
         return false;
       return this->emitGetPtrGlobal(*GlobalIndex, E);
     }
 
     // Non-primitive values.
     if (!this->emitGetPtrGlobal(*GlobalIndex, E))
       return false;
-    return this->visitInitializer(SubExpr);
+    if (!this->visitInitializer(SubExpr))
+      return false;
+    return this->emitInitGlobalTempComp(TempDecl, E);
   }
 
   // For everyhing else, use local variables.
   if (SubExprT) {
     if (std::optional<unsigned> LocalIndex = allocateLocalPrimitive(
             SubExpr, *SubExprT, /*IsMutable=*/true, /*IsExtended=*/true)) {
       if (!this->visitInitializer(SubExpr))
         return false;

clang/lib/AST/Interp/Descriptor.h

public:
   /// Checks if the descriptor is of an array of unknown size.
   bool isUnknownSizeArray() const { return Size == UnknownSizeMark; }
 
   /// Checks if the descriptor is of a primitive.
   bool isPrimitive() const { return !IsArray && !ElemRecord; }
 
   /// Checks if the descriptor is of an array.
   bool isArray() const { return IsArray; }
+  /// Checks if the descriptor is of a record.
+  bool isRecord() const { return !IsArray && ElemRecord; }
 };
 
 /// Bitfield tracking the initialisation status of elements of primitive arrays.
 /// A pointer to this is embedded at the end of all primitive arrays.
 /// If the map was not yet created and nothing was initialized, the pointer to
 /// this structure is 0. If the object was fully initialized, the pointer is -1.
 struct InitMap final {
 private:

clang/lib/AST/Interp/Interp.h

bool InitGlobalTemp(InterpState &S, CodePtr OpPC, uint32_t I,
   APValue APV = Value.toAPValue();
   APValue *Cached = Temp->getOrCreateValue(true);
   *Cached = APV;
 
   S.P.getGlobal(I)->deref<T>() = S.Stk.pop<T>();
   return true;
 }
 
+/// 1) Converts the value on top of the stack to an APValue
+/// 2) Sets that APValue on \Temp
+/// 3) Initialized global with index \I with that
+inline bool InitGlobalTempComp(InterpState &S, CodePtr OpPC,
+                               const LifetimeExtendedTemporaryDecl *Temp) {
+  assert(Temp);
+  const Pointer &P = S.Stk.peek<Pointer>();
+  APValue *Cached = Temp->getOrCreateValue(true);
+
+  *Cached = P.toRValue(S.getCtx());
+  return true;
+}
+
 template <PrimType Name, class T = typename PrimConv<Name>::T>
 bool InitThisField(InterpState &S, CodePtr OpPC, uint32_t I) {
   if (S.checkingPotentialConstantExpression())
     return false;
   const Pointer &This = S.Current->getThis();
   if (!CheckThis(S, OpPC, This))
     return false;
   const Pointer &Field = This.atField(I);

clang/lib/AST/Interp/Opcodes.td

 // [] -> [Value]
 def GetGlobal : AccessOpcode;
 // [Value] -> []
 def InitGlobal : AccessOpcode;
 // [Value] -> []
 def InitGlobalTemp : AccessOpcode {
   let Args = [ArgUint32, ArgLETD];
 }
+// [Pointer] -> [Pointer]
+def InitGlobalTempComp : Opcode {
+  let Args = [ArgLETD];
+  let Types = [];
+  let HasGroup = 0;
+}
 // [Value] -> []
 def SetGlobal : AccessOpcode;
 
 // [] -> [Value]
 def GetParam : AccessOpcode;
 // [Value] -> []
 def SetParam : AccessOpcode;
 

clang/lib/AST/Interp/Pointer.h

 #include "llvm/ADT/PointerUnion.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace clang {
 namespace interp {
 class Block;
 class DeadBlock;
 class Pointer;
+class Context;
 enum PrimType : unsigned;
 
 /// A pointer to a memory block, live or dead.
 ///
 /// This object can be allocated into interpreter stack frames. If pointing to
 /// a live block, it is a link in the chain of pointers pointing to the block.
 ///
 /// In the simplest form, a Pointer has a Block* (the pointee) and both Base
public:
   ~Pointer();
 
   void operator=(const Pointer &P);
   void operator=(Pointer &&P);
 
   /// Converts the pointer to an APValue.
   APValue toAPValue() const;
 
+  /// Converts the pointer to an APValue that is an rvalue.
+  APValue toRValue(const Context &Ctx) 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)

clang/lib/AST/Interp/Pointer.cpp

 //===--- Pointer.cpp - 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "Pointer.h"
+#include "Boolean.h"
+#include "Context.h"
+#include "Floating.h"
 #include "Function.h"
+#include "Integral.h"
 #include "InterpBlock.h"
 #include "PrimType.h"
+#include "Record.h"
 
 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) {}

 
 bool Pointer::hasSameBase(const Pointer &A, const Pointer &B) {
   return A.Pointee == B.Pointee;
 }
 
 bool Pointer::hasSameArray(const Pointer &A, const Pointer &B) {
   return hasSameBase(A, B) && A.Base == B.Base && A.getFieldDesc()->IsArray;
 }
+
+APValue Pointer::toRValue(const Context &Ctx) const {
+  // Primitives.
+  if (getFieldDesc()->isPrimitive()) {
+    PrimType PT = *Ctx.classify(getType());
+    TYPE_SWITCH(PT, return deref<T>().toAPValue());
+    llvm_unreachable("Unhandled PrimType?");
+  }
+
+  APValue Result;
+  // Records.
+  if (getFieldDesc()->isRecord()) {
+    const Record *R = getRecord();
+    Result =
+        APValue(APValue::UninitStruct(), R->getNumBases(), R->getNumFields());
+
+    for (unsigned I = 0; I != R->getNumFields(); ++I) {
+      const Pointer FieldPtr = this->atField(R->getField(I)->Offset);
+      Result.getStructField(I) = FieldPtr.toRValue(Ctx);
+    }
+
+    for (unsigned I = 0; I != R->getNumBases(); ++I) {
+      const Pointer BasePtr = this->atField(R->getBase(I)->Offset);
+      Result.getStructBase(I) = BasePtr.toRValue(Ctx);
+    }
+  }
+
+  // TODO: Arrays
+
+  return Result;
+}

clang/lib/AST/Interp/Record.h

public:
   Field *getField(unsigned I) { return &Fields[I]; }
 
   using const_base_iter = BaseList::const_iterator;
   llvm::iterator_range<const_base_iter> bases() const {
     return llvm::make_range(Bases.begin(), Bases.end());
   }
 
   unsigned getNumBases() const { return Bases.size(); }
+  const Base *getBase(unsigned I) const { return &Bases[I]; }
   Base *getBase(unsigned I) { return &Bases[I]; }
 
   using const_virtual_iter = VirtualBaseList::const_iterator;
   llvm::iterator_range<const_virtual_iter> virtual_bases() const {
     return llvm::make_range(VirtualBases.begin(), VirtualBases.end());
   }
 
   unsigned getNumVirtualBases() const { return VirtualBases.size(); }

clang/test/AST/Interp/records.cpp

 constexpr C c;
 static_assert(c.a == 100, "");
 static_assert(c.b == 200, "");
 
 constexpr C c2 = C().get();
 static_assert(c.a == 100, "");
 static_assert(c.b == 200, "");
 
+
+constexpr const C &c3 = C().get();
+
 constexpr int getB() {
   C c;
   int &j = c.b;
 
   j = j * 2;
 
   return c.b;
 }