[clang][Interp] Fix passing parameters of composite type

[tbaeder]

Summary

We pass these as pointers, so we need to be careful not to emit pointers
to pointers when we emit visit DeclRefExprs pointing to parameters.

[shafik]

clang/lib/AST/Interp/ByteCodeEmitter.h

72

I don't understand the additional comment,

clang/lib/AST/Interp/Context.cpp

30 ↗

(On Diff #534187)

left over debugging code?

56 ↗

(On Diff #534187)

Left over debugging code?

[tbaeder]

clang/lib/AST/Interp/ByteCodeEmitter.h

72

It's supposed to be the types of the map, but I've removed the comment change locally.

clang/lib/AST/Interp/Context.cpp

30 ↗

(On Diff #534187)

Yes

56 ↗

(On Diff #534187)

Yes

[aaron.ballman]

LGTM with debugging code removed and comments cleaned up.

clang/lib/AST/Interp/ByteCodeEmitter.h

protected:
   bool jumpFalse(const LabelTy &Label);
   bool jump(const LabelTy &Label);
   bool fallthrough(const LabelTy &Label);
 
   /// Callback for local registration.
   Local createLocal(Descriptor *D);
 
   /// Parameter indices.
-  llvm::DenseMap<const ParmVarDecl *, unsigned> Params;
+  llvm::DenseMap<const ParmVarDecl *, ParamOffset> Params;
   /// Lambda captures.
-  /// Map from Decl* to [Offset, IsReference] pair.
-  llvm::DenseMap<const ValueDecl *, std::pair<unsigned, bool>> LambdaCaptures;
+  llvm::DenseMap<const ValueDecl *, ParamOffset> LambdaCaptures;
   unsigned LambdaThisCapture;
   /// Local descriptors.
   llvm::SmallVector<SmallVector<Local, 8>, 2> Descriptors;
 
 private:
   /// Current compilation context.
   Context &Ctx;
   /// Program to link to.

clang/lib/AST/Interp/ByteCodeEmitter.cpp

if (isLambdaCallOperator(MD)) {
       // FIXME: LambdaThisCapture
       (void)LTC;
     }
   }
 
   // Assign descriptors to all parameters.
   // Composite objects are lowered to pointers.
   for (const ParmVarDecl *PD : FuncDecl->parameters()) {
-    PrimType Ty = Ctx.classify(PD->getType()).value_or(PT_Ptr);
-    Descriptor *Desc = P.createDescriptor(PD, Ty);
-    ParamDescriptors.insert({ParamOffset, {Ty, Desc}});
-    Params.insert({PD, ParamOffset});
+    std::optional<PrimType> T = Ctx.classify(PD->getType());
+    PrimType PT = T.value_or(PT_Ptr);
+    Descriptor *Desc = P.createDescriptor(PD, PT);
+    ParamDescriptors.insert({ParamOffset, {PT, Desc}});
+    Params.insert({PD, {ParamOffset, T != std::nullopt}});
     ParamOffsets.push_back(ParamOffset);
-    ParamOffset += align(primSize(Ty));
-    ParamTypes.push_back(Ty);
+    ParamOffset += align(primSize(PT));
+    ParamTypes.push_back(PT);
   }
 
   // Create a handle over the emitted code.
   Function *Func = P.getFunction(FuncDecl);
   if (!Func)
     Func = P.createFunction(FuncDecl, ParamOffset, std::move(ParamTypes),
                             std::move(ParamDescriptors),
                             std::move(ParamOffsets), HasThisPointer, HasRVO);

clang/lib/AST/Interp/ByteCodeExprGen.cpp

 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::dereferenceParam(
     const Expr *LV, PrimType T, const ParmVarDecl *PD, DerefKind AK,
     llvm::function_ref<bool(PrimType)> Direct,
     llvm::function_ref<bool(PrimType)> Indirect) {
   auto It = this->Params.find(PD);
   if (It != this->Params.end()) {
-    unsigned Idx = It->second;
+    unsigned Idx = It->second.Offset;
     switch (AK) {
     case DerefKind::Read:
       return DiscardResult ? true : this->emitGetParam(T, Idx, LV);
 
     case DerefKind::Write:
       if (!Direct(T))
         return false;
       if (!this->emitSetParam(T, Idx, LV))
if (auto It = Locals.find(D); It != Locals.end()) {
     return this->emitGetPtrLocal(Offset, E);
   } else if (auto GlobalIndex = P.getGlobal(D)) {
     if (IsReference)
       return this->emitGetGlobalPtr(*GlobalIndex, E);
 
     return this->emitGetPtrGlobal(*GlobalIndex, E);
   } else if (const auto *PVD = dyn_cast<ParmVarDecl>(D)) {
     if (auto It = this->Params.find(PVD); It != this->Params.end()) {
-      if (IsReference)
-        return this->emitGetParamPtr(It->second, E);
-      return this->emitGetPtrParam(It->second, E);
+      if (IsReference || !It->second.IsPtr)
+        return this->emitGetParamPtr(It->second.Offset, E);
+
+      return this->emitGetPtrParam(It->second.Offset, E);
     }
   }
 
   // Handle lambda captures.
   if (auto It = this->LambdaCaptures.find(D);
       It != this->LambdaCaptures.end()) {
-    auto [Offset, IsReference] = It->second;
+    auto [Offset, IsPtr] = It->second;
 
-    if (IsReference)
+    if (IsPtr)
       return this->emitGetThisFieldPtr(Offset, E);
     return this->emitGetPtrThisField(Offset, E);
   }
 
   return false;
 }
 
 template <class Emitter>

clang/lib/AST/Interp/ByteCodeStmtGen.cpp

bool ByteCodeStmtGen<Emitter>::emitLambdaStaticInvokerBody(
   // Forward all arguments from the static invoker to the lambda call operator.
   for (const ParmVarDecl *PVD : MD->parameters()) {
     auto It = this->Params.find(PVD);
     assert(It != this->Params.end());
 
     // We do the lvalue-to-rvalue conversion manually here, so no need
     // to care about references.
     PrimType ParamType = this->classify(PVD->getType()).value_or(PT_Ptr);
-    if (!this->emitGetParam(ParamType, It->second, MD))
+    if (!this->emitGetParam(ParamType, It->second.Offset, MD))
       return false;
   }
 
   if (!this->emitCall(Func, LambdaCallOp))
     return false;
 
   this->emitCleanup();
   if (ReturnType)

clang/lib/AST/Interp/Context.h

 class VarDecl;
 
 namespace interp {
 class Function;
 class Program;
 class State;
 enum PrimType : unsigned;
 
+struct ParamOffset {
+  unsigned Offset;
+  bool IsPtr;
+};
+
 /// Holds all information required to evaluate constexpr code in a module.
 class Context final {
 public:
   /// Initialises the constexpr VM.
   Context(ASTContext &Ctx);
 
   /// Cleans up the constexpr VM.
   ~Context();

clang/lib/AST/Interp/EvalEmitter.h

protected:
   Local createLocal(Descriptor *D);
 
   /// Returns the source location of the current opcode.
   SourceInfo getSource(const Function *F, CodePtr PC) const override {
     return (F && F->hasBody()) ? F->getSource(PC) : CurrentSource;
   }
 
   /// Parameter indices.
-  llvm::DenseMap<const ParmVarDecl *, unsigned> Params;
+  llvm::DenseMap<const ParmVarDecl *, ParamOffset> Params;
   /// Lambda captures.
-  /// Map from Decl* to [Offset, IsReference] pair.
-  llvm::DenseMap<const ValueDecl *, std::pair<unsigned, bool>> LambdaCaptures;
+  llvm::DenseMap<const ValueDecl *, ParamOffset> LambdaCaptures;
   unsigned LambdaThisCapture;
   /// Local descriptors.
   llvm::SmallVector<SmallVector<Local, 8>, 2> Descriptors;
 
 private:
   /// Current compilation context.
   Context &Ctx;
   /// Current program.