[Atomics] code stubs for atomic operations

src/compiler/js-intrinsic-lowering.cc

Index: src/compiler/js-intrinsic-lowering.cc
diff --git a/src/compiler/js-intrinsic-lowering.cc b/src/compiler/js-intrinsic-lowering.cc
index ca5cb932b4bd7606521b32ae63c7c8076779d74f..7b1059ffc612888d0386f9ea8f1dafefde739e0f 100644
--- a/src/compiler/js-intrinsic-lowering.cc
+++ b/src/compiler/js-intrinsic-lowering.cc
@@ -21,6 +21,19 @@ 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),
@@ -107,6 +120,8 @@ Reduction JSIntrinsicLowering::Reduce(Node* node) {
       return ReduceTailCall(node);
     case Runtime::kInlineGetSuperConstructor:
       return ReduceGetSuperConstructor(node);
+    case Runtime::kInlineAtomicsLoad:
+      return ReduceAtomicsLoad(node);
     default:
       break;
   }
@@ -471,12 +486,14 @@ Reduction JSIntrinsicLowering::ReduceFixedArraySet(Node* node) {
 
 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);
 }
 
 
@@ -501,7 +518,8 @@ Reduction JSIntrinsicLowering::ReduceRegExpSource(Node* node) {
 
 
 Reduction JSIntrinsicLowering::ReduceSubString(Node* node) {
-  return Change(node, CodeFactory::SubString(isolate()), 3);
+  return Change(node, CodeFactory::SubString(isolate()), 3,
+                CallDescriptor::kNeedsFrameState);
 }
 
 
@@ -560,7 +578,8 @@ Reduction JSIntrinsicLowering::ReduceToLength(Node* node) {
     ReplaceWithValue(node, value);
     return Replace(value);
   }
-  return Change(node, CodeFactory::ToLength(isolate()), 0);
+  return Change(node, CodeFactory::ToLength(isolate()), 0,
+                CallDescriptor::kNeedsFrameState);
 }
 
 
@@ -618,6 +637,10 @@ Reduction JSIntrinsicLowering::ReduceGetSuperConstructor(Node* node) {
                 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) {
@@ -660,12 +683,12 @@ Reduction JSIntrinsicLowering::ChangeToUndefined(Node* node, Node* 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));