1 files changed, 46 insertions, 13 deletions

diff --git a/deps/v8/src/maglev/maglev-graph.h b/deps/v8/src/maglev/maglev-graph.h
index cc084e8350..225008224e 100644
--- a/deps/v8/src/maglev/maglev-graph.h
+++ b/deps/v8/src/maglev/maglev-graph.h
@@ -7,19 +7,17 @@
 
 #include <vector>
 
+#include "src/codegen/optimized-compilation-info.h"
 #include "src/compiler/heap-refs.h"
 #include "src/maglev/maglev-basic-block.h"
-#include "src/zone/zone-allocator.h"
 
 namespace v8 {
 namespace internal {
 namespace maglev {
 
-using BlockConstIterator =
-    std::vector<BasicBlock*, ZoneAllocator<BasicBlock*>>::const_iterator;
+using BlockConstIterator = ZoneVector<BasicBlock*>::const_iterator;
 using BlockConstReverseIterator =
-    std::vector<BasicBlock*,
-                ZoneAllocator<BasicBlock*>>::const_reverse_iterator;
+    ZoneVector<BasicBlock*>::const_reverse_iterator;
 
 class Graph final : public ZoneObject {
  public:
@@ -32,8 +30,11 @@ class Graph final : public ZoneObject {
         smi_(zone),
         int_(zone),
         float_(zone),
+        external_references_(zone),
         parameters_(zone),
-        constants_(zone) {}
+        register_inputs_(),
+        constants_(zone),
+        inlined_functions_(zone) {}
 
   BasicBlock* operator[](int i) { return blocks_[i]; }
   const BasicBlock* operator[](int i) const { return blocks_[i]; }
@@ -51,6 +52,8 @@ class Graph final : public ZoneObject {
 
   uint32_t tagged_stack_slots() const { return tagged_stack_slots_; }
   uint32_t untagged_stack_slots() const { return untagged_stack_slots_; }
+  uint32_t max_call_stack_args() const { return max_call_stack_args_; }
+  uint32_t max_deopted_stack_size() const { return max_deopted_stack_size_; }
   void set_tagged_stack_slots(uint32_t stack_slots) {
     DCHECK_EQ(kMaxUInt32, tagged_stack_slots_);
     DCHECK_NE(kMaxUInt32, stack_slots);
@@ -61,32 +64,62 @@ class Graph final : public ZoneObject {
     DCHECK_NE(kMaxUInt32, stack_slots);
     untagged_stack_slots_ = stack_slots;
   }
+  void set_max_call_stack_args(uint32_t stack_slots) {
+    DCHECK_EQ(kMaxUInt32, max_call_stack_args_);
+    DCHECK_NE(kMaxUInt32, stack_slots);
+    max_call_stack_args_ = stack_slots;
+  }
+  void set_max_deopted_stack_size(uint32_t size) {
+    DCHECK_EQ(kMaxUInt32, max_deopted_stack_size_);
+    DCHECK_NE(kMaxUInt32, size);
+    max_deopted_stack_size_ = size;
+  }
+
+  int total_inlined_bytecode_size() const {
+    return total_inlined_bytecode_size_;
+  }
+  void add_inlined_bytecode_size(int size) {
+    total_inlined_bytecode_size_ += size;
+  }
 
   ZoneMap<RootIndex, RootConstant*>& root() { return root_; }
   ZoneMap<int, SmiConstant*>& smi() { return smi_; }
   ZoneMap<int, Int32Constant*>& int32() { return int_; }
-  ZoneMap<double, Float64Constant*>& float64() { return float_; }
+  ZoneMap<uint64_t, Float64Constant*>& float64() { return float_; }
+  ZoneMap<Address, ExternalConstant*>& external_references() {
+    return external_references_;
+  }
   ZoneVector<InitialValue*>& parameters() { return parameters_; }
+  RegList& register_inputs() { return register_inputs_; }
   compiler::ZoneRefMap<compiler::ObjectRef, Constant*>& constants() {
     return constants_;
   }
-  Float64Constant* nan() const { return nan_; }
-  void set_nan(Float64Constant* nan) {
-    DCHECK_NULL(nan_);
-    nan_ = nan;
+  ZoneVector<OptimizedCompilationInfo::InlinedFunctionHolder>&
+  inlined_functions() {
+    return inlined_functions_;
   }
+  bool has_recursive_calls() const { return has_recursive_calls_; }
+  void set_has_recursive_calls(bool value) { has_recursive_calls_ = value; }
 
  private:
   uint32_t tagged_stack_slots_ = kMaxUInt32;
   uint32_t untagged_stack_slots_ = kMaxUInt32;
+  uint32_t max_call_stack_args_ = kMaxUInt32;
+  uint32_t max_deopted_stack_size_ = kMaxUInt32;
   ZoneVector<BasicBlock*> blocks_;
   ZoneMap<RootIndex, RootConstant*> root_;
   ZoneMap<int, SmiConstant*> smi_;
   ZoneMap<int, Int32Constant*> int_;
-  ZoneMap<double, Float64Constant*> float_;
+  // Use the bits of the float as the key.
+  ZoneMap<uint64_t, Float64Constant*> float_;
+  ZoneMap<Address, ExternalConstant*> external_references_;
   ZoneVector<InitialValue*> parameters_;
+  RegList register_inputs_;
   compiler::ZoneRefMap<compiler::ObjectRef, Constant*> constants_;
-  Float64Constant* nan_ = nullptr;
+  ZoneVector<OptimizedCompilationInfo::InlinedFunctionHolder>
+      inlined_functions_;
+  bool has_recursive_calls_ = false;
+  int total_inlined_bytecode_size_ = 0;
 };
 
 }  // namespace maglev