Internalize strings in-place

src/compiler/effect-control-linearizer.cc

 // Copyright 2015 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/compiler/effect-control-linearizer.h"
 
 #include "src/code-factory.h"
 #include "src/compiler/access-builder.h"
 #include "src/compiler/compiler-source-position-table.h"
 #include "src/compiler/js-graph.h"
@@ skipping 2213 matching lines @@
 
   return ValueEffectControl(value, effect, control);
 }
 
 EffectControlLinearizer::ValueEffectControl
 EffectControlLinearizer::LowerStringCharCodeAt(Node* node, Node* effect,
                                                Node* control) {
   Node* subject = node->InputAt(0);
   Node* index = node->InputAt(1);
 
   // We may need to loop several times for ConsString/SlicedString {subject}s.

[Igor Sheludko, 2016/12/20 23:46:58]

/ThinString

[Jakob Kummerow, 2017/01/04 12:45:06]

Done.

-  Node* loop =
-      graph()->NewNode(common()->Loop(4), control, control, control, control);
+  Node* loop = graph()->NewNode(common()->Loop(5), control, control, control,
+                                control, control);
   Node* lsubject =
-      graph()->NewNode(common()->Phi(MachineRepresentation::kTagged, 4),
-                       subject, subject, subject, subject, loop);
+      graph()->NewNode(common()->Phi(MachineRepresentation::kTagged, 5),
+                       subject, subject, subject, subject, subject, loop);
   Node* lindex =
-      graph()->NewNode(common()->Phi(MachineRepresentation::kWord32, 4), index,
-                       index, index, index, loop);
-  Node* leffect = graph()->NewNode(common()->EffectPhi(4), effect, effect,
-                                   effect, effect, loop);
+      graph()->NewNode(common()->Phi(MachineRepresentation::kWord32, 5), index,
+                       index, index, index, index, loop);
+  Node* leffect = graph()->NewNode(common()->EffectPhi(5), effect, effect,
+                                   effect, effect, effect, loop);
 
   control = loop;
   effect = leffect;
 
   // Determine the instance type of {lsubject}.
   Node* lsubject_map = effect =
       graph()->NewNode(simplified()->LoadField(AccessBuilder::ForMap()),
                        lsubject, effect, control);
   Node* lsubject_instance_type = effect = graph()->NewNode(
       simplified()->LoadField(AccessBuilder::ForMapInstanceType()),
@@ skipping 194 matching lines @@
         etrue2 =
             graph()->NewNode(common()->EffectPhi(2), etrue3, efalse3, if_true2);
         vtrue2 =
             graph()->NewNode(common()->Phi(MachineRepresentation::kWord32, 2),
                              vtrue3, vfalse3, if_true2);
       }
 
       Node* if_false2 = graph()->NewNode(common()->IfFalse(), branch2);
       Node* efalse2 = efalse1;
       {
-        // The {lsubject} is a SlicedString, continue with its parent.
-        Node* lsubject_parent = efalse2 = graph()->NewNode(
-            simplified()->LoadField(AccessBuilder::ForSlicedStringParent()),
-            lsubject, efalse2, if_false2);
-        Node* lsubject_offset = efalse2 = graph()->NewNode(
-            simplified()->LoadField(AccessBuilder::ForSlicedStringOffset()),
-            lsubject, efalse2, if_false2);
-        Node* lsubject_index = graph()->NewNode(
-            machine()->Int32Add(), lindex, ChangeSmiToInt32(lsubject_offset));
+        // Check if the {lsubject} is a SlicedString.
+        Node* check3 = graph()->NewNode(
+            machine()->Word32Equal(),
+            graph()->NewNode(
+                machine()->Word32And(), lsubject_instance_type,
+                jsgraph()->Int32Constant(kStringRepresentationMask)),
+            jsgraph()->Int32Constant(kSlicedStringTag));
+        Node* branch3 = graph()->NewNode(common()->Branch(), check3, if_false2);
 
-        // Retry the {loop} with the parent subject.
-        loop->ReplaceInput(3, if_false2);
-        leffect->ReplaceInput(3, efalse2);
-        lindex->ReplaceInput(3, lsubject_index);
-        lsubject->ReplaceInput(3, lsubject_parent);
+        Node* if_true3 = graph()->NewNode(common()->IfTrue(), branch3);
+        Node* etrue3 = efalse2;
+        {
+          // The {lsubject} is a SlicedString, continue with its parent.
+          Node* lsubject_parent = etrue3 = graph()->NewNode(
+              simplified()->LoadField(AccessBuilder::ForSlicedStringParent()),
+              lsubject, etrue3, if_true3);
+          Node* lsubject_offset = etrue3 = graph()->NewNode(
+              simplified()->LoadField(AccessBuilder::ForSlicedStringOffset()),
+              lsubject, etrue3, if_true3);
+          Node* lsubject_index = graph()->NewNode(
+              machine()->Int32Add(), lindex, ChangeSmiToInt32(lsubject_offset));
+
+          // Retry the {loop} with the parent subject.
+          loop->ReplaceInput(3, if_true3);
+          leffect->ReplaceInput(3, etrue3);
+          lindex->ReplaceInput(3, lsubject_index);
+          lsubject->ReplaceInput(3, lsubject_parent);
+        }
+
+        Node* if_false3 = graph()->NewNode(common()->IfFalse(), branch3);
+        Node* efalse3 = efalse2;
+        {
+          // The {lsubject} is a ThinString, continue with its actual value.
+          Node* lsubject_actual = efalse3 = graph()->NewNode(
+              simplified()->LoadField(AccessBuilder::ForThinStringActual()),
+              lsubject, efalse3, if_false3);
+
+          // Retry the {loop} with the actual subject.
+          loop->ReplaceInput(4, if_false3);
+          leffect->ReplaceInput(4, efalse3);
+          lsubject->ReplaceInput(4, lsubject_actual);
+        }
       }
 
       if_false1 = if_true2;
       efalse1 = etrue2;
       vfalse1 = vtrue2;
     }
 
     if_false0 = if_false1;
     efalse0 = efalse1;
     vfalse0 = vfalse1;
@@ skipping 1332 matching lines @@
         isolate(), graph()->zone(), callable.descriptor(), 0, flags,
         Operator::kEliminatable);
     to_number_operator_.set(common()->Call(desc));
   }
   return to_number_operator_.get();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8