Make strlen() an opcode

oyamauchi · sgolemon · commit 3b96353ea0f4 · 2012-11-04T18:08:56.000-08:00
It's the second most-called builtin in production (after idx()) and the common
case of a string argument is incredibly simple to implement (pull the m_len
field out of the arg, decref) so let's jit it.
diff --git a/src/compiler/analysis/emitter.cpp b/src/compiler/analysis/emitter.cpp
@@ -2897,6 +2897,13 @@ bool EmitterVisitor::visitImpl(ConstructPtr node) {
             e.AKExists();
             return true;
           }
+        } else if (call->isCallToFunction("strlen")) {
+          if (params && params->getCount() == 1) {
+            visit((*params)[0]);
+            emitConvertToCell(e);
+            e.Strlen();
+            return true;
+          }
         } else if (call->isCallToFunction("define")) {
           if (params && params->getCount() == 2) {
             ExpressionPtr p0 = (*params)[0];
diff --git a/src/runtime/base/string_data.h b/src/runtime/base/string_data.h
@@ -248,6 +248,7 @@ class StringData {
     return rawdata();
   }
   int size() const { return m_len; }
+  static uint sizeOffset() { return offsetof(StringData, m_len); }
   int capacity() const { return isSmall() ? MaxSmallSize : bigCap(); }
   StringSlice slice() const {
     TAINT_OBSERVER_REGISTER_ACCESSED(m_taint_data);
diff --git a/src/runtime/vm/bytecode.cpp b/src/runtime/vm/bytecode.cpp
@@ -6943,6 +6943,21 @@ inline void OPTBLD_INLINE VMExecutionContext::iopContHandle(PC& pc) {
   throw exn.asObjRef();
 }
 
+inline void OPTBLD_INLINE VMExecutionContext::iopStrlen(PC& pc) {
+  NEXT();
+  TypedValue* subj = m_stack.topTV();
+  int64 ans = 0;
+  if (LIKELY(IS_STRING_TYPE(subj->m_type))) {
+    ans = subj->m_data.pstr->size();
+  } else {
+    ans = f_strlen(tvAsVariant(subj));
+  }
+
+  tvRefcountedDecRef(subj);
+  subj->m_type = KindOfInt64;
+  subj->m_data.num = ans;
+}
+
 void VMExecutionContext::classExistsImpl(PC& pc, Attr typeAttr) {
   NEXT();
   TypedValue* aloadTV = m_stack.topTV();
diff --git a/src/runtime/vm/hhbc.h b/src/runtime/vm/hhbc.h
@@ -547,6 +547,7 @@ enum SetOpOp {
   O(ContCurrent,     NA,               NOV,             ONE(CV),    NF) \
   O(ContStopped,     NA,               NOV,             NOV,        NF) \
   O(ContHandle,      NA,               ONE(CV),         NOV,        CF_TF) \
+  O(Strlen,          NA,               ONE(CV),         ONE(CV),    NF) \
   O(HighInvalid,     NA,               NOV,             NOV,        NF) \
 
 enum Op {
diff --git a/src/runtime/vm/translator/hopt/hhbctranslator.cpp b/src/runtime/vm/translator/hopt/hhbctranslator.cpp
@@ -705,6 +705,32 @@ void HhbcTranslator::emitContHandle() {
   emitInterpOne(Type::None);
 }
 
+void HhbcTranslator::emitStrlen() {
+  Type::Tag inType = topC()->getType();
+
+  if (Type::isString(inType)) {
+    SSATmp* input = popC();
+    SSATmp* offset = m_tb.genDefConst<int64>(StringData::sizeOffset());
+    SSATmp* ans = m_tb.genLdRaw(input, offset, Type::Int);
+    m_tb.genDecRef(input);
+    // XXX We need a LdRaw that loads 32 bits, but what's the right way?
+    push(m_tb.genAnd(ans, m_tb.genDefConst<int64>(0xffffffff)));
+  } else if (Type::isNull(inType)) {
+    push(m_tb.genDefConst<int64>(0));
+  } else if (inType == Type::Bool) {
+    // strlen(true) == 1, strlen(false) == 0.
+    push(m_tb.genConvToInt(popC()));
+  } else if (inType == Type::Arr) {
+    SSATmp* input = popC();
+    push(m_tb.genDefConst<int64>(strlen("Array")));
+    m_tb.genDecRef(input);
+  } else {
+    spillStack();
+    popC();
+    emitInterpOneOrPunt(Type::Int);
+  }
+}
+
 SSATmp* HhbcTranslator::getClsPropAddr(const Class* cls,
                                        const StringData* propName) {
   SSATmp* clsTmp = popA();
diff --git a/src/runtime/vm/translator/hopt/hhbctranslator.h b/src/runtime/vm/translator/hopt/hhbctranslator.h
@@ -287,6 +287,8 @@ class HhbcTranslator {
   void emitContStopped();
   void emitContHandle();
 
+  void emitStrlen();
+
   // tracelet guards
   Trace* guardTypeStack(uint32 stackIndex,
                         Type::Tag type,
diff --git a/src/runtime/vm/translator/hopt/irtranslator.cpp b/src/runtime/vm/translator/hopt/irtranslator.cpp
@@ -702,6 +702,11 @@ void TranslatorX64::irTranslateContHandle(const Tracelet& t,
   HHIR_EMIT(ContHandle);
 }
 
+void TranslatorX64::irTranslateStrlen(const Tracelet& t,
+                                      const NormalizedInstruction& i) {
+  HHIR_EMIT(Strlen);
+}
+
 void TranslatorX64::irTranslateClassExists(const Tracelet& t,
                                            const NormalizedInstruction& i) {
   const StringData* clsName = i.inputs[1]->rtt.valueStringOrNull();
diff --git a/src/runtime/vm/translator/translator-x64.cpp b/src/runtime/vm/translator/translator-x64.cpp
@@ -6972,6 +6972,71 @@ void TranslatorX64::translateContHandle(const Tracelet& t,
   not_reached();
 }
 
+void TranslatorX64::analyzeStrlen(Tracelet& t,
+                                  NormalizedInstruction& i) {
+  switch (i.inputs[0]->rtt.valueType()) {
+    NULLCASE() :
+    case KindOfBoolean:
+      i.m_txFlags = Native;
+      break;
+    STRINGCASE() :
+      // May have to destroy a StringData, but can't reenter
+      i.m_txFlags = Simple;
+      break;
+    case KindOfArray:
+      i.m_txFlags = Supported;
+      break;
+    case KindOfInt64:
+    case KindOfDouble:
+    case KindOfObject:
+      i.m_txFlags = Interp;
+      break;
+    default:
+      not_reached();
+  }
+}
+
+void TranslatorX64::translateStrlen(const Tracelet& t,
+                                    const NormalizedInstruction& i) {
+  PhysReg rInput = getReg(i.inputs[0]->location);
+  DataType inType = i.inputs[0]->rtt.valueType();
+
+  switch (inType) {
+    NULLCASE(): {
+      m_regMap.allocOutputRegs(i);
+      PhysReg rOutput = getReg(i.outStack->location);
+      a.  xor_reg64_reg64(rOutput, rOutput);
+      break;
+    }
+    case KindOfBoolean:
+      m_regMap.allocOutputRegs(i);
+      // Nothing. strlen(true) == 1, strlen(false) == 0
+      break;
+    STRINGCASE(): {
+      ScratchReg rScratch(m_regMap);
+      a.  load_reg64_disp_reg32(rInput, StringData::sizeOffset(), *rScratch);
+      emitDecRef(a, i, rInput, inType);
+      m_regMap.bindScratch(rScratch, i.outStack->location, KindOfInt64,
+                           RegInfo::DIRTY);
+      ASSERT(m_regMap.regIsFree(rInput));
+      break;
+    }
+    case KindOfArray: {
+      m_regMap.allocOutputRegs(i);
+      PhysReg rOutput = getReg(i.outStack->location);
+      emitDecRef(a, i, rInput, KindOfArray);
+      // You think I am kidding about this, but I am not. This is PHP.
+      a.  mov_imm32_reg32(strlen("Array"), rOutput);
+      break;
+    }
+    case KindOfInt64:
+    case KindOfDouble:
+    case KindOfObject:
+    default:
+      not_reached();
+  }
+}
+
 static void analyzeClassExistsImpl(NormalizedInstruction& i) {
   const int nameIdx = 1;
   const int autoIdx = 0;
diff --git a/src/runtime/vm/translator/translator-x64.h b/src/runtime/vm/translator/translator-x64.h
@@ -575,7 +575,8 @@ MINSTRS
   CASE(ContValid) \
   CASE(ContCurrent) \
   CASE(ContStopped) \
-  CASE(ContHandle)
+  CASE(ContHandle) \
+  CASE(Strlen)
 
   // These are instruction-like functions which cover more than one
   // opcode.
diff --git a/src/runtime/vm/translator/translator.cpp b/src/runtime/vm/translator/translator.cpp
@@ -1159,6 +1159,7 @@ static const struct {
   { OpContCurrent, {None,             Stack1,       OutUnknown,        1 }},
   { OpContStopped, {None,             None,         OutNone,           0 }},
   { OpContHandle,  {Stack1,           None,         OutNone,          -1 }},
+  { OpStrlen,      {Stack1,           Stack1,       OutInt64,          0 }},
 };
 
 static hphp_hash_map<Opcode, InstrInfo> instrInfo;
diff --git a/src/test/vm/rename_dynamic.php b/src/test/vm/rename_dynamic.php
@@ -8,20 +8,20 @@ function prefix() {
   return "__rename_func_";
 }
 
-$stub_name = prefix() . 'strlen';
+$stub_name = prefix() . 'strtoupper';
 
-var_dump(strlen(''));
-fb_rename_function('strlen', $stub_name);
-fb_rename_function('bungle', 'strlen');
-var_dump(strlen(''));
+var_dump(strtoupper('tweet'));
+fb_rename_function('strtoupper', $stub_name);
+fb_rename_function('bungle', 'strtoupper');
+var_dump(strtoupper('tweet'));
 
 // release stringdata
 unset($stub_name);
 
 // try to allocate something in that memory
 $stub_name = prefix() . 'hagfish';
 
-$stub_name = prefix() . 'strlen';
-fb_rename_function('strlen', 'bungle');
-fb_rename_function($stub_name, 'strlen');
-var_dump(strlen(''));
+$stub_name = prefix() . 'strtoupper';
+fb_rename_function('strtoupper', 'bungle');
+fb_rename_function($stub_name, 'strtoupper');
+var_dump(strtoupper('tweet'));
diff --git a/src/test/vm/rename_dynamic.php.exp b/src/test/vm/rename_dynamic.php.exp
@@ -1,3 +1,3 @@
-int(0)
+string(5) "TWEET"
 int(314159)
-int(0)
+string(5) "TWEET"
