[turbofan] Use graph assembler for memory optimizer.

src/compiler/graph-assembler.h

 // 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_COMPILER_GRAPH_ASSEMBLER_H_
 #define V8_COMPILER_GRAPH_ASSEMBLER_H_
 
 #include "src/compiler/js-graph.h"
 #include "src/compiler/node.h"
 #include "src/compiler/simplified-operator.h"
@@ skipping 10 matching lines @@
   V(ChangeInt32ToInt64)                  \
   V(ChangeInt32ToFloat64)                \
   V(ChangeUint32ToFloat64)               \
   V(ChangeUint32ToUint64)                \
   V(ChangeFloat64ToInt32)                \
   V(ChangeFloat64ToUint32)               \
   V(TruncateInt64ToInt32)                \
   V(RoundFloat64ToInt32)                 \
   V(TruncateFloat64ToWord32)             \
   V(Float64ExtractHighWord32)            \
-  V(Float64Abs)
+  V(Float64Abs)                          \
+  V(BitcastWordToTagged)
 
 #define PURE_ASSEMBLER_MACH_BINOP_LIST(V) \
   V(WordShl)                              \
   V(WordSar)                              \
   V(WordAnd)                              \
   V(Word32Or)                             \
   V(Word32And)                            \
   V(Word32Shr)                            \
   V(Word32Shl)                            \
+  V(IntAdd)                               \
+  V(IntSub)                               \
+  V(UintLessThan)                         \
   V(Int32Add)                             \
   V(Int32Sub)                             \
   V(Int32Mul)                             \
   V(Int32LessThanOrEqual)                 \
   V(Uint32LessThanOrEqual)                \
   V(Uint32LessThan)                       \
   V(Int32LessThan)                        \
   V(Float64Add)                           \
   V(Float64Sub)                           \
   V(Float64Mod)                           \
   V(Float64Equal)                         \
   V(Float64LessThan)                      \
   V(Float64LessThanOrEqual)               \
   V(Word32Equal)                          \
   V(WordEqual)
 
 #define CHECKED_ASSEMBLER_MACH_BINOP_LIST(V) \
   V(Int32AddWithOverflow)                    \
   V(Int32SubWithOverflow)                    \
   V(Int32MulWithOverflow)                    \
   V(Int32Mod)                                \
   V(Int32Div)                                \
   V(Uint32Mod)                               \
   V(Uint32Div)
 
+#define JSGRAPH_SINGLETON_CONSTANT_LIST(V) \
+  V(TrueConstant)                          \
+  V(FalseConstant)                         \
+  V(HeapNumberMapConstant)                 \
+  V(NoContextConstant)                     \
+  V(EmptyStringConstant)                   \
+  V(UndefinedConstant)                     \
+  V(TheHoleConstant)                       \
+  V(FixedArrayMapConstant)                 \
+  V(ToNumberBuiltinConstant)               \
+  V(AllocateInNewSpaceStubConstant)        \
+  V(AllocateInOldSpaceStubConstant)
+
 class GraphAssembler;
 
 enum class GraphAssemblerLabelType { kDeferred, kNonDeferred };
 
 // Label with statically known count of incoming branches and phis.
 template <size_t MergeCount, size_t VarCount = 0u>
 class GraphAssemblerStaticLabel {
  public:
   Node* PhiAt(size_t index);
 
@@ skipping 133 matching lines @@
   template <typename... Reps>
   GraphAssemblerLabel MakeLabelFor(GraphAssemblerLabelType is_deferred,
                                    size_t merge_count, Reps... reps) {
     MachineRepresentation reps_array[] = {MachineRepresentation::kNone,
                                           reps...};
     return GraphAssemblerLabel(is_deferred, merge_count, sizeof...(reps),
                                &(reps_array[1]), temp_zone());
   }
 
   // Value creation.
-  Node* TrueConstant();
-  Node* FalseConstant();
-  Node* HeapNumberMapConstant();
   Node* IntPtrConstant(intptr_t value);
   Node* Uint32Constant(int32_t value);
   Node* Int32Constant(int32_t value);
+  Node* UniqueInt32Constant(int32_t value);
   Node* SmiConstant(int32_t value);
   Node* Float64Constant(double value);
   Node* Projection(int index, Node* value);
   Node* HeapConstant(Handle<HeapObject> object);
-  Node* NoContextConstant();
   Node* CEntryStubConstant(int result_size);
   Node* ExternalConstant(ExternalReference ref);
-  Node* EmptyStringConstant();
-  Node* UndefinedConstant();
-  Node* TheHoleConstant();
-  Node* FixedArrayMapConstant();
+
+#define SINGLETON_CONST_DECL(Name) Node* Name();
+  JSGRAPH_SINGLETON_CONSTANT_LIST(SINGLETON_CONST_DECL)
+#undef SINGLETON_CONST_DECL
 
 #define PURE_UNOP_DECL(Name) Node* Name(Node* input);
   PURE_ASSEMBLER_MACH_UNOP_LIST(PURE_UNOP_DECL)
 #undef PURE_UNOP_DECL
 
 #define BINOP_DECL(Name) Node* Name(Node* left, Node* right);
   PURE_ASSEMBLER_MACH_BINOP_LIST(BINOP_DECL)
   CHECKED_ASSEMBLER_MACH_BINOP_LIST(BINOP_DECL)
 #undef BINOP_DECL
 
   Node* Float64RoundDown(Node* value);
 
   Node* ToNumber(Node* value);
   Node* Allocate(PretenureFlag pretenure, Node* size);
   Node* LoadField(FieldAccess const&, Node* object);
   Node* LoadElement(ElementAccess const&, Node* object, Node* index);
   Node* StoreField(FieldAccess const&, Node* object, Node* value);
   Node* StoreElement(ElementAccess const&, Node* object, Node* index,
                      Node* value);
 
   Node* Store(StoreRepresentation rep, Node* object, Node* offset, Node* value);
+  Node* Load(MachineType rep, Node* object, Node* offset);
 
   Node* Retain(Node* buffer);
   Node* UnsafePointerAdd(Node* base, Node* external);
 
   Node* DeoptimizeIf(DeoptimizeReason reason, Node* condition,
                      Node* frame_state);
   Node* DeoptimizeUnless(DeoptimizeReason reason, Node* condition,
                          Node* frame_state);
   template <typename... Args>
   Node* Call(const CallDescriptor* desc, Args... args);
+  template <typename... Args>
+  Node* Call(const Operator* op, Args... args);
 
   // Basic control operations.
   template <class LabelType>
   void Bind(LabelType* label);
 
   template <class LabelType, typename... vars>
   void Goto(LabelType* label, vars...);
 
   void Branch(Node* condition, GraphAssemblerStaticLabel<1>* if_true,
               GraphAssemblerStaticLabel<1>* if_false);
@@ skipping 126 matching lines @@
 
   current_control_ = graph()->NewNode(common()->IfFalse(), branch);
   MergeState(label, vars...);
 
   current_control_ = graph()->NewNode(common()->IfTrue(), branch);
 }
 
 template <typename... Args>
 Node* GraphAssembler::Call(const CallDescriptor* desc, Args... args) {
   const Operator* op = common()->Call(desc);
+  return Call(op, args...);
+}
+
+template <typename... Args>
+Node* GraphAssembler::Call(const Operator* op, Args... args) {
+  DCHECK_EQ(IrOpcode::kCall, op->opcode());
   Node* args_array[] = {args..., current_effect_, current_control_};
   int size = static_cast<int>(sizeof...(args)) + op->EffectInputCount() +
              op->ControlInputCount();
   Node* call = graph()->NewNode(op, size, args_array);
   DCHECK_EQ(0, op->ControlOutputCount());
   current_effect_ = call;
   return call;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_GRAPH_ASSEMBLER_H_