[turbofan] cleanup InstructionSequence

src/compiler/register-allocator.h

 // Copyright 2014 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_REGISTER_ALLOCATOR_H_
 #define V8_REGISTER_ALLOCATOR_H_
 
 #include "src/allocation.h"
 #include "src/compiler/instruction.h"
 #include "src/macro-assembler.h"
@@ skipping 299 matching lines @@
   InstructionOperand* current_hint_operand_;
   InstructionOperand* spill_operand_;
   int spill_start_index_;
 
   friend class RegisterAllocator;  // Assigns to kind_.
 };
 
 
 class RegisterAllocator BASE_EMBEDDED {
  public:
-  explicit RegisterAllocator(InstructionSequence* code);
+  // TODO(dcarney): remove info
+  explicit RegisterAllocator(Frame* frame, CompilationInfo* info,
+                             InstructionSequence* code);
 
   static void TraceAlloc(const char* msg, ...);
 
   // Checks whether the value of a given virtual register is a reference.
   // TODO(titzer): rename this to IsReference.
   bool HasTaggedValue(int virtual_register) const;
 
   // Returns the register kind required by the given virtual register.
   RegisterKind RequiredRegisterKind(int virtual_register) const;
 
   bool Allocate();
 
   const ZoneList<LiveRange*>* live_ranges() const { return &live_ranges_; }
   const Vector<LiveRange*>* fixed_live_ranges() const {
     return &fixed_live_ranges_;
   }
   const Vector<LiveRange*>* fixed_double_live_ranges() const {
     return &fixed_double_live_ranges_;
   }
 
+  CompilationInfo* info() const { return info_; }
   inline InstructionSequence* code() const { return code_; }
 
   // This zone is for datastructures only needed during register allocation.
   inline Zone* zone() { return &zone_; }
 
   // This zone is for InstructionOperands and moves that live beyond register
   // allocation.
   inline Zone* code_zone() { return code()->zone(); }
 
   int GetVirtualRegister() {
@@ skipping 134 matching lines @@
   LiveRange* FixedDoubleLiveRangeFor(int index);
   LiveRange* LiveRangeFor(int index);
   GapInstruction* GetLastGap(const InstructionBlock* block);
 
   const char* RegisterName(int allocation_index);
 
   inline Instruction* InstructionAt(int index) {
     return code()->InstructionAt(index);
   }
 
+  Frame* frame() const { return frame_; }
+
   Zone zone_;
+  Frame* frame_;
+  CompilationInfo* info_;
   InstructionSequence* code_;
 
   // During liveness analysis keep a mapping from block id to live_in sets
   // for blocks already analyzed.
   ZoneList<BitVector*> live_in_sets_;
 
   // Liveness analysis results.
   ZoneList<LiveRange*> live_ranges_;
 
   // Lists of live ranges
@@ skipping 32 matching lines @@
   RegisterAllocator* allocator_;
   unsigned allocator_zone_start_allocation_size_;
 
   DISALLOW_COPY_AND_ASSIGN(RegisterAllocatorPhase);
 };
 }
 }
 }  // namespace v8::internal::compiler
 
 #endif  // V8_REGISTER_ALLOCATOR_H_