src/3rdparty/v8/src/frames-inl.h

   1 // Copyright 2012 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_FRAMES_INL_H_
  29 #define V8_FRAMES_INL_H_
  30
  31 #include "frames.h"
  32 #include "isolate.h"
  33 #include "v8memory.h"
  34
  35 #if V8_TARGET_ARCH_IA32
  36 #include "ia32/frames-ia32.h"
  37 #elif V8_TARGET_ARCH_X64
  38 #include "x64/frames-x64.h"
  39 #elif V8_TARGET_ARCH_ARM
  40 #include "arm/frames-arm.h"
  41 #elif V8_TARGET_ARCH_MIPS
  42 #include "mips/frames-mips.h"
  43 #else
  44 #error Unsupported target architecture.
  45 #endif
  46
  47 namespace v8 {
  48 namespace internal {
  49
  50
  51 inline Address StackHandler::address() const {
  52   return reinterpret_cast<Address>(const_cast<StackHandler*>(this));
  53 }
  54
  55
  56 inline StackHandler* StackHandler::next() const {
  57   const int offset = StackHandlerConstants::kNextOffset;
  58   return FromAddress(Memory::Address_at(address() + offset));
  59 }
  60
  61
  62 inline bool StackHandler::includes(Address address) const {
  63   Address start = this->address();
  64   Address end = start + StackHandlerConstants::kSize;
  65   return start <= address && address <= end;
  66 }
  67
  68
  69 inline void StackHandler::Iterate(ObjectVisitor* v, Code* holder) const {
  70   v->VisitPointer(context_address());
  71   v->VisitPointer(code_address());
  72 }
  73
  74
  75 inline StackHandler* StackHandler::FromAddress(Address address) {
  76   return reinterpret_cast<StackHandler*>(address);
  77 }
  78
  79
  80 inline bool StackHandler::is_js_entry() const {
  81   return kind() == JS_ENTRY;
  82 }
  83
  84
  85 inline bool StackHandler::is_catch() const {
  86   return kind() == CATCH;
  87 }
  88
  89
  90 inline bool StackHandler::is_finally() const {
  91   return kind() == FINALLY;
  92 }
  93
  94
  95 inline StackHandler::Kind StackHandler::kind() const {
  96   const int offset = StackHandlerConstants::kStateOffset;
  97   return KindField::decode(Memory::unsigned_at(address() + offset));
  98 }
  99
 100
 101 inline Object** StackHandler::context_address() const {
 102   const int offset = StackHandlerConstants::kContextOffset;
 103   return reinterpret_cast<Object**>(address() + offset);
 104 }
 105
 106
 107 inline Object** StackHandler::code_address() const {
 108   const int offset = StackHandlerConstants::kCodeOffset;
 109   return reinterpret_cast<Object**>(address() + offset);
 110 }
 111
 112
 113 inline StackFrame::StackFrame(StackFrameIterator* iterator)
 114     : iterator_(iterator), isolate_(iterator_->isolate()) {
 115 }
 116
 117
 118 inline StackHandler* StackFrame::top_handler() const {
 119   return iterator_->handler();
 120 }
 121
 122
 123 inline Code* StackFrame::LookupCode() const {
 124   return GetContainingCode(isolate(), pc());
 125 }
 126
 127
 128 inline Code* StackFrame::GetContainingCode(Isolate* isolate, Address pc) {
 129   return isolate->inner_pointer_to_code_cache()->GetCacheEntry(pc)->code;
 130 }
 131
 132
 133 inline EntryFrame::EntryFrame(StackFrameIterator* iterator)
 134     : StackFrame(iterator) {
 135 }
 136
 137
 138 inline EntryConstructFrame::EntryConstructFrame(StackFrameIterator* iterator)
 139     : EntryFrame(iterator) {
 140 }
 141
 142
 143 inline ExitFrame::ExitFrame(StackFrameIterator* iterator)
 144     : StackFrame(iterator) {
 145 }
 146
 147
 148 inline StandardFrame::StandardFrame(StackFrameIterator* iterator)
 149     : StackFrame(iterator) {
 150 }
 151
 152
 153 inline Object* StandardFrame::GetExpression(int index) const {
 154   return Memory::Object_at(GetExpressionAddress(index));
 155 }
 156
 157
 158 inline void StandardFrame::SetExpression(int index, Object* value) {
 159   Memory::Object_at(GetExpressionAddress(index)) = value;
 160 }
 161
 162
 163 inline Object* StandardFrame::context() const {
 164   const int offset = StandardFrameConstants::kContextOffset;
 165   return Memory::Object_at(fp() + offset);
 166 }
 167
 168
 169 inline Address StandardFrame::caller_fp() const {
 170   return Memory::Address_at(fp() + StandardFrameConstants::kCallerFPOffset);
 171 }
 172
 173
 174 inline Address StandardFrame::caller_pc() const {
 175   return Memory::Address_at(ComputePCAddress(fp()));
 176 }
 177
 178
 179 inline Address StandardFrame::ComputePCAddress(Address fp) {
 180   return fp + StandardFrameConstants::kCallerPCOffset;
 181 }
 182
 183
 184 inline bool StandardFrame::IsArgumentsAdaptorFrame(Address fp) {
 185   Object* marker =
 186       Memory::Object_at(fp + StandardFrameConstants::kContextOffset);
 187   return marker == Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR);
 188 }
 189
 190
 191 inline bool StandardFrame::IsConstructFrame(Address fp) {
 192   Object* marker =
 193       Memory::Object_at(fp + StandardFrameConstants::kMarkerOffset);
 194   return marker == Smi::FromInt(StackFrame::CONSTRUCT);
 195 }
 196
 197
 198 inline JavaScriptFrame::JavaScriptFrame(StackFrameIterator* iterator)
 199     : StandardFrame(iterator) {
 200 }
 201
 202
 203 Address JavaScriptFrame::GetParameterSlot(int index) const {
 204   int param_count = ComputeParametersCount();
 205   ASSERT(-1 <= index && index < param_count);
 206   int parameter_offset = (param_count - index - 1) * kPointerSize;
 207   return caller_sp() + parameter_offset;
 208 }
 209
 210
 211 Object* JavaScriptFrame::GetParameter(int index) const {
 212   return Memory::Object_at(GetParameterSlot(index));
 213 }
 214
 215
 216 inline Object* JavaScriptFrame::receiver() const {
 217   return GetParameter(-1);
 218 }
 219
 220
 221 inline void JavaScriptFrame::set_receiver(Object* value) {
 222   Memory::Object_at(GetParameterSlot(-1)) = value;
 223 }
 224
 225
 226 inline bool JavaScriptFrame::has_adapted_arguments() const {
 227   return IsArgumentsAdaptorFrame(caller_fp());
 228 }
 229
 230
 231 inline Object* JavaScriptFrame::function() const {
 232   Object* result = function_slot_object();
 233   ASSERT(result->IsJSFunction());
 234   return result;
 235 }
 236
 237
 238 inline OptimizedFrame::OptimizedFrame(StackFrameIterator* iterator)
 239     : JavaScriptFrame(iterator) {
 240 }
 241
 242
 243 inline ArgumentsAdaptorFrame::ArgumentsAdaptorFrame(
 244     StackFrameIterator* iterator) : JavaScriptFrame(iterator) {
 245 }
 246
 247
 248 inline InternalFrame::InternalFrame(StackFrameIterator* iterator)
 249     : StandardFrame(iterator) {
 250 }
 251
 252
 253 inline ConstructFrame::ConstructFrame(StackFrameIterator* iterator)
 254     : InternalFrame(iterator) {
 255 }
 256
 257
 258 template<typename Iterator>
 259 inline JavaScriptFrameIteratorTemp<Iterator>::JavaScriptFrameIteratorTemp(
 260     Isolate* isolate)
 261     : iterator_(isolate) {
 262   if (!done()) Advance();
 263 }
 264
 265
 266 template<typename Iterator>
 267 inline JavaScriptFrameIteratorTemp<Iterator>::JavaScriptFrameIteratorTemp(
 268     Isolate* isolate, ThreadLocalTop* top)
 269     : iterator_(isolate, top) {
 270   if (!done()) Advance();
 271 }
 272
 273
 274 template<typename Iterator>
 275 inline JavaScriptFrame* JavaScriptFrameIteratorTemp<Iterator>::frame() const {
 276   // TODO(1233797): The frame hierarchy needs to change. It's
 277   // problematic that we can't use the safe-cast operator to cast to
 278   // the JavaScript frame type, because we may encounter arguments
 279   // adaptor frames.
 280   StackFrame* frame = iterator_.frame();
 281   ASSERT(frame->is_java_script() || frame->is_arguments_adaptor());
 282   return static_cast<JavaScriptFrame*>(frame);
 283 }
 284
 285
 286 template<typename Iterator>
 287 JavaScriptFrameIteratorTemp<Iterator>::JavaScriptFrameIteratorTemp(
 288     Isolate* isolate, StackFrame::Id id)
 289     : iterator_(isolate) {
 290   AdvanceToId(id);
 291 }
 292
 293
 294 template<typename Iterator>
 295 void JavaScriptFrameIteratorTemp<Iterator>::Advance() {
 296   do {
 297     iterator_.Advance();
 298   } while (!iterator_.done() && !iterator_.frame()->is_java_script());
 299 }
 300
 301
 302 template<typename Iterator>
 303 void JavaScriptFrameIteratorTemp<Iterator>::AdvanceToArgumentsFrame() {
 304   if (!frame()->has_adapted_arguments()) return;
 305   iterator_.Advance();
 306   ASSERT(iterator_.frame()->is_arguments_adaptor());
 307 }
 308
 309
 310 template<typename Iterator>
 311 void JavaScriptFrameIteratorTemp<Iterator>::AdvanceToId(StackFrame::Id id) {
 312   while (!done()) {
 313     Advance();
 314     if (frame()->id() == id) return;
 315   }
 316 }
 317
 318
 319 template<typename Iterator>
 320 void JavaScriptFrameIteratorTemp<Iterator>::Reset() {
 321   iterator_.Reset();
 322   if (!done()) Advance();
 323 }
 324
 325
 326 } }  // namespace v8::internal
 327
 328 #endif  // V8_FRAMES_INL_H_