Eagerly extract stack limit from Isolate in InitializeAstVisitor()

src/ast.h

 // Copyright 2012 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_AST_H_
 #define V8_AST_H_
 
 #include "src/assembler.h"
 #include "src/ast-value-factory.h"
 #include "src/bailout-reason.h"
@@ skipping 3143 matching lines @@
   void Visit(AstNode* node) final {                         \
     if (!CheckStackOverflow()) node->Accept(this);          \
   }                                                         \
                                                             \
   void SetStackOverflow() { stack_overflow_ = true; }       \
   void ClearStackOverflow() { stack_overflow_ = false; }    \
   bool HasStackOverflow() const { return stack_overflow_; } \
                                                             \
   bool CheckStackOverflow() {                               \
     if (stack_overflow_) return true;                       \
-    StackLimitCheck check(isolate_);                        \
-    if (!check.HasOverflowed()) return false;               \
-    stack_overflow_ = true;                                 \
-    return true;                                            \
+    if (GetCurrentStackPosition() < stack_limit_) {         \
+      stack_overflow_ = true;                               \
+      return true;                                          \
+    }                                                       \
+    return false;                                           \
   }                                                         \
                                                             \
  private:                                                   \
   void InitializeAstVisitor(Isolate* isolate, Zone* zone) { \
-    isolate_ = isolate;                                     \
     zone_ = zone;                                           \
+    stack_limit_ = isolate->stack_guard()->real_climit();   \
     stack_overflow_ = false;                                \
   }                                                         \
   Zone* zone() { return zone_; }                            \
-  Isolate* isolate() { return isolate_; }                   \
                                                             \
-  Isolate* isolate_;                                        \
   Zone* zone_;                                              \
+  uintptr_t stack_limit_;                                   \
   bool stack_overflow_
 
 
 // ----------------------------------------------------------------------------
 // AstNode factory
 
 class AstNodeFactory final BASE_EMBEDDED {
  public:
   explicit AstNodeFactory(AstValueFactory* ast_value_factory)
       : local_zone_(ast_value_factory->zone()),
@@ skipping 424 matching lines @@
   // the parser-level zone.
   Zone* parser_zone_;
   AstValueFactory* ast_value_factory_;
 };
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_AST_H_