Inline the code dealing with entering spilled scopes and maintaining a...

src/x64/codegen-x64.h

 // Copyright 2009 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 303 matching lines @@
 
   void DeleteFrame();
 
   RegisterAllocator* allocator() const { return allocator_; }
 
   CodeGenState* state() { return state_; }
   void set_state(CodeGenState* state) { state_ = state; }
 
   void AddDeferred(DeferredCode* code) { deferred_.Add(code); }
 
+#ifdef DEBUG
   bool in_spilled_code() const { return in_spilled_code_; }
   void set_in_spilled_code(bool flag) { in_spilled_code_ = flag; }
+#endif
 
  private:
   // Construction/Destruction
   CodeGenerator(int buffer_size, Handle<Script> script, bool is_eval);
   virtual ~CodeGenerator() { delete masm_; }
 
   // Accessors
   Scope* scope() const { return scope_; }
 
   // Clearing and generating deferred code.
@@ skipping 17 matching lines @@
 
 #define DEF_VISIT(type) \
   void Visit##type(type* node);
   NODE_LIST(DEF_VISIT)
 #undef DEF_VISIT
 
   // Visit a statement and then spill the virtual frame if control flow can
   // reach the end of the statement (ie, it does not exit via break,
   // continue, return, or throw).  This function is used temporarily while
   // the code generator is being transformed.
-  void VisitAndSpill(Statement* statement);
+  inline void VisitAndSpill(Statement* statement);
 
   // Visit a list of statements and then spill the virtual frame if control
   // flow can reach the end of the list.
-  void VisitStatementsAndSpill(ZoneList<Statement*>* statements);
+  inline void VisitStatementsAndSpill(ZoneList<Statement*>* statements);
 
   // Main code generation function
   void GenCode(FunctionLiteral* fun);
 
   // Generate the return sequence code.  Should be called no more than
   // once per compiled function, immediately after binding the return
   // target (which can not be done more than once).
   void GenerateReturnSequence(Result* return_value);
 
   // The following are used by class Reference.
@@ skipping 19 matching lines @@
                      TypeofState typeof_state,
                      ControlDestination* destination,
                      bool force_control);
   void Load(Expression* x, TypeofState typeof_state = NOT_INSIDE_TYPEOF);
   void LoadGlobal();
   void LoadGlobalReceiver();
 
   // Generate code to push the value of an expression on top of the frame
   // and then spill the frame fully to memory.  This function is used
   // temporarily while the code generator is being transformed.
-  void LoadAndSpill(Expression* expression,
-                    TypeofState typeof_state = NOT_INSIDE_TYPEOF);
+  inline void LoadAndSpill(Expression* expression,
+                           TypeofState typeof_state = NOT_INSIDE_TYPEOF);
 
   // Read a value from a slot and leave it on top of the expression stack.
   void LoadFromSlot(Slot* slot, TypeofState typeof_state);
   Result LoadFromGlobalSlotCheckExtensions(Slot* slot,
                                            TypeofState typeof_state,
                                            JumpTarget* slow);
 
   // Store the value on top of the expression stack into a slot, leaving the
   // value in place.
   void StoreToSlot(Slot* slot, InitState init_state);
@@ skipping 180 matching lines @@
 
   // Jump targets.
   // The target of the return from the function.
   BreakTarget function_return_;
 
   // True if the function return is shadowed (ie, jumping to the target
   // function_return_ does not jump to the true function return, but rather
   // to some unlinking code).
   bool function_return_is_shadowed_;
 
+#ifdef DEBUG
   // True when we are in code that expects the virtual frame to be fully
   // spilled.  Some virtual frame function are disabled in DEBUG builds when
   // called from spilled code, because they do not leave the virtual frame
   // in a spilled state.
   bool in_spilled_code_;
+#endif
 
   static InlineRuntimeLUT kInlineRuntimeLUT[];
 
   friend class VirtualFrame;
   friend class JumpTarget;
   friend class Reference;
   friend class Result;
 
   DISALLOW_COPY_AND_ASSIGN(CodeGenerator);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_X64_CODEGEN_X64_H_