OLD | NEW |
1 // Copyright 2013 the V8 project authors. All rights reserved. | 1 // Copyright 2013 the V8 project authors. All rights reserved. |
2 // Redistribution and use in source and binary forms, with or without | 2 // Redistribution and use in source and binary forms, with or without |
3 // modification, are permitted provided that the following conditions are | 3 // modification, are permitted provided that the following conditions are |
4 // met: | 4 // met: |
5 // | 5 // |
6 // * Redistributions of source code must retain the above copyright | 6 // * Redistributions of source code must retain the above copyright |
7 // notice, this list of conditions and the following disclaimer. | 7 // notice, this list of conditions and the following disclaimer. |
8 // * Redistributions in binary form must reproduce the above | 8 // * Redistributions in binary form must reproduce the above |
9 // copyright notice, this list of conditions and the following | 9 // copyright notice, this list of conditions and the following |
10 // disclaimer in the documentation and/or other materials provided | 10 // disclaimer in the documentation and/or other materials provided |
(...skipping 1568 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1579 (output_frame_size - output_frame_offset) + kPointerSize; | 1579 (output_frame_size - output_frame_offset) + kPointerSize; |
1580 output_frame->SetFrameSlot(output_frame_offset, value); | 1580 output_frame->SetFrameSlot(output_frame_offset, value); |
1581 if (trace_scope_ != NULL) { | 1581 if (trace_scope_ != NULL) { |
1582 PrintF(trace_scope_->file(), | 1582 PrintF(trace_scope_->file(), |
1583 " 0x%08" V8PRIxPTR ": [top + %d] <- 0x%08" | 1583 " 0x%08" V8PRIxPTR ": [top + %d] <- 0x%08" |
1584 V8PRIxPTR " ; args*\n", | 1584 V8PRIxPTR " ; args*\n", |
1585 top_address + output_frame_offset, output_frame_offset, value); | 1585 top_address + output_frame_offset, output_frame_offset, value); |
1586 } | 1586 } |
1587 | 1587 |
1588 // Copy the register parameters to the failure frame. | 1588 // Copy the register parameters to the failure frame. |
| 1589 int arguments_length_offset = -1; |
1589 for (int i = 0; i < descriptor->register_param_count_; ++i) { | 1590 for (int i = 0; i < descriptor->register_param_count_; ++i) { |
1590 output_frame_offset -= kPointerSize; | 1591 output_frame_offset -= kPointerSize; |
1591 DoTranslateCommand(iterator, 0, output_frame_offset); | 1592 DoTranslateCommand(iterator, 0, output_frame_offset); |
| 1593 |
| 1594 if (!arg_count_known && descriptor->IsParameterCountRegister(i)) { |
| 1595 arguments_length_offset = output_frame_offset; |
| 1596 } |
1592 } | 1597 } |
1593 | 1598 |
| 1599 ASSERT(0 == output_frame_offset); |
| 1600 |
1594 if (!arg_count_known) { | 1601 if (!arg_count_known) { |
1595 DoTranslateCommand(iterator, 0, length_frame_offset, | 1602 ASSERT(arguments_length_offset >= 0); |
1596 TRANSLATED_VALUE_IS_NATIVE); | 1603 // We know it's a smi because 1) the code stub guarantees the stack |
1597 caller_arg_count = output_frame->GetFrameSlot(length_frame_offset); | 1604 // parameter count is in smi range, and 2) the DoTranslateCommand in the |
| 1605 // parameter loop above translated that to a tagged value. |
| 1606 Smi* smi_caller_arg_count = reinterpret_cast<Smi*>( |
| 1607 output_frame->GetFrameSlot(arguments_length_offset)); |
| 1608 caller_arg_count = smi_caller_arg_count->value(); |
| 1609 output_frame->SetFrameSlot(length_frame_offset, caller_arg_count); |
| 1610 if (trace_scope_ != NULL) { |
| 1611 PrintF(trace_scope_->file(), |
| 1612 " 0x%08" V8PRIxPTR ": [top + %d] <- 0x%08" |
| 1613 V8PRIxPTR " ; args.length\n", |
| 1614 top_address + length_frame_offset, length_frame_offset, |
| 1615 caller_arg_count); |
| 1616 } |
1598 value = frame_ptr + StandardFrameConstants::kCallerSPOffset + | 1617 value = frame_ptr + StandardFrameConstants::kCallerSPOffset + |
1599 (caller_arg_count - 1) * kPointerSize; | 1618 (caller_arg_count - 1) * kPointerSize; |
1600 output_frame->SetFrameSlot(args_arguments_offset, value); | 1619 output_frame->SetFrameSlot(args_arguments_offset, value); |
1601 if (trace_scope_ != NULL) { | 1620 if (trace_scope_ != NULL) { |
1602 PrintF(trace_scope_->file(), | 1621 PrintF(trace_scope_->file(), |
1603 " 0x%08" V8PRIxPTR ": [top + %d] <- 0x%08" | 1622 " 0x%08" V8PRIxPTR ": [top + %d] <- 0x%08" |
1604 V8PRIxPTR " ; args.arguments\n", | 1623 V8PRIxPTR " ; args.arguments\n", |
1605 top_address + args_arguments_offset, args_arguments_offset, value); | 1624 top_address + args_arguments_offset, args_arguments_offset, |
| 1625 value); |
1606 } | 1626 } |
1607 } | 1627 } |
1608 | 1628 |
1609 ASSERT(0 == output_frame_offset); | |
1610 | |
1611 // Copy the double registers from the input into the output frame. | 1629 // Copy the double registers from the input into the output frame. |
1612 CopyDoubleRegisters(output_frame); | 1630 CopyDoubleRegisters(output_frame); |
1613 | 1631 |
1614 // Fill registers containing handler and number of parameters. | 1632 // Fill registers containing handler and number of parameters. |
1615 SetPlatformCompiledStubRegisters(output_frame, descriptor); | 1633 SetPlatformCompiledStubRegisters(output_frame, descriptor); |
1616 | 1634 |
1617 // Compute this frame's PC, state, and continuation. | 1635 // Compute this frame's PC, state, and continuation. |
1618 Code* trampoline = NULL; | 1636 Code* trampoline = NULL; |
1619 StubFunctionMode function_mode = descriptor->function_mode_; | 1637 StubFunctionMode function_mode = descriptor->function_mode_; |
1620 StubFailureTrampolineStub(function_mode).FindCodeInCache(&trampoline, | 1638 StubFailureTrampolineStub(function_mode).FindCodeInCache(&trampoline, |
(...skipping 246 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1867 index); | 1885 index); |
1868 } | 1886 } |
1869 | 1887 |
1870 info->SetExpression(index, *num); | 1888 info->SetExpression(index, *num); |
1871 } | 1889 } |
1872 } | 1890 } |
1873 } | 1891 } |
1874 #endif | 1892 #endif |
1875 | 1893 |
1876 | 1894 |
1877 static const char* TraceValueType(bool is_smi, bool is_native = false) { | 1895 static const char* TraceValueType(bool is_smi) { |
1878 if (is_native) { | 1896 if (is_smi) { |
1879 return "native"; | |
1880 } else if (is_smi) { | |
1881 return "smi"; | 1897 return "smi"; |
1882 } | 1898 } |
1883 | 1899 |
1884 return "heap number"; | 1900 return "heap number"; |
1885 } | 1901 } |
1886 | 1902 |
1887 | 1903 |
1888 void Deoptimizer::DoTranslateObject(TranslationIterator* iterator, | 1904 void Deoptimizer::DoTranslateObject(TranslationIterator* iterator, |
1889 int object_index, | 1905 int object_index, |
1890 int field_index) { | 1906 int field_index) { |
(...skipping 248 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
2139 for (int i = 0; i < length; i++) { | 2155 for (int i = 0; i < length; i++) { |
2140 DoTranslateObject(iterator, object_index, i); | 2156 DoTranslateObject(iterator, object_index, i); |
2141 } | 2157 } |
2142 return; | 2158 return; |
2143 } | 2159 } |
2144 } | 2160 } |
2145 } | 2161 } |
2146 | 2162 |
2147 | 2163 |
2148 void Deoptimizer::DoTranslateCommand(TranslationIterator* iterator, | 2164 void Deoptimizer::DoTranslateCommand(TranslationIterator* iterator, |
2149 int frame_index, | 2165 int frame_index, |
2150 unsigned output_offset, | 2166 unsigned output_offset) { |
2151 DeoptimizerTranslatedValueType value_type) { | |
2152 disasm::NameConverter converter; | 2167 disasm::NameConverter converter; |
2153 // A GC-safe temporary placeholder that we can put in the output frame. | 2168 // A GC-safe temporary placeholder that we can put in the output frame. |
2154 const intptr_t kPlaceholder = reinterpret_cast<intptr_t>(Smi::FromInt(0)); | 2169 const intptr_t kPlaceholder = reinterpret_cast<intptr_t>(Smi::FromInt(0)); |
2155 bool is_native = value_type == TRANSLATED_VALUE_IS_NATIVE; | |
2156 | 2170 |
2157 Translation::Opcode opcode = | 2171 Translation::Opcode opcode = |
2158 static_cast<Translation::Opcode>(iterator->Next()); | 2172 static_cast<Translation::Opcode>(iterator->Next()); |
2159 | 2173 |
2160 switch (opcode) { | 2174 switch (opcode) { |
2161 case Translation::BEGIN: | 2175 case Translation::BEGIN: |
2162 case Translation::JS_FRAME: | 2176 case Translation::JS_FRAME: |
2163 case Translation::ARGUMENTS_ADAPTOR_FRAME: | 2177 case Translation::ARGUMENTS_ADAPTOR_FRAME: |
2164 case Translation::CONSTRUCT_STUB_FRAME: | 2178 case Translation::CONSTRUCT_STUB_FRAME: |
2165 case Translation::GETTER_STUB_FRAME: | 2179 case Translation::GETTER_STUB_FRAME: |
(...skipping 17 matching lines...) Expand all Loading... |
2183 trace_scope_->file()); | 2197 trace_scope_->file()); |
2184 PrintF(trace_scope_->file(), "\n"); | 2198 PrintF(trace_scope_->file(), "\n"); |
2185 } | 2199 } |
2186 output_[frame_index]->SetFrameSlot(output_offset, input_value); | 2200 output_[frame_index]->SetFrameSlot(output_offset, input_value); |
2187 return; | 2201 return; |
2188 } | 2202 } |
2189 | 2203 |
2190 case Translation::INT32_REGISTER: { | 2204 case Translation::INT32_REGISTER: { |
2191 int input_reg = iterator->Next(); | 2205 int input_reg = iterator->Next(); |
2192 intptr_t value = input_->GetRegister(input_reg); | 2206 intptr_t value = input_->GetRegister(input_reg); |
2193 bool is_smi = (value_type == TRANSLATED_VALUE_IS_TAGGED) && | 2207 bool is_smi = Smi::IsValid(value); |
2194 Smi::IsValid(value); | |
2195 if (trace_scope_ != NULL) { | 2208 if (trace_scope_ != NULL) { |
2196 PrintF( | 2209 PrintF( |
2197 trace_scope_->file(), | 2210 trace_scope_->file(), |
2198 " 0x%08" V8PRIxPTR ": [top + %d] <- %" V8PRIdPTR " ; %s (%s)\n", | 2211 " 0x%08" V8PRIxPTR ": [top + %d] <- %" V8PRIdPTR " ; %s (%s)\n", |
2199 output_[frame_index]->GetTop() + output_offset, | 2212 output_[frame_index]->GetTop() + output_offset, |
2200 output_offset, | 2213 output_offset, |
2201 value, | 2214 value, |
2202 converter.NameOfCPURegister(input_reg), | 2215 converter.NameOfCPURegister(input_reg), |
2203 TraceValueType(is_smi, is_native)); | 2216 TraceValueType(is_smi)); |
2204 } | 2217 } |
2205 if (is_smi) { | 2218 if (is_smi) { |
2206 intptr_t tagged_value = | 2219 intptr_t tagged_value = |
2207 reinterpret_cast<intptr_t>(Smi::FromInt(static_cast<int>(value))); | 2220 reinterpret_cast<intptr_t>(Smi::FromInt(static_cast<int>(value))); |
2208 output_[frame_index]->SetFrameSlot(output_offset, tagged_value); | 2221 output_[frame_index]->SetFrameSlot(output_offset, tagged_value); |
2209 } else if (value_type == TRANSLATED_VALUE_IS_NATIVE) { | |
2210 output_[frame_index]->SetFrameSlot(output_offset, value); | |
2211 } else { | 2222 } else { |
2212 // We save the untagged value on the side and store a GC-safe | 2223 // We save the untagged value on the side and store a GC-safe |
2213 // temporary placeholder in the frame. | 2224 // temporary placeholder in the frame. |
2214 ASSERT(value_type == TRANSLATED_VALUE_IS_TAGGED); | |
2215 AddDoubleValue(output_[frame_index]->GetTop() + output_offset, | 2225 AddDoubleValue(output_[frame_index]->GetTop() + output_offset, |
2216 static_cast<double>(static_cast<int32_t>(value))); | 2226 static_cast<double>(static_cast<int32_t>(value))); |
2217 output_[frame_index]->SetFrameSlot(output_offset, kPlaceholder); | 2227 output_[frame_index]->SetFrameSlot(output_offset, kPlaceholder); |
2218 } | 2228 } |
2219 return; | 2229 return; |
2220 } | 2230 } |
2221 | 2231 |
2222 case Translation::UINT32_REGISTER: { | 2232 case Translation::UINT32_REGISTER: { |
2223 int input_reg = iterator->Next(); | 2233 int input_reg = iterator->Next(); |
2224 uintptr_t value = static_cast<uintptr_t>(input_->GetRegister(input_reg)); | 2234 uintptr_t value = static_cast<uintptr_t>(input_->GetRegister(input_reg)); |
2225 bool is_smi = (value_type == TRANSLATED_VALUE_IS_TAGGED) && | 2235 bool is_smi = value <= static_cast<uintptr_t>(Smi::kMaxValue); |
2226 (value <= static_cast<uintptr_t>(Smi::kMaxValue)); | |
2227 if (trace_scope_ != NULL) { | 2236 if (trace_scope_ != NULL) { |
2228 PrintF( | 2237 PrintF( |
2229 trace_scope_->file(), | 2238 trace_scope_->file(), |
2230 " 0x%08" V8PRIxPTR ": [top + %d] <- %" V8PRIuPTR | 2239 " 0x%08" V8PRIxPTR ": [top + %d] <- %" V8PRIuPTR |
2231 " ; uint %s (%s)\n", | 2240 " ; uint %s (%s)\n", |
2232 output_[frame_index]->GetTop() + output_offset, | 2241 output_[frame_index]->GetTop() + output_offset, |
2233 output_offset, | 2242 output_offset, |
2234 value, | 2243 value, |
2235 converter.NameOfCPURegister(input_reg), | 2244 converter.NameOfCPURegister(input_reg), |
2236 TraceValueType(is_smi, is_native)); | 2245 TraceValueType(is_smi)); |
2237 } | 2246 } |
2238 if (is_smi) { | 2247 if (is_smi) { |
2239 intptr_t tagged_value = | 2248 intptr_t tagged_value = |
2240 reinterpret_cast<intptr_t>(Smi::FromInt(static_cast<int>(value))); | 2249 reinterpret_cast<intptr_t>(Smi::FromInt(static_cast<int>(value))); |
2241 output_[frame_index]->SetFrameSlot(output_offset, tagged_value); | 2250 output_[frame_index]->SetFrameSlot(output_offset, tagged_value); |
2242 } else if (value_type == TRANSLATED_VALUE_IS_NATIVE) { | |
2243 output_[frame_index]->SetFrameSlot(output_offset, value); | |
2244 } else { | 2251 } else { |
2245 // We save the untagged value on the side and store a GC-safe | 2252 // We save the untagged value on the side and store a GC-safe |
2246 // temporary placeholder in the frame. | 2253 // temporary placeholder in the frame. |
2247 ASSERT(value_type == TRANSLATED_VALUE_IS_TAGGED); | |
2248 AddDoubleValue(output_[frame_index]->GetTop() + output_offset, | 2254 AddDoubleValue(output_[frame_index]->GetTop() + output_offset, |
2249 static_cast<double>(static_cast<uint32_t>(value))); | 2255 static_cast<double>(static_cast<uint32_t>(value))); |
2250 output_[frame_index]->SetFrameSlot(output_offset, kPlaceholder); | 2256 output_[frame_index]->SetFrameSlot(output_offset, kPlaceholder); |
2251 } | 2257 } |
2252 return; | 2258 return; |
2253 } | 2259 } |
2254 | 2260 |
2255 case Translation::DOUBLE_REGISTER: { | 2261 case Translation::DOUBLE_REGISTER: { |
2256 int input_reg = iterator->Next(); | 2262 int input_reg = iterator->Next(); |
2257 double value = input_->GetDoubleRegister(input_reg); | 2263 double value = input_->GetDoubleRegister(input_reg); |
(...skipping 30 matching lines...) Expand all Loading... |
2288 PrintF(trace_scope_->file(), "\n"); | 2294 PrintF(trace_scope_->file(), "\n"); |
2289 } | 2295 } |
2290 output_[frame_index]->SetFrameSlot(output_offset, input_value); | 2296 output_[frame_index]->SetFrameSlot(output_offset, input_value); |
2291 return; | 2297 return; |
2292 } | 2298 } |
2293 | 2299 |
2294 case Translation::INT32_STACK_SLOT: { | 2300 case Translation::INT32_STACK_SLOT: { |
2295 int input_slot_index = iterator->Next(); | 2301 int input_slot_index = iterator->Next(); |
2296 unsigned input_offset = input_->GetOffsetFromSlotIndex(input_slot_index); | 2302 unsigned input_offset = input_->GetOffsetFromSlotIndex(input_slot_index); |
2297 intptr_t value = input_->GetFrameSlot(input_offset); | 2303 intptr_t value = input_->GetFrameSlot(input_offset); |
2298 bool is_smi = (value_type == TRANSLATED_VALUE_IS_TAGGED) && | 2304 bool is_smi = Smi::IsValid(value); |
2299 Smi::IsValid(value); | |
2300 if (trace_scope_ != NULL) { | 2305 if (trace_scope_ != NULL) { |
2301 PrintF(trace_scope_->file(), | 2306 PrintF(trace_scope_->file(), |
2302 " 0x%08" V8PRIxPTR ": ", | 2307 " 0x%08" V8PRIxPTR ": ", |
2303 output_[frame_index]->GetTop() + output_offset); | 2308 output_[frame_index]->GetTop() + output_offset); |
2304 PrintF(trace_scope_->file(), | 2309 PrintF(trace_scope_->file(), |
2305 "[top + %d] <- %" V8PRIdPTR " ; [sp + %d] (%s)\n", | 2310 "[top + %d] <- %" V8PRIdPTR " ; [sp + %d] (%s)\n", |
2306 output_offset, | 2311 output_offset, |
2307 value, | 2312 value, |
2308 input_offset, | 2313 input_offset, |
2309 TraceValueType(is_smi, is_native)); | 2314 TraceValueType(is_smi)); |
2310 } | 2315 } |
2311 if (is_smi) { | 2316 if (is_smi) { |
2312 intptr_t tagged_value = | 2317 intptr_t tagged_value = |
2313 reinterpret_cast<intptr_t>(Smi::FromInt(static_cast<int>(value))); | 2318 reinterpret_cast<intptr_t>(Smi::FromInt(static_cast<int>(value))); |
2314 output_[frame_index]->SetFrameSlot(output_offset, tagged_value); | 2319 output_[frame_index]->SetFrameSlot(output_offset, tagged_value); |
2315 } else if (value_type == TRANSLATED_VALUE_IS_NATIVE) { | |
2316 output_[frame_index]->SetFrameSlot(output_offset, value); | |
2317 } else { | 2320 } else { |
2318 // We save the untagged value on the side and store a GC-safe | 2321 // We save the untagged value on the side and store a GC-safe |
2319 // temporary placeholder in the frame. | 2322 // temporary placeholder in the frame. |
2320 ASSERT(value_type == TRANSLATED_VALUE_IS_TAGGED); | |
2321 AddDoubleValue(output_[frame_index]->GetTop() + output_offset, | 2323 AddDoubleValue(output_[frame_index]->GetTop() + output_offset, |
2322 static_cast<double>(static_cast<int32_t>(value))); | 2324 static_cast<double>(static_cast<int32_t>(value))); |
2323 output_[frame_index]->SetFrameSlot(output_offset, kPlaceholder); | 2325 output_[frame_index]->SetFrameSlot(output_offset, kPlaceholder); |
2324 } | 2326 } |
2325 return; | 2327 return; |
2326 } | 2328 } |
2327 | 2329 |
2328 case Translation::UINT32_STACK_SLOT: { | 2330 case Translation::UINT32_STACK_SLOT: { |
2329 int input_slot_index = iterator->Next(); | 2331 int input_slot_index = iterator->Next(); |
2330 unsigned input_offset = input_->GetOffsetFromSlotIndex(input_slot_index); | 2332 unsigned input_offset = input_->GetOffsetFromSlotIndex(input_slot_index); |
2331 uintptr_t value = | 2333 uintptr_t value = |
2332 static_cast<uintptr_t>(input_->GetFrameSlot(input_offset)); | 2334 static_cast<uintptr_t>(input_->GetFrameSlot(input_offset)); |
2333 bool is_smi = (value_type == TRANSLATED_VALUE_IS_TAGGED) && | 2335 bool is_smi = value <= static_cast<uintptr_t>(Smi::kMaxValue); |
2334 (value <= static_cast<uintptr_t>(Smi::kMaxValue)); | |
2335 if (trace_scope_ != NULL) { | 2336 if (trace_scope_ != NULL) { |
2336 PrintF(trace_scope_->file(), | 2337 PrintF(trace_scope_->file(), |
2337 " 0x%08" V8PRIxPTR ": ", | 2338 " 0x%08" V8PRIxPTR ": ", |
2338 output_[frame_index]->GetTop() + output_offset); | 2339 output_[frame_index]->GetTop() + output_offset); |
2339 PrintF(trace_scope_->file(), | 2340 PrintF(trace_scope_->file(), |
2340 "[top + %d] <- %" V8PRIuPTR " ; [sp + %d] (uint32 %s)\n", | 2341 "[top + %d] <- %" V8PRIuPTR " ; [sp + %d] (uint32 %s)\n", |
2341 output_offset, | 2342 output_offset, |
2342 value, | 2343 value, |
2343 input_offset, | 2344 input_offset, |
2344 TraceValueType(is_smi, is_native)); | 2345 TraceValueType(is_smi)); |
2345 } | 2346 } |
2346 if (is_smi) { | 2347 if (is_smi) { |
2347 intptr_t tagged_value = | 2348 intptr_t tagged_value = |
2348 reinterpret_cast<intptr_t>(Smi::FromInt(static_cast<int>(value))); | 2349 reinterpret_cast<intptr_t>(Smi::FromInt(static_cast<int>(value))); |
2349 output_[frame_index]->SetFrameSlot(output_offset, tagged_value); | 2350 output_[frame_index]->SetFrameSlot(output_offset, tagged_value); |
2350 } else if (value_type == TRANSLATED_VALUE_IS_NATIVE) { | |
2351 output_[frame_index]->SetFrameSlot(output_offset, value); | |
2352 } else { | 2351 } else { |
2353 // We save the untagged value on the side and store a GC-safe | 2352 // We save the untagged value on the side and store a GC-safe |
2354 // temporary placeholder in the frame. | 2353 // temporary placeholder in the frame. |
2355 ASSERT(value_type == TRANSLATED_VALUE_IS_TAGGED); | |
2356 AddDoubleValue(output_[frame_index]->GetTop() + output_offset, | 2354 AddDoubleValue(output_[frame_index]->GetTop() + output_offset, |
2357 static_cast<double>(static_cast<uint32_t>(value))); | 2355 static_cast<double>(static_cast<uint32_t>(value))); |
2358 output_[frame_index]->SetFrameSlot(output_offset, kPlaceholder); | 2356 output_[frame_index]->SetFrameSlot(output_offset, kPlaceholder); |
2359 } | 2357 } |
2360 return; | 2358 return; |
2361 } | 2359 } |
2362 | 2360 |
2363 case Translation::DOUBLE_STACK_SLOT: { | 2361 case Translation::DOUBLE_STACK_SLOT: { |
2364 int input_slot_index = iterator->Next(); | 2362 int input_slot_index = iterator->Next(); |
2365 unsigned input_offset = input_->GetOffsetFromSlotIndex(input_slot_index); | 2363 unsigned input_offset = input_->GetOffsetFromSlotIndex(input_slot_index); |
(...skipping 682 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
3048 | 3046 |
3049 void DeoptimizedFrameInfo::Iterate(ObjectVisitor* v) { | 3047 void DeoptimizedFrameInfo::Iterate(ObjectVisitor* v) { |
3050 v->VisitPointer(BitCast<Object**>(&function_)); | 3048 v->VisitPointer(BitCast<Object**>(&function_)); |
3051 v->VisitPointers(parameters_, parameters_ + parameters_count_); | 3049 v->VisitPointers(parameters_, parameters_ + parameters_count_); |
3052 v->VisitPointers(expression_stack_, expression_stack_ + expression_count_); | 3050 v->VisitPointers(expression_stack_, expression_stack_ + expression_count_); |
3053 } | 3051 } |
3054 | 3052 |
3055 #endif // ENABLE_DEBUGGER_SUPPORT | 3053 #endif // ENABLE_DEBUGGER_SUPPORT |
3056 | 3054 |
3057 } } // namespace v8::internal | 3055 } } // namespace v8::internal |
OLD | NEW |