Home | History | Annotate | Download | only in src 
      1 // Copyright 2006-2009 the V8 project authors. All rights reserved.
      2 // Redistribution and use in source and binary forms, with or without
      3 // modification, are permitted provided that the following conditions are
      4 // met:
      5 //
      6 //     * Redistributions of source code must retain the above copyright
      7 //       notice, this list of conditions and the following disclaimer.
      8 //     * Redistributions in binary form must reproduce the above
      9 //       copyright notice, this list of conditions and the following
     10 //       disclaimer in the documentation and/or other materials provided
     11 //       with the distribution.
     12 //     * Neither the name of Google Inc. nor the names of its
     13 //       contributors may be used to endorse or promote products derived
     14 //       from this software without specific prior written permission.
     15 //
     16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
     19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
     20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
     22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     27 
     28 #ifndef V8_LOG_INL_H_
     29 #define V8_LOG_INL_H_
     30 
     31 #include "log.h"
     32 
     33 namespace v8 {
     34 namespace internal {
     35 
     36 //
     37 // VMState class implementation.  A simple stack of VM states held by the
     38 // logger and partially threaded through the call stack.  States are pushed by
     39 // VMState construction and popped by destruction.
     40 //
     41 #ifdef ENABLE_LOGGING_AND_PROFILING
     42 inline const char* StateToString(StateTag state) {
     43   switch (state) {
     44     case JS:
     45       return "JS";
     46     case GC:
     47       return "GC";
     48     case COMPILER:
     49       return "COMPILER";
     50     case OTHER:
     51       return "OTHER";
     52     default:
     53       UNREACHABLE();
     54       return NULL;
     55   }
     56 }
     57 
     58 VMState::VMState(StateTag state) : disabled_(true), external_callback_(NULL) {
     59   if (!Logger::is_logging()) {
     60     return;
     61   }
     62 
     63   disabled_ = false;
     64 #if !defined(ENABLE_HEAP_PROTECTION)
     65   // When not protecting the heap, there is no difference between
     66   // EXTERNAL and OTHER.  As an optimization in that case, we will not
     67   // perform EXTERNAL->OTHER transitions through the API.  We thus
     68   // compress the two states into one.
     69   if (state == EXTERNAL) state = OTHER;
     70 #endif
     71   state_ = state;
     72   previous_ = Logger::current_state_;
     73   Logger::current_state_ = this;
     74 
     75   if (FLAG_log_state_changes) {
     76     LOG(UncheckedStringEvent("Entering", StateToString(state_)));
     77     if (previous_ != NULL) {
     78       LOG(UncheckedStringEvent("From", StateToString(previous_->state_)));
     79     }
     80   }
     81 
     82 #ifdef ENABLE_HEAP_PROTECTION
     83   if (FLAG_protect_heap && previous_ != NULL) {
     84     if (state_ == EXTERNAL) {
     85       // We are leaving V8.
     86       ASSERT(previous_->state_ != EXTERNAL);
     87       Heap::Protect();
     88     } else if (previous_->state_ == EXTERNAL) {
     89       // We are entering V8.
     90       Heap::Unprotect();
     91     }
     92   }
     93 #endif
     94 }
     95 
     96 
     97 VMState::~VMState() {
     98   if (disabled_) return;
     99   Logger::current_state_ = previous_;
    100 
    101   if (FLAG_log_state_changes) {
    102     LOG(UncheckedStringEvent("Leaving", StateToString(state_)));
    103     if (previous_ != NULL) {
    104       LOG(UncheckedStringEvent("To", StateToString(previous_->state_)));
    105     }
    106   }
    107 
    108 #ifdef ENABLE_HEAP_PROTECTION
    109   if (FLAG_protect_heap && previous_ != NULL) {
    110     if (state_ == EXTERNAL) {
    111       // We are reentering V8.
    112       ASSERT(previous_->state_ != EXTERNAL);
    113       Heap::Unprotect();
    114     } else if (previous_->state_ == EXTERNAL) {
    115       // We are leaving V8.
    116       Heap::Protect();
    117     }
    118   }
    119 #endif
    120 }
    121 #endif
    122 
    123 
    124 } }  // namespace v8::internal
    125 
    126 #endif  // V8_LOG_INL_H_
    127