[Atomics] code stubs for atomic operations

src/compiler/code-stub-assembler.h

 // 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.
 
 #ifndef V8_COMPILER_CODE_STUB_ASSEMBLER_H_
 #define V8_COMPILER_CODE_STUB_ASSEMBLER_H_
 
 // Clients of this interface shouldn't depend on lots of compiler internals.
 // Do not include anything from src/compiler here!
 #include "src/allocation.h"
 #include "src/builtins.h"
+#include "src/machine-type.h"
 #include "src/runtime/runtime.h"
 
 namespace v8 {
 namespace internal {
 
 class CallInterfaceDescriptor;
 class Isolate;
 class Zone;
 
 namespace compiler {
@@ skipping 14 matching lines @@
 
   Handle<Code> GenerateCode();
 
   // Constants.
   Node* Int32Constant(int value);
   Node* IntPtrConstant(intptr_t value);
   Node* NumberConstant(double value);
   Node* HeapConstant(Handle<HeapObject> object);
   Node* BooleanConstant(bool value);
 
+  // Memory Operations.
+  Node* Load(MachineType rep, Node* base);
+  Node* Load(MachineType rep, Node* base, Node* index);
+
   Node* Parameter(int value);
+  Node* StackArg(Node* num_args, int value);
+  Node* StackArgOrUndefined(Node* num_args, int value);

[Jarin, 2016/02/03 09:04:07]

You should not need this, just use Parameter.

[binji, 2016/02/03 22:09:02]

This doesn't seem to work, perhaps I'm doing it wrong? Parameter() seems to
return the descriptor registers, in order. (e.g. Parameter(0) returns the value
of rax, which is argc for the function call). But the builtin has all of its
parameters stored on the stack. Is there an easy way to automatically fill the
registers with these stack values?

[Jarin, 2016/02/04 05:28:01]

We looked at this with Benedikt and it looks like the problem is that the
linkage uses the BuiltinDescriptor to describe the parameters, and that only
defines the register parameters. 

Instead, we need to initialize CodeStubAssembler with JSCallDesriptor. Could you
try to define a new constructor that calls Linkage::JSCallDescriptor (rather
than  Linkage::GetStubCallDescriptor)?

In any case, thanks for exploring this, you are awesome!

[binji, 2016/02/05 02:53:01]

Thanks, that works. Done!

   void Return(Node* value);
 
   // Tag and untag Smi values.
   Node* SmiTag(Node* value);
   Node* SmiUntag(Node* value);
 
   // Basic arithmetic operations.
   Node* IntPtrAdd(Node* a, Node* b);
   Node* IntPtrSub(Node* a, Node* b);
   Node* WordShl(Node* value, int shift);
@@ skipping 30 matching lines @@
   bool code_generated_;
 
   DISALLOW_COPY_AND_ASSIGN(CodeStubAssembler);
 };
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_CODE_STUB_ASSEMBLER_H_