[clang][Interp] Handle SourceLocExprs

[tbaeder]

Summary

This is a bit awkward, since we get an APValue from the expression, which we then need to re-integrate into our bytecode/primtype based interpreter.

[cor3ntin]

Note that you are probably need something like SourceLocExprScopeGuard to make source_location actually work, , it might be worth doing in this patch.
The idea is to remember the location of a call when evaluating default arguments / default member initializers

clang/test/AST/Interp/builtin-functions.cpp

245

what is missing to enable the existing source location tests with the new intterpreter?

[tbaeder]

In D155627#4513433, @cor3ntin wrote:

Note that you are probably need something like SourceLocExprScopeGuard to make source_location actually work, , it might be worth doing in this patch.
The idea is to remember the location of a call when evaluating default arguments / default member initializers

Yeah I saw, that's what the FIXME comment is about.

clang/test/AST/Interp/builtin-functions.cpp

245

There is a crash that I need to investigate first, but SemaCXX/source_location.cpp also uses stuff like static_assert(noexcept(...)); that I don't handle yet.

[tbaeder]

clang/test/AST/Interp/builtin-functions.cpp

245

Okay, after my last two patches I uploaded, the only problem missing is the broken source locations for initializers.

[cor3ntin]

clang/test/AST/Interp/builtin-functions.cpp

245

I think it might be worth doing in this patch (unless it requires a lot of work)

[tbaeder]

clang/test/AST/Interp/builtin-functions.cpp

245

I was wrong and there's some other work needed. Namely, I need to redo how we do initializers. I will definitely tackel that this quarter and dial down the work on new features.

[tbaeder]

@cor3ntin Ok, I need...

• https://reviews.llvm.org/D155707
• https://reviews.llvm.org/D156027
• https://reviews.llvm.org/D156042

to enable the existing tests with at least one of the RUN lines.

[cor3ntin]

FYI i think this is fine but I'm waiting for progress on the PRs that would allow us to enable more tests.

[cor3ntin]

@tbaeder Maybe you could land the dependencies of this patch so that we can progress it. Thanks!

[tbaeder]

Having https://reviews.llvm.org/D144457 and https://reviews.llvm.org/D144457 approved would make rebasing easier :)

[aaron.ballman]

In D155627#4595089, @tbaeder wrote:

Having https://reviews.llvm.org/D144457 and https://reviews.llvm.org/D144457 approved would make rebasing easier :)

I can look into https://reviews.llvm.org/D144457, but then having to do https://reviews.llvm.org/D144457 right after is going to be tough. (I suspect there may be a copy pasta here.) ;-)

[tbaeder]

In D155627#4596321, @aaron.ballman wrote:

In D155627#4595089, @tbaeder wrote:

Having https://reviews.llvm.org/D144457 and https://reviews.llvm.org/D144457 approved would make rebasing easier :)

I can look into https://reviews.llvm.org/D144457, but then having to do https://reviews.llvm.org/D144457 right after is going to be tough. (I suspect there may be a copy pasta here.) ;-)

But once you've reviewed https://reviews.llvm.org/D144457, reviewing https://reviews.llvm.org/D144457 shouldn't be that hard? :)

I'm pretty sure the second link should've been https://reviews.llvm.org/D152132.

[aaron.ballman]

In D155627#4598032, @tbaeder wrote:

In D155627#4596321, @aaron.ballman wrote:

In D155627#4595089, @tbaeder wrote:

Having https://reviews.llvm.org/D144457 and https://reviews.llvm.org/D144457 approved would make rebasing easier :)

I can look into https://reviews.llvm.org/D144457, but then having to do https://reviews.llvm.org/D144457 right after is going to be tough. (I suspect there may be a copy pasta here.) ;-)

But once you've reviewed https://reviews.llvm.org/D144457, reviewing https://reviews.llvm.org/D144457 shouldn't be that hard? :)

I dunno, I'm skeptical.

I'm pretty sure the second link should've been https://reviews.llvm.org/D152132.

Oh, so now we're moving the goalposts too? ;-) I'll check that one out next, thanks for clarifying!

[tbaeder]

All the dependencies have been pushed.

[tbaeder]

Ping

[cor3ntin]

So you can enable some of the sema source location tests?

[tbaeder]

I do in https://reviews.llvm.org/D156045, but that depends on other commits (not sure which exactly right now though).

clang/lib/AST/Interp/ByteCodeExprGen.h

 
 template <class Emitter> class LocalScope;
 template <class Emitter> class DestructorScope;
 template <class Emitter> class RecordScope;
 template <class Emitter> class VariableScope;
 template <class Emitter> class DeclScope;
 template <class Emitter> class OptionScope;
 template <class Emitter> class ArrayIndexScope;
+template <class Emitter> class SourceLocScope;
 
 /// Compilation context for expressions.
 template <class Emitter>
 class ByteCodeExprGen : public ConstStmtVisitor<ByteCodeExprGen<Emitter>, bool>,
                         public Emitter {
 protected:
   // Aliases for types defined in the emitter.
   using LabelTy = typename Emitter::LabelTy;
public:
   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);
   bool VisitCXXNoexceptExpr(const CXXNoexceptExpr *E);
   bool VisitCXXConstructExpr(const CXXConstructExpr *E);
+  bool VisitSourceLocExpr(const SourceLocExpr *E);
 
 protected:
   bool visitExpr(const Expr *E) override;
   bool visitDecl(const VarDecl *VD) override;
 
 protected:
   /// Emits scope cleanup instructions.
   void emitCleanup();
protected:
   /// Evaluates an expression for side effects and discards the result.
   bool discard(const Expr *E);
   /// Just pass evaluation on to \p E. This leaves all the parsing flags
   /// intact.
   bool delegate(const Expr *E);
 
   /// Creates and initializes a variable from the given decl.
   bool visitVarDecl(const VarDecl *VD);
+  /// Visit an APValue.
+  bool visitAPValue(const APValue &Val, PrimType ValType, const Expr *E);
 
   /// Visits an expression and converts it to a boolean.
   bool visitBool(const Expr *E);
 
   /// Visits an initializer for a local.
   bool visitLocalInitializer(const Expr *Init, unsigned I) {
     if (!this->emitGetPtrLocal(I, Init))
       return false;

 private:
   friend class VariableScope<Emitter>;
   friend class LocalScope<Emitter>;
   friend class DestructorScope<Emitter>;
   friend class RecordScope<Emitter>;
   friend class DeclScope<Emitter>;
   friend class OptionScope<Emitter>;
   friend class ArrayIndexScope<Emitter>;
+  friend class SourceLocScope<Emitter>;
 
   /// Emits a zero initializer.
   bool visitZeroInitializer(QualType QT, const Expr *E);
   bool visitZeroRecordInitializer(const Record *R, const Expr *E);
 
   enum class DerefKind {
     /// Value is read and pushed to stack.
     Read,
bool dereferenceParam(const Expr *LV, PrimType T, const ParmVarDecl *PD,
                         DerefKind AK,
                         llvm::function_ref<bool(PrimType)> Direct,
                         llvm::function_ref<bool(PrimType)> Indirect);
   bool dereferenceVar(const Expr *LV, PrimType T, const VarDecl *PD,
                       DerefKind AK, llvm::function_ref<bool(PrimType)> Direct,
                       llvm::function_ref<bool(PrimType)> Indirect);
 
   /// Emits an APSInt constant.
+  bool emitConst(const llvm::APSInt &Value, PrimType Ty, const Expr *E);
   bool emitConst(const llvm::APSInt &Value, const Expr *E);
   bool emitConst(const llvm::APInt &Value, const Expr *E) {
     return emitConst(static_cast<llvm::APSInt>(Value), E);
   }
 
   /// Emits an integer constant.
+  template <typename T> bool emitConst(T Value, PrimType Ty, const Expr *E);
   template <typename T> bool emitConst(T Value, const Expr *E);
 
   /// Returns the CXXRecordDecl for the type of the given expression,
   /// or nullptr if no such decl exists.
   const CXXRecordDecl *getRecordDecl(const Expr *E) const {
     QualType T = E->getType();
     if (const auto *RD = T->getPointeeCXXRecordDecl())
       return RD;
protected:
   llvm::DenseMap<const OpaqueValueExpr *, unsigned> OpaqueExprs;
 
   /// Current scope.
   VariableScope<Emitter> *VarScope = nullptr;
 
   /// Current argument index. Needed to emit ArrayInitIndexExpr.
   std::optional<uint64_t> ArrayIndex;
 
+  /// DefaultInit- or DefaultArgExpr, needed for SourceLocExpr.
+  const Expr *SourceLocDefaultExpr = nullptr;
+
   /// Flag indicating if return value is to be discarded.
   bool DiscardResult = false;
 
   /// Flag inidicating if we're initializing an already created
   /// variable. This is set in visitInitializer().
   bool Initializing = false;
 };
 
public:
 
   ~ArrayIndexScope() { Ctx->ArrayIndex = OldArrayIndex; }
 
 private:
   ByteCodeExprGen<Emitter> *Ctx;
   std::optional<uint64_t> OldArrayIndex;
 };
 
+template <class Emitter> class SourceLocScope final {
+public:
+  SourceLocScope(ByteCodeExprGen<Emitter> *Ctx, const Expr *DefaultExpr)
+      : Ctx(Ctx) {
+    assert(DefaultExpr);
+    // We only switch if the current SourceLocDefaultExpr is null.
+    if (!Ctx->SourceLocDefaultExpr) {
+      Enabled = true;
+      Ctx->SourceLocDefaultExpr = DefaultExpr;
+    }
+  }
+
+  ~SourceLocScope() {
+    if (Enabled)
+      Ctx->SourceLocDefaultExpr = nullptr;
+  }
+
+private:
+  ByteCodeExprGen<Emitter> *Ctx;
+  bool Enabled = false;
+};
+
 } // namespace interp
 } // namespace clang
 
 #endif

clang/lib/AST/Interp/ByteCodeExprGen.cpp

for (size_t I = 0; I != NumElems; ++I) {
         return false;
     }
     return true;
   }
 
   return false;
 }
 
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::VisitSourceLocExpr(const SourceLocExpr *E) {
+  if (DiscardResult)
+    return true;
+
+  const APValue Val =
+      E->EvaluateInContext(Ctx.getASTContext(), SourceLocDefaultExpr);
+
+  // Things like __builtin_LINE().
+  if (E->getType()->isIntegerType()) {
+    assert(Val.isInt());
+    const APSInt &I = Val.getInt();
+    return this->emitConst(I, E);
+  }
+  // Otherwise, the APValue is an LValue, with only one element.
+  // Theoretically, we don't need the APValue at all of course.
+  assert(E->getType()->isPointerType());
+  assert(Val.isLValue());
+  const APValue::LValueBase &Base = Val.getLValueBase();
+  if (const Expr *LValueExpr = Base.dyn_cast<const Expr *>())
+    return this->visit(LValueExpr);
+
+  // Otherwise, we have a decl (which is the case for
+  // __builtin_source_location).
+  assert(Base.is<const ValueDecl *>());
+  assert(Val.getLValuePath().size() == 0);
+  const auto *BaseDecl = Base.dyn_cast<const ValueDecl *>();
+  assert(BaseDecl);
+
+  auto *UGCD = cast<UnnamedGlobalConstantDecl>(BaseDecl);
+
+  std::optional<unsigned> GlobalIndex = P.getOrCreateGlobal(UGCD);
+  if (!GlobalIndex)
+    return false;
+
+  if (!this->emitGetPtrGlobal(*GlobalIndex, E))
+    return false;
+
+  const Record *R = getRecord(E->getType());
+  const APValue &V = UGCD->getValue();
+  for (unsigned I = 0, N = R->getNumFields(); I != N; ++I) {
+    const Record::Field *F = R->getField(I);
+    const APValue &FieldValue = V.getStructField(I);
+
+    PrimType FieldT = classifyPrim(F->Decl->getType());
+
+    if (!this->visitAPValue(FieldValue, FieldT, E))
+      return false;
+    if (!this->emitInitField(FieldT, F->Offset, E))
+      return false;
+  }
+
+  // Leave the pointer to the global on the stack.
+  return true;
+}
+
 template <class Emitter> bool ByteCodeExprGen<Emitter>::discard(const Expr *E) {
   if (E->containsErrors())
     return false;
 
   OptionScope<Emitter> Scope(this, /*NewDiscardResult=*/true,
                              /*NewInitializing=*/false);
   return this->Visit(E);
 }
bool ByteCodeExprGen<Emitter>::dereferenceVar(
   }
 
   // Value cannot be produced - try to emit pointer.
   return visit(LV) && Indirect(T);
 }
 
 template <class Emitter>
 template <typename T>
-bool ByteCodeExprGen<Emitter>::emitConst(T Value, const Expr *E) {
-  switch (classifyPrim(E->getType())) {
+bool ByteCodeExprGen<Emitter>::emitConst(T Value, PrimType Ty, const Expr *E) {
+  switch (Ty) {
   case PT_Sint8:
     return this->emitConstSint8(Value, E);
   case PT_Uint8:
     return this->emitConstUint8(Value, E);
   case PT_Sint16:
     return this->emitConstSint16(Value, E);
   case PT_Uint16:
     return this->emitConstUint16(Value, E);
bool ByteCodeExprGen<Emitter>::emitConst(T Value, PrimType Ty, const Expr *E) {
   case PT_Float:
     llvm_unreachable("Invalid integral type");
     break;
   }
   llvm_unreachable("unknown primitive type");
 }
 
 template <class Emitter>
-bool ByteCodeExprGen<Emitter>::emitConst(const APSInt &Value, const Expr *E) {
+template <typename T>
+bool ByteCodeExprGen<Emitter>::emitConst(T Value, const Expr *E) {
+  return this->emitConst(Value, classifyPrim(E->getType()), E);
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::emitConst(const APSInt &Value, PrimType Ty,
+                                         const Expr *E) {
   if (Value.isSigned())
-    return this->emitConst(Value.getSExtValue(), E);
-  return this->emitConst(Value.getZExtValue(), E);
+    return this->emitConst(Value.getSExtValue(), Ty, E);
+  return this->emitConst(Value.getZExtValue(), Ty, E);
+}
+
+template <class Emitter>
+bool ByteCodeExprGen<Emitter>::emitConst(const APSInt &Value, const Expr *E) {
+  return this->emitConst(Value, classifyPrim(E->getType()), E);
 }
 
 template <class Emitter>
 unsigned ByteCodeExprGen<Emitter>::allocateLocalPrimitive(DeclTy &&Src,
                                                           PrimType Ty,
                                                           bool IsConst,
                                                           bool IsExtended) {
   // Make sure we don't accidentally register the same decl twice.
if (Context::shouldBeGloballyIndexed(VD)) {
     }
     return true;
   }
 
   return false;
 }
 
 template <class Emitter>
+bool ByteCodeExprGen<Emitter>::visitAPValue(const APValue &Val,
+                                            PrimType ValType, const Expr *E) {
+  assert(!DiscardResult);
+  if (Val.isInt())
+    return this->emitConst(Val.getInt(), ValType, E);
+
+  if (Val.isLValue()) {
+    APValue::LValueBase Base = Val.getLValueBase();
+    if (const Expr *BaseExpr = Base.dyn_cast<const Expr *>())
+      return this->visit(BaseExpr);
+  }
+
+  return false;
+}
+
+template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitBuiltinCallExpr(const CallExpr *E) {
   const Function *Func = getFunction(E->getDirectCallee());
   if (!Func)
     return false;
 
   // Put arguments on the stack.
   for (const auto *Arg : E->arguments()) {
     if (!this->visit(Arg))

 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitCXXDefaultInitExpr(
     const CXXDefaultInitExpr *E) {
 
   if (Initializing)
     return this->visitInitializer(E->getExpr());
 
   assert(classify(E->getType()));
+  SourceLocScope<Emitter> SLS(this, E);
   return this->visit(E->getExpr());
 }
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitCXXDefaultArgExpr(
     const CXXDefaultArgExpr *E) {
-  const Expr *SubExpr = E->getExpr();
+  SourceLocScope<Emitter> SLS(this, E);
 
+  const Expr *SubExpr = E->getExpr();
   if (std::optional<PrimType> T = classify(E->getExpr()))
     return this->visit(SubExpr);
 
   assert(Initializing);
   return this->visitInitializer(SubExpr);
 }
 
 template <class Emitter>

clang/lib/AST/Interp/Program.cpp

std::optional<unsigned> Program::getOrCreateDummy(const ParmVarDecl *PD) {
   }
   return std::nullopt;
 }
 
 std::optional<unsigned> Program::createGlobal(const ValueDecl *VD,
                                               const Expr *Init) {
   assert(!getGlobal(VD));
   bool IsStatic, IsExtern;
-  if (auto *Var = dyn_cast<VarDecl>(VD)) {
+  if (const auto *Var = dyn_cast<VarDecl>(VD)) {
     IsStatic = Context::shouldBeGloballyIndexed(VD);
     IsExtern = !Var->getAnyInitializer();
+  } else if (isa<UnnamedGlobalConstantDecl>(VD)) {
+    IsStatic = true;
+    IsExtern = false;
   } else {
     IsStatic = false;
     IsExtern = true;
   }
   if (auto Idx = createGlobal(VD, VD->getType(), IsStatic, IsExtern, Init)) {
     for (const Decl *P = VD; P; P = P->getPreviousDecl())
       GlobalIndices[P] = *Idx;
     return *Idx;

clang/test/AST/Interp/builtin-functions.cpp

#endif
   char classify_zero    [__builtin_fpclassify(-1, -1, -1, -1, +1, 0.0)];
   char classify_neg_zero[__builtin_fpclassify(-1, -1, -1, -1, +1, -0.0)];
   char classify_subnorm [__builtin_fpclassify(-1, -1, -1, +1, -1, 1.0e-38f)];
 }
 
 namespace fabs {
   static_assert(__builtin_fabs(-14.0) == 14.0, "");
 }
+
+namespace std {
+struct source_location {
+  struct __impl {
+    unsigned int _M_line;
+    const char *_M_file_name;
+    signed char _M_column;
+    const char *_M_function_name;
+  };
+  using BuiltinT = decltype(__builtin_source_location()); // OK.
+};
+}
+
+namespace SourceLocation {
+  constexpr auto A = __builtin_source_location();
+  static_assert(A->_M_line == __LINE__ -1, "");
+  static_assert(A->_M_column == 22, "");
+  static_assert(__builtin_strcmp(A->_M_function_name, "") == 0, "");
+  static_assert(__builtin_strcmp(A->_M_file_name, __FILE__) == 0, "");
+
+  static_assert(__builtin_LINE() == __LINE__, "");
+
+  struct Foo {
+    int a = __builtin_LINE();
+  };
+
+  static_assert(Foo{}.a == __LINE__, "");
+}