[compiler] Remove compiler internals from CodeAssembler.

src/compiler/code-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-assembler.h"
 
 #include <ostream>
 
 #include "src/code-factory.h"
 #include "src/compiler/graph.h"
@@ skipping 51 matching lines @@
 
 void CodeAssembler::CallPrologue() {}
 
 void CodeAssembler::CallEpilogue() {}
 
 Handle<Code> CodeAssembler::GenerateCode() {
   DCHECK(!code_generated_);
 
   Schedule* schedule = raw_assembler_->Export();
   Handle<Code> code = Pipeline::GenerateCodeForCodeStub(
-      isolate(), raw_assembler_->call_descriptor(), graph(), schedule, flags_,
-      name_);
+      isolate(), raw_assembler_->call_descriptor(), raw_assembler_->graph(),
+      schedule, flags_, name_);
 
   code_generated_ = true;
   return code;
 }
 
 bool CodeAssembler::Is64() const { return raw_assembler_->machine()->Is64(); }
 
 bool CodeAssembler::IsFloat64RoundUpSupported() const {
   return raw_assembler_->machine()->Float64RoundUp().IsSupported();
 }
@@ skipping 107 matching lines @@
 }
 
 Node* CodeAssembler::LoadParentFramePointer() {
   return raw_assembler_->LoadParentFramePointer();
 }
 
 Node* CodeAssembler::LoadStackPointer() {
   return raw_assembler_->LoadStackPointer();
 }
 
-Node* CodeAssembler::SmiShiftBitsConstant() {
-  return IntPtrConstant(kSmiShiftSize + kSmiTagSize);
-}
-
 #define DEFINE_CODE_ASSEMBLER_BINARY_OP(name)   \
   Node* CodeAssembler::name(Node* a, Node* b) { \
     return raw_assembler_->name(a, b);          \
   }
 CODE_ASSEMBLER_BINARY_OP_LIST(DEFINE_CODE_ASSEMBLER_BINARY_OP)
 #undef DEFINE_CODE_ASSEMBLER_BINARY_OP
 
 Node* CodeAssembler::WordShl(Node* value, int shift) {
   return (shift != 0) ? raw_assembler_->WordShl(value, IntPtrConstant(shift))
                       : value;
@@ skipping 687 matching lines @@
 
   Bind(&end);
   return value.value();
 }
 
 // RawMachineAssembler delegate helpers:
 Isolate* CodeAssembler::isolate() const { return raw_assembler_->isolate(); }
 
 Factory* CodeAssembler::factory() const { return isolate()->factory(); }
 
-Graph* CodeAssembler::graph() const { return raw_assembler_->graph(); }
-
 Zone* CodeAssembler::zone() const { return raw_assembler_->zone(); }
 
 // The core implementation of Variable is stored through an indirection so
 // that it can outlive the often block-scoped Variable declarations. This is
 // needed to ensure that variable binding and merging through phis can
 // properly be verified.
 class CodeAssembler::Variable::Impl : public ZoneObject {
  public:
   explicit Impl(MachineRepresentation rep) : value_(nullptr), rep_(rep) {}
   Node* value_;
@@ skipping 134 matching lines @@
       }
     }
   }
 
   bound_ = true;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8