[Atomics] code stubs for atomic operations

src/compiler/code-stub-assembler.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/code-stub-assembler.h"
 
 #include <ostream>
 
 #include "src/code-factory.h"
 #include "src/compiler/graph.h"
@@ skipping 19 matching lines @@
                                      size_t result_size)
     : raw_assembler_(new RawMachineAssembler(
           isolate, new (zone) Graph(zone),
           Linkage::GetStubCallDescriptor(
               isolate, zone, descriptor, descriptor.GetStackParameterCount(),
               CallDescriptor::kNoFlags, Operator::kNoProperties,
               MachineType::AnyTagged(), result_size))),
       flags_(flags),
       name_(name),
       code_generated_(false),
-      variables_(zone) {}
+      variables_(zone),
+      linkage_type_(LinkageDescriptorType::kStubCall),
+      parameter_count_(descriptor.GetParameterCount()) {}
+
+
+CodeStubAssembler::CodeStubAssembler(Isolate* isolate, Zone* zone,
+                                     int parameter_count, Code::Flags flags,
+                                     const char* name)
+    : raw_assembler_(new RawMachineAssembler(
+          isolate, new (zone) Graph(zone),
+          Linkage::GetJSCallDescriptor(zone, false, parameter_count,
+                                       CallDescriptor::kNoFlags))),
+      flags_(flags),
+      name_(name),
+      code_generated_(false),
+      variables_(zone),
+      linkage_type_(LinkageDescriptorType::kJSCall),
+      parameter_count_(parameter_count) {}
 
 CodeStubAssembler::~CodeStubAssembler() {}
 
 void CodeStubAssembler::CallPrologue() {}
 
 void CodeStubAssembler::CallEpilogue() {}
 
 Handle<Code> CodeStubAssembler::GenerateCode() {
   DCHECK(!code_generated_);
 
@@ skipping 70 matching lines @@
   return raw_assembler_->WordSar(value, SmiShiftBitsConstant());
 }
 
 #define DEFINE_CODE_STUB_ASSEMBER_BINARY_OP(name)   \
   Node* CodeStubAssembler::name(Node* a, Node* b) { \
     return raw_assembler_->name(a, b);              \
   }
 CODE_STUB_ASSEMBLER_BINARY_OP_LIST(DEFINE_CODE_STUB_ASSEMBER_BINARY_OP)
 #undef DEFINE_CODE_STUB_ASSEMBER_BINARY_OP
 
-Node* CodeStubAssembler::ChangeInt32ToInt64(Node* value) {
-  return raw_assembler_->ChangeInt32ToInt64(value);
-}
-
 Node* CodeStubAssembler::WordShl(Node* value, int shift) {
   return raw_assembler_->WordShl(value, Int32Constant(shift));
 }
 
+
+#define DEFINE_CODE_STUB_ASSEMBER_UNARY_OP(name) \
+  Node* CodeStubAssembler::name(Node* a) { return raw_assembler_->name(a); }
+CODE_STUB_ASSEMBLER_UNARY_OP_LIST(DEFINE_CODE_STUB_ASSEMBER_UNARY_OP)
+#undef DEFINE_CODE_STUB_ASSEMBER_UNARY_OP
+
+
 Node* CodeStubAssembler::WordIsSmi(Node* a) {
   return WordEqual(raw_assembler_->WordAnd(a, Int32Constant(kSmiTagMask)),
                    Int32Constant(0));
 }
 
 Node* CodeStubAssembler::LoadBufferObject(Node* buffer, int offset) {
   return raw_assembler_->Load(MachineType::AnyTagged(), buffer,
                               IntPtrConstant(offset));
 }
 
 Node* CodeStubAssembler::LoadObjectField(Node* object, int offset) {
   return raw_assembler_->Load(MachineType::AnyTagged(), object,
                               IntPtrConstant(offset - kHeapObjectTag));
 }
 
+Node* CodeStubAssembler::LoadHeapNumber(Node* object) {
+  return raw_assembler_->Load(MachineType::Float64(), object,
+                              IntPtrConstant(HeapNumber::kValueOffset));
+}
+
 Node* CodeStubAssembler::LoadFixedArrayElementSmiIndex(Node* object,
                                                        Node* smi_index,
                                                        int additional_offset) {
   Node* header_size = raw_assembler_->Int32Constant(
       additional_offset + FixedArray::kHeaderSize - kHeapObjectTag);
   Node* scaled_index =
       (kSmiShiftSize == 0)
           ? raw_assembler_->Word32Shl(
                 smi_index, Int32Constant(kPointerSizeLog2 - kSmiTagSize))
           : raw_assembler_->Word32Shl(SmiUntag(smi_index),
@@ skipping 55 matching lines @@
 Node* CodeStubAssembler::StoreNoWriteBarrier(MachineRepresentation rep,
                                              Node* base, Node* index,
                                              Node* value) {
   return raw_assembler_->Store(rep, base, index, value, kNoWriteBarrier);
 }
 
 Node* CodeStubAssembler::Projection(int index, Node* value) {
   return raw_assembler_->Projection(index, value);
 }
 
+Node* CodeStubAssembler::InstanceType(Node* object) {
+  return raw_assembler_->WordAnd(
+      LoadObjectField(LoadObjectField(object, HeapObject::kMapOffset),
+                      Map::kInstanceTypeOffset),
+      raw_assembler_->Int32Constant(255));
+}
+
+Node* CodeStubAssembler::BitFieldValue(Node* word32, uint32_t shift,
+                                       uint32_t mask) {
+  return raw_assembler_->Word32Shr(
+      raw_assembler_->Word32And(word32, raw_assembler_->Int32Constant(mask)),
+      raw_assembler_->Int32Constant(shift));
+}
+
+Node* CodeStubAssembler::Context() {

[binji, 2016/02/12 01:46:56]

This seems a bit weird, but seems to work. Better way to do this?

[Benedikt Meurer, 2016/02/12 05:58:38]

I think we shouldn't have this helper method, it's actually confusing. Please
just use the Parameter node in the builtin.

[binji, 2016/02/12 20:35:18]

Done.

+  switch (linkage_type_) {
+    case LinkageDescriptorType::kStubCall:
+      return Parameter(Linkage::GetStubCallContextParamIndex(parameter_count_));
+
+    case LinkageDescriptorType::kJSCall:
+      return Parameter(Linkage::GetJSCallContextParamIndex(parameter_count_));
+  }
+}
+
 Node* CodeStubAssembler::CallN(CallDescriptor* descriptor, Node* code_target,
                                Node** args) {
   CallPrologue();
   Node* return_value = raw_assembler_->CallN(descriptor, code_target, args);
   CallEpilogue();
   return return_value;
 }
 
 
 Node* CodeStubAssembler::TailCallN(CallDescriptor* descriptor,
@@ skipping 40 matching lines @@
                                      Node* context, Node* arg1, Node* arg2,
                                      Node* arg3, Node* arg4) {
   CallPrologue();
   Node* return_value = raw_assembler_->CallRuntime4(function_id, arg1, arg2,
                                                     arg3, arg4, context);
   CallEpilogue();
   return return_value;
 }
 
 Node* CodeStubAssembler::TailCallRuntime(Runtime::FunctionId function_id,
+                                         Node* context) {
+  return raw_assembler_->TailCallRuntime0(function_id, context);
+}
+
+Node* CodeStubAssembler::TailCallRuntime(Runtime::FunctionId function_id,
                                          Node* context, Node* arg1) {
   return raw_assembler_->TailCallRuntime1(function_id, arg1, context);
 }
 
 Node* CodeStubAssembler::TailCallRuntime(Runtime::FunctionId function_id,
                                          Node* context, Node* arg1,
                                          Node* arg2) {
   return raw_assembler_->TailCallRuntime2(function_id, arg1, arg2, context);
 }
 
@@ skipping 303 matching lines @@
       }
     }
   }
 
   bound_ = true;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8