Separate CodeAssembler and CodeStubAssembler

src/code-stub-assembler.h

Index: src/code-stub-assembler.h
diff --git a/src/code-stub-assembler.h b/src/code-stub-assembler.h
new file mode 100644
index 0000000000000000000000000000000000000000..4193c8b3541956eaa05574269cebaa3452e3dce1
--- /dev/null
+++ b/src/code-stub-assembler.h
@@ -0,0 +1,147 @@
+// Copyright 2016 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_CODE_STUB_ASSEMBLER_H_
+#define V8_CODE_STUB_ASSEMBLER_H_
+
+#include "src/compiler/code-assembler.h"
+#include "src/objects.h"
+
+namespace v8 {
+namespace internal {
+
+class CallInterfaceDescriptor;
+
+// Provides JavaScript-specific "macro-assembler" functionality on top of the
+// CodeAssembler. By factoring the JavaScript-isms out of the CodeAssembler,
+// it's possible to add JavaScript-specific useful CodeAssembler "macros"
+// without modifying files in the compiler directory (and requiring a review
+// from a compiler directory OWNER).
+class CodeStubAssembler : public compiler::CodeAssembler {
+ public:
+  // Create with CallStub linkage.
+  // |result_size| specifies the number of results returned by the stub.
+  // TODO(rmcilroy): move result_size to the CallInterfaceDescriptor.
+  CodeStubAssembler(Isolate* isolate, Zone* zone,
+                    const CallInterfaceDescriptor& descriptor,
+                    Code::Flags flags, const char* name,
+                    size_t result_size = 1);
+
+  // Create with JSCall linkage.
+  CodeStubAssembler(Isolate* isolate, Zone* zone, int parameter_count,
+                    Code::Flags flags, const char* name);
+
+  // Smi conversions.
+  compiler::Node* SmiToFloat64(compiler::Node* value);
+  compiler::Node* SmiToWord32(compiler::Node* value);
+
+  // Smi operations.
+  compiler::Node* SmiAdd(compiler::Node* a, compiler::Node* b);
+  compiler::Node* SmiAddWithOverflow(compiler::Node* a, compiler::Node* b);
+  compiler::Node* SmiSub(compiler::Node* a, compiler::Node* b);
+  compiler::Node* SmiSubWithOverflow(compiler::Node* a, compiler::Node* b);
+  compiler::Node* SmiEqual(compiler::Node* a, compiler::Node* b);
+  compiler::Node* SmiLessThan(compiler::Node* a, compiler::Node* b);
+  compiler::Node* SmiLessThanOrEqual(compiler::Node* a, compiler::Node* b);
+  compiler::Node* SmiMin(compiler::Node* a, compiler::Node* b);
+
+  // Check a value for smi-ness
+  compiler::Node* WordIsSmi(compiler::Node* a);
+
+  // Check that the value is a positive smi.
+  compiler::Node* WordIsPositiveSmi(compiler::Node* a);
+
+  // Load an object pointer from a buffer that isn't in the heap.
+  compiler::Node* LoadBufferObject(compiler::Node* buffer, int offset,
+                                   MachineType rep = MachineType::AnyTagged());
+  // Load a field from an object on the heap.
+  compiler::Node* LoadObjectField(compiler::Node* object, int offset,
+                                  MachineType rep = MachineType::AnyTagged());
+  // Load the floating point value of a HeapNumber.
+  compiler::Node* LoadHeapNumberValue(compiler::Node* object);
+  // Store the floating point value of a HeapNumber.
+
+  // Load the Map of an HeapObject.
+  compiler::Node* LoadMap(compiler::Node* object);
+  // Load the instance type of an HeapObject.
+  compiler::Node* LoadInstanceType(compiler::Node* object);
+
+  // Load the elements backing store of a JSObject.
+  compiler::Node* LoadElements(compiler::Node* object);
+  // Load the length of a fixed array base instance.
+  compiler::Node* LoadFixedArrayBaseLength(compiler::Node* array);
+
+  // Load the bit field of a Map.
+  compiler::Node* LoadMapBitField(compiler::Node* map);
+  // Load bit field 2 of a map.
+  compiler::Node* LoadMapBitField2(compiler::Node* map);
+  // Load bit field 3 of a map.
+  compiler::Node* LoadMapBitField3(compiler::Node* map);
+  // Load the instance type of a map.
+  compiler::Node* LoadMapInstanceType(compiler::Node* map);
+  // Load the instance descriptors of a map.
+  compiler::Node* LoadMapDescriptors(compiler::Node* map);
+
+  // Load the hash field of a name.
+  compiler::Node* LoadNameHash(compiler::Node* name);
+
+  // Load an array element from a FixedArray.
+  compiler::Node* LoadFixedArrayElementInt32Index(compiler::Node* object,
+                                                  compiler::Node* int32_index,
+                                                  int additional_offset = 0);
+  compiler::Node* LoadFixedArrayElementSmiIndex(compiler::Node* object,
+                                                compiler::Node* smi_index,
+                                                int additional_offset = 0);
+  compiler::Node* LoadFixedArrayElementConstantIndex(compiler::Node* object,
+                                                     int index);
+
+  compiler::Node* StoreHeapNumberValue(compiler::Node* object,
+                                       compiler::Node* value);
+
+  // Store the Map of an HeapObject.
+  compiler::Node* StoreMapNoWriteBarrier(compiler::Node* object,
+                                         compiler::Node* map);
+  // Store an array element to a FixedArray.
+  compiler::Node* StoreFixedArrayElementNoWriteBarrier(compiler::Node* object,
+                                                       compiler::Node* index,
+                                                       compiler::Node* value);
+  // Allocate a HeapNumber without initializing its value.
+  compiler::Node* AllocateHeapNumber();
+  // Allocate a HeapNumber with a specific value.
+  compiler::Node* AllocateHeapNumberWithValue(compiler::Node* value);
+
+  // Returns a node that is true if the given bit is set in |word32|.
+  template <typename T>
+  compiler::Node* BitFieldDecode(compiler::Node* word32) {
+    return BitFieldDecode(word32, T::kShift, T::kMask);
+  }
+
+  compiler::Node* BitFieldDecode(compiler::Node* word32, uint32_t shift,
+                                 uint32_t mask);
+
+  // Conversions.
+  compiler::Node* ChangeFloat64ToTagged(compiler::Node* value);
+  compiler::Node* ChangeInt32ToTagged(compiler::Node* value);
+  compiler::Node* TruncateTaggedToFloat64(compiler::Node* context,
+                                          compiler::Node* value);
+  compiler::Node* TruncateTaggedToWord32(compiler::Node* context,
+                                         compiler::Node* value);
+  // Truncate the floating point value of a HeapNumber to an Int32.
+  compiler::Node* TruncateHeapNumberValueToWord32(compiler::Node* object);
+
+  void BranchIfSmiLessThan(compiler::Node* a, compiler::Node* b, Label* if_true,
+                           Label* if_false) {
+    BranchIf(SmiLessThan(a, b), if_true, if_false);
+  }
+
+  void BranchIfSmiLessThanOrEqual(compiler::Node* a, compiler::Node* b,
+                                  Label* if_true, Label* if_false) {
+    BranchIf(SmiLessThanOrEqual(a, b), if_true, if_false);
+  }
+};
+
+}  // namespace internal
+}  // namespace v8
+
+#endif  // V8_CODE_STUB_ASSEMBLER_H_