[turbofan] Use graph assembler for memory optimizer.

src/compiler/graph-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/graph-assembler.h"
 
 #include "src/code-factory.h"
 #include "src/compiler/linkage.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 GraphAssembler::GraphAssembler(JSGraph* jsgraph, Node* effect, Node* control,
                                Zone* zone)
     : temp_zone_(zone),
       jsgraph_(jsgraph),
       current_effect_(effect),
       current_control_(control) {}
 
-Node* GraphAssembler::TrueConstant() { return jsgraph()->TrueConstant(); }
-
-Node* GraphAssembler::FalseConstant() { return jsgraph()->FalseConstant(); }
-
-Node* GraphAssembler::HeapNumberMapConstant() {
-  return jsgraph()->HeapNumberMapConstant();
-}
-
 Node* GraphAssembler::IntPtrConstant(intptr_t value) {
   return jsgraph()->IntPtrConstant(value);
 }
 
 Node* GraphAssembler::Int32Constant(int32_t value) {
   return jsgraph()->Int32Constant(value);
 }
 
+Node* GraphAssembler::UniqueInt32Constant(int32_t value) {
+  return graph()->NewNode(common()->Int32Constant(value));
+}
+
 Node* GraphAssembler::SmiConstant(int32_t value) {
   return jsgraph()->SmiConstant(value);
 }
 
 Node* GraphAssembler::Uint32Constant(int32_t value) {
   return jsgraph()->Uint32Constant(value);
 }
 
 Node* GraphAssembler::Float64Constant(double value) {
   return jsgraph()->Float64Constant(value);
 }
 
 Node* GraphAssembler::HeapConstant(Handle<HeapObject> object) {
   return jsgraph()->HeapConstant(object);
 }
 
-Node* GraphAssembler::NoContextConstant() {
-  return jsgraph()->NoContextConstant();
-}
 
 Node* GraphAssembler::ExternalConstant(ExternalReference ref) {
   return jsgraph()->ExternalConstant(ref);
 }
 
 Node* GraphAssembler::CEntryStubConstant(int result_size) {
   return jsgraph()->CEntryStubConstant(result_size);
 }
 
-Node* GraphAssembler::EmptyStringConstant() {
-  return jsgraph()->EmptyStringConstant();
-}
-
-Node* GraphAssembler::UndefinedConstant() {
-  return jsgraph()->UndefinedConstant();
-}
-
-Node* GraphAssembler::TheHoleConstant() { return jsgraph()->TheHoleConstant(); }
-
-Node* GraphAssembler::FixedArrayMapConstant() {
-  return jsgraph()->FixedArrayMapConstant();
-}
+#define SINGLETON_CONST_DEF(Name) \
+  Node* GraphAssembler::Name() { return jsgraph()->Name(); }
+JSGRAPH_SINGLETON_CONSTANT_LIST(SINGLETON_CONST_DEF)
+#undef SINGLETON_CONST_DEF
 
 #define PURE_UNOP_DEF(Name)                            \
   Node* GraphAssembler::Name(Node* input) {            \
     return graph()->NewNode(machine()->Name(), input); \
   }
 PURE_ASSEMBLER_MACH_UNOP_LIST(PURE_UNOP_DEF)
 #undef PURE_UNOP_DEF
 
 #define PURE_BINOP_DEF(Name)                                 \
   Node* GraphAssembler::Name(Node* left, Node* right) {      \
@@ skipping 53 matching lines @@
                               value, current_effect_, current_control_);
 }
 
 Node* GraphAssembler::Store(StoreRepresentation rep, Node* object, Node* offset,
                             Node* value) {
   return current_effect_ =
              graph()->NewNode(machine()->Store(rep), object, offset, value,
                               current_effect_, current_control_);
 }
 
+Node* GraphAssembler::Load(MachineType rep, Node* object, Node* offset) {
+  return current_effect_ =
+             graph()->NewNode(machine()->Load(rep), object, offset,
+                              current_effect_, current_control_);
+}
+
 Node* GraphAssembler::Retain(Node* buffer) {
   return current_effect_ =
              graph()->NewNode(common()->Retain(), buffer, current_effect_);
 }
 
 Node* GraphAssembler::UnsafePointerAdd(Node* base, Node* external) {
   return current_effect_ =
              graph()->NewNode(machine()->UnsafePointerAdd(), base, external,
                               current_effect_, current_control_);
 }
 
 Node* GraphAssembler::ToNumber(Node* value) {
-  return current_effect_ = graph()->NewNode(
-             ToNumberOperator(), jsgraph()->ToNumberBuiltinConstant(), value,
-             jsgraph()->NoContextConstant(), current_effect_);
+  return current_effect_ =
+             graph()->NewNode(ToNumberOperator(), ToNumberBuiltinConstant(),
+                              value, NoContextConstant(), current_effect_);
 }
 
 Node* GraphAssembler::DeoptimizeIf(DeoptimizeReason reason, Node* condition,
                                    Node* frame_state) {
   return current_control_ = current_effect_ =
              graph()->NewNode(common()->DeoptimizeIf(reason), condition,
                               frame_state, current_effect_, current_control_);
 }
 
 Node* GraphAssembler::DeoptimizeUnless(DeoptimizeReason reason, Node* condition,
@@ skipping 112 matching lines @@
   return representations_[phi_index];
 }
 
 Node** GraphAssemblerLabel::GetControlsPtr() { return controls_; }
 
 Node** GraphAssemblerLabel::GetEffectsPtr() { return effects_; }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8