Replace LowStringPtrOrId with LazyStringData

Summary:
- LowStringPtrOrId took advantage of the 3 low bits all always being 0.
- With PackedPtr that will not be true.
- But these are roughly never used (only used from Reflection).
- So just lookupLitstrId every time we get them. Which is very cheap.

Reviewed By: jano

Differential Revision: D76876470

fbshipit-source-id: ded0db0556530af09d6ce2419ab1013dc4576f1b

Author: WizKid

hphp/hhbbc/emit.cpp

@@ -678,7 +678,7 @@ EmitBcInfo emit_bytecode(EmitUnitState& euState, UnitEmitter& ue, FuncEmitter& f
   return ret;
 }
 
-void emit_locals_and_params(FuncEmitter& fe, const php::Func& func,
+void emit_locals_and_params(UnitEmitter& ue, FuncEmitter& fe, const php::Func& func,
                             const EmitBcInfo& info) {
   Id id = 0;
   for (auto const& loc : func.locals) {
@@ -690,8 +690,8 @@ void emit_locals_and_params(FuncEmitter& fe, const php::Func& func,
       Func::ParamInfo pinfo;
       pinfo.defaultValue = param.defaultValue;
       pinfo.typeConstraints = param.typeConstraints;
-      pinfo.userType = param.userTypeConstraint;
-      pinfo.phpCode = param.phpCode;
+      pinfo.userType = ue.mergeLitstr(param.userTypeConstraint);
+      pinfo.phpCode = ue.mergeLitstr(param.phpCode);
       pinfo.userAttributes = param.userAttributes;
       if (param.inout) pinfo.setFlag(Func::ParamInfo::Flags::InOut);
       if (param.outOnly) pinfo.setFlag(Func::ParamInfo::Flags::OutOnly);
@@ -957,17 +957,17 @@ void emit_ehent_tree(FuncEmitter& fe, const php::WideFunc& func,
   fe.setEHTabIsSorted();
 }
 
-void emit_finish_func(EmitUnitState& state, FuncEmitter& fe,
+void emit_finish_func(EmitUnitState& state, UnitEmitter& ue, FuncEmitter& fe,
                       php::WideFunc& wf, const EmitBcInfo& info) {
   auto const& func = *wf;
   if (info.containsCalls) fe.containsCalls = true;
 
-  emit_locals_and_params(fe, func, info);
+  emit_locals_and_params(ue, fe, func, info);
   emit_ehent_tree(fe, wf, info);
   wf.blocks().clear();
 
   fe.userAttributes = func.userAttributes;
-  fe.retUserType = func.returnUserType;
+  fe.retUserType = ue.mergeLitstr(func.returnUserType);
   fe.retTypeConstraints = func.retTypeConstraints;
   fe.typeParamNames = std::vector<LowStringPtr>(
     func.typeParamNames.begin(),
@@ -1056,7 +1056,7 @@ void emit_func(EmitUnitState& state, UnitEmitter& ue,
   emit_init_func(ue, fe, f);
   auto func = php::WideFunc::mut(&f);
   auto const info = emit_bytecode(state, ue, fe, func);
-  emit_finish_func(state, fe, func, info);
+  emit_finish_func(state, ue, fe, func, info);
 }
 
 void emit_class(EmitUnitState& state, UnitEmitter& ue, PreClassEmitter* pce,

hphp/hhbbc/parse.cpp

@@ -619,10 +619,10 @@ void add_frame_variables(php::Func& func, const FuncEmitter& fe, const UnitEmitt
       php::Param {
         param.defaultValue,
         NoBlockId,
-        param.userType.ptr(ue),
+        param.userType.get(ue),
         param.typeConstraints,
         param.userAttributes,
-        param.phpCode.ptr(ue),
+        param.phpCode.get(ue),
         param.isInOut(),
         param.isOutOnly(),
         param.isReadonly(),
@@ -679,7 +679,7 @@ std::unique_ptr<php::Func> parse_func(ParseUnitState& puState,
                                        AttrPersistent);
 
   ret->userAttributes     = fe.userAttributes;
-  ret->returnUserType     = fe.retUserType.ptr(ue);
+  ret->returnUserType     = fe.retUserType.get(ue);
   ret->retTypeConstraints = fe.retTypeConstraints;
   for (auto const& typeParam : fe.typeParamNames) {
     ret->typeParamNames.emplace_back(typeParam);

hphp/runtime/base/lazy-string-data.cpp

@@ -0,0 +1,39 @@
+/*
+   +----------------------------------------------------------------------+
+   | HipHop for PHP                                                       |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 2010-present Facebook, Inc. (http://www.facebook.com)  |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 3.01 of the PHP license,      |
+   | that is bundled with this package in the file LICENSE, and is        |
+   | available through the world-wide-web at the following url:           |
+   | http://www.php.net/license/3_01.txt                                  |
+   | If you did not receive a copy of the PHP license and are unable to   |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@php.net so we can mail you a copy immediately.               |
+   +----------------------------------------------------------------------+
+*/
+
+#include "hphp/runtime/base/lazy-string-data.h"
+
+#include "hphp/runtime/base/string-data.h"
+#include "hphp/runtime/vm/unit.h"
+#include "hphp/runtime/vm/unit-emitter.h"
+
+namespace HPHP {
+
+const StringData* LazyStringData::get(const Unit* unit) const {
+  if (m_id != kInvalidId) {
+    return unit->lookupLitstrId(m_id);
+  }
+  return nullptr;
+}
+
+const StringData* LazyStringData::get(const UnitEmitter& ue) const {
+  if (m_id != kInvalidId) {
+    return ue.lookupLitstrId(m_id);
+  }
+  return nullptr;
+}
+
+}

hphp/runtime/base/low-string-ptr-or-id.h hphp/runtime/base/lazy-string-data.hhphp/runtime/base/low-string-ptr-or-id.h renamed to hphp/runtime/base/lazy-string-data.h

@@ -16,40 +16,36 @@
 
 #pragma once
 
-#include "hphp/util/low-ptr.h"
 #include "hphp/runtime/base/types.h"
 
 namespace HPHP {
 
+struct StringData;
 struct Unit;
 struct UnitEmitter;
 
-struct LowStringPtrOrId {
+struct LazyStringData {
 
-  using storage_type = LowPtr<const StringData>::storage_type;
+  LazyStringData(): m_id(kInvalidId) {}
+  LazyStringData(Id id): m_id(id) {}
 
-  LowStringPtrOrId(): m_s(0) {}
-  explicit LowStringPtrOrId(const LowStringPtr str) : HPHP::LowStringPtrOrId(str.get()) {}
-  explicit LowStringPtrOrId(const StringData* str);
-  explicit LowStringPtrOrId(Id id);
-  LowStringPtrOrId(const LowStringPtrOrId& other);
+  LazyStringData& operator=(Id id) {
+    m_id = id;
+    return *this;
+  }
 
-  LowStringPtrOrId& operator=(const StringData* str);
-  LowStringPtrOrId& operator=(const LowStringPtrOrId& other);
+  const Id id() const { return m_id; }
 
-  Id id() const;
-  const StringData* rawPtr() const;
-  const StringData* ptr(const Unit* unit) const;
-  const StringData* ptr(const UnitEmitter& ue) const;
+  const StringData* get(const Unit* unit) const;
+  const StringData* get(const UnitEmitter& ue) const;
 
-private:
-  mutable std::atomic<storage_type> m_s;
-};
+  template <typename SerDe>
+  void serde(SerDe& sd) {
+    sd(m_id);
+  }
 
-template<>
-struct BlobEncoderHelper<LowStringPtrOrId> {
-  static void serde(BlobEncoder&, const LowStringPtrOrId&);
-  static void serde(BlobDecoder&, LowStringPtrOrId&);
+ private:
+  Id m_id;
 };
 
-} // namespace HPHP
+}

hphp/runtime/base/low-string-ptr-or-id.cpp

@@ -164,7 +164,7 @@ Variant default_arg_from_php_code(const Func::ParamInfo& fpi,
 
   try {
     return g_context->getEvaledArg(
-      fpi.phpCode.ptr(func->unit()),
+      fpi.phpCode.get(func->unit()),
       // We use cls() instead of implCls() because we want the namespace and
       // class context for which the closure is scoped, not that of the
       // Closure subclass (which, among other things, is always globally
@@ -824,7 +824,7 @@ static Array get_function_param_info(const Func* func) {
       : staticEmptyString();
 
     param.set(s_type, make_tv<KindOfPersistentString>(type));
-    auto userType = fpi.userType.ptr(func->unit());
+    auto userType = fpi.userType.get(func->unit());
     const StringData* typeHint = userType
       ? userType
       : staticEmptyString();
@@ -853,7 +853,7 @@ static Array get_function_param_info(const Func* func) {
       param.set(s_type_hint_nullable, make_tv<KindOfBoolean>(false));
     }
 
-    if (auto phpCode = fpi.phpCode.ptr(func->unit())) {
+    if (auto phpCode = fpi.phpCode.get(func->unit())) {
       Variant v = default_arg_from_php_code(fpi, func, i);
       param.set(s_default, v);
       param.set(s_defaultText, make_tv<KindOfPersistentString>(phpCode));

hphp/runtime/ext/reflection/ext_reflection.cpp

@@ -2240,7 +2240,7 @@ void parse_parameter_list(AsmState& as) {
     }
 
     auto [userType, typeConstraints] = parse_type_info(as);
-    param.userType = userType;
+    param.userType = as.ue->mergeLitstr(userType);
     param.typeConstraints = TypeIntersectionConstraint(
         std::move(typeConstraints)
     );
@@ -2273,7 +2273,9 @@ void parse_parameter_list(AsmState& as) {
       ch = as.in.getc();
       if (ch == '(') {
         String str = parse_long_string(as);
-        parse_default_value(param, makeStaticString(str));
+        auto v = makeStaticString(str);
+        auto id = as.ue->mergeLitstr(v);
+        parse_default_value(param, id, v);
         as.in.expectWs(')');
         as.in.skipWhitespace();
         ch = as.in.getc();
@@ -2389,7 +2391,7 @@ void parse_function(AsmState& as) {
   as.fe = as.ue->newFuncEmitter(sname);
   as.fe->init(line0, line1, attrs, nullptr, as.ue->isSystemLib());
 
-  as.fe->retUserType = userType;
+  as.fe->retUserType = as.ue->mergeLitstr(userType);
   as.fe->retTypeConstraints = TypeIntersectionConstraint(
     std::move(typeConstraints)
   );
@@ -2444,7 +2446,7 @@ void parse_method(AsmState& as) {
   as.pce->addMethod(as.fe);
   as.fe->init(line0, line1, attrs, nullptr, as.ue->isSystemLib());
 
-  as.fe->retUserType = userType;
+  as.fe->retUserType = as.ue->mergeLitstr(userType);
   as.fe->retTypeConstraints = TypeIntersectionConstraint(
     std::move(typeConstraints)
   );
@@ -3312,8 +3314,8 @@ std::unique_ptr<UnitEmitter> assemble_string(
   return ue;
 }
 
-void parse_default_value(Func::ParamInfo& param, const StringData* str) {
-  param.phpCode = str;
+void parse_default_value(Func::ParamInfo& param, Id id, const StringData* str) {
+  param.phpCode = id;
   TypedValue tv;
   tvWriteUninit(tv);
   if (str->size() == 4) {

hphp/runtime/vm/as.cpp

@@ -171,12 +171,12 @@ void fixup_default_values(T& state, FuncEmitter* fe) {
       VariableSerializer vs(VariableSerializer::Type::PHPOutput);
       auto str = vs.serialize(tvAsCVarRef(&dv), true);
       pi.defaultValue = dv;
-      pi.phpCode = makeStaticString(str.get());
+      pi.phpCode = state.ue->mergeLitstr(makeStaticString(str.get()));
     }
   }
 }
 
-void parse_default_value(Func::ParamInfo& param, const StringData* str);
+void parse_default_value(Func::ParamInfo& param, Id id, const StringData* str);
 
 // Sets output on success; throws on failure.
 void ParseRepoAuthType(folly::StringPiece input, RepoAuthType& output);