CodeStubAssembler can generate code for builtins

src/compiler/code-stub-assembler.cc

Index: src/compiler/code-stub-assembler.cc
diff --git a/src/compiler/code-stub-assembler.cc b/src/compiler/code-stub-assembler.cc
index 45f47d3310933dc50a8b8feb7ec5c12149c5a844..ef82968f035a1a8726e27173d47fb9b674af5abc 100644
--- a/src/compiler/code-stub-assembler.cc
+++ b/src/compiler/code-stub-assembler.cc
@@ -39,6 +39,18 @@ CodeStubAssembler::CodeStubAssembler(Isolate* isolate, Zone* zone,
       code_generated_(false),
       variables_(zone) {}
 
+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) {}
+
 CodeStubAssembler::~CodeStubAssembler() {}
 
 void CodeStubAssembler::CallPrologue() {}
@@ -132,14 +144,17 @@ Node* CodeStubAssembler::SmiUntag(Node* value) {
 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));
@@ -155,6 +170,11 @@ Node* CodeStubAssembler::LoadObjectField(Node* object, int offset) {
                               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) {
@@ -230,6 +250,20 @@ 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::CallN(CallDescriptor* descriptor, Node* code_target,
                                Node** args) {
   CallPrologue();
@@ -290,6 +324,11 @@ Node* CodeStubAssembler::CallRuntime(Runtime::FunctionId function_id,
 }
 
 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);
 }