fix GetVariableOffset for static constexpr class attribute

by explicitly initializing constexpr with `Sema::InstantiateVariableDefinition`

Author: Vipul-Cariappa

lib/Interpreter/CppInterOp.cpp

@@ -1284,12 +1284,22 @@ namespace Cpp {
 #endif
       }
       auto VDAorErr = compat::getSymbolAddress(I, StringRef(mangledName));
-      if (!VDAorErr) {
-        llvm::logAllUnhandledErrors(VDAorErr.takeError(), llvm::errs(),
-                                    "Failed to GetVariableOffset:");
-        return 0;
+      if (VDAorErr)
+        return (intptr_t)jitTargetAddressToPointer<void*>(VDAorErr.get());
+
+      llvm::logAllUnhandledErrors(VDAorErr.takeError(), llvm::errs(),
+                                  "Failed to GetVariableOffset:");
+
+      if (!VD->hasInit())
+        getSema().InstantiateVariableDefinition(SourceLocation(), VD);
+      if (VD->hasInit() &&
+          (VD->isConstexpr() || VD->getType().isConstQualified())) {
+        if (const APValue* val = VD->evaluateValue()) {
+          if (VD->getType()->isIntegralType(C)) {
+            return (intptr_t)val->getInt().getRawData();
+          }
+        }
       }
-      return (intptr_t) jitTargetAddressToPointer<void*>(VDAorErr.get());
     }
 
     return 0;

unittests/CppInterOp/FunctionReflectionTest.cpp

@@ -1154,3 +1154,82 @@ TEST(FunctionReflectionTest, Destruct) {
   output = testing::internal::GetCapturedStdout();
   EXPECT_EQ(output, "Destructor Executed");
 }
+
+TEST(FunctionReflectionTest, StaticConstExprDatamember) {
+  if (llvm::sys::RunningOnValgrind())
+    GTEST_SKIP() << "XFAIL due to Valgrind report";
+
+#ifdef _WIN32
+  GTEST_SKIP() << "Disabled on Windows. Needs fixing.";
+#endif
+
+  Cpp::CreateInterpreter();
+
+  Cpp::Declare(R"(
+  class MyClass {
+  public:
+    static constexpr int x = 3;
+  };
+
+  template<int i>
+  class MyTemplatedClass {
+  public:
+    static constexpr int x = i;
+  };
+
+  template<typename _Tp, _Tp __v>
+  struct integral_constant
+  {
+      static constexpr _Tp value = __v;
+  };
+
+  template<typename... Eles>
+  struct Elements
+  : public integral_constant<int, sizeof...(Eles)> {};
+  )");
+
+  Cpp::TCppScope_t MyClass = Cpp::GetNamed("MyClass");
+  EXPECT_TRUE(MyClass);
+
+  std::vector<Cpp::TCppScope_t> datamembers;
+  Cpp::GetStaticDatamembers(MyClass, datamembers);
+  EXPECT_EQ(datamembers.size(), 1);
+
+  intptr_t offset = Cpp::GetVariableOffset(datamembers[0]);
+  EXPECT_EQ(3, *(int*)offset);
+
+  ASTContext& C = Interp->getCI()->getASTContext();
+  std::vector<Cpp::TemplateArgInfo> template_args = {
+      {C.IntTy.getAsOpaquePtr(), "5"}};
+
+  Cpp::TCppFunction_t MyTemplatedClass =
+      Cpp::InstantiateTemplate(Cpp::GetNamed("MyTemplatedClass"),
+                               template_args.data(), template_args.size());
+  EXPECT_TRUE(MyTemplatedClass);
+
+  datamembers.clear();
+  Cpp::GetStaticDatamembers(MyTemplatedClass, datamembers);
+  EXPECT_EQ(datamembers.size(), 1);
+
+  offset = Cpp::GetVariableOffset(datamembers[0]);
+  EXPECT_EQ(5, *(int*)offset);
+
+  std::vector<Cpp::TemplateArgInfo> ele_template_args = {
+      {C.IntTy.getAsOpaquePtr()}, {C.FloatTy.getAsOpaquePtr()}};
+
+  Cpp::TCppFunction_t Elements = Cpp::InstantiateTemplate(
+      Cpp::GetNamed("Elements"), ele_template_args.data(),
+      ele_template_args.size());
+  EXPECT_TRUE(Elements);
+
+  EXPECT_EQ(1, Cpp::GetNumBases(Elements));
+
+  Cpp::TCppScope_t IC = Cpp::GetBaseClass(Elements, 0);
+
+  datamembers.clear();
+  Cpp::GetStaticDatamembers(IC, datamembers);
+  EXPECT_EQ(datamembers.size(), 1);
+
+  offset = Cpp::GetVariableOffset(datamembers[0]);
+  EXPECT_EQ(2, *(int*)offset);
+}