1 // Copyright 2012 the V8 project authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #ifndef V8_FRAMES_INL_H_ 6 #define V8_FRAMES_INL_H_ 7 8 #include "src/frames.h" 9 #include "src/isolate.h" 10 #include "src/objects-inl.h" 11 #include "src/v8memory.h" 12 13 #if V8_TARGET_ARCH_IA32 14 #include "src/ia32/frames-ia32.h" // NOLINT 15 #elif V8_TARGET_ARCH_X64 16 #include "src/x64/frames-x64.h" // NOLINT 17 #elif V8_TARGET_ARCH_ARM64 18 #include "src/arm64/frames-arm64.h" // NOLINT 19 #elif V8_TARGET_ARCH_ARM 20 #include "src/arm/frames-arm.h" // NOLINT 21 #elif V8_TARGET_ARCH_PPC 22 #include "src/ppc/frames-ppc.h" // NOLINT 23 #elif V8_TARGET_ARCH_MIPS 24 #include "src/mips/frames-mips.h" // NOLINT 25 #elif V8_TARGET_ARCH_MIPS64 26 #include "src/mips64/frames-mips64.h" // NOLINT 27 #elif V8_TARGET_ARCH_X87 28 #include "src/x87/frames-x87.h" // NOLINT 29 #else 30 #error Unsupported target architecture. 31 #endif 32 33 namespace v8 { 34 namespace internal { 35 36 37 inline Address StackHandler::address() const { 38 return reinterpret_cast<Address>(const_cast<StackHandler*>(this)); 39 } 40 41 42 inline StackHandler* StackHandler::next() const { 43 const int offset = StackHandlerConstants::kNextOffset; 44 return FromAddress(Memory::Address_at(address() + offset)); 45 } 46 47 48 inline StackHandler* StackHandler::FromAddress(Address address) { 49 return reinterpret_cast<StackHandler*>(address); 50 } 51 52 53 inline StackFrame::StackFrame(StackFrameIteratorBase* iterator) 54 : iterator_(iterator), isolate_(iterator_->isolate()) { 55 } 56 57 58 inline StackHandler* StackFrame::top_handler() const { 59 return iterator_->handler(); 60 } 61 62 63 inline Code* StackFrame::LookupCode() const { 64 return GetContainingCode(isolate(), pc()); 65 } 66 67 68 inline Code* StackFrame::GetContainingCode(Isolate* isolate, Address pc) { 69 return isolate->inner_pointer_to_code_cache()->GetCacheEntry(pc)->code; 70 } 71 72 73 inline Address* StackFrame::ResolveReturnAddressLocation(Address* pc_address) { 74 if (return_address_location_resolver_ == NULL) { 75 return pc_address; 76 } else { 77 return reinterpret_cast<Address*>( 78 return_address_location_resolver_( 79 reinterpret_cast<uintptr_t>(pc_address))); 80 } 81 } 82 83 84 inline EntryFrame::EntryFrame(StackFrameIteratorBase* iterator) 85 : StackFrame(iterator) { 86 } 87 88 89 inline EntryConstructFrame::EntryConstructFrame( 90 StackFrameIteratorBase* iterator) 91 : EntryFrame(iterator) { 92 } 93 94 95 inline ExitFrame::ExitFrame(StackFrameIteratorBase* iterator) 96 : StackFrame(iterator) { 97 } 98 99 100 inline StandardFrame::StandardFrame(StackFrameIteratorBase* iterator) 101 : StackFrame(iterator) { 102 } 103 104 105 inline Object* StandardFrame::GetExpression(int index) const { 106 return Memory::Object_at(GetExpressionAddress(index)); 107 } 108 109 110 inline void StandardFrame::SetExpression(int index, Object* value) { 111 Memory::Object_at(GetExpressionAddress(index)) = value; 112 } 113 114 115 inline Object* StandardFrame::context() const { 116 const int offset = StandardFrameConstants::kContextOffset; 117 return Memory::Object_at(fp() + offset); 118 } 119 120 121 inline Address StandardFrame::caller_fp() const { 122 return Memory::Address_at(fp() + StandardFrameConstants::kCallerFPOffset); 123 } 124 125 126 inline Address StandardFrame::caller_pc() const { 127 return Memory::Address_at(ComputePCAddress(fp())); 128 } 129 130 131 inline Address StandardFrame::ComputePCAddress(Address fp) { 132 return fp + StandardFrameConstants::kCallerPCOffset; 133 } 134 135 136 inline Address StandardFrame::ComputeConstantPoolAddress(Address fp) { 137 return fp + StandardFrameConstants::kConstantPoolOffset; 138 } 139 140 141 inline bool StandardFrame::IsArgumentsAdaptorFrame(Address fp) { 142 Object* marker = 143 Memory::Object_at(fp + StandardFrameConstants::kContextOffset); 144 return marker == Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR); 145 } 146 147 148 inline bool StandardFrame::IsConstructFrame(Address fp) { 149 Object* marker = 150 Memory::Object_at(fp + StandardFrameConstants::kMarkerOffset); 151 return marker == Smi::FromInt(StackFrame::CONSTRUCT); 152 } 153 154 155 inline JavaScriptFrame::JavaScriptFrame(StackFrameIteratorBase* iterator) 156 : StandardFrame(iterator) { 157 } 158 159 160 Address JavaScriptFrame::GetParameterSlot(int index) const { 161 int param_count = ComputeParametersCount(); 162 DCHECK(-1 <= index && index < param_count); 163 int parameter_offset = (param_count - index - 1) * kPointerSize; 164 return caller_sp() + parameter_offset; 165 } 166 167 168 Object* JavaScriptFrame::GetParameter(int index) const { 169 return Memory::Object_at(GetParameterSlot(index)); 170 } 171 172 173 inline Address JavaScriptFrame::GetOperandSlot(int index) const { 174 Address base = fp() + JavaScriptFrameConstants::kLocal0Offset; 175 DCHECK(IsAddressAligned(base, kPointerSize)); 176 DCHECK_EQ(type(), JAVA_SCRIPT); 177 DCHECK_LT(index, ComputeOperandsCount()); 178 DCHECK_LE(0, index); 179 // Operand stack grows down. 180 return base - index * kPointerSize; 181 } 182 183 184 inline Object* JavaScriptFrame::GetOperand(int index) const { 185 return Memory::Object_at(GetOperandSlot(index)); 186 } 187 188 189 inline int JavaScriptFrame::ComputeOperandsCount() const { 190 Address base = fp() + JavaScriptFrameConstants::kLocal0Offset; 191 // Base points to low address of first operand and stack grows down, so add 192 // kPointerSize to get the actual stack size. 193 intptr_t stack_size_in_bytes = (base + kPointerSize) - sp(); 194 DCHECK(IsAligned(stack_size_in_bytes, kPointerSize)); 195 DCHECK(type() == JAVA_SCRIPT); 196 DCHECK(stack_size_in_bytes >= 0); 197 return static_cast<int>(stack_size_in_bytes >> kPointerSizeLog2); 198 } 199 200 201 inline Object* JavaScriptFrame::receiver() const { 202 return GetParameter(-1); 203 } 204 205 206 inline void JavaScriptFrame::set_receiver(Object* value) { 207 Memory::Object_at(GetParameterSlot(-1)) = value; 208 } 209 210 211 inline bool JavaScriptFrame::has_adapted_arguments() const { 212 return IsArgumentsAdaptorFrame(caller_fp()); 213 } 214 215 216 inline JSFunction* JavaScriptFrame::function() const { 217 return JSFunction::cast(function_slot_object()); 218 } 219 220 221 inline Object* JavaScriptFrame::function_slot_object() const { 222 const int offset = JavaScriptFrameConstants::kFunctionOffset; 223 return Memory::Object_at(fp() + offset); 224 } 225 226 227 inline StubFrame::StubFrame(StackFrameIteratorBase* iterator) 228 : StandardFrame(iterator) { 229 } 230 231 232 inline OptimizedFrame::OptimizedFrame(StackFrameIteratorBase* iterator) 233 : JavaScriptFrame(iterator) { 234 } 235 236 237 inline InterpretedFrame::InterpretedFrame(StackFrameIteratorBase* iterator) 238 : JavaScriptFrame(iterator) {} 239 240 241 inline ArgumentsAdaptorFrame::ArgumentsAdaptorFrame( 242 StackFrameIteratorBase* iterator) : JavaScriptFrame(iterator) { 243 } 244 245 246 inline InternalFrame::InternalFrame(StackFrameIteratorBase* iterator) 247 : StandardFrame(iterator) { 248 } 249 250 251 inline StubFailureTrampolineFrame::StubFailureTrampolineFrame( 252 StackFrameIteratorBase* iterator) : StandardFrame(iterator) { 253 } 254 255 256 inline ConstructFrame::ConstructFrame(StackFrameIteratorBase* iterator) 257 : InternalFrame(iterator) { 258 } 259 260 261 inline JavaScriptFrameIterator::JavaScriptFrameIterator( 262 Isolate* isolate) 263 : iterator_(isolate) { 264 if (!done()) Advance(); 265 } 266 267 268 inline JavaScriptFrameIterator::JavaScriptFrameIterator( 269 Isolate* isolate, ThreadLocalTop* top) 270 : iterator_(isolate, top) { 271 if (!done()) Advance(); 272 } 273 274 275 inline JavaScriptFrame* JavaScriptFrameIterator::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 DCHECK(frame->is_java_script() || frame->is_arguments_adaptor()); 282 return static_cast<JavaScriptFrame*>(frame); 283 } 284 285 286 inline StackFrame* SafeStackFrameIterator::frame() const { 287 DCHECK(!done()); 288 DCHECK(frame_->is_java_script() || frame_->is_exit()); 289 return frame_; 290 } 291 292 293 } // namespace internal 294 } // namespace v8 295 296 #endif // V8_FRAMES_INL_H_ 297
