Turn the NumberToStringStub into a hydrogen stub.

src/hydrogen.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 923 matching lines @@
 
   HArgumentsObject* arguments_object_;
   HArgumentsElements* arguments_elements_;
 
   FunctionState* outer_;
 };
 
 
 class HIfContinuation V8_FINAL {
  public:
-  HIfContinuation() { continuation_captured_ = false; }
+  HIfContinuation() : continuation_captured_(false) {}
+  HIfContinuation(HBasicBlock* true_branch,
+                  HBasicBlock* false_branch,
+                  int position = RelocInfo::kNoPosition)
+      : continuation_captured_(true), true_branch_(true_branch),
+        false_branch_(false_branch), position_(position) {}
   ~HIfContinuation() { ASSERT(!continuation_captured_); }
 
   void Capture(HBasicBlock* true_branch,
                HBasicBlock* false_branch,
                int position) {
     ASSERT(!continuation_captured_);
     true_branch_ = true_branch;
     false_branch_ = false_branch;
     position_ = position;
     continuation_captured_ = true;
   }
 
   void Continue(HBasicBlock** true_branch,
                 HBasicBlock** false_branch,
                 int* position) {
     ASSERT(continuation_captured_);
     *true_branch = true_branch_;
     *false_branch = false_branch_;
     if (position != NULL) *position = position_;
     continuation_captured_ = false;
   }
 
   bool IsTrueReachable() { return true_branch_ != NULL; }
   bool IsFalseReachable() { return false_branch_ != NULL; }
   bool TrueAndFalseReachable() {
     return IsTrueReachable() || IsFalseReachable();
   }
 
+  HBasicBlock* true_branch() const { return true_branch_; }
+  HBasicBlock* false_branch() const { return false_branch_; }
+
+ private:
   bool continuation_captured_;
   HBasicBlock* true_branch_;
   HBasicBlock* false_branch_;
   int position_;
 };
 
 
 class HGraphBuilder {
  public:
   explicit HGraphBuilder(CompilationInfo* info)
@@ skipping 238 matching lines @@
                                    HValue* elements,
                                    ElementsKind kind,
                                    HValue* length);
 
   void BuildTransitionElementsKind(HValue* object,
                                    HValue* map,
                                    ElementsKind from_kind,
                                    ElementsKind to_kind,
                                    bool is_jsarray);
 
+  // Do lookup in the number string cache. If the object is not found
+  // in the cache, the false branch of the continuation is taken;
+  // otherwise the true branch is taken and the returned value contains
+  // the cache value for the object. The returned value must NOT be used
+  // on the false branch.
+  HValue* BuildLookupNumberStringCache(HValue* object,
+                                       HIfContinuation* continuation);
+  HValue* BuildNumberToString(HValue* number);
+
   HInstruction* BuildUncheckedMonomorphicElementAccess(
       HValue* checked_object,
       HValue* key,
       HValue* val,
       bool is_js_array,
       ElementsKind elements_kind,
       bool is_store,
       LoadKeyedHoleMode load_mode,
       KeyedAccessStoreMode store_mode);
 
@@ skipping 126 matching lines @@
 
     template<class Condition, class P2, class P3>
     Condition* AndIf(HValue* p1, P2 p2, P3 p3) {
       And();
       return If<Condition>(p1, p2, p3);
     }
 
     void Or();
     void And();
 
+    // Captures the current state of this IfBuilder in the specified
+    // continuation and ends this IfBuilder.
     void CaptureContinuation(HIfContinuation* continuation);
 
+    // Joins the specified continuation from this IfBuilder and ends this
+    // IfBuilder. This appends a Goto instruction from the true branch of
+    // this IfBuilder to the true branch of the continuation unless the
+    // true branch of this IfBuilder is already finished. And vice versa
+    // for the false branch.
+    void JoinContinuation(HIfContinuation* continuation);
+
     void Then();
     void Else();
     void End();
 
     void Deopt(const char* reason);
     void ElseDeopt(const char* reason) {
       Else();
       Deopt(reason);
     }
 
@@ skipping 989 matching lines @@
   }
 
  private:
   HGraphBuilder* builder_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_H_