LCOV - code coverage report
Current view: top level - src - assembler.cc (source / functions) Hit Total Coverage
Test: app.info Lines: 520 615 84.6 %
Date: 2017-04-26 Functions: 165 181 91.2 %

          Line data    Source code
       1             : // Copyright (c) 1994-2006 Sun Microsystems Inc.
       2             : // All Rights Reserved.
       3             : //
       4             : // Redistribution and use in source and binary forms, with or without
       5             : // modification, are permitted provided that the following conditions are
       6             : // met:
       7             : //
       8             : // - Redistributions of source code must retain the above copyright notice,
       9             : // this list of conditions and the following disclaimer.
      10             : //
      11             : // - Redistribution in binary form must reproduce the above copyright
      12             : // notice, this list of conditions and the following disclaimer in the
      13             : // documentation and/or other materials provided with the distribution.
      14             : //
      15             : // - Neither the name of Sun Microsystems or the names of contributors may
      16             : // be used to endorse or promote products derived from this software without
      17             : // specific prior written permission.
      18             : //
      19             : // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
      20             : // IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
      21             : // THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
      22             : // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
      23             : // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
      24             : // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
      25             : // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
      26             : // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
      27             : // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
      28             : // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
      29             : // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
      30             : 
      31             : // The original source code covered by the above license above has been
      32             : // modified significantly by Google Inc.
      33             : // Copyright 2012 the V8 project authors. All rights reserved.
      34             : 
      35             : #include "src/assembler.h"
      36             : 
      37             : #include <math.h>
      38             : #include <string.h>
      39             : #include <cmath>
      40             : 
      41             : #include "src/api.h"
      42             : #include "src/assembler-inl.h"
      43             : #include "src/base/cpu.h"
      44             : #include "src/base/functional.h"
      45             : #include "src/base/ieee754.h"
      46             : #include "src/base/lazy-instance.h"
      47             : #include "src/base/platform/platform.h"
      48             : #include "src/base/utils/random-number-generator.h"
      49             : #include "src/codegen.h"
      50             : #include "src/counters.h"
      51             : #include "src/debug/debug.h"
      52             : #include "src/deoptimizer.h"
      53             : #include "src/disassembler.h"
      54             : #include "src/execution.h"
      55             : #include "src/ic/ic.h"
      56             : #include "src/ic/stub-cache.h"
      57             : #include "src/interpreter/interpreter.h"
      58             : #include "src/ostreams.h"
      59             : #include "src/regexp/jsregexp.h"
      60             : #include "src/regexp/regexp-macro-assembler.h"
      61             : #include "src/regexp/regexp-stack.h"
      62             : #include "src/register-configuration.h"
      63             : #include "src/runtime/runtime.h"
      64             : #include "src/simulator.h"  // For flushing instruction cache.
      65             : #include "src/snapshot/serializer-common.h"
      66             : #include "src/string-search.h"
      67             : #include "src/wasm/wasm-external-refs.h"
      68             : 
      69             : // Include native regexp-macro-assembler.
      70             : #ifndef V8_INTERPRETED_REGEXP
      71             : #if V8_TARGET_ARCH_IA32
      72             : #include "src/regexp/ia32/regexp-macro-assembler-ia32.h"  // NOLINT
      73             : #elif V8_TARGET_ARCH_X64
      74             : #include "src/regexp/x64/regexp-macro-assembler-x64.h"  // NOLINT
      75             : #elif V8_TARGET_ARCH_ARM64
      76             : #include "src/regexp/arm64/regexp-macro-assembler-arm64.h"  // NOLINT
      77             : #elif V8_TARGET_ARCH_ARM
      78             : #include "src/regexp/arm/regexp-macro-assembler-arm.h"  // NOLINT
      79             : #elif V8_TARGET_ARCH_PPC
      80             : #include "src/regexp/ppc/regexp-macro-assembler-ppc.h"  // NOLINT
      81             : #elif V8_TARGET_ARCH_MIPS
      82             : #include "src/regexp/mips/regexp-macro-assembler-mips.h"  // NOLINT
      83             : #elif V8_TARGET_ARCH_MIPS64
      84             : #include "src/regexp/mips64/regexp-macro-assembler-mips64.h"  // NOLINT
      85             : #elif V8_TARGET_ARCH_S390
      86             : #include "src/regexp/s390/regexp-macro-assembler-s390.h"  // NOLINT
      87             : #elif V8_TARGET_ARCH_X87
      88             : #include "src/regexp/x87/regexp-macro-assembler-x87.h"  // NOLINT
      89             : #else  // Unknown architecture.
      90             : #error "Unknown architecture."
      91             : #endif  // Target architecture.
      92             : #endif  // V8_INTERPRETED_REGEXP
      93             : 
      94             : namespace v8 {
      95             : namespace internal {
      96             : 
      97             : // -----------------------------------------------------------------------------
      98             : // Common double constants.
      99             : 
     100             : struct DoubleConstant BASE_EMBEDDED {
     101             : double min_int;
     102             : double one_half;
     103             : double minus_one_half;
     104             : double negative_infinity;
     105             : uint64_t the_hole_nan;
     106             : double uint32_bias;
     107             : };
     108             : 
     109             : static DoubleConstant double_constants;
     110             : 
     111             : static struct V8_ALIGNED(16) {
     112             :   uint32_t a;
     113             :   uint32_t b;
     114             :   uint32_t c;
     115             :   uint32_t d;
     116             : } float_absolute_constant = {0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF, 0x7FFFFFFF};
     117             : 
     118             : static struct V8_ALIGNED(16) {
     119             :   uint32_t a;
     120             :   uint32_t b;
     121             :   uint32_t c;
     122             :   uint32_t d;
     123             : } float_negate_constant = {0x80000000, 0x80000000, 0x80000000, 0x80000000};
     124             : 
     125             : static struct V8_ALIGNED(16) {
     126             :   uint64_t a;
     127             :   uint64_t b;
     128             : } double_absolute_constant = {V8_UINT64_C(0x7FFFFFFFFFFFFFFF),
     129             :                               V8_UINT64_C(0x7FFFFFFFFFFFFFFF)};
     130             : 
     131             : static struct V8_ALIGNED(16) {
     132             :   uint64_t a;
     133             :   uint64_t b;
     134             : } double_negate_constant = {V8_UINT64_C(0x8000000000000000),
     135             :                             V8_UINT64_C(0x8000000000000000)};
     136             : 
     137             : const char* const RelocInfo::kFillerCommentString = "DEOPTIMIZATION PADDING";
     138             : 
     139             : // -----------------------------------------------------------------------------
     140             : // Implementation of AssemblerBase
     141             : 
     142    13459314 : AssemblerBase::IsolateData::IsolateData(Isolate* isolate)
     143             :     : serializer_enabled_(isolate->serializer_enabled())
     144             : #if V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_X64
     145             :       ,
     146    13459314 :       max_old_generation_size_(isolate->heap()->MaxOldGenerationSize())
     147             : #endif
     148             : #if V8_TARGET_ARCH_X64
     149             :       ,
     150             :       code_range_start_(
     151    40377942 :           isolate->heap()->memory_allocator()->code_range()->start())
     152             : #endif
     153             : {
     154    13459314 : }
     155             : 
     156    13459319 : AssemblerBase::AssemblerBase(IsolateData isolate_data, void* buffer,
     157             :                              int buffer_size)
     158             :     : isolate_data_(isolate_data),
     159             :       enabled_cpu_features_(0),
     160             :       emit_debug_code_(FLAG_debug_code),
     161             :       predictable_code_size_(false),
     162    13459319 :       constant_pool_available_(false) {
     163    13459319 :   own_buffer_ = buffer == NULL;
     164    13459319 :   if (buffer_size == 0) buffer_size = kMinimalBufferSize;
     165             :   DCHECK(buffer_size > 0);
     166    13459319 :   if (own_buffer_) buffer = NewArray<byte>(buffer_size);
     167    13459322 :   buffer_ = static_cast<byte*>(buffer);
     168    13459322 :   buffer_size_ = buffer_size;
     169    13459322 :   pc_ = buffer_;
     170    13459322 : }
     171             : 
     172    13459312 : AssemblerBase::~AssemblerBase() {
     173    13459312 :   if (own_buffer_) DeleteArray(buffer_);
     174    13459317 : }
     175             : 
     176   382191068 : void AssemblerBase::FlushICache(Isolate* isolate, void* start, size_t size) {
     177   764386729 :   if (size == 0) return;
     178             : 
     179             : #if defined(USE_SIMULATOR)
     180             :   base::LockGuard<base::Mutex> lock_guard(isolate->simulator_i_cache_mutex());
     181             :   Simulator::FlushICache(isolate->simulator_i_cache(), start, size);
     182             : #else
     183   382266012 :   CpuFeatures::FlushICache(start, size);
     184             : #endif  // USE_SIMULATOR
     185             : }
     186             : 
     187           0 : void AssemblerBase::Print(Isolate* isolate) {
     188           0 :   OFStream os(stdout);
     189           0 :   v8::internal::Disassembler::Decode(isolate, &os, buffer_, pc_, nullptr);
     190           0 : }
     191             : 
     192             : 
     193             : // -----------------------------------------------------------------------------
     194             : // Implementation of PredictableCodeSizeScope
     195             : 
     196           0 : PredictableCodeSizeScope::PredictableCodeSizeScope(AssemblerBase* assembler)
     197           0 :     : PredictableCodeSizeScope(assembler, -1) {}
     198             : 
     199             : 
     200     5584953 : PredictableCodeSizeScope::PredictableCodeSizeScope(AssemblerBase* assembler,
     201             :                                                    int expected_size)
     202             :     : assembler_(assembler),
     203             :       expected_size_(expected_size),
     204             :       start_offset_(assembler->pc_offset()),
     205     5584953 :       old_value_(assembler->predictable_code_size()) {
     206             :   assembler_->set_predictable_code_size(true);
     207     1861651 : }
     208             : 
     209             : 
     210     1861658 : PredictableCodeSizeScope::~PredictableCodeSizeScope() {
     211             :   // TODO(svenpanne) Remove the 'if' when everything works.
     212     1861658 :   if (expected_size_ >= 0) {
     213     3723318 :     CHECK_EQ(expected_size_, assembler_->pc_offset() - start_offset_);
     214             :   }
     215     1861658 :   assembler_->set_predictable_code_size(old_value_);
     216     1861658 : }
     217             : 
     218             : 
     219             : // -----------------------------------------------------------------------------
     220             : // Implementation of CpuFeatureScope
     221             : 
     222             : #ifdef DEBUG
     223             : CpuFeatureScope::CpuFeatureScope(AssemblerBase* assembler, CpuFeature f,
     224             :                                  CheckPolicy check)
     225             :     : assembler_(assembler) {
     226             :   DCHECK_IMPLIES(check == kCheckSupported, CpuFeatures::IsSupported(f));
     227             :   old_enabled_ = assembler_->enabled_cpu_features();
     228             :   assembler_->EnableCpuFeature(f);
     229             : }
     230             : 
     231             : CpuFeatureScope::~CpuFeatureScope() {
     232             :   assembler_->set_enabled_cpu_features(old_enabled_);
     233             : }
     234             : #endif
     235             : 
     236             : 
     237             : bool CpuFeatures::initialized_ = false;
     238             : unsigned CpuFeatures::supported_ = 0;
     239             : unsigned CpuFeatures::icache_line_size_ = 0;
     240             : unsigned CpuFeatures::dcache_line_size_ = 0;
     241             : 
     242             : // -----------------------------------------------------------------------------
     243             : // Implementation of RelocInfoWriter and RelocIterator
     244             : //
     245             : // Relocation information is written backwards in memory, from high addresses
     246             : // towards low addresses, byte by byte.  Therefore, in the encodings listed
     247             : // below, the first byte listed it at the highest address, and successive
     248             : // bytes in the record are at progressively lower addresses.
     249             : //
     250             : // Encoding
     251             : //
     252             : // The most common modes are given single-byte encodings.  Also, it is
     253             : // easy to identify the type of reloc info and skip unwanted modes in
     254             : // an iteration.
     255             : //
     256             : // The encoding relies on the fact that there are fewer than 14
     257             : // different relocation modes using standard non-compact encoding.
     258             : //
     259             : // The first byte of a relocation record has a tag in its low 2 bits:
     260             : // Here are the record schemes, depending on the low tag and optional higher
     261             : // tags.
     262             : //
     263             : // Low tag:
     264             : //   00: embedded_object:      [6-bit pc delta] 00
     265             : //
     266             : //   01: code_target:          [6-bit pc delta] 01
     267             : //
     268             : //   10: short_data_record:    [6-bit pc delta] 10 followed by
     269             : //                             [6-bit data delta] [2-bit data type tag]
     270             : //
     271             : //   11: long_record           [6 bit reloc mode] 11
     272             : //                             followed by pc delta
     273             : //                             followed by optional data depending on type.
     274             : //
     275             : //  1-bit data type tags, used in short_data_record and data_jump long_record:
     276             : //   code_target_with_id: 0
     277             : //   deopt_reason:        1
     278             : //
     279             : //  If a pc delta exceeds 6 bits, it is split into a remainder that fits into
     280             : //  6 bits and a part that does not. The latter is encoded as a long record
     281             : //  with PC_JUMP as pseudo reloc info mode. The former is encoded as part of
     282             : //  the following record in the usual way. The long pc jump record has variable
     283             : //  length:
     284             : //               pc-jump:        [PC_JUMP] 11
     285             : //                               [7 bits data] 0
     286             : //                                  ...
     287             : //                               [7 bits data] 1
     288             : //               (Bits 6..31 of pc delta, with leading zeroes
     289             : //                dropped, and last non-zero chunk tagged with 1.)
     290             : 
     291             : const int kTagBits = 2;
     292             : const int kTagMask = (1 << kTagBits) - 1;
     293             : const int kLongTagBits = 6;
     294             : const int kShortDataTypeTagBits = 1;
     295             : const int kShortDataBits = kBitsPerByte - kShortDataTypeTagBits;
     296             : 
     297             : const int kEmbeddedObjectTag = 0;
     298             : const int kCodeTargetTag = 1;
     299             : const int kLocatableTag = 2;
     300             : const int kDefaultTag = 3;
     301             : 
     302             : const int kSmallPCDeltaBits = kBitsPerByte - kTagBits;
     303             : const int kSmallPCDeltaMask = (1 << kSmallPCDeltaBits) - 1;
     304             : const int RelocInfo::kMaxSmallPCDelta = kSmallPCDeltaMask;
     305             : 
     306             : const int kChunkBits = 7;
     307             : const int kChunkMask = (1 << kChunkBits) - 1;
     308             : const int kLastChunkTagBits = 1;
     309             : const int kLastChunkTagMask = 1;
     310             : const int kLastChunkTag = 1;
     311             : 
     312             : const int kCodeWithIdTag = 0;
     313             : const int kDeoptReasonTag = 1;
     314             : 
     315       64643 : void RelocInfo::update_wasm_memory_reference(
     316             :     Isolate* isolate, Address old_base, Address new_base,
     317             :     ICacheFlushMode icache_flush_mode) {
     318             :   DCHECK(IsWasmMemoryReference(rmode_));
     319             :   DCHECK_GE(wasm_memory_reference(), old_base);
     320       64643 :   Address updated_reference = new_base + (wasm_memory_reference() - old_base);
     321             :   // The reference is not checked here but at runtime. Validity of references
     322             :   // may change over time.
     323             :   unchecked_update_wasm_memory_reference(isolate, updated_reference,
     324       64643 :                                          icache_flush_mode);
     325       64643 : }
     326             : 
     327      273757 : void RelocInfo::update_wasm_memory_size(Isolate* isolate, uint32_t old_size,
     328             :                                         uint32_t new_size,
     329             :                                         ICacheFlushMode icache_flush_mode) {
     330             :   DCHECK(IsWasmMemorySizeReference(rmode_));
     331      273757 :   uint32_t current_size_reference = wasm_memory_size_reference();
     332             :   uint32_t updated_size_reference =
     333      273757 :       new_size + (current_size_reference - old_size);
     334             :   unchecked_update_wasm_size(isolate, updated_size_reference,
     335      273757 :                              icache_flush_mode);
     336      273757 : }
     337             : 
     338       35409 : void RelocInfo::update_wasm_global_reference(
     339             :     Isolate* isolate, Address old_base, Address new_base,
     340             :     ICacheFlushMode icache_flush_mode) {
     341             :   DCHECK(IsWasmGlobalReference(rmode_));
     342             :   Address updated_reference;
     343             :   DCHECK_LE(old_base, wasm_global_reference());
     344       35409 :   updated_reference = new_base + (wasm_global_reference() - old_base);
     345             :   DCHECK_LE(new_base, updated_reference);
     346             :   unchecked_update_wasm_memory_reference(isolate, updated_reference,
     347       35409 :                                          icache_flush_mode);
     348       35409 : }
     349             : 
     350         157 : void RelocInfo::update_wasm_function_table_size_reference(
     351             :     Isolate* isolate, uint32_t old_size, uint32_t new_size,
     352             :     ICacheFlushMode icache_flush_mode) {
     353             :   DCHECK(IsWasmFunctionTableSizeReference(rmode_));
     354         157 :   uint32_t current_size_reference = wasm_function_table_size_reference();
     355             :   uint32_t updated_size_reference =
     356         157 :       new_size + (current_size_reference - old_size);
     357             :   unchecked_update_wasm_size(isolate, updated_size_reference,
     358         157 :                              icache_flush_mode);
     359         157 : }
     360             : 
     361    19002856 : void RelocInfo::set_target_address(Isolate* isolate, Address target,
     362             :                                    WriteBarrierMode write_barrier_mode,
     363    37079850 :                                    ICacheFlushMode icache_flush_mode) {
     364             :   DCHECK(IsCodeTarget(rmode_) || IsRuntimeEntry(rmode_));
     365             :   Assembler::set_target_address_at(isolate, pc_, host_, target,
     366    19002856 :                                    icache_flush_mode);
     367    56972591 :   if (write_barrier_mode == UPDATE_WRITE_BARRIER && host() != NULL &&
     368    18966863 :       IsCodeTarget(rmode_)) {
     369    18076989 :     Code* target_code = Code::GetCodeFromTargetAddress(target);
     370             :     host()->GetHeap()->incremental_marking()->RecordWriteIntoCode(host(), this,
     371    18076989 :                                                                   target_code);
     372             :   }
     373    19002866 : }
     374             : 
     375    37190950 : uint32_t RelocInfoWriter::WriteLongPCJump(uint32_t pc_delta) {
     376             :   // Return if the pc_delta can fit in kSmallPCDeltaBits bits.
     377             :   // Otherwise write a variable length PC jump for the bits that do
     378             :   // not fit in the kSmallPCDeltaBits bits.
     379    74381900 :   if (is_uintn(pc_delta, kSmallPCDeltaBits)) return pc_delta;
     380             :   WriteMode(RelocInfo::PC_JUMP);
     381     2203795 :   uint32_t pc_jump = pc_delta >> kSmallPCDeltaBits;
     382             :   DCHECK(pc_jump > 0);
     383             :   // Write kChunkBits size chunks of the pc_jump.
     384     4408047 :   for (; pc_jump > 0; pc_jump = pc_jump >> kChunkBits) {
     385     2204252 :     byte b = pc_jump & kChunkMask;
     386     2204252 :     *--pos_ = b << kLastChunkTagBits;
     387             :   }
     388             :   // Tag the last chunk so it can be identified.
     389     2203795 :   *pos_ = *pos_ | kLastChunkTag;
     390             :   // Return the remaining kSmallPCDeltaBits of the pc_delta.
     391     2203795 :   return pc_delta & kSmallPCDeltaMask;
     392             : }
     393             : 
     394             : 
     395             : void RelocInfoWriter::WriteShortTaggedPC(uint32_t pc_delta, int tag) {
     396             :   // Write a byte of tagged pc-delta, possibly preceded by an explicit pc-jump.
     397    34074631 :   pc_delta = WriteLongPCJump(pc_delta);
     398    34074647 :   *--pos_ = pc_delta << kTagBits | tag;
     399             : }
     400             : 
     401             : 
     402             : void RelocInfoWriter::WriteShortTaggedData(intptr_t data_delta, int tag) {
     403     1528503 :   *--pos_ = static_cast<byte>(data_delta << kShortDataTypeTagBits | tag);
     404             : }
     405             : 
     406             : 
     407             : void RelocInfoWriter::WriteMode(RelocInfo::Mode rmode) {
     408             :   STATIC_ASSERT(RelocInfo::NUMBER_OF_MODES <= (1 << kLongTagBits));
     409     5320234 :   *--pos_ = static_cast<int>((rmode << kTagBits) | kDefaultTag);
     410             : }
     411             : 
     412             : 
     413     3116439 : void RelocInfoWriter::WriteModeAndPC(uint32_t pc_delta, RelocInfo::Mode rmode) {
     414             :   // Write two-byte tagged pc-delta, possibly preceded by var. length pc-jump.
     415     3116439 :   pc_delta = WriteLongPCJump(pc_delta);
     416             :   WriteMode(rmode);
     417     3116439 :   *--pos_ = pc_delta;
     418     3116439 : }
     419             : 
     420             : 
     421             : void RelocInfoWriter::WriteIntData(int number) {
     422     2966904 :   for (int i = 0; i < kIntSize; i++) {
     423     2966904 :     *--pos_ = static_cast<byte>(number);
     424             :     // Signed right shift is arithmetic shift.  Tested in test-utils.cc.
     425     2966904 :     number = number >> kBitsPerByte;
     426             :   }
     427             : }
     428             : 
     429             : 
     430             : void RelocInfoWriter::WriteData(intptr_t data_delta) {
     431           0 :   for (int i = 0; i < kIntptrSize; i++) {
     432           0 :     *--pos_ = static_cast<byte>(data_delta);
     433             :     // Signed right shift is arithmetic shift.  Tested in test-utils.cc.
     434           0 :     data_delta = data_delta >> kBitsPerByte;
     435             :   }
     436             : }
     437             : 
     438             : 
     439    78183290 : void RelocInfoWriter::Write(const RelocInfo* rinfo) {
     440             :   RelocInfo::Mode rmode = rinfo->rmode();
     441             : #ifdef DEBUG
     442             :   byte* begin_pos = pos_;
     443             : #endif
     444             :   DCHECK(rinfo->rmode() < RelocInfo::NUMBER_OF_MODES);
     445             :   DCHECK(rinfo->pc() - last_pc_ >= 0);
     446             :   // Use unsigned delta-encoding for pc.
     447    37191071 :   uint32_t pc_delta = static_cast<uint32_t>(rinfo->pc() - last_pc_);
     448             : 
     449             :   // The two most common modes are given small tags, and usually fit in a byte.
     450    37191071 :   if (rmode == RelocInfo::EMBEDDED_OBJECT) {
     451             :     WriteShortTaggedPC(pc_delta, kEmbeddedObjectTag);
     452    20994268 :   } else if (rmode == RelocInfo::CODE_TARGET) {
     453             :     WriteShortTaggedPC(pc_delta, kCodeTargetTag);
     454             :     DCHECK(begin_pos - pos_ <= RelocInfo::kMaxCallSize);
     455     4644943 :   } else if (rmode == RelocInfo::CODE_TARGET_WITH_ID) {
     456             :     // Use signed delta-encoding for id.
     457             :     DCHECK_EQ(static_cast<int>(rinfo->data()), rinfo->data());
     458     1530903 :     int id_delta = static_cast<int>(rinfo->data()) - last_id_;
     459             :     // Check if delta is small enough to fit in a tagged byte.
     460     3061806 :     if (is_intn(id_delta, kShortDataBits)) {
     461             :       WriteShortTaggedPC(pc_delta, kLocatableTag);
     462             :       WriteShortTaggedData(id_delta, kCodeWithIdTag);
     463             :     } else {
     464             :       // Otherwise, use costly encoding.
     465      186819 :       WriteModeAndPC(pc_delta, rmode);
     466             :       WriteIntData(id_delta);
     467             :     }
     468     1530903 :     last_id_ = static_cast<int>(rinfo->data());
     469     3114040 :   } else if (rmode == RelocInfo::DEOPT_REASON) {
     470             :     DCHECK(rinfo->data() < (1 << kShortDataBits));
     471             :     WriteShortTaggedPC(pc_delta, kLocatableTag);
     472             :     WriteShortTaggedData(rinfo->data(), kDeoptReasonTag);
     473             :   } else {
     474     2929621 :     WriteModeAndPC(pc_delta, rmode);
     475     2929621 :     if (RelocInfo::IsComment(rmode)) {
     476             :       WriteData(rinfo->data());
     477     5859242 :     } else if (RelocInfo::IsConstPool(rmode) ||
     478     5674823 :                RelocInfo::IsVeneerPool(rmode) || RelocInfo::IsDeoptId(rmode) ||
     479     5305985 :                RelocInfo::IsDeoptPosition(rmode) ||
     480             :                RelocInfo::IsWasmProtectedLanding(rmode)) {
     481      554907 :       WriteIntData(static_cast<int>(rinfo->data()));
     482             :     }
     483             :   }
     484    37191087 :   last_pc_ = rinfo->pc();
     485    37191087 :   last_mode_ = rmode;
     486             : #ifdef DEBUG
     487             :   DCHECK(begin_pos - pos_ <= kMaxSize);
     488             : #endif
     489    37191087 : }
     490             : 
     491             : 
     492             : inline int RelocIterator::AdvanceGetTag() {
     493  1204494507 :   return *--pos_ & kTagMask;
     494             : }
     495             : 
     496             : 
     497             : inline RelocInfo::Mode RelocIterator::GetMode() {
     498             :   return static_cast<RelocInfo::Mode>((*pos_ >> kTagBits) &
     499   727879845 :                                       ((1 << kLongTagBits) - 1));
     500             : }
     501             : 
     502             : 
     503             : inline void RelocIterator::ReadShortTaggedPC() {
     504   476614662 :   rinfo_.pc_ += *pos_ >> kTagBits;
     505             : }
     506             : 
     507             : 
     508             : inline void RelocIterator::AdvanceReadPC() {
     509   504785240 :   rinfo_.pc_ += *--pos_;
     510             : }
     511             : 
     512             : 
     513           0 : void RelocIterator::AdvanceReadId() {
     514             :   int x = 0;
     515     2513264 :   for (int i = 0; i < kIntSize; i++) {
     516     2513264 :     x |= static_cast<int>(*--pos_) << i * kBitsPerByte;
     517             :   }
     518      628316 :   last_id_ += x;
     519      628316 :   rinfo_.data_ = last_id_;
     520           0 : }
     521             : 
     522             : 
     523           0 : void RelocIterator::AdvanceReadInt() {
     524             :   int x = 0;
     525       11368 :   for (int i = 0; i < kIntSize; i++) {
     526       11368 :     x |= static_cast<int>(*--pos_) << i * kBitsPerByte;
     527             :   }
     528        2842 :   rinfo_.data_ = x;
     529           0 : }
     530             : 
     531             : 
     532           0 : void RelocIterator::AdvanceReadData() {
     533             :   intptr_t x = 0;
     534           0 :   for (int i = 0; i < kIntptrSize; i++) {
     535           0 :     x |= static_cast<intptr_t>(*--pos_) << i * kBitsPerByte;
     536             :   }
     537           0 :   rinfo_.data_ = x;
     538           0 : }
     539             : 
     540             : 
     541   223094614 : void RelocIterator::AdvanceReadLongPCJump() {
     542             :   // Read the 32-kSmallPCDeltaBits most significant bits of the
     543             :   // pc jump in kChunkBits bit chunks and shift them into place.
     544             :   // Stop when the last chunk is encountered.
     545             :   uint32_t pc_jump = 0;
     546   223095267 :   for (int i = 0; i < kIntSize; i++) {
     547   223095040 :     byte pc_jump_part = *--pos_;
     548   223095040 :     pc_jump |= (pc_jump_part >> kLastChunkTagBits) << i * kChunkBits;
     549   223095040 :     if ((pc_jump_part & kLastChunkTagMask) == 1) break;
     550             :   }
     551             :   // The least significant kSmallPCDeltaBits bits will be added
     552             :   // later.
     553   223094614 :   rinfo_.pc_ += pc_jump << kSmallPCDeltaBits;
     554   223094614 : }
     555             : 
     556             : 
     557             : inline int RelocIterator::GetShortDataTypeTag() {
     558     5455126 :   return *pos_ & ((1 << kShortDataTypeTagBits) - 1);
     559             : }
     560             : 
     561             : 
     562             : inline void RelocIterator::ReadShortTaggedId() {
     563     4359992 :   int8_t signed_b = *pos_;
     564             :   // Signed right shift is arithmetic shift.  Tested in test-utils.cc.
     565     4359992 :   last_id_ += signed_b >> kShortDataTypeTagBits;
     566     4359992 :   rinfo_.data_ = last_id_;
     567             : }
     568             : 
     569             : 
     570             : inline void RelocIterator::ReadShortTaggedData() {
     571          60 :   uint8_t unsigned_b = *pos_;
     572          60 :   rinfo_.data_ = unsigned_b >> kShortDataTypeTagBits;
     573             : }
     574             : 
     575             : 
     576  1970421047 : void RelocIterator::next() {
     577             :   DCHECK(!done());
     578             :   // Basically, do the opposite of RelocInfoWriter::Write.
     579             :   // Reading of data is as far as possible avoided for unwanted modes,
     580             :   // but we must always update the pc.
     581             :   //
     582             :   // We exit this loop by returning when we find a mode we want.
     583  2280807987 :   while (pos_ > end_) {
     584             :     int tag = AdvanceGetTag();
     585  1204494507 :     if (tag == kEmbeddedObjectTag) {
     586             :       ReadShortTaggedPC();
     587    79166625 :       if (SetMode(RelocInfo::EMBEDDED_OBJECT)) return;
     588  1125327882 :     } else if (tag == kCodeTargetTag) {
     589             :       ReadShortTaggedPC();
     590   391992911 :       if (SetMode(RelocInfo::CODE_TARGET)) return;
     591   733334971 :     } else if (tag == kLocatableTag) {
     592             :       ReadShortTaggedPC();
     593             :       Advance();
     594             :       int data_type_tag = GetShortDataTypeTag();
     595     5455126 :       if (data_type_tag == kCodeWithIdTag) {
     596     4675876 :         if (SetMode(RelocInfo::CODE_TARGET_WITH_ID)) {
     597             :           ReadShortTaggedId();
     598             :           return;
     599             :         }
     600             :       } else {
     601             :         DCHECK(data_type_tag == kDeoptReasonTag);
     602      779250 :         if (SetMode(RelocInfo::DEOPT_REASON)) {
     603             :           ReadShortTaggedData();
     604             :           return;
     605             :         }
     606             :       }
     607             :     } else {
     608             :       DCHECK(tag == kDefaultTag);
     609             :       RelocInfo::Mode rmode = GetMode();
     610   727879845 :       if (rmode == RelocInfo::PC_JUMP) {
     611   223094605 :         AdvanceReadLongPCJump();
     612             :       } else {
     613             :         AdvanceReadPC();
     614   504785240 :         if (rmode == RelocInfo::CODE_TARGET_WITH_ID) {
     615      702696 :           if (SetMode(rmode)) {
     616             :             AdvanceReadId();
     617             :             return;
     618             :           }
     619             :           Advance(kIntSize);
     620   504082544 :         } else if (RelocInfo::IsComment(rmode)) {
     621           0 :           if (SetMode(rmode)) {
     622             :             AdvanceReadData();
     623             :             return;
     624             :           }
     625             :           Advance(kIntptrSize);
     626  1008164440 :         } else if (RelocInfo::IsConstPool(rmode) ||
     627   504081975 :                    RelocInfo::IsVeneerPool(rmode) ||
     628   503302766 :                    RelocInfo::IsDeoptId(rmode) ||
     629  1005826835 :                    RelocInfo::IsDeoptPosition(rmode) ||
     630             :                    RelocInfo::IsWasmProtectedLanding(rmode)) {
     631     2342524 :           if (SetMode(rmode)) {
     632             :             AdvanceReadInt();
     633             :             return;
     634             :           }
     635             :           Advance(kIntSize);
     636   501740020 :         } else if (SetMode(static_cast<RelocInfo::Mode>(rmode))) {
     637             :           return;
     638             :         }
     639             :       }
     640             :     }
     641             :   }
     642    88537527 :   if (code_age_sequence_ != NULL) {
     643             :     byte* old_code_age_sequence = code_age_sequence_;
     644     1245192 :     code_age_sequence_ = NULL;
     645     1245192 :     if (SetMode(RelocInfo::CODE_AGE_SEQUENCE)) {
     646        5272 :       rinfo_.data_ = 0;
     647        5272 :       rinfo_.pc_ = old_code_age_sequence;
     648        5272 :       return;
     649             :     }
     650             :   }
     651    88532255 :   done_ = true;
     652             : }
     653             : 
     654    88932303 : RelocIterator::RelocIterator(Code* code, int mode_mask) {
     655    88932303 :   rinfo_.host_ = code;
     656    88932303 :   rinfo_.pc_ = code->instruction_start();
     657    88932303 :   rinfo_.data_ = 0;
     658             :   // Relocation info is read backwards.
     659   177864606 :   pos_ = code->relocation_start() + code->relocation_size();
     660    88932303 :   end_ = code->relocation_start();
     661    88932303 :   done_ = false;
     662    88932303 :   mode_mask_ = mode_mask;
     663    88932303 :   last_id_ = 0;
     664    88932303 :   byte* sequence = code->FindCodeAgeSequence();
     665             :   // We get the isolate from the map, because at serialization time
     666             :   // the code pointer has been cloned and isn't really in heap space.
     667             :   Isolate* isolate = code->map()->GetIsolate();
     668    88932524 :   if (sequence != NULL && !Code::IsYoungSequence(isolate, sequence)) {
     669     1245690 :     code_age_sequence_ = sequence;
     670             :   } else {
     671    87686833 :     code_age_sequence_ = NULL;
     672             :   }
     673    88932523 :   if (mode_mask_ == 0) pos_ = end_;
     674    88932523 :   next();
     675    88932458 : }
     676             : 
     677           0 : RelocIterator::RelocIterator(const CodeDesc& desc, int mode_mask) {
     678           0 :   rinfo_.pc_ = desc.buffer;
     679           0 :   rinfo_.data_ = 0;
     680             :   // Relocation info is read backwards.
     681           0 :   pos_ = desc.buffer + desc.buffer_size;
     682           0 :   end_ = pos_ - desc.reloc_size;
     683           0 :   done_ = false;
     684           0 :   mode_mask_ = mode_mask;
     685           0 :   last_id_ = 0;
     686           0 :   code_age_sequence_ = NULL;
     687           0 :   if (mode_mask_ == 0) pos_ = end_;
     688           0 :   next();
     689           0 : }
     690             : 
     691             : 
     692             : // -----------------------------------------------------------------------------
     693             : // Implementation of RelocInfo
     694             : 
     695       87516 : bool RelocInfo::IsPatchedDebugBreakSlotSequence() {
     696       87516 :   return DebugCodegen::DebugBreakSlotIsPatched(pc_);
     697             : }
     698             : 
     699             : #ifdef DEBUG
     700             : bool RelocInfo::RequiresRelocation(Isolate* isolate, const CodeDesc& desc) {
     701             :   // Ensure there are no code targets or embedded objects present in the
     702             :   // deoptimization entries, they would require relocation after code
     703             :   // generation.
     704             :   int mode_mask = RelocInfo::kCodeTargetMask |
     705             :                   RelocInfo::ModeMask(RelocInfo::EMBEDDED_OBJECT) |
     706             :                   RelocInfo::ModeMask(RelocInfo::CELL) |
     707             :                   RelocInfo::kApplyMask;
     708             :   RelocIterator it(desc, mode_mask);
     709             :   return !it.done();
     710             : }
     711             : #endif
     712             : 
     713             : 
     714             : #ifdef ENABLE_DISASSEMBLER
     715             : const char* RelocInfo::RelocModeName(RelocInfo::Mode rmode) {
     716             :   switch (rmode) {
     717             :     case NONE32:
     718             :       return "no reloc 32";
     719             :     case NONE64:
     720             :       return "no reloc 64";
     721             :     case EMBEDDED_OBJECT:
     722             :       return "embedded object";
     723             :     case CODE_TARGET:
     724             :       return "code target";
     725             :     case CODE_TARGET_WITH_ID:
     726             :       return "code target with id";
     727             :     case CELL:
     728             :       return "property cell";
     729             :     case RUNTIME_ENTRY:
     730             :       return "runtime entry";
     731             :     case COMMENT:
     732             :       return "comment";
     733             :     case EXTERNAL_REFERENCE:
     734             :       return "external reference";
     735             :     case INTERNAL_REFERENCE:
     736             :       return "internal reference";
     737             :     case INTERNAL_REFERENCE_ENCODED:
     738             :       return "encoded internal reference";
     739             :     case DEOPT_SCRIPT_OFFSET:
     740             :       return "deopt script offset";
     741             :     case DEOPT_INLINING_ID:
     742             :       return "deopt inlining id";
     743             :     case DEOPT_REASON:
     744             :       return "deopt reason";
     745             :     case DEOPT_ID:
     746             :       return "deopt index";
     747             :     case CONST_POOL:
     748             :       return "constant pool";
     749             :     case VENEER_POOL:
     750             :       return "veneer pool";
     751             :     case DEBUG_BREAK_SLOT_AT_POSITION:
     752             :       return "debug break slot at position";
     753             :     case DEBUG_BREAK_SLOT_AT_RETURN:
     754             :       return "debug break slot at return";
     755             :     case DEBUG_BREAK_SLOT_AT_CALL:
     756             :       return "debug break slot at call";
     757             :     case DEBUG_BREAK_SLOT_AT_TAIL_CALL:
     758             :       return "debug break slot at tail call";
     759             :     case CODE_AGE_SEQUENCE:
     760             :       return "code age sequence";
     761             :     case WASM_MEMORY_REFERENCE:
     762             :       return "wasm memory reference";
     763             :     case WASM_MEMORY_SIZE_REFERENCE:
     764             :       return "wasm memory size reference";
     765             :     case WASM_GLOBAL_REFERENCE:
     766             :       return "wasm global value reference";
     767             :     case WASM_FUNCTION_TABLE_SIZE_REFERENCE:
     768             :       return "wasm function table size reference";
     769             :     case WASM_PROTECTED_INSTRUCTION_LANDING:
     770             :       return "wasm protected instruction landing";
     771             :     case NUMBER_OF_MODES:
     772             :     case PC_JUMP:
     773             :       UNREACHABLE();
     774             :       return "number_of_modes";
     775             :   }
     776             :   return "unknown relocation type";
     777             : }
     778             : 
     779             : 
     780             : void RelocInfo::Print(Isolate* isolate, std::ostream& os) {  // NOLINT
     781             :   os << static_cast<const void*>(pc_) << "  " << RelocModeName(rmode_);
     782             :   if (IsComment(rmode_)) {
     783             :     os << "  (" << reinterpret_cast<char*>(data_) << ")";
     784             :   } else if (rmode_ == DEOPT_SCRIPT_OFFSET || rmode_ == DEOPT_INLINING_ID) {
     785             :     os << "  (" << data() << ")";
     786             :   } else if (rmode_ == DEOPT_REASON) {
     787             :     os << "  ("
     788             :        << DeoptimizeReasonToString(static_cast<DeoptimizeReason>(data_)) << ")";
     789             :   } else if (rmode_ == EMBEDDED_OBJECT) {
     790             :     os << "  (" << Brief(target_object()) << ")";
     791             :   } else if (rmode_ == EXTERNAL_REFERENCE) {
     792             :     ExternalReferenceEncoder ref_encoder(isolate);
     793             :     os << " ("
     794             :        << ref_encoder.NameOfAddress(isolate, target_external_reference())
     795             :        << ")  (" << static_cast<const void*>(target_external_reference())
     796             :        << ")";
     797             :   } else if (IsCodeTarget(rmode_)) {
     798             :     Code* code = Code::GetCodeFromTargetAddress(target_address());
     799             :     os << " (" << Code::Kind2String(code->kind()) << ")  ("
     800             :        << static_cast<const void*>(target_address()) << ")";
     801             :     if (rmode_ == CODE_TARGET_WITH_ID) {
     802             :       os << " (id=" << static_cast<int>(data_) << ")";
     803             :     }
     804             :   } else if (IsRuntimeEntry(rmode_) &&
     805             :              isolate->deoptimizer_data() != NULL) {
     806             :     // Depotimization bailouts are stored as runtime entries.
     807             :     int id = Deoptimizer::GetDeoptimizationId(
     808             :         isolate, target_address(), Deoptimizer::EAGER);
     809             :     if (id != Deoptimizer::kNotDeoptimizationEntry) {
     810             :       os << "  (deoptimization bailout " << id << ")";
     811             :     }
     812             :   } else if (IsConstPool(rmode_)) {
     813             :     os << " (size " << static_cast<int>(data_) << ")";
     814             :   }
     815             : 
     816             :   os << "\n";
     817             : }
     818             : #endif  // ENABLE_DISASSEMBLER
     819             : 
     820             : 
     821             : #ifdef VERIFY_HEAP
     822             : void RelocInfo::Verify(Isolate* isolate) {
     823             :   switch (rmode_) {
     824             :     case EMBEDDED_OBJECT:
     825             :       Object::VerifyPointer(target_object());
     826             :       break;
     827             :     case CELL:
     828             :       Object::VerifyPointer(target_cell());
     829             :       break;
     830             :     case CODE_TARGET_WITH_ID:
     831             :     case CODE_TARGET: {
     832             :       // convert inline target address to code object
     833             :       Address addr = target_address();
     834             :       CHECK(addr != NULL);
     835             :       // Check that we can find the right code object.
     836             :       Code* code = Code::GetCodeFromTargetAddress(addr);
     837             :       Object* found = isolate->FindCodeObject(addr);
     838             :       CHECK(found->IsCode());
     839             :       CHECK(code->address() == HeapObject::cast(found)->address());
     840             :       break;
     841             :     }
     842             :     case INTERNAL_REFERENCE:
     843             :     case INTERNAL_REFERENCE_ENCODED: {
     844             :       Address target = target_internal_reference();
     845             :       Address pc = target_internal_reference_address();
     846             :       Code* code = Code::cast(isolate->FindCodeObject(pc));
     847             :       CHECK(target >= code->instruction_start());
     848             :       CHECK(target <= code->instruction_end());
     849             :       break;
     850             :     }
     851             :     case RUNTIME_ENTRY:
     852             :     case COMMENT:
     853             :     case EXTERNAL_REFERENCE:
     854             :     case DEOPT_SCRIPT_OFFSET:
     855             :     case DEOPT_INLINING_ID:
     856             :     case DEOPT_REASON:
     857             :     case DEOPT_ID:
     858             :     case CONST_POOL:
     859             :     case VENEER_POOL:
     860             :     case DEBUG_BREAK_SLOT_AT_POSITION:
     861             :     case DEBUG_BREAK_SLOT_AT_RETURN:
     862             :     case DEBUG_BREAK_SLOT_AT_CALL:
     863             :     case DEBUG_BREAK_SLOT_AT_TAIL_CALL:
     864             :     case WASM_MEMORY_REFERENCE:
     865             :     case WASM_MEMORY_SIZE_REFERENCE:
     866             :     case WASM_GLOBAL_REFERENCE:
     867             :     case WASM_FUNCTION_TABLE_SIZE_REFERENCE:
     868             :     case WASM_PROTECTED_INSTRUCTION_LANDING:
     869             :     // TODO(eholk): make sure the protected instruction is in range.
     870             :     case NONE32:
     871             :     case NONE64:
     872             :       break;
     873             :     case NUMBER_OF_MODES:
     874             :     case PC_JUMP:
     875             :       UNREACHABLE();
     876             :       break;
     877             :     case CODE_AGE_SEQUENCE:
     878             :       DCHECK(Code::IsYoungSequence(isolate, pc_) || code_age_stub()->IsCode());
     879             :       break;
     880             :   }
     881             : }
     882             : #endif  // VERIFY_HEAP
     883             : 
     884             : 
     885             : // Implementation of ExternalReference
     886             : 
     887    38292579 : static ExternalReference::Type BuiltinCallTypeForResultSize(int result_size) {
     888    38292579 :   switch (result_size) {
     889             :     case 1:
     890             :       return ExternalReference::BUILTIN_CALL;
     891             :     case 2:
     892       61733 :       return ExternalReference::BUILTIN_CALL_PAIR;
     893             :     case 3:
     894       61216 :       return ExternalReference::BUILTIN_CALL_TRIPLE;
     895             :   }
     896           0 :   UNREACHABLE();
     897             :   return ExternalReference::BUILTIN_CALL;
     898             : }
     899             : 
     900             : 
     901       59461 : void ExternalReference::SetUp() {
     902       59461 :   double_constants.min_int = kMinInt;
     903       59461 :   double_constants.one_half = 0.5;
     904       59461 :   double_constants.minus_one_half = -0.5;
     905       59461 :   double_constants.the_hole_nan = kHoleNanInt64;
     906       59461 :   double_constants.negative_infinity = -V8_INFINITY;
     907             :   double_constants.uint32_bias =
     908       59461 :     static_cast<double>(static_cast<uint32_t>(0xFFFFFFFF)) + 1;
     909       59461 : }
     910             : 
     911    13939607 : ExternalReference::ExternalReference(Address address, Isolate* isolate)
     912    13939607 :     : address_(Redirect(isolate, address)) {}
     913             : 
     914      143230 : ExternalReference::ExternalReference(
     915             :     ApiFunction* fun,
     916             :     Type type = ExternalReference::BUILTIN_CALL,
     917             :     Isolate* isolate = NULL)
     918      143230 :   : address_(Redirect(isolate, fun->address(), type)) {}
     919             : 
     920             : 
     921         215 : ExternalReference::ExternalReference(Builtins::Name name, Isolate* isolate)
     922         215 :   : address_(isolate->builtins()->builtin_address(name)) {}
     923             : 
     924             : 
     925    36208735 : ExternalReference::ExternalReference(Runtime::FunctionId id, Isolate* isolate)
     926    36208735 :     : ExternalReference(Runtime::FunctionForId(id), isolate) {}
     927             : 
     928             : 
     929    38292579 : ExternalReference::ExternalReference(const Runtime::Function* f,
     930             :                                      Isolate* isolate)
     931             :     : address_(Redirect(isolate, f->entry,
     932    76585162 :                         BuiltinCallTypeForResultSize(f->result_size))) {}
     933             : 
     934             : 
     935      452516 : ExternalReference ExternalReference::isolate_address(Isolate* isolate) {
     936      452516 :   return ExternalReference(isolate);
     937             : }
     938             : 
     939       63882 : ExternalReference ExternalReference::interpreter_dispatch_table_address(
     940       63882 :     Isolate* isolate) {
     941       63882 :   return ExternalReference(isolate->interpreter()->dispatch_table_address());
     942             : }
     943             : 
     944           0 : ExternalReference ExternalReference::interpreter_dispatch_counters(
     945           0 :     Isolate* isolate) {
     946             :   return ExternalReference(
     947           0 :       isolate->interpreter()->bytecode_dispatch_counters_table());
     948             : }
     949             : 
     950           0 : ExternalReference::ExternalReference(StatsCounter* counter)
     951           0 :   : address_(reinterpret_cast<Address>(counter->GetInternalPointer())) {}
     952             : 
     953             : 
     954      273248 : ExternalReference::ExternalReference(Isolate::AddressId id, Isolate* isolate)
     955      273248 :   : address_(isolate->get_address_from_id(id)) {}
     956             : 
     957             : 
     958         616 : ExternalReference::ExternalReference(const SCTableReference& table_ref)
     959         616 :   : address_(table_ref.address()) {}
     960             : 
     961             : 
     962      144664 : ExternalReference ExternalReference::
     963             :     incremental_marking_record_write_function(Isolate* isolate) {
     964             :   return ExternalReference(Redirect(
     965             :       isolate,
     966      144664 :       FUNCTION_ADDR(IncrementalMarking::RecordWriteFromCode)));
     967             : }
     968             : 
     969             : ExternalReference
     970       61173 : ExternalReference::incremental_marking_record_write_code_entry_function(
     971             :     Isolate* isolate) {
     972             :   return ExternalReference(Redirect(
     973             :       isolate,
     974       61173 :       FUNCTION_ADDR(IncrementalMarking::RecordWriteOfCodeEntryFromCode)));
     975             : }
     976             : 
     977       61130 : ExternalReference ExternalReference::store_buffer_overflow_function(
     978             :     Isolate* isolate) {
     979             :   return ExternalReference(Redirect(
     980             :       isolate,
     981       61130 :       FUNCTION_ADDR(StoreBuffer::StoreBufferOverflow)));
     982             : }
     983             : 
     984             : 
     985       67218 : ExternalReference ExternalReference::delete_handle_scope_extensions(
     986             :     Isolate* isolate) {
     987             :   return ExternalReference(Redirect(
     988             :       isolate,
     989       67218 :       FUNCTION_ADDR(HandleScope::DeleteExtensions)));
     990             : }
     991             : 
     992             : 
     993       61775 : ExternalReference ExternalReference::get_date_field_function(
     994             :     Isolate* isolate) {
     995       61775 :   return ExternalReference(Redirect(isolate, FUNCTION_ADDR(JSDate::GetField)));
     996             : }
     997             : 
     998             : 
     999       61302 : ExternalReference ExternalReference::get_make_code_young_function(
    1000             :     Isolate* isolate) {
    1001             :   return ExternalReference(Redirect(
    1002       61302 :       isolate, FUNCTION_ADDR(Code::MakeCodeAgeSequenceYoung)));
    1003             : }
    1004             : 
    1005             : 
    1006       61130 : ExternalReference ExternalReference::get_mark_code_as_executed_function(
    1007             :     Isolate* isolate) {
    1008             :   return ExternalReference(Redirect(
    1009       61130 :       isolate, FUNCTION_ADDR(Code::MarkCodeAsExecuted)));
    1010             : }
    1011             : 
    1012             : 
    1013       61345 : ExternalReference ExternalReference::date_cache_stamp(Isolate* isolate) {
    1014       61345 :   return ExternalReference(isolate->date_cache()->stamp_address());
    1015             : }
    1016             : 
    1017             : 
    1018       61376 : ExternalReference ExternalReference::stress_deopt_count(Isolate* isolate) {
    1019       61376 :   return ExternalReference(isolate->stress_deopt_count_address());
    1020             : }
    1021             : 
    1022             : 
    1023      146219 : ExternalReference ExternalReference::new_deoptimizer_function(
    1024             :     Isolate* isolate) {
    1025             :   return ExternalReference(
    1026      146219 :       Redirect(isolate, FUNCTION_ADDR(Deoptimizer::New)));
    1027             : }
    1028             : 
    1029             : 
    1030      146219 : ExternalReference ExternalReference::compute_output_frames_function(
    1031             :     Isolate* isolate) {
    1032             :   return ExternalReference(
    1033      146219 :       Redirect(isolate, FUNCTION_ADDR(Deoptimizer::ComputeOutputFrames)));
    1034             : }
    1035             : 
    1036       61051 : ExternalReference ExternalReference::wasm_f32_trunc(Isolate* isolate) {
    1037             :   return ExternalReference(
    1038       61051 :       Redirect(isolate, FUNCTION_ADDR(wasm::f32_trunc_wrapper)));
    1039             : }
    1040       61051 : ExternalReference ExternalReference::wasm_f32_floor(Isolate* isolate) {
    1041             :   return ExternalReference(
    1042       61051 :       Redirect(isolate, FUNCTION_ADDR(wasm::f32_floor_wrapper)));
    1043             : }
    1044       61051 : ExternalReference ExternalReference::wasm_f32_ceil(Isolate* isolate) {
    1045             :   return ExternalReference(
    1046       61051 :       Redirect(isolate, FUNCTION_ADDR(wasm::f32_ceil_wrapper)));
    1047             : }
    1048       61051 : ExternalReference ExternalReference::wasm_f32_nearest_int(Isolate* isolate) {
    1049             :   return ExternalReference(
    1050       61051 :       Redirect(isolate, FUNCTION_ADDR(wasm::f32_nearest_int_wrapper)));
    1051             : }
    1052             : 
    1053       61051 : ExternalReference ExternalReference::wasm_f64_trunc(Isolate* isolate) {
    1054             :   return ExternalReference(
    1055       61051 :       Redirect(isolate, FUNCTION_ADDR(wasm::f64_trunc_wrapper)));
    1056             : }
    1057             : 
    1058       61051 : ExternalReference ExternalReference::wasm_f64_floor(Isolate* isolate) {
    1059             :   return ExternalReference(
    1060       61051 :       Redirect(isolate, FUNCTION_ADDR(wasm::f64_floor_wrapper)));
    1061             : }
    1062             : 
    1063       61051 : ExternalReference ExternalReference::wasm_f64_ceil(Isolate* isolate) {
    1064             :   return ExternalReference(
    1065       61051 :       Redirect(isolate, FUNCTION_ADDR(wasm::f64_ceil_wrapper)));
    1066             : }
    1067             : 
    1068       61051 : ExternalReference ExternalReference::wasm_f64_nearest_int(Isolate* isolate) {
    1069             :   return ExternalReference(
    1070       61051 :       Redirect(isolate, FUNCTION_ADDR(wasm::f64_nearest_int_wrapper)));
    1071             : }
    1072             : 
    1073       61051 : ExternalReference ExternalReference::wasm_int64_to_float32(Isolate* isolate) {
    1074             :   return ExternalReference(
    1075       61051 :       Redirect(isolate, FUNCTION_ADDR(wasm::int64_to_float32_wrapper)));
    1076             : }
    1077             : 
    1078       61051 : ExternalReference ExternalReference::wasm_uint64_to_float32(Isolate* isolate) {
    1079             :   return ExternalReference(
    1080       61051 :       Redirect(isolate, FUNCTION_ADDR(wasm::uint64_to_float32_wrapper)));
    1081             : }
    1082             : 
    1083       61051 : ExternalReference ExternalReference::wasm_int64_to_float64(Isolate* isolate) {
    1084             :   return ExternalReference(
    1085       61051 :       Redirect(isolate, FUNCTION_ADDR(wasm::int64_to_float64_wrapper)));
    1086             : }
    1087             : 
    1088       61051 : ExternalReference ExternalReference::wasm_uint64_to_float64(Isolate* isolate) {
    1089             :   return ExternalReference(
    1090       61051 :       Redirect(isolate, FUNCTION_ADDR(wasm::uint64_to_float64_wrapper)));
    1091             : }
    1092             : 
    1093       61051 : ExternalReference ExternalReference::wasm_float32_to_int64(Isolate* isolate) {
    1094             :   return ExternalReference(
    1095       61051 :       Redirect(isolate, FUNCTION_ADDR(wasm::float32_to_int64_wrapper)));
    1096             : }
    1097             : 
    1098       61051 : ExternalReference ExternalReference::wasm_float32_to_uint64(Isolate* isolate) {
    1099             :   return ExternalReference(
    1100       61051 :       Redirect(isolate, FUNCTION_ADDR(wasm::float32_to_uint64_wrapper)));
    1101             : }
    1102             : 
    1103       61051 : ExternalReference ExternalReference::wasm_float64_to_int64(Isolate* isolate) {
    1104             :   return ExternalReference(
    1105       61051 :       Redirect(isolate, FUNCTION_ADDR(wasm::float64_to_int64_wrapper)));
    1106             : }
    1107             : 
    1108       61051 : ExternalReference ExternalReference::wasm_float64_to_uint64(Isolate* isolate) {
    1109             :   return ExternalReference(
    1110       61051 :       Redirect(isolate, FUNCTION_ADDR(wasm::float64_to_uint64_wrapper)));
    1111             : }
    1112             : 
    1113       61051 : ExternalReference ExternalReference::wasm_int64_div(Isolate* isolate) {
    1114             :   return ExternalReference(
    1115       61051 :       Redirect(isolate, FUNCTION_ADDR(wasm::int64_div_wrapper)));
    1116             : }
    1117             : 
    1118       61051 : ExternalReference ExternalReference::wasm_int64_mod(Isolate* isolate) {
    1119             :   return ExternalReference(
    1120       61051 :       Redirect(isolate, FUNCTION_ADDR(wasm::int64_mod_wrapper)));
    1121             : }
    1122             : 
    1123       61051 : ExternalReference ExternalReference::wasm_uint64_div(Isolate* isolate) {
    1124             :   return ExternalReference(
    1125       61051 :       Redirect(isolate, FUNCTION_ADDR(wasm::uint64_div_wrapper)));
    1126             : }
    1127             : 
    1128       61051 : ExternalReference ExternalReference::wasm_uint64_mod(Isolate* isolate) {
    1129             :   return ExternalReference(
    1130       61051 :       Redirect(isolate, FUNCTION_ADDR(wasm::uint64_mod_wrapper)));
    1131             : }
    1132             : 
    1133       61051 : ExternalReference ExternalReference::wasm_word32_ctz(Isolate* isolate) {
    1134             :   return ExternalReference(
    1135       61051 :       Redirect(isolate, FUNCTION_ADDR(wasm::word32_ctz_wrapper)));
    1136             : }
    1137             : 
    1138       61051 : ExternalReference ExternalReference::wasm_word64_ctz(Isolate* isolate) {
    1139             :   return ExternalReference(
    1140       61051 :       Redirect(isolate, FUNCTION_ADDR(wasm::word64_ctz_wrapper)));
    1141             : }
    1142             : 
    1143       61051 : ExternalReference ExternalReference::wasm_word32_popcnt(Isolate* isolate) {
    1144             :   return ExternalReference(
    1145       61051 :       Redirect(isolate, FUNCTION_ADDR(wasm::word32_popcnt_wrapper)));
    1146             : }
    1147             : 
    1148       61051 : ExternalReference ExternalReference::wasm_word64_popcnt(Isolate* isolate) {
    1149             :   return ExternalReference(
    1150       61051 :       Redirect(isolate, FUNCTION_ADDR(wasm::word64_popcnt_wrapper)));
    1151             : }
    1152             : 
    1153        9435 : static void f64_acos_wrapper(double* param) {
    1154        9435 :   WriteDoubleValue(param, base::ieee754::acos(ReadDoubleValue(param)));
    1155        9435 : }
    1156             : 
    1157       61067 : ExternalReference ExternalReference::f64_acos_wrapper_function(
    1158             :     Isolate* isolate) {
    1159       61067 :   return ExternalReference(Redirect(isolate, FUNCTION_ADDR(f64_acos_wrapper)));
    1160             : }
    1161             : 
    1162        9435 : static void f64_asin_wrapper(double* param) {
    1163        9435 :   WriteDoubleValue(param, base::ieee754::asin(ReadDoubleValue(param)));
    1164        9435 : }
    1165             : 
    1166       61067 : ExternalReference ExternalReference::f64_asin_wrapper_function(
    1167             :     Isolate* isolate) {
    1168       61067 :   return ExternalReference(Redirect(isolate, FUNCTION_ADDR(f64_asin_wrapper)));
    1169             : }
    1170             : 
    1171       61065 : ExternalReference ExternalReference::wasm_float64_pow(Isolate* isolate) {
    1172             :   return ExternalReference(
    1173       61065 :       Redirect(isolate, FUNCTION_ADDR(wasm::float64_pow_wrapper)));
    1174             : }
    1175             : 
    1176          44 : static void f64_mod_wrapper(double* param0, double* param1) {
    1177             :   WriteDoubleValue(param0,
    1178          44 :                    modulo(ReadDoubleValue(param0), ReadDoubleValue(param1)));
    1179          44 : }
    1180             : 
    1181       61072 : ExternalReference ExternalReference::f64_mod_wrapper_function(
    1182             :     Isolate* isolate) {
    1183       61072 :   return ExternalReference(Redirect(isolate, FUNCTION_ADDR(f64_mod_wrapper)));
    1184             : }
    1185             : 
    1186       66876 : ExternalReference ExternalReference::wasm_call_trap_callback_for_testing(
    1187             :     Isolate* isolate) {
    1188             :   return ExternalReference(
    1189       66876 :       Redirect(isolate, FUNCTION_ADDR(wasm::call_trap_callback_for_testing)));
    1190             : }
    1191             : 
    1192       61044 : ExternalReference ExternalReference::log_enter_external_function(
    1193             :     Isolate* isolate) {
    1194             :   return ExternalReference(
    1195       61044 :       Redirect(isolate, FUNCTION_ADDR(Logger::EnterExternal)));
    1196             : }
    1197             : 
    1198             : 
    1199       61044 : ExternalReference ExternalReference::log_leave_external_function(
    1200             :     Isolate* isolate) {
    1201             :   return ExternalReference(
    1202       61044 :       Redirect(isolate, FUNCTION_ADDR(Logger::LeaveExternal)));
    1203             : }
    1204             : 
    1205      373110 : ExternalReference ExternalReference::roots_array_start(Isolate* isolate) {
    1206      373110 :   return ExternalReference(isolate->heap()->roots_array_start());
    1207             : }
    1208             : 
    1209             : 
    1210       89880 : ExternalReference ExternalReference::allocation_sites_list_address(
    1211             :     Isolate* isolate) {
    1212       89880 :   return ExternalReference(isolate->heap()->allocation_sites_list_address());
    1213             : }
    1214             : 
    1215             : 
    1216     1439783 : ExternalReference ExternalReference::address_of_stack_limit(Isolate* isolate) {
    1217     1439783 :   return ExternalReference(isolate->stack_guard()->address_of_jslimit());
    1218             : }
    1219             : 
    1220             : 
    1221       61044 : ExternalReference ExternalReference::address_of_real_stack_limit(
    1222             :     Isolate* isolate) {
    1223       61044 :   return ExternalReference(isolate->stack_guard()->address_of_real_jslimit());
    1224             : }
    1225             : 
    1226             : 
    1227      751821 : ExternalReference ExternalReference::address_of_regexp_stack_limit(
    1228      751821 :     Isolate* isolate) {
    1229      751821 :   return ExternalReference(isolate->regexp_stack()->limit_address());
    1230             : }
    1231             : 
    1232       61216 : ExternalReference ExternalReference::address_of_regexp_dotall_flag(
    1233             :     Isolate* isolate) {
    1234       61216 :   return ExternalReference(&FLAG_harmony_regexp_dotall);
    1235             : }
    1236             : 
    1237      194093 : ExternalReference ExternalReference::store_buffer_top(Isolate* isolate) {
    1238      194093 :   return ExternalReference(isolate->heap()->store_buffer_top_address());
    1239             : }
    1240             : 
    1241             : 
    1242      346127 : ExternalReference ExternalReference::new_space_allocation_top_address(
    1243             :     Isolate* isolate) {
    1244      346127 :   return ExternalReference(isolate->heap()->NewSpaceAllocationTopAddress());
    1245             : }
    1246             : 
    1247             : 
    1248      246499 : ExternalReference ExternalReference::new_space_allocation_limit_address(
    1249             :     Isolate* isolate) {
    1250      246499 :   return ExternalReference(isolate->heap()->NewSpaceAllocationLimitAddress());
    1251             : }
    1252             : 
    1253             : 
    1254      119045 : ExternalReference ExternalReference::old_space_allocation_top_address(
    1255             :     Isolate* isolate) {
    1256      119045 :   return ExternalReference(isolate->heap()->OldSpaceAllocationTopAddress());
    1257             : }
    1258             : 
    1259             : 
    1260       61234 : ExternalReference ExternalReference::old_space_allocation_limit_address(
    1261             :     Isolate* isolate) {
    1262       61234 :   return ExternalReference(isolate->heap()->OldSpaceAllocationLimitAddress());
    1263             : }
    1264             : 
    1265             : 
    1266       67218 : ExternalReference ExternalReference::handle_scope_level_address(
    1267             :     Isolate* isolate) {
    1268       67218 :   return ExternalReference(HandleScope::current_level_address(isolate));
    1269             : }
    1270             : 
    1271             : 
    1272       67218 : ExternalReference ExternalReference::handle_scope_next_address(
    1273             :     Isolate* isolate) {
    1274       67218 :   return ExternalReference(HandleScope::current_next_address(isolate));
    1275             : }
    1276             : 
    1277             : 
    1278       67218 : ExternalReference ExternalReference::handle_scope_limit_address(
    1279             :     Isolate* isolate) {
    1280       67218 :   return ExternalReference(HandleScope::current_limit_address(isolate));
    1281             : }
    1282             : 
    1283             : 
    1284       67218 : ExternalReference ExternalReference::scheduled_exception_address(
    1285             :     Isolate* isolate) {
    1286       67218 :   return ExternalReference(isolate->scheduled_exception_address());
    1287             : }
    1288             : 
    1289             : 
    1290      140039 : ExternalReference ExternalReference::address_of_pending_message_obj(
    1291             :     Isolate* isolate) {
    1292      140039 :   return ExternalReference(isolate->pending_message_obj_address());
    1293             : }
    1294             : 
    1295             : 
    1296       61072 : ExternalReference ExternalReference::address_of_min_int() {
    1297       61072 :   return ExternalReference(reinterpret_cast<void*>(&double_constants.min_int));
    1298             : }
    1299             : 
    1300             : 
    1301       61072 : ExternalReference ExternalReference::address_of_one_half() {
    1302       61072 :   return ExternalReference(reinterpret_cast<void*>(&double_constants.one_half));
    1303             : }
    1304             : 
    1305             : 
    1306       61044 : ExternalReference ExternalReference::address_of_minus_one_half() {
    1307             :   return ExternalReference(
    1308       61044 :       reinterpret_cast<void*>(&double_constants.minus_one_half));
    1309             : }
    1310             : 
    1311             : 
    1312       61044 : ExternalReference ExternalReference::address_of_negative_infinity() {
    1313             :   return ExternalReference(
    1314       61044 :       reinterpret_cast<void*>(&double_constants.negative_infinity));
    1315             : }
    1316             : 
    1317             : 
    1318       61051 : ExternalReference ExternalReference::address_of_the_hole_nan() {
    1319             :   return ExternalReference(
    1320       61051 :       reinterpret_cast<void*>(&double_constants.the_hole_nan));
    1321             : }
    1322             : 
    1323             : 
    1324       61044 : ExternalReference ExternalReference::address_of_uint32_bias() {
    1325             :   return ExternalReference(
    1326       61044 :       reinterpret_cast<void*>(&double_constants.uint32_bias));
    1327             : }
    1328             : 
    1329             : 
    1330       61051 : ExternalReference ExternalReference::address_of_float_abs_constant() {
    1331       61051 :   return ExternalReference(reinterpret_cast<void*>(&float_absolute_constant));
    1332             : }
    1333             : 
    1334             : 
    1335       61051 : ExternalReference ExternalReference::address_of_float_neg_constant() {
    1336       61051 :   return ExternalReference(reinterpret_cast<void*>(&float_negate_constant));
    1337             : }
    1338             : 
    1339             : 
    1340       61051 : ExternalReference ExternalReference::address_of_double_abs_constant() {
    1341       61051 :   return ExternalReference(reinterpret_cast<void*>(&double_absolute_constant));
    1342             : }
    1343             : 
    1344             : 
    1345       61051 : ExternalReference ExternalReference::address_of_double_neg_constant() {
    1346       61051 :   return ExternalReference(reinterpret_cast<void*>(&double_negate_constant));
    1347             : }
    1348             : 
    1349             : 
    1350       67218 : ExternalReference ExternalReference::is_profiling_address(Isolate* isolate) {
    1351       67218 :   return ExternalReference(isolate->is_profiling_address());
    1352             : }
    1353             : 
    1354             : 
    1355       67175 : ExternalReference ExternalReference::invoke_function_callback(
    1356             :     Isolate* isolate) {
    1357             :   Address thunk_address = FUNCTION_ADDR(&InvokeFunctionCallback);
    1358             :   ExternalReference::Type thunk_type = ExternalReference::PROFILING_API_CALL;
    1359             :   ApiFunction thunk_fun(thunk_address);
    1360       67175 :   return ExternalReference(&thunk_fun, thunk_type, isolate);
    1361             : }
    1362             : 
    1363             : 
    1364       61087 : ExternalReference ExternalReference::invoke_accessor_getter_callback(
    1365             :     Isolate* isolate) {
    1366             :   Address thunk_address = FUNCTION_ADDR(&InvokeAccessorGetterCallback);
    1367             :   ExternalReference::Type thunk_type =
    1368             :       ExternalReference::PROFILING_GETTER_CALL;
    1369             :   ApiFunction thunk_fun(thunk_address);
    1370       61087 :   return ExternalReference(&thunk_fun, thunk_type, isolate);
    1371             : }
    1372             : 
    1373             : 
    1374             : #ifndef V8_INTERPRETED_REGEXP
    1375             : 
    1376      245511 : ExternalReference ExternalReference::re_check_stack_guard_state(
    1377             :     Isolate* isolate) {
    1378             :   Address function;
    1379             : #if V8_TARGET_ARCH_X64
    1380             :   function = FUNCTION_ADDR(RegExpMacroAssemblerX64::CheckStackGuardState);
    1381             : #elif V8_TARGET_ARCH_IA32
    1382             :   function = FUNCTION_ADDR(RegExpMacroAssemblerIA32::CheckStackGuardState);
    1383             : #elif V8_TARGET_ARCH_ARM64
    1384             :   function = FUNCTION_ADDR(RegExpMacroAssemblerARM64::CheckStackGuardState);
    1385             : #elif V8_TARGET_ARCH_ARM
    1386             :   function = FUNCTION_ADDR(RegExpMacroAssemblerARM::CheckStackGuardState);
    1387             : #elif V8_TARGET_ARCH_PPC
    1388             :   function = FUNCTION_ADDR(RegExpMacroAssemblerPPC::CheckStackGuardState);
    1389             : #elif V8_TARGET_ARCH_MIPS
    1390             :   function = FUNCTION_ADDR(RegExpMacroAssemblerMIPS::CheckStackGuardState);
    1391             : #elif V8_TARGET_ARCH_MIPS64
    1392             :   function = FUNCTION_ADDR(RegExpMacroAssemblerMIPS::CheckStackGuardState);
    1393             : #elif V8_TARGET_ARCH_S390
    1394             :   function = FUNCTION_ADDR(RegExpMacroAssemblerS390::CheckStackGuardState);
    1395             : #elif V8_TARGET_ARCH_X87
    1396             :   function = FUNCTION_ADDR(RegExpMacroAssemblerX87::CheckStackGuardState);
    1397             : #else
    1398             :   UNREACHABLE();
    1399             : #endif
    1400      245511 :   return ExternalReference(Redirect(isolate, function));
    1401             : }
    1402             : 
    1403             : 
    1404      153260 : ExternalReference ExternalReference::re_grow_stack(Isolate* isolate) {
    1405             :   return ExternalReference(
    1406      153260 :       Redirect(isolate, FUNCTION_ADDR(NativeRegExpMacroAssembler::GrowStack)));
    1407             : }
    1408             : 
    1409       61353 : ExternalReference ExternalReference::re_case_insensitive_compare_uc16(
    1410             :     Isolate* isolate) {
    1411             :   return ExternalReference(Redirect(
    1412             :       isolate,
    1413       61353 :       FUNCTION_ADDR(NativeRegExpMacroAssembler::CaseInsensitiveCompareUC16)));
    1414             : }
    1415             : 
    1416             : 
    1417       66653 : ExternalReference ExternalReference::re_word_character_map() {
    1418             :   return ExternalReference(
    1419       66653 :       NativeRegExpMacroAssembler::word_character_map_address());
    1420             : }
    1421             : 
    1422       61474 : ExternalReference ExternalReference::address_of_static_offsets_vector(
    1423             :     Isolate* isolate) {
    1424             :   return ExternalReference(
    1425       61474 :       reinterpret_cast<Address>(isolate->jsregexp_static_offsets_vector()));
    1426             : }
    1427             : 
    1428       61474 : ExternalReference ExternalReference::address_of_regexp_stack_memory_address(
    1429       61474 :     Isolate* isolate) {
    1430             :   return ExternalReference(
    1431       61474 :       isolate->regexp_stack()->memory_address());
    1432             : }
    1433             : 
    1434       61474 : ExternalReference ExternalReference::address_of_regexp_stack_memory_size(
    1435       61474 :     Isolate* isolate) {
    1436       61474 :   return ExternalReference(isolate->regexp_stack()->memory_size_address());
    1437             : }
    1438             : 
    1439             : #endif  // V8_INTERPRETED_REGEXP
    1440             : 
    1441       61094 : ExternalReference ExternalReference::ieee754_acos_function(Isolate* isolate) {
    1442             :   return ExternalReference(
    1443       61094 :       Redirect(isolate, FUNCTION_ADDR(base::ieee754::acos), BUILTIN_FP_CALL));
    1444             : }
    1445             : 
    1446       61093 : ExternalReference ExternalReference::ieee754_acosh_function(Isolate* isolate) {
    1447             :   return ExternalReference(Redirect(
    1448       61093 :       isolate, FUNCTION_ADDR(base::ieee754::acosh), BUILTIN_FP_FP_CALL));
    1449             : }
    1450             : 
    1451       61094 : ExternalReference ExternalReference::ieee754_asin_function(Isolate* isolate) {
    1452             :   return ExternalReference(
    1453       61094 :       Redirect(isolate, FUNCTION_ADDR(base::ieee754::asin), BUILTIN_FP_CALL));
    1454             : }
    1455             : 
    1456       61093 : ExternalReference ExternalReference::ieee754_asinh_function(Isolate* isolate) {
    1457             :   return ExternalReference(Redirect(
    1458       61093 :       isolate, FUNCTION_ADDR(base::ieee754::asinh), BUILTIN_FP_FP_CALL));
    1459             : }
    1460             : 
    1461       61110 : ExternalReference ExternalReference::ieee754_atan_function(Isolate* isolate) {
    1462             :   return ExternalReference(
    1463       61110 :       Redirect(isolate, FUNCTION_ADDR(base::ieee754::atan), BUILTIN_FP_CALL));
    1464             : }
    1465             : 
    1466       61093 : ExternalReference ExternalReference::ieee754_atanh_function(Isolate* isolate) {
    1467             :   return ExternalReference(Redirect(
    1468       61093 :       isolate, FUNCTION_ADDR(base::ieee754::atanh), BUILTIN_FP_FP_CALL));
    1469             : }
    1470             : 
    1471       61117 : ExternalReference ExternalReference::ieee754_atan2_function(Isolate* isolate) {
    1472             :   return ExternalReference(Redirect(
    1473       61117 :       isolate, FUNCTION_ADDR(base::ieee754::atan2), BUILTIN_FP_FP_CALL));
    1474             : }
    1475             : 
    1476       61093 : ExternalReference ExternalReference::ieee754_cbrt_function(Isolate* isolate) {
    1477             :   return ExternalReference(Redirect(isolate, FUNCTION_ADDR(base::ieee754::cbrt),
    1478       61093 :                                     BUILTIN_FP_FP_CALL));
    1479             : }
    1480             : 
    1481       61397 : ExternalReference ExternalReference::ieee754_cos_function(Isolate* isolate) {
    1482             :   return ExternalReference(
    1483       61397 :       Redirect(isolate, FUNCTION_ADDR(base::ieee754::cos), BUILTIN_FP_CALL));
    1484             : }
    1485             : 
    1486       61102 : ExternalReference ExternalReference::ieee754_cosh_function(Isolate* isolate) {
    1487             :   return ExternalReference(
    1488       61102 :       Redirect(isolate, FUNCTION_ADDR(base::ieee754::cosh), BUILTIN_FP_CALL));
    1489             : }
    1490             : 
    1491       61168 : ExternalReference ExternalReference::ieee754_exp_function(Isolate* isolate) {
    1492             :   return ExternalReference(
    1493       61168 :       Redirect(isolate, FUNCTION_ADDR(base::ieee754::exp), BUILTIN_FP_CALL));
    1494             : }
    1495             : 
    1496       61093 : ExternalReference ExternalReference::ieee754_expm1_function(Isolate* isolate) {
    1497             :   return ExternalReference(Redirect(
    1498       61093 :       isolate, FUNCTION_ADDR(base::ieee754::expm1), BUILTIN_FP_FP_CALL));
    1499             : }
    1500             : 
    1501       61503 : ExternalReference ExternalReference::ieee754_log_function(Isolate* isolate) {
    1502             :   return ExternalReference(
    1503       61503 :       Redirect(isolate, FUNCTION_ADDR(base::ieee754::log), BUILTIN_FP_CALL));
    1504             : }
    1505             : 
    1506       61093 : ExternalReference ExternalReference::ieee754_log1p_function(Isolate* isolate) {
    1507             :   return ExternalReference(
    1508       61093 :       Redirect(isolate, FUNCTION_ADDR(base::ieee754::log1p), BUILTIN_FP_CALL));
    1509             : }
    1510             : 
    1511       61093 : ExternalReference ExternalReference::ieee754_log10_function(Isolate* isolate) {
    1512             :   return ExternalReference(
    1513       61093 :       Redirect(isolate, FUNCTION_ADDR(base::ieee754::log10), BUILTIN_FP_CALL));
    1514             : }
    1515             : 
    1516       61093 : ExternalReference ExternalReference::ieee754_log2_function(Isolate* isolate) {
    1517             :   return ExternalReference(
    1518       61093 :       Redirect(isolate, FUNCTION_ADDR(base::ieee754::log2), BUILTIN_FP_CALL));
    1519             : }
    1520             : 
    1521       61427 : ExternalReference ExternalReference::ieee754_sin_function(Isolate* isolate) {
    1522             :   return ExternalReference(
    1523       61427 :       Redirect(isolate, FUNCTION_ADDR(base::ieee754::sin), BUILTIN_FP_CALL));
    1524             : }
    1525             : 
    1526       61102 : ExternalReference ExternalReference::ieee754_sinh_function(Isolate* isolate) {
    1527             :   return ExternalReference(
    1528       61102 :       Redirect(isolate, FUNCTION_ADDR(base::ieee754::sinh), BUILTIN_FP_CALL));
    1529             : }
    1530             : 
    1531       61110 : ExternalReference ExternalReference::ieee754_tan_function(Isolate* isolate) {
    1532             :   return ExternalReference(
    1533       61110 :       Redirect(isolate, FUNCTION_ADDR(base::ieee754::tan), BUILTIN_FP_CALL));
    1534             : }
    1535             : 
    1536       61102 : ExternalReference ExternalReference::ieee754_tanh_function(Isolate* isolate) {
    1537             :   return ExternalReference(
    1538       61102 :       Redirect(isolate, FUNCTION_ADDR(base::ieee754::tanh), BUILTIN_FP_CALL));
    1539             : }
    1540             : 
    1541     4532866 : void* libc_memchr(void* string, int character, size_t search_length) {
    1542     4532866 :   return memchr(string, character, search_length);
    1543             : }
    1544             : 
    1545       61130 : ExternalReference ExternalReference::libc_memchr_function(Isolate* isolate) {
    1546       61130 :   return ExternalReference(Redirect(isolate, FUNCTION_ADDR(libc_memchr)));
    1547             : }
    1548             : 
    1549        1401 : void* libc_memcpy(void* dest, const void* src, size_t n) {
    1550        1401 :   return memcpy(dest, src, n);
    1551             : }
    1552             : 
    1553       61087 : ExternalReference ExternalReference::libc_memcpy_function(Isolate* isolate) {
    1554       61087 :   return ExternalReference(Redirect(isolate, FUNCTION_ADDR(libc_memcpy)));
    1555             : }
    1556             : 
    1557      254550 : void* libc_memset(void* dest, int byte, size_t n) {
    1558             :   DCHECK_EQ(static_cast<char>(byte), byte);
    1559      254550 :   return memset(dest, byte, n);
    1560             : }
    1561             : 
    1562       61087 : ExternalReference ExternalReference::libc_memset_function(Isolate* isolate) {
    1563       61087 :   return ExternalReference(Redirect(isolate, FUNCTION_ADDR(libc_memset)));
    1564             : }
    1565             : 
    1566             : template <typename SubjectChar, typename PatternChar>
    1567      244520 : ExternalReference ExternalReference::search_string_raw(Isolate* isolate) {
    1568             :   auto f = SearchStringRaw<SubjectChar, PatternChar>;
    1569      244520 :   return ExternalReference(Redirect(isolate, FUNCTION_ADDR(f)));
    1570             : }
    1571             : 
    1572       61130 : ExternalReference ExternalReference::try_internalize_string_function(
    1573             :     Isolate* isolate) {
    1574             :   return ExternalReference(Redirect(
    1575       61130 :       isolate, FUNCTION_ADDR(StringTable::LookupStringIfExists_NoAllocate)));
    1576             : }
    1577             : 
    1578             : // Explicit instantiations for all combinations of 1- and 2-byte strings.
    1579             : template ExternalReference
    1580             : ExternalReference::search_string_raw<const uint8_t, const uint8_t>(Isolate*);
    1581             : template ExternalReference
    1582             : ExternalReference::search_string_raw<const uint8_t, const uc16>(Isolate*);
    1583             : template ExternalReference
    1584             : ExternalReference::search_string_raw<const uc16, const uint8_t>(Isolate*);
    1585             : template ExternalReference
    1586             : ExternalReference::search_string_raw<const uc16, const uc16>(Isolate*);
    1587             : 
    1588           0 : ExternalReference ExternalReference::page_flags(Page* page) {
    1589           0 :   return ExternalReference(reinterpret_cast<Address>(page) +
    1590           0 :                            MemoryChunk::kFlagsOffset);
    1591             : }
    1592             : 
    1593             : 
    1594       24143 : ExternalReference ExternalReference::ForDeoptEntry(Address entry) {
    1595       24143 :   return ExternalReference(entry);
    1596             : }
    1597             : 
    1598             : 
    1599       61044 : ExternalReference ExternalReference::cpu_features() {
    1600             :   DCHECK(CpuFeatures::initialized_);
    1601       61044 :   return ExternalReference(&CpuFeatures::supported_);
    1602             : }
    1603             : 
    1604       61345 : ExternalReference ExternalReference::is_tail_call_elimination_enabled_address(
    1605             :     Isolate* isolate) {
    1606       61345 :   return ExternalReference(isolate->is_tail_call_elimination_enabled_address());
    1607             : }
    1608             : 
    1609       63823 : ExternalReference ExternalReference::promise_hook_or_debug_is_active_address(
    1610             :     Isolate* isolate) {
    1611       63823 :   return ExternalReference(isolate->promise_hook_or_debug_is_active_address());
    1612             : }
    1613             : 
    1614       63281 : ExternalReference ExternalReference::debug_is_active_address(
    1615       63281 :     Isolate* isolate) {
    1616       63281 :   return ExternalReference(isolate->debug()->is_active_address());
    1617             : }
    1618             : 
    1619       61603 : ExternalReference ExternalReference::debug_hook_on_function_call_address(
    1620       61603 :     Isolate* isolate) {
    1621       61603 :   return ExternalReference(isolate->debug()->hook_on_function_call_address());
    1622             : }
    1623             : 
    1624       61314 : ExternalReference ExternalReference::runtime_function_table_address(
    1625             :     Isolate* isolate) {
    1626             :   return ExternalReference(
    1627       61314 :       const_cast<Runtime::Function*>(Runtime::RuntimeFunctionTable(isolate)));
    1628             : }
    1629             : 
    1630             : 
    1631          18 : double power_helper(Isolate* isolate, double x, double y) {
    1632          18 :   int y_int = static_cast<int>(y);
    1633          18 :   if (y == y_int) {
    1634           8 :     return power_double_int(x, y_int);  // Returns 1 if exponent is 0.
    1635             :   }
    1636          10 :   if (y == 0.5) {
    1637           0 :     lazily_initialize_fast_sqrt(isolate);
    1638             :     return (std::isinf(x)) ? V8_INFINITY
    1639           0 :                            : fast_sqrt(x + 0.0, isolate);  // Convert -0 to +0.
    1640             :   }
    1641          10 :   if (y == -0.5) {
    1642           0 :     lazily_initialize_fast_sqrt(isolate);
    1643             :     return (std::isinf(x)) ? 0 : 1.0 / fast_sqrt(x + 0.0,
    1644           0 :                                                  isolate);  // Convert -0 to +0.
    1645             :   }
    1646          10 :   return power_double_double(x, y);
    1647             : }
    1648             : 
    1649             : 
    1650             : // Helper function to compute x^y, where y is known to be an
    1651             : // integer. Uses binary decomposition to limit the number of
    1652             : // multiplications; see the discussion in "Hacker's Delight" by Henry
    1653             : // S. Warren, Jr., figure 11-6, page 213.
    1654           8 : double power_double_int(double x, int y) {
    1655           8 :   double m = (y < 0) ? 1 / x : x;
    1656           8 :   unsigned n = (y < 0) ? -y : y;
    1657             :   double p = 1;
    1658          40 :   while (n != 0) {
    1659          24 :     if ((n & 1) != 0) p *= m;
    1660          24 :     m *= m;
    1661          24 :     if ((n & 2) != 0) p *= m;
    1662          24 :     m *= m;
    1663          24 :     n >>= 2;
    1664             :   }
    1665           8 :   return p;
    1666             : }
    1667             : 
    1668             : 
    1669        4512 : double power_double_double(double x, double y) {
    1670             :   // The checks for special cases can be dropped in ia32 because it has already
    1671             :   // been done in generated code before bailing out here.
    1672        4771 :   if (std::isnan(y) || ((x == 1 || x == -1) && std::isinf(y))) {
    1673             :     return std::numeric_limits<double>::quiet_NaN();
    1674             :   }
    1675        3657 :   return Pow(x, y);
    1676             : }
    1677             : 
    1678             : 
    1679       61156 : ExternalReference ExternalReference::power_double_double_function(
    1680             :     Isolate* isolate) {
    1681             :   return ExternalReference(Redirect(isolate,
    1682             :                                     FUNCTION_ADDR(power_double_double),
    1683       61156 :                                     BUILTIN_FP_FP_CALL));
    1684             : }
    1685             : 
    1686             : 
    1687       63269 : ExternalReference ExternalReference::mod_two_doubles_operation(
    1688             :     Isolate* isolate) {
    1689             :   return ExternalReference(Redirect(isolate,
    1690             :                                     FUNCTION_ADDR(modulo),
    1691       63269 :                                     BUILTIN_FP_FP_CALL));
    1692             : }
    1693             : 
    1694       61173 : ExternalReference ExternalReference::debug_last_step_action_address(
    1695       61173 :     Isolate* isolate) {
    1696       61173 :   return ExternalReference(isolate->debug()->last_step_action_address());
    1697             : }
    1698             : 
    1699       61087 : ExternalReference ExternalReference::debug_suspended_generator_address(
    1700       61087 :     Isolate* isolate) {
    1701       61087 :   return ExternalReference(isolate->debug()->suspended_generator_address());
    1702             : }
    1703             : 
    1704       62076 : ExternalReference ExternalReference::debug_restart_fp_address(
    1705       62076 :     Isolate* isolate) {
    1706       62076 :   return ExternalReference(isolate->debug()->restart_fp_address());
    1707             : }
    1708             : 
    1709        1101 : ExternalReference ExternalReference::fixed_typed_array_base_data_offset() {
    1710             :   return ExternalReference(reinterpret_cast<void*>(
    1711        1101 :       FixedTypedArrayBase::kDataOffset - kHeapObjectTag));
    1712             : }
    1713             : 
    1714             : 
    1715      536839 : bool operator==(ExternalReference lhs, ExternalReference rhs) {
    1716      536839 :   return lhs.address() == rhs.address();
    1717             : }
    1718             : 
    1719             : 
    1720           0 : bool operator!=(ExternalReference lhs, ExternalReference rhs) {
    1721           0 :   return !(lhs == rhs);
    1722             : }
    1723             : 
    1724             : 
    1725     2559449 : size_t hash_value(ExternalReference reference) {
    1726     2559469 :   return base::hash<Address>()(reference.address());
    1727             : }
    1728             : 
    1729             : 
    1730           0 : std::ostream& operator<<(std::ostream& os, ExternalReference reference) {
    1731             :   os << static_cast<const void*>(reference.address());
    1732           0 :   const Runtime::Function* fn = Runtime::FunctionForEntry(reference.address());
    1733           0 :   if (fn) os << "<" << fn->name << ".entry>";
    1734           0 :   return os;
    1735             : }
    1736             : 
    1737             : 
    1738          42 : ConstantPoolBuilder::ConstantPoolBuilder(int ptr_reach_bits,
    1739         126 :                                          int double_reach_bits) {
    1740          42 :   info_[ConstantPoolEntry::INTPTR].entries.reserve(64);
    1741          42 :   info_[ConstantPoolEntry::INTPTR].regular_reach_bits = ptr_reach_bits;
    1742          42 :   info_[ConstantPoolEntry::DOUBLE].regular_reach_bits = double_reach_bits;
    1743          42 : }
    1744             : 
    1745             : 
    1746        1099 : ConstantPoolEntry::Access ConstantPoolBuilder::NextAccess(
    1747             :     ConstantPoolEntry::Type type) const {
    1748        1099 :   const PerTypeEntryInfo& info = info_[type];
    1749             : 
    1750        1099 :   if (info.overflow()) return ConstantPoolEntry::OVERFLOWED;
    1751             : 
    1752         959 :   int dbl_count = info_[ConstantPoolEntry::DOUBLE].regular_count;
    1753         959 :   int dbl_offset = dbl_count * kDoubleSize;
    1754         959 :   int ptr_count = info_[ConstantPoolEntry::INTPTR].regular_count;
    1755         959 :   int ptr_offset = ptr_count * kPointerSize + dbl_offset;
    1756             : 
    1757         959 :   if (type == ConstantPoolEntry::DOUBLE) {
    1758             :     // Double overflow detection must take into account the reach for both types
    1759         441 :     int ptr_reach_bits = info_[ConstantPoolEntry::INTPTR].regular_reach_bits;
    1760        1323 :     if (!is_uintn(dbl_offset, info.regular_reach_bits) ||
    1761         287 :         (ptr_count > 0 &&
    1762         287 :          !is_uintn(ptr_offset + kDoubleSize - kPointerSize, ptr_reach_bits))) {
    1763             :       return ConstantPoolEntry::OVERFLOWED;
    1764             :     }
    1765             :   } else {
    1766             :     DCHECK(type == ConstantPoolEntry::INTPTR);
    1767        1036 :     if (!is_uintn(ptr_offset, info.regular_reach_bits)) {
    1768             :       return ConstantPoolEntry::OVERFLOWED;
    1769             :     }
    1770             :   }
    1771             : 
    1772         840 :   return ConstantPoolEntry::REGULAR;
    1773             : }
    1774             : 
    1775             : 
    1776         798 : ConstantPoolEntry::Access ConstantPoolBuilder::AddEntry(
    1777        5908 :     ConstantPoolEntry& entry, ConstantPoolEntry::Type type) {
    1778             :   DCHECK(!emitted_label_.is_bound());
    1779         798 :   PerTypeEntryInfo& info = info_[type];
    1780             :   const int entry_size = ConstantPoolEntry::size(type);
    1781             :   bool merged = false;
    1782             : 
    1783         798 :   if (entry.sharing_ok()) {
    1784             :     // Try to merge entries
    1785         770 :     std::vector<ConstantPoolEntry>::iterator it = info.shared_entries.begin();
    1786         770 :     int end = static_cast<int>(info.shared_entries.size());
    1787        9996 :     for (int i = 0; i < end; i++, it++) {
    1788        4312 :       if ((entry_size == kPointerSize) ? entry.value() == it->value()
    1789             :                                        : entry.value64() == it->value64()) {
    1790             :         // Merge with found entry.
    1791             :         entry.set_merged_index(i);
    1792             :         merged = true;
    1793          84 :         break;
    1794             :       }
    1795             :     }
    1796             :   }
    1797             : 
    1798             :   // By definition, merged entries have regular access.
    1799             :   DCHECK(!merged || entry.merged_index() < info.regular_count);
    1800             :   ConstantPoolEntry::Access access =
    1801         798 :       (merged ? ConstantPoolEntry::REGULAR : NextAccess(type));
    1802             : 
    1803             :   // Enforce an upper bound on search time by limiting the search to
    1804             :   // unique sharable entries which fit in the regular section.
    1805         798 :   if (entry.sharing_ok() && !merged && access == ConstantPoolEntry::REGULAR) {
    1806         476 :     info.shared_entries.push_back(entry);
    1807             :   } else {
    1808         392 :     info.entries.push_back(entry);
    1809             :   }
    1810             : 
    1811             :   // We're done if we found a match or have already triggered the
    1812             :   // overflow state.
    1813        1512 :   if (merged || info.overflow()) return access;
    1814             : 
    1815         574 :   if (access == ConstantPoolEntry::REGULAR) {
    1816         504 :     info.regular_count++;
    1817             :   } else {
    1818          70 :     info.overflow_start = static_cast<int>(info.entries.size()) - 1;
    1819             :   }
    1820             : 
    1821             :   return access;
    1822             : }
    1823             : 
    1824             : 
    1825           0 : void ConstantPoolBuilder::EmitSharedEntries(Assembler* assm,
    1826             :                                             ConstantPoolEntry::Type type) {
    1827           0 :   PerTypeEntryInfo& info = info_[type];
    1828           0 :   std::vector<ConstantPoolEntry>& shared_entries = info.shared_entries;
    1829             :   const int entry_size = ConstantPoolEntry::size(type);
    1830           0 :   int base = emitted_label_.pos();
    1831             :   DCHECK(base > 0);
    1832           0 :   int shared_end = static_cast<int>(shared_entries.size());
    1833             :   std::vector<ConstantPoolEntry>::iterator shared_it = shared_entries.begin();
    1834           0 :   for (int i = 0; i < shared_end; i++, shared_it++) {
    1835           0 :     int offset = assm->pc_offset() - base;
    1836             :     shared_it->set_offset(offset);  // Save offset for merged entries.
    1837             :     if (entry_size == kPointerSize) {
    1838           0 :       assm->dp(shared_it->value());
    1839             :     } else {
    1840             :       assm->dq(shared_it->value64());
    1841             :     }
    1842             :     DCHECK(is_uintn(offset, info.regular_reach_bits));
    1843             : 
    1844             :     // Patch load sequence with correct offset.
    1845             :     assm->PatchConstantPoolAccessInstruction(shared_it->position(), offset,
    1846           0 :                                              ConstantPoolEntry::REGULAR, type);
    1847             :   }
    1848           0 : }
    1849             : 
    1850             : 
    1851           0 : void ConstantPoolBuilder::EmitGroup(Assembler* assm,
    1852             :                                     ConstantPoolEntry::Access access,
    1853             :                                     ConstantPoolEntry::Type type) {
    1854           0 :   PerTypeEntryInfo& info = info_[type];
    1855             :   const bool overflow = info.overflow();
    1856           0 :   std::vector<ConstantPoolEntry>& entries = info.entries;
    1857             :   std::vector<ConstantPoolEntry>& shared_entries = info.shared_entries;
    1858             :   const int entry_size = ConstantPoolEntry::size(type);
    1859           0 :   int base = emitted_label_.pos();
    1860             :   DCHECK(base > 0);
    1861             :   int begin;
    1862             :   int end;
    1863             : 
    1864           0 :   if (access == ConstantPoolEntry::REGULAR) {
    1865             :     // Emit any shared entries first
    1866           0 :     EmitSharedEntries(assm, type);
    1867             :   }
    1868             : 
    1869           0 :   if (access == ConstantPoolEntry::REGULAR) {
    1870             :     begin = 0;
    1871           0 :     end = overflow ? info.overflow_start : static_cast<int>(entries.size());
    1872             :   } else {
    1873             :     DCHECK(access == ConstantPoolEntry::OVERFLOWED);
    1874           0 :     if (!overflow) return;
    1875           0 :     begin = info.overflow_start;
    1876           0 :     end = static_cast<int>(entries.size());
    1877             :   }
    1878             : 
    1879             :   std::vector<ConstantPoolEntry>::iterator it = entries.begin();
    1880           0 :   if (begin > 0) std::advance(it, begin);
    1881           0 :   for (int i = begin; i < end; i++, it++) {
    1882             :     // Update constant pool if necessary and get the entry's offset.
    1883             :     int offset;
    1884             :     ConstantPoolEntry::Access entry_access;
    1885           0 :     if (!it->is_merged()) {
    1886             :       // Emit new entry
    1887             :       offset = assm->pc_offset() - base;
    1888             :       entry_access = access;
    1889             :       if (entry_size == kPointerSize) {
    1890           0 :         assm->dp(it->value());
    1891             :       } else {
    1892             :         assm->dq(it->value64());
    1893             :       }
    1894             :     } else {
    1895             :       // Retrieve offset from shared entry.
    1896             :       offset = shared_entries[it->merged_index()].offset();
    1897             :       entry_access = ConstantPoolEntry::REGULAR;
    1898             :     }
    1899             : 
    1900             :     DCHECK(entry_access == ConstantPoolEntry::OVERFLOWED ||
    1901             :            is_uintn(offset, info.regular_reach_bits));
    1902             : 
    1903             :     // Patch load sequence with correct offset.
    1904             :     assm->PatchConstantPoolAccessInstruction(it->position(), offset,
    1905           0 :                                              entry_access, type);
    1906             :   }
    1907             : }
    1908             : 
    1909             : 
    1910             : // Emit and return position of pool.  Zero implies no constant pool.
    1911           0 : int ConstantPoolBuilder::Emit(Assembler* assm) {
    1912           0 :   bool emitted = emitted_label_.is_bound();
    1913             :   bool empty = IsEmpty();
    1914             : 
    1915           0 :   if (!emitted) {
    1916             :     // Mark start of constant pool.  Align if necessary.
    1917           0 :     if (!empty) assm->DataAlign(kDoubleSize);
    1918           0 :     assm->bind(&emitted_label_);
    1919           0 :     if (!empty) {
    1920             :       // Emit in groups based on access and type.
    1921             :       // Emit doubles first for alignment purposes.
    1922           0 :       EmitGroup(assm, ConstantPoolEntry::REGULAR, ConstantPoolEntry::DOUBLE);
    1923           0 :       EmitGroup(assm, ConstantPoolEntry::REGULAR, ConstantPoolEntry::INTPTR);
    1924           0 :       if (info_[ConstantPoolEntry::DOUBLE].overflow()) {
    1925           0 :         assm->DataAlign(kDoubleSize);
    1926             :         EmitGroup(assm, ConstantPoolEntry::OVERFLOWED,
    1927           0 :                   ConstantPoolEntry::DOUBLE);
    1928             :       }
    1929           0 :       if (info_[ConstantPoolEntry::INTPTR].overflow()) {
    1930             :         EmitGroup(assm, ConstantPoolEntry::OVERFLOWED,
    1931           0 :                   ConstantPoolEntry::INTPTR);
    1932             :       }
    1933             :     }
    1934             :   }
    1935             : 
    1936           0 :   return !empty ? emitted_label_.pos() : 0;
    1937             : }
    1938             : 
    1939             : 
    1940             : // Platform specific but identical code for all the platforms.
    1941             : 
    1942      184419 : void Assembler::RecordDeoptReason(DeoptimizeReason reason,
    1943             :                                   SourcePosition position, int id) {
    1944             :   EnsureSpace ensure_space(this);
    1945      184419 :   RecordRelocInfo(RelocInfo::DEOPT_SCRIPT_OFFSET, position.ScriptOffset());
    1946      184419 :   RecordRelocInfo(RelocInfo::DEOPT_INLINING_ID, position.InliningId());
    1947      184419 :   RecordRelocInfo(RelocInfo::DEOPT_REASON, static_cast<int>(reason));
    1948      184419 :   RecordRelocInfo(RelocInfo::DEOPT_ID, id);
    1949      184419 : }
    1950             : 
    1951             : 
    1952     1322594 : void Assembler::RecordComment(const char* msg) {
    1953     1322594 :   if (FLAG_code_comments) {
    1954             :     EnsureSpace ensure_space(this);
    1955           0 :     RecordRelocInfo(RelocInfo::COMMENT, reinterpret_cast<intptr_t>(msg));
    1956             :   }
    1957     1322594 : }
    1958             : 
    1959             : 
    1960       17028 : void Assembler::RecordDebugBreakSlot(RelocInfo::Mode mode) {
    1961             :   EnsureSpace ensure_space(this);
    1962             :   DCHECK(RelocInfo::IsDebugBreakSlot(mode));
    1963       17028 :   RecordRelocInfo(mode);
    1964       17028 : }
    1965             : 
    1966             : 
    1967           0 : void Assembler::DataAlign(int m) {
    1968             :   DCHECK(m >= 2 && base::bits::IsPowerOfTwo32(m));
    1969           0 :   while ((pc_offset() & (m - 1)) != 0) {
    1970           0 :     db(0);
    1971             :   }
    1972           0 : }
    1973             : }  // namespace internal
    1974             : }  // namespace v8

Generated by: LCOV version 1.10