[Atomics] code stubs for atomic operations

src/compiler/js-intrinsic-lowering.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/js-intrinsic-lowering.h"
 
 #include <stack>
 
 #include "src/code-factory.h"
 #include "src/compiler/access-builder.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/linkage.h"
 #include "src/compiler/node-matchers.h"
 #include "src/compiler/node-properties.h"
 #include "src/compiler/operator-properties.h"
 #include "src/counters.h"
 #include "src/objects-inl.h"
 #include "src/type-cache.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
+// TODO(binji): copied from js-generic-lowering.cc, combine?
+static CallDescriptor::Flags AdjustFrameStatesForCall(Node* node) {

[Jarin, 2016/01/28 08:11:12]

I believe here you only need a simpler version because the frame state count
should be always > 0. 

Do you ever see count == 0 here? 

If no, then maybe DCHECK(count > 0) and you do not have to pass the flags in the
methods below.

Actually, thinking about it more, your stubs should never cause lazy deopt, so
maybe we could try to wire this up without frame states. In any case, you should
know statically whether you need a frame state or not.

[binji, 2016/01/28 16:20:01]

No, I think I was ending up with multiple frame states.
 
Can't say I fully understand this. I just found that when I tried to call the
stub without this, I was hitting an assert due to mismatching input counts.

[Jarin, 2016/02/01 07:42:43]

What I am saying is that you should not adapt based on the frame state count of
the node. Since the load can never cause a deoptimization, it should be fine to
always remove all the frame state inputs and then set CallDescriptor::kNoFlags
for the call.
Yeah, it is complicated, not many people understand this. If we do the builtin
approach, none of this will be necessary.

+  int count = OperatorProperties::GetFrameStateInputCount(node->op());
+  if (count > 1) {
+    int index = NodeProperties::FirstFrameStateIndex(node) + 1;
+    do {
+      node->RemoveInput(index);
+    } while (--count > 1);
+  }
+  return count > 0 ? CallDescriptor::kNeedsFrameState
+                   : CallDescriptor::kNoFlags;
+}
+
 JSIntrinsicLowering::JSIntrinsicLowering(Editor* editor, JSGraph* jsgraph,
                                          DeoptimizationMode mode)
     : AdvancedReducer(editor),
       jsgraph_(jsgraph),
       mode_(mode),
       type_cache_(TypeCache::Get()) {}
 
 
 Reduction JSIntrinsicLowering::Reduce(Node* node) {
   if (node->opcode() != IrOpcode::kJSCallRuntime) return NoChange();
@@ skipping 66 matching lines @@
     case Runtime::kInlineToPrimitive:
       return ReduceToPrimitive(node);
     case Runtime::kInlineToString:
       return ReduceToString(node);
     case Runtime::kInlineCall:
       return ReduceCall(node);
     case Runtime::kInlineTailCall:
       return ReduceTailCall(node);
     case Runtime::kInlineGetSuperConstructor:
       return ReduceGetSuperConstructor(node);
+    case Runtime::kInlineAtomicsLoad:
+      return ReduceAtomicsLoad(node);
     default:
       break;
   }
   return NoChange();
 }
 
 
 Reduction JSIntrinsicLowering::ReduceCreateIterResultObject(Node* node) {
   Node* const value = NodeProperties::GetValueInput(node, 0);
   Node* const done = NodeProperties::GetValueInput(node, 1);
@@ skipping 344 matching lines @@
   Node* store = (graph()->NewNode(
       simplified()->StoreElement(AccessBuilder::ForFixedArrayElement()), base,
       index, value, effect, control));
   ReplaceWithValue(node, value, store);
   return Changed(store);
 }
 
 
 Reduction JSIntrinsicLowering::ReduceRegExpConstructResult(Node* node) {
   // TODO(bmeurer): Introduce JSCreateRegExpResult?
-  return Change(node, CodeFactory::RegExpConstructResult(isolate()), 0);
+  return Change(node, CodeFactory::RegExpConstructResult(isolate()), 0,
+                CallDescriptor::kNeedsFrameState);
 }
 
 
 Reduction JSIntrinsicLowering::ReduceRegExpExec(Node* node) {
-  return Change(node, CodeFactory::RegExpExec(isolate()), 4);
+  return Change(node, CodeFactory::RegExpExec(isolate()), 4,
+                CallDescriptor::kNeedsFrameState);
 }
 
 
 Reduction JSIntrinsicLowering::ReduceRegExpFlags(Node* node) {
   Node* const receiver = NodeProperties::GetValueInput(node, 0);
   Node* const effect = NodeProperties::GetEffectInput(node);
   Node* const control = NodeProperties::GetControlInput(node);
   Operator const* const op =
       simplified()->LoadField(AccessBuilder::ForJSRegExpFlags());
   return Change(node, op, receiver, effect, control);
 }
 
 
 Reduction JSIntrinsicLowering::ReduceRegExpSource(Node* node) {
   Node* const receiver = NodeProperties::GetValueInput(node, 0);
   Node* const effect = NodeProperties::GetEffectInput(node);
   Node* const control = NodeProperties::GetControlInput(node);
   Operator const* const op =
       simplified()->LoadField(AccessBuilder::ForJSRegExpSource());
   return Change(node, op, receiver, effect, control);
 }
 
 
 Reduction JSIntrinsicLowering::ReduceSubString(Node* node) {
-  return Change(node, CodeFactory::SubString(isolate()), 3);
+  return Change(node, CodeFactory::SubString(isolate()), 3,
+                CallDescriptor::kNeedsFrameState);
 }
 
 
 Reduction JSIntrinsicLowering::ReduceToInteger(Node* node) {
   Node* value = NodeProperties::GetValueInput(node, 0);
   Type* value_type = NodeProperties::GetType(value);
   if (value_type->Is(type_cache().kIntegerOrMinusZero)) {
     ReplaceWithValue(node, value);
     return Replace(value);
   }
@@ skipping 38 matching lines @@
                              jsgraph()->Constant(kMaxSafeInteger), value),
             jsgraph()->Constant(kMaxSafeInteger), value);
         value_type =
             Type::Range(value_type->Min(), kMaxSafeInteger, graph()->zone());
         NodeProperties::SetType(value, value_type);
       }
     }
     ReplaceWithValue(node, value);
     return Replace(value);
   }
-  return Change(node, CodeFactory::ToLength(isolate()), 0);
+  return Change(node, CodeFactory::ToLength(isolate()), 0,
+                CallDescriptor::kNeedsFrameState);
 }
 
 
 Reduction JSIntrinsicLowering::ReduceToObject(Node* node) {
   NodeProperties::ChangeOp(node, javascript()->ToObject());
   return Changed(node);
 }
 
 
 Reduction JSIntrinsicLowering::ReduceToPrimitive(Node* node) {
@@ skipping 37 matching lines @@
   Node* active_function = NodeProperties::GetValueInput(node, 0);
   Node* effect = NodeProperties::GetEffectInput(node);
   Node* control = NodeProperties::GetControlInput(node);
   Node* active_function_map = effect =
       graph()->NewNode(simplified()->LoadField(AccessBuilder::ForMap()),
                        active_function, effect, control);
   return Change(node, simplified()->LoadField(AccessBuilder::ForMapPrototype()),
                 active_function_map, effect, control);
 }
 
+Reduction JSIntrinsicLowering::ReduceAtomicsLoad(Node* node) {
+  CallDescriptor::Flags flags = AdjustFrameStatesForCall(node);
+  return Change(node, CodeFactory::AtomicsLoad(isolate()), 0, flags);
+}
 
 Reduction JSIntrinsicLowering::Change(Node* node, const Operator* op, Node* a,
                                       Node* b) {
   RelaxControls(node);
   node->ReplaceInput(0, a);
   node->ReplaceInput(1, b);
   node->TrimInputCount(2);
   NodeProperties::ChangeOp(node, op);
   return Changed(node);
 }
@@ skipping 22 matching lines @@
   NodeProperties::ChangeOp(node, op);
   return Changed(node);
 }
 
 
 Reduction JSIntrinsicLowering::ChangeToUndefined(Node* node, Node* effect) {
   ReplaceWithValue(node, jsgraph()->UndefinedConstant(), effect);
   return Changed(node);
 }
 
-
 Reduction JSIntrinsicLowering::Change(Node* node, Callable const& callable,
-                                      int stack_parameter_count) {
+                                      int stack_parameter_count,
+                                      CallDescriptor::Flags flags) {
   CallDescriptor const* const desc = Linkage::GetStubCallDescriptor(
       isolate(), graph()->zone(), callable.descriptor(), stack_parameter_count,
-      CallDescriptor::kNeedsFrameState, node->op()->properties());
+      flags, node->op()->properties());
   node->InsertInput(graph()->zone(), 0,
                     jsgraph()->HeapConstant(callable.code()));
   NodeProperties::ChangeOp(node, common()->Call(desc));
   return Changed(node);
 }
 
 
 Graph* JSIntrinsicLowering::graph() const { return jsgraph()->graph(); }
 
 
@@ skipping 14 matching lines @@
 }
 
 
 SimplifiedOperatorBuilder* JSIntrinsicLowering::simplified() const {
   return jsgraph()->simplified();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8