[turbofan] Deopt support for escape analysis

src/compiler/instruction.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_COMPILER_INSTRUCTION_H_
 #define V8_COMPILER_INSTRUCTION_H_
 
 #include <deque>
 #include <iosfwd>
 #include <map>
 #include <set>
 
 #include "src/compiler/common-operator.h"
 #include "src/compiler/frame.h"
 #include "src/compiler/instruction-codes.h"
 #include "src/compiler/opcodes.h"
 #include "src/compiler/source-position.h"
 #include "src/macro-assembler.h"
 #include "src/register-configuration.h"
 #include "src/zone-allocator.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
+class FrameStateDescriptor;
 class Schedule;
 
+
 class InstructionOperand {
  public:
   static const int kInvalidVirtualRegister = -1;
 
   // TODO(dcarney): recover bit. INVALID can be represented as UNALLOCATED with
   // kInvalidVirtualRegister and some DCHECKS.
   enum Kind { INVALID, UNALLOCATED, CONSTANT, IMMEDIATE, EXPLICIT, ALLOCATED };
 
   InstructionOperand() : InstructionOperand(INVALID) {}
 
@@ skipping 60 matching lines @@
   explicit InstructionOperand(Kind kind) : value_(KindField::encode(kind)) {}
 
   inline uint64_t GetCanonicalizedValue() const;
 
   class KindField : public BitField64<Kind, 0, 3> {};
 
   uint64_t value_;
 };
 
 
+typedef ZoneVector<InstructionOperand> InstructionOperandVector;
+
+
 struct PrintableInstructionOperand {
   const RegisterConfiguration* register_configuration_;
   InstructionOperand op_;
 };
 
 
 std::ostream& operator<<(std::ostream& os,
                          const PrintableInstructionOperand& op);
 
 
@@ skipping 803 matching lines @@
     DCHECK_EQ(kHeapObject, type());
     return bit_cast<Handle<HeapObject> >(static_cast<intptr_t>(value_));
   }
 
  private:
   Type type_;
   int64_t value_;
 };
 
 
-class FrameStateDescriptor : public ZoneObject {
- public:
-  FrameStateDescriptor(Zone* zone, FrameStateType type, BailoutId bailout_id,
-                       OutputFrameStateCombine state_combine,
-                       size_t parameters_count, size_t locals_count,
-                       size_t stack_count,
-                       MaybeHandle<SharedFunctionInfo> shared_info,
-                       FrameStateDescriptor* outer_state = nullptr);
-
-  FrameStateType type() const { return type_; }
-  BailoutId bailout_id() const { return bailout_id_; }
-  OutputFrameStateCombine state_combine() const { return frame_state_combine_; }
-  size_t parameters_count() const { return parameters_count_; }
-  size_t locals_count() const { return locals_count_; }
-  size_t stack_count() const { return stack_count_; }
-  MaybeHandle<SharedFunctionInfo> shared_info() const { return shared_info_; }
-  FrameStateDescriptor* outer_state() const { return outer_state_; }
-  bool HasContext() const {
-    return type_ == FrameStateType::kJavaScriptFunction;
-  }
-
-  size_t GetSize(OutputFrameStateCombine combine =
-                     OutputFrameStateCombine::Ignore()) const;
-  size_t GetTotalSize() const;
-  size_t GetFrameCount() const;
-  size_t GetJSFrameCount() const;
-
-  MachineType GetType(size_t index) const;
-  void SetType(size_t index, MachineType type);
-
- private:
-  FrameStateType type_;
-  BailoutId bailout_id_;
-  OutputFrameStateCombine frame_state_combine_;
-  size_t parameters_count_;
-  size_t locals_count_;
-  size_t stack_count_;
-  ZoneVector<MachineType> types_;
-  MaybeHandle<SharedFunctionInfo> const shared_info_;
-  FrameStateDescriptor* outer_state_;
-};
-
 std::ostream& operator<<(std::ostream& os, const Constant& constant);
 
 
 class PhiInstruction final : public ZoneObject {
  public:
   typedef ZoneVector<InstructionOperand> Inputs;
 
   PhiInstruction(Zone* zone, int virtual_register, size_t input_count);
 
   void SetInput(size_t offset, int virtual_register);
@@ skipping 294 matching lines @@
 
 
 std::ostream& operator<<(std::ostream& os,
                          const PrintableInstructionSequence& code);
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_INSTRUCTION_H_