Add support for untagged LoadField, StoreField, LoadElement, and StoreElement simplfied operators. …

src/compiler/simplified-lowering.cc

 // Copyright 2014 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/simplified-lowering.h"
 
 #include "src/compiler/graph-inl.h"
 #include "src/compiler/node-properties-inl.h"
 #include "src/objects.h"
 
@@ skipping 175 matching lines @@
   Node* merge = graph()->NewNode(common()->Merge(2), tbranch, fbranch);
   Node* phi = graph()->NewNode(common()->Phi(2), jsgraph()->TrueConstant(),
                                jsgraph()->FalseConstant(), merge);
   UpdateControlSuccessors(control, merge);
   branch->ReplaceInput(1, control);
   node->ReplaceUses(phi);
 }
 
 
 static WriteBarrierKind ComputeWriteBarrierKind(
-    MachineRepresentation representation, Type* type) {
+    bool base_is_tagged, MachineRepresentation representation, Type* type) {

[Benedikt Meurer, 2014/08/04 12:18:31]

Nit: Use that same enum here as well.

   // TODO(turbofan): skip write barriers for Smis, etc.
-  if (representation == kMachineTagged) {
+  if (base_is_tagged && representation == kMachineTagged) {
+    // Write barriers are only for writes into heap objects (i.e. tagged base).
     return kFullWriteBarrier;
   }
   return kNoWriteBarrier;
 }
 
 
 void SimplifiedLowering::DoLoadField(Node* node, Node* effect, Node* control) {
   const FieldAccess& access = FieldAccessOf(node->op());
   node->set_op(machine_.Load(access.representation));
-  Node* offset =
-      graph()->NewNode(common()->Int32Constant(access.offset - kHeapObjectTag));
+  Node* offset = jsgraph()->Int32Constant(access.offset - access.tag());
   node->InsertInput(zone(), 1, offset);
 }
 
 
 void SimplifiedLowering::DoStoreField(Node* node, Node* effect, Node* control) {
   const FieldAccess& access = FieldAccessOf(node->op());
-  WriteBarrierKind kind =
-      ComputeWriteBarrierKind(access.representation, access.type);
+  WriteBarrierKind kind = ComputeWriteBarrierKind(
+      access.tag() != 0, access.representation, access.type);
   node->set_op(machine_.Store(access.representation, kind));
-  Node* offset =
-      graph()->NewNode(common()->Int32Constant(access.offset - kHeapObjectTag));
+  Node* offset = jsgraph()->Int32Constant(access.offset - access.tag());
   node->InsertInput(zone(), 1, offset);
 }
 
 
 Node* SimplifiedLowering::ComputeIndex(const ElementAccess& access,
                                        Node* index) {
   int element_size = 0;
   switch (access.representation) {
     case kMachineTagged:
       element_size = kPointerSize;
       break;
     case kMachineWord8:
       element_size = 1;
       break;
     case kMachineWord16:
       element_size = 2;
       break;
     case kMachineWord32:
       element_size = 4;
       break;
     case kMachineWord64:
     case kMachineFloat64:
       element_size = 8;
       break;
     case kMachineLast:
       UNREACHABLE();
       break;
   }
   if (element_size != 1) {
-    index = graph()->NewNode(
-        machine()->Int32Mul(),
-        graph()->NewNode(common()->Int32Constant(element_size)), index);
+    index = graph()->NewNode(machine()->Int32Mul(),
+                             jsgraph()->Int32Constant(element_size), index);
   }
-  int fixed_offset = access.header_size - kHeapObjectTag;
+  int fixed_offset = access.header_size - access.tag();
   if (fixed_offset == 0) return index;
-  return graph()->NewNode(
-      machine()->Int32Add(),
-      graph()->NewNode(common()->Int32Constant(fixed_offset)), index);
+  return graph()->NewNode(machine()->Int32Add(),
+                          jsgraph()->Int32Constant(fixed_offset), index);
 }
 
 
 void SimplifiedLowering::DoLoadElement(Node* node, Node* effect,
                                        Node* control) {
   const ElementAccess& access = ElementAccessOf(node->op());
   node->set_op(machine_.Load(access.representation));
   node->ReplaceInput(1, ComputeIndex(access, node->InputAt(1)));
 }
 
 
 void SimplifiedLowering::DoStoreElement(Node* node, Node* effect,
                                         Node* control) {
   const ElementAccess& access = ElementAccessOf(node->op());
-  WriteBarrierKind kind =
-      ComputeWriteBarrierKind(access.representation, access.type);
+  WriteBarrierKind kind = ComputeWriteBarrierKind(
+      access.tag() != 0, access.representation, access.type);
   node->set_op(machine_.Store(access.representation, kind));
   node->ReplaceInput(1, ComputeIndex(access, node->InputAt(1)));
 }
 
 
 void SimplifiedLowering::Lower(Node* node) {
   Node* start = graph()->start();
   switch (node->opcode()) {
     case IrOpcode::kBooleanNot:
     case IrOpcode::kNumberEqual:
@@ skipping 49 matching lines @@
       DoStoreElement(node, start, start);
       break;
     default:
       break;
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8