Add CodeStubAssembler::FlattenString

src/code-stub-assembler.cc

 // Copyright 2016 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 #include "src/code-stub-assembler.h"
 #include "src/code-factory.h"
 #include "src/frames-inl.h"
 #include "src/frames.h"
 #include "src/ic/handler-configuration.h"
 #include "src/ic/stub-cache.h"
 
@@ skipping 3592 matching lines @@
 
   Bind(&not_heap_number);
   {
     GotoIf(Word32NotEqual(input_instance_type, Int32Constant(ODDBALL_TYPE)),
            &runtime);
     result.Bind(LoadObjectField(input, Oddball::kToStringOffset));
     Goto(&done);
   }
 
   Bind(&runtime);
-  {
-    result.Bind(CallRuntime(Runtime::kToString, context, input));
-    Goto(&done);
-  }
+  result.Bind(CallRuntime(Runtime::kToString, context, input));

[danno, 2016/10/20 08:35:52]

After our discussion, not sure if you want this whitespace change.

+  Goto(&done);
 
   Bind(&done);
   return result.value();
 }
 
+Node* CodeStubAssembler::FlattenString(Node* string) {
+  Variable var_result(this, MachineRepresentation::kTagged);
+  var_result.Bind(string);
+
+  Node* instance_type = LoadInstanceType(string);
+
+  // Check if the {string} is not a ConsString (i.e. already flat).
+  Label is_flat_in_cons(this), end(this);
+  GotoUnless(Word32Equal(Word32And(instance_type,
+                                   Int32Constant(kStringRepresentationMask)),
+                         Int32Constant(kConsStringTag)),
+             &end);
+
+  // Check whether the right hand side is the empty string (i.e. if
+  // this is really a flat string in a cons string).
+  Node* rhs = LoadObjectField(string, ConsString::kSecondOffset);
+  GotoIf(WordEqual(rhs, EmptyStringConstant()), &is_flat_in_cons);
+
+  // Bail out to the runtime.

[danno, 2016/10/20 08:35:52]

Make this label deferred. You can make that efficient by making the above
statement a GotoUnless to the runtime label, which you explicitly declare as
deferred.

+  var_result.Bind(
+      CallRuntime(Runtime::kFlattenString, NoContextConstant(), string));
+  Goto(&end);
+
+  Bind(&is_flat_in_cons);
+  var_result.Bind(LoadObjectField(string, ConsString::kFirstOffset));
+  Goto(&end);
+
+  Bind(&end);
+  return var_result.value();
+}
+
 Node* CodeStubAssembler::JSReceiverToPrimitive(Node* context, Node* input) {
   STATIC_ASSERT(LAST_JS_RECEIVER_TYPE == LAST_TYPE);
   Label if_isreceiver(this, Label::kDeferred), if_isnotreceiver(this);
   Variable result(this, MachineRepresentation::kTagged);
   Label done(this, &result);
 
   GotoIf(TaggedIsSmi(input), &if_isnotreceiver);
 
   Node* map = LoadMap(input);
   Node* instance_type = LoadMapInstanceType(map);
@@ skipping 4675 matching lines @@
   Node* buffer_bit_field = LoadObjectField(
       buffer, JSArrayBuffer::kBitFieldOffset, MachineType::Uint32());
   Node* was_neutered_mask = Int32Constant(JSArrayBuffer::WasNeutered::kMask);
 
   return Word32NotEqual(Word32And(buffer_bit_field, was_neutered_mask),
                         Int32Constant(0));
 }
 
 }  // namespace internal
 }  // namespace v8