Remove an unused isolate_ field from BacktrackStack.

src/interpreter-irregexp.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 140 matching lines @@
   return *reinterpret_cast<const uint16_t *>(pc);
 }
 
 
 // A simple abstraction over the backtracking stack used by the interpreter.
 // This backtracking stack does not grow automatically, but it ensures that the
 // the memory held by the stack is released or remembered in a cache if the
 // matching terminates.
 class BacktrackStack {
  public:
-  explicit BacktrackStack(Isolate* isolate) : isolate_(isolate) {
+  explicit BacktrackStack() {
     data_ = NewArray<int>(kBacktrackStackSize);
   }
 
   ~BacktrackStack() {
     DeleteArray(data_);
   }
 
   int* data() const { return data_; }
 
   int max_size() const { return kBacktrackStackSize; }
 
  private:
   static const int kBacktrackStackSize = 10000;
 
   int* data_;
-  Isolate* isolate_;
 
   DISALLOW_COPY_AND_ASSIGN(BacktrackStack);
 };
 
 
 template <typename Char>
 static RegExpImpl::IrregexpResult RawMatch(Isolate* isolate,
                                            const byte* code_base,
                                            Vector<const Char> subject,
                                            int* registers,
                                            int current,
                                            uint32_t current_char) {
   const byte* pc = code_base;
   // BacktrackStack ensures that the memory allocated for the backtracking stack
   // is returned to the system or cached if there is no stack being cached at
   // the moment.
-  BacktrackStack backtrack_stack(isolate);
+  BacktrackStack backtrack_stack;
   int* backtrack_stack_base = backtrack_stack.data();
   int* backtrack_sp = backtrack_stack_base;
   int backtrack_stack_space = backtrack_stack.max_size();
 #ifdef DEBUG
   if (FLAG_trace_regexp_bytecodes) {
     PrintF("\n\nStart bytecode interpreter\n\n");
   }
 #endif
   while (true) {
     int32_t insn = Load32Aligned(pc);
@@ skipping 420 matching lines @@
     return RawMatch(isolate,
                     code_base,
                     subject_vector,
                     registers,
                     start_position,
                     previous_char);
   }
 }
 
 } }  // namespace v8::internal