Fix non-unique ProfPrologueIDs

Summary:
In low pointer builds we use the 32 bit Func* as an ID instead of computing separate unique ID numbers for each function. This works fine in repo mode but in non-repo mode it means that FuncId is no longer unique (e.g. if I free a Func and allocate a new one it may be allocated at the same address and therefore share the same FuncId).

This is mostly a theoretical concern as we don't run non-repo low pointer builds anywhere but we do have some tests that depend on being able to calculate unique ProfPrologueIDs in all build configurations. To fix that without expanding the Func structure store a side table of IDs in non-repo mode.

Reviewed By: ricklavoie

Differential Revision: D73924655

fbshipit-source-id: 3495f3ab3c8b941f5b95913e2e7dad21923673e3

Author: paulbiss

hphp/runtime/vm/func-id.cpp

@@ -16,12 +16,17 @@
 #include <limits>
 
 #include "hphp/runtime/vm/func-id.h"
+#include "hphp/runtime/vm/func.h"
 
 namespace HPHP {
 ///////////////////////////////////////////////////////////////////////////////
 
 FuncId FuncId::Invalid = FuncId::fromInt(std::numeric_limits<FuncId::Int>::max());
 FuncId FuncId::Dummy   = FuncId::fromInt(std::numeric_limits<FuncId::Int>::max() - 1);
 
+#ifdef USE_LOWPTR
+FuncId::Int FuncId::toStableInt() const { return getFunc()->getStableId(); }
+#endif
+
 ///////////////////////////////////////////////////////////////////////////////
 }

hphp/runtime/vm/func-id.h

@@ -51,12 +51,14 @@ struct FuncId {
   static FuncId fromInt(Int num) {
     return FuncId{Id(reinterpret_cast<const Func*>(num))};
   }
+  Int toStableInt() const;
 #else
   using Id = uint32_t;
   Int toInt() const { return m_id; }
   constexpr static FuncId fromInt(Int num) {
     return FuncId{num};
   }
+  Int toStableInt() const { return toInt(); }
 #endif
 
   bool isInvalid() const { return m_id == Invalid.m_id; }

hphp/runtime/vm/func.cpp

@@ -86,6 +86,8 @@ static InitFiniNode s_funcVecReinit([]{
   UnsafeReinitEmptyAtomicLowPtrVector(
     Func::s_funcVec, Cfg::Eval::FuncCountHint);
 }, InitFiniNode::When::PostRuntimeOptions, "s_funcVec reinit");
+#else
+folly::ConcurrentHashMap<uint32_t, uint32_t> s_stableFuncIDs;
 #endif
 
 static ServiceData::ExportedCounter* s_funcid_counter =
@@ -389,8 +391,21 @@ FuncId::Int Func::maxFuncIdNum() {
 
 #ifdef USE_LOWPTR
 void Func::setNewFuncId() {
-  s_nextFuncId.fetch_add(1, std::memory_order_acq_rel);
+  auto const id = s_nextFuncId.fetch_add(1, std::memory_order_acq_rel);
   s_funcid_counter->increment();
+
+  if (!Cfg::Repo::Authoritative) {
+    s_stableFuncIDs.insert_or_assign(
+      static_cast<uint32_t>(reinterpret_cast<intptr_t>(this)), id);
+  }
+}
+
+uint32_t Func::getStableId() const {
+  if (Cfg::Repo::Authoritative) return getFuncId().toInt();
+  auto const it = s_stableFuncIDs.find(
+    static_cast<uint32_t>(reinterpret_cast<intptr_t>(this)));
+  assertx(it != s_stableFuncIDs.end());
+  return it->second;
 }
 
 const Func* Func::fromFuncId(FuncId id) {
@@ -413,6 +428,10 @@ void Func::setNewFuncId() {
   s_funcVec.set(m_funcId.toInt(), this);
 }
 
+uint32_t Func::getStableId() const {
+  return getFuncId().toInt();
+}
+
 const Func* Func::fromFuncId(FuncId id) {
   assertx(id.toInt() < s_nextFuncId);
   auto const func = s_funcVec.get(id.toInt());

hphp/runtime/vm/func.h

@@ -258,6 +258,12 @@ struct Func final {
    */
   FuncId getFuncId() const;
 
+  /*
+   * Get a function ID that is guaranteed not to be reused during the lifetime
+   * of the process.
+   */
+  uint32_t getStableId() const;
+
 #ifndef USE_LOWPTR
   static constexpr size_t funcIdOffset() {
     return offsetof(Func, m_funcId);

hphp/runtime/vm/jit/prof-data.h

@@ -594,7 +594,7 @@ struct ProfData {
 
     /* implicit */ operator uint64_t() const {
       assertx(nArgs >= 0);
-      return (uint64_t(func.toInt()) << 32) | nArgs;
+      return (uint64_t(func.toStableInt()) << 32) | nArgs;
     }
   };