[Interpreter] Ensure we always have an outer register allocation scope.

src/interpreter/bytecode-register-allocator.h

 // 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.
 
-#ifndef V8_COMPILER_TYPE_HINT_ANALYZER_H_
-#define V8_COMPILER_TYPE_HINT_ANALYZER_H_
+#ifndef V8_INTERPRETER_BYTECODE_REGISTER_ALLOCATOR_H_
+#define V8_INTERPRETER_BYTECODE_REGISTER_ALLOCATOR_H_
 
-#include "src/compiler/type-hints.h"
-#include "src/handles.h"
 #include "src/zone-containers.h"
 
 namespace v8 {
 namespace internal {
-namespace compiler {
+namespace interpreter {
 
-// The result of analyzing type hints.
-class TypeHintAnalysis final : public ZoneObject {
+class BytecodeArrayBuilder;
+class Register;
+
+// A class than allows the instantiator to allocate temporary registers that are
+// cleaned up when scope is closed.
+class BytecodeRegisterAllocator {
  public:
-  typedef ZoneMap<TypeFeedbackId, Handle<Code>> Infos;
+  explicit BytecodeRegisterAllocator(BytecodeArrayBuilder* builder);
+  ~BytecodeRegisterAllocator();
+  Register NewRegister();
 
-  explicit TypeHintAnalysis(Infos const& infos) : infos_(infos) {}
+  void PrepareForConsecutiveAllocations(size_t count);
+  Register NextConsecutiveRegister();
 
-  bool GetBinaryOperationHints(TypeFeedbackId id,
-                               BinaryOperationHints* hints) const;
-  bool GetToBooleanHints(TypeFeedbackId id, ToBooleanHints* hints) const;
+  bool RegisterIsAllocatedInThisScope(Register reg) const;
+
+  bool HasConsecutiveAllocations() const { return next_consecutive_count_ > 0; }
 
  private:
-  Infos const infos_;
+  void* operator new(size_t size);
+  void operator delete(void* p);
+
+  BytecodeArrayBuilder* builder_;
+  ZoneVector<int> allocated_;
+  int next_consecutive_register_;
+  int next_consecutive_count_;
+
+  DISALLOW_COPY_AND_ASSIGN(BytecodeRegisterAllocator);
 };
 
-
-// The class that performs type hint analysis on the fullcodegen code object.
-class TypeHintAnalyzer final {
- public:
-  explicit TypeHintAnalyzer(Zone* zone) : zone_(zone) {}
-
-  TypeHintAnalysis* Analyze(Handle<Code> code);
-
- private:
-  Zone* zone() const { return zone_; }
-
-  Zone* const zone_;
-
-  DISALLOW_COPY_AND_ASSIGN(TypeHintAnalyzer);
-};
-
-}  // namespace compiler
+}  // namespace interpreter
 }  // namespace internal
 }  // namespace v8
 
-#endif  // V8_COMPILER_TYPE_HINT_ANALYZER_H_
+
+#endif  // V8_INTERPRETER_BYTECODE_REGISTER_ALLOCATOR_H_