[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"
 #include "src/compiler/instruction-selector.h"
 #include "src/compiler/linkage.h"
 #include "src/compiler/pipeline.h"
 #include "src/compiler/raw-machine-assembler.h"
 #include "src/compiler/schedule.h"
 #include "src/frames.h"
 #include "src/interface-descriptors.h"
 #include "src/interpreter/bytecodes.h"
 #include "src/machine-type.h"
 #include "src/macro-assembler.h"
 #include "src/zone.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
-
 CodeStubAssembler::CodeStubAssembler(Isolate* isolate, Zone* zone,
                                      const CallInterfaceDescriptor& descriptor,
                                      Code::Flags flags, const char* name)
     : raw_assembler_(new RawMachineAssembler(
           isolate, new (zone) Graph(zone),
           Linkage::GetStubCallDescriptor(isolate, zone, descriptor, 0,
                                          CallDescriptor::kNoFlags))),
       flags_(flags),
       name_(name),
-      code_generated_(false) {}
+      code_generated_(false),
+      linkage_type_(LinkageDescriptorType::kStubCall),
+      parameter_count_(descriptor.GetParameterCount()) {}
 
 
-CodeStubAssembler::~CodeStubAssembler() {}
+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),
+      linkage_type_(LinkageDescriptorType::kJSCall),
+      parameter_count_(parameter_count) {}
+
+
+CodeStubAssembler::~CodeStubAssembler() {
+  for (auto label : labels_) {
+    delete label;

[Jarin, 2016/02/08 10:25:04]

We don't normally do new/delete dances and use zones instead (so deleting is not
necessary). In this case, I am not sure why you would want heap allocation at
all.

+  }
+}
 
 
 Handle<Code> CodeStubAssembler::GenerateCode() {
   DCHECK(!code_generated_);
 
   Schedule* schedule = raw_assembler_->Export();
   Handle<Code> code = Pipeline::GenerateCodeForCodeStub(
       isolate(), raw_assembler_->call_descriptor(), graph(), schedule, flags_,
       name_);
 
@@ skipping 15 matching lines @@
 Node* CodeStubAssembler::NumberConstant(double value) {
   return raw_assembler_->NumberConstant(value);
 }
 
 
 Node* CodeStubAssembler::HeapConstant(Handle<HeapObject> object) {
   return raw_assembler_->HeapConstant(object);
 }
 
 
+Node* CodeStubAssembler::UndefinedConstant() {
+  return raw_assembler_->UndefinedConstant();
+}
+
+
 Node* CodeStubAssembler::BooleanConstant(bool value) {
   return raw_assembler_->BooleanConstant(value);
 }
 
 
+Node* CodeStubAssembler::Load(MachineType type, Node* base) {
+  return raw_assembler_->Load(type, base);
+}
+
+
+Node* CodeStubAssembler::Load(MachineType type, Node* base, Node* index) {
+  return raw_assembler_->Load(type, base, index);
+}
+
+
 Node* CodeStubAssembler::Parameter(int value) {
   return raw_assembler_->Parameter(value);
 }
 
 
-void CodeStubAssembler::Return(Node* value) {
-  return raw_assembler_->Return(value);
-}
-
-
 Node* CodeStubAssembler::SmiShiftBitsConstant() {
   return Int32Constant(kSmiShiftSize + kSmiTagSize);
 }
 
 
 Node* CodeStubAssembler::SmiTag(Node* value) {
   return raw_assembler_->WordShl(value, SmiShiftBitsConstant());
 }
 
 
@@ skipping 10 matching lines @@
 Node* CodeStubAssembler::IntPtrSub(Node* a, Node* b) {
   return raw_assembler_->IntPtrSub(a, b);
 }
 
 
 Node* CodeStubAssembler::WordShl(Node* value, int shift) {
   return raw_assembler_->WordShl(value, Int32Constant(shift));
 }
 
 
+Node* CodeStubAssembler::WordEqual(Node* a, Node* b) {
+  return raw_assembler_->WordEqual(a, b);
+}
+
+
+Node* CodeStubAssembler::WordOr(Node* a, Node* b) {
+  return raw_assembler_->WordOr(a, b);
+}
+
+
+Node* CodeStubAssembler::WordAnd(Node* a, Node* b) {
+  return raw_assembler_->WordAnd(a, b);
+}
+
+
+Node* CodeStubAssembler::Int32GreaterThanOrEqual(Node* a, Node* b) {
+  return raw_assembler_->Int32GreaterThanOrEqual(a, b);
+}
+
+
+Node* CodeStubAssembler::Int32LessThan(Node* a, Node* b) {
+  return raw_assembler_->Int32LessThan(a, b);
+}
+
+
 Node* CodeStubAssembler::LoadObjectField(Node* object, int offset) {
   return raw_assembler_->Load(MachineType::AnyTagged(), object,
                               IntPtrConstant(offset - kHeapObjectTag));
 }
 
 
+Node* CodeStubAssembler::IsHeapObject(Node* object) {
+  RawMachineAssembler* rma = raw_assembler_.get();
+  return rma->WordEqual(
+      rma->WordAnd(object, rma->IntPtrConstant(kHeapObjectTagMask)),
+      rma->IntPtrConstant(kHeapObjectTag));
+}
+
+
+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() {
+  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) {
   return raw_assembler_->CallN(descriptor, code_target, args);
 }
 
 
 Node* CodeStubAssembler::TailCallN(CallDescriptor* descriptor,
                                    Node* code_target, Node** args) {
   return raw_assembler_->TailCallN(descriptor, code_target, args);
 }
 
 
 Node* CodeStubAssembler::CallRuntime(Runtime::FunctionId function_id,
-                                     Node* context, Node* arg1) {
-  return raw_assembler_->CallRuntime1(function_id, arg1, context);
+                                     Node* arg1) {
+  return raw_assembler_->CallRuntime1(function_id, arg1, Context());
 }
 
 
 Node* CodeStubAssembler::CallRuntime(Runtime::FunctionId function_id,
-                                     Node* context, Node* arg1, Node* arg2) {
-  return raw_assembler_->CallRuntime2(function_id, arg1, arg2, context);
+                                     Node* arg1, Node* arg2) {
+  return raw_assembler_->CallRuntime2(function_id, arg1, arg2, Context());
 }
 
 
 Node* CodeStubAssembler::TailCallRuntime(Runtime::FunctionId function_id,
-                                         Node* context, Node* arg1) {
-  return raw_assembler_->TailCallRuntime1(function_id, arg1, 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);
+                                         Node* arg1, Node* arg2) {
+  return raw_assembler_->TailCallRuntime2(function_id, arg1, arg2, Context());
 }
 
 
+RawMachineLabel* CodeStubAssembler::GetOrCreateRawMachineLabel(Label* label) {
+  if (!label->raw_label_) {
+    RawMachineLabel* result = new RawMachineLabel();

[Jarin, 2016/02/08 10:25:04]

As noted above, we do not normally allocate on the C++ heap directly. Normally,
you should do something like 

new (zone()->New(sizeof(RawMachineLabel)) RawMachineLabel()

or you can inherit from ZoneObject (which overloads new) and then you can say

new (zone()) RawMachineLabel()

If RawMachineLabel is a field of Label, none of this is necessary.

+    label->raw_label_ = result;
+    labels_.push_back(result);
+    return result;
+  }
+
+  return label->raw_label_;
+}
+
+
+void CodeStubAssembler::Goto(Label* label) {
+  raw_assembler_->Goto(GetOrCreateRawMachineLabel(label));
+}
+
+void CodeStubAssembler::Branch(Node* cond, Label* true_label,
+                               Label* false_label) {
+  raw_assembler_->Branch(cond, GetOrCreateRawMachineLabel(true_label),
+                         GetOrCreateRawMachineLabel(false_label));
+}
+
+
+void CodeStubAssembler::Bind(Label* label) {
+  raw_assembler_->Bind(GetOrCreateRawMachineLabel(label));
+}
+
+
+void CodeStubAssembler::Return(Node* value) {
+  return raw_assembler_->Return(value);
+}
+
+
+Node* CodeStubAssembler::Phi(MachineRepresentation rep, Node* n1, Node* n2) {
+  return raw_assembler_->Phi(rep, n1, n2);
+}
+
+
 // RawMachineAssembler delegate helpers:
 Isolate* CodeStubAssembler::isolate() { return raw_assembler_->isolate(); }
 
 
 Graph* CodeStubAssembler::graph() { return raw_assembler_->graph(); }
 
 
 Zone* CodeStubAssembler::zone() { return raw_assembler_->zone(); }
 
-
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8