../deps/v8/src/base/bit-field.h

Bug Summary

File:	out/../deps/v8/src/base/bit-field.h
Warning:	line 56, column 34 The result of the '<<' expression is undefined

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name code-stub-assembler.cc -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/home/maurizio/node-v18.6.0/out -resource-dir /usr/local/lib/clang/16.0.0 -D _GLIBCXX_USE_CXX11_ABI=1 -D NODE_OPENSSL_CONF_NAME=nodejs_conf -D NODE_OPENSSL_HAS_QUIC -D V8_GYP_BUILD -D V8_TYPED_ARRAY_MAX_SIZE_IN_HEAP=64 -D __STDC_FORMAT_MACROS -D OPENSSL_NO_PINSHARED -D OPENSSL_THREADS -D V8_TARGET_ARCH_X64 -D V8_HAVE_TARGET_OS -D V8_TARGET_OS_LINUX -D V8_EMBEDDER_STRING="-node.8" -D ENABLE_DISASSEMBLER -D V8_PROMISE_INTERNAL_FIELD_COUNT=1 -D V8_SHORT_BUILTIN_CALLS -D OBJECT_PRINT -D V8_INTL_SUPPORT -D V8_ATOMIC_OBJECT_FIELD_WRITES -D V8_ENABLE_LAZY_SOURCE_POSITIONS -D V8_USE_SIPHASH -D V8_SHARED_RO_HEAP -D V8_WIN64_UNWINDING_INFO -D V8_ENABLE_REGEXP_INTERPRETER_THREADED_DISPATCH -D V8_SNAPSHOT_COMPRESSION -D V8_ENABLE_WEBASSEMBLY -D V8_ENABLE_JAVASCRIPT_PROMISE_HOOKS -D V8_ALLOCATION_FOLDING -D V8_ALLOCATION_SITE_TRACKING -D V8_SCRIPTORMODULE_LEGACY_LIFETIME -D V8_ADVANCED_BIGINT_ALGORITHMS -D UCONFIG_NO_SERVICE=1 -D U_ENABLE_DYLOAD=0 -D U_STATIC_IMPLEMENTATION=1 -D U_HAVE_STD_STRING=1 -D UCONFIG_NO_BREAK_ITERATION=0 -I ../deps/v8 -I ../deps/v8/include -I /home/maurizio/node-v18.6.0/out/Release/obj/gen -I /home/maurizio/node-v18.6.0/out/Release/obj/gen/generate-bytecode-output-root -I ../deps/icu-small/source/i18n -I ../deps/icu-small/source/common -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8 -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/x86_64-redhat-linux -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../include/c++/8/backward -internal-isystem /usr/local/lib/clang/16.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../x86_64-redhat-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O3 -Wno-unused-parameter -Wno-return-type -std=gnu++17 -fdeprecated-macro -fdebug-compilation-dir=/home/maurizio/node-v18.6.0/out -ferror-limit 19 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-08-22-142216-507842-1 -x c++ ../deps/v8/src/codegen/code-stub-assembler.cc

../deps/v8/src/codegen/code-stub-assembler.cc

→

1// Copyright 2016 the V8 project authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.

5#include "src/codegen/code-stub-assembler.h"

7#include <functional>

9#include "include/v8-internal.h"
10#include "src/base/macros.h"
11#include "src/codegen/code-factory.h"
12#include "src/codegen/tnode.h"
13#include "src/common/globals.h"
14#include "src/execution/frames-inl.h"
15#include "src/execution/frames.h"
16#include "src/execution/protectors.h"
17#include "src/heap/heap-inl.h"  // For MemoryChunk. TODO(jkummerow): Drop.
18#include "src/heap/memory-chunk.h"
19#include "src/logging/counters.h"
20#include "src/numbers/integer-literal-inl.h"
21#include "src/objects/api-callbacks.h"
22#include "src/objects/cell.h"
23#include "src/objects/descriptor-array.h"
24#include "src/objects/function-kind.h"
25#include "src/objects/heap-number.h"
26#include "src/objects/instance-type.h"
27#include "src/objects/js-generator.h"
28#include "src/objects/oddball.h"
29#include "src/objects/ordered-hash-table-inl.h"
30#include "src/objects/property-cell.h"
31#include "src/roots/roots.h"

33#if V8_ENABLE_WEBASSEMBLY1
34#include "src/wasm/wasm-objects.h"
35#endif  // V8_ENABLE_WEBASSEMBLY

37namespace v8 {
38namespace internal {

40CodeStubAssembler::CodeStubAssembler(compiler::CodeAssemblerState* state)
  : compiler::CodeAssembler(state),
    TorqueGeneratedExportedMacrosAssembler(state) {
if (DEBUG_BOOLfalse && FLAG_csa_trap_on_node != nullptr) {
  HandleBreakOnNode();
}
46}

48void CodeStubAssembler::HandleBreakOnNode() {
// FLAG_csa_trap_on_node should be in a form "STUB,NODE" where STUB is a
// string specifying the name of a stub and NODE is number specifying node id.
const char* name = state()->name();
size_t name_length = strlen(name);
if (strncmp(FLAG_csa_trap_on_node, name, name_length) != 0) {
  // Different name.
  return;
}
size_t option_length = strlen(FLAG_csa_trap_on_node);
if (option_length < name_length + 2 ||
    FLAG_csa_trap_on_node[name_length] != ',') {
  // Option is too short.
  return;
}
const char* start = &FLAG_csa_trap_on_node[name_length + 1];
char* end;
int node_id = static_cast<int>(strtol(start, &end, 10));
if (start == end) {
  // Bad node id.
  return;
}
BreakOnNode(node_id);
71}

73void CodeStubAssembler::Dcheck(const BranchGenerator& branch,
                             const char* message, const char* file, int line,
                             std::initializer_list<ExtraNode> extra_nodes) {
76#if defined(DEBUG)
if (FLAG_debug_code) {
  Check(branch, message, file, line, extra_nodes);
}
80#endif
81}

83void CodeStubAssembler::Dcheck(const NodeGenerator<BoolT>& condition_body,
                             const char* message, const char* file, int line,
                             std::initializer_list<ExtraNode> extra_nodes) {
86#if defined(DEBUG)
if (FLAG_debug_code) {
  Check(condition_body, message, file, line, extra_nodes);
}
90#endif
91}

93void CodeStubAssembler::Dcheck(TNode<Word32T> condition_node,
                             const char* message, const char* file, int line,
                             std::initializer_list<ExtraNode> extra_nodes) {
96#if defined(DEBUG)
if (FLAG_debug_code) {
  Check(condition_node, message, file, line, extra_nodes);
}
100#endif
101}

103void CodeStubAssembler::Check(const BranchGenerator& branch,
                            const char* message, const char* file, int line,
                            std::initializer_list<ExtraNode> extra_nodes) {
Label ok(this);
Label not_ok(this, Label::kDeferred);
if (message != nullptr) {
  Comment("[ Assert: ", message);
} else {
  Comment("[ Assert");
}
branch(&ok, &not_ok);

BIND(&not_ok)Bind(&not_ok);
std::vector<FileAndLine> file_and_line;
if (file != nullptr) {
  file_and_line.push_back({file, line});
}
FailAssert(message, file_and_line, extra_nodes);

BIND(&ok)Bind(&ok);
Comment("] Assert");
124}

126void CodeStubAssembler::Check(const NodeGenerator<BoolT>& condition_body,
                            const char* message, const char* file, int line,
                            std::initializer_list<ExtraNode> extra_nodes) {
BranchGenerator branch = [=](Label* ok, Label* not_ok) {
  TNode<BoolT> condition = condition_body();
  Branch(condition, ok, not_ok);
};

Check(branch, message, file, line, extra_nodes);
135}

137void CodeStubAssembler::Check(TNode<Word32T> condition_node,
                            const char* message, const char* file, int line,
                            std::initializer_list<ExtraNode> extra_nodes) {
BranchGenerator branch = [=](Label* ok, Label* not_ok) {
  Branch(condition_node, ok, not_ok);
};

Check(branch, message, file, line, extra_nodes);
145}

147void CodeStubAssembler::IncrementCallCount(
  TNode<FeedbackVector> feedback_vector, TNode<UintPtrT> slot_id) {
Comment("increment call count");
TNode<Smi> call_count =
    CAST(LoadFeedbackVectorSlot(feedback_vector, slot_id, kTaggedSize))Cast(LoadFeedbackVectorSlot(feedback_vector, slot_id, kTaggedSize
));
// The lowest {FeedbackNexus::CallCountField::kShift} bits of the call
// count are used as flags. To increment the call count by 1 we hence
// have to increment by 1 << {FeedbackNexus::CallCountField::kShift}.
TNode<Smi> new_count = SmiAdd(
    call_count, SmiConstant(1 << FeedbackNexus::CallCountField::kShift));
// Count is Smi, so we don't need a write barrier.
StoreFeedbackVectorSlot(feedback_vector, slot_id, new_count,
                        SKIP_WRITE_BARRIER, kTaggedSize);
160}

162void CodeStubAssembler::FastCheck(TNode<BoolT> condition) {
Label ok(this), not_ok(this, Label::kDeferred);
Branch(condition, &ok, &not_ok);
BIND(&not_ok)Bind(&not_ok);
Unreachable();
BIND(&ok)Bind(&ok);
168}

170void CodeStubAssembler::FailAssert(
  const char* message, const std::vector<FileAndLine>& files_and_lines,
  std::initializer_list<ExtraNode> extra_nodes) {
DCHECK_NOT_NULL(message)((void) 0);
base::EmbeddedVector<char, 1024> chars;
std::stringstream stream;
for (auto it = files_and_lines.rbegin(); it != files_and_lines.rend(); ++it) {
  if (it->first != nullptr) {
    stream << " [" << it->first << ":" << it->second << "]";
179#ifndef DEBUG
    // To limit the size of these strings in release builds, we include only
    // the innermost macro's file name and line number.
    break;
183#endif
  }
}
std::string files_and_lines_text = stream.str();
if (files_and_lines_text.size() != 0) {
  SNPrintF(chars, "%s%s", message, files_and_lines_text.c_str());
  message = chars.begin();
}
TNode<String> message_node = StringConstant(message);

193#ifdef DEBUG
// Only print the extra nodes in debug builds.
for (auto& node : extra_nodes) {
  CallRuntime(Runtime::kPrintWithNameForAssert, SmiConstant(0),
              StringConstant(node.second), node.first);
}
199#endif

AbortCSADcheck(message_node);
Unreachable();
203}

205TNode<Int32T> CodeStubAssembler::SelectInt32Constant(TNode<BoolT> condition,
                                                   int true_value,
                                                   int false_value) {
return SelectConstant<Int32T>(condition, Int32Constant(true_value),
                              Int32Constant(false_value));
210}

212TNode<IntPtrT> CodeStubAssembler::SelectIntPtrConstant(TNode<BoolT> condition,
                                                     int true_value,
                                                     int false_value) {
return SelectConstant<IntPtrT>(condition, IntPtrConstant(true_value),
                               IntPtrConstant(false_value));
217}

219TNode<Oddball> CodeStubAssembler::SelectBooleanConstant(
  TNode<BoolT> condition) {
return SelectConstant<Oddball>(condition, TrueConstant(), FalseConstant());
222}

224TNode<Smi> CodeStubAssembler::SelectSmiConstant(TNode<BoolT> condition,
                                              Smi true_value,
                                              Smi false_value) {
return SelectConstant<Smi>(condition, SmiConstant(true_value),
                           SmiConstant(false_value));
229}

231TNode<Smi> CodeStubAssembler::NoContextConstant() {
return SmiConstant(Context::kNoContext);
233}

235#define HEAP_CONSTANT_ACCESSOR(rootIndexName, rootAccessorName, name)        \
TNode<std::remove_pointer<std::remove_reference<decltype(                  \
    std::declval<Heap>().rootAccessorName())>::type>::type>                \
    CodeStubAssembler::name##Constant() {                                  \
  return UncheckedCast<std::remove_pointer<std::remove_reference<decltype( \
      std::declval<Heap>().rootAccessorName())>::type>::type>(             \
      LoadRoot(RootIndex::k##rootIndexName));                              \
}
243HEAP_MUTABLE_IMMOVABLE_OBJECT_LIST(HEAP_CONSTANT_ACCESSOR)HEAP_CONSTANT_ACCESSOR(ArrayIteratorProtector, array_iterator_protector
, ArrayIteratorProtector) HEAP_CONSTANT_ACCESSOR(ArraySpeciesProtector
, array_species_protector, ArraySpeciesProtector) HEAP_CONSTANT_ACCESSOR
(AsyncFunctionAwaitRejectSharedFun, async_function_await_reject_shared_fun
, AsyncFunctionAwaitRejectSharedFun) HEAP_CONSTANT_ACCESSOR(AsyncFunctionAwaitResolveSharedFun
, async_function_await_resolve_shared_fun, AsyncFunctionAwaitResolveSharedFun
) HEAP_CONSTANT_ACCESSOR(AsyncGeneratorAwaitRejectSharedFun, async_generator_await_reject_shared_fun
, AsyncGeneratorAwaitRejectSharedFun) HEAP_CONSTANT_ACCESSOR(
AsyncGeneratorAwaitResolveSharedFun, async_generator_await_resolve_shared_fun
, AsyncGeneratorAwaitResolveSharedFun) HEAP_CONSTANT_ACCESSOR
(AsyncGeneratorReturnClosedRejectSharedFun, async_generator_return_closed_reject_shared_fun
, AsyncGeneratorReturnClosedRejectSharedFun) HEAP_CONSTANT_ACCESSOR
(AsyncGeneratorReturnClosedResolveSharedFun, async_generator_return_closed_resolve_shared_fun
, AsyncGeneratorReturnClosedResolveSharedFun) HEAP_CONSTANT_ACCESSOR
(AsyncGeneratorReturnResolveSharedFun, async_generator_return_resolve_shared_fun
, AsyncGeneratorReturnResolveSharedFun) HEAP_CONSTANT_ACCESSOR
(AsyncGeneratorYieldResolveSharedFun, async_generator_yield_resolve_shared_fun
, AsyncGeneratorYieldResolveSharedFun) HEAP_CONSTANT_ACCESSOR
(AsyncIteratorValueUnwrapSharedFun, async_iterator_value_unwrap_shared_fun
, AsyncIteratorValueUnwrapSharedFun) HEAP_CONSTANT_ACCESSOR(IsConcatSpreadableProtector
, is_concat_spreadable_protector, IsConcatSpreadableProtector
) HEAP_CONSTANT_ACCESSOR(MapIteratorProtector, map_iterator_protector
, MapIteratorProtector) HEAP_CONSTANT_ACCESSOR(NoElementsProtector
, no_elements_protector, NoElementsProtector) HEAP_CONSTANT_ACCESSOR
(MegaDOMProtector, mega_dom_protector, MegaDOMProtector) HEAP_CONSTANT_ACCESSOR
(NumberStringCache, number_string_cache, NumberStringCache) HEAP_CONSTANT_ACCESSOR
(PromiseAllResolveElementSharedFun, promise_all_resolve_element_shared_fun
, PromiseAllResolveElementSharedFun) HEAP_CONSTANT_ACCESSOR(PromiseAllSettledRejectElementSharedFun
, promise_all_settled_reject_element_shared_fun, PromiseAllSettledRejectElementSharedFun
) HEAP_CONSTANT_ACCESSOR(PromiseAllSettledResolveElementSharedFun
, promise_all_settled_resolve_element_shared_fun, PromiseAllSettledResolveElementSharedFun
) HEAP_CONSTANT_ACCESSOR(PromiseAnyRejectElementSharedFun, promise_any_reject_element_shared_fun
, PromiseAnyRejectElementSharedFun) HEAP_CONSTANT_ACCESSOR(PromiseCapabilityDefaultRejectSharedFun
, promise_capability_default_reject_shared_fun, PromiseCapabilityDefaultRejectSharedFun
) HEAP_CONSTANT_ACCESSOR(PromiseCapabilityDefaultResolveSharedFun
, promise_capability_default_resolve_shared_fun, PromiseCapabilityDefaultResolveSharedFun
) HEAP_CONSTANT_ACCESSOR(PromiseCatchFinallySharedFun, promise_catch_finally_shared_fun
, PromiseCatchFinallySharedFun) HEAP_CONSTANT_ACCESSOR(PromiseGetCapabilitiesExecutorSharedFun
, promise_get_capabilities_executor_shared_fun, PromiseGetCapabilitiesExecutorSharedFun
) HEAP_CONSTANT_ACCESSOR(PromiseResolveProtector, promise_resolve_protector
, PromiseResolveProtector) HEAP_CONSTANT_ACCESSOR(PromiseSpeciesProtector
, promise_species_protector, PromiseSpeciesProtector) HEAP_CONSTANT_ACCESSOR
(PromiseThenFinallySharedFun, promise_then_finally_shared_fun
, PromiseThenFinallySharedFun) HEAP_CONSTANT_ACCESSOR(PromiseThenProtector
, promise_then_protector, PromiseThenProtector) HEAP_CONSTANT_ACCESSOR
(PromiseThrowerFinallySharedFun, promise_thrower_finally_shared_fun
, PromiseThrowerFinallySharedFun) HEAP_CONSTANT_ACCESSOR(PromiseValueThunkFinallySharedFun
, promise_value_thunk_finally_shared_fun, PromiseValueThunkFinallySharedFun
) HEAP_CONSTANT_ACCESSOR(ProxyRevokeSharedFun, proxy_revoke_shared_fun
, ProxyRevokeSharedFun) HEAP_CONSTANT_ACCESSOR(RegExpSpeciesProtector
, regexp_species_protector, RegExpSpeciesProtector) HEAP_CONSTANT_ACCESSOR
(SetIteratorProtector, set_iterator_protector, SetIteratorProtector
) HEAP_CONSTANT_ACCESSOR(SingleCharacterStringCache, single_character_string_cache
, SingleCharacterStringCache) HEAP_CONSTANT_ACCESSOR(StringIteratorProtector
, string_iterator_protector, StringIteratorProtector) HEAP_CONSTANT_ACCESSOR
(TypedArraySpeciesProtector, typed_array_species_protector, TypedArraySpeciesProtector
)
244#undef HEAP_CONSTANT_ACCESSOR

246#define HEAP_CONSTANT_ACCESSOR(rootIndexName, rootAccessorName, name)        \
TNode<std::remove_pointer<std::remove_reference<decltype(                  \
    std::declval<ReadOnlyRoots>().rootAccessorName())>::type>::type>       \
    CodeStubAssembler::name##Constant() {                                  \
  return UncheckedCast<std::remove_pointer<std::remove_reference<decltype( \
      std::declval<ReadOnlyRoots>().rootAccessorName())>::type>::type>(    \
      LoadRoot(RootIndex::k##rootIndexName));                              \
}
254HEAP_IMMUTABLE_IMMOVABLE_OBJECT_LIST(HEAP_CONSTANT_ACCESSOR)HEAP_CONSTANT_ACCESSOR(AllocationSiteWithoutWeakNextMap, allocation_site_without_weaknext_map
, AllocationSiteWithoutWeakNextMap) HEAP_CONSTANT_ACCESSOR(AllocationSiteWithWeakNextMap
, allocation_site_map, AllocationSiteMap) HEAP_CONSTANT_ACCESSOR
(arguments_to_string, arguments_to_string, ArgumentsToString)
 HEAP_CONSTANT_ACCESSOR(Array_string, Array_string, ArrayString
) HEAP_CONSTANT_ACCESSOR(array_to_string, array_to_string, ArrayToString
) HEAP_CONSTANT_ACCESSOR(BooleanMap, boolean_map, BooleanMap)
 HEAP_CONSTANT_ACCESSOR(boolean_to_string, boolean_to_string,
 BooleanToString) HEAP_CONSTANT_ACCESSOR(ConsOneByteStringMap
, cons_one_byte_string_map, ConsOneByteStringMap) HEAP_CONSTANT_ACCESSOR
(ConsStringMap, cons_string_map, ConsStringMap) HEAP_CONSTANT_ACCESSOR
(constructor_string, constructor_string, ConstructorString) HEAP_CONSTANT_ACCESSOR
(date_to_string, date_to_string, DateToString) HEAP_CONSTANT_ACCESSOR
(default_string, default_string, DefaultString) HEAP_CONSTANT_ACCESSOR
(EmptyByteArray, empty_byte_array, EmptyByteArray) HEAP_CONSTANT_ACCESSOR
(EmptyFixedArray, empty_fixed_array, EmptyFixedArray) HEAP_CONSTANT_ACCESSOR
(EmptyScopeInfo, empty_scope_info, EmptyScopeInfo) HEAP_CONSTANT_ACCESSOR
(EmptyPropertyDictionary, empty_property_dictionary, EmptyPropertyDictionary
) HEAP_CONSTANT_ACCESSOR(EmptyOrderedPropertyDictionary, empty_ordered_property_dictionary
, EmptyOrderedPropertyDictionary) HEAP_CONSTANT_ACCESSOR(EmptySwissPropertyDictionary
, empty_swiss_property_dictionary, EmptySwissPropertyDictionary
) HEAP_CONSTANT_ACCESSOR(EmptySlowElementDictionary, empty_slow_element_dictionary
, EmptySlowElementDictionary) HEAP_CONSTANT_ACCESSOR(empty_string
, empty_string, EmptyString) HEAP_CONSTANT_ACCESSOR(error_to_string
, error_to_string, ErrorToString) HEAP_CONSTANT_ACCESSOR(errors_string
, errors_string, ErrorsString) HEAP_CONSTANT_ACCESSOR(FalseValue
, false_value, False) HEAP_CONSTANT_ACCESSOR(FixedArrayMap, fixed_array_map
, FixedArrayMap) HEAP_CONSTANT_ACCESSOR(FixedCOWArrayMap, fixed_cow_array_map
, FixedCOWArrayMap) HEAP_CONSTANT_ACCESSOR(Function_string, function_string
, FunctionString) HEAP_CONSTANT_ACCESSOR(function_to_string, function_to_string
, FunctionToString) HEAP_CONSTANT_ACCESSOR(GlobalPropertyCellMap
, global_property_cell_map, PropertyCellMap) HEAP_CONSTANT_ACCESSOR
(has_instance_symbol, has_instance_symbol, HasInstanceSymbol)
 HEAP_CONSTANT_ACCESSOR(Infinity_string, Infinity_string, InfinityString
) HEAP_CONSTANT_ACCESSOR(is_concat_spreadable_symbol, is_concat_spreadable_symbol
, IsConcatSpreadableSymbol) HEAP_CONSTANT_ACCESSOR(iterator_symbol
, iterator_symbol, IteratorSymbol) HEAP_CONSTANT_ACCESSOR(length_string
, length_string, LengthString) HEAP_CONSTANT_ACCESSOR(ManyClosuresCellMap
, many_closures_cell_map, ManyClosuresCellMap) HEAP_CONSTANT_ACCESSOR
(match_symbol, match_symbol, MatchSymbol) HEAP_CONSTANT_ACCESSOR
(megamorphic_symbol, megamorphic_symbol, MegamorphicSymbol) HEAP_CONSTANT_ACCESSOR
(mega_dom_symbol, mega_dom_symbol, MegaDOMSymbol) HEAP_CONSTANT_ACCESSOR
(message_string, message_string, MessageString) HEAP_CONSTANT_ACCESSOR
(minus_Infinity_string, minus_Infinity_string, MinusInfinityString
) HEAP_CONSTANT_ACCESSOR(MinusZeroValue, minus_zero_value, MinusZero
) HEAP_CONSTANT_ACCESSOR(name_string, name_string, NameString
) HEAP_CONSTANT_ACCESSOR(NanValue, nan_value, Nan) HEAP_CONSTANT_ACCESSOR
(NaN_string, NaN_string, NaNString) HEAP_CONSTANT_ACCESSOR(next_string
, next_string, NextString) HEAP_CONSTANT_ACCESSOR(NoClosuresCellMap
, no_closures_cell_map, NoClosuresCellMap) HEAP_CONSTANT_ACCESSOR
(null_to_string, null_to_string, NullToString) HEAP_CONSTANT_ACCESSOR
(NullValue, null_value, Null) HEAP_CONSTANT_ACCESSOR(number_string
, number_string, NumberString) HEAP_CONSTANT_ACCESSOR(number_to_string
, number_to_string, NumberToString) HEAP_CONSTANT_ACCESSOR(Object_string
, Object_string, ObjectString) HEAP_CONSTANT_ACCESSOR(object_to_string
, object_to_string, ObjectToString) HEAP_CONSTANT_ACCESSOR(OneByteStringMap
, one_byte_string_map, OneByteStringMap) HEAP_CONSTANT_ACCESSOR
(OneClosureCellMap, one_closure_cell_map, OneClosureCellMap) HEAP_CONSTANT_ACCESSOR
(OnePointerFillerMap, one_pointer_filler_map, OnePointerFillerMap
) HEAP_CONSTANT_ACCESSOR(PromiseCapabilityMap, promise_capability_map
, PromiseCapabilityMap) HEAP_CONSTANT_ACCESSOR(promise_forwarding_handler_symbol
, promise_forwarding_handler_symbol, PromiseForwardingHandlerSymbol
) HEAP_CONSTANT_ACCESSOR(PromiseFulfillReactionJobTaskMap, promise_fulfill_reaction_job_task_map
, PromiseFulfillReactionJobTaskMap) HEAP_CONSTANT_ACCESSOR(promise_handled_by_symbol
, promise_handled_by_symbol, PromiseHandledBySymbol) HEAP_CONSTANT_ACCESSOR
(PromiseReactionMap, promise_reaction_map, PromiseReactionMap
) HEAP_CONSTANT_ACCESSOR(PromiseRejectReactionJobTaskMap, promise_reject_reaction_job_task_map
, PromiseRejectReactionJobTaskMap) HEAP_CONSTANT_ACCESSOR(PromiseResolveThenableJobTaskMap
, promise_resolve_thenable_job_task_map, PromiseResolveThenableJobTaskMap
) HEAP_CONSTANT_ACCESSOR(prototype_string, prototype_string, PrototypeString
) HEAP_CONSTANT_ACCESSOR(replace_symbol, replace_symbol, ReplaceSymbol
) HEAP_CONSTANT_ACCESSOR(regexp_to_string, regexp_to_string, RegexpToString
) HEAP_CONSTANT_ACCESSOR(resolve_string, resolve_string, ResolveString
) HEAP_CONSTANT_ACCESSOR(return_string, return_string, ReturnString
) HEAP_CONSTANT_ACCESSOR(search_symbol, search_symbol, SearchSymbol
) HEAP_CONSTANT_ACCESSOR(species_symbol, species_symbol, SpeciesSymbol
) HEAP_CONSTANT_ACCESSOR(StaleRegister, stale_register, StaleRegister
) HEAP_CONSTANT_ACCESSOR(StoreHandler0Map, store_handler0_map
, StoreHandler0Map) HEAP_CONSTANT_ACCESSOR(string_string, string_string
, StringString) HEAP_CONSTANT_ACCESSOR(string_to_string, string_to_string
, StringToString) HEAP_CONSTANT_ACCESSOR(StringMap, string_map
, StringMap) HEAP_CONSTANT_ACCESSOR(TheHoleValue, the_hole_value
, TheHole) HEAP_CONSTANT_ACCESSOR(then_string, then_string, ThenString
) HEAP_CONSTANT_ACCESSOR(toString_string, toString_string, ToStringString
) HEAP_CONSTANT_ACCESSOR(to_primitive_symbol, to_primitive_symbol
, ToPrimitiveSymbol) HEAP_CONSTANT_ACCESSOR(to_string_tag_symbol
, to_string_tag_symbol, ToStringTagSymbol) HEAP_CONSTANT_ACCESSOR
(TrueValue, true_value, True) HEAP_CONSTANT_ACCESSOR(undefined_to_string
, undefined_to_string, UndefinedToString) HEAP_CONSTANT_ACCESSOR
(UndefinedValue, undefined_value, Undefined) HEAP_CONSTANT_ACCESSOR
(uninitialized_symbol, uninitialized_symbol, UninitializedSymbol
) HEAP_CONSTANT_ACCESSOR(valueOf_string, valueOf_string, ValueOfString
) HEAP_CONSTANT_ACCESSOR(wasm_wrapped_object_symbol, wasm_wrapped_object_symbol
, WasmWrappedObjectSymbol) HEAP_CONSTANT_ACCESSOR(zero_string
, zero_string, ZeroString) HEAP_CONSTANT_ACCESSOR(AccessorInfoMap
, accessor_info_map, AccessorInfoMap) HEAP_CONSTANT_ACCESSOR(
AccessorPairMap, accessor_pair_map, AccessorPairMap) HEAP_CONSTANT_ACCESSOR
(AllocationMementoMap, allocation_memento_map, AllocationMementoMap
) HEAP_CONSTANT_ACCESSOR(ArrayBoilerplateDescriptionMap, array_boilerplate_description_map
, ArrayBoilerplateDescriptionMap) HEAP_CONSTANT_ACCESSOR(BreakPointMap
, break_point_map, BreakPointMap) HEAP_CONSTANT_ACCESSOR(BreakPointInfoMap
, break_point_info_map, BreakPointInfoMap) HEAP_CONSTANT_ACCESSOR
(BytecodeArrayMap, bytecode_array_map, BytecodeArrayMap) HEAP_CONSTANT_ACCESSOR
(CachedTemplateObjectMap, cached_template_object_map, CachedTemplateObjectMap
) HEAP_CONSTANT_ACCESSOR(CellMap, cell_map, CellMap) HEAP_CONSTANT_ACCESSOR
(WeakCellMap, weak_cell_map, WeakCellMap) HEAP_CONSTANT_ACCESSOR
(CodeMap, code_map, CodeMap) HEAP_CONSTANT_ACCESSOR(CodeDataContainerMap
, code_data_container_map, CodeDataContainerMap) HEAP_CONSTANT_ACCESSOR
(CoverageInfoMap, coverage_info_map, CoverageInfoMap) HEAP_CONSTANT_ACCESSOR
(DebugInfoMap, debug_info_map, DebugInfoMap) HEAP_CONSTANT_ACCESSOR
(FreeSpaceMap, free_space_map, FreeSpaceMap) HEAP_CONSTANT_ACCESSOR
(FeedbackVectorMap, feedback_vector_map, FeedbackVectorMap) HEAP_CONSTANT_ACCESSOR
(FixedDoubleArrayMap, fixed_double_array_map, FixedDoubleArrayMap
) HEAP_CONSTANT_ACCESSOR(FunctionTemplateInfoMap, function_template_info_map
, FunctionTemplateInfoMap) HEAP_CONSTANT_ACCESSOR(MegaDomHandlerMap
, mega_dom_handler_map, MegaDomHandlerMap) HEAP_CONSTANT_ACCESSOR
(MetaMap, meta_map, MapMap) HEAP_CONSTANT_ACCESSOR(PreparseDataMap
, preparse_data_map, PreparseDataMap) HEAP_CONSTANT_ACCESSOR(
PropertyArrayMap, property_array_map, PropertyArrayMap) HEAP_CONSTANT_ACCESSOR
(PrototypeInfoMap, prototype_info_map, PrototypeInfoMap) HEAP_CONSTANT_ACCESSOR
(SharedFunctionInfoMap, shared_function_info_map, SharedFunctionInfoMap
) HEAP_CONSTANT_ACCESSOR(SmallOrderedHashSetMap, small_ordered_hash_set_map
, SmallOrderedHashSetMap) HEAP_CONSTANT_ACCESSOR(SmallOrderedHashMapMap
, small_ordered_hash_map_map, SmallOrderedHashMapMap) HEAP_CONSTANT_ACCESSOR
(SmallOrderedNameDictionaryMap, small_ordered_name_dictionary_map
, SmallOrderedNameDictionaryMap) HEAP_CONSTANT_ACCESSOR(SwissNameDictionaryMap
, swiss_name_dictionary_map, SwissNameDictionaryMap) HEAP_CONSTANT_ACCESSOR
(SymbolMap, symbol_map, SymbolMap) HEAP_CONSTANT_ACCESSOR(TransitionArrayMap
, transition_array_map, TransitionArrayMap) HEAP_CONSTANT_ACCESSOR
(Tuple2Map, tuple2_map, Tuple2Map) HEAP_CONSTANT_ACCESSOR(HeapNumberMap
, heap_number_map, HeapNumberMap) HEAP_CONSTANT_ACCESSOR(WeakFixedArrayMap
, weak_fixed_array_map, WeakFixedArrayMap) HEAP_CONSTANT_ACCESSOR
(SloppyArgumentsElementsMap, sloppy_arguments_elements_map, SloppyArgumentsElementsMap
) HEAP_CONSTANT_ACCESSOR(DescriptorArrayMap, descriptor_array_map
, DescriptorArrayMap) HEAP_CONSTANT_ACCESSOR(StrongDescriptorArrayMap
, strong_descriptor_array_map, StrongDescriptorArrayMap) HEAP_CONSTANT_ACCESSOR
(UncompiledDataWithoutPreparseDataMap, uncompiled_data_without_preparse_data_map
, UncompiledDataWithoutPreparseDataMap) HEAP_CONSTANT_ACCESSOR
(UncompiledDataWithPreparseDataMap, uncompiled_data_with_preparse_data_map
, UncompiledDataWithPreparseDataMap) HEAP_CONSTANT_ACCESSOR(UncompiledDataWithoutPreparseDataWithJobMap
, uncompiled_data_without_preparse_data_with_job_map, UncompiledDataWithoutPreparseDataWithJobMap
) HEAP_CONSTANT_ACCESSOR(UncompiledDataWithPreparseDataAndJobMap
, uncompiled_data_with_preparse_data_and_job_map, UncompiledDataWithPreparseDataAndJobMap
) HEAP_CONSTANT_ACCESSOR(OnHeapBasicBlockProfilerDataMap, on_heap_basic_block_profiler_data_map
, OnHeapBasicBlockProfilerDataMap) HEAP_CONSTANT_ACCESSOR(TurbofanBitsetTypeMap
, turbofan_bitset_type_map, TurbofanBitsetTypeMap) HEAP_CONSTANT_ACCESSOR
(TurbofanUnionTypeMap, turbofan_union_type_map, TurbofanUnionTypeMap
) HEAP_CONSTANT_ACCESSOR(TurbofanRangeTypeMap, turbofan_range_type_map
, TurbofanRangeTypeMap) HEAP_CONSTANT_ACCESSOR(TurbofanHeapConstantTypeMap
, turbofan_heap_constant_type_map, TurbofanHeapConstantTypeMap
) HEAP_CONSTANT_ACCESSOR(TurbofanOtherNumberConstantTypeMap, turbofan_other_number_constant_type_map
, TurbofanOtherNumberConstantTypeMap) HEAP_CONSTANT_ACCESSOR(
InternalClassMap, internal_class_map, InternalClassMap) HEAP_CONSTANT_ACCESSOR
(SmiPairMap, smi_pair_map, SmiPairMap) HEAP_CONSTANT_ACCESSOR
(SmiBoxMap, smi_box_map, SmiBoxMap) HEAP_CONSTANT_ACCESSOR(ExportedSubClassBaseMap
, exported_sub_class_base_map, ExportedSubClassBaseMap) HEAP_CONSTANT_ACCESSOR
(ExportedSubClassMap, exported_sub_class_map, ExportedSubClassMap
) HEAP_CONSTANT_ACCESSOR(AbstractInternalClassSubclass1Map, abstract_internal_class_subclass1_map
, AbstractInternalClassSubclass1Map) HEAP_CONSTANT_ACCESSOR(AbstractInternalClassSubclass2Map
, abstract_internal_class_subclass2_map, AbstractInternalClassSubclass2Map
) HEAP_CONSTANT_ACCESSOR(InternalClassWithSmiElementsMap, internal_class_with_smi_elements_map
, InternalClassWithSmiElementsMap) HEAP_CONSTANT_ACCESSOR(InternalClassWithStructElementsMap
, internal_class_with_struct_elements_map, InternalClassWithStructElementsMap
) HEAP_CONSTANT_ACCESSOR(ExportedSubClass2Map, exported_sub_class2_map
, ExportedSubClass2Map) HEAP_CONSTANT_ACCESSOR(SortStateMap, sort_state_map
, SortStateMap)
255#undef HEAP_CONSTANT_ACCESSOR

257#define HEAP_CONSTANT_TEST(rootIndexName, rootAccessorName, name)    \
TNode<BoolT> CodeStubAssembler::Is##name(TNode<Object> value) {    \
  return TaggedEqual(value, name##Constant());                     \
}                                                                  \
TNode<BoolT> CodeStubAssembler::IsNot##name(TNode<Object> value) { \
  return TaggedNotEqual(value, name##Constant());                  \
}
264HEAP_IMMOVABLE_OBJECT_LIST(HEAP_CONSTANT_TEST)HEAP_CONSTANT_TEST(ArrayIteratorProtector, array_iterator_protector
, ArrayIteratorProtector) HEAP_CONSTANT_TEST(ArraySpeciesProtector
, array_species_protector, ArraySpeciesProtector) HEAP_CONSTANT_TEST
(AsyncFunctionAwaitRejectSharedFun, async_function_await_reject_shared_fun
, AsyncFunctionAwaitRejectSharedFun) HEAP_CONSTANT_TEST(AsyncFunctionAwaitResolveSharedFun
, async_function_await_resolve_shared_fun, AsyncFunctionAwaitResolveSharedFun
) HEAP_CONSTANT_TEST(AsyncGeneratorAwaitRejectSharedFun, async_generator_await_reject_shared_fun
, AsyncGeneratorAwaitRejectSharedFun) HEAP_CONSTANT_TEST(AsyncGeneratorAwaitResolveSharedFun
, async_generator_await_resolve_shared_fun, AsyncGeneratorAwaitResolveSharedFun
) HEAP_CONSTANT_TEST(AsyncGeneratorReturnClosedRejectSharedFun
, async_generator_return_closed_reject_shared_fun, AsyncGeneratorReturnClosedRejectSharedFun
) HEAP_CONSTANT_TEST(AsyncGeneratorReturnClosedResolveSharedFun
, async_generator_return_closed_resolve_shared_fun, AsyncGeneratorReturnClosedResolveSharedFun
) HEAP_CONSTANT_TEST(AsyncGeneratorReturnResolveSharedFun, async_generator_return_resolve_shared_fun
, AsyncGeneratorReturnResolveSharedFun) HEAP_CONSTANT_TEST(AsyncGeneratorYieldResolveSharedFun
, async_generator_yield_resolve_shared_fun, AsyncGeneratorYieldResolveSharedFun
) HEAP_CONSTANT_TEST(AsyncIteratorValueUnwrapSharedFun, async_iterator_value_unwrap_shared_fun
, AsyncIteratorValueUnwrapSharedFun) HEAP_CONSTANT_TEST(IsConcatSpreadableProtector
, is_concat_spreadable_protector, IsConcatSpreadableProtector
) HEAP_CONSTANT_TEST(MapIteratorProtector, map_iterator_protector
, MapIteratorProtector) HEAP_CONSTANT_TEST(NoElementsProtector
, no_elements_protector, NoElementsProtector) HEAP_CONSTANT_TEST
(MegaDOMProtector, mega_dom_protector, MegaDOMProtector) HEAP_CONSTANT_TEST
(NumberStringCache, number_string_cache, NumberStringCache) HEAP_CONSTANT_TEST
(PromiseAllResolveElementSharedFun, promise_all_resolve_element_shared_fun
, PromiseAllResolveElementSharedFun) HEAP_CONSTANT_TEST(PromiseAllSettledRejectElementSharedFun
, promise_all_settled_reject_element_shared_fun, PromiseAllSettledRejectElementSharedFun
) HEAP_CONSTANT_TEST(PromiseAllSettledResolveElementSharedFun
, promise_all_settled_resolve_element_shared_fun, PromiseAllSettledResolveElementSharedFun
) HEAP_CONSTANT_TEST(PromiseAnyRejectElementSharedFun, promise_any_reject_element_shared_fun
, PromiseAnyRejectElementSharedFun) HEAP_CONSTANT_TEST(PromiseCapabilityDefaultRejectSharedFun
, promise_capability_default_reject_shared_fun, PromiseCapabilityDefaultRejectSharedFun
) HEAP_CONSTANT_TEST(PromiseCapabilityDefaultResolveSharedFun
, promise_capability_default_resolve_shared_fun, PromiseCapabilityDefaultResolveSharedFun
) HEAP_CONSTANT_TEST(PromiseCatchFinallySharedFun, promise_catch_finally_shared_fun
, PromiseCatchFinallySharedFun) HEAP_CONSTANT_TEST(PromiseGetCapabilitiesExecutorSharedFun
, promise_get_capabilities_executor_shared_fun, PromiseGetCapabilitiesExecutorSharedFun
) HEAP_CONSTANT_TEST(PromiseResolveProtector, promise_resolve_protector
, PromiseResolveProtector) HEAP_CONSTANT_TEST(PromiseSpeciesProtector
, promise_species_protector, PromiseSpeciesProtector) HEAP_CONSTANT_TEST
(PromiseThenFinallySharedFun, promise_then_finally_shared_fun
, PromiseThenFinallySharedFun) HEAP_CONSTANT_TEST(PromiseThenProtector
, promise_then_protector, PromiseThenProtector) HEAP_CONSTANT_TEST
(PromiseThrowerFinallySharedFun, promise_thrower_finally_shared_fun
, PromiseThrowerFinallySharedFun) HEAP_CONSTANT_TEST(PromiseValueThunkFinallySharedFun
, promise_value_thunk_finally_shared_fun, PromiseValueThunkFinallySharedFun
) HEAP_CONSTANT_TEST(ProxyRevokeSharedFun, proxy_revoke_shared_fun
, ProxyRevokeSharedFun) HEAP_CONSTANT_TEST(RegExpSpeciesProtector
, regexp_species_protector, RegExpSpeciesProtector) HEAP_CONSTANT_TEST
(SetIteratorProtector, set_iterator_protector, SetIteratorProtector
) HEAP_CONSTANT_TEST(SingleCharacterStringCache, single_character_string_cache
, SingleCharacterStringCache) HEAP_CONSTANT_TEST(StringIteratorProtector
, string_iterator_protector, StringIteratorProtector) HEAP_CONSTANT_TEST
(TypedArraySpeciesProtector, typed_array_species_protector, TypedArraySpeciesProtector
) HEAP_CONSTANT_TEST(AllocationSiteWithoutWeakNextMap, allocation_site_without_weaknext_map
, AllocationSiteWithoutWeakNextMap) HEAP_CONSTANT_TEST(AllocationSiteWithWeakNextMap
, allocation_site_map, AllocationSiteMap) HEAP_CONSTANT_TEST(
arguments_to_string, arguments_to_string, ArgumentsToString) HEAP_CONSTANT_TEST
(Array_string, Array_string, ArrayString) HEAP_CONSTANT_TEST(
array_to_string, array_to_string, ArrayToString) HEAP_CONSTANT_TEST
(BooleanMap, boolean_map, BooleanMap) HEAP_CONSTANT_TEST(boolean_to_string
, boolean_to_string, BooleanToString) HEAP_CONSTANT_TEST(ConsOneByteStringMap
, cons_one_byte_string_map, ConsOneByteStringMap) HEAP_CONSTANT_TEST
(ConsStringMap, cons_string_map, ConsStringMap) HEAP_CONSTANT_TEST
(constructor_string, constructor_string, ConstructorString) HEAP_CONSTANT_TEST
(date_to_string, date_to_string, DateToString) HEAP_CONSTANT_TEST
(default_string, default_string, DefaultString) HEAP_CONSTANT_TEST
(EmptyByteArray, empty_byte_array, EmptyByteArray) HEAP_CONSTANT_TEST
(EmptyFixedArray, empty_fixed_array, EmptyFixedArray) HEAP_CONSTANT_TEST
(EmptyScopeInfo, empty_scope_info, EmptyScopeInfo) HEAP_CONSTANT_TEST
(EmptyPropertyDictionary, empty_property_dictionary, EmptyPropertyDictionary
) HEAP_CONSTANT_TEST(EmptyOrderedPropertyDictionary, empty_ordered_property_dictionary
, EmptyOrderedPropertyDictionary) HEAP_CONSTANT_TEST(EmptySwissPropertyDictionary
, empty_swiss_property_dictionary, EmptySwissPropertyDictionary
) HEAP_CONSTANT_TEST(EmptySlowElementDictionary, empty_slow_element_dictionary
, EmptySlowElementDictionary) HEAP_CONSTANT_TEST(empty_string
, empty_string, EmptyString) HEAP_CONSTANT_TEST(error_to_string
, error_to_string, ErrorToString) HEAP_CONSTANT_TEST(errors_string
, errors_string, ErrorsString) HEAP_CONSTANT_TEST(FalseValue,
 false_value, False) HEAP_CONSTANT_TEST(FixedArrayMap, fixed_array_map
, FixedArrayMap) HEAP_CONSTANT_TEST(FixedCOWArrayMap, fixed_cow_array_map
, FixedCOWArrayMap) HEAP_CONSTANT_TEST(Function_string, function_string
, FunctionString) HEAP_CONSTANT_TEST(function_to_string, function_to_string
, FunctionToString) HEAP_CONSTANT_TEST(GlobalPropertyCellMap,
 global_property_cell_map, PropertyCellMap) HEAP_CONSTANT_TEST
(has_instance_symbol, has_instance_symbol, HasInstanceSymbol)
 HEAP_CONSTANT_TEST(Infinity_string, Infinity_string, InfinityString
) HEAP_CONSTANT_TEST(is_concat_spreadable_symbol, is_concat_spreadable_symbol
, IsConcatSpreadableSymbol) HEAP_CONSTANT_TEST(iterator_symbol
, iterator_symbol, IteratorSymbol) HEAP_CONSTANT_TEST(length_string
, length_string, LengthString) HEAP_CONSTANT_TEST(ManyClosuresCellMap
, many_closures_cell_map, ManyClosuresCellMap) HEAP_CONSTANT_TEST
(match_symbol, match_symbol, MatchSymbol) HEAP_CONSTANT_TEST(
megamorphic_symbol, megamorphic_symbol, MegamorphicSymbol) HEAP_CONSTANT_TEST
(mega_dom_symbol, mega_dom_symbol, MegaDOMSymbol) HEAP_CONSTANT_TEST
(message_string, message_string, MessageString) HEAP_CONSTANT_TEST
(minus_Infinity_string, minus_Infinity_string, MinusInfinityString
) HEAP_CONSTANT_TEST(MinusZeroValue, minus_zero_value, MinusZero
) HEAP_CONSTANT_TEST(name_string, name_string, NameString) HEAP_CONSTANT_TEST
(NanValue, nan_value, Nan) HEAP_CONSTANT_TEST(NaN_string, NaN_string
, NaNString) HEAP_CONSTANT_TEST(next_string, next_string, NextString
) HEAP_CONSTANT_TEST(NoClosuresCellMap, no_closures_cell_map,
 NoClosuresCellMap) HEAP_CONSTANT_TEST(null_to_string, null_to_string
, NullToString) HEAP_CONSTANT_TEST(NullValue, null_value, Null
) HEAP_CONSTANT_TEST(number_string, number_string, NumberString
) HEAP_CONSTANT_TEST(number_to_string, number_to_string, NumberToString
) HEAP_CONSTANT_TEST(Object_string, Object_string, ObjectString
) HEAP_CONSTANT_TEST(object_to_string, object_to_string, ObjectToString
) HEAP_CONSTANT_TEST(OneByteStringMap, one_byte_string_map, OneByteStringMap
) HEAP_CONSTANT_TEST(OneClosureCellMap, one_closure_cell_map,
 OneClosureCellMap) HEAP_CONSTANT_TEST(OnePointerFillerMap, one_pointer_filler_map
, OnePointerFillerMap) HEAP_CONSTANT_TEST(PromiseCapabilityMap
, promise_capability_map, PromiseCapabilityMap) HEAP_CONSTANT_TEST
(promise_forwarding_handler_symbol, promise_forwarding_handler_symbol
, PromiseForwardingHandlerSymbol) HEAP_CONSTANT_TEST(PromiseFulfillReactionJobTaskMap
, promise_fulfill_reaction_job_task_map, PromiseFulfillReactionJobTaskMap
) HEAP_CONSTANT_TEST(promise_handled_by_symbol, promise_handled_by_symbol
, PromiseHandledBySymbol) HEAP_CONSTANT_TEST(PromiseReactionMap
, promise_reaction_map, PromiseReactionMap) HEAP_CONSTANT_TEST
(PromiseRejectReactionJobTaskMap, promise_reject_reaction_job_task_map
, PromiseRejectReactionJobTaskMap) HEAP_CONSTANT_TEST(PromiseResolveThenableJobTaskMap
, promise_resolve_thenable_job_task_map, PromiseResolveThenableJobTaskMap
) HEAP_CONSTANT_TEST(prototype_string, prototype_string, PrototypeString
) HEAP_CONSTANT_TEST(replace_symbol, replace_symbol, ReplaceSymbol
) HEAP_CONSTANT_TEST(regexp_to_string, regexp_to_string, RegexpToString
) HEAP_CONSTANT_TEST(resolve_string, resolve_string, ResolveString
) HEAP_CONSTANT_TEST(return_string, return_string, ReturnString
) HEAP_CONSTANT_TEST(search_symbol, search_symbol, SearchSymbol
) HEAP_CONSTANT_TEST(species_symbol, species_symbol, SpeciesSymbol
) HEAP_CONSTANT_TEST(StaleRegister, stale_register, StaleRegister
) HEAP_CONSTANT_TEST(StoreHandler0Map, store_handler0_map, StoreHandler0Map
) HEAP_CONSTANT_TEST(string_string, string_string, StringString
) HEAP_CONSTANT_TEST(string_to_string, string_to_string, StringToString
) HEAP_CONSTANT_TEST(StringMap, string_map, StringMap) HEAP_CONSTANT_TEST
(TheHoleValue, the_hole_value, TheHole) HEAP_CONSTANT_TEST(then_string
, then_string, ThenString) HEAP_CONSTANT_TEST(toString_string
, toString_string, ToStringString) HEAP_CONSTANT_TEST(to_primitive_symbol
, to_primitive_symbol, ToPrimitiveSymbol) HEAP_CONSTANT_TEST(
to_string_tag_symbol, to_string_tag_symbol, ToStringTagSymbol
) HEAP_CONSTANT_TEST(TrueValue, true_value, True) HEAP_CONSTANT_TEST
(undefined_to_string, undefined_to_string, UndefinedToString)
 HEAP_CONSTANT_TEST(UndefinedValue, undefined_value, Undefined
) HEAP_CONSTANT_TEST(uninitialized_symbol, uninitialized_symbol
, UninitializedSymbol) HEAP_CONSTANT_TEST(valueOf_string, valueOf_string
, ValueOfString) HEAP_CONSTANT_TEST(wasm_wrapped_object_symbol
, wasm_wrapped_object_symbol, WasmWrappedObjectSymbol) HEAP_CONSTANT_TEST
(zero_string, zero_string, ZeroString) HEAP_CONSTANT_TEST(AccessorInfoMap
, accessor_info_map, AccessorInfoMap) HEAP_CONSTANT_TEST(AccessorPairMap
, accessor_pair_map, AccessorPairMap) HEAP_CONSTANT_TEST(AllocationMementoMap
, allocation_memento_map, AllocationMementoMap) HEAP_CONSTANT_TEST
(ArrayBoilerplateDescriptionMap, array_boilerplate_description_map
, ArrayBoilerplateDescriptionMap) HEAP_CONSTANT_TEST(BreakPointMap
, break_point_map, BreakPointMap) HEAP_CONSTANT_TEST(BreakPointInfoMap
, break_point_info_map, BreakPointInfoMap) HEAP_CONSTANT_TEST
(BytecodeArrayMap, bytecode_array_map, BytecodeArrayMap) HEAP_CONSTANT_TEST
(CachedTemplateObjectMap, cached_template_object_map, CachedTemplateObjectMap
) HEAP_CONSTANT_TEST(CellMap, cell_map, CellMap) HEAP_CONSTANT_TEST
(WeakCellMap, weak_cell_map, WeakCellMap) HEAP_CONSTANT_TEST(
CodeMap, code_map, CodeMap) HEAP_CONSTANT_TEST(CodeDataContainerMap
, code_data_container_map, CodeDataContainerMap) HEAP_CONSTANT_TEST
(CoverageInfoMap, coverage_info_map, CoverageInfoMap) HEAP_CONSTANT_TEST
(DebugInfoMap, debug_info_map, DebugInfoMap) HEAP_CONSTANT_TEST
(FreeSpaceMap, free_space_map, FreeSpaceMap) HEAP_CONSTANT_TEST
(FeedbackVectorMap, feedback_vector_map, FeedbackVectorMap) HEAP_CONSTANT_TEST
(FixedDoubleArrayMap, fixed_double_array_map, FixedDoubleArrayMap
) HEAP_CONSTANT_TEST(FunctionTemplateInfoMap, function_template_info_map
, FunctionTemplateInfoMap) HEAP_CONSTANT_TEST(MegaDomHandlerMap
, mega_dom_handler_map, MegaDomHandlerMap) HEAP_CONSTANT_TEST
(MetaMap, meta_map, MapMap) HEAP_CONSTANT_TEST(PreparseDataMap
, preparse_data_map, PreparseDataMap) HEAP_CONSTANT_TEST(PropertyArrayMap
, property_array_map, PropertyArrayMap) HEAP_CONSTANT_TEST(PrototypeInfoMap
, prototype_info_map, PrototypeInfoMap) HEAP_CONSTANT_TEST(SharedFunctionInfoMap
, shared_function_info_map, SharedFunctionInfoMap) HEAP_CONSTANT_TEST
(SmallOrderedHashSetMap, small_ordered_hash_set_map, SmallOrderedHashSetMap
) HEAP_CONSTANT_TEST(SmallOrderedHashMapMap, small_ordered_hash_map_map
, SmallOrderedHashMapMap) HEAP_CONSTANT_TEST(SmallOrderedNameDictionaryMap
, small_ordered_name_dictionary_map, SmallOrderedNameDictionaryMap
) HEAP_CONSTANT_TEST(SwissNameDictionaryMap, swiss_name_dictionary_map
, SwissNameDictionaryMap) HEAP_CONSTANT_TEST(SymbolMap, symbol_map
, SymbolMap) HEAP_CONSTANT_TEST(TransitionArrayMap, transition_array_map
, TransitionArrayMap) HEAP_CONSTANT_TEST(Tuple2Map, tuple2_map
, Tuple2Map) HEAP_CONSTANT_TEST(HeapNumberMap, heap_number_map
, HeapNumberMap) HEAP_CONSTANT_TEST(WeakFixedArrayMap, weak_fixed_array_map
, WeakFixedArrayMap) HEAP_CONSTANT_TEST(SloppyArgumentsElementsMap
, sloppy_arguments_elements_map, SloppyArgumentsElementsMap) HEAP_CONSTANT_TEST
(DescriptorArrayMap, descriptor_array_map, DescriptorArrayMap
) HEAP_CONSTANT_TEST(StrongDescriptorArrayMap, strong_descriptor_array_map
, StrongDescriptorArrayMap) HEAP_CONSTANT_TEST(UncompiledDataWithoutPreparseDataMap
, uncompiled_data_without_preparse_data_map, UncompiledDataWithoutPreparseDataMap
) HEAP_CONSTANT_TEST(UncompiledDataWithPreparseDataMap, uncompiled_data_with_preparse_data_map
, UncompiledDataWithPreparseDataMap) HEAP_CONSTANT_TEST(UncompiledDataWithoutPreparseDataWithJobMap
, uncompiled_data_without_preparse_data_with_job_map, UncompiledDataWithoutPreparseDataWithJobMap
) HEAP_CONSTANT_TEST(UncompiledDataWithPreparseDataAndJobMap,
 uncompiled_data_with_preparse_data_and_job_map, UncompiledDataWithPreparseDataAndJobMap
) HEAP_CONSTANT_TEST(OnHeapBasicBlockProfilerDataMap, on_heap_basic_block_profiler_data_map
, OnHeapBasicBlockProfilerDataMap) HEAP_CONSTANT_TEST(TurbofanBitsetTypeMap
, turbofan_bitset_type_map, TurbofanBitsetTypeMap) HEAP_CONSTANT_TEST
(TurbofanUnionTypeMap, turbofan_union_type_map, TurbofanUnionTypeMap
) HEAP_CONSTANT_TEST(TurbofanRangeTypeMap, turbofan_range_type_map
, TurbofanRangeTypeMap) HEAP_CONSTANT_TEST(TurbofanHeapConstantTypeMap
, turbofan_heap_constant_type_map, TurbofanHeapConstantTypeMap
) HEAP_CONSTANT_TEST(TurbofanOtherNumberConstantTypeMap, turbofan_other_number_constant_type_map
, TurbofanOtherNumberConstantTypeMap) HEAP_CONSTANT_TEST(InternalClassMap
, internal_class_map, InternalClassMap) HEAP_CONSTANT_TEST(SmiPairMap
, smi_pair_map, SmiPairMap) HEAP_CONSTANT_TEST(SmiBoxMap, smi_box_map
, SmiBoxMap) HEAP_CONSTANT_TEST(ExportedSubClassBaseMap, exported_sub_class_base_map
, ExportedSubClassBaseMap) HEAP_CONSTANT_TEST(ExportedSubClassMap
, exported_sub_class_map, ExportedSubClassMap) HEAP_CONSTANT_TEST
(AbstractInternalClassSubclass1Map, abstract_internal_class_subclass1_map
, AbstractInternalClassSubclass1Map) HEAP_CONSTANT_TEST(AbstractInternalClassSubclass2Map
, abstract_internal_class_subclass2_map, AbstractInternalClassSubclass2Map
) HEAP_CONSTANT_TEST(InternalClassWithSmiElementsMap, internal_class_with_smi_elements_map
, InternalClassWithSmiElementsMap) HEAP_CONSTANT_TEST(InternalClassWithStructElementsMap
, internal_class_with_struct_elements_map, InternalClassWithStructElementsMap
) HEAP_CONSTANT_TEST(ExportedSubClass2Map, exported_sub_class2_map
, ExportedSubClass2Map) HEAP_CONSTANT_TEST(SortStateMap, sort_state_map
, SortStateMap)
265#undef HEAP_CONSTANT_TEST

267TNode<BInt> CodeStubAssembler::BIntConstant(int value) {
268#if defined(BINT_IS_SMI)
return SmiConstant(value);
270#elif defined(BINT_IS_INTPTR)
return IntPtrConstant(value);
272#else
273#error Unknown architecture.
274#endif
275}

277template <>
278TNode<Smi> CodeStubAssembler::IntPtrOrSmiConstant<Smi>(int value) {
return SmiConstant(value);
280}

282template <>
283TNode<IntPtrT> CodeStubAssembler::IntPtrOrSmiConstant<IntPtrT>(int value) {
return IntPtrConstant(value);
285}

287template <>
288TNode<UintPtrT> CodeStubAssembler::IntPtrOrSmiConstant<UintPtrT>(int value) {
return Unsigned(IntPtrConstant(value));
290}

292template <>
293TNode<RawPtrT> CodeStubAssembler::IntPtrOrSmiConstant<RawPtrT>(int value) {
return ReinterpretCast<RawPtrT>(IntPtrConstant(value));
295}

297bool CodeStubAssembler::TryGetIntPtrOrSmiConstantValue(
  TNode<Smi> maybe_constant, int* value) {
Smi smi_constant;
if (TryToSmiConstant(maybe_constant, &smi_constant)) {
  *value = Smi::ToInt(smi_constant);
  return true;
}
return false;
305}

307bool CodeStubAssembler::TryGetIntPtrOrSmiConstantValue(
  TNode<IntPtrT> maybe_constant, int* value) {
int32_t int32_constant;
if (TryToInt32Constant(maybe_constant, &int32_constant)) {
  *value = int32_constant;
  return true;
}
return false;
315}

317TNode<IntPtrT> CodeStubAssembler::IntPtrRoundUpToPowerOfTwo32(
  TNode<IntPtrT> value) {
Comment("IntPtrRoundUpToPowerOfTwo32");
CSA_DCHECK(this, UintPtrLessThanOrEqual(value, IntPtrConstant(0x80000000u)))((void)0);
value = Signed(IntPtrSub(value, IntPtrConstant(1)));
for (int i = 1; i <= 16; i *= 2) {
  value = Signed(WordOr(value, WordShr(value, IntPtrConstant(i))));
}
return Signed(IntPtrAdd(value, IntPtrConstant(1)));
326}

328TNode<BoolT> CodeStubAssembler::WordIsPowerOfTwo(TNode<IntPtrT> value) {
intptr_t constant;
if (TryToIntPtrConstant(value, &constant)) {
  return BoolConstant(base::bits::IsPowerOfTwo(constant));
}
// value && !(value & (value - 1))
return IntPtrEqual(
    Select<IntPtrT>(
        IntPtrEqual(value, IntPtrConstant(0)),
        [=] { return IntPtrConstant(1); },
        [=] { return WordAnd(value, IntPtrSub(value, IntPtrConstant(1))); }),
    IntPtrConstant(0));
340}

342TNode<Float64T> CodeStubAssembler::Float64Round(TNode<Float64T> x) {
TNode<Float64T> one = Float64Constant(1.0);
TNode<Float64T> one_half = Float64Constant(0.5);

Label return_x(this);

// Round up {x} towards Infinity.
TVARIABLE(Float64T, var_x, Float64Ceil(x))TVariable<Float64T> var_x(Float64Ceil(x), this);

GotoIf(Float64LessThanOrEqual(Float64Sub(var_x.value(), one_half), x),
       &return_x);
var_x = Float64Sub(var_x.value(), one);
Goto(&return_x);

BIND(&return_x)Bind(&return_x);
return var_x.value();
358}

360TNode<Float64T> CodeStubAssembler::Float64Ceil(TNode<Float64T> x) {
if (IsFloat64RoundUpSupported()) {
  return Float64RoundUp(x);
}

TNode<Float64T> one = Float64Constant(1.0);
TNode<Float64T> zero = Float64Constant(0.0);
TNode<Float64T> two_52 = Float64Constant(4503599627370496.0E0);
TNode<Float64T> minus_two_52 = Float64Constant(-4503599627370496.0E0);

TVARIABLE(Float64T, var_x, x)TVariable<Float64T> var_x(x, this);
Label return_x(this), return_minus_x(this);

// Check if {x} is greater than zero.
Label if_xgreaterthanzero(this), if_xnotgreaterthanzero(this);
Branch(Float64GreaterThan(x, zero), &if_xgreaterthanzero,
       &if_xnotgreaterthanzero);

BIND(&if_xgreaterthanzero)Bind(&if_xgreaterthanzero);
{
  // Just return {x} unless it's in the range ]0,2^52[.
  GotoIf(Float64GreaterThanOrEqual(x, two_52), &return_x);

  // Round positive {x} towards Infinity.
  var_x = Float64Sub(Float64Add(two_52, x), two_52);
  GotoIfNot(Float64LessThan(var_x.value(), x), &return_x);
  var_x = Float64Add(var_x.value(), one);
  Goto(&return_x);
}

BIND(&if_xnotgreaterthanzero)Bind(&if_xnotgreaterthanzero);
{
  // Just return {x} unless it's in the range ]-2^52,0[
  GotoIf(Float64LessThanOrEqual(x, minus_two_52), &return_x);
  GotoIfNot(Float64LessThan(x, zero), &return_x);

  // Round negated {x} towards Infinity and return the result negated.
  TNode<Float64T> minus_x = Float64Neg(x);
  var_x = Float64Sub(Float64Add(two_52, minus_x), two_52);
  GotoIfNot(Float64GreaterThan(var_x.value(), minus_x), &return_minus_x);
  var_x = Float64Sub(var_x.value(), one);
  Goto(&return_minus_x);
}

BIND(&return_minus_x)Bind(&return_minus_x);
var_x = Float64Neg(var_x.value());
Goto(&return_x);

BIND(&return_x)Bind(&return_x);
return var_x.value();
410}

412TNode<Float64T> CodeStubAssembler::Float64Floor(TNode<Float64T> x) {
if (IsFloat64RoundDownSupported()) {
  return Float64RoundDown(x);
}

TNode<Float64T> one = Float64Constant(1.0);
TNode<Float64T> zero = Float64Constant(0.0);
TNode<Float64T> two_52 = Float64Constant(4503599627370496.0E0);
TNode<Float64T> minus_two_52 = Float64Constant(-4503599627370496.0E0);

TVARIABLE(Float64T, var_x, x)TVariable<Float64T> var_x(x, this);
Label return_x(this), return_minus_x(this);

// Check if {x} is greater than zero.
Label if_xgreaterthanzero(this), if_xnotgreaterthanzero(this);
Branch(Float64GreaterThan(x, zero), &if_xgreaterthanzero,
       &if_xnotgreaterthanzero);

BIND(&if_xgreaterthanzero)Bind(&if_xgreaterthanzero);
{
  // Just return {x} unless it's in the range ]0,2^52[.
  GotoIf(Float64GreaterThanOrEqual(x, two_52), &return_x);

  // Round positive {x} towards -Infinity.
  var_x = Float64Sub(Float64Add(two_52, x), two_52);
  GotoIfNot(Float64GreaterThan(var_x.value(), x), &return_x);
  var_x = Float64Sub(var_x.value(), one);
  Goto(&return_x);
}

BIND(&if_xnotgreaterthanzero)Bind(&if_xnotgreaterthanzero);
{
  // Just return {x} unless it's in the range ]-2^52,0[
  GotoIf(Float64LessThanOrEqual(x, minus_two_52), &return_x);
  GotoIfNot(Float64LessThan(x, zero), &return_x);

  // Round negated {x} towards -Infinity and return the result negated.
  TNode<Float64T> minus_x = Float64Neg(x);
  var_x = Float64Sub(Float64Add(two_52, minus_x), two_52);
  GotoIfNot(Float64LessThan(var_x.value(), minus_x), &return_minus_x);
  var_x = Float64Add(var_x.value(), one);
  Goto(&return_minus_x);
}

BIND(&return_minus_x)Bind(&return_minus_x);
var_x = Float64Neg(var_x.value());
Goto(&return_x);

BIND(&return_x)Bind(&return_x);
return var_x.value();
462}

464TNode<Float64T> CodeStubAssembler::Float64RoundToEven(TNode<Float64T> x) {
if (IsFloat64RoundTiesEvenSupported()) {
  return Float64RoundTiesEven(x);
}
// See ES#sec-touint8clamp for details.
TNode<Float64T> f = Float64Floor(x);
TNode<Float64T> f_and_half = Float64Add(f, Float64Constant(0.5));

TVARIABLE(Float64T, var_result)TVariable<Float64T> var_result(this);
Label return_f(this), return_f_plus_one(this), done(this);

GotoIf(Float64LessThan(f_and_half, x), &return_f_plus_one);
GotoIf(Float64LessThan(x, f_and_half), &return_f);
{
  TNode<Float64T> f_mod_2 = Float64Mod(f, Float64Constant(2.0));
  Branch(Float64Equal(f_mod_2, Float64Constant(0.0)), &return_f,
         &return_f_plus_one);
}

BIND(&return_f)Bind(&return_f);
var_result = f;
Goto(&done);

BIND(&return_f_plus_one)Bind(&return_f_plus_one);
var_result = Float64Add(f, Float64Constant(1.0));
Goto(&done);

BIND(&done)Bind(&done);
return var_result.value();
493}

495TNode<Float64T> CodeStubAssembler::Float64Trunc(TNode<Float64T> x) {
if (IsFloat64RoundTruncateSupported()) {
  return Float64RoundTruncate(x);
}

TNode<Float64T> one = Float64Constant(1.0);
TNode<Float64T> zero = Float64Constant(0.0);
TNode<Float64T> two_52 = Float64Constant(4503599627370496.0E0);
TNode<Float64T> minus_two_52 = Float64Constant(-4503599627370496.0E0);

TVARIABLE(Float64T, var_x, x)TVariable<Float64T> var_x(x, this);
Label return_x(this), return_minus_x(this);

// Check if {x} is greater than 0.
Label if_xgreaterthanzero(this), if_xnotgreaterthanzero(this);
Branch(Float64GreaterThan(x, zero), &if_xgreaterthanzero,
       &if_xnotgreaterthanzero);

BIND(&if_xgreaterthanzero)Bind(&if_xgreaterthanzero);
{
  if (IsFloat64RoundDownSupported()) {
    var_x = Float64RoundDown(x);
  } else {
    // Just return {x} unless it's in the range ]0,2^52[.
    GotoIf(Float64GreaterThanOrEqual(x, two_52), &return_x);

    // Round positive {x} towards -Infinity.
    var_x = Float64Sub(Float64Add(two_52, x), two_52);
    GotoIfNot(Float64GreaterThan(var_x.value(), x), &return_x);
    var_x = Float64Sub(var_x.value(), one);
  }
  Goto(&return_x);
}

BIND(&if_xnotgreaterthanzero)Bind(&if_xnotgreaterthanzero);
{
  if (IsFloat64RoundUpSupported()) {
    var_x = Float64RoundUp(x);
    Goto(&return_x);
  } else {
    // Just return {x} unless its in the range ]-2^52,0[.
    GotoIf(Float64LessThanOrEqual(x, minus_two_52), &return_x);
    GotoIfNot(Float64LessThan(x, zero), &return_x);

    // Round negated {x} towards -Infinity and return result negated.
    TNode<Float64T> minus_x = Float64Neg(x);
    var_x = Float64Sub(Float64Add(two_52, minus_x), two_52);
    GotoIfNot(Float64GreaterThan(var_x.value(), minus_x), &return_minus_x);
    var_x = Float64Sub(var_x.value(), one);
    Goto(&return_minus_x);
  }
}

BIND(&return_minus_x)Bind(&return_minus_x);
var_x = Float64Neg(var_x.value());
Goto(&return_x);

BIND(&return_x)Bind(&return_x);
return var_x.value();
554}

556TNode<IntPtrT> CodeStubAssembler::PopulationCountFallback(
  TNode<UintPtrT> value) {
// Taken from slow path of base::bits::CountPopulation, the comments here show
// C++ code and comments from there for reference.
// Fall back to divide-and-conquer popcount (see "Hacker's Delight" by Henry
// S. Warren,  Jr.), chapter 5-1.
constexpr uintptr_t mask[] = {static_cast<uintptr_t>(0x5555555555555555),
                              static_cast<uintptr_t>(0x3333333333333333),
                              static_cast<uintptr_t>(0x0f0f0f0f0f0f0f0f)};

// TNode<UintPtrT> value = Unsigned(value_word);
TNode<UintPtrT> lhs, rhs;

// Start with 64 buckets of 1 bits, holding values from [0,1].
// {value = ((value >> 1) & mask[0]) + (value & mask[0])}
lhs = WordAnd(WordShr(value, UintPtrConstant(1)), UintPtrConstant(mask[0]));
rhs = WordAnd(value, UintPtrConstant(mask[0]));
value = UintPtrAdd(lhs, rhs);

// Having 32 buckets of 2 bits, holding values from [0,2] now.
// {value = ((value >> 2) & mask[1]) + (value & mask[1])}
lhs = WordAnd(WordShr(value, UintPtrConstant(2)), UintPtrConstant(mask[1]));
rhs = WordAnd(value, UintPtrConstant(mask[1]));
value = UintPtrAdd(lhs, rhs);

// Having 16 buckets of 4 bits, holding values from [0,4] now.
// {value = ((value >> 4) & mask[2]) + (value & mask[2])}
lhs = WordAnd(WordShr(value, UintPtrConstant(4)), UintPtrConstant(mask[2]));
rhs = WordAnd(value, UintPtrConstant(mask[2]));
value = UintPtrAdd(lhs, rhs);

// Having 8 buckets of 8 bits, holding values from [0,8] now.
// From this point on, the buckets are bigger than the number of bits
// required to hold the values, and the buckets are bigger the maximum
// result, so there's no need to mask value anymore, since there's no
// more risk of overflow between buckets.
// {value = (value >> 8) + value}
lhs = WordShr(value, UintPtrConstant(8));
value = UintPtrAdd(lhs, value);

// Having 4 buckets of 16 bits, holding values from [0,16] now.
// {value = (value >> 16) + value}
lhs = WordShr(value, UintPtrConstant(16));
value = UintPtrAdd(lhs, value);

if (Is64()) {
  // Having 2 buckets of 32 bits, holding values from [0,32] now.
  // {value = (value >> 32) + value}
  lhs = WordShr(value, UintPtrConstant(32));
  value = UintPtrAdd(lhs, value);
}

// Having 1 buckets of sizeof(intptr_t) bits, holding values from [0,64] now.
// {return static_cast<unsigned>(value & 0xff)}
return Signed(WordAnd(value, UintPtrConstant(0xff)));
611}

613TNode<Int64T> CodeStubAssembler::PopulationCount64(TNode<Word64T> value) {
if (IsWord64PopcntSupported()) {
  return Word64Popcnt(value);
}

if (Is32()) {
  // Unsupported.
  UNREACHABLE()V8_Fatal("unreachable code");
}

return ReinterpretCast<Int64T>(
    PopulationCountFallback(ReinterpretCast<UintPtrT>(value)));
625}

627TNode<Int32T> CodeStubAssembler::PopulationCount32(TNode<Word32T> value) {
if (IsWord32PopcntSupported()) {
  return Word32Popcnt(value);
}

if (Is32()) {
  TNode<IntPtrT> res =
      PopulationCountFallback(ReinterpretCast<UintPtrT>(value));
  return ReinterpretCast<Int32T>(res);
} else {
  TNode<IntPtrT> res = PopulationCountFallback(
      ReinterpretCast<UintPtrT>(ChangeUint32ToUint64(value)));
  return TruncateInt64ToInt32(ReinterpretCast<Int64T>(res));
}
641}

643TNode<Int64T> CodeStubAssembler::CountTrailingZeros64(TNode<Word64T> value) {
if (IsWord64CtzSupported()) {
  return Word64Ctz(value);
}

if (Is32()) {
  // Unsupported.
  UNREACHABLE()V8_Fatal("unreachable code");
}

// Same fallback as in base::bits::CountTrailingZeros.
// Fall back to popcount (see "Hacker's Delight" by Henry S. Warren, Jr.),
// chapter 5-4. On x64, since is faster than counting in a loop and faster
// than doing binary search.
TNode<Word64T> lhs = Word64Not(value);
TNode<Word64T> rhs = Uint64Sub(Unsigned(value), Uint64Constant(1));
return PopulationCount64(Word64And(lhs, rhs));
660}

662TNode<Int32T> CodeStubAssembler::CountTrailingZeros32(TNode<Word32T> value) {
if (IsWord32CtzSupported()) {
  return Word32Ctz(value);
}

if (Is32()) {
  // Same fallback as in Word64CountTrailingZeros.
  TNode<Word32T> lhs = Word32BitwiseNot(value);
  TNode<Word32T> rhs = Int32Sub(Signed(value), Int32Constant(1));
  return PopulationCount32(Word32And(lhs, rhs));
} else {
  TNode<Int64T> res64 = CountTrailingZeros64(ChangeUint32ToUint64(value));
  return TruncateInt64ToInt32(Signed(res64));
}
676}

678TNode<Int64T> CodeStubAssembler::CountLeadingZeros64(TNode<Word64T> value) {
return Word64Clz(value);
680}

682TNode<Int32T> CodeStubAssembler::CountLeadingZeros32(TNode<Word32T> value) {
return Word32Clz(value);
684}

686template <>
687TNode<Smi> CodeStubAssembler::TaggedToParameter(TNode<Smi> value) {
return value;
689}

691template <>
692TNode<IntPtrT> CodeStubAssembler::TaggedToParameter(TNode<Smi> value) {
return SmiUntag(value);
694}

696TNode<IntPtrT> CodeStubAssembler::TaggedIndexToIntPtr(
  TNode<TaggedIndex> value) {
return Signed(WordSarShiftOutZeros(BitcastTaggedToWordForTagAndSmiBits(value),
                                   IntPtrConstant(kSmiTagSize)));
700}

702TNode<TaggedIndex> CodeStubAssembler::IntPtrToTaggedIndex(
  TNode<IntPtrT> value) {
return ReinterpretCast<TaggedIndex>(
    BitcastWordToTaggedSigned(WordShl(value, IntPtrConstant(kSmiTagSize))));
706}

708TNode<Smi> CodeStubAssembler::TaggedIndexToSmi(TNode<TaggedIndex> value) {
if (SmiValuesAre32Bits()) {
  DCHECK_EQ(kSmiShiftSize, 31)((void) 0);
  return BitcastWordToTaggedSigned(
      WordShl(BitcastTaggedToWordForTagAndSmiBits(value),
              IntPtrConstant(kSmiShiftSize)));
}
DCHECK(SmiValuesAre31Bits())((void) 0);
DCHECK_EQ(kSmiShiftSize, 0)((void) 0);
return ReinterpretCast<Smi>(value);
718}

720TNode<TaggedIndex> CodeStubAssembler::SmiToTaggedIndex(TNode<Smi> value) {
if (kSystemPointerSize == kInt32Size) {
  return ReinterpretCast<TaggedIndex>(value);
}
if (SmiValuesAre32Bits()) {
  DCHECK_EQ(kSmiShiftSize, 31)((void) 0);
  return ReinterpretCast<TaggedIndex>(BitcastWordToTaggedSigned(
      WordSar(BitcastTaggedToWordForTagAndSmiBits(value),
              IntPtrConstant(kSmiShiftSize))));
}
DCHECK(SmiValuesAre31Bits())((void) 0);
DCHECK_EQ(kSmiShiftSize, 0)((void) 0);
// Just sign-extend the lower 32 bits.
TNode<Int32T> raw =
    TruncateWordToInt32(BitcastTaggedToWordForTagAndSmiBits(value));
return ReinterpretCast<TaggedIndex>(
    BitcastWordToTaggedSigned(ChangeInt32ToIntPtr(raw)));
737}

739TNode<Smi> CodeStubAssembler::NormalizeSmiIndex(TNode<Smi> smi_index) {
if (COMPRESS_POINTERS_BOOLfalse) {
  TNode<Int32T> raw =
      TruncateWordToInt32(BitcastTaggedToWordForTagAndSmiBits(smi_index));
  smi_index = BitcastWordToTaggedSigned(ChangeInt32ToIntPtr(raw));
}
return smi_index;
746}

748TNode<Smi> CodeStubAssembler::SmiFromInt32(TNode<Int32T> value) {
if (COMPRESS_POINTERS_BOOLfalse) {
  static_assert(!COMPRESS_POINTERS_BOOLfalse || (kSmiShiftSize + kSmiTagSize == 1),
                "Use shifting instead of add");
  return BitcastWordToTaggedSigned(
      ChangeUint32ToWord(Int32Add(value, value)));
}
return SmiTag(ChangeInt32ToIntPtr(value));
756}

758TNode<Smi> CodeStubAssembler::SmiFromUint32(TNode<Uint32T> value) {
CSA_DCHECK(this, IntPtrLessThan(ChangeUint32ToWord(value),((void)0)
                                IntPtrConstant(Smi::kMaxValue)))((void)0);
return SmiFromInt32(Signed(value));
762}

764TNode<BoolT> CodeStubAssembler::IsValidPositiveSmi(TNode<IntPtrT> value) {
intptr_t constant_value;
if (TryToIntPtrConstant(value, &constant_value)) {
  return (static_cast<uintptr_t>(constant_value) <=
          static_cast<uintptr_t>(Smi::kMaxValue))
             ? Int32TrueConstant()
             : Int32FalseConstant();
}

return UintPtrLessThanOrEqual(value, IntPtrConstant(Smi::kMaxValue));
774}

776TNode<Smi> CodeStubAssembler::SmiTag(TNode<IntPtrT> value) {
int32_t constant_value;
if (TryToInt32Constant(value, &constant_value) &&
    Smi::IsValid(constant_value)) {
  return SmiConstant(constant_value);
}
if (COMPRESS_POINTERS_BOOLfalse) {
  return SmiFromInt32(TruncateIntPtrToInt32(value));
}
TNode<Smi> smi =
    BitcastWordToTaggedSigned(WordShl(value, SmiShiftBitsConstant()));
return smi;
788}

790TNode<IntPtrT> CodeStubAssembler::SmiUntag(TNode<Smi> value) {
intptr_t constant_value;
if (TryToIntPtrConstant(value, &constant_value)) {
  return IntPtrConstant(constant_value >> (kSmiShiftSize + kSmiTagSize));
}
TNode<IntPtrT> raw_bits = BitcastTaggedToWordForTagAndSmiBits(value);
if (COMPRESS_POINTERS_BOOLfalse) {
  // Clear the upper half using sign-extension.
  raw_bits = ChangeInt32ToIntPtr(TruncateIntPtrToInt32(raw_bits));
}
return Signed(WordSarShiftOutZeros(raw_bits, SmiShiftBitsConstant()));
801}

803TNode<Int32T> CodeStubAssembler::SmiToInt32(TNode<Smi> value) {
if (COMPRESS_POINTERS_BOOLfalse) {
  return Signed(Word32SarShiftOutZeros(
      TruncateIntPtrToInt32(BitcastTaggedToWordForTagAndSmiBits(value)),
      SmiShiftBitsConstant32()));
}
TNode<IntPtrT> result = SmiUntag(value);
return TruncateIntPtrToInt32(result);
811}

813TNode<Float64T> CodeStubAssembler::SmiToFloat64(TNode<Smi> value) {
return ChangeInt32ToFloat64(SmiToInt32(value));
815}

817TNode<Smi> CodeStubAssembler::SmiMax(TNode<Smi> a, TNode<Smi> b) {
return SelectConstant<Smi>(SmiLessThan(a, b), b, a);
819}

821TNode<Smi> CodeStubAssembler::SmiMin(TNode<Smi> a, TNode<Smi> b) {
return SelectConstant<Smi>(SmiLessThan(a, b), a, b);
823}

825TNode<IntPtrT> CodeStubAssembler::TryIntPtrAdd(TNode<IntPtrT> a,
                                             TNode<IntPtrT> b,
                                             Label* if_overflow) {
TNode<PairT<IntPtrT, BoolT>> pair = IntPtrAddWithOverflow(a, b);
TNode<BoolT> overflow = Projection<1>(pair);
GotoIf(overflow, if_overflow);
return Projection<0>(pair);
832}

834TNode<IntPtrT> CodeStubAssembler::TryIntPtrSub(TNode<IntPtrT> a,
                                             TNode<IntPtrT> b,
                                             Label* if_overflow) {
TNode<PairT<IntPtrT, BoolT>> pair = IntPtrSubWithOverflow(a, b);
TNode<BoolT> overflow = Projection<1>(pair);
GotoIf(overflow, if_overflow);
return Projection<0>(pair);
841}

843TNode<Int32T> CodeStubAssembler::TryInt32Mul(TNode<Int32T> a, TNode<Int32T> b,
                                           Label* if_overflow) {
TNode<PairT<Int32T, BoolT>> pair = Int32MulWithOverflow(a, b);
TNode<BoolT> overflow = Projection<1>(pair);
GotoIf(overflow, if_overflow);
return Projection<0>(pair);
849}

851TNode<Smi> CodeStubAssembler::TrySmiAdd(TNode<Smi> lhs, TNode<Smi> rhs,
                                      Label* if_overflow) {
if (SmiValuesAre32Bits()) {
  return BitcastWordToTaggedSigned(
      TryIntPtrAdd(BitcastTaggedToWordForTagAndSmiBits(lhs),
                   BitcastTaggedToWordForTagAndSmiBits(rhs), if_overflow));
} else {
  DCHECK(SmiValuesAre31Bits())((void) 0);
  TNode<PairT<Int32T, BoolT>> pair = Int32AddWithOverflow(
      TruncateIntPtrToInt32(BitcastTaggedToWordForTagAndSmiBits(lhs)),
      TruncateIntPtrToInt32(BitcastTaggedToWordForTagAndSmiBits(rhs)));
  TNode<BoolT> overflow = Projection<1>(pair);
  GotoIf(overflow, if_overflow);
  TNode<Int32T> result = Projection<0>(pair);
  return BitcastWordToTaggedSigned(ChangeInt32ToIntPtr(result));
}
867}

869TNode<Smi> CodeStubAssembler::TrySmiSub(TNode<Smi> lhs, TNode<Smi> rhs,
                                      Label* if_overflow) {
if (SmiValuesAre32Bits()) {
  TNode<PairT<IntPtrT, BoolT>> pair =
      IntPtrSubWithOverflow(BitcastTaggedToWordForTagAndSmiBits(lhs),
                            BitcastTaggedToWordForTagAndSmiBits(rhs));
  TNode<BoolT> overflow = Projection<1>(pair);
  GotoIf(overflow, if_overflow);
  TNode<IntPtrT> result = Projection<0>(pair);
  return BitcastWordToTaggedSigned(result);
} else {
  DCHECK(SmiValuesAre31Bits())((void) 0);
  TNode<PairT<Int32T, BoolT>> pair = Int32SubWithOverflow(
      TruncateIntPtrToInt32(BitcastTaggedToWordForTagAndSmiBits(lhs)),
      TruncateIntPtrToInt32(BitcastTaggedToWordForTagAndSmiBits(rhs)));
  TNode<BoolT> overflow = Projection<1>(pair);
  GotoIf(overflow, if_overflow);
  TNode<Int32T> result = Projection<0>(pair);
  return BitcastWordToTaggedSigned(ChangeInt32ToIntPtr(result));
}
889}

891TNode<Smi> CodeStubAssembler::TrySmiAbs(TNode<Smi> a, Label* if_overflow) {
if (SmiValuesAre32Bits()) {
  TNode<PairT<IntPtrT, BoolT>> pair =
      IntPtrAbsWithOverflow(BitcastTaggedToWordForTagAndSmiBits(a));
  TNode<BoolT> overflow = Projection<1>(pair);
  GotoIf(overflow, if_overflow);
  TNode<IntPtrT> result = Projection<0>(pair);
  return BitcastWordToTaggedSigned(result);
} else {
  CHECK(SmiValuesAre31Bits())do { if ((__builtin_expect(!!(!(SmiValuesAre31Bits())), 0))) {
 V8_Fatal("Check failed: %s.", "SmiValuesAre31Bits()"); } } while
 (false);
  CHECK(IsInt32AbsWithOverflowSupported())do { if ((__builtin_expect(!!(!(IsInt32AbsWithOverflowSupported
())), 0))) { V8_Fatal("Check failed: %s.", "IsInt32AbsWithOverflowSupported()"
); } } while (false);
  TNode<PairT<Int32T, BoolT>> pair = Int32AbsWithOverflow(
      TruncateIntPtrToInt32(BitcastTaggedToWordForTagAndSmiBits(a)));
  TNode<BoolT> overflow = Projection<1>(pair);
  GotoIf(overflow, if_overflow);
  TNode<Int32T> result = Projection<0>(pair);
  return BitcastWordToTaggedSigned(ChangeInt32ToIntPtr(result));
}
909}

911TNode<Number> CodeStubAssembler::NumberMax(TNode<Number> a, TNode<Number> b) {
// TODO(danno): This could be optimized by specifically handling smi cases.
TVARIABLE(Number, result)TVariable<Number> result(this);
Label done(this), greater_than_equal_a(this), greater_than_equal_b(this);
GotoIfNumberGreaterThanOrEqual(a, b, &greater_than_equal_a);
GotoIfNumberGreaterThanOrEqual(b, a, &greater_than_equal_b);
result = NanConstant();
Goto(&done);
BIND(&greater_than_equal_a)Bind(&greater_than_equal_a);
result = a;
Goto(&done);
BIND(&greater_than_equal_b)Bind(&greater_than_equal_b);
result = b;
Goto(&done);
BIND(&done)Bind(&done);
return result.value();
927}

929TNode<Number> CodeStubAssembler::NumberMin(TNode<Number> a, TNode<Number> b) {
// TODO(danno): This could be optimized by specifically handling smi cases.
TVARIABLE(Number, result)TVariable<Number> result(this);
Label done(this), greater_than_equal_a(this), greater_than_equal_b(this);
GotoIfNumberGreaterThanOrEqual(a, b, &greater_than_equal_a);
GotoIfNumberGreaterThanOrEqual(b, a, &greater_than_equal_b);
result = NanConstant();
Goto(&done);
BIND(&greater_than_equal_a)Bind(&greater_than_equal_a);
result = b;
Goto(&done);
BIND(&greater_than_equal_b)Bind(&greater_than_equal_b);
result = a;
Goto(&done);
BIND(&done)Bind(&done);
return result.value();
945}

947TNode<Number> CodeStubAssembler::SmiMod(TNode<Smi> a, TNode<Smi> b) {
TVARIABLE(Number, var_result)TVariable<Number> var_result(this);
Label return_result(this, &var_result),
    return_minuszero(this, Label::kDeferred),
    return_nan(this, Label::kDeferred);

// Untag {a} and {b}.
TNode<Int32T> int_a = SmiToInt32(a);
TNode<Int32T> int_b = SmiToInt32(b);

// Return NaN if {b} is zero.
GotoIf(Word32Equal(int_b, Int32Constant(0)), &return_nan);

// Check if {a} is non-negative.
Label if_aisnotnegative(this), if_aisnegative(this, Label::kDeferred);
Branch(Int32LessThanOrEqual(Int32Constant(0), int_a), &if_aisnotnegative,
       &if_aisnegative);

BIND(&if_aisnotnegative)Bind(&if_aisnotnegative);
{
  // Fast case, don't need to check any other edge cases.
  TNode<Int32T> r = Int32Mod(int_a, int_b);
  var_result = SmiFromInt32(r);
  Goto(&return_result);
}

BIND(&if_aisnegative)Bind(&if_aisnegative);
{
  if (SmiValuesAre32Bits()) {
    // Check if {a} is kMinInt and {b} is -1 (only relevant if the
    // kMinInt is actually representable as a Smi).
    Label join(this);
    GotoIfNot(Word32Equal(int_a, Int32Constant(kMinInt)), &join);
    GotoIf(Word32Equal(int_b, Int32Constant(-1)), &return_minuszero);
    Goto(&join);
    BIND(&join)Bind(&join);
  }

  // Perform the integer modulus operation.
  TNode<Int32T> r = Int32Mod(int_a, int_b);

  // Check if {r} is zero, and if so return -0, because we have to
  // take the sign of the left hand side {a}, which is negative.
  GotoIf(Word32Equal(r, Int32Constant(0)), &return_minuszero);

  // The remainder {r} can be outside the valid Smi range on 32bit
  // architectures, so we cannot just say SmiFromInt32(r) here.
  var_result = ChangeInt32ToTagged(r);
  Goto(&return_result);
}

BIND(&return_minuszero)Bind(&return_minuszero);
var_result = MinusZeroConstant();
Goto(&return_result);

BIND(&return_nan)Bind(&return_nan);
var_result = NanConstant();
Goto(&return_result);

BIND(&return_result)Bind(&return_result);
return var_result.value();
1008}

1010TNode<Number> CodeStubAssembler::SmiMul(TNode<Smi> a, TNode<Smi> b) {
TVARIABLE(Number, var_result)TVariable<Number> var_result(this);
TVARIABLE(Float64T, var_lhs_float64)TVariable<Float64T> var_lhs_float64(this);
TVARIABLE(Float64T, var_rhs_float64)TVariable<Float64T> var_rhs_float64(this);
Label return_result(this, &var_result);

// Both {a} and {b} are Smis. Convert them to integers and multiply.
TNode<Int32T> lhs32 = SmiToInt32(a);
TNode<Int32T> rhs32 = SmiToInt32(b);
auto pair = Int32MulWithOverflow(lhs32, rhs32);

TNode<BoolT> overflow = Projection<1>(pair);

// Check if the multiplication overflowed.
Label if_overflow(this, Label::kDeferred), if_notoverflow(this);
Branch(overflow, &if_overflow, &if_notoverflow);
BIND(&if_notoverflow)Bind(&if_notoverflow);
{
  // If the answer is zero, we may need to return -0.0, depending on the
  // input.
  Label answer_zero(this), answer_not_zero(this);
  TNode<Int32T> answer = Projection<0>(pair);
  TNode<Int32T> zero = Int32Constant(0);
  Branch(Word32Equal(answer, zero), &answer_zero, &answer_not_zero);
  BIND(&answer_not_zero)Bind(&answer_not_zero);
  {
    var_result = ChangeInt32ToTagged(answer);
    Goto(&return_result);
  }
  BIND(&answer_zero)Bind(&answer_zero);
  {
    TNode<Int32T> or_result = Word32Or(lhs32, rhs32);
    Label if_should_be_negative_zero(this), if_should_be_zero(this);
    Branch(Int32LessThan(or_result, zero), &if_should_be_negative_zero,
           &if_should_be_zero);
    BIND(&if_should_be_negative_zero)Bind(&if_should_be_negative_zero);
    {
      var_result = MinusZeroConstant();
      Goto(&return_result);
    }
    BIND(&if_should_be_zero)Bind(&if_should_be_zero);
    {
      var_result = SmiConstant(0);
      Goto(&return_result);
    }
  }
}
BIND(&if_overflow)Bind(&if_overflow);
{
  var_lhs_float64 = SmiToFloat64(a);
  var_rhs_float64 = SmiToFloat64(b);
  TNode<Float64T> value =
      Float64Mul(var_lhs_float64.value(), var_rhs_float64.value());
  var_result = AllocateHeapNumberWithValue(value);
  Goto(&return_result);
}

BIND(&return_result)Bind(&return_result);
return var_result.value();
1069}

1071TNode<Smi> CodeStubAssembler::TrySmiDiv(TNode<Smi> dividend, TNode<Smi> divisor,
                                      Label* bailout) {
// Both {a} and {b} are Smis. Bailout to floating point division if {divisor}
// is zero.
GotoIf(TaggedEqual(divisor, SmiConstant(0)), bailout);

// Do floating point division if {dividend} is zero and {divisor} is
// negative.
Label dividend_is_zero(this), dividend_is_not_zero(this);
Branch(TaggedEqual(dividend, SmiConstant(0)), &dividend_is_zero,
       &dividend_is_not_zero);

BIND(&dividend_is_zero)Bind(&dividend_is_zero);
{
  GotoIf(SmiLessThan(divisor, SmiConstant(0)), bailout);
  Goto(&dividend_is_not_zero);
}
BIND(&dividend_is_not_zero)Bind(&dividend_is_not_zero);

TNode<Int32T> untagged_divisor = SmiToInt32(divisor);
TNode<Int32T> untagged_dividend = SmiToInt32(dividend);

// Do floating point division if {dividend} is kMinInt (or kMinInt - 1
// if the Smi size is 31) and {divisor} is -1.
Label divisor_is_minus_one(this), divisor_is_not_minus_one(this);
Branch(Word32Equal(untagged_divisor, Int32Constant(-1)),
       &divisor_is_minus_one, &divisor_is_not_minus_one);

BIND(&divisor_is_minus_one)Bind(&divisor_is_minus_one);
{
  GotoIf(Word32Equal(
             untagged_dividend,
             Int32Constant(kSmiValueSize == 32 ? kMinInt : (kMinInt >> 1))),
         bailout);
  Goto(&divisor_is_not_minus_one);
}
BIND(&divisor_is_not_minus_one)Bind(&divisor_is_not_minus_one);

TNode<Int32T> untagged_result = Int32Div(untagged_dividend, untagged_divisor);
TNode<Int32T> truncated = Int32Mul(untagged_result, untagged_divisor);

// Do floating point division if the remainder is not 0.
GotoIf(Word32NotEqual(untagged_dividend, truncated), bailout);

return SmiFromInt32(untagged_result);
1116}

1118TNode<Smi> CodeStubAssembler::SmiLexicographicCompare(TNode<Smi> x,
                                                    TNode<Smi> y) {
TNode<ExternalReference> smi_lexicographic_compare =
    ExternalConstant(ExternalReference::smi_lexicographic_compare_function());
TNode<ExternalReference> isolate_ptr =
    ExternalConstant(ExternalReference::isolate_address(isolate()));
return CAST(CallCFunction(smi_lexicographic_compare, MachineType::AnyTagged(),Cast(CallCFunction(smi_lexicographic_compare, MachineType::AnyTagged
(), std::make_pair(MachineType::Pointer(), isolate_ptr), std::
make_pair(MachineType::AnyTagged(), x), std::make_pair(MachineType
::AnyTagged(), y)))
                          std::make_pair(MachineType::Pointer(), isolate_ptr),Cast(CallCFunction(smi_lexicographic_compare, MachineType::AnyTagged
(), std::make_pair(MachineType::Pointer(), isolate_ptr), std::
make_pair(MachineType::AnyTagged(), x), std::make_pair(MachineType
::AnyTagged(), y)))
                          std::make_pair(MachineType::AnyTagged(), x),Cast(CallCFunction(smi_lexicographic_compare, MachineType::AnyTagged
(), std::make_pair(MachineType::Pointer(), isolate_ptr), std::
make_pair(MachineType::AnyTagged(), x), std::make_pair(MachineType
::AnyTagged(), y)))
                          std::make_pair(MachineType::AnyTagged(), y)))Cast(CallCFunction(smi_lexicographic_compare, MachineType::AnyTagged
(), std::make_pair(MachineType::Pointer(), isolate_ptr), std::
make_pair(MachineType::AnyTagged(), x), std::make_pair(MachineType
::AnyTagged(), y)));
1128}

1130TNode<Int32T> CodeStubAssembler::TruncateWordToInt32(TNode<WordT> value) {
if (Is64()) {
  return TruncateInt64ToInt32(ReinterpretCast<Int64T>(value));
}
return ReinterpretCast<Int32T>(value);
1135}

1137TNode<Int32T> CodeStubAssembler::TruncateIntPtrToInt32(TNode<IntPtrT> value) {
if (Is64()) {
  return TruncateInt64ToInt32(ReinterpretCast<Int64T>(value));
}
return ReinterpretCast<Int32T>(value);
1142}

1144TNode<BoolT> CodeStubAssembler::TaggedIsSmi(TNode<MaybeObject> a) {
STATIC_ASSERT(kSmiTagMask < kMaxUInt32)static_assert(kSmiTagMask < kMaxUInt32, "kSmiTagMask < kMaxUInt32"
);
return Word32Equal(
    Word32And(TruncateIntPtrToInt32(BitcastTaggedToWordForTagAndSmiBits(a)),
              Int32Constant(kSmiTagMask)),
    Int32Constant(0));
1150}

1152TNode<BoolT> CodeStubAssembler::TaggedIsNotSmi(TNode<MaybeObject> a) {
return Word32BinaryNot(TaggedIsSmi(a));
1154}

1156TNode<BoolT> CodeStubAssembler::TaggedIsPositiveSmi(TNode<Object> a) {
1157#if defined(V8_HOST_ARCH_32_BIT) || defined(V8_31BIT_SMIS_ON_64BIT_ARCH)
return Word32Equal(
    Word32And(
        TruncateIntPtrToInt32(BitcastTaggedToWordForTagAndSmiBits(a)),
        Uint32Constant(static_cast<uint32_t>(kSmiTagMask | kSmiSignMask))),
    Int32Constant(0));
1163#else
return WordEqual(WordAnd(BitcastTaggedToWordForTagAndSmiBits(a),
                         IntPtrConstant(kSmiTagMask | kSmiSignMask)),
                 IntPtrConstant(0));
1167#endif
1168}

1170TNode<BoolT> CodeStubAssembler::WordIsAligned(TNode<WordT> word,
                                            size_t alignment) {
DCHECK(base::bits::IsPowerOfTwo(alignment))((void) 0);
DCHECK_LE(alignment, kMaxUInt32)((void) 0);
return Word32Equal(
    Int32Constant(0),
    Word32And(TruncateWordToInt32(word),
              Uint32Constant(static_cast<uint32_t>(alignment) - 1)));
1178}

1180#if DEBUG
1181void CodeStubAssembler::Bind(Label* label, AssemblerDebugInfo debug_info) {
CodeAssembler::Bind(label, debug_info);
1183}
1184#endif  // DEBUG

1186void CodeStubAssembler::Bind(Label* label) { CodeAssembler::Bind(label); }

1188TNode<Float64T> CodeStubAssembler::LoadDoubleWithHoleCheck(
  TNode<FixedDoubleArray> array, TNode<IntPtrT> index, Label* if_hole) {
return LoadFixedDoubleArrayElement(array, index, if_hole);
1191}

1193void CodeStubAssembler::BranchIfJSReceiver(TNode<Object> object, Label* if_true,
                                         Label* if_false) {
GotoIf(TaggedIsSmi(object), if_false);
STATIC_ASSERT(LAST_JS_RECEIVER_TYPE == LAST_TYPE)static_assert(LAST_JS_RECEIVER_TYPE == LAST_TYPE, "LAST_JS_RECEIVER_TYPE == LAST_TYPE"
);
Branch(IsJSReceiver(CAST(object)Cast(object)), if_true, if_false);
1198}

1200void CodeStubAssembler::GotoIfForceSlowPath(Label* if_true) {
1201#ifdef V8_ENABLE_FORCE_SLOW_PATH
const TNode<ExternalReference> force_slow_path_addr =
    ExternalConstant(ExternalReference::force_slow_path(isolate()));
const TNode<Uint8T> force_slow = Load<Uint8T>(force_slow_path_addr);

GotoIf(force_slow, if_true);
1207#endif
1208}

1210TNode<HeapObject> CodeStubAssembler::AllocateRaw(TNode<IntPtrT> size_in_bytes,
                                               AllocationFlags flags,
                                               TNode<RawPtrT> top_address,
                                               TNode<RawPtrT> limit_address) {
Label if_out_of_memory(this, Label::kDeferred);

// TODO(jgruber,jkummerow): Extract the slow paths (= probably everything
// but bump pointer allocation) into a builtin to save code space. The
// size_in_bytes check may be moved there as well since a non-smi
// size_in_bytes probably doesn't fit into the bump pointer region
// (double-check that).

intptr_t size_in_bytes_constant;
bool size_in_bytes_is_constant = false;
if (TryToIntPtrConstant(size_in_bytes, &size_in_bytes_constant)) {
2
←
Assuming the condition is true→
3
←
Taking true branch→
  size_in_bytes_is_constant = true;
  CHECK(Internals::IsValidSmi(size_in_bytes_constant))do { if ((__builtin_expect(!!(!(Internals::IsValidSmi(size_in_bytes_constant
))), 0))) { V8_Fatal("Check failed: %s.", "Internals::IsValidSmi(size_in_bytes_constant)"
); } } while (false);
4
←
Taking false branch→
5
←
Loop condition is false.  Exiting loop→
  CHECK_GT(size_in_bytes_constant, 0)do { bool _cmp = ::v8::base::CmpGTImpl< typename ::v8::base
::pass_value_or_ref<decltype(size_in_bytes_constant)>::
type, typename ::v8::base::pass_value_or_ref<decltype(0)>
::type>((size_in_bytes_constant), (0)); do { if ((__builtin_expect
(!!(!(_cmp)), 0))) { V8_Fatal("Check failed: %s.", "size_in_bytes_constant"
 " " ">" " " "0"); } } while (false); } while (false);
6
←
Taking false branch→
7
←
Loop condition is false.  Exiting loop→
8
←
Loop condition is false.  Exiting loop→
} else {
  GotoIfNot(IsValidPositiveSmi(size_in_bytes), &if_out_of_memory);
}

TNode<RawPtrT> top = Load<RawPtrT>(top_address);
TNode<RawPtrT> limit = Load<RawPtrT>(limit_address);

// If there's not enough space, call the runtime.
TVARIABLE(Object, result)TVariable<Object> result(this);
Label runtime_call(this, Label::kDeferred), no_runtime_call(this), out(this);

bool needs_double_alignment = flags & AllocationFlag::kDoubleAlignment;
bool allow_large_object_allocation =
    flags & AllocationFlag::kAllowLargeObjectAllocation;

if (allow_large_object_allocation) {
9
←
Assuming 'allow_large_object_allocation' is false→
10
←
Taking false branch→
  Label next(this);
  GotoIf(IsRegularHeapObjectSize(size_in_bytes), &next);

  TNode<Smi> runtime_flags = SmiConstant(Smi::FromInt(
      AllocateDoubleAlignFlag::encode(needs_double_alignment) |
      AllowLargeObjectAllocationFlag::encode(allow_large_object_allocation)));
  result =
      CallRuntime(Runtime::kAllocateInYoungGeneration, NoContextConstant(),
                  SmiTag(size_in_bytes), runtime_flags);
  Goto(&out);

  BIND(&next)Bind(&next);
}

TVARIABLE(IntPtrT, adjusted_size, size_in_bytes)TVariable<IntPtrT> adjusted_size(size_in_bytes, this);

if (needs_double_alignment) {
11
←
Assuming 'needs_double_alignment' is false→
12
←
Taking false branch→
  Label next(this);
  GotoIfNot(WordAnd(top, IntPtrConstant(kDoubleAlignmentMask)), &next);

  adjusted_size = IntPtrAdd(size_in_bytes, IntPtrConstant(4));
  Goto(&next);

  BIND(&next)Bind(&next);
}

TNode<IntPtrT> new_top =
    IntPtrAdd(UncheckedCast<IntPtrT>(top), adjusted_size.value());

Branch(UintPtrGreaterThanOrEqual(new_top, limit), &runtime_call,
       &no_runtime_call);

BIND(&runtime_call)Bind(&runtime_call);
{
  TNode<Smi> runtime_flags = SmiConstant(Smi::FromInt(
      AllocateDoubleAlignFlag::encode(needs_double_alignment) |
      AllowLargeObjectAllocationFlag::encode(allow_large_object_allocation)));
13
←
Calling 'BitField::encode'→
  if (flags & AllocationFlag::kPretenured) {
    result =
        CallRuntime(Runtime::kAllocateInOldGeneration, NoContextConstant(),
                    SmiTag(size_in_bytes), runtime_flags);
  } else {
    result =
        CallRuntime(Runtime::kAllocateInYoungGeneration, NoContextConstant(),
                    SmiTag(size_in_bytes), runtime_flags);
  }
  Goto(&out);
}

// When there is enough space, return `top' and bump it up.
BIND(&no_runtime_call)Bind(&no_runtime_call);
{
  StoreNoWriteBarrier(MachineType::PointerRepresentation(), top_address,
                      new_top);

  TVARIABLE(IntPtrT, address, UncheckedCast<IntPtrT>(top))TVariable<IntPtrT> address(UncheckedCast<IntPtrT>
(top), this);

  if (needs_double_alignment) {
    Label next(this);
    GotoIf(IntPtrEqual(adjusted_size.value(), size_in_bytes), &next);

    // Store a filler and increase the address by 4.
    StoreNoWriteBarrier(MachineRepresentation::kTagged, top,
                        OnePointerFillerMapConstant());
    address = IntPtrAdd(UncheckedCast<IntPtrT>(top), IntPtrConstant(4));
    Goto(&next);

    BIND(&next)Bind(&next);
  }

  result = BitcastWordToTagged(
      IntPtrAdd(address.value(), IntPtrConstant(kHeapObjectTag)));
  Goto(&out);
}

if (!size_in_bytes_is_constant) {
  BIND(&if_out_of_memory)Bind(&if_out_of_memory);
  CallRuntime(Runtime::kFatalProcessOutOfMemoryInAllocateRaw,
              NoContextConstant());
  Unreachable();
}

BIND(&out)Bind(&out);
return UncheckedCast<HeapObject>(result.value());
1328}

1330TNode<HeapObject> CodeStubAssembler::AllocateRawUnaligned(
  TNode<IntPtrT> size_in_bytes, AllocationFlags flags,
  TNode<RawPtrT> top_address, TNode<RawPtrT> limit_address) {
DCHECK_EQ(flags & AllocationFlag::kDoubleAlignment, 0)((void) 0);
return AllocateRaw(size_in_bytes, flags, top_address, limit_address);
1
Calling 'CodeStubAssembler::AllocateRaw'→
1335}

1337TNode<HeapObject> CodeStubAssembler::AllocateRawDoubleAligned(
  TNode<IntPtrT> size_in_bytes, AllocationFlags flags,
  TNode<RawPtrT> top_address, TNode<RawPtrT> limit_address) {
1340#if defined(V8_HOST_ARCH_32_BIT)
return AllocateRaw(size_in_bytes, flags | AllocationFlag::kDoubleAlignment,
                   top_address, limit_address);
1343#elif defined(V8_HOST_ARCH_64_BIT1)
1344#ifdef V8_COMPRESS_POINTERS
1345// TODO(ishell, v8:8875): Consider using aligned allocations once the
1346// allocation alignment inconsistency is fixed. For now we keep using
1347// unaligned access since both x64 and arm64 architectures (where pointer
1348// compression is supported) allow unaligned access to doubles and full words.
1349#endif  // V8_COMPRESS_POINTERS
// Allocation on 64 bit machine is naturally double aligned
return AllocateRaw(size_in_bytes, flags & ~AllocationFlag::kDoubleAlignment,
                   top_address, limit_address);
1353#else
1354#error Architecture not supported
1355#endif
1356}

1358TNode<HeapObject> CodeStubAssembler::AllocateInNewSpace(
  TNode<IntPtrT> size_in_bytes, AllocationFlags flags) {
DCHECK(flags == AllocationFlag::kNone ||((void) 0)
       flags == AllocationFlag::kDoubleAlignment)((void) 0);
CSA_DCHECK(this, IsRegularHeapObjectSize(size_in_bytes))((void)0);
return Allocate(size_in_bytes, flags);
1364}

1366TNode<HeapObject> CodeStubAssembler::Allocate(TNode<IntPtrT> size_in_bytes,
                                            AllocationFlags flags) {
Comment("Allocate");
if (FLAG_single_generation) flags |= AllocationFlag::kPretenured;
bool const new_space = !(flags & AllocationFlag::kPretenured);
bool const allow_large_objects =
    flags & AllocationFlag::kAllowLargeObjectAllocation;
if (!allow_large_objects) {
  intptr_t size_constant;
  if (TryToIntPtrConstant(size_in_bytes, &size_constant)) {
    CHECK_LE(size_constant, kMaxRegularHeapObjectSize)do { bool _cmp = ::v8::base::CmpLEImpl< typename ::v8::base
::pass_value_or_ref<decltype(size_constant)>::type, typename
 ::v8::base::pass_value_or_ref<decltype(kMaxRegularHeapObjectSize
)>::type>((size_constant), (kMaxRegularHeapObjectSize))
; do { if ((__builtin_expect(!!(!(_cmp)), 0))) { V8_Fatal("Check failed: %s."
, "size_constant" " " "<=" " " "kMaxRegularHeapObjectSize"
); } } while (false); } while (false);
  } else {
    CSA_DCHECK(this, IsRegularHeapObjectSize(size_in_bytes))((void)0);
  }
}
if (!(flags & AllocationFlag::kDoubleAlignment)) {
  return OptimizedAllocate(
      size_in_bytes,
      new_space ? AllocationType::kYoung : AllocationType::kOld,
      allow_large_objects ? AllowLargeObjects::kTrue
                          : AllowLargeObjects::kFalse);
}
TNode<ExternalReference> top_address = ExternalConstant(
    new_space
        ? ExternalReference::new_space_allocation_top_address(isolate())
        : ExternalReference::old_space_allocation_top_address(isolate()));

1393#ifdef DEBUG
// New space is optional and if disabled both top and limit return
// kNullAddress.
if (ExternalReference::new_space_allocation_top_address(isolate())
        .address() != kNullAddress) {
  Address raw_top_address =
      ExternalReference::new_space_allocation_top_address(isolate())
          .address();
  Address raw_limit_address =
      ExternalReference::new_space_allocation_limit_address(isolate())
          .address();

  CHECK_EQ(kSystemPointerSize, raw_limit_address - raw_top_address)do { bool _cmp = ::v8::base::CmpEQImpl< typename ::v8::base
::pass_value_or_ref<decltype(kSystemPointerSize)>::type
, typename ::v8::base::pass_value_or_ref<decltype(raw_limit_address
 - raw_top_address)>::type>((kSystemPointerSize), (raw_limit_address
 - raw_top_address)); do { if ((__builtin_expect(!!(!(_cmp)),
 0))) { V8_Fatal("Check failed: %s.", "kSystemPointerSize" " "
 "==" " " "raw_limit_address - raw_top_address"); } } while (
false); } while (false);
}

DCHECK_EQ(kSystemPointerSize,((void) 0)
          ExternalReference::old_space_allocation_limit_address(isolate())((void) 0)
                  .address() -((void) 0)
              ExternalReference::old_space_allocation_top_address(isolate())((void) 0)
                  .address())((void) 0);
1413#endif

TNode<IntPtrT> limit_address =
    IntPtrAdd(ReinterpretCast<IntPtrT>(top_address),
              IntPtrConstant(kSystemPointerSize));

if (flags & AllocationFlag::kDoubleAlignment) {
  return AllocateRawDoubleAligned(size_in_bytes, flags,
                                  ReinterpretCast<RawPtrT>(top_address),
                                  ReinterpretCast<RawPtrT>(limit_address));
} else {
  return AllocateRawUnaligned(size_in_bytes, flags,
                              ReinterpretCast<RawPtrT>(top_address),
                              ReinterpretCast<RawPtrT>(limit_address));
}
1428}

1430TNode<HeapObject> CodeStubAssembler::AllocateInNewSpace(int size_in_bytes,
                                                      AllocationFlags flags) {
CHECK(flags == AllocationFlag::kNone ||do { if ((__builtin_expect(!!(!(flags == AllocationFlag::kNone
 || flags == AllocationFlag::kDoubleAlignment)), 0))) { V8_Fatal
("Check failed: %s.", "flags == AllocationFlag::kNone || flags == AllocationFlag::kDoubleAlignment"
); } } while (false)
      flags == AllocationFlag::kDoubleAlignment)do { if ((__builtin_expect(!!(!(flags == AllocationFlag::kNone
 || flags == AllocationFlag::kDoubleAlignment)), 0))) { V8_Fatal
("Check failed: %s.", "flags == AllocationFlag::kNone || flags == AllocationFlag::kDoubleAlignment"
); } } while (false);
DCHECK_LE(size_in_bytes, kMaxRegularHeapObjectSize)((void) 0);
return CodeStubAssembler::Allocate(IntPtrConstant(size_in_bytes), flags);
1436}

1438TNode<HeapObject> CodeStubAssembler::Allocate(int size_in_bytes,
                                            AllocationFlags flags) {
return CodeStubAssembler::Allocate(IntPtrConstant(size_in_bytes), flags);
1441}

1443TNode<BoolT> CodeStubAssembler::IsRegularHeapObjectSize(TNode<IntPtrT> size) {
return UintPtrLessThanOrEqual(size,
                              IntPtrConstant(kMaxRegularHeapObjectSize));
1446}

1448#if V8_ENABLE_WEBASSEMBLY1
1449TNode<HeapObject> CodeStubAssembler::AllocateWasmArray(
  TNode<IntPtrT> size_in_bytes, int initialization) {
TNode<HeapObject> array =
    Allocate(size_in_bytes, AllocationFlag::kAllowLargeObjectAllocation);
if (initialization == kUninitialized) return array;

TNode<IntPtrT> array_address = BitcastTaggedToWord(array);
TNode<IntPtrT> start = IntPtrAdd(
    array_address, IntPtrConstant(WasmArray::kHeaderSize - kHeapObjectTag));
TNode<IntPtrT> limit = IntPtrAdd(
    array_address, IntPtrSub(size_in_bytes, IntPtrConstant(kHeapObjectTag)));

TNode<Object> value;
if (initialization == kInitializeToZero) {
  // A pointer-sized zero pattern is just what we need for numeric Wasm
  // arrays (their object size is rounded up to a multiple of kPointerSize).
  value = SmiConstant(0);
} else if (initialization == kInitializeToNull) {
  value = NullConstant();
} else {
  UNREACHABLE()V8_Fatal("unreachable code");
}
StoreFieldsNoWriteBarrier(start, limit, value);
return array;
1473}
1474#endif  // V8_ENABLE_WEBASSEMBLY

1476void CodeStubAssembler::BranchIfToBooleanIsTrue(TNode<Object> value,
                                              Label* if_true,
                                              Label* if_false) {
Label if_smi(this), if_notsmi(this), if_heapnumber(this, Label::kDeferred),
    if_bigint(this, Label::kDeferred);
// Rule out false {value}.
GotoIf(TaggedEqual(value, FalseConstant()), if_false);

// Check if {value} is a Smi or a HeapObject.
Branch(TaggedIsSmi(value), &if_smi, &if_notsmi);

BIND(&if_smi)Bind(&if_smi);
{
  // The {value} is a Smi, only need to check against zero.
  BranchIfSmiEqual(CAST(value)Cast(value), SmiConstant(0), if_false, if_true);
}

BIND(&if_notsmi)Bind(&if_notsmi);
{
  TNode<HeapObject> value_heapobject = CAST(value)Cast(value);

  // Check if {value} is the empty string.
  GotoIf(IsEmptyString(value_heapobject), if_false);

  // The {value} is a HeapObject, load its map.
  TNode<Map> value_map = LoadMap(value_heapobject);

  // Only null, undefined and document.all have the undetectable bit set,
  // so we can return false immediately when that bit is set.
  GotoIf(IsUndetectableMap(value_map), if_false);

  // We still need to handle numbers specially, but all other {value}s
  // that make it here yield true.
  GotoIf(IsHeapNumberMap(value_map), &if_heapnumber);
  Branch(IsBigInt(value_heapobject), &if_bigint, if_true);

  BIND(&if_heapnumber)Bind(&if_heapnumber);
  {
    // Load the floating point value of {value}.
    TNode<Float64T> value_value =
        LoadObjectField<Float64T>(value_heapobject, HeapNumber::kValueOffset);

    // Check if the floating point {value} is neither 0.0, -0.0 nor NaN.
    Branch(Float64LessThan(Float64Constant(0.0), Float64Abs(value_value)),
           if_true, if_false);
  }

  BIND(&if_bigint)Bind(&if_bigint);
  {
    TNode<BigInt> bigint = CAST(value)Cast(value);
    TNode<Word32T> bitfield = LoadBigIntBitfield(bigint);
    TNode<Uint32T> length = DecodeWord32<BigIntBase::LengthBits>(bitfield);
    Branch(Word32Equal(length, Int32Constant(0)), if_false, if_true);
  }
}
1531}

1533TNode<RawPtrT> CodeStubAssembler::LoadSandboxedPointerFromObject(
  TNode<HeapObject> object, TNode<IntPtrT> field_offset) {
1535#ifdef V8_SANDBOXED_POINTERS
return ReinterpretCast<RawPtrT>(
    LoadObjectField<SandboxedPtrT>(object, field_offset));
1538#else
return LoadObjectField<RawPtrT>(object, field_offset);
1540#endif  // V8_SANDBOXED_POINTERS
1541}

1543void CodeStubAssembler::StoreSandboxedPointerToObject(TNode<HeapObject> object,
                                                    TNode<IntPtrT> offset,
                                                    TNode<RawPtrT> pointer) {
1546#ifdef V8_SANDBOXED_POINTERS
TNode<SandboxedPtrT> sbx_ptr = ReinterpretCast<SandboxedPtrT>(pointer);

// Ensure pointer points into the sandbox.
TNode<ExternalReference> sandbox_base_address =
    ExternalConstant(ExternalReference::sandbox_base_address());
TNode<ExternalReference> sandbox_end_address =
    ExternalConstant(ExternalReference::sandbox_end_address());
TNode<UintPtrT> sandbox_base = Load<UintPtrT>(sandbox_base_address);
TNode<UintPtrT> sandbox_end = Load<UintPtrT>(sandbox_end_address);
CSA_CHECK(this, UintPtrGreaterThanOrEqual(sbx_ptr, sandbox_base))(this)->FastCheck(UintPtrGreaterThanOrEqual(sbx_ptr, sandbox_base
));
CSA_CHECK(this, UintPtrLessThan(sbx_ptr, sandbox_end))(this)->FastCheck(UintPtrLessThan(sbx_ptr, sandbox_end));

StoreObjectFieldNoWriteBarrier<SandboxedPtrT>(object, offset, sbx_ptr);
1560#else
StoreObjectFieldNoWriteBarrier<RawPtrT>(object, offset, pointer);
1562#endif  // V8_SANDBOXED_POINTERS
1563}

1565TNode<RawPtrT> CodeStubAssembler::EmptyBackingStoreBufferConstant() {
1566#ifdef V8_SANDBOXED_POINTERS
// TODO(chromium:1218005) consider creating a LoadSandboxedPointerConstant()
// if more of these constants are required later on.
TNode<ExternalReference> empty_backing_store_buffer =
    ExternalConstant(ExternalReference::empty_backing_store_buffer());
return Load<RawPtrT>(empty_backing_store_buffer);
1572#else
return ReinterpretCast<RawPtrT>(IntPtrConstant(0));
1574#endif  // V8_SANDBOXED_POINTERS
1575}

1577#ifdef V8_SANDBOXED_EXTERNAL_POINTERS
1578TNode<ExternalPointerT> CodeStubAssembler::ChangeIndexToExternalPointer(
  TNode<Uint32T> index) {
DCHECK_EQ(kExternalPointerSize, kUInt32Size)((void) 0);
TNode<Uint32T> shifted_index =
    Word32Shl(index, Uint32Constant(kExternalPointerIndexShift));
return ReinterpretCast<ExternalPointerT>(shifted_index);
1584}

1586TNode<Uint32T> CodeStubAssembler::ChangeExternalPointerToIndex(
  TNode<ExternalPointerT> external_pointer) {
DCHECK_EQ(kExternalPointerSize, kUInt32Size)((void) 0);
TNode<Uint32T> shifted_index = ReinterpretCast<Uint32T>(external_pointer);
return Word32Shr(shifted_index, Uint32Constant(kExternalPointerIndexShift));
1591}
1592#endif  // V8_SANDBOXED_EXTERNAL_POINTERS

1594void CodeStubAssembler::InitializeExternalPointerField(TNode<HeapObject> object,
                                                     TNode<IntPtrT> offset) {
1596#ifdef V8_SANDBOXED_EXTERNAL_POINTERS
TNode<ExternalReference> external_pointer_table_address = ExternalConstant(
    ExternalReference::external_pointer_table_address(isolate()));

// We could implement the fast path for allocating from the freelist here,
// however, this logic needs to be atomic and so requires CSA to expose
// atomic operations.
TNode<ExternalReference> table_allocate_function = ExternalConstant(
    ExternalReference::external_pointer_table_allocate_entry());
TNode<Uint32T> index = UncheckedCast<Uint32T>(CallCFunction(
    table_allocate_function, MachineType::Uint32(),
    std::make_pair(MachineType::Pointer(), external_pointer_table_address)));

// Currently, we assume that the caller will immediately initialize the entry
// through StoreExternalPointerToObject after allocating it. That way, we
// avoid initializing the entry twice (once with nullptr, then again with the
// real value). TODO(saelo) initialize the entry with zero here and switch
// callers to a version that initializes the entry with a given pointer.

TNode<ExternalPointerT> pointer = ChangeIndexToExternalPointer(index);
StoreObjectFieldNoWriteBarrier<ExternalPointerT>(object, offset, pointer);
1617#endif
1618}

1620TNode<RawPtrT> CodeStubAssembler::LoadExternalPointerFromObject(
  TNode<HeapObject> object, TNode<IntPtrT> offset,
  ExternalPointerTag external_pointer_tag) {
1623#ifdef V8_SANDBOXED_EXTERNAL_POINTERS
TNode<ExternalReference> external_pointer_table_address = ExternalConstant(
    ExternalReference::external_pointer_table_address(isolate()));
TNode<RawPtrT> table = UncheckedCast<RawPtrT>(
    Load(MachineType::Pointer(), external_pointer_table_address,
         UintPtrConstant(Internals::kExternalPointerTableBufferOffset)));

TNode<ExternalPointerT> encoded =
    LoadObjectField<ExternalPointerT>(object, offset);
TNode<Uint32T> index = ChangeExternalPointerToIndex(encoded);
// TODO(v8:10391): consider updating ElementOffsetFromIndex to generate code
// that does one shift right instead of two shifts (right and then left).
TNode<IntPtrT> table_offset = ElementOffsetFromIndex(
    ChangeUint32ToWord(index), SYSTEM_POINTER_ELEMENTS, 0);

TNode<UintPtrT> entry = Load<UintPtrT>(table, table_offset);
if (external_pointer_tag != 0) {
  TNode<UintPtrT> tag = UintPtrConstant(~external_pointer_tag);
  entry = UncheckedCast<UintPtrT>(WordAnd(entry, tag));
}
return UncheckedCast<RawPtrT>(UncheckedCast<WordT>(entry));
1644#else
return LoadObjectField<RawPtrT>(object, offset);
1646#endif  // V8_SANDBOXED_EXTERNAL_POINTERS
1647}

1649void CodeStubAssembler::StoreExternalPointerToObject(
  TNode<HeapObject> object, TNode<IntPtrT> offset, TNode<RawPtrT> pointer,
  ExternalPointerTag external_pointer_tag) {
1652#ifdef V8_SANDBOXED_EXTERNAL_POINTERS
TNode<ExternalReference> external_pointer_table_address = ExternalConstant(
    ExternalReference::external_pointer_table_address(isolate()));
TNode<RawPtrT> table = UncheckedCast<RawPtrT>(
    Load(MachineType::Pointer(), external_pointer_table_address,
         UintPtrConstant(Internals::kExternalPointerTableBufferOffset)));

TNode<ExternalPointerT> encoded =
    LoadObjectField<ExternalPointerT>(object, offset);
TNode<Uint32T> index = ChangeExternalPointerToIndex(encoded);
// TODO(v8:10391): consider updating ElementOffsetFromIndex to generate code
// that does one shift right instead of two shifts (right and then left).
TNode<IntPtrT> table_offset = ElementOffsetFromIndex(
    ChangeUint32ToWord(index), SYSTEM_POINTER_ELEMENTS, 0);

TNode<UintPtrT> value = UncheckedCast<UintPtrT>(pointer);
if (external_pointer_tag != 0) {
  TNode<UintPtrT> tag = UintPtrConstant(external_pointer_tag);
  value = UncheckedCast<UintPtrT>(WordOr(pointer, tag));
}
StoreNoWriteBarrier(MachineType::PointerRepresentation(), table, table_offset,
                    value);
1674#else
StoreObjectFieldNoWriteBarrier<RawPtrT>(object, offset, pointer);
1676#endif  // V8_SANDBOXED_EXTERNAL_POINTERS
1677}

1679TNode<Object> CodeStubAssembler::LoadFromParentFrame(int offset) {
TNode<RawPtrT> frame_pointer = LoadParentFramePointer();
return LoadFullTagged(frame_pointer, IntPtrConstant(offset));
1682}

1684TNode<Uint8T> CodeStubAssembler::LoadUint8Ptr(TNode<RawPtrT> ptr,
                                            TNode<IntPtrT> offset) {
return Load<Uint8T>(IntPtrAdd(ReinterpretCast<IntPtrT>(ptr), offset));
1687}

1689TNode<IntPtrT> CodeStubAssembler::LoadAndUntagObjectField(
  TNode<HeapObject> object, int offset) {
// Please use LoadMap(object) instead.
DCHECK_NE(offset, HeapObject::kMapOffset)((void) 0);
if (SmiValuesAre32Bits()) {
1694#if V8_TARGET_LITTLE_ENDIAN1
  offset += 4;
1696#endif
  return ChangeInt32ToIntPtr(LoadObjectField<Int32T>(object, offset));
} else {
  return SmiToIntPtr(LoadObjectField<Smi>(object, offset));
}
1701}

1703TNode<Int32T> CodeStubAssembler::LoadAndUntagToWord32ObjectField(
  TNode<HeapObject> object, int offset) {
// Please use LoadMap(object) instead.
DCHECK_NE(offset, HeapObject::kMapOffset)((void) 0);
if (SmiValuesAre32Bits()) {
1708#if V8_TARGET_LITTLE_ENDIAN1
  offset += 4;
1710#endif
  return LoadObjectField<Int32T>(object, offset);
} else {
  return SmiToInt32(LoadObjectField<Smi>(object, offset));
}
1715}

1717TNode<Float64T> CodeStubAssembler::LoadHeapNumberValue(
  TNode<HeapObject> object) {
CSA_DCHECK(this, Word32Or(IsHeapNumber(object), IsOddball(object)))((void)0);
STATIC_ASSERT(HeapNumber::kValueOffset == Oddball::kToNumberRawOffset)static_assert(HeapNumber::kValueOffset == Oddball::kToNumberRawOffset
, "HeapNumber::kValueOffset == Oddball::kToNumberRawOffset");
return LoadObjectField<Float64T>(object, HeapNumber::kValueOffset);
1722}

1724TNode<Map> CodeStubAssembler::GetInstanceTypeMap(InstanceType instance_type) {
Handle<Map> map_handle(
    Map::GetInstanceTypeMap(ReadOnlyRoots(isolate()), instance_type),
    isolate());
return HeapConstant(map_handle);
1729}

1731TNode<Map> CodeStubAssembler::LoadMap(TNode<HeapObject> object) {
TNode<Map> map = LoadObjectField<Map>(object, HeapObject::kMapOffset);
1733#ifdef V8_MAP_PACKING
// Check the loaded map is unpacked. i.e. the lowest two bits != 0b10
CSA_DCHECK(this,((void)0)
           WordNotEqual(WordAnd(BitcastTaggedToWord(map),((void)0)
                                IntPtrConstant(Internals::kMapWordXorMask)),((void)0)
                        IntPtrConstant(Internals::kMapWordSignature)))((void)0);
1739#endif
return map;
1741}

1743TNode<Uint16T> CodeStubAssembler::LoadInstanceType(TNode<HeapObject> object) {
return LoadMapInstanceType(LoadMap(object));
1745}

1747TNode<BoolT> CodeStubAssembler::HasInstanceType(TNode<HeapObject> object,
                                              InstanceType instance_type) {
return InstanceTypeEqual(LoadInstanceType(object), instance_type);
1750}

1752TNode<BoolT> CodeStubAssembler::DoesntHaveInstanceType(
  TNode<HeapObject> object, InstanceType instance_type) {
return Word32NotEqual(LoadInstanceType(object), Int32Constant(instance_type));
1755}

1757TNode<BoolT> CodeStubAssembler::TaggedDoesntHaveInstanceType(
  TNode<HeapObject> any_tagged, InstanceType type) {
/* return Phi <TaggedIsSmi(val), DoesntHaveInstanceType(val, type)> */
TNode<BoolT> tagged_is_smi = TaggedIsSmi(any_tagged);
return Select<BoolT>(
    tagged_is_smi, [=]() { return tagged_is_smi; },
    [=]() { return DoesntHaveInstanceType(any_tagged, type); });
1764}

1766TNode<BoolT> CodeStubAssembler::IsSpecialReceiverMap(TNode<Map> map) {
TNode<BoolT> is_special =
    IsSpecialReceiverInstanceType(LoadMapInstanceType(map));
uint32_t mask = Map::Bits1::HasNamedInterceptorBit::kMask |
                Map::Bits1::IsAccessCheckNeededBit::kMask;
USE(mask)do { ::v8::base::Use unused_tmp_array_for_use_macro[]{mask}; (
void)unused_tmp_array_for_use_macro; } while (false);
// Interceptors or access checks imply special receiver.
CSA_DCHECK(this,((void)0)
           SelectConstant<BoolT>(IsSetWord32(LoadMapBitField(map), mask),((void)0)
                                 is_special, Int32TrueConstant()))((void)0);
return is_special;
1777}

1779TNode<Word32T> CodeStubAssembler::IsStringWrapperElementsKind(TNode<Map> map) {
TNode<Int32T> kind = LoadMapElementsKind(map);
return Word32Or(
    Word32Equal(kind, Int32Constant(FAST_STRING_WRAPPER_ELEMENTS)),
    Word32Equal(kind, Int32Constant(SLOW_STRING_WRAPPER_ELEMENTS)));
1784}

1786void CodeStubAssembler::GotoIfMapHasSlowProperties(TNode<Map> map,
                                                 Label* if_slow) {
GotoIf(IsStringWrapperElementsKind(map), if_slow);
GotoIf(IsSpecialReceiverMap(map), if_slow);
GotoIf(IsDictionaryMap(map), if_slow);
1791}

1793TNode<HeapObject> CodeStubAssembler::LoadFastProperties(
  TNode<JSReceiver> object) {
CSA_SLOW_DCHECK(this, Word32BinaryNot(IsDictionaryMap(LoadMap(object))))((void)0);
TNode<Object> properties = LoadJSReceiverPropertiesOrHash(object);
return Select<HeapObject>(
    TaggedIsSmi(properties), [=] { return EmptyFixedArrayConstant(); },
    [=] { return CAST(properties)Cast(properties); });
1800}

1802TNode<HeapObject> CodeStubAssembler::LoadSlowProperties(
  TNode<JSReceiver> object) {
CSA_SLOW_DCHECK(this, IsDictionaryMap(LoadMap(object)))((void)0);
TNode<Object> properties = LoadJSReceiverPropertiesOrHash(object);
NodeGenerator<HeapObject> make_empty = [=]() -> TNode<HeapObject> {
  if (V8_ENABLE_SWISS_NAME_DICTIONARY_BOOLfalse) {
    return EmptySwissPropertyDictionaryConstant();
  } else {
    return EmptyPropertyDictionaryConstant();
  }
};
NodeGenerator<HeapObject> cast_properties = [=] {
  TNode<HeapObject> dict = CAST(properties)Cast(properties);
  if (V8_ENABLE_SWISS_NAME_DICTIONARY_BOOLfalse) {
    CSA_DCHECK(this, Word32Or(IsSwissNameDictionary(dict),((void)0)
                              IsGlobalDictionary(dict)))((void)0);
  } else {
    CSA_DCHECK(this,((void)0)
               Word32Or(IsNameDictionary(dict), IsGlobalDictionary(dict)))((void)0);
  }
  return dict;
};
return Select<HeapObject>(TaggedIsSmi(properties), make_empty,
                          cast_properties);
1826}

1828TNode<Object> CodeStubAssembler::LoadJSArgumentsObjectLength(
  TNode<Context> context, TNode<JSArgumentsObject> array) {
CSA_DCHECK(this, IsJSArgumentsObjectWithLength(context, array))((void)0);
constexpr int offset = JSStrictArgumentsObject::kLengthOffset;
STATIC_ASSERT(offset == JSSloppyArgumentsObject::kLengthOffset)static_assert(offset == JSSloppyArgumentsObject::kLengthOffset
, "offset == JSSloppyArgumentsObject::kLengthOffset");
return LoadObjectField(array, offset);
1834}

1836TNode<Smi> CodeStubAssembler::LoadFastJSArrayLength(TNode<JSArray> array) {
TNode<Number> length = LoadJSArrayLength(array);
CSA_DCHECK(this, Word32Or(IsFastElementsKind(LoadElementsKind(array)),((void)0)
                          IsElementsKindInRange(((void)0)
                              LoadElementsKind(array),((void)0)
                              FIRST_ANY_NONEXTENSIBLE_ELEMENTS_KIND,((void)0)
                              LAST_ANY_NONEXTENSIBLE_ELEMENTS_KIND)))((void)0);
// JSArray length is always a positive Smi for fast arrays.
CSA_SLOW_DCHECK(this, TaggedIsPositiveSmi(length))((void)0);
return CAST(length)Cast(length);
1846}

1848TNode<Smi> CodeStubAssembler::LoadFixedArrayBaseLength(
  TNode<FixedArrayBase> array) {
CSA_SLOW_DCHECK(this, IsNotWeakFixedArraySubclass(array))((void)0);
return LoadObjectField<Smi>(array, FixedArrayBase::kLengthOffset);
1852}

1854TNode<IntPtrT> CodeStubAssembler::LoadAndUntagFixedArrayBaseLength(
  TNode<FixedArrayBase> array) {
return LoadAndUntagObjectField(array, FixedArrayBase::kLengthOffset);
1857}

1859TNode<IntPtrT> CodeStubAssembler::LoadFeedbackVectorLength(
  TNode<FeedbackVector> vector) {
return ChangeInt32ToIntPtr(
    LoadObjectField<Int32T>(vector, FeedbackVector::kLengthOffset));
1863}

1865TNode<Smi> CodeStubAssembler::LoadWeakFixedArrayLength(
  TNode<WeakFixedArray> array) {
return LoadObjectField<Smi>(array, WeakFixedArray::kLengthOffset);
1868}

1870TNode<IntPtrT> CodeStubAssembler::LoadAndUntagWeakFixedArrayLength(
  TNode<WeakFixedArray> array) {
return LoadAndUntagObjectField(array, WeakFixedArray::kLengthOffset);
1873}

1875TNode<Int32T> CodeStubAssembler::LoadNumberOfDescriptors(
  TNode<DescriptorArray> array) {
return UncheckedCast<Int32T>(LoadObjectField<Int16T>(
    array, DescriptorArray::kNumberOfDescriptorsOffset));
1879}

1881TNode<Int32T> CodeStubAssembler::LoadNumberOfOwnDescriptors(TNode<Map> map) {
TNode<Uint32T> bit_field3 = LoadMapBitField3(map);
return UncheckedCast<Int32T>(
    DecodeWord32<Map::Bits3::NumberOfOwnDescriptorsBits>(bit_field3));
1885}

1887TNode<Int32T> CodeStubAssembler::LoadMapBitField(TNode<Map> map) {
return UncheckedCast<Int32T>(
    LoadObjectField<Uint8T>(map, Map::kBitFieldOffset));
1890}

1892TNode<Int32T> CodeStubAssembler::LoadMapBitField2(TNode<Map> map) {
return UncheckedCast<Int32T>(
    LoadObjectField<Uint8T>(map, Map::kBitField2Offset));
1895}

1897TNode<Uint32T> CodeStubAssembler::LoadMapBitField3(TNode<Map> map) {
return LoadObjectField<Uint32T>(map, Map::kBitField3Offset);
1899}

1901TNode<Uint16T> CodeStubAssembler::LoadMapInstanceType(TNode<Map> map) {
return LoadObjectField<Uint16T>(map, Map::kInstanceTypeOffset);
1903}

1905TNode<Int32T> CodeStubAssembler::LoadMapElementsKind(TNode<Map> map) {
TNode<Int32T> bit_field2 = LoadMapBitField2(map);
return Signed(DecodeWord32<Map::Bits2::ElementsKindBits>(bit_field2));
1908}

1910TNode<Int32T> CodeStubAssembler::LoadElementsKind(TNode<HeapObject> object) {
return LoadMapElementsKind(LoadMap(object));
1912}

1914TNode<DescriptorArray> CodeStubAssembler::LoadMapDescriptors(TNode<Map> map) {
return LoadObjectField<DescriptorArray>(map, Map::kInstanceDescriptorsOffset);
1916}

1918TNode<HeapObject> CodeStubAssembler::LoadMapPrototype(TNode<Map> map) {
return LoadObjectField<HeapObject>(map, Map::kPrototypeOffset);
1920}

1922TNode<IntPtrT> CodeStubAssembler::LoadMapInstanceSizeInWords(TNode<Map> map) {
return ChangeInt32ToIntPtr(
    LoadObjectField<Uint8T>(map, Map::kInstanceSizeInWordsOffset));
1925}

1927TNode<IntPtrT> CodeStubAssembler::LoadMapInobjectPropertiesStartInWords(
  TNode<Map> map) {
// See Map::GetInObjectPropertiesStartInWords() for details.
CSA_DCHECK(this, IsJSObjectMap(map))((void)0);
return ChangeInt32ToIntPtr(LoadObjectField<Uint8T>(
    map, Map::kInobjectPropertiesStartOrConstructorFunctionIndexOffset));
1933}

1935TNode<IntPtrT> CodeStubAssembler::LoadMapConstructorFunctionIndex(
  TNode<Map> map) {
// See Map::GetConstructorFunctionIndex() for details.
CSA_DCHECK(this, IsPrimitiveInstanceType(LoadMapInstanceType(map)))((void)0);
return ChangeInt32ToIntPtr(LoadObjectField<Uint8T>(
    map, Map::kInobjectPropertiesStartOrConstructorFunctionIndexOffset));
1941}

1943TNode<Object> CodeStubAssembler::LoadMapConstructor(TNode<Map> map) {
TVARIABLE(Object, result,TVariable<Object> result(LoadObjectField( map, Map::kConstructorOrBackPointerOrNativeContextOffset
), this)
          LoadObjectField(TVariable<Object> result(LoadObjectField( map, Map::kConstructorOrBackPointerOrNativeContextOffset
), this)
              map, Map::kConstructorOrBackPointerOrNativeContextOffset))TVariable<Object> result(LoadObjectField( map, Map::kConstructorOrBackPointerOrNativeContextOffset
), this);

Label done(this), loop(this, &result);
Goto(&loop);
BIND(&loop)Bind(&loop);
{
  GotoIf(TaggedIsSmi(result.value()), &done);
  TNode<BoolT> is_map_type =
      InstanceTypeEqual(LoadInstanceType(CAST(result.value())Cast(result.value())), MAP_TYPE);
  GotoIfNot(is_map_type, &done);
  result =
      LoadObjectField(CAST(result.value())Cast(result.value()),
                      Map::kConstructorOrBackPointerOrNativeContextOffset);
  Goto(&loop);
}
BIND(&done)Bind(&done);
return result.value();
1963}

1965TNode<WordT> CodeStubAssembler::LoadMapEnumLength(TNode<Map> map) {
TNode<Uint32T> bit_field3 = LoadMapBitField3(map);
return DecodeWordFromWord32<Map::Bits3::EnumLengthBits>(bit_field3);
1968}

1970TNode<Object> CodeStubAssembler::LoadMapBackPointer(TNode<Map> map) {
TNode<HeapObject> object = CAST(LoadObjectField(Cast(LoadObjectField( map, Map::kConstructorOrBackPointerOrNativeContextOffset
))
    map, Map::kConstructorOrBackPointerOrNativeContextOffset))Cast(LoadObjectField( map, Map::kConstructorOrBackPointerOrNativeContextOffset
));
return Select<Object>(
    IsMap(object), [=] { return object; },
    [=] { return UndefinedConstant(); });
1976}

1978TNode<Uint32T> CodeStubAssembler::EnsureOnlyHasSimpleProperties(
  TNode<Map> map, TNode<Int32T> instance_type, Label* bailout) {
// This check can have false positives, since it applies to any
// JSPrimitiveWrapper type.
GotoIf(IsCustomElementsReceiverInstanceType(instance_type), bailout);

TNode<Uint32T> bit_field3 = LoadMapBitField3(map);
GotoIf(IsSetWord32(bit_field3, Map::Bits3::IsDictionaryMapBit::kMask),
       bailout);

return bit_field3;
1989}

1991TNode<IntPtrT> CodeStubAssembler::LoadJSReceiverIdentityHash(
  TNode<JSReceiver> receiver, Label* if_no_hash) {
TVARIABLE(IntPtrT, var_hash)TVariable<IntPtrT> var_hash(this);
Label done(this), if_smi(this), if_property_array(this),
    if_swiss_property_dictionary(this), if_property_dictionary(this),
    if_fixed_array(this);

TNode<Object> properties_or_hash =
    LoadObjectField(receiver, JSReceiver::kPropertiesOrHashOffset);
GotoIf(TaggedIsSmi(properties_or_hash), &if_smi);

TNode<HeapObject> properties = CAST(properties_or_hash)Cast(properties_or_hash);
TNode<Uint16T> properties_instance_type = LoadInstanceType(properties);

GotoIf(InstanceTypeEqual(properties_instance_type, PROPERTY_ARRAY_TYPE),
       &if_property_array);
if (V8_ENABLE_SWISS_NAME_DICTIONARY_BOOLfalse) {
  GotoIf(
      InstanceTypeEqual(properties_instance_type, SWISS_NAME_DICTIONARY_TYPE),
      &if_swiss_property_dictionary);
}
Branch(InstanceTypeEqual(properties_instance_type, NAME_DICTIONARY_TYPE),
       &if_property_dictionary, &if_fixed_array);

BIND(&if_fixed_array)Bind(&if_fixed_array);
{
  var_hash = IntPtrConstant(PropertyArray::kNoHashSentinel);
  Goto(&done);
}

BIND(&if_smi)Bind(&if_smi);
{
  var_hash = SmiUntag(CAST(properties_or_hash)Cast(properties_or_hash));
  Goto(&done);
}

BIND(&if_property_array)Bind(&if_property_array);
{
  TNode<IntPtrT> length_and_hash = LoadAndUntagObjectField(
      properties, PropertyArray::kLengthAndHashOffset);
  var_hash = Signed(DecodeWord<PropertyArray::HashField>(length_and_hash));
  Goto(&done);
}
if (V8_ENABLE_SWISS_NAME_DICTIONARY_BOOLfalse) {
  BIND(&if_swiss_property_dictionary)Bind(&if_swiss_property_dictionary);
  {
    var_hash = Signed(
        ChangeUint32ToWord(LoadSwissNameDictionaryHash(CAST(properties)Cast(properties))));
    Goto(&done);
  }
}

BIND(&if_property_dictionary)Bind(&if_property_dictionary);
{
  var_hash = SmiUntag(CAST(LoadFixedArrayElement(Cast(LoadFixedArrayElement( Cast(properties), NameDictionary::
kObjectHashIndex))
      CAST(properties), NameDictionary::kObjectHashIndex))Cast(LoadFixedArrayElement( Cast(properties), NameDictionary::
kObjectHashIndex)));
  Goto(&done);
}

BIND(&done)Bind(&done);
if (if_no_hash != nullptr) {
  GotoIf(IntPtrEqual(var_hash.value(),
                     IntPtrConstant(PropertyArray::kNoHashSentinel)),
         if_no_hash);
}
return var_hash.value();
2057}

2059TNode<Uint32T> CodeStubAssembler::LoadNameHashAssumeComputed(TNode<Name> name) {
TNode<Uint32T> hash_field = LoadNameRawHashField(name);
CSA_DCHECK(this, IsClearWord32(hash_field, Name::kHashNotComputedMask))((void)0);
return DecodeWord32<Name::HashBits>(hash_field);
2063}

2065TNode<Uint32T> CodeStubAssembler::LoadNameHash(TNode<Name> name,
                                             Label* if_hash_not_computed) {
TNode<Uint32T> raw_hash_field = LoadNameRawHashField(name);
if (if_hash_not_computed != nullptr) {
  GotoIf(IsSetWord32(raw_hash_field, Name::kHashNotComputedMask),
         if_hash_not_computed);
}
return DecodeWord32<Name::HashBits>(raw_hash_field);
2073}

2075TNode<Smi> CodeStubAssembler::LoadStringLengthAsSmi(TNode<String> string) {
return SmiFromIntPtr(LoadStringLengthAsWord(string));
2077}

2079TNode<IntPtrT> CodeStubAssembler::LoadStringLengthAsWord(TNode<String> string) {
return Signed(ChangeUint32ToWord(LoadStringLengthAsWord32(string)));
2081}

2083TNode<Uint32T> CodeStubAssembler::LoadStringLengthAsWord32(
  TNode<String> string) {
return LoadObjectField<Uint32T>(string, String::kLengthOffset);
2086}

2088TNode<Object> CodeStubAssembler::LoadJSPrimitiveWrapperValue(
  TNode<JSPrimitiveWrapper> object) {
return LoadObjectField(object, JSPrimitiveWrapper::kValueOffset);
2091}

2093void CodeStubAssembler::DispatchMaybeObject(TNode<MaybeObject> maybe_object,
                                          Label* if_smi, Label* if_cleared,
                                          Label* if_weak, Label* if_strong,
                                          TVariable<Object>* extracted) {
Label inner_if_smi(this), inner_if_strong(this);

GotoIf(TaggedIsSmi(maybe_object), &inner_if_smi);

GotoIf(IsCleared(maybe_object), if_cleared);

GotoIf(IsStrong(maybe_object), &inner_if_strong);

*extracted = GetHeapObjectAssumeWeak(maybe_object);
Goto(if_weak);

BIND(&inner_if_smi)Bind(&inner_if_smi);
*extracted = CAST(maybe_object)Cast(maybe_object);
Goto(if_smi);

BIND(&inner_if_strong)Bind(&inner_if_strong);
*extracted = CAST(maybe_object)Cast(maybe_object);
Goto(if_strong);
2115}

2117void CodeStubAssembler::DcheckHasValidMap(TNode<HeapObject> object) {
2118#ifdef V8_MAP_PACKING
// Test if the map is an unpacked and valid map
CSA_DCHECK(this, IsMap(LoadMap(object)))((void)0);
2121#endif
2122}

2124TNode<BoolT> CodeStubAssembler::IsStrong(TNode<MaybeObject> value) {
return Word32Equal(Word32And(TruncateIntPtrToInt32(
                                 BitcastTaggedToWordForTagAndSmiBits(value)),
                             Int32Constant(kHeapObjectTagMask)),
                   Int32Constant(kHeapObjectTag));
2129}

2131TNode<HeapObject> CodeStubAssembler::GetHeapObjectIfStrong(
  TNode<MaybeObject> value, Label* if_not_strong) {
GotoIfNot(IsStrong(value), if_not_strong);
return CAST(value)Cast(value);
2135}

2137TNode<BoolT> CodeStubAssembler::IsWeakOrCleared(TNode<MaybeObject> value) {
return Word32Equal(Word32And(TruncateIntPtrToInt32(
                                 BitcastTaggedToWordForTagAndSmiBits(value)),
                             Int32Constant(kHeapObjectTagMask)),
                   Int32Constant(kWeakHeapObjectTag));
2142}

2144TNode<BoolT> CodeStubAssembler::IsCleared(TNode<MaybeObject> value) {
return Word32Equal(TruncateIntPtrToInt32(BitcastMaybeObjectToWord(value)),
                   Int32Constant(kClearedWeakHeapObjectLower32));
2147}

2149TNode<HeapObject> CodeStubAssembler::GetHeapObjectAssumeWeak(
  TNode<MaybeObject> value) {
CSA_DCHECK(this, IsWeakOrCleared(value))((void)0);
CSA_DCHECK(this, IsNotCleared(value))((void)0);
return UncheckedCast<HeapObject>(BitcastWordToTagged(WordAnd(
    BitcastMaybeObjectToWord(value), IntPtrConstant(~kWeakHeapObjectMask))));
2155}

2157TNode<HeapObject> CodeStubAssembler::GetHeapObjectAssumeWeak(
  TNode<MaybeObject> value, Label* if_cleared) {
GotoIf(IsCleared(value), if_cleared);
return GetHeapObjectAssumeWeak(value);
2161}

2163// This version generates
2164//   (maybe_object & ~mask) == value
2165// It works for non-Smi |maybe_object| and for both Smi and HeapObject values
2166// but requires a big constant for ~mask.
2167TNode<BoolT> CodeStubAssembler::IsWeakReferenceToObject(
  TNode<MaybeObject> maybe_object, TNode<Object> value) {
CSA_DCHECK(this, TaggedIsNotSmi(maybe_object))((void)0);
if (COMPRESS_POINTERS_BOOLfalse) {
  return Word32Equal(
      Word32And(TruncateWordToInt32(BitcastMaybeObjectToWord(maybe_object)),
                Uint32Constant(~static_cast<uint32_t>(kWeakHeapObjectMask))),
      TruncateWordToInt32(BitcastTaggedToWord(value)));
} else {
  return WordEqual(WordAnd(BitcastMaybeObjectToWord(maybe_object),
                           IntPtrConstant(~kWeakHeapObjectMask)),
                   BitcastTaggedToWord(value));
}
2180}

2182// This version generates
2183//   maybe_object == (heap_object | mask)
2184// It works for any |maybe_object| values and generates a better code because it
2185// uses a small constant for mask.
2186TNode<BoolT> CodeStubAssembler::IsWeakReferenceTo(
  TNode<MaybeObject> maybe_object, TNode<HeapObject> heap_object) {
if (COMPRESS_POINTERS_BOOLfalse) {
  return Word32Equal(
      TruncateWordToInt32(BitcastMaybeObjectToWord(maybe_object)),
      Word32Or(TruncateWordToInt32(BitcastTaggedToWord(heap_object)),
               Int32Constant(kWeakHeapObjectMask)));
} else {
  return WordEqual(BitcastMaybeObjectToWord(maybe_object),
                   WordOr(BitcastTaggedToWord(heap_object),
                          IntPtrConstant(kWeakHeapObjectMask)));
}
2198}

2200TNode<MaybeObject> CodeStubAssembler::MakeWeak(TNode<HeapObject> value) {
return ReinterpretCast<MaybeObject>(BitcastWordToTagged(
    WordOr(BitcastTaggedToWord(value), IntPtrConstant(kWeakHeapObjectTag))));
2203}

2205template <>
2206TNode<IntPtrT> CodeStubAssembler::LoadArrayLength(TNode<FixedArray> array) {
return LoadAndUntagFixedArrayBaseLength(array);
2208}

2210template <>
2211TNode<IntPtrT> CodeStubAssembler::LoadArrayLength(TNode<WeakFixedArray> array) {
return LoadAndUntagWeakFixedArrayLength(array);
2213}

2215template <>
2216TNode<IntPtrT> CodeStubAssembler::LoadArrayLength(TNode<PropertyArray> array) {
return LoadPropertyArrayLength(array);
2218}

2220template <>
2221TNode<IntPtrT> CodeStubAssembler::LoadArrayLength(
  TNode<DescriptorArray> array) {
return IntPtrMul(ChangeInt32ToIntPtr(LoadNumberOfDescriptors(array)),
                 IntPtrConstant(DescriptorArray::kEntrySize));
2225}

2227template <>
2228TNode<IntPtrT> CodeStubAssembler::LoadArrayLength(
  TNode<TransitionArray> array) {
return LoadAndUntagWeakFixedArrayLength(array);
2231}

2233template <typename Array, typename TIndex, typename TValue>
2234TNode<TValue> CodeStubAssembler::LoadArrayElement(TNode<Array> array,
                                                int array_header_size,
                                                TNode<TIndex> index_node,
                                                int additional_offset) {
// TODO(v8:9708): Do we want to keep both IntPtrT and UintPtrT variants?
static_assert(std::is_same<TIndex, Smi>::value ||
                  std::is_same<TIndex, UintPtrT>::value ||
                  std::is_same<TIndex, IntPtrT>::value,
              "Only Smi, UintPtrT or IntPtrT indices are allowed");
CSA_DCHECK(this, IntPtrGreaterThanOrEqual(ParameterToIntPtr(index_node),((void)0)
                                          IntPtrConstant(0)))((void)0);
DCHECK(IsAligned(additional_offset, kTaggedSize))((void) 0);
int32_t header_size = array_header_size + additional_offset - kHeapObjectTag;
TNode<IntPtrT> offset =
    ElementOffsetFromIndex(index_node, HOLEY_ELEMENTS, header_size);
CSA_DCHECK(this, IsOffsetInBounds(offset, LoadArrayLength(array),((void)0)
                                  array_header_size))((void)0);
constexpr MachineType machine_type = MachineTypeOf<TValue>::value;
return UncheckedCast<TValue>(LoadFromObject(machine_type, array, offset));
2253}

2255template V8_EXPORT_PRIVATE TNode<MaybeObject>
2256CodeStubAssembler::LoadArrayElement<TransitionArray, IntPtrT>(
  TNode<TransitionArray>, int, TNode<IntPtrT>, int);

2259template <typename TIndex>
2260TNode<Object> CodeStubAssembler::LoadFixedArrayElement(
  TNode<FixedArray> object, TNode<TIndex> index, int additional_offset,
  CheckBounds check_bounds) {
// TODO(v8:9708): Do we want to keep both IntPtrT and UintPtrT variants?
static_assert(std::is_same<TIndex, Smi>::value ||
                  std::is_same<TIndex, UintPtrT>::value ||
                  std::is_same<TIndex, IntPtrT>::value,
              "Only Smi, UintPtrT or IntPtrT indexes are allowed");
CSA_DCHECK(this, IsFixedArraySubclass(object))((void)0);
CSA_DCHECK(this, IsNotWeakFixedArraySubclass(object))((void)0);

if (NeedsBoundsCheck(check_bounds)) {
  FixedArrayBoundsCheck(object, index, additional_offset);
}
TNode<MaybeObject> element = LoadArrayElement(object, FixedArray::kHeaderSize,
                                              index, additional_offset);
return CAST(element)Cast(element);
2277}

2279template V8_EXPORT_PRIVATE TNode<Object>
2280CodeStubAssembler::LoadFixedArrayElement<Smi>(TNode<FixedArray>, TNode<Smi>,
                                            int, CheckBounds);
2282template V8_EXPORT_PRIVATE TNode<Object>
2283CodeStubAssembler::LoadFixedArrayElement<UintPtrT>(TNode<FixedArray>,
                                                 TNode<UintPtrT>, int,
                                                 CheckBounds);
2286template V8_EXPORT_PRIVATE TNode<Object>
2287CodeStubAssembler::LoadFixedArrayElement<IntPtrT>(TNode<FixedArray>,
                                                TNode<IntPtrT>, int,
                                                CheckBounds);

2291void CodeStubAssembler::FixedArrayBoundsCheck(TNode<FixedArrayBase> array,
                                            TNode<Smi> index,
                                            int additional_offset) {
if (!FLAG_fixed_array_bounds_checks) return;
DCHECK(IsAligned(additional_offset, kTaggedSize))((void) 0);
TNode<Smi> effective_index;
Smi constant_index;
bool index_is_constant = TryToSmiConstant(index, &constant_index);
if (index_is_constant) {
  effective_index = SmiConstant(Smi::ToInt(constant_index) +
                                additional_offset / kTaggedSize);
} else {
  effective_index =
      SmiAdd(index, SmiConstant(additional_offset / kTaggedSize));
}
CSA_CHECK(this, SmiBelow(effective_index, LoadFixedArrayBaseLength(array)))(this)->FastCheck(SmiBelow(effective_index, LoadFixedArrayBaseLength
(array)));
2307}

2309void CodeStubAssembler::FixedArrayBoundsCheck(TNode<FixedArrayBase> array,
                                            TNode<IntPtrT> index,
                                            int additional_offset) {
if (!FLAG_fixed_array_bounds_checks) return;
DCHECK(IsAligned(additional_offset, kTaggedSize))((void) 0);
// IntPtrAdd does constant-folding automatically.
TNode<IntPtrT> effective_index =
    IntPtrAdd(index, IntPtrConstant(additional_offset / kTaggedSize));
CSA_CHECK(this, UintPtrLessThan(effective_index,(this)->FastCheck(UintPtrLessThan(effective_index, LoadAndUntagFixedArrayBaseLength
(array)))
                                LoadAndUntagFixedArrayBaseLength(array)))(this)->FastCheck(UintPtrLessThan(effective_index, LoadAndUntagFixedArrayBaseLength
(array)));
2319}

2321TNode<Object> CodeStubAssembler::LoadPropertyArrayElement(
  TNode<PropertyArray> object, TNode<IntPtrT> index) {
int additional_offset = 0;
return CAST(LoadArrayElement(object, PropertyArray::kHeaderSize, index,Cast(LoadArrayElement(object, PropertyArray::kHeaderSize, index
, additional_offset))
                             additional_offset))Cast(LoadArrayElement(object, PropertyArray::kHeaderSize, index
, additional_offset));
2326}

2328TNode<IntPtrT> CodeStubAssembler::LoadPropertyArrayLength(
  TNode<PropertyArray> object) {
TNode<IntPtrT> value =
    LoadAndUntagObjectField(object, PropertyArray::kLengthAndHashOffset);
return Signed(DecodeWord<PropertyArray::LengthField>(value));
2333}

2335TNode<RawPtrT> CodeStubAssembler::LoadJSTypedArrayDataPtr(
  TNode<JSTypedArray> typed_array) {
// Data pointer = external_pointer + static_cast<Tagged_t>(base_pointer).
TNode<RawPtrT> external_pointer =
    LoadJSTypedArrayExternalPointerPtr(typed_array);

TNode<IntPtrT> base_pointer;
if (COMPRESS_POINTERS_BOOLfalse) {
  TNode<Int32T> compressed_base =
      LoadObjectField<Int32T>(typed_array, JSTypedArray::kBasePointerOffset);
  // Zero-extend TaggedT to WordT according to current compression scheme
  // so that the addition with |external_pointer| (which already contains
  // compensated offset value) below will decompress the tagged value.
  // See JSTypedArray::ExternalPointerCompensationForOnHeapArray() for
  // details.
  base_pointer = Signed(ChangeUint32ToWord(compressed_base));
} else {
  base_pointer =
      LoadObjectField<IntPtrT>(typed_array, JSTypedArray::kBasePointerOffset);
}
return RawPtrAdd(external_pointer, base_pointer);
2356}

2358TNode<BigInt> CodeStubAssembler::LoadFixedBigInt64ArrayElementAsTagged(
  TNode<RawPtrT> data_pointer, TNode<IntPtrT> offset) {
if (Is64()) {
  TNode<IntPtrT> value = Load<IntPtrT>(data_pointer, offset);
  return BigIntFromInt64(value);
} else {
  DCHECK(!Is64())((void) 0);
2365#if defined(V8_TARGET_BIG_ENDIAN)
  TNode<IntPtrT> high = Load<IntPtrT>(data_pointer, offset);
  TNode<IntPtrT> low = Load<IntPtrT>(
      data_pointer, IntPtrAdd(offset, IntPtrConstant(kSystemPointerSize)));
2369#else
  TNode<IntPtrT> low = Load<IntPtrT>(data_pointer, offset);
  TNode<IntPtrT> high = Load<IntPtrT>(
      data_pointer, IntPtrAdd(offset, IntPtrConstant(kSystemPointerSize)));
2373#endif
  return BigIntFromInt32Pair(low, high);
}
2376}

2378TNode<BigInt> CodeStubAssembler::BigIntFromInt32Pair(TNode<IntPtrT> low,
                                                   TNode<IntPtrT> high) {
DCHECK(!Is64())((void) 0);
TVARIABLE(BigInt, var_result)TVariable<BigInt> var_result(this);
TVARIABLE(Word32T, var_sign, Int32Constant(BigInt::SignBits::encode(false)))TVariable<Word32T> var_sign(Int32Constant(BigInt::SignBits
::encode(false)), this);
TVARIABLE(IntPtrT, var_high, high)TVariable<IntPtrT> var_high(high, this);
TVARIABLE(IntPtrT, var_low, low)TVariable<IntPtrT> var_low(low, this);
Label high_zero(this), negative(this), allocate_one_digit(this),
    allocate_two_digits(this), if_zero(this), done(this);

GotoIf(IntPtrEqual(var_high.value(), IntPtrConstant(0)), &high_zero);
Branch(IntPtrLessThan(var_high.value(), IntPtrConstant(0)), &negative,
       &allocate_two_digits);

BIND(&high_zero)Bind(&high_zero);
Branch(IntPtrEqual(var_low.value(), IntPtrConstant(0)), &if_zero,
       &allocate_one_digit);

BIND(&negative)Bind(&negative);
{
  var_sign = Int32Constant(BigInt::SignBits::encode(true));
  // We must negate the value by computing "0 - (high|low)", performing
  // both parts of the subtraction separately and manually taking care
  // of the carry bit (which is 1 iff low != 0).
  var_high = IntPtrSub(IntPtrConstant(0), var_high.value());
  Label carry(this), no_carry(this);
  Branch(IntPtrEqual(var_low.value(), IntPtrConstant(0)), &no_carry, &carry);
  BIND(&carry)Bind(&carry);
  var_high = IntPtrSub(var_high.value(), IntPtrConstant(1));
  Goto(&no_carry);
  BIND(&no_carry)Bind(&no_carry);
  var_low = IntPtrSub(IntPtrConstant(0), var_low.value());
  // var_high was non-zero going into this block, but subtracting the
  // carry bit from it could bring us back onto the "one digit" path.
  Branch(IntPtrEqual(var_high.value(), IntPtrConstant(0)),
         &allocate_one_digit, &allocate_two_digits);
}

BIND(&allocate_one_digit)Bind(&allocate_one_digit);
{
  var_result = AllocateRawBigInt(IntPtrConstant(1));
  StoreBigIntBitfield(var_result.value(),
                      Word32Or(var_sign.value(),
                               Int32Constant(BigInt::LengthBits::encode(1))));
  StoreBigIntDigit(var_result.value(), 0, Unsigned(var_low.value()));
  Goto(&done);
}

BIND(&allocate_two_digits)Bind(&allocate_two_digits);
{
  var_result = AllocateRawBigInt(IntPtrConstant(2));
  StoreBigIntBitfield(var_result.value(),
                      Word32Or(var_sign.value(),
                               Int32Constant(BigInt::LengthBits::encode(2))));
  StoreBigIntDigit(var_result.value(), 0, Unsigned(var_low.value()));
  StoreBigIntDigit(var_result.value(), 1, Unsigned(var_high.value()));
  Goto(&done);
}

BIND(&if_zero)Bind(&if_zero);
var_result = AllocateBigInt(IntPtrConstant(0));
Goto(&done);

BIND(&done)Bind(&done);
return var_result.value();
2443}

2445TNode<BigInt> CodeStubAssembler::BigIntFromInt64(TNode<IntPtrT> value) {
DCHECK(Is64())((void) 0);
TVARIABLE(BigInt, var_result)TVariable<BigInt> var_result(this);
Label done(this), if_positive(this), if_negative(this), if_zero(this);
GotoIf(IntPtrEqual(value, IntPtrConstant(0)), &if_zero);
var_result = AllocateRawBigInt(IntPtrConstant(1));
Branch(IntPtrGreaterThan(value, IntPtrConstant(0)), &if_positive,
       &if_negative);

BIND(&if_positive)Bind(&if_positive);
{
  StoreBigIntBitfield(var_result.value(),
                      Int32Constant(BigInt::SignBits::encode(false) |
                                    BigInt::LengthBits::encode(1)));
  StoreBigIntDigit(var_result.value(), 0, Unsigned(value));
  Goto(&done);
}

BIND(&if_negative)Bind(&if_negative);
{
  StoreBigIntBitfield(var_result.value(),
                      Int32Constant(BigInt::SignBits::encode(true) |
                                    BigInt::LengthBits::encode(1)));
  StoreBigIntDigit(var_result.value(), 0,
                   Unsigned(IntPtrSub(IntPtrConstant(0), value)));
  Goto(&done);
}

BIND(&if_zero)Bind(&if_zero);
{
  var_result = AllocateBigInt(IntPtrConstant(0));
  Goto(&done);
}

BIND(&done)Bind(&done);
return var_result.value();
2481}

2483TNode<BigInt> CodeStubAssembler::LoadFixedBigUint64ArrayElementAsTagged(
  TNode<RawPtrT> data_pointer, TNode<IntPtrT> offset) {
Label if_zero(this), done(this);
if (Is64()) {
  TNode<UintPtrT> value = Load<UintPtrT>(data_pointer, offset);
  return BigIntFromUint64(value);
} else {
  DCHECK(!Is64())((void) 0);
2491#if defined(V8_TARGET_BIG_ENDIAN)
  TNode<UintPtrT> high = Load<UintPtrT>(data_pointer, offset);
  TNode<UintPtrT> low = Load<UintPtrT>(
      data_pointer, IntPtrAdd(offset, IntPtrConstant(kSystemPointerSize)));
2495#else
  TNode<UintPtrT> low = Load<UintPtrT>(data_pointer, offset);
  TNode<UintPtrT> high = Load<UintPtrT>(
      data_pointer, IntPtrAdd(offset, IntPtrConstant(kSystemPointerSize)));
2499#endif
  return BigIntFromUint32Pair(low, high);
}
2502}

2504TNode<BigInt> CodeStubAssembler::BigIntFromUint32Pair(TNode<UintPtrT> low,
                                                    TNode<UintPtrT> high) {
DCHECK(!Is64())((void) 0);
TVARIABLE(BigInt, var_result)TVariable<BigInt> var_result(this);
Label high_zero(this), if_zero(this), done(this);

GotoIf(IntPtrEqual(high, IntPtrConstant(0)), &high_zero);
var_result = AllocateBigInt(IntPtrConstant(2));
StoreBigIntDigit(var_result.value(), 0, low);
StoreBigIntDigit(var_result.value(), 1, high);
Goto(&done);

BIND(&high_zero)Bind(&high_zero);
GotoIf(IntPtrEqual(low, IntPtrConstant(0)), &if_zero);
var_result = AllocateBigInt(IntPtrConstant(1));
StoreBigIntDigit(var_result.value(), 0, low);
Goto(&done);

BIND(&if_zero)Bind(&if_zero);
var_result = AllocateBigInt(IntPtrConstant(0));
Goto(&done);

BIND(&done)Bind(&done);
return var_result.value();
2528}

2530TNode<BigInt> CodeStubAssembler::BigIntFromUint64(TNode<UintPtrT> value) {
DCHECK(Is64())((void) 0);
TVARIABLE(BigInt, var_result)TVariable<BigInt> var_result(this);
Label done(this), if_zero(this);
GotoIf(IntPtrEqual(value, IntPtrConstant(0)), &if_zero);
var_result = AllocateBigInt(IntPtrConstant(1));
StoreBigIntDigit(var_result.value(), 0, value);
Goto(&done);

BIND(&if_zero)Bind(&if_zero);
var_result = AllocateBigInt(IntPtrConstant(0));
Goto(&done);
BIND(&done)Bind(&done);
return var_result.value();
2544}

2546TNode<Numeric> CodeStubAssembler::LoadFixedTypedArrayElementAsTagged(
  TNode<RawPtrT> data_pointer, TNode<UintPtrT> index,
  ElementsKind elements_kind) {
TNode<IntPtrT> offset =
    ElementOffsetFromIndex(Signed(index), elements_kind, 0);
switch (elements_kind) {
  case UINT8_ELEMENTS: /* fall through */
  case UINT8_CLAMPED_ELEMENTS:
    return SmiFromInt32(Load<Uint8T>(data_pointer, offset));
  case INT8_ELEMENTS:
    return SmiFromInt32(Load<Int8T>(data_pointer, offset));
  case UINT16_ELEMENTS:
    return SmiFromInt32(Load<Uint16T>(data_pointer, offset));
  case INT16_ELEMENTS:
    return SmiFromInt32(Load<Int16T>(data_pointer, offset));
  case UINT32_ELEMENTS:
    return ChangeUint32ToTagged(Load<Uint32T>(data_pointer, offset));
  case INT32_ELEMENTS:
    return ChangeInt32ToTagged(Load<Int32T>(data_pointer, offset));
  case FLOAT32_ELEMENTS:
    return AllocateHeapNumberWithValue(
        ChangeFloat32ToFloat64(Load<Float32T>(data_pointer, offset)));
  case FLOAT64_ELEMENTS:
    return AllocateHeapNumberWithValue(Load<Float64T>(data_pointer, offset));
  case BIGINT64_ELEMENTS:
    return LoadFixedBigInt64ArrayElementAsTagged(data_pointer, offset);
  case BIGUINT64_ELEMENTS:
    return LoadFixedBigUint64ArrayElementAsTagged(data_pointer, offset);
  default:
    UNREACHABLE()V8_Fatal("unreachable code");
}
2577}

2579TNode<Numeric> CodeStubAssembler::LoadFixedTypedArrayElementAsTagged(
  TNode<RawPtrT> data_pointer, TNode<UintPtrT> index,
  TNode<Int32T> elements_kind) {
TVARIABLE(Numeric, var_result)TVariable<Numeric> var_result(this);
Label done(this), if_unknown_type(this, Label::kDeferred);
int32_t elements_kinds[] = {
2585#define TYPED_ARRAY_CASE(Type, type, TYPE, ctype) TYPE##_ELEMENTS,
    TYPED_ARRAYS(TYPED_ARRAY_CASE)TYPED_ARRAY_CASE(Uint8, uint8, UINT8, uint8_t) TYPED_ARRAY_CASE
(Int8, int8, INT8, int8_t) TYPED_ARRAY_CASE(Uint16, uint16, UINT16
, uint16_t) TYPED_ARRAY_CASE(Int16, int16, INT16, int16_t) TYPED_ARRAY_CASE
(Uint32, uint32, UINT32, uint32_t) TYPED_ARRAY_CASE(Int32, int32
, INT32, int32_t) TYPED_ARRAY_CASE(Float32, float32, FLOAT32,
 float) TYPED_ARRAY_CASE(Float64, float64, FLOAT64, double) TYPED_ARRAY_CASE
(Uint8Clamped, uint8_clamped, UINT8_CLAMPED, uint8_t) TYPED_ARRAY_CASE
(BigUint64, biguint64, BIGUINT64, uint64_t) TYPED_ARRAY_CASE(
BigInt64, bigint64, BIGINT64, int64_t) RAB_GSAB_TYPED_ARRAYS(TYPED_ARRAY_CASE)TYPED_ARRAY_CASE(RabGsabUint8, rab_gsab_uint8, RAB_GSAB_UINT8
, uint8_t) TYPED_ARRAY_CASE(RabGsabInt8, rab_gsab_int8, RAB_GSAB_INT8
, int8_t) TYPED_ARRAY_CASE(RabGsabUint16, rab_gsab_uint16, RAB_GSAB_UINT16
, uint16_t) TYPED_ARRAY_CASE(RabGsabInt16, rab_gsab_int16, RAB_GSAB_INT16
, int16_t) TYPED_ARRAY_CASE(RabGsabUint32, rab_gsab_uint32, RAB_GSAB_UINT32
, uint32_t) TYPED_ARRAY_CASE(RabGsabInt32, rab_gsab_int32, RAB_GSAB_INT32
, int32_t) TYPED_ARRAY_CASE(RabGsabFloat32, rab_gsab_float32,
 RAB_GSAB_FLOAT32, float) TYPED_ARRAY_CASE(RabGsabFloat64, rab_gsab_float64
, RAB_GSAB_FLOAT64, double) TYPED_ARRAY_CASE(RabGsabUint8Clamped
, rab_gsab_uint8_clamped, RAB_GSAB_UINT8_CLAMPED, uint8_t) TYPED_ARRAY_CASE
(RabGsabBigUint64, rab_gsab_biguint64, RAB_GSAB_BIGUINT64, uint64_t
) TYPED_ARRAY_CASE(RabGsabBigInt64, rab_gsab_bigint64, RAB_GSAB_BIGINT64
, int64_t)
2587#undef TYPED_ARRAY_CASE
};

2590#define TYPED_ARRAY_CASE(Type, type, TYPE, ctype) Label if_##type##array(this);
TYPED_ARRAYS(TYPED_ARRAY_CASE)TYPED_ARRAY_CASE(Uint8, uint8, UINT8, uint8_t) TYPED_ARRAY_CASE
(Int8, int8, INT8, int8_t) TYPED_ARRAY_CASE(Uint16, uint16, UINT16
, uint16_t) TYPED_ARRAY_CASE(Int16, int16, INT16, int16_t) TYPED_ARRAY_CASE
(Uint32, uint32, UINT32, uint32_t) TYPED_ARRAY_CASE(Int32, int32
, INT32, int32_t) TYPED_ARRAY_CASE(Float32, float32, FLOAT32,
 float) TYPED_ARRAY_CASE(Float64, float64, FLOAT64, double) TYPED_ARRAY_CASE
(Uint8Clamped, uint8_clamped, UINT8_CLAMPED, uint8_t) TYPED_ARRAY_CASE
(BigUint64, biguint64, BIGUINT64, uint64_t) TYPED_ARRAY_CASE(
BigInt64, bigint64, BIGINT64, int64_t)
2592#undef TYPED_ARRAY_CASE

Label* elements_kind_labels[] = {
2595#define TYPED_ARRAY_CASE(Type, type, TYPE, ctype) &if_##type##array,
    TYPED_ARRAYS(TYPED_ARRAY_CASE)TYPED_ARRAY_CASE(Uint8, uint8, UINT8, uint8_t) TYPED_ARRAY_CASE
(Int8, int8, INT8, int8_t) TYPED_ARRAY_CASE(Uint16, uint16, UINT16
, uint16_t) TYPED_ARRAY_CASE(Int16, int16, INT16, int16_t) TYPED_ARRAY_CASE
(Uint32, uint32, UINT32, uint32_t) TYPED_ARRAY_CASE(Int32, int32
, INT32, int32_t) TYPED_ARRAY_CASE(Float32, float32, FLOAT32,
 float) TYPED_ARRAY_CASE(Float64, float64, FLOAT64, double) TYPED_ARRAY_CASE
(Uint8Clamped, uint8_clamped, UINT8_CLAMPED, uint8_t) TYPED_ARRAY_CASE
(BigUint64, biguint64, BIGUINT64, uint64_t) TYPED_ARRAY_CASE(
BigInt64, bigint64, BIGINT64, int64_t)
    // The same labels again for RAB / GSAB. We dispatch RAB / GSAB elements
    // kinds to the corresponding non-RAB / GSAB elements kinds.
    TYPED_ARRAYS(TYPED_ARRAY_CASE)TYPED_ARRAY_CASE(Uint8, uint8, UINT8, uint8_t) TYPED_ARRAY_CASE
(Int8, int8, INT8, int8_t) TYPED_ARRAY_CASE(Uint16, uint16, UINT16
, uint16_t) TYPED_ARRAY_CASE(Int16, int16, INT16, int16_t) TYPED_ARRAY_CASE
(Uint32, uint32, UINT32, uint32_t) TYPED_ARRAY_CASE(Int32, int32
, INT32, int32_t) TYPED_ARRAY_CASE(Float32, float32, FLOAT32,
 float) TYPED_ARRAY_CASE(Float64, float64, FLOAT64, double) TYPED_ARRAY_CASE
(Uint8Clamped, uint8_clamped, UINT8_CLAMPED, uint8_t) TYPED_ARRAY_CASE
(BigUint64, biguint64, BIGUINT64, uint64_t) TYPED_ARRAY_CASE(
BigInt64, bigint64, BIGINT64, int64_t)
2600#undef TYPED_ARRAY_CASE
};
STATIC_ASSERT(arraysize(elements_kinds) == arraysize(elements_kind_labels))static_assert((sizeof(ArraySizeHelper(elements_kinds))) == (sizeof
(ArraySizeHelper(elements_kind_labels))), "arraysize(elements_kinds) == arraysize(elements_kind_labels)"
);

Switch(elements_kind, &if_unknown_type, elements_kinds, elements_kind_labels,
       arraysize(elements_kinds)(sizeof(ArraySizeHelper(elements_kinds))));

BIND(&if_unknown_type)Bind(&if_unknown_type);
Unreachable();

2610#define TYPED_ARRAY_CASE(Type, type, TYPE, ctype)                        \
BIND(&if_##type##array)Bind(&if_##type##array);                                               \
{                                                                      \
  var_result = LoadFixedTypedArrayElementAsTagged(data_pointer, index, \
                                                  TYPE##_ELEMENTS);    \
  Goto(&done);                                                         \
}
TYPED_ARRAYS(TYPED_ARRAY_CASE)TYPED_ARRAY_CASE(Uint8, uint8, UINT8, uint8_t) TYPED_ARRAY_CASE
(Int8, int8, INT8, int8_t) TYPED_ARRAY_CASE(Uint16, uint16, UINT16
, uint16_t) TYPED_ARRAY_CASE(Int16, int16, INT16, int16_t) TYPED_ARRAY_CASE
(Uint32, uint32, UINT32, uint32_t) TYPED_ARRAY_CASE(Int32, int32
, INT32, int32_t) TYPED_ARRAY_CASE(Float32, float32, FLOAT32,
 float) TYPED_ARRAY_CASE(Float64, float64, FLOAT64, double) TYPED_ARRAY_CASE
(Uint8Clamped, uint8_clamped, UINT8_CLAMPED, uint8_t) TYPED_ARRAY_CASE
(BigUint64, biguint64, BIGUINT64, uint64_t) TYPED_ARRAY_CASE(
BigInt64, bigint64, BIGINT64, int64_t)
2618#undef TYPED_ARRAY_CASE

BIND(&done)Bind(&done);
return var_result.value();
2622}

2624template <typename TIndex>
2625TNode<MaybeObject> CodeStubAssembler::LoadFeedbackVectorSlot(
  TNode<FeedbackVector> feedback_vector, TNode<TIndex> slot,
  int additional_offset) {
int32_t header_size = FeedbackVector::kRawFeedbackSlotsOffset +
                      additional_offset - kHeapObjectTag;
TNode<IntPtrT> offset =
    ElementOffsetFromIndex(slot, HOLEY_ELEMENTS, header_size);
CSA_SLOW_DCHECK(((void)0)
    this, IsOffsetInBounds(offset, LoadFeedbackVectorLength(feedback_vector),((void)0)
                           FeedbackVector::kHeaderSize))((void)0);
return Load<MaybeObject>(feedback_vector, offset);
2636}

2638template TNode<MaybeObject> CodeStubAssembler::LoadFeedbackVectorSlot(
  TNode<FeedbackVector> feedback_vector, TNode<TaggedIndex> slot,
  int additional_offset);
2641template TNode<MaybeObject> CodeStubAssembler::LoadFeedbackVectorSlot(
  TNode<FeedbackVector> feedback_vector, TNode<IntPtrT> slot,
  int additional_offset);
2644template TNode<MaybeObject> CodeStubAssembler::LoadFeedbackVectorSlot(
  TNode<FeedbackVector> feedback_vector, TNode<UintPtrT> slot,
  int additional_offset);

2648template <typename Array>
2649TNode<Int32T> CodeStubAssembler::LoadAndUntagToWord32ArrayElement(
  TNode<Array> object, int array_header_size, TNode<IntPtrT> index,
  int additional_offset) {
DCHECK(IsAligned(additional_offset, kTaggedSize))((void) 0);
int endian_correction = 0;
2654#if V8_TARGET_LITTLE_ENDIAN1
if (SmiValuesAre32Bits()) endian_correction = 4;
2656#endif
int32_t header_size = array_header_size + additional_offset - kHeapObjectTag +
                      endian_correction;
TNode<IntPtrT> offset =
    ElementOffsetFromIndex(index, HOLEY_ELEMENTS, header_size);
CSA_DCHECK(this, IsOffsetInBounds(offset, LoadArrayLength(object),((void)0)
                                  array_header_size + endian_correction))((void)0);
if (SmiValuesAre32Bits()) {
  return Load<Int32T>(object, offset);
} else {
  return SmiToInt32(Load<Smi>(object, offset));
}
2668}

2670TNode<Int32T> CodeStubAssembler::LoadAndUntagToWord32FixedArrayElement(
  TNode<FixedArray> object, TNode<IntPtrT> index, int additional_offset) {
CSA_SLOW_DCHECK(this, IsFixedArraySubclass(object))((void)0);
return LoadAndUntagToWord32ArrayElement(object, FixedArray::kHeaderSize,
                                        index, additional_offset);
2675}

2677TNode<MaybeObject> CodeStubAssembler::LoadWeakFixedArrayElement(
  TNode<WeakFixedArray> object, TNode<IntPtrT> index, int additional_offset) {
return LoadArrayElement(object, WeakFixedArray::kHeaderSize, index,
                        additional_offset);
2681}

2683TNode<Float64T> CodeStubAssembler::LoadFixedDoubleArrayElement(
  TNode<FixedDoubleArray> object, TNode<IntPtrT> index, Label* if_hole,
  MachineType machine_type) {
int32_t header_size = FixedDoubleArray::kHeaderSize - kHeapObjectTag;
TNode<IntPtrT> offset =
    ElementOffsetFromIndex(index, HOLEY_DOUBLE_ELEMENTS, header_size);
CSA_DCHECK(this, IsOffsetInBounds(((void)0)
                     offset, LoadAndUntagFixedArrayBaseLength(object),((void)0)
                     FixedDoubleArray::kHeaderSize, HOLEY_DOUBLE_ELEMENTS))((void)0);
return LoadDoubleWithHoleCheck(object, offset, if_hole, machine_type);
2693}

2695TNode<Object> CodeStubAssembler::LoadFixedArrayBaseElementAsTagged(
  TNode<FixedArrayBase> elements, TNode<IntPtrT> index,
  TNode<Int32T> elements_kind, Label* if_accessor, Label* if_hole) {
TVARIABLE(Object, var_result)TVariable<Object> var_result(this);
Label done(this), if_packed(this), if_holey(this), if_packed_double(this),
    if_holey_double(this), if_dictionary(this, Label::kDeferred);

int32_t kinds[] = {
    // Handled by if_packed.
    PACKED_SMI_ELEMENTS, PACKED_ELEMENTS, PACKED_NONEXTENSIBLE_ELEMENTS,
    PACKED_SEALED_ELEMENTS, PACKED_FROZEN_ELEMENTS,
    // Handled by if_holey.
    HOLEY_SMI_ELEMENTS, HOLEY_ELEMENTS, HOLEY_NONEXTENSIBLE_ELEMENTS,
    HOLEY_SEALED_ELEMENTS, HOLEY_FROZEN_ELEMENTS,
    // Handled by if_packed_double.
    PACKED_DOUBLE_ELEMENTS,
    // Handled by if_holey_double.
    HOLEY_DOUBLE_ELEMENTS};
Label* labels[] = {// PACKED_{SMI,}_ELEMENTS
                   &if_packed, &if_packed, &if_packed, &if_packed, &if_packed,
                   // HOLEY_{SMI,}_ELEMENTS
                   &if_holey, &if_holey, &if_holey, &if_holey, &if_holey,
                   // PACKED_DOUBLE_ELEMENTS
                   &if_packed_double,
                   // HOLEY_DOUBLE_ELEMENTS
                   &if_holey_double};
Switch(elements_kind, &if_dictionary, kinds, labels, arraysize(kinds)(sizeof(ArraySizeHelper(kinds))));

BIND(&if_packed)Bind(&if_packed);
{
  var_result = LoadFixedArrayElement(CAST(elements)Cast(elements), index, 0);
  Goto(&done);
}

BIND(&if_holey)Bind(&if_holey);
{
  var_result = LoadFixedArrayElement(CAST(elements)Cast(elements), index);
  Branch(TaggedEqual(var_result.value(), TheHoleConstant()), if_hole, &done);
}

BIND(&if_packed_double)Bind(&if_packed_double);
{
  var_result = AllocateHeapNumberWithValue(
      LoadFixedDoubleArrayElement(CAST(elements)Cast(elements), index));
  Goto(&done);
}

BIND(&if_holey_double)Bind(&if_holey_double);
{
  var_result = AllocateHeapNumberWithValue(
      LoadFixedDoubleArrayElement(CAST(elements)Cast(elements), index, if_hole));
  Goto(&done);
}

BIND(&if_dictionary)Bind(&if_dictionary);
{
  CSA_DCHECK(this, IsDictionaryElementsKind(elements_kind))((void)0);
  var_result = BasicLoadNumberDictionaryElement(CAST(elements)Cast(elements), index,
                                                if_accessor, if_hole);
  Goto(&done);
}

BIND(&done)Bind(&done);
return var_result.value();
2759}

2761TNode<BoolT> CodeStubAssembler::IsDoubleHole(TNode<Object> base,
                                           TNode<IntPtrT> offset) {
// TODO(ishell): Compare only the upper part for the hole once the
// compiler is able to fold addition of already complex |offset| with
// |kIeeeDoubleExponentWordOffset| into one addressing mode.
if (Is64()) {
  TNode<Uint64T> element = Load<Uint64T>(base, offset);
  return Word64Equal(element, Int64Constant(kHoleNanInt64));
} else {
  TNode<Uint32T> element_upper = Load<Uint32T>(
      base, IntPtrAdd(offset, IntPtrConstant(kIeeeDoubleExponentWordOffset)));
  return Word32Equal(element_upper, Int32Constant(kHoleNanUpper32));
}
2774}

2776TNode<Float64T> CodeStubAssembler::LoadDoubleWithHoleCheck(
  TNode<Object> base, TNode<IntPtrT> offset, Label* if_hole,
  MachineType machine_type) {
if (if_hole) {
  GotoIf(IsDoubleHole(base, offset), if_hole);
}
if (machine_type.IsNone()) {
  // This means the actual value is not needed.
  return TNode<Float64T>();
}
return UncheckedCast<Float64T>(Load(machine_type, base, offset));
2787}

2789TNode<ScopeInfo> CodeStubAssembler::LoadScopeInfo(TNode<Context> context) {
return CAST(LoadContextElement(context, Context::SCOPE_INFO_INDEX))Cast(LoadContextElement(context, Context::SCOPE_INFO_INDEX));
2791}

2793TNode<BoolT> CodeStubAssembler::LoadScopeInfoHasExtensionField(
  TNode<ScopeInfo> scope_info) {
TNode<IntPtrT> value =
    LoadAndUntagObjectField(scope_info, ScopeInfo::kFlagsOffset);
return IsSetWord<ScopeInfo::HasContextExtensionSlotBit>(value);
2798}

2800void CodeStubAssembler::StoreContextElementNoWriteBarrier(
  TNode<Context> context, int slot_index, TNode<Object> value) {
int offset = Context::SlotOffset(slot_index);
StoreNoWriteBarrier(MachineRepresentation::kTagged, context,
                    IntPtrConstant(offset), value);
2805}

2807TNode<NativeContext> CodeStubAssembler::LoadNativeContext(
  TNode<Context> context) {
TNode<Map> map = LoadMap(context);
return CAST(LoadObjectField(Cast(LoadObjectField( map, Map::kConstructorOrBackPointerOrNativeContextOffset
))
    map, Map::kConstructorOrBackPointerOrNativeContextOffset))Cast(LoadObjectField( map, Map::kConstructorOrBackPointerOrNativeContextOffset
));
2812}

2814TNode<Context> CodeStubAssembler::LoadModuleContext(TNode<Context> context) {
TNode<NativeContext> native_context = LoadNativeContext(context);
TNode<Map> module_map = CAST(Cast(LoadContextElement(native_context, Context::MODULE_CONTEXT_MAP_INDEX
))
    LoadContextElement(native_context, Context::MODULE_CONTEXT_MAP_INDEX))Cast(LoadContextElement(native_context, Context::MODULE_CONTEXT_MAP_INDEX
));
TVariable<Object> cur_context(context, this);

Label context_found(this);

Label context_search(this, &cur_context);

// Loop until cur_context->map() is module_map.
Goto(&context_search);
BIND(&context_search)Bind(&context_search);
{
  CSA_DCHECK(this, Word32BinaryNot(((void)0)
                       TaggedEqual(cur_context.value(), native_context)))((void)0);
  GotoIf(TaggedEqual(LoadMap(CAST(cur_context.value())Cast(cur_context.value())), module_map),
         &context_found);

  cur_context =
      LoadContextElement(CAST(cur_context.value())Cast(cur_context.value()), Context::PREVIOUS_INDEX);
  Goto(&context_search);
}

BIND(&context_found)Bind(&context_found);
return UncheckedCast<Context>(cur_context.value());
2840}

2842TNode<Object> CodeStubAssembler::GetImportMetaObject(TNode<Context> context) {
const TNode<Context> module_context = LoadModuleContext(context);
const TNode<HeapObject> module =
    CAST(LoadContextElement(module_context, Context::EXTENSION_INDEX))Cast(LoadContextElement(module_context, Context::EXTENSION_INDEX
));
const TNode<Object> import_meta =
    LoadObjectField(module, SourceTextModule::kImportMetaOffset);

TVARIABLE(Object, return_value, import_meta)TVariable<Object> return_value(import_meta, this);

Label end(this);
GotoIfNot(IsTheHole(import_meta), &end);

return_value = CallRuntime(Runtime::kGetImportMetaObject, context);
Goto(&end);

BIND(&end)Bind(&end);
return return_value.value();
2859}

2861TNode<Map> CodeStubAssembler::LoadObjectFunctionInitialMap(
  TNode<NativeContext> native_context) {
TNode<JSFunction> object_function =
    CAST(LoadContextElement(native_context, Context::OBJECT_FUNCTION_INDEX))Cast(LoadContextElement(native_context, Context::OBJECT_FUNCTION_INDEX
));
return CAST(LoadJSFunctionPrototypeOrInitialMap(object_function))Cast(LoadJSFunctionPrototypeOrInitialMap(object_function));
2866}

2868TNode<Map> CodeStubAssembler::LoadSlowObjectWithNullPrototypeMap(
  TNode<NativeContext> native_context) {
TNode<Map> map = CAST(LoadContextElement(Cast(LoadContextElement( native_context, Context::SLOW_OBJECT_WITH_NULL_PROTOTYPE_MAP
))
    native_context, Context::SLOW_OBJECT_WITH_NULL_PROTOTYPE_MAP))Cast(LoadContextElement( native_context, Context::SLOW_OBJECT_WITH_NULL_PROTOTYPE_MAP
));
return map;
2873}

2875TNode<Map> CodeStubAssembler::LoadJSArrayElementsMap(
  TNode<Int32T> kind, TNode<NativeContext> native_context) {
CSA_DCHECK(this, IsFastElementsKind(kind))((void)0);
TNode<IntPtrT> offset =
    IntPtrAdd(IntPtrConstant(Context::FIRST_JS_ARRAY_MAP_SLOT),
              ChangeInt32ToIntPtr(kind));
return UncheckedCast<Map>(LoadContextElement(native_context, offset));
2882}

2884TNode<Map> CodeStubAssembler::LoadJSArrayElementsMap(
  ElementsKind kind, TNode<NativeContext> native_context) {
return UncheckedCast<Map>(
    LoadContextElement(native_context, Context::ArrayMapIndex(kind)));
2888}

2890TNode<BoolT> CodeStubAssembler::IsGeneratorFunction(
  TNode<JSFunction> function) {
const TNode<SharedFunctionInfo> shared_function_info =
    LoadObjectField<SharedFunctionInfo>(
        function, JSFunction::kSharedFunctionInfoOffset);

const TNode<Uint32T> function_kind =
    DecodeWord32<SharedFunctionInfo::FunctionKindBits>(
        LoadObjectField<Uint32T>(shared_function_info,
                                 SharedFunctionInfo::kFlagsOffset));

// See IsGeneratorFunction(FunctionKind kind).
return IsInRange(
    function_kind,
    static_cast<uint32_t>(FunctionKind::kAsyncConciseGeneratorMethod),
    static_cast<uint32_t>(FunctionKind::kConciseGeneratorMethod));
2906}

2908TNode<BoolT> CodeStubAssembler::IsJSFunctionWithPrototypeSlot(
  TNode<HeapObject> object) {
// Only JSFunction maps may have HasPrototypeSlotBit set.
return IsSetWord32<Map::Bits1::HasPrototypeSlotBit>(
    LoadMapBitField(LoadMap(object)));
2913}

2915void CodeStubAssembler::BranchIfHasPrototypeProperty(
  TNode<JSFunction> function, TNode<Int32T> function_map_bit_field,
  Label* if_true, Label* if_false) {
// (has_prototype_slot() && IsConstructor()) ||
// IsGeneratorFunction(shared()->kind())
uint32_t mask = Map::Bits1::HasPrototypeSlotBit::kMask |
                Map::Bits1::IsConstructorBit::kMask;

GotoIf(IsAllSetWord32(function_map_bit_field, mask), if_true);
Branch(IsGeneratorFunction(function), if_true, if_false);
2925}

2927void CodeStubAssembler::GotoIfPrototypeRequiresRuntimeLookup(
  TNode<JSFunction> function, TNode<Map> map, Label* runtime) {
// !has_prototype_property() || has_non_instance_prototype()
TNode<Int32T> map_bit_field = LoadMapBitField(map);
Label next_check(this);
BranchIfHasPrototypeProperty(function, map_bit_field, &next_check, runtime);
BIND(&next_check)Bind(&next_check);
GotoIf(IsSetWord32<Map::Bits1::HasNonInstancePrototypeBit>(map_bit_field),
       runtime);
2936}

2938TNode<HeapObject> CodeStubAssembler::LoadJSFunctionPrototype(
  TNode<JSFunction> function, Label* if_bailout) {
CSA_DCHECK(this, IsFunctionWithPrototypeSlotMap(LoadMap(function)))((void)0);
CSA_DCHECK(this, IsClearWord32<Map::Bits1::HasNonInstancePrototypeBit>(((void)0)
                     LoadMapBitField(LoadMap(function))))((void)0);
TNode<HeapObject> proto_or_map = LoadObjectField<HeapObject>(
    function, JSFunction::kPrototypeOrInitialMapOffset);
GotoIf(IsTheHole(proto_or_map), if_bailout);

TVARIABLE(HeapObject, var_result, proto_or_map)TVariable<HeapObject> var_result(proto_or_map, this);
Label done(this, &var_result);
GotoIfNot(IsMap(proto_or_map), &done);

var_result = LoadMapPrototype(CAST(proto_or_map)Cast(proto_or_map));
Goto(&done);

BIND(&done)Bind(&done);
return var_result.value();
2956}

2958TNode<BytecodeArray> CodeStubAssembler::LoadSharedFunctionInfoBytecodeArray(
  TNode<SharedFunctionInfo> shared) {
TNode<HeapObject> function_data = LoadObjectField<HeapObject>(
    shared, SharedFunctionInfo::kFunctionDataOffset);

TVARIABLE(HeapObject, var_result, function_data)TVariable<HeapObject> var_result(function_data, this);

Label check_for_interpreter_data(this, &var_result);
Label done(this, &var_result);

GotoIfNot(HasInstanceType(var_result.value(), CODET_TYPE),
          &check_for_interpreter_data);
{
  TNode<CodeT> code = CAST(var_result.value())Cast(var_result.value());
2972#ifdef DEBUG
  TNode<Int32T> code_flags =
      LoadObjectField<Int32T>(code, CodeT::kFlagsOffset);
  CSA_DCHECK(((void)0)
      this, Word32Equal(DecodeWord32<CodeT::KindField>(code_flags),((void)0)
                        Int32Constant(static_cast<int>(CodeKind::BASELINE))))((void)0);
2978#endif  // DEBUG
  TNode<HeapObject> baseline_data = LoadObjectField<HeapObject>(
      FromCodeT(code), Code::kDeoptimizationDataOrInterpreterDataOffset);
  var_result = baseline_data;
}
Goto(&check_for_interpreter_data);

BIND(&check_for_interpreter_data)Bind(&check_for_interpreter_data);

GotoIfNot(HasInstanceType(var_result.value(), INTERPRETER_DATA_TYPE), &done);
TNode<BytecodeArray> bytecode_array = LoadObjectField<BytecodeArray>(
    var_result.value(), InterpreterData::kBytecodeArrayOffset);
var_result = bytecode_array;
Goto(&done);

BIND(&done)Bind(&done);
return CAST(var_result.value())Cast(var_result.value());
2995}

2997void CodeStubAssembler::StoreObjectByteNoWriteBarrier(TNode<HeapObject> object,
                                                    int offset,
                                                    TNode<Word32T> value) {
StoreNoWriteBarrier(MachineRepresentation::kWord8, object,
                    IntPtrConstant(offset - kHeapObjectTag), value);
3002}

3004void CodeStubAssembler::StoreHeapNumberValue(TNode<HeapNumber> object,
                                           TNode<Float64T> value) {
StoreObjectFieldNoWriteBarrier(object, HeapNumber::kValueOffset, value);
3007}

3009void CodeStubAssembler::StoreObjectField(TNode<HeapObject> object, int offset,
                                       TNode<Smi> value) {
StoreObjectFieldNoWriteBarrier(object, offset, value);
3012}

3014void CodeStubAssembler::StoreObjectField(TNode<HeapObject> object,
                                       TNode<IntPtrT> offset,
                                       TNode<Smi> value) {
StoreObjectFieldNoWriteBarrier(object, offset, value);
3018}

3020void CodeStubAssembler::StoreObjectField(TNode<HeapObject> object, int offset,
                                       TNode<Object> value) {
DCHECK_NE(HeapObject::kMapOffset, offset)((void) 0);  // Use StoreMap instead.
OptimizedStoreField(MachineRepresentation::kTagged,
                    UncheckedCast<HeapObject>(object), offset, value);
3025}

3027void CodeStubAssembler::StoreObjectField(TNode<HeapObject> object,
                                       TNode<IntPtrT> offset,
                                       TNode<Object> value) {
int const_offset;
if (TryToInt32Constant(offset, &const_offset)) {
  StoreObjectField(object, const_offset, value);
} else {
  Store(object, IntPtrSub(offset, IntPtrConstant(kHeapObjectTag)), value);
}
3036}

3038void CodeStubAssembler::UnsafeStoreObjectFieldNoWriteBarrier(
  TNode<HeapObject> object, int offset, TNode<Object> value) {
DCHECK_NE(HeapObject::kMapOffset, offset)((void) 0);  // Use StoreMap instead.
OptimizedStoreFieldUnsafeNoWriteBarrier(MachineRepresentation::kTagged,
                                        object, offset, value);
3043}

3045void CodeStubAssembler::StoreJSSharedStructInObjectField(
  TNode<HeapObject> object, TNode<IntPtrT> offset, TNode<Object> value) {
CSA_DCHECK(this, IsJSSharedStruct(object))((void)0);
// JSSharedStructs are allocated in the shared old space, which is currently
// collected by stopping the world, so the incremental write barrier is not
// needed. They can only store Smis and other HeapObjects in the shared old
// space, so the generational write barrier is also not needed.
// TODO(v8:12547): Add a safer, shared variant of NoWriteBarrier instead of
// using Unsafe.
int const_offset;
if (TryToInt32Constant(offset, &const_offset)) {
  UnsafeStoreObjectFieldNoWriteBarrier(object, const_offset, value);
} else {
  UnsafeStoreNoWriteBarrier(MachineRepresentation::kTagged, object,
                            IntPtrSub(offset, IntPtrConstant(kHeapObjectTag)),
                            value);
}
3062}

3064void CodeStubAssembler::StoreMap(TNode<HeapObject> object, TNode<Map> map) {
OptimizedStoreMap(object, map);
DcheckHasValidMap(object);
3067}

3069void CodeStubAssembler::StoreMapNoWriteBarrier(TNode<HeapObject> object,
                                             RootIndex map_root_index) {
StoreMapNoWriteBarrier(object, CAST(LoadRoot(map_root_index))Cast(LoadRoot(map_root_index)));
3072}

3074void CodeStubAssembler::StoreMapNoWriteBarrier(TNode<HeapObject> object,
                                             TNode<Map> map) {
OptimizedStoreMap(object, map);
DcheckHasValidMap(object);
3078}

3080void CodeStubAssembler::StoreObjectFieldRoot(TNode<HeapObject> object,
                                           int offset, RootIndex root_index) {
TNode<Object> root = LoadRoot(root_index);
if (offset == HeapObject::kMapOffset) {
  StoreMap(object, CAST(root)Cast(root));
} else if (RootsTable::IsImmortalImmovable(root_index)) {
  StoreObjectFieldNoWriteBarrier(object, offset, root);
} else {
  StoreObjectField(object, offset, root);
}
3090}

3092template <typename TIndex>
3093void CodeStubAssembler::StoreFixedArrayOrPropertyArrayElement(
  TNode<UnionT<FixedArray, PropertyArray>> object, TNode<TIndex> index_node,
  TNode<Object> value, WriteBarrierMode barrier_mode, int additional_offset) {
// TODO(v8:9708): Do we want to keep both IntPtrT and UintPtrT variants?
static_assert(std::is_same<TIndex, Smi>::value ||
                  std::is_same<TIndex, UintPtrT>::value ||
                  std::is_same<TIndex, IntPtrT>::value,
              "Only Smi, UintPtrT or IntPtrT index is allowed");
DCHECK(barrier_mode == SKIP_WRITE_BARRIER ||((void) 0)
       barrier_mode == UNSAFE_SKIP_WRITE_BARRIER ||((void) 0)
       barrier_mode == UPDATE_WRITE_BARRIER ||((void) 0)
       barrier_mode == UPDATE_EPHEMERON_KEY_WRITE_BARRIER)((void) 0);
DCHECK(IsAligned(additional_offset, kTaggedSize))((void) 0);
STATIC_ASSERT(static_cast<int>(FixedArray::kHeaderSize) ==static_assert(static_cast<int>(FixedArray::kHeaderSize)
 == static_cast<int>(PropertyArray::kHeaderSize), "static_cast<int>(FixedArray::kHeaderSize) == static_cast<int>(PropertyArray::kHeaderSize)"
)
              static_cast<int>(PropertyArray::kHeaderSize))static_assert(static_cast<int>(FixedArray::kHeaderSize)
 == static_cast<int>(PropertyArray::kHeaderSize), "static_cast<int>(FixedArray::kHeaderSize) == static_cast<int>(PropertyArray::kHeaderSize)"
);
int header_size =
    FixedArray::kHeaderSize + additional_offset - kHeapObjectTag;
TNode<IntPtrT> offset =
    ElementOffsetFromIndex(index_node, HOLEY_ELEMENTS, header_size);
STATIC_ASSERT(static_cast<int>(FixedArrayBase::kLengthOffset) ==static_assert(static_cast<int>(FixedArrayBase::kLengthOffset
) == static_cast<int>(WeakFixedArray::kLengthOffset), "static_cast<int>(FixedArrayBase::kLengthOffset) == static_cast<int>(WeakFixedArray::kLengthOffset)"
)
              static_cast<int>(WeakFixedArray::kLengthOffset))static_assert(static_cast<int>(FixedArrayBase::kLengthOffset
) == static_cast<int>(WeakFixedArray::kLengthOffset), "static_cast<int>(FixedArrayBase::kLengthOffset) == static_cast<int>(WeakFixedArray::kLengthOffset)"
);
STATIC_ASSERT(static_cast<int>(FixedArrayBase::kLengthOffset) ==static_assert(static_cast<int>(FixedArrayBase::kLengthOffset
) == static_cast<int>(PropertyArray::kLengthAndHashOffset
), "static_cast<int>(FixedArrayBase::kLengthOffset) == static_cast<int>(PropertyArray::kLengthAndHashOffset)"
)
              static_cast<int>(PropertyArray::kLengthAndHashOffset))static_assert(static_cast<int>(FixedArrayBase::kLengthOffset
) == static_cast<int>(PropertyArray::kLengthAndHashOffset
), "static_cast<int>(FixedArrayBase::kLengthOffset) == static_cast<int>(PropertyArray::kLengthAndHashOffset)"
);
// Check that index_node + additional_offset <= object.length.
// TODO(cbruni): Use proper LoadXXLength helpers
CSA_DCHECK(((void)0)
    this,((void)0)
    IsOffsetInBounds(((void)0)
        offset,((void)0)
        Select<IntPtrT>(((void)0)
            IsPropertyArray(object),((void)0)
            [=] {((void)0)
              TNode<IntPtrT> length_and_hash = LoadAndUntagObjectField(((void)0)
                  object, PropertyArray::kLengthAndHashOffset);((void)0)
              return Signed(((void)0)
                  DecodeWord<PropertyArray::LengthField>(length_and_hash));((void)0)
            },((void)0)
            [=] {((void)0)
              return LoadAndUntagObjectField(object,((void)0)
                                             FixedArrayBase::kLengthOffset);((void)0)
            }),((void)0)
        FixedArray::kHeaderSize))((void)0);
if (barrier_mode == SKIP_WRITE_BARRIER) {
  StoreNoWriteBarrier(MachineRepresentation::kTagged, object, offset, value);
} else if (barrier_mode == UNSAFE_SKIP_WRITE_BARRIER) {
  UnsafeStoreNoWriteBarrier(MachineRepresentation::kTagged, object, offset,
                            value);
} else if (barrier_mode == UPDATE_EPHEMERON_KEY_WRITE_BARRIER) {
  StoreEphemeronKey(object, offset, value);
} else {
  Store(object, offset, value);
}
3145}

3147template V8_EXPORT_PRIVATE void
3148CodeStubAssembler::StoreFixedArrayOrPropertyArrayElement<Smi>(
  TNode<UnionT<FixedArray, PropertyArray>>, TNode<Smi>, TNode<Object>,
  WriteBarrierMode, int);

3152template V8_EXPORT_PRIVATE void
3153CodeStubAssembler::StoreFixedArrayOrPropertyArrayElement<IntPtrT>(
  TNode<UnionT<FixedArray, PropertyArray>>, TNode<IntPtrT>, TNode<Object>,
  WriteBarrierMode, int);

3157template V8_EXPORT_PRIVATE void
3158CodeStubAssembler::StoreFixedArrayOrPropertyArrayElement<UintPtrT>(
  TNode<UnionT<FixedArray, PropertyArray>>, TNode<UintPtrT>, TNode<Object>,
  WriteBarrierMode, int);

3162template <typename TIndex>
3163void CodeStubAssembler::StoreFixedDoubleArrayElement(
  TNode<FixedDoubleArray> object, TNode<TIndex> index, TNode<Float64T> value,
  CheckBounds check_bounds) {
// TODO(v8:9708): Do we want to keep both IntPtrT and UintPtrT variants?
static_assert(std::is_same<TIndex, Smi>::value ||
                  std::is_same<TIndex, UintPtrT>::value ||
                  std::is_same<TIndex, IntPtrT>::value,
              "Only Smi, UintPtrT or IntPtrT index is allowed");
if (NeedsBoundsCheck(check_bounds)) {
  FixedArrayBoundsCheck(object, index, 0);
}
TNode<IntPtrT> offset = ElementOffsetFromIndex(
    index, PACKED_DOUBLE_ELEMENTS, FixedArray::kHeaderSize - kHeapObjectTag);
MachineRepresentation rep = MachineRepresentation::kFloat64;
// Make sure we do not store signalling NaNs into double arrays.
TNode<Float64T> value_silenced = Float64SilenceNaN(value);
StoreNoWriteBarrier(rep, object, offset, value_silenced);
3180}

3182// Export the Smi version which is used outside of code-stub-assembler.
3183template V8_EXPORT_PRIVATE void CodeStubAssembler::StoreFixedDoubleArrayElement<
  Smi>(TNode<FixedDoubleArray>, TNode<Smi>, TNode<Float64T>, CheckBounds);

3186void CodeStubAssembler::StoreFeedbackVectorSlot(
  TNode<FeedbackVector> feedback_vector, TNode<UintPtrT> slot,
  TNode<AnyTaggedT> value, WriteBarrierMode barrier_mode,
  int additional_offset) {
DCHECK(IsAligned(additional_offset, kTaggedSize))((void) 0);
DCHECK(barrier_mode == SKIP_WRITE_BARRIER ||((void) 0)
       barrier_mode == UNSAFE_SKIP_WRITE_BARRIER ||((void) 0)
       barrier_mode == UPDATE_WRITE_BARRIER)((void) 0);
int header_size = FeedbackVector::kRawFeedbackSlotsOffset +
                  additional_offset - kHeapObjectTag;
TNode<IntPtrT> offset =
    ElementOffsetFromIndex(Signed(slot), HOLEY_ELEMENTS, header_size);
// Check that slot <= feedback_vector.length.
CSA_DCHECK(this,((void)0)
           IsOffsetInBounds(offset, LoadFeedbackVectorLength(feedback_vector),((void)0)
                            FeedbackVector::kHeaderSize),((void)0)
           SmiFromIntPtr(offset), feedback_vector)((void)0);
if (barrier_mode == SKIP_WRITE_BARRIER) {
  StoreNoWriteBarrier(MachineRepresentation::kTagged, feedback_vector, offset,
                      value);
} else if (barrier_mode == UNSAFE_SKIP_WRITE_BARRIER) {
  UnsafeStoreNoWriteBarrier(MachineRepresentation::kTagged, feedback_vector,
                            offset, value);
} else {
  Store(feedback_vector, offset, value);
}
3212}

3214TNode<Int32T> CodeStubAssembler::EnsureArrayPushable(TNode<Context> context,
                                                   TNode<Map> map,
                                                   Label* bailout) {
// Disallow pushing onto prototypes. It might be the JSArray prototype.
// Disallow pushing onto non-extensible objects.
Comment("Disallow pushing onto prototypes");
GotoIfNot(IsExtensibleNonPrototypeMap(map), bailout);

EnsureArrayLengthWritable(context, map, bailout);

TNode<Uint32T> kind =
    DecodeWord32<Map::Bits2::ElementsKindBits>(LoadMapBitField2(map));
return Signed(kind);
3227}

3229void CodeStubAssembler::PossiblyGrowElementsCapacity(
  ElementsKind kind, TNode<HeapObject> array, TNode<BInt> length,
  TVariable<FixedArrayBase>* var_elements, TNode<BInt> growth,
  Label* bailout) {
Label fits(this, var_elements);
TNode<BInt> capacity =
    TaggedToParameter<BInt>(LoadFixedArrayBaseLength(var_elements->value()));

TNode<BInt> new_length = IntPtrOrSmiAdd(growth, length);
GotoIfNot(IntPtrOrSmiGreaterThan(new_length, capacity), &fits);
TNode<BInt> new_capacity = CalculateNewElementsCapacity(new_length);
*var_elements = GrowElementsCapacity(array, var_elements->value(), kind, kind,
                                     capacity, new_capacity, bailout);
Goto(&fits);
BIND(&fits)Bind(&fits);
3244}

3246TNode<Smi> CodeStubAssembler::BuildAppendJSArray(ElementsKind kind,
                                               TNode<JSArray> array,
                                               CodeStubArguments* args,
                                               TVariable<IntPtrT>* arg_index,
                                               Label* bailout) {
Comment("BuildAppendJSArray: ", ElementsKindToString(kind));
Label pre_bailout(this);
Label success(this);
TVARIABLE(Smi, var_tagged_length)TVariable<Smi> var_tagged_length(this);
TVARIABLE(BInt, var_length, SmiToBInt(LoadFastJSArrayLength(array)))TVariable<BInt> var_length(SmiToBInt(LoadFastJSArrayLength
(array)), this);
TVARIABLE(FixedArrayBase, var_elements, LoadElements(array))TVariable<FixedArrayBase> var_elements(LoadElements(array
), this);

// Resize the capacity of the fixed array if it doesn't fit.
TNode<IntPtrT> first = arg_index->value();
TNode<BInt> growth =
    IntPtrToBInt(IntPtrSub(args->GetLengthWithoutReceiver(), first));
PossiblyGrowElementsCapacity(kind, array, var_length.value(), &var_elements,
                             growth, &pre_bailout);

// Push each argument onto the end of the array now that there is enough
// capacity.
CodeStubAssembler::VariableList push_vars({&var_length}, zone());
TNode<FixedArrayBase> elements = var_elements.value();
args->ForEach(
    push_vars,
    [&](TNode<Object> arg) {
      TryStoreArrayElement(kind, &pre_bailout, elements, var_length.value(),
                           arg);
      Increment(&var_length);
    },
    first);
{
  TNode<Smi> length = BIntToSmi(var_length.value());
  var_tagged_length = length;
  StoreObjectFieldNoWriteBarrier(array, JSArray::kLengthOffset, length);
  Goto(&success);
}

BIND(&pre_bailout)Bind(&pre_bailout);
{
  TNode<Smi> length = ParameterToTagged(var_length.value());
  var_tagged_length = length;
  TNode<Smi> diff = SmiSub(length, LoadFastJSArrayLength(array));
  StoreObjectFieldNoWriteBarrier(array, JSArray::kLengthOffset, length);
  *arg_index = IntPtrAdd(arg_index->value(), SmiUntag(diff));
  Goto(bailout);
}

BIND(&success)Bind(&success);
return var_tagged_length.value();
3296}

3298void CodeStubAssembler::TryStoreArrayElement(ElementsKind kind, Label* bailout,
                                           TNode<FixedArrayBase> elements,
                                           TNode<BInt> index,
                                           TNode<Object> value) {
if (IsSmiElementsKind(kind)) {
  GotoIf(TaggedIsNotSmi(value), bailout);
} else if (IsDoubleElementsKind(kind)) {
  GotoIfNotNumber(value, bailout);
}

if (IsDoubleElementsKind(kind)) {
  StoreElement(elements, kind, index, ChangeNumberToFloat64(CAST(value)Cast(value)));
} else {
  StoreElement(elements, kind, index, value);
}
3313}

3315void CodeStubAssembler::BuildAppendJSArray(ElementsKind kind,
                                         TNode<JSArray> array,
                                         TNode<Object> value,
                                         Label* bailout) {
Comment("BuildAppendJSArray: ", ElementsKindToString(kind));
TVARIABLE(BInt, var_length, SmiToBInt(LoadFastJSArrayLength(array)))TVariable<BInt> var_length(SmiToBInt(LoadFastJSArrayLength
(array)), this);
TVARIABLE(FixedArrayBase, var_elements, LoadElements(array))TVariable<FixedArrayBase> var_elements(LoadElements(array
), this);

// Resize the capacity of the fixed array if it doesn't fit.
TNode<BInt> growth = IntPtrOrSmiConstant<BInt>(1);
PossiblyGrowElementsCapacity(kind, array, var_length.value(), &var_elements,
                             growth, bailout);

// Push each argument onto the end of the array now that there is enough
// capacity.
TryStoreArrayElement(kind, bailout, var_elements.value(), var_length.value(),
                     value);
Increment(&var_length);

TNode<Smi> length = BIntToSmi(var_length.value());
StoreObjectFieldNoWriteBarrier(array, JSArray::kLengthOffset, length);
3336}

3338TNode<Cell> CodeStubAssembler::AllocateCellWithValue(TNode<Object> value,
                                                   WriteBarrierMode mode) {
TNode<HeapObject> result = Allocate(Cell::kSize, AllocationFlag::kNone);
StoreMapNoWriteBarrier(result, RootIndex::kCellMap);
TNode<Cell> cell = CAST(result)Cast(result);
StoreCellValue(cell, value, mode);
return cell;
3345}

3347TNode<Object> CodeStubAssembler::LoadCellValue(TNode<Cell> cell) {
return LoadObjectField(cell, Cell::kValueOffset);
3349}

3351void CodeStubAssembler::StoreCellValue(TNode<Cell> cell, TNode<Object> value,
                                     WriteBarrierMode mode) {
DCHECK(mode == SKIP_WRITE_BARRIER || mode == UPDATE_WRITE_BARRIER)((void) 0);

if (mode == UPDATE_WRITE_BARRIER) {
  StoreObjectField(cell, Cell::kValueOffset, value);
} else {
  StoreObjectFieldNoWriteBarrier(cell, Cell::kValueOffset, value);
}
3360}

3362TNode<HeapNumber> CodeStubAssembler::AllocateHeapNumber() {
TNode<HeapObject> result = Allocate(HeapNumber::kSize, AllocationFlag::kNone);
RootIndex heap_map_index = RootIndex::kHeapNumberMap;
StoreMapNoWriteBarrier(result, heap_map_index);
return UncheckedCast<HeapNumber>(result);
3367}

3369TNode<HeapNumber> CodeStubAssembler::AllocateHeapNumberWithValue(
  TNode<Float64T> value) {
TNode<HeapNumber> result = AllocateHeapNumber();
StoreHeapNumberValue(result, value);
return result;
3374}

3376TNode<Object> CodeStubAssembler::CloneIfMutablePrimitive(TNode<Object> object) {
TVARIABLE(Object, result, object)TVariable<Object> result(object, this);
Label done(this);

GotoIf(TaggedIsSmi(object), &done);
// TODO(leszeks): Read the field descriptor to decide if this heap number is
// mutable or not.
GotoIfNot(IsHeapNumber(UncheckedCast<HeapObject>(object)), &done);
{
  // Mutable heap number found --- allocate a clone.
  TNode<Float64T> value =
      LoadHeapNumberValue(UncheckedCast<HeapNumber>(object));
  result = AllocateHeapNumberWithValue(value);
  Goto(&done);
}

BIND(&done)Bind(&done);
return result.value();
3394}

3396TNode<BigInt> CodeStubAssembler::AllocateBigInt(TNode<IntPtrT> length) {
TNode<BigInt> result = AllocateRawBigInt(length);
StoreBigIntBitfield(result,
                    Word32Shl(TruncateIntPtrToInt32(length),
                              Int32Constant(BigInt::LengthBits::kShift)));
return result;
3402}

3404TNode<BigInt> CodeStubAssembler::AllocateRawBigInt(TNode<IntPtrT> length) {
TNode<IntPtrT> size =
    IntPtrAdd(IntPtrConstant(BigInt::kHeaderSize),
              Signed(WordShl(length, kSystemPointerSizeLog2)));
TNode<HeapObject> raw_result =
    Allocate(size, AllocationFlag::kAllowLargeObjectAllocation);
StoreMapNoWriteBarrier(raw_result, RootIndex::kBigIntMap);
if (FIELD_SIZE(BigInt::kOptionalPaddingOffset)(BigInt::kOptionalPaddingOffsetEnd + 1 - BigInt::kOptionalPaddingOffset
) != 0) {
  DCHECK_EQ(4, FIELD_SIZE(BigInt::kOptionalPaddingOffset))((void) 0);
  StoreObjectFieldNoWriteBarrier(raw_result, BigInt::kOptionalPaddingOffset,
                                 Int32Constant(0));
}
return UncheckedCast<BigInt>(raw_result);
3417}

3419void CodeStubAssembler::StoreBigIntBitfield(TNode<BigInt> bigint,
                                          TNode<Word32T> bitfield) {
StoreObjectFieldNoWriteBarrier(bigint, BigInt::kBitfieldOffset, bitfield);
3422}

3424void CodeStubAssembler::StoreBigIntDigit(TNode<BigInt> bigint,
                                       intptr_t digit_index,
                                       TNode<UintPtrT> digit) {
CHECK_LE(0, digit_index)do { bool _cmp = ::v8::base::CmpLEImpl< typename ::v8::base
::pass_value_or_ref<decltype(0)>::type, typename ::v8::
base::pass_value_or_ref<decltype(digit_index)>::type>
((0), (digit_index)); do { if ((__builtin_expect(!!(!(_cmp)),
 0))) { V8_Fatal("Check failed: %s.", "0" " " "<=" " " "digit_index"
); } } while (false); } while (false);
CHECK_LT(digit_index, BigInt::kMaxLength)do { bool _cmp = ::v8::base::CmpLTImpl< typename ::v8::base
::pass_value_or_ref<decltype(digit_index)>::type, typename
 ::v8::base::pass_value_or_ref<decltype(BigInt::kMaxLength
)>::type>((digit_index), (BigInt::kMaxLength)); do { if
 ((__builtin_expect(!!(!(_cmp)), 0))) { V8_Fatal("Check failed: %s."
, "digit_index" " " "<" " " "BigInt::kMaxLength"); } } while
 (false); } while (false);
StoreObjectFieldNoWriteBarrier(
    bigint,
    BigInt::kDigitsOffset +
        static_cast<int>(digit_index) * kSystemPointerSize,
    digit);
3434}

3436void CodeStubAssembler::StoreBigIntDigit(TNode<BigInt> bigint,
                                       TNode<IntPtrT> digit_index,
                                       TNode<UintPtrT> digit) {
TNode<IntPtrT> offset =
    IntPtrAdd(IntPtrConstant(BigInt::kDigitsOffset),
              IntPtrMul(digit_index, IntPtrConstant(kSystemPointerSize)));
StoreObjectFieldNoWriteBarrier(bigint, offset, digit);
3443}

3445TNode<Word32T> CodeStubAssembler::LoadBigIntBitfield(TNode<BigInt> bigint) {
return UncheckedCast<Word32T>(
    LoadObjectField<Uint32T>(bigint, BigInt::kBitfieldOffset));
3448}

3450TNode<UintPtrT> CodeStubAssembler::LoadBigIntDigit(TNode<BigInt> bigint,
                                                 intptr_t digit_index) {
CHECK_LE(0, digit_index)do { bool _cmp = ::v8::base::CmpLEImpl< typename ::v8::base
::pass_value_or_ref<decltype(0)>::type, typename ::v8::
base::pass_value_or_ref<decltype(digit_index)>::type>
((0), (digit_index)); do { if ((__builtin_expect(!!(!(_cmp)),
 0))) { V8_Fatal("Check failed: %s.", "0" " " "<=" " " "digit_index"
); } } while (false); } while (false);
CHECK_LT(digit_index, BigInt::kMaxLength)do { bool _cmp = ::v8::base::CmpLTImpl< typename ::v8::base
::pass_value_or_ref<decltype(digit_index)>::type, typename
 ::v8::base::pass_value_or_ref<decltype(BigInt::kMaxLength
)>::type>((digit_index), (BigInt::kMaxLength)); do { if
 ((__builtin_expect(!!(!(_cmp)), 0))) { V8_Fatal("Check failed: %s."
, "digit_index" " " "<" " " "BigInt::kMaxLength"); } } while
 (false); } while (false);
return LoadObjectField<UintPtrT>(
    bigint, BigInt::kDigitsOffset +
                static_cast<int>(digit_index) * kSystemPointerSize);
3457}

3459TNode<UintPtrT> CodeStubAssembler::LoadBigIntDigit(TNode<BigInt> bigint,
                                                 TNode<IntPtrT> digit_index) {
TNode<IntPtrT> offset =
    IntPtrAdd(IntPtrConstant(BigInt::kDigitsOffset),
              IntPtrMul(digit_index, IntPtrConstant(kSystemPointerSize)));
return LoadObjectField<UintPtrT>(bigint, offset);
3465}

3467TNode<ByteArray> CodeStubAssembler::AllocateNonEmptyByteArray(
  TNode<UintPtrT> length, AllocationFlags flags) {
CSA_DCHECK(this, WordNotEqual(length, IntPtrConstant(0)))((void)0);

Comment("AllocateNonEmptyByteArray");
TVARIABLE(Object, var_result)TVariable<Object> var_result(this);

TNode<IntPtrT> raw_size =
    GetArrayAllocationSize(Signed(length), UINT8_ELEMENTS,
                           ByteArray::kHeaderSize + kObjectAlignmentMask);
TNode<IntPtrT> size =
    WordAnd(raw_size, IntPtrConstant(~kObjectAlignmentMask));

TNode<HeapObject> result = Allocate(size, flags);

DCHECK(RootsTable::IsImmortalImmovable(RootIndex::kByteArrayMap))((void) 0);
StoreMapNoWriteBarrier(result, RootIndex::kByteArrayMap);
StoreObjectFieldNoWriteBarrier(result, ByteArray::kLengthOffset,
                               SmiTag(Signed(length)));

return CAST(result)Cast(result);
3488}

3490TNode<ByteArray> CodeStubAssembler::AllocateByteArray(TNode<UintPtrT> length,
                                                    AllocationFlags flags) {
// TODO(ishell): unify with AllocateNonEmptyByteArray().

Comment("AllocateByteArray");
TVARIABLE(Object, var_result)TVariable<Object> var_result(this);

// Compute the ByteArray size and check if it fits into new space.
Label if_lengthiszero(this), if_sizeissmall(this),
    if_notsizeissmall(this, Label::kDeferred), if_join(this);
GotoIf(WordEqual(length, UintPtrConstant(0)), &if_lengthiszero);

TNode<IntPtrT> raw_size =
    GetArrayAllocationSize(Signed(length), UINT8_ELEMENTS,
                           ByteArray::kHeaderSize + kObjectAlignmentMask);
TNode<IntPtrT> size =
    WordAnd(raw_size, IntPtrConstant(~kObjectAlignmentMask));
Branch(IntPtrLessThanOrEqual(size, IntPtrConstant(kMaxRegularHeapObjectSize)),
       &if_sizeissmall, &if_notsizeissmall);

BIND(&if_sizeissmall)Bind(&if_sizeissmall);
{
  // Just allocate the ByteArray in new space.
  TNode<HeapObject> result =
      AllocateInNewSpace(UncheckedCast<IntPtrT>(size), flags);
  DCHECK(RootsTable::IsImmortalImmovable(RootIndex::kByteArrayMap))((void) 0);
  StoreMapNoWriteBarrier(result, RootIndex::kByteArrayMap);
  StoreObjectFieldNoWriteBarrier(result, ByteArray::kLengthOffset,
                                 SmiTag(Signed(length)));
  var_result = result;
  Goto(&if_join);
}

BIND(&if_notsizeissmall)Bind(&if_notsizeissmall);
{
  // We might need to allocate in large object space, go to the runtime.
  TNode<Object> result =
      CallRuntime(Runtime::kAllocateByteArray, NoContextConstant(),
                  ChangeUintPtrToTagged(length));
  var_result = result;
  Goto(&if_join);
}

BIND(&if_lengthiszero)Bind(&if_lengthiszero);
{
  var_result = EmptyByteArrayConstant();
  Goto(&if_join);
}

BIND(&if_join)Bind(&if_join);
return CAST(var_result.value())Cast(var_result.value());
3541}

3543TNode<String> CodeStubAssembler::AllocateSeqOneByteString(
  uint32_t length, AllocationFlags flags) {
Comment("AllocateSeqOneByteString");
if (length == 0) {
  return EmptyStringConstant();
}
TNode<HeapObject> result = Allocate(SeqOneByteString::SizeFor(length), flags);
DCHECK(RootsTable::IsImmortalImmovable(RootIndex::kOneByteStringMap))((void) 0);
StoreMapNoWriteBarrier(result, RootIndex::kOneByteStringMap);
StoreObjectFieldNoWriteBarrier(result, SeqOneByteString::kLengthOffset,
                               Uint32Constant(length));
StoreObjectFieldNoWriteBarrier(result, SeqOneByteString::kRawHashFieldOffset,
                               Int32Constant(String::kEmptyHashField));
return CAST(result)Cast(result);
3557}

3559TNode<BoolT> CodeStubAssembler::IsZeroOrContext(TNode<Object> object) {
return Select<BoolT>(
    TaggedEqual(object, SmiConstant(0)), [=] { return Int32TrueConstant(); },
    [=] { return IsContext(CAST(object)Cast(object)); });
3563}

3565TNode<String> CodeStubAssembler::AllocateSeqTwoByteString(
  uint32_t length, AllocationFlags flags) {
Comment("AllocateSeqTwoByteString");
if (length == 0) {
  return EmptyStringConstant();
}
TNode<HeapObject> result = Allocate(SeqTwoByteString::SizeFor(length), flags);
DCHECK(RootsTable::IsImmortalImmovable(RootIndex::kStringMap))((void) 0);
StoreMapNoWriteBarrier(result, RootIndex::kStringMap);
StoreObjectFieldNoWriteBarrier(result, SeqTwoByteString::kLengthOffset,
                               Uint32Constant(length));
StoreObjectFieldNoWriteBarrier(result, SeqTwoByteString::kRawHashFieldOffset,
                               Int32Constant(String::kEmptyHashField));
return CAST(result)Cast(result);
3579}

3581TNode<String> CodeStubAssembler::AllocateSlicedString(RootIndex map_root_index,
                                                    TNode<Uint32T> length,
                                                    TNode<String> parent,
                                                    TNode<Smi> offset) {
DCHECK(map_root_index == RootIndex::kSlicedOneByteStringMap ||((void) 0)
       map_root_index == RootIndex::kSlicedStringMap)((void) 0);
TNode<HeapObject> result = Allocate(SlicedString::kSize);
DCHECK(RootsTable::IsImmortalImmovable(map_root_index))((void) 0);
StoreMapNoWriteBarrier(result, map_root_index);
StoreObjectFieldNoWriteBarrier(result, SlicedString::kRawHashFieldOffset,
                               Int32Constant(String::kEmptyHashField));
StoreObjectFieldNoWriteBarrier(result, SlicedString::kLengthOffset, length);
StoreObjectFieldNoWriteBarrier(result, SlicedString::kParentOffset, parent);
StoreObjectFieldNoWriteBarrier(result, SlicedString::kOffsetOffset, offset);
return CAST(result)Cast(result);
3596}

3598TNode<String> CodeStubAssembler::AllocateSlicedOneByteString(
  TNode<Uint32T> length, TNode<String> parent, TNode<Smi> offset) {
return AllocateSlicedString(RootIndex::kSlicedOneByteStringMap, length,
                            parent, offset);
3602}

3604TNode<String> CodeStubAssembler::AllocateSlicedTwoByteString(
  TNode<Uint32T> length, TNode<String> parent, TNode<Smi> offset) {
return AllocateSlicedString(RootIndex::kSlicedStringMap, length, parent,
                            offset);
3608}

3610TNode<NameDictionary> CodeStubAssembler::AllocateNameDictionary(
  int at_least_space_for) {
return AllocateNameDictionary(IntPtrConstant(at_least_space_for));
3613}

3615TNode<NameDictionary> CodeStubAssembler::AllocateNameDictionary(
  TNode<IntPtrT> at_least_space_for, AllocationFlags flags) {
CSA_DCHECK(this, UintPtrLessThanOrEqual(((void)0)
                     at_least_space_for,((void)0)
                     IntPtrConstant(NameDictionary::kMaxCapacity)))((void)0);
TNode<IntPtrT> capacity = HashTableComputeCapacity(at_least_space_for);
return AllocateNameDictionaryWithCapacity(capacity, flags);
3622}

3624TNode<NameDictionary> CodeStubAssembler::AllocateNameDictionaryWithCapacity(
  TNode<IntPtrT> capacity, AllocationFlags flags) {
CSA_DCHECK(this, WordIsPowerOfTwo(capacity))((void)0);
CSA_DCHECK(this, IntPtrGreaterThan(capacity, IntPtrConstant(0)))((void)0);
TNode<IntPtrT> length = EntryToIndex<NameDictionary>(capacity);
TNode<IntPtrT> store_size = IntPtrAdd(
    TimesTaggedSize(length), IntPtrConstant(NameDictionary::kHeaderSize));

TNode<NameDictionary> result =
    UncheckedCast<NameDictionary>(Allocate(store_size, flags));

// Initialize FixedArray fields.
{
  DCHECK(RootsTable::IsImmortalImmovable(RootIndex::kNameDictionaryMap))((void) 0);
  StoreMapNoWriteBarrier(result, RootIndex::kNameDictionaryMap);
  StoreObjectFieldNoWriteBarrier(result, FixedArray::kLengthOffset,
                                 SmiFromIntPtr(length));
}

// Initialized HashTable fields.
{
  TNode<Smi> zero = SmiConstant(0);
  StoreFixedArrayElement(result, NameDictionary::kNumberOfElementsIndex, zero,
                         SKIP_WRITE_BARRIER);
  StoreFixedArrayElement(result,
                         NameDictionary::kNumberOfDeletedElementsIndex, zero,
                         SKIP_WRITE_BARRIER);
  StoreFixedArrayElement(result, NameDictionary::kCapacityIndex,
                         SmiTag(capacity), SKIP_WRITE_BARRIER);
  // Initialize Dictionary fields.
  StoreFixedArrayElement(result, NameDictionary::kNextEnumerationIndexIndex,
                         SmiConstant(PropertyDetails::kInitialIndex),
                         SKIP_WRITE_BARRIER);
  StoreFixedArrayElement(result, NameDictionary::kObjectHashIndex,
                         SmiConstant(PropertyArray::kNoHashSentinel),
                         SKIP_WRITE_BARRIER);
}

// Initialize NameDictionary elements.
{
  TNode<IntPtrT> result_word = BitcastTaggedToWord(result);
  TNode<IntPtrT> start_address = IntPtrAdd(
      result_word, IntPtrConstant(NameDictionary::OffsetOfElementAt(
                                      NameDictionary::kElementsStartIndex) -
                                  kHeapObjectTag));
  TNode<IntPtrT> end_address = IntPtrAdd(
      result_word, IntPtrSub(store_size, IntPtrConstant(kHeapObjectTag)));

  TNode<Oddball> filler = UndefinedConstant();
  DCHECK(RootsTable::IsImmortalImmovable(RootIndex::kUndefinedValue))((void) 0);

  StoreFieldsNoWriteBarrier(start_address, end_address, filler);
}

return result;
3679}

3681TNode<NameDictionary> CodeStubAssembler::CopyNameDictionary(
  TNode<NameDictionary> dictionary, Label* large_object_fallback) {
Comment("Copy boilerplate property dict");
TNode<IntPtrT> capacity = SmiUntag(GetCapacity<NameDictionary>(dictionary));
CSA_DCHECK(this, IntPtrGreaterThanOrEqual(capacity, IntPtrConstant(0)))((void)0);
GotoIf(UintPtrGreaterThan(
           capacity, IntPtrConstant(NameDictionary::kMaxRegularCapacity)),
       large_object_fallback);
TNode<NameDictionary> properties =
    AllocateNameDictionaryWithCapacity(capacity);
TNode<IntPtrT> length = SmiUntag(LoadFixedArrayBaseLength(dictionary));
CopyFixedArrayElements(PACKED_ELEMENTS, dictionary, properties, length,
                       SKIP_WRITE_BARRIER);
return properties;
3695}

3697template <typename CollectionType>
3698TNode<CollectionType> CodeStubAssembler::AllocateOrderedHashTable(
  TNode<IntPtrT> capacity) {
capacity = IntPtrRoundUpToPowerOfTwo32(capacity);
capacity =
    IntPtrMax(capacity, IntPtrConstant(CollectionType::kInitialCapacity));
return AllocateOrderedHashTableWithCapacity<CollectionType>(capacity);
3704}

3706template <typename CollectionType>
3707TNode<CollectionType> CodeStubAssembler::AllocateOrderedHashTableWithCapacity(
  TNode<IntPtrT> capacity) {
CSA_DCHECK(this, WordIsPowerOfTwo(capacity))((void)0);
CSA_DCHECK(this,((void)0)
           IntPtrGreaterThanOrEqual(((void)0)
               capacity, IntPtrConstant(CollectionType::kInitialCapacity)))((void)0);
CSA_DCHECK(this,((void)0)
           IntPtrLessThanOrEqual(((void)0)
               capacity, IntPtrConstant(CollectionType::MaxCapacity())))((void)0);

STATIC_ASSERT(CollectionType::kLoadFactor == 2)static_assert(CollectionType::kLoadFactor == 2, "CollectionType::kLoadFactor == 2"
);
TNode<IntPtrT> bucket_count = Signed(WordShr(capacity, IntPtrConstant(1)));
TNode<IntPtrT> data_table_length =
    IntPtrMul(capacity, IntPtrConstant(CollectionType::kEntrySize));

TNode<IntPtrT> data_table_start_index = IntPtrAdd(
    IntPtrConstant(CollectionType::HashTableStartIndex()), bucket_count);
TNode<IntPtrT> fixed_array_length =
    IntPtrAdd(data_table_start_index, data_table_length);

// Allocate the table and add the proper map.
const ElementsKind elements_kind = HOLEY_ELEMENTS;
TNode<Map> fixed_array_map =
    HeapConstant(CollectionType::GetMap(ReadOnlyRoots(isolate())));
TNode<CollectionType> table = CAST(AllocateFixedArray(Cast(AllocateFixedArray( elements_kind, fixed_array_length, AllocationFlag
::kAllowLargeObjectAllocation, fixed_array_map))
    elements_kind, fixed_array_length,Cast(AllocateFixedArray( elements_kind, fixed_array_length, AllocationFlag
::kAllowLargeObjectAllocation, fixed_array_map))
    AllocationFlag::kAllowLargeObjectAllocation, fixed_array_map))Cast(AllocateFixedArray( elements_kind, fixed_array_length, AllocationFlag
::kAllowLargeObjectAllocation, fixed_array_map));

Comment("Initialize the OrderedHashTable fields.");
const WriteBarrierMode barrier_mode = SKIP_WRITE_BARRIER;
UnsafeStoreFixedArrayElement(table, CollectionType::NumberOfElementsIndex(),
                             SmiConstant(0), barrier_mode);
UnsafeStoreFixedArrayElement(table,
                             CollectionType::NumberOfDeletedElementsIndex(),
                             SmiConstant(0), barrier_mode);
UnsafeStoreFixedArrayElement(table, CollectionType::NumberOfBucketsIndex(),
                             SmiFromIntPtr(bucket_count), barrier_mode);

TNode<IntPtrT> object_address = BitcastTaggedToWord(table);

STATIC_ASSERT(CollectionType::HashTableStartIndex() ==static_assert(CollectionType::HashTableStartIndex() == CollectionType
::NumberOfBucketsIndex() + 1, "CollectionType::HashTableStartIndex() == CollectionType::NumberOfBucketsIndex() + 1"
)
              CollectionType::NumberOfBucketsIndex() + 1)static_assert(CollectionType::HashTableStartIndex() == CollectionType
::NumberOfBucketsIndex() + 1, "CollectionType::HashTableStartIndex() == CollectionType::NumberOfBucketsIndex() + 1"
);

TNode<Smi> not_found_sentinel = SmiConstant(CollectionType::kNotFound);

intptr_t const_capacity;
if (TryToIntPtrConstant(capacity, &const_capacity) &&
    const_capacity == CollectionType::kInitialCapacity) {
  int const_bucket_count =
      static_cast<int>(const_capacity / CollectionType::kLoadFactor);
  int const_data_table_length =
      static_cast<int>(const_capacity * CollectionType::kEntrySize);
  int const_data_table_start_index = static_cast<int>(
      CollectionType::HashTableStartIndex() + const_bucket_count);

  Comment("Fill the buckets with kNotFound (constant capacity).");
  for (int i = 0; i < const_bucket_count; i++) {
    UnsafeStoreFixedArrayElement(table,
                                 CollectionType::HashTableStartIndex() + i,
                                 not_found_sentinel, barrier_mode);
  }

  Comment("Fill the data table with undefined (constant capacity).");
  for (int i = 0; i < const_data_table_length; i++) {
    UnsafeStoreFixedArrayElement(table, const_data_table_start_index + i,
                                 UndefinedConstant(), barrier_mode);
  }
} else {
  Comment("Fill the buckets with kNotFound.");
  TNode<IntPtrT> buckets_start_address =
      IntPtrAdd(object_address,
                IntPtrConstant(FixedArray::OffsetOfElementAt(
                                   CollectionType::HashTableStartIndex()) -
                               kHeapObjectTag));
  TNode<IntPtrT> buckets_end_address =
      IntPtrAdd(buckets_start_address, TimesTaggedSize(bucket_count));

  StoreFieldsNoWriteBarrier(buckets_start_address, buckets_end_address,
                            not_found_sentinel);

  Comment("Fill the data table with undefined.");
  TNode<IntPtrT> data_start_address = buckets_end_address;
  TNode<IntPtrT> data_end_address = IntPtrAdd(
      object_address,
      IntPtrAdd(IntPtrConstant(FixedArray::kHeaderSize - kHeapObjectTag),
                TimesTaggedSize(fixed_array_length)));

  StoreFieldsNoWriteBarrier(data_start_address, data_end_address,
                            UndefinedConstant());

3797#ifdef DEBUG
  TNode<IntPtrT> ptr_diff =
      IntPtrSub(data_end_address, buckets_start_address);
  TNode<IntPtrT> array_length = LoadAndUntagFixedArrayBaseLength(table);
  TNode<IntPtrT> array_data_fields = IntPtrSub(
      array_length, IntPtrConstant(CollectionType::HashTableStartIndex()));
  TNode<IntPtrT> expected_end =
      IntPtrAdd(data_start_address,
                TimesTaggedSize(IntPtrMul(
                    capacity, IntPtrConstant(CollectionType::kEntrySize))));

  CSA_DCHECK(this, IntPtrEqual(ptr_diff, TimesTaggedSize(array_data_fields)))((void)0);
  CSA_DCHECK(this, IntPtrEqual(expected_end, data_end_address))((void)0);
3810#endif
}

return table;
3814}

3816TNode<OrderedNameDictionary> CodeStubAssembler::AllocateOrderedNameDictionary(
  TNode<IntPtrT> capacity) {
TNode<OrderedNameDictionary> table =
    AllocateOrderedHashTable<OrderedNameDictionary>(capacity);
StoreFixedArrayElement(table, OrderedNameDictionary::PrefixIndex(),
                       SmiConstant(PropertyArray::kNoHashSentinel),
                       SKIP_WRITE_BARRIER);
return table;
3824}

3826TNode<OrderedNameDictionary> CodeStubAssembler::AllocateOrderedNameDictionary(
  int capacity) {
return AllocateOrderedNameDictionary(IntPtrConstant(capacity));
3829}

3831TNode<OrderedHashSet> CodeStubAssembler::AllocateOrderedHashSet() {
return AllocateOrderedHashTableWithCapacity<OrderedHashSet>(
    IntPtrConstant(OrderedHashSet::kInitialCapacity));
3834}

3836TNode<OrderedHashMap> CodeStubAssembler::AllocateOrderedHashMap() {
return AllocateOrderedHashTableWithCapacity<OrderedHashMap>(
    IntPtrConstant(OrderedHashMap::kInitialCapacity));
3839}

3841TNode<JSObject> CodeStubAssembler::AllocateJSObjectFromMap(
  TNode<Map> map, base::Optional<TNode<HeapObject>> properties,
  base::Optional<TNode<FixedArray>> elements, AllocationFlags flags,
  SlackTrackingMode slack_tracking_mode) {
CSA_DCHECK(this, Word32BinaryNot(IsJSFunctionMap(map)))((void)0);
CSA_DCHECK(this, Word32BinaryNot(InstanceTypeEqual(LoadMapInstanceType(map),((void)0)
                                                   JS_GLOBAL_OBJECT_TYPE)))((void)0);
TNode<IntPtrT> instance_size =
    TimesTaggedSize(LoadMapInstanceSizeInWords(map));
TNode<HeapObject> object = AllocateInNewSpace(instance_size, flags);
StoreMapNoWriteBarrier(object, map);
InitializeJSObjectFromMap(object, map, instance_size, properties, elements,
                          slack_tracking_mode);
return CAST(object)Cast(object);
3855}

3857void CodeStubAssembler::InitializeJSObjectFromMap(
  TNode<HeapObject> object, TNode<Map> map, TNode<IntPtrT> instance_size,
  base::Optional<TNode<HeapObject>> properties,
  base::Optional<TNode<FixedArray>> elements,
  SlackTrackingMode slack_tracking_mode) {
// This helper assumes that the object is in new-space, as guarded by the
// check in AllocatedJSObjectFromMap.
if (!properties) {
  CSA_DCHECK(this, Word32BinaryNot(IsDictionaryMap((map))))((void)0);
  StoreObjectFieldRoot(object, JSObject::kPropertiesOrHashOffset,
                       RootIndex::kEmptyFixedArray);
} else {
  CSA_DCHECK(this, Word32Or(Word32Or(Word32Or(IsPropertyArray(*properties),((void)0)
                                              IsNameDictionary(*properties)),((void)0)
                                     IsSwissNameDictionary(*properties)),((void)0)
                            IsEmptyFixedArray(*properties)))((void)0);
  StoreObjectFieldNoWriteBarrier(object, JSObject::kPropertiesOrHashOffset,
                                 *properties);
}
if (!elements) {
  StoreObjectFieldRoot(object, JSObject::kElementsOffset,
                       RootIndex::kEmptyFixedArray);
} else {
  StoreObjectFieldNoWriteBarrier(object, JSObject::kElementsOffset,
                                 *elements);
}
if (slack_tracking_mode == kNoSlackTracking) {
  InitializeJSObjectBodyNoSlackTracking(object, map, instance_size);
} else {
  DCHECK_EQ(slack_tracking_mode, kWithSlackTracking)((void) 0);
  InitializeJSObjectBodyWithSlackTracking(object, map, instance_size);
}
3889}

3891void CodeStubAssembler::InitializeJSObjectBodyNoSlackTracking(
  TNode<HeapObject> object, TNode<Map> map, TNode<IntPtrT> instance_size,
  int start_offset) {
STATIC_ASSERT(Map::kNoSlackTracking == 0)static_assert(Map::kNoSlackTracking == 0, "Map::kNoSlackTracking == 0"
);
CSA_DCHECK(this, IsClearWord32<Map::Bits3::ConstructionCounterBits>(((void)0)
                     LoadMapBitField3(map)))((void)0);
InitializeFieldsWithRoot(object, IntPtrConstant(start_offset), instance_size,
                         RootIndex::kUndefinedValue);
3899}

3901void CodeStubAssembler::InitializeJSObjectBodyWithSlackTracking(
  TNode<HeapObject> object, TNode<Map> map, TNode<IntPtrT> instance_size) {
Comment("InitializeJSObjectBodyNoSlackTracking");

// Perform in-object slack tracking if requested.
int start_offset = JSObject::kHeaderSize;
TNode<Uint32T> bit_field3 = LoadMapBitField3(map);
Label end(this), slack_tracking(this), complete(this, Label::kDeferred);
STATIC_ASSERT(Map::kNoSlackTracking == 0)static_assert(Map::kNoSlackTracking == 0, "Map::kNoSlackTracking == 0"
);
GotoIf(IsSetWord32<Map::Bits3::ConstructionCounterBits>(bit_field3),
       &slack_tracking);
Comment("No slack tracking");
InitializeJSObjectBodyNoSlackTracking(object, map, instance_size);
Goto(&end);

BIND(&slack_tracking)Bind(&slack_tracking);
{
  Comment("Decrease construction counter");
  // Slack tracking is only done on initial maps.
  CSA_DCHECK(this, IsUndefined(LoadMapBackPointer(map)))((void)0);
  STATIC_ASSERT(Map::Bits3::ConstructionCounterBits::kLastUsedBit == 31)static_assert(Map::Bits3::ConstructionCounterBits::kLastUsedBit
 == 31, "Map::Bits3::ConstructionCounterBits::kLastUsedBit == 31"
);
  TNode<Word32T> new_bit_field3 = Int32Sub(
      bit_field3,
      Int32Constant(1 << Map::Bits3::ConstructionCounterBits::kShift));
  StoreObjectFieldNoWriteBarrier(map, Map::kBitField3Offset, new_bit_field3);
  STATIC_ASSERT(Map::kSlackTrackingCounterEnd == 1)static_assert(Map::kSlackTrackingCounterEnd == 1, "Map::kSlackTrackingCounterEnd == 1"
);

  // The object still has in-object slack therefore the |unsed_or_unused|
  // field contain the "used" value.
  TNode<IntPtrT> used_size =
      Signed(TimesTaggedSize(ChangeUint32ToWord(LoadObjectField<Uint8T>(
          map, Map::kUsedOrUnusedInstanceSizeInWordsOffset))));

  Comment("iInitialize filler fields");
  InitializeFieldsWithRoot(object, used_size, instance_size,
                           RootIndex::kOnePointerFillerMap);

  Comment("Initialize undefined fields");
  InitializeFieldsWithRoot(object, IntPtrConstant(start_offset), used_size,
                           RootIndex::kUndefinedValue);

  STATIC_ASSERT(Map::kNoSlackTracking == 0)static_assert(Map::kNoSlackTracking == 0, "Map::kNoSlackTracking == 0"
);
  GotoIf(IsClearWord32<Map::Bits3::ConstructionCounterBits>(new_bit_field3),
         &complete);
  Goto(&end);
}

// Finalize the instance size.
BIND(&complete)Bind(&complete);
{
  // ComplextInobjectSlackTracking doesn't allocate and thus doesn't need a
  // context.
  CallRuntime(Runtime::kCompleteInobjectSlackTrackingForMap,
              NoContextConstant(), map);
  Goto(&end);
}

BIND(&end)Bind(&end);
3959}

3961void CodeStubAssembler::StoreFieldsNoWriteBarrier(TNode<IntPtrT> start_address,
                                                TNode<IntPtrT> end_address,
                                                TNode<Object> value) {
Comment("StoreFieldsNoWriteBarrier");
CSA_DCHECK(this, WordIsAligned(start_address, kTaggedSize))((void)0);
CSA_DCHECK(this, WordIsAligned(end_address, kTaggedSize))((void)0);
BuildFastLoop<IntPtrT>(
    start_address, end_address,
    [=](TNode<IntPtrT> current) {
      UnsafeStoreNoWriteBarrier(MachineRepresentation::kTagged, current,
                                value);
    },
    kTaggedSize, IndexAdvanceMode::kPost);
3974}

3976void CodeStubAssembler::MakeFixedArrayCOW(TNode<FixedArray> array) {
CSA_DCHECK(this, IsFixedArrayMap(LoadMap(array)))((void)0);
Label done(this);
// The empty fixed array is not modifiable anyway. And we shouldn't change its
// Map.
GotoIf(TaggedEqual(array, EmptyFixedArrayConstant()), &done);
StoreMap(array, FixedCOWArrayMapConstant());
Goto(&done);
BIND(&done)Bind(&done);
3985}

3987TNode<BoolT> CodeStubAssembler::IsValidFastJSArrayCapacity(
  TNode<IntPtrT> capacity) {
return UintPtrLessThanOrEqual(capacity,
                              UintPtrConstant(JSArray::kMaxFastArrayLength));
3991}

3993TNode<JSArray> CodeStubAssembler::AllocateJSArray(
  TNode<Map> array_map, TNode<FixedArrayBase> elements, TNode<Smi> length,
  base::Optional<TNode<AllocationSite>> allocation_site,
  int array_header_size) {
Comment("begin allocation of JSArray passing in elements");
CSA_SLOW_DCHECK(this, TaggedIsPositiveSmi(length))((void)0);

int base_size = array_header_size;
if (allocation_site) {
  DCHECK(V8_ALLOCATION_SITE_TRACKING_BOOL)((void) 0);
  base_size += AllocationMemento::kSize;
}

TNode<IntPtrT> size = IntPtrConstant(base_size);
TNode<JSArray> result =
    AllocateUninitializedJSArray(array_map, length, allocation_site, size);
StoreObjectFieldNoWriteBarrier(result, JSArray::kElementsOffset, elements);
return result;
4011}

4013namespace {

4015// To prevent GC between the array and elements allocation, the elements
4016// object allocation is folded together with the js-array allocation.
4017TNode<FixedArrayBase> InnerAllocateElements(CodeStubAssembler* csa,
                                          TNode<JSArray> js_array,
                                          int offset) {
return csa->UncheckedCast<FixedArrayBase>(
    csa->BitcastWordToTagged(csa->IntPtrAdd(
        csa->BitcastTaggedToWord(js_array), csa->IntPtrConstant(offset))));
4023}

4025}  // namespace

4027std::pair<TNode<JSArray>, TNode<FixedArrayBase>>
4028CodeStubAssembler::AllocateUninitializedJSArrayWithElements(
  ElementsKind kind, TNode<Map> array_map, TNode<Smi> length,
  base::Optional<TNode<AllocationSite>> allocation_site,
  TNode<IntPtrT> capacity, AllocationFlags allocation_flags,
  int array_header_size) {
Comment("begin allocation of JSArray with elements");
CHECK_EQ(allocation_flags & ~AllocationFlag::kAllowLargeObjectAllocation, 0)do { bool _cmp = ::v8::base::CmpEQImpl< typename ::v8::base
::pass_value_or_ref<decltype(allocation_flags & ~AllocationFlag
::kAllowLargeObjectAllocation)>::type, typename ::v8::base
::pass_value_or_ref<decltype(0)>::type>((allocation_flags
 & ~AllocationFlag::kAllowLargeObjectAllocation), (0)); do
 { if ((__builtin_expect(!!(!(_cmp)), 0))) { V8_Fatal("Check failed: %s."
, "allocation_flags & ~AllocationFlag::kAllowLargeObjectAllocation"
 " " "==" " " "0"); } } while (false); } while (false);
CSA_SLOW_DCHECK(this, TaggedIsPositiveSmi(length))((void)0);

TVARIABLE(JSArray, array)TVariable<JSArray> array(this);
TVARIABLE(FixedArrayBase, elements)TVariable<FixedArrayBase> elements(this);

Label out(this), empty(this), nonempty(this);

int capacity_int;
if (TryToInt32Constant(capacity, &capacity_int)) {
  if (capacity_int == 0) {
    TNode<FixedArray> empty_array = EmptyFixedArrayConstant();
    array = AllocateJSArray(array_map, empty_array, length, allocation_site,
                            array_header_size);
    return {array.value(), empty_array};
  } else {
    Goto(&nonempty);
  }
} else {
  Branch(WordEqual(capacity, IntPtrConstant(0)), &empty, &nonempty);

  BIND(&empty)Bind(&empty);
  {
    TNode<FixedArray> empty_array = EmptyFixedArrayConstant();
    array = AllocateJSArray(array_map, empty_array, length, allocation_site,
                            array_header_size);
    elements = empty_array;
    Goto(&out);
  }
}

BIND(&nonempty)Bind(&nonempty);
{
  int base_size = array_header_size;
  if (allocation_site) {
    DCHECK(V8_ALLOCATION_SITE_TRACKING_BOOL)((void) 0);
    base_size += AllocationMemento::kSize;
  }

  const int elements_offset = base_size;

  // Compute space for elements
  base_size += FixedArray::kHeaderSize;
  TNode<IntPtrT> size = ElementOffsetFromIndex(capacity, kind, base_size);

  // For very large arrays in which the requested allocation exceeds the
  // maximal size of a regular heap object, we cannot use the allocation
  // folding trick. Instead, we first allocate the elements in large object
  // space, and then allocate the JSArray (and possibly the allocation
  // memento) in new space.
  if (allocation_flags & AllocationFlag::kAllowLargeObjectAllocation) {
    Label next(this);
    GotoIf(IsRegularHeapObjectSize(size), &next);

    CSA_CHECK(this, IsValidFastJSArrayCapacity(capacity))(this)->FastCheck(IsValidFastJSArrayCapacity(capacity));

    // Allocate and initialize the elements first. Full initialization is
    // needed because the upcoming JSArray allocation could trigger GC.
    elements = AllocateFixedArray(kind, capacity, allocation_flags);

    if (IsDoubleElementsKind(kind)) {
      FillFixedDoubleArrayWithZero(CAST(elements.value())Cast(elements.value()), capacity);
    } else {
      FillFixedArrayWithSmiZero(CAST(elements.value())Cast(elements.value()), capacity);
    }

    // The JSArray and possibly allocation memento next. Note that
    // allocation_flags are *not* passed on here and the resulting JSArray
    // will always be in new space.
    array = AllocateJSArray(array_map, elements.value(), length,
                            allocation_site, array_header_size);

    Goto(&out);

    BIND(&next)Bind(&next);
  }
  // Fold all objects into a single new space allocation.
  array =
      AllocateUninitializedJSArray(array_map, length, allocation_site, size);
  elements = InnerAllocateElements(this, array.value(), elements_offset);

  StoreObjectFieldNoWriteBarrier(array.value(), JSObject::kElementsOffset,
                                 elements.value());

  // Setup elements object.
  STATIC_ASSERT(FixedArrayBase::kHeaderSize == 2 * kTaggedSize)static_assert(FixedArrayBase::kHeaderSize == 2 * kTaggedSize,
 "FixedArrayBase::kHeaderSize == 2 * kTaggedSize");
  RootIndex elements_map_index = IsDoubleElementsKind(kind)
                                     ? RootIndex::kFixedDoubleArrayMap
                                     : RootIndex::kFixedArrayMap;
  DCHECK(RootsTable::IsImmortalImmovable(elements_map_index))((void) 0);
  StoreMapNoWriteBarrier(elements.value(), elements_map_index);

  CSA_DCHECK(this, WordNotEqual(capacity, IntPtrConstant(0)))((void)0);
  TNode<Smi> capacity_smi = SmiTag(capacity);
  StoreObjectFieldNoWriteBarrier(elements.value(), FixedArray::kLengthOffset,
                                 capacity_smi);
  Goto(&out);
}

BIND(&out)Bind(&out);
return {array.value(), elements.value()};
4135}

4137TNode<JSArray> CodeStubAssembler::AllocateUninitializedJSArray(
  TNode<Map> array_map, TNode<Smi> length,
  base::Optional<TNode<AllocationSite>> allocation_site,
  TNode<IntPtrT> size_in_bytes) {
CSA_SLOW_DCHECK(this, TaggedIsPositiveSmi(length))((void)0);

// Allocate space for the JSArray and the elements FixedArray in one go.
TNode<HeapObject> array = AllocateInNewSpace(size_in_bytes);

StoreMapNoWriteBarrier(array, array_map);
StoreObjectFieldNoWriteBarrier(array, JSArray::kLengthOffset, length);
StoreObjectFieldRoot(array, JSArray::kPropertiesOrHashOffset,
                     RootIndex::kEmptyFixedArray);

if (allocation_site) {
  DCHECK(V8_ALLOCATION_SITE_TRACKING_BOOL)((void) 0);
  InitializeAllocationMemento(array, IntPtrConstant(JSArray::kHeaderSize),
                              *allocation_site);
}

return CAST(array)Cast(array);
4158}

4160TNode<JSArray> CodeStubAssembler::AllocateJSArray(
  ElementsKind kind, TNode<Map> array_map, TNode<IntPtrT> capacity,
  TNode<Smi> length, base::Optional<TNode<AllocationSite>> allocation_site,
  AllocationFlags allocation_flags) {
CSA_SLOW_DCHECK(this, TaggedIsPositiveSmi(length))((void)0);

TNode<JSArray> array;
TNode<FixedArrayBase> elements;

std::tie(array, elements) = AllocateUninitializedJSArrayWithElements(
    kind, array_map, length, allocation_site, capacity, allocation_flags);

Label out(this), nonempty(this);

Branch(WordEqual(capacity, IntPtrConstant(0)), &out, &nonempty);

BIND(&nonempty)Bind(&nonempty);
{
  FillFixedArrayWithValue(kind, elements, IntPtrConstant(0), capacity,
                          RootIndex::kTheHoleValue);
  Goto(&out);
}

BIND(&out)Bind(&out);
return array;
4185}

4187TNode<JSArray> CodeStubAssembler::ExtractFastJSArray(TNode<Context> context,
                                                   TNode<JSArray> array,
                                                   TNode<BInt> begin,
                                                   TNode<BInt> count) {
TNode<Map> original_array_map = LoadMap(array);
TNode<Int32T> elements_kind = LoadMapElementsKind(original_array_map);

// Use the canonical map for the Array's ElementsKind
TNode<NativeContext> native_context = LoadNativeContext(context);
TNode<Map> array_map = LoadJSArrayElementsMap(elements_kind, native_context);

TNode<FixedArrayBase> new_elements = ExtractFixedArray(
    LoadElements(array), base::Optional<TNode<BInt>>(begin),
    base::Optional<TNode<BInt>>(count),
    base::Optional<TNode<BInt>>(base::nullopt),
    ExtractFixedArrayFlag::kAllFixedArrays, nullptr, elements_kind);

TNode<JSArray> result = AllocateJSArray(
    array_map, new_elements, ParameterToTagged(count), base::nullopt);
return result;
4207}

4209TNode<JSArray> CodeStubAssembler::CloneFastJSArray(
  TNode<Context> context, TNode<JSArray> array,
  base::Optional<TNode<AllocationSite>> allocation_site,
  HoleConversionMode convert_holes) {
// TODO(dhai): we should be able to assert IsFastJSArray(array) here, but this
// function is also used to copy boilerplates even when the no-elements
// protector is invalid. This function should be renamed to reflect its uses.

TNode<Number> length = LoadJSArrayLength(array);
TNode<FixedArrayBase> new_elements;
TVARIABLE(FixedArrayBase, var_new_elements)TVariable<FixedArrayBase> var_new_elements(this);
TVARIABLE(Int32T, var_elements_kind, LoadMapElementsKind(LoadMap(array)))TVariable<Int32T> var_elements_kind(LoadMapElementsKind
(LoadMap(array)), this);

Label allocate_jsarray(this), holey_extract(this),
    allocate_jsarray_main(this);

bool need_conversion =
    convert_holes == HoleConversionMode::kConvertToUndefined;
if (need_conversion) {
  // We need to take care of holes, if the array is of holey elements kind.
  GotoIf(IsHoleyFastElementsKindForRead(var_elements_kind.value()),
         &holey_extract);
}

// Simple extraction that preserves holes.
new_elements = ExtractFixedArray(
    LoadElements(array),
    base::Optional<TNode<BInt>>(IntPtrOrSmiConstant<BInt>(0)),
    base::Optional<TNode<BInt>>(TaggedToParameter<BInt>(CAST(length)Cast(length))),
    base::Optional<TNode<BInt>>(base::nullopt),
    ExtractFixedArrayFlag::kAllFixedArraysDontCopyCOW, nullptr,
    var_elements_kind.value());
var_new_elements = new_elements;
Goto(&allocate_jsarray);

if (need_conversion) {
  BIND(&holey_extract)Bind(&holey_extract);
  // Convert holes to undefined.
  TVARIABLE(BoolT, var_holes_converted, Int32FalseConstant())TVariable<BoolT> var_holes_converted(Int32FalseConstant
(), this);
  // Copy |array|'s elements store. The copy will be compatible with the
  // original elements kind unless there are holes in the source. Any holes
  // get converted to undefined, hence in that case the copy is compatible
  // only with PACKED_ELEMENTS and HOLEY_ELEMENTS, and we will choose
  // PACKED_ELEMENTS. Also, if we want to replace holes, we must not use
  // ExtractFixedArrayFlag::kDontCopyCOW.
  new_elements = ExtractFixedArray(
      LoadElements(array),
      base::Optional<TNode<BInt>>(IntPtrOrSmiConstant<BInt>(0)),
      base::Optional<TNode<BInt>>(TaggedToParameter<BInt>(CAST(length)Cast(length))),
      base::Optional<TNode<BInt>>(base::nullopt),
      ExtractFixedArrayFlag::kAllFixedArrays, &var_holes_converted);
  var_new_elements = new_elements;
  // If the array type didn't change, use the original elements kind.
  GotoIfNot(var_holes_converted.value(), &allocate_jsarray);
  // Otherwise use PACKED_ELEMENTS for the target's elements kind.
  var_elements_kind = Int32Constant(PACKED_ELEMENTS);
  Goto(&allocate_jsarray);
}

BIND(&allocate_jsarray)Bind(&allocate_jsarray);

// Handle any nonextensible elements kinds
CSA_DCHECK(this, IsElementsKindLessThanOrEqual(((void)0)
                     var_elements_kind.value(),((void)0)
                     LAST_ANY_NONEXTENSIBLE_ELEMENTS_KIND))((void)0);
GotoIf(IsElementsKindLessThanOrEqual(var_elements_kind.value(),
                                     LAST_FAST_ELEMENTS_KIND),
       &allocate_jsarray_main);
var_elements_kind = Int32Constant(PACKED_ELEMENTS);
Goto(&allocate_jsarray_main);

BIND(&allocate_jsarray_main)Bind(&allocate_jsarray_main);
// Use the cannonical map for the chosen elements kind.
TNode<NativeContext> native_context = LoadNativeContext(context);
TNode<Map> array_map =
    LoadJSArrayElementsMap(var_elements_kind.value(), native_context);

TNode<JSArray> result = AllocateJSArray(array_map, var_new_elements.value(),
                                        CAST(length)Cast(length), allocation_site);
return result;
4289}

4291template <typename TIndex>
4292TNode<FixedArrayBase> CodeStubAssembler::AllocateFixedArray(
  ElementsKind kind, TNode<TIndex> capacity, AllocationFlags flags,
  base::Optional<TNode<Map>> fixed_array_map) {
static_assert(
    std::is_same<TIndex, Smi>::value || std::is_same<TIndex, IntPtrT>::value,
    "Only Smi or IntPtrT capacity is allowed");
Comment("AllocateFixedArray");
CSA_DCHECK(this,((void)0)
           IntPtrOrSmiGreaterThan(capacity, IntPtrOrSmiConstant<TIndex>(0)))((void)0);

const intptr_t kMaxLength = IsDoubleElementsKind(kind)
                                ? FixedDoubleArray::kMaxLength
                                : FixedArray::kMaxLength;
intptr_t capacity_constant;
if (ToParameterConstant(capacity, &capacity_constant)) {
  CHECK_LE(capacity_constant, kMaxLength)do { bool _cmp = ::v8::base::CmpLEImpl< typename ::v8::base
::pass_value_or_ref<decltype(capacity_constant)>::type,
 typename ::v8::base::pass_value_or_ref<decltype(kMaxLength
)>::type>((capacity_constant), (kMaxLength)); do { if (
(__builtin_expect(!!(!(_cmp)), 0))) { V8_Fatal("Check failed: %s."
, "capacity_constant" " " "<=" " " "kMaxLength"); } } while
 (false); } while (false);
} else {
  Label if_out_of_memory(this, Label::kDeferred), next(this);
  Branch(IntPtrOrSmiGreaterThan(capacity, IntPtrOrSmiConstant<TIndex>(
                                              static_cast<int>(kMaxLength))),
         &if_out_of_memory, &next);

  BIND(&if_out_of_memory)Bind(&if_out_of_memory);
  CallRuntime(Runtime::kFatalProcessOutOfMemoryInvalidArrayLength,
              NoContextConstant());
  Unreachable();

  BIND(&next)Bind(&next);
}

TNode<IntPtrT> total_size = GetFixedArrayAllocationSize(capacity, kind);

if (IsDoubleElementsKind(kind)) flags |= AllocationFlag::kDoubleAlignment;
// Allocate both array and elements object, and initialize the JSArray.
TNode<HeapObject> array = Allocate(total_size, flags);
if (fixed_array_map) {
  // Conservatively only skip the write barrier if there are no allocation
  // flags, this ensures that the object hasn't ended up in LOS. Note that the
  // fixed array map is currently always immortal and technically wouldn't
  // need the write barrier even in LOS, but it's better to not take chances
  // in case this invariant changes later, since it's difficult to enforce
  // locally here.
  if (flags == AllocationFlag::kNone) {
    StoreMapNoWriteBarrier(array, *fixed_array_map);
  } else {
    StoreMap(array, *fixed_array_map);
  }
} else {
  RootIndex map_index = IsDoubleElementsKind(kind)
                            ? RootIndex::kFixedDoubleArrayMap
                            : RootIndex::kFixedArrayMap;
  DCHECK(RootsTable::IsImmortalImmovable(map_index))((void) 0);
  StoreMapNoWriteBarrier(array, map_index);
}
StoreObjectFieldNoWriteBarrier(array, FixedArrayBase::kLengthOffset,
                               ParameterToTagged(capacity));
return UncheckedCast<FixedArrayBase>(array);
4349}

4351// There is no need to export the Smi version since it is only used inside
4352// code-stub-assembler.
4353template V8_EXPORT_PRIVATE TNode<FixedArrayBase>
  CodeStubAssembler::AllocateFixedArray<IntPtrT>(ElementsKind, TNode<IntPtrT>,
                                                 AllocationFlags,
                                                 base::Optional<TNode<Map>>);

4358template <typename TIndex>
4359TNode<FixedArray> CodeStubAssembler::ExtractToFixedArray(
  TNode<FixedArrayBase> source, TNode<TIndex> first, TNode<TIndex> count,
  TNode<TIndex> capacity, TNode<Map> source_map, ElementsKind from_kind,
  AllocationFlags allocation_flags, ExtractFixedArrayFlags extract_flags,
  HoleConversionMode convert_holes, TVariable<BoolT>* var_holes_converted,
  base::Optional<TNode<Int32T>> source_elements_kind) {
static_assert(
    std::is_same<TIndex, Smi>::value || std::is_same<TIndex, IntPtrT>::value,
    "Only Smi or IntPtrT first, count, and capacity are allowed");

DCHECK(extract_flags & ExtractFixedArrayFlag::kFixedArrays)((void) 0);
CSA_DCHECK(this,((void)0)
           IntPtrOrSmiNotEqual(IntPtrOrSmiConstant<TIndex>(0), capacity))((void)0);
CSA_DCHECK(this, TaggedEqual(source_map, LoadMap(source)))((void)0);

TVARIABLE(FixedArrayBase, var_result)TVariable<FixedArrayBase> var_result(this);
TVARIABLE(Map, var_target_map, source_map)TVariable<Map> var_target_map(source_map, this);

Label done(this, {&var_result}), is_cow(this),
    new_space_handler(this, {&var_target_map});

// If source_map is either FixedDoubleArrayMap, or FixedCOWArrayMap but
// we can't just use COW, use FixedArrayMap as the target map. Otherwise, use
// source_map as the target map.
if (IsDoubleElementsKind(from_kind)) {
  CSA_DCHECK(this, IsFixedDoubleArrayMap(source_map))((void)0);
  var_target_map = FixedArrayMapConstant();
  Goto(&new_space_handler);
} else {
  CSA_DCHECK(this, Word32BinaryNot(IsFixedDoubleArrayMap(source_map)))((void)0);
  Branch(TaggedEqual(var_target_map.value(), FixedCOWArrayMapConstant()),
         &is_cow, &new_space_handler);

  BIND(&is_cow)Bind(&is_cow);
  {
    // |source| is a COW array, so we don't actually need to allocate a new
    // array unless:
    // 1) |extract_flags| forces us to, or
    // 2) we're asked to extract only part of the |source| (|first| != 0).
    if (extract_flags & ExtractFixedArrayFlag::kDontCopyCOW) {
      Branch(IntPtrOrSmiNotEqual(IntPtrOrSmiConstant<TIndex>(0), first),
             &new_space_handler, [&] {
               var_result = source;
               Goto(&done);
             });
    } else {
      var_target_map = FixedArrayMapConstant();
      Goto(&new_space_handler);
    }
  }
}

BIND(&new_space_handler)Bind(&new_space_handler);
{
  Comment("Copy FixedArray in young generation");
  // We use PACKED_ELEMENTS to tell AllocateFixedArray and
  // CopyFixedArrayElements that we want a FixedArray.
  const ElementsKind to_kind = PACKED_ELEMENTS;
  TNode<FixedArrayBase> to_elements = AllocateFixedArray(
      to_kind, capacity, allocation_flags, var_target_map.value());
  var_result = to_elements;

4421#ifndef V8_ENABLE_SINGLE_GENERATION
4422#ifdef DEBUG
  TNode<IntPtrT> object_word = BitcastTaggedToWord(to_elements);
  TNode<IntPtrT> object_page = PageFromAddress(object_word);
  TNode<IntPtrT> page_flags =
      Load<IntPtrT>(object_page, IntPtrConstant(Page::kFlagsOffset));
  CSA_DCHECK(((void)0)
      this,((void)0)
      WordNotEqual(((void)0)
          WordAnd(page_flags,((void)0)
                  IntPtrConstant(MemoryChunk::kIsInYoungGenerationMask)),((void)0)
          IntPtrConstant(0)))((void)0);
4433#endif
4434#endif

  if (convert_holes == HoleConversionMode::kDontConvert &&
      !IsDoubleElementsKind(from_kind)) {
    // We can use CopyElements (memcpy) because we don't need to replace or
    // convert any values. Since {to_elements} is in new-space, CopyElements
    // will efficiently use memcpy.
    FillFixedArrayWithValue(to_kind, to_elements, count, capacity,
                            RootIndex::kTheHoleValue);
    CopyElements(to_kind, to_elements, IntPtrConstant(0), source,
                 ParameterToIntPtr(first), ParameterToIntPtr(count),
                 SKIP_WRITE_BARRIER);
  } else {
    CopyFixedArrayElements(from_kind, source, to_kind, to_elements, first,
                           count, capacity, SKIP_WRITE_BARRIER, convert_holes,
                           var_holes_converted);
  }
  Goto(&done);
}

BIND(&done)Bind(&done);
return UncheckedCast<FixedArray>(var_result.value());
4456}

4458template <typename TIndex>
4459TNode<FixedArrayBase> CodeStubAssembler::ExtractFixedDoubleArrayFillingHoles(
  TNode<FixedArrayBase> from_array, TNode<TIndex> first, TNode<TIndex> count,
  TNode<TIndex> capacity, TNode<Map> fixed_array_map,
  TVariable<BoolT>* var_holes_converted, AllocationFlags allocation_flags,
  ExtractFixedArrayFlags extract_flags) {
static_assert(
    std::is_same<TIndex, Smi>::value || std::is_same<TIndex, IntPtrT>::value,
    "Only Smi or IntPtrT first, count, and capacity are allowed");

DCHECK_NE(var_holes_converted, nullptr)((void) 0);
CSA_DCHECK(this, IsFixedDoubleArrayMap(fixed_array_map))((void)0);

TVARIABLE(FixedArrayBase, var_result)TVariable<FixedArrayBase> var_result(this);
const ElementsKind kind = PACKED_DOUBLE_ELEMENTS;
TNode<FixedArrayBase> to_elements =
    AllocateFixedArray(kind, capacity, allocation_flags, fixed_array_map);
var_result = to_elements;
// We first try to copy the FixedDoubleArray to a new FixedDoubleArray.
// |var_holes_converted| is set to False preliminarily.
*var_holes_converted = Int32FalseConstant();

// The construction of the loop and the offsets for double elements is
// extracted from CopyFixedArrayElements.
CSA_SLOW_DCHECK(this, IsFixedArrayWithKindOrEmpty(from_array, kind))((void)0);
STATIC_ASSERT(FixedArray::kHeaderSize == FixedDoubleArray::kHeaderSize)static_assert(FixedArray::kHeaderSize == FixedDoubleArray::kHeaderSize
, "FixedArray::kHeaderSize == FixedDoubleArray::kHeaderSize");

Comment("[ ExtractFixedDoubleArrayFillingHoles");

// This copy can trigger GC, so we pre-initialize the array with holes.
FillFixedArrayWithValue(kind, to_elements, IntPtrOrSmiConstant<TIndex>(0),
                        capacity, RootIndex::kTheHoleValue);

const int first_element_offset = FixedArray::kHeaderSize - kHeapObjectTag;
TNode<IntPtrT> first_from_element_offset =
    ElementOffsetFromIndex(first, kind, 0);
TNode<IntPtrT> limit_offset = IntPtrAdd(first_from_element_offset,
                                        IntPtrConstant(first_element_offset));
TVARIABLE(IntPtrT, var_from_offset,TVariable<IntPtrT> var_from_offset(ElementOffsetFromIndex
(IntPtrOrSmiAdd(first, count), kind, first_element_offset), this
)
          ElementOffsetFromIndex(IntPtrOrSmiAdd(first, count), kind,TVariable<IntPtrT> var_from_offset(ElementOffsetFromIndex
(IntPtrOrSmiAdd(first, count), kind, first_element_offset), this
)
                                 first_element_offset))TVariable<IntPtrT> var_from_offset(ElementOffsetFromIndex
(IntPtrOrSmiAdd(first, count), kind, first_element_offset), this
);

Label decrement(this, {&var_from_offset}), done(this);
TNode<IntPtrT> to_array_adjusted =
    IntPtrSub(BitcastTaggedToWord(to_elements), first_from_element_offset);

Branch(WordEqual(var_from_offset.value(), limit_offset), &done, &decrement);

BIND(&decrement)Bind(&decrement);
{
  TNode<IntPtrT> from_offset =
      IntPtrSub(var_from_offset.value(), IntPtrConstant(kDoubleSize));
  var_from_offset = from_offset;

  TNode<IntPtrT> to_offset = from_offset;

  Label if_hole(this);

  TNode<Float64T> value = LoadDoubleWithHoleCheck(
      from_array, var_from_offset.value(), &if_hole, MachineType::Float64());

  StoreNoWriteBarrier(MachineRepresentation::kFloat64, to_array_adjusted,
                      to_offset, value);

  TNode<BoolT> compare = WordNotEqual(from_offset, limit_offset);
  Branch(compare, &decrement, &done);

  BIND(&if_hole)Bind(&if_hole);
  // We are unlucky: there are holes! We need to restart the copy, this time
  // we will copy the FixedDoubleArray to a new FixedArray with undefined
  // replacing holes. We signal this to the caller through
  // |var_holes_converted|.
  *var_holes_converted = Int32TrueConstant();
  to_elements =
      ExtractToFixedArray(from_array, first, count, capacity, fixed_array_map,
                          kind, allocation_flags, extract_flags,
                          HoleConversionMode::kConvertToUndefined);
  var_result = to_elements;
  Goto(&done);
}

BIND(&done)Bind(&done);
Comment("] ExtractFixedDoubleArrayFillingHoles");
return var_result.value();
4542}

4544template <typename TIndex>
4545TNode<FixedArrayBase> CodeStubAssembler::ExtractFixedArray(
  TNode<FixedArrayBase> source, base::Optional<TNode<TIndex>> first,
  base::Optional<TNode<TIndex>> count, base::Optional<TNode<TIndex>> capacity,
  ExtractFixedArrayFlags extract_flags, TVariable<BoolT>* var_holes_converted,
  base::Optional<TNode<Int32T>> source_elements_kind) {
static_assert(
    std::is_same<TIndex, Smi>::value || std::is_same<TIndex, IntPtrT>::value,
    "Only Smi or IntPtrT first, count, and capacity are allowed");
DCHECK(extract_flags & ExtractFixedArrayFlag::kFixedArrays ||((void) 0)
       extract_flags & ExtractFixedArrayFlag::kFixedDoubleArrays)((void) 0);
// If we want to replace holes, ExtractFixedArrayFlag::kDontCopyCOW should
// not be used, because that disables the iteration which detects holes.
DCHECK_IMPLIES(var_holes_converted != nullptr,((void) 0)
               !(extract_flags & ExtractFixedArrayFlag::kDontCopyCOW))((void) 0);
HoleConversionMode convert_holes =
    var_holes_converted != nullptr ? HoleConversionMode::kConvertToUndefined
                                   : HoleConversionMode::kDontConvert;
TVARIABLE(FixedArrayBase, var_result)TVariable<FixedArrayBase> var_result(this);
auto allocation_flags = AllocationFlag::kAllowLargeObjectAllocation;
if (!first) {
  first = IntPtrOrSmiConstant<TIndex>(0);
}
if (!count) {
  count = IntPtrOrSmiSub(
      TaggedToParameter<TIndex>(LoadFixedArrayBaseLength(source)), *first);

  CSA_DCHECK(this, IntPtrOrSmiLessThanOrEqual(IntPtrOrSmiConstant<TIndex>(0),((void)0)
                                              *count))((void)0);
}
if (!capacity) {
  capacity = *count;
} else {
  CSA_DCHECK(this, Word32BinaryNot(IntPtrOrSmiGreaterThan(((void)0)
                       IntPtrOrSmiAdd(*first, *count), *capacity)))((void)0);
}

Label if_fixed_double_array(this), empty(this), done(this, &var_result);
TNode<Map> source_map = LoadMap(source);
GotoIf(IntPtrOrSmiEqual(IntPtrOrSmiConstant<TIndex>(0), *capacity), &empty);

if (extract_flags & ExtractFixedArrayFlag::kFixedDoubleArrays) {
  if (extract_flags & ExtractFixedArrayFlag::kFixedArrays) {
    GotoIf(IsFixedDoubleArrayMap(source_map), &if_fixed_double_array);
  } else {
    CSA_DCHECK(this, IsFixedDoubleArrayMap(source_map))((void)0);
  }
}

if (extract_flags & ExtractFixedArrayFlag::kFixedArrays) {
  // Here we can only get |source| as FixedArray, never FixedDoubleArray.
  // PACKED_ELEMENTS is used to signify that the source is a FixedArray.
  TNode<FixedArray> to_elements = ExtractToFixedArray(
      source, *first, *count, *capacity, source_map, PACKED_ELEMENTS,
      allocation_flags, extract_flags, convert_holes, var_holes_converted,
      source_elements_kind);
  var_result = to_elements;
  Goto(&done);
}

if (extract_flags & ExtractFixedArrayFlag::kFixedDoubleArrays) {
  BIND(&if_fixed_double_array)Bind(&if_fixed_double_array);
  Comment("Copy FixedDoubleArray");

  if (convert_holes == HoleConversionMode::kConvertToUndefined) {
    TNode<FixedArrayBase> to_elements = ExtractFixedDoubleArrayFillingHoles(
        source, *first, *count, *capacity, source_map, var_holes_converted,
        allocation_flags, extract_flags);
    var_result = to_elements;
  } else {
    // We use PACKED_DOUBLE_ELEMENTS to signify that both the source and
    // the target are FixedDoubleArray. That it is PACKED or HOLEY does not
    // matter.
    ElementsKind kind = PACKED_DOUBLE_ELEMENTS;
    TNode<FixedArrayBase> to_elements =
        AllocateFixedArray(kind, *capacity, allocation_flags, source_map);
    FillFixedArrayWithValue(kind, to_elements, *count, *capacity,
                            RootIndex::kTheHoleValue);
    CopyElements(kind, to_elements, IntPtrConstant(0), source,
                 ParameterToIntPtr(*first), ParameterToIntPtr(*count));
    var_result = to_elements;
  }

  Goto(&done);
}

BIND(&empty)Bind(&empty);
{
  Comment("Copy empty array");

  var_result = EmptyFixedArrayConstant();
  Goto(&done);
}

BIND(&done)Bind(&done);
return var_result.value();
4640}

4642template V8_EXPORT_PRIVATE TNode<FixedArrayBase>
4643CodeStubAssembler::ExtractFixedArray<Smi>(
  TNode<FixedArrayBase>, base::Optional<TNode<Smi>>,
  base::Optional<TNode<Smi>>, base::Optional<TNode<Smi>>,
  ExtractFixedArrayFlags, TVariable<BoolT>*, base::Optional<TNode<Int32T>>);

4648template V8_EXPORT_PRIVATE TNode<FixedArrayBase>
4649CodeStubAssembler::ExtractFixedArray<IntPtrT>(
  TNode<FixedArrayBase>, base::Optional<TNode<IntPtrT>>,
  base::Optional<TNode<IntPtrT>>, base::Optional<TNode<IntPtrT>>,
  ExtractFixedArrayFlags, TVariable<BoolT>*, base::Optional<TNode<Int32T>>);

4654void CodeStubAssembler::InitializePropertyArrayLength(
  TNode<PropertyArray> property_array, TNode<IntPtrT> length) {
CSA_DCHECK(this, IntPtrGreaterThan(length, IntPtrConstant(0)))((void)0);
CSA_DCHECK(this,((void)0)
           IntPtrLessThanOrEqual(((void)0)
               length, IntPtrConstant(PropertyArray::LengthField::kMax)))((void)0);
StoreObjectFieldNoWriteBarrier(
    property_array, PropertyArray::kLengthAndHashOffset, SmiTag(length));
4662}

4664TNode<PropertyArray> CodeStubAssembler::AllocatePropertyArray(
  TNode<IntPtrT> capacity) {
CSA_DCHECK(this, IntPtrGreaterThan(capacity, IntPtrConstant(0)))((void)0);
TNode<IntPtrT> total_size = GetPropertyArrayAllocationSize(capacity);

TNode<HeapObject> array = Allocate(total_size, AllocationFlag::kNone);
RootIndex map_index = RootIndex::kPropertyArrayMap;
DCHECK(RootsTable::IsImmortalImmovable(map_index))((void) 0);
StoreMapNoWriteBarrier(array, map_index);
TNode<PropertyArray> property_array = CAST(array)Cast(array);
InitializePropertyArrayLength(property_array, capacity);
return property_array;
4676}

4678void CodeStubAssembler::FillPropertyArrayWithUndefined(
  TNode<PropertyArray> array, TNode<IntPtrT> from_index,
  TNode<IntPtrT> to_index) {
ElementsKind kind = PACKED_ELEMENTS;
TNode<Oddball> value = UndefinedConstant();
BuildFastArrayForEach(
    array, kind, from_index, to_index,
    [this, value](TNode<HeapObject> array, TNode<IntPtrT> offset) {
      StoreNoWriteBarrier(MachineRepresentation::kTagged, array, offset,
                          value);
    });
4689}

4691template <typename TIndex>
4692void CodeStubAssembler::FillFixedArrayWithValue(ElementsKind kind,
                                              TNode<FixedArrayBase> array,
                                              TNode<TIndex> from_index,
                                              TNode<TIndex> to_index,
                                              RootIndex value_root_index) {
static_assert(
    std::is_same<TIndex, Smi>::value || std::is_same<TIndex, IntPtrT>::value,
    "Only Smi or IntPtrT from and to are allowed");
CSA_SLOW_DCHECK(this, IsFixedArrayWithKind(array, kind))((void)0);
DCHECK(value_root_index == RootIndex::kTheHoleValue ||((void) 0)
       value_root_index == RootIndex::kUndefinedValue)((void) 0);

// Determine the value to initialize the {array} based
// on the {value_root_index} and the elements {kind}.
TNode<Object> value = LoadRoot(value_root_index);
TNode<Float64T> float_value;
if (IsDoubleElementsKind(kind)) {
  float_value = LoadHeapNumberValue(CAST(value)Cast(value));
}

BuildFastArrayForEach(
    array, kind, from_index, to_index,
    [this, value, float_value, kind](TNode<HeapObject> array,
                                     TNode<IntPtrT> offset) {
      if (IsDoubleElementsKind(kind)) {
        StoreNoWriteBarrier(MachineRepresentation::kFloat64, array, offset,
                            float_value);
      } else {
        StoreNoWriteBarrier(MachineRepresentation::kTagged, array, offset,
                            value);
      }
    });
4724}

4726template V8_EXPORT_PRIVATE void
  CodeStubAssembler::FillFixedArrayWithValue<IntPtrT>(ElementsKind,
                                                      TNode<FixedArrayBase>,
                                                      TNode<IntPtrT>,
                                                      TNode<IntPtrT>,
                                                      RootIndex);
4732template V8_EXPORT_PRIVATE void CodeStubAssembler::FillFixedArrayWithValue<Smi>(
  ElementsKind, TNode<FixedArrayBase>, TNode<Smi>, TNode<Smi>, RootIndex);

4735void CodeStubAssembler::StoreDoubleHole(TNode<HeapObject> object,
                                      TNode<IntPtrT> offset) {
TNode<UintPtrT> double_hole =
    Is64() ? ReinterpretCast<UintPtrT>(Int64Constant(kHoleNanInt64))
           : ReinterpretCast<UintPtrT>(Int32Constant(kHoleNanLower32));
// TODO(danno): When we have a Float32/Float64 wrapper class that
// preserves double bits during manipulation, remove this code/change
// this to an indexed Float64 store.
if (Is64()) {
  StoreNoWriteBarrier(MachineRepresentation::kWord64, object, offset,
                      double_hole);
} else {
  StoreNoWriteBarrier(MachineRepresentation::kWord32, object, offset,
                      double_hole);
  StoreNoWriteBarrier(MachineRepresentation::kWord32, object,
                      IntPtrAdd(offset, IntPtrConstant(kInt32Size)),
                      double_hole);
}
4753}

4755void CodeStubAssembler::StoreFixedDoubleArrayHole(TNode<FixedDoubleArray> array,
                                                TNode<IntPtrT> index) {
TNode<IntPtrT> offset = ElementOffsetFromIndex(
    index, PACKED_DOUBLE_ELEMENTS, FixedArray::kHeaderSize - kHeapObjectTag);
CSA_DCHECK(this, IsOffsetInBounds(((void)0)
                     offset, LoadAndUntagFixedArrayBaseLength(array),((void)0)
                     FixedDoubleArray::kHeaderSize, PACKED_DOUBLE_ELEMENTS))((void)0);
StoreDoubleHole(array, offset);
4763}

4765void CodeStubAssembler::FillFixedArrayWithSmiZero(TNode<FixedArray> array,
                                                TNode<IntPtrT> length) {
CSA_DCHECK(this, WordEqual(length, LoadAndUntagFixedArrayBaseLength(array)))((void)0);

TNode<IntPtrT> byte_length = TimesTaggedSize(length);
CSA_DCHECK(this, UintPtrLessThan(length, byte_length))((void)0);

static const int32_t fa_base_data_offset =
    FixedArray::kHeaderSize - kHeapObjectTag;
TNode<IntPtrT> backing_store = IntPtrAdd(BitcastTaggedToWord(array),
                                         IntPtrConstant(fa_base_data_offset));

// Call out to memset to perform initialization.
TNode<ExternalReference> memset =
    ExternalConstant(ExternalReference::libc_memset_function());
STATIC_ASSERT(kSizetSize == kIntptrSize)static_assert(kSizetSize == kIntptrSize, "kSizetSize == kIntptrSize"
);
CallCFunction(memset, MachineType::Pointer(),
              std::make_pair(MachineType::Pointer(), backing_store),
              std::make_pair(MachineType::IntPtr(), IntPtrConstant(0)),
              std::make_pair(MachineType::UintPtr(), byte_length));
4785}

4787void CodeStubAssembler::FillFixedDoubleArrayWithZero(
  TNode<FixedDoubleArray> array, TNode<IntPtrT> length) {
CSA_DCHECK(this, WordEqual(length, LoadAndUntagFixedArrayBaseLength(array)))((void)0);

TNode<IntPtrT> byte_length = TimesDoubleSize(length);
CSA_DCHECK(this, UintPtrLessThan(length, byte_length))((void)0);

static const int32_t fa_base_data_offset =
    FixedDoubleArray::kHeaderSize - kHeapObjectTag;
TNode<IntPtrT> backing_store = IntPtrAdd(BitcastTaggedToWord(array),
                                         IntPtrConstant(fa_base_data_offset));

// Call out to memset to perform initialization.
TNode<ExternalReference> memset =
    ExternalConstant(ExternalReference::libc_memset_function());
STATIC_ASSERT(kSizetSize == kIntptrSize)static_assert(kSizetSize == kIntptrSize, "kSizetSize == kIntptrSize"
);
CallCFunction(memset, MachineType::Pointer(),
              std::make_pair(MachineType::Pointer(), backing_store),
              std::make_pair(MachineType::IntPtr(), IntPtrConstant(0)),
              std::make_pair(MachineType::UintPtr(), byte_length));
4807}

4809void CodeStubAssembler::JumpIfPointersFromHereAreInteresting(
  TNode<Object> object, Label* interesting) {
Label finished(this);
TNode<IntPtrT> object_word = BitcastTaggedToWord(object);
TNode<IntPtrT> object_page = PageFromAddress(object_word);
TNode<IntPtrT> page_flags = UncheckedCast<IntPtrT>(Load(
    MachineType::IntPtr(), object_page, IntPtrConstant(Page::kFlagsOffset)));
Branch(
    WordEqual(WordAnd(page_flags,
                      IntPtrConstant(
                          MemoryChunk::kPointersFromHereAreInterestingMask)),
              IntPtrConstant(0)),
    &finished, interesting);
BIND(&finished)Bind(&finished);
4823}

4825void CodeStubAssembler::MoveElements(ElementsKind kind,
                                   TNode<FixedArrayBase> elements,
                                   TNode<IntPtrT> dst_index,
                                   TNode<IntPtrT> src_index,
                                   TNode<IntPtrT> length) {
Label finished(this);
Label needs_barrier(this);
4832#ifdef V8_DISABLE_WRITE_BARRIERS
const bool needs_barrier_check = false;
4834#else
const bool needs_barrier_check = !IsDoubleElementsKind(kind);
4836#endif  // V8_DISABLE_WRITE_BARRIERS

DCHECK(IsFastElementsKind(kind))((void) 0);
CSA_DCHECK(this, IsFixedArrayWithKind(elements, kind))((void)0);
CSA_DCHECK(this,((void)0)
           IntPtrLessThanOrEqual(IntPtrAdd(dst_index, length),((void)0)
                                 LoadAndUntagFixedArrayBaseLength(elements)))((void)0);
CSA_DCHECK(this,((void)0)
           IntPtrLessThanOrEqual(IntPtrAdd(src_index, length),((void)0)
                                 LoadAndUntagFixedArrayBaseLength(elements)))((void)0);

// The write barrier can be ignored if {dst_elements} is in new space, or if
// the elements pointer is FixedDoubleArray.
if (needs_barrier_check) {
  JumpIfPointersFromHereAreInteresting(elements, &needs_barrier);
}

const TNode<IntPtrT> source_byte_length =
    IntPtrMul(length, IntPtrConstant(ElementsKindToByteSize(kind)));
static const int32_t fa_base_data_offset =
    FixedArrayBase::kHeaderSize - kHeapObjectTag;
TNode<IntPtrT> elements_intptr = BitcastTaggedToWord(elements);
TNode<IntPtrT> target_data_ptr =
    IntPtrAdd(elements_intptr,
              ElementOffsetFromIndex(dst_index, kind, fa_base_data_offset));
TNode<IntPtrT> source_data_ptr =
    IntPtrAdd(elements_intptr,
              ElementOffsetFromIndex(src_index, kind, fa_base_data_offset));
TNode<ExternalReference> memmove =
    ExternalConstant(ExternalReference::libc_memmove_function());
CallCFunction(memmove, MachineType::Pointer(),
              std::make_pair(MachineType::Pointer(), target_data_ptr),
              std::make_pair(MachineType::Pointer(), source_data_ptr),
              std::make_pair(MachineType::UintPtr(), source_byte_length));

if (needs_barrier_check) {
  Goto(&finished);

  BIND(&needs_barrier)Bind(&needs_barrier);
  {
    const TNode<IntPtrT> begin = src_index;
    const TNode<IntPtrT> end = IntPtrAdd(begin, length);

    // If dst_index is less than src_index, then walk forward.
    const TNode<IntPtrT> delta =
        IntPtrMul(IntPtrSub(dst_index, begin),
                  IntPtrConstant(ElementsKindToByteSize(kind)));
    auto loop_body = [&](TNode<HeapObject> array, TNode<IntPtrT> offset) {
      const TNode<AnyTaggedT> element = Load<AnyTaggedT>(array, offset);
      const TNode<WordT> delta_offset = IntPtrAdd(offset, delta);
      Store(array, delta_offset, element);
    };

    Label iterate_forward(this);
    Label iterate_backward(this);
    Branch(IntPtrLessThan(delta, IntPtrConstant(0)), &iterate_forward,
           &iterate_backward);
    BIND(&iterate_forward)Bind(&iterate_forward);
    {
      // Make a loop for the stores.
      BuildFastArrayForEach(elements, kind, begin, end, loop_body,
                            ForEachDirection::kForward);
      Goto(&finished);
    }

    BIND(&iterate_backward)Bind(&iterate_backward);
    {
      BuildFastArrayForEach(elements, kind, begin, end, loop_body,
                            ForEachDirection::kReverse);
      Goto(&finished);
    }
  }
  BIND(&finished)Bind(&finished);
}
4910}

4912void CodeStubAssembler::CopyElements(ElementsKind kind,
                                   TNode<FixedArrayBase> dst_elements,
                                   TNode<IntPtrT> dst_index,
                                   TNode<FixedArrayBase> src_elements,
                                   TNode<IntPtrT> src_index,
                                   TNode<IntPtrT> length,
                                   WriteBarrierMode write_barrier) {
Label finished(this);
Label needs_barrier(this);
4921#ifdef V8_DISABLE_WRITE_BARRIERS
const bool needs_barrier_check = false;
4923#else
const bool needs_barrier_check = !IsDoubleElementsKind(kind);
4925#endif  // V8_DISABLE_WRITE_BARRIERS

DCHECK(IsFastElementsKind(kind))((void) 0);
CSA_DCHECK(this, IsFixedArrayWithKind(dst_elements, kind))((void)0);
CSA_DCHECK(this, IsFixedArrayWithKind(src_elements, kind))((void)0);
CSA_DCHECK(this, IntPtrLessThanOrEqual(((void)0)
                     IntPtrAdd(dst_index, length),((void)0)
                     LoadAndUntagFixedArrayBaseLength(dst_elements)))((void)0);
CSA_DCHECK(this, IntPtrLessThanOrEqual(((void)0)
                     IntPtrAdd(src_index, length),((void)0)
                     LoadAndUntagFixedArrayBaseLength(src_elements)))((void)0);
CSA_DCHECK(this, Word32Or(TaggedNotEqual(dst_elements, src_elements),((void)0)
                          IntPtrEqual(length, IntPtrConstant(0))))((void)0);

// The write barrier can be ignored if {dst_elements} is in new space, or if
// the elements pointer is FixedDoubleArray.
if (needs_barrier_check) {
  JumpIfPointersFromHereAreInteresting(dst_elements, &needs_barrier);
}

TNode<IntPtrT> source_byte_length =
    IntPtrMul(length, IntPtrConstant(ElementsKindToByteSize(kind)));
static const int32_t fa_base_data_offset =
    FixedArrayBase::kHeaderSize - kHeapObjectTag;
TNode<IntPtrT> src_offset_start =
    ElementOffsetFromIndex(src_index, kind, fa_base_data_offset);
TNode<IntPtrT> dst_offset_start =
    ElementOffsetFromIndex(dst_index, kind, fa_base_data_offset);
TNode<IntPtrT> src_elements_intptr = BitcastTaggedToWord(src_elements);
TNode<IntPtrT> source_data_ptr =
    IntPtrAdd(src_elements_intptr, src_offset_start);
TNode<IntPtrT> dst_elements_intptr = BitcastTaggedToWord(dst_elements);
TNode<IntPtrT> dst_data_ptr =
    IntPtrAdd(dst_elements_intptr, dst_offset_start);
TNode<ExternalReference> memcpy =
    ExternalConstant(ExternalReference::libc_memcpy_function());
CallCFunction(memcpy, MachineType::Pointer(),
              std::make_pair(MachineType::Pointer(), dst_data_ptr),
              std::make_pair(MachineType::Pointer(), source_data_ptr),
              std::make_pair(MachineType::UintPtr(), source_byte_length));

if (needs_barrier_check) {
  Goto(&finished);

  BIND(&needs_barrier)Bind(&needs_barrier);
  {
    const TNode<IntPtrT> begin = src_index;
    const TNode<IntPtrT> end = IntPtrAdd(begin, length);
    const TNode<IntPtrT> delta =
        IntPtrMul(IntPtrSub(dst_index, src_index),
                  IntPtrConstant(ElementsKindToByteSize(kind)));
    BuildFastArrayForEach(
        src_elements, kind, begin, end,
        [&](TNode<HeapObject> array, TNode<IntPtrT> offset) {
          const TNode<AnyTaggedT> element = Load<AnyTaggedT>(array, offset);
          const TNode<WordT> delta_offset = IntPtrAdd(offset, delta);
          if (write_barrier == SKIP_WRITE_BARRIER) {
            StoreNoWriteBarrier(MachineRepresentation::kTagged, dst_elements,
                                delta_offset, element);
          } else {
            Store(dst_elements, delta_offset, element);
          }
        },
        ForEachDirection::kForward);
    Goto(&finished);
  }
  BIND(&finished)Bind(&finished);
}
4993}

4995template <typename TIndex>
4996void CodeStubAssembler::CopyFixedArrayElements(
  ElementsKind from_kind, TNode<FixedArrayBase> from_array,
  ElementsKind to_kind, TNode<FixedArrayBase> to_array,
  TNode<TIndex> first_element, TNode<TIndex> element_count,
  TNode<TIndex> capacity, WriteBarrierMode barrier_mode,
  HoleConversionMode convert_holes, TVariable<BoolT>* var_holes_converted) {
DCHECK_IMPLIES(var_holes_converted != nullptr,((void) 0)
               convert_holes == HoleConversionMode::kConvertToUndefined)((void) 0);
CSA_SLOW_DCHECK(this, IsFixedArrayWithKindOrEmpty(from_array, from_kind))((void)0);
CSA_SLOW_DCHECK(this, IsFixedArrayWithKindOrEmpty(to_array, to_kind))((void)0);
STATIC_ASSERT(FixedArray::kHeaderSize == FixedDoubleArray::kHeaderSize)static_assert(FixedArray::kHeaderSize == FixedDoubleArray::kHeaderSize
, "FixedArray::kHeaderSize == FixedDoubleArray::kHeaderSize");
static_assert(
    std::is_same<TIndex, Smi>::value || std::is_same<TIndex, IntPtrT>::value,
    "Only Smi or IntPtrT indices are allowed");

const int first_element_offset = FixedArray::kHeaderSize - kHeapObjectTag;
Comment("[ CopyFixedArrayElements");

// Typed array elements are not supported.
DCHECK(!IsTypedArrayElementsKind(from_kind))((void) 0);
DCHECK(!IsTypedArrayElementsKind(to_kind))((void) 0);

Label done(this);
bool from_double_elements = IsDoubleElementsKind(from_kind);
bool to_double_elements = IsDoubleElementsKind(to_kind);
bool doubles_to_objects_conversion =
    IsDoubleElementsKind(from_kind) && IsObjectElementsKind(to_kind);
bool needs_write_barrier =
    doubles_to_objects_conversion ||
    (barrier_mode == UPDATE_WRITE_BARRIER && IsObjectElementsKind(to_kind));
bool element_offset_matches =
    !needs_write_barrier &&
    (kTaggedSize == kDoubleSize ||
     IsDoubleElementsKind(from_kind) == IsDoubleElementsKind(to_kind));
TNode<UintPtrT> double_hole =
    Is64() ? ReinterpretCast<UintPtrT>(Int64Constant(kHoleNanInt64))
           : ReinterpretCast<UintPtrT>(Int32Constant(kHoleNanLower32));

// If copying might trigger a GC, we pre-initialize the FixedArray such that
// it's always in a consistent state.
if (convert_holes == HoleConversionMode::kConvertToUndefined) {
  DCHECK(IsObjectElementsKind(to_kind))((void) 0);
  // Use undefined for the part that we copy and holes for the rest.
  // Later if we run into a hole in the source we can just skip the writing
  // to the target and are still guaranteed that we get an undefined.
  FillFixedArrayWithValue(to_kind, to_array, IntPtrOrSmiConstant<TIndex>(0),
                          element_count, RootIndex::kUndefinedValue);
  FillFixedArrayWithValue(to_kind, to_array, element_count, capacity,
                          RootIndex::kTheHoleValue);
} else if (doubles_to_objects_conversion) {
  // Pre-initialized the target with holes so later if we run into a hole in
  // the source we can just skip the writing to the target.
  FillFixedArrayWithValue(to_kind, to_array, IntPtrOrSmiConstant<TIndex>(0),
                          capacity, RootIndex::kTheHoleValue);
} else if (element_count != capacity) {
  FillFixedArrayWithValue(to_kind, to_array, element_count, capacity,
                          RootIndex::kTheHoleValue);
}

TNode<IntPtrT> first_from_element_offset =
    ElementOffsetFromIndex(first_element, from_kind, 0);
TNode<IntPtrT> limit_offset = Signed(IntPtrAdd(
    first_from_element_offset, IntPtrConstant(first_element_offset)));
TVARIABLE(IntPtrT, var_from_offset,TVariable<IntPtrT> var_from_offset(ElementOffsetFromIndex
(IntPtrOrSmiAdd(first_element, element_count), from_kind, first_element_offset
), this)
          ElementOffsetFromIndex(IntPtrOrSmiAdd(first_element, element_count),TVariable<IntPtrT> var_from_offset(ElementOffsetFromIndex
(IntPtrOrSmiAdd(first_element, element_count), from_kind, first_element_offset
), this)
                                 from_kind, first_element_offset))TVariable<IntPtrT> var_from_offset(ElementOffsetFromIndex
(IntPtrOrSmiAdd(first_element, element_count), from_kind, first_element_offset
), this);
// This second variable is used only when the element sizes of source and
// destination arrays do not match.
TVARIABLE(IntPtrT, var_to_offset)TVariable<IntPtrT> var_to_offset(this);
if (element_offset_matches) {
  var_to_offset = var_from_offset.value();
} else {
  var_to_offset =
      ElementOffsetFromIndex(element_count, to_kind, first_element_offset);
}

VariableList vars({&var_from_offset, &var_to_offset}, zone());
if (var_holes_converted != nullptr) vars.push_back(var_holes_converted);
Label decrement(this, vars);

TNode<IntPtrT> to_array_adjusted =
    element_offset_matches
        ? IntPtrSub(BitcastTaggedToWord(to_array), first_from_element_offset)
        : ReinterpretCast<IntPtrT>(to_array);

Branch(WordEqual(var_from_offset.value(), limit_offset), &done, &decrement);

BIND(&decrement)Bind(&decrement);
{
  TNode<IntPtrT> from_offset = Signed(IntPtrSub(
      var_from_offset.value(),
      IntPtrConstant(from_double_elements ? kDoubleSize : kTaggedSize)));
  var_from_offset = from_offset;

  TNode<IntPtrT> to_offset;
  if (element_offset_matches) {
    to_offset = from_offset;
  } else {
    to_offset = IntPtrSub(
        var_to_offset.value(),
        IntPtrConstant(to_double_elements ? kDoubleSize : kTaggedSize));
    var_to_offset = to_offset;
  }

  Label next_iter(this), store_double_hole(this), signal_hole(this);
  Label* if_hole;
  if (convert_holes == HoleConversionMode::kConvertToUndefined) {
    // The target elements array is already preinitialized with undefined
    // so we only need to signal that a hole was found and continue the loop.
    if_hole = &signal_hole;
  } else if (doubles_to_objects_conversion) {
    // The target elements array is already preinitialized with holes, so we
    // can just proceed with the next iteration.
    if_hole = &next_iter;
  } else if (IsDoubleElementsKind(to_kind)) {
    if_hole = &store_double_hole;
  } else {
    // In all the other cases don't check for holes and copy the data as is.
    if_hole = nullptr;
  }

  if (to_double_elements) {
    DCHECK(!needs_write_barrier)((void) 0);
    TNode<Float64T> value = LoadElementAndPrepareForStore<Float64T>(
        from_array, var_from_offset.value(), from_kind, to_kind, if_hole);
    StoreNoWriteBarrier(MachineRepresentation::kFloat64, to_array_adjusted,
                        to_offset, value);
  } else {
    TNode<Object> value = LoadElementAndPrepareForStore<Object>(
        from_array, var_from_offset.value(), from_kind, to_kind, if_hole);
    if (needs_write_barrier) {
      CHECK_EQ(to_array, to_array_adjusted)do { bool _cmp = ::v8::base::CmpEQImpl< typename ::v8::base
::pass_value_or_ref<decltype(to_array)>::type, typename
 ::v8::base::pass_value_or_ref<decltype(to_array_adjusted)
>::type>((to_array), (to_array_adjusted)); do { if ((__builtin_expect
(!!(!(_cmp)), 0))) { V8_Fatal("Check failed: %s.", "to_array"
 " " "==" " " "to_array_adjusted"); } } while (false); } while
 (false);
      Store(to_array_adjusted, to_offset, value);
    } else {
      UnsafeStoreNoWriteBarrier(MachineRepresentation::kTagged,
                                to_array_adjusted, to_offset, value);
    }
  }

  Goto(&next_iter);

  if (if_hole == &store_double_hole) {
    BIND(&store_double_hole)Bind(&store_double_hole);
    // Don't use doubles to store the hole double, since manipulating the
    // signaling NaN used for the hole in C++, e.g. with bit_cast, will
    // change its value on ia32 (the x87 stack is used to return values
    // and stores to the stack silently clear the signalling bit).
    //
    // TODO(danno): When we have a Float32/Float64 wrapper class that
    // preserves double bits during manipulation, remove this code/change
    // this to an indexed Float64 store.
    if (Is64()) {
      StoreNoWriteBarrier(MachineRepresentation::kWord64, to_array_adjusted,
                          to_offset, double_hole);
    } else {
      StoreNoWriteBarrier(MachineRepresentation::kWord32, to_array_adjusted,
                          to_offset, double_hole);
      StoreNoWriteBarrier(MachineRepresentation::kWord32, to_array_adjusted,
                          IntPtrAdd(to_offset, IntPtrConstant(kInt32Size)),
                          double_hole);
    }
    Goto(&next_iter);
  } else if (if_hole == &signal_hole) {
    // This case happens only when IsObjectElementsKind(to_kind).
    BIND(&signal_hole)Bind(&signal_hole);
    if (var_holes_converted != nullptr) {
      *var_holes_converted = Int32TrueConstant();
    }
    Goto(&next_iter);
  }

  BIND(&next_iter)Bind(&next_iter);
  TNode<BoolT> compare = WordNotEqual(from_offset, limit_offset);
  Branch(compare, &decrement, &done);
}

BIND(&done)Bind(&done);
Comment("] CopyFixedArrayElements");
5174}

5176TNode<FixedArray> CodeStubAssembler::HeapObjectToFixedArray(
  TNode<HeapObject> base, Label* cast_fail) {
Label fixed_array(this);
TNode<Map> map = LoadMap(base);
GotoIf(TaggedEqual(map, FixedArrayMapConstant()), &fixed_array);
GotoIf(TaggedNotEqual(map, FixedCOWArrayMapConstant()), cast_fail);
Goto(&fixed_array);
BIND(&fixed_array)Bind(&fixed_array);
return UncheckedCast<FixedArray>(base);
5185}

5187void CodeStubAssembler::CopyPropertyArrayValues(TNode<HeapObject> from_array,
                                              TNode<PropertyArray> to_array,
                                              TNode<IntPtrT> property_count,
                                              WriteBarrierMode barrier_mode,
                                              DestroySource destroy_source) {
CSA_SLOW_DCHECK(this, Word32Or(IsPropertyArray(from_array),((void)0)
                               IsEmptyFixedArray(from_array)))((void)0);
Comment("[ CopyPropertyArrayValues");

bool needs_write_barrier = barrier_mode == UPDATE_WRITE_BARRIER;

if (destroy_source == DestroySource::kNo) {
  // PropertyArray may contain mutable HeapNumbers, which will be cloned on
  // the heap, requiring a write barrier.
  needs_write_barrier = true;
}

TNode<IntPtrT> start = IntPtrConstant(0);
ElementsKind kind = PACKED_ELEMENTS;
BuildFastArrayForEach(
    from_array, kind, start, property_count,
    [this, to_array, needs_write_barrier, destroy_source](
        TNode<HeapObject> array, TNode<IntPtrT> offset) {
      TNode<AnyTaggedT> value = Load<AnyTaggedT>(array, offset);

      if (destroy_source == DestroySource::kNo) {
        value = CloneIfMutablePrimitive(CAST(value)Cast(value));
      }

      if (needs_write_barrier) {
        Store(to_array, offset, value);
      } else {
        StoreNoWriteBarrier(MachineRepresentation::kTagged, to_array, offset,
                            value);
      }
    });

5224#ifdef DEBUG
// Zap {from_array} if the copying above has made it invalid.
if (destroy_source == DestroySource::kYes) {
  Label did_zap(this);
  GotoIf(IsEmptyFixedArray(from_array), &did_zap);
  FillPropertyArrayWithUndefined(CAST(from_array)Cast(from_array), start, property_count);

  Goto(&did_zap);
  BIND(&did_zap)Bind(&did_zap);
}
5234#endif
Comment("] CopyPropertyArrayValues");
5236}

5238TNode<FixedArrayBase> CodeStubAssembler::CloneFixedArray(
  TNode<FixedArrayBase> source, ExtractFixedArrayFlags flags) {
return ExtractFixedArray(
    source, base::Optional<TNode<BInt>>(IntPtrOrSmiConstant<BInt>(0)),
    base::Optional<TNode<BInt>>(base::nullopt),
    base::Optional<TNode<BInt>>(base::nullopt), flags);
5244}

5246template <>
5247TNode<Object> CodeStubAssembler::LoadElementAndPrepareForStore(
  TNode<FixedArrayBase> array, TNode<IntPtrT> offset, ElementsKind from_kind,
  ElementsKind to_kind, Label* if_hole) {
CSA_DCHECK(this, IsFixedArrayWithKind(array, from_kind))((void)0);
DCHECK(!IsDoubleElementsKind(to_kind))((void) 0);
if (IsDoubleElementsKind(from_kind)) {
  TNode<Float64T> value =
      LoadDoubleWithHoleCheck(array, offset, if_hole, MachineType::Float64());
  return AllocateHeapNumberWithValue(value);
} else {
  TNode<Object> value = Load<Object>(array, offset);
  if (if_hole) {
    GotoIf(TaggedEqual(value, TheHoleConstant()), if_hole);
  }
  return value;
}
5263}

5265template <>
5266TNode<Float64T> CodeStubAssembler::LoadElementAndPrepareForStore(
  TNode<FixedArrayBase> array, TNode<IntPtrT> offset, ElementsKind from_kind,
  ElementsKind to_kind, Label* if_hole) {
CSA_DCHECK(this, IsFixedArrayWithKind(array, from_kind))((void)0);
DCHECK(IsDoubleElementsKind(to_kind))((void) 0);
if (IsDoubleElementsKind(from_kind)) {
  return LoadDoubleWithHoleCheck(array, offset, if_hole,
                                 MachineType::Float64());
} else {
  TNode<Object> value = Load<Object>(array, offset);
  if (if_hole) {
    GotoIf(TaggedEqual(value, TheHoleConstant()), if_hole);
  }
  if (IsSmiElementsKind(from_kind)) {
    return SmiToFloat64(CAST(value)Cast(value));
  }
  return LoadHeapNumberValue(CAST(value)Cast(value));
}
5284}

5286template <typename TIndex>
5287TNode<TIndex> CodeStubAssembler::CalculateNewElementsCapacity(
  TNode<TIndex> old_capacity) {
static_assert(
    std::is_same<TIndex, Smi>::value || std::is_same<TIndex, IntPtrT>::value,
    "Only Smi or IntPtrT old_capacity is allowed");
Comment("TryGrowElementsCapacity");
TNode<TIndex> half_old_capacity = WordOrSmiShr(old_capacity, 1);
TNode<TIndex> new_capacity = IntPtrOrSmiAdd(half_old_capacity, old_capacity);
TNode<TIndex> padding =
    IntPtrOrSmiConstant<TIndex>(JSObject::kMinAddedElementsCapacity);
return IntPtrOrSmiAdd(new_capacity, padding);
5298}

5300template V8_EXPORT_PRIVATE TNode<IntPtrT>
  CodeStubAssembler::CalculateNewElementsCapacity<IntPtrT>(TNode<IntPtrT>);
5302template V8_EXPORT_PRIVATE TNode<Smi>
  CodeStubAssembler::CalculateNewElementsCapacity<Smi>(TNode<Smi>);

5305TNode<FixedArrayBase> CodeStubAssembler::TryGrowElementsCapacity(
  TNode<HeapObject> object, TNode<FixedArrayBase> elements, ElementsKind kind,
  TNode<Smi> key, Label* bailout) {
CSA_SLOW_DCHECK(this, IsFixedArrayWithKindOrEmpty(elements, kind))((void)0);
TNode<Smi> capacity = LoadFixedArrayBaseLength(elements);

return TryGrowElementsCapacity(object, elements, kind,
                               TaggedToParameter<BInt>(key),
                               TaggedToParameter<BInt>(capacity), bailout);
5314}

5316template <typename TIndex>
5317TNode<FixedArrayBase> CodeStubAssembler::TryGrowElementsCapacity(
  TNode<HeapObject> object, TNode<FixedArrayBase> elements, ElementsKind kind,
  TNode<TIndex> key, TNode<TIndex> capacity, Label* bailout) {
static_assert(
    std::is_same<TIndex, Smi>::value || std::is_same<TIndex, IntPtrT>::value,
    "Only Smi or IntPtrT key and capacity nodes are allowed");
Comment("TryGrowElementsCapacity");
CSA_SLOW_DCHECK(this, IsFixedArrayWithKindOrEmpty(elements, kind))((void)0);

// If the gap growth is too big, fall back to the runtime.
TNode<TIndex> max_gap = IntPtrOrSmiConstant<TIndex>(JSObject::kMaxGap);
TNode<TIndex> max_capacity = IntPtrOrSmiAdd(capacity, max_gap);
GotoIf(UintPtrOrSmiGreaterThanOrEqual(key, max_capacity), bailout);

// Calculate the capacity of the new backing store.
TNode<TIndex> new_capacity = CalculateNewElementsCapacity(
    IntPtrOrSmiAdd(key, IntPtrOrSmiConstant<TIndex>(1)));

return GrowElementsCapacity(object, elements, kind, kind, capacity,
                            new_capacity, bailout);
5337}

5339template <typename TIndex>
5340TNode<FixedArrayBase> CodeStubAssembler::GrowElementsCapacity(
  TNode<HeapObject> object, TNode<FixedArrayBase> elements,
  ElementsKind from_kind, ElementsKind to_kind, TNode<TIndex> capacity,
  TNode<TIndex> new_capacity, Label* bailout) {
static_assert(
    std::is_same<TIndex, Smi>::value || std::is_same<TIndex, IntPtrT>::value,
    "Only Smi or IntPtrT capacities are allowed");
Comment("[ GrowElementsCapacity");
CSA_SLOW_DCHECK(this, IsFixedArrayWithKindOrEmpty(elements, from_kind))((void)0);

// If size of the allocation for the new capacity doesn't fit in a page
// that we can bump-pointer allocate from, fall back to the runtime.
int max_size = FixedArrayBase::GetMaxLengthForNewSpaceAllocation(to_kind);
GotoIf(UintPtrOrSmiGreaterThanOrEqual(new_capacity,
                                      IntPtrOrSmiConstant<TIndex>(max_size)),
       bailout);

// Allocate the new backing store.
TNode<FixedArrayBase> new_elements =
    AllocateFixedArray(to_kind, new_capacity);

// Copy the elements from the old elements store to the new.
// The size-check above guarantees that the |new_elements| is allocated
// in new space so we can skip the write barrier.
CopyFixedArrayElements(from_kind, elements, to_kind, new_elements, capacity,
                       new_capacity, SKIP_WRITE_BARRIER);

StoreObjectField(object, JSObject::kElementsOffset, new_elements);
Comment("] GrowElementsCapacity");
return new_elements;
5370}

5372template TNode<FixedArrayBase> CodeStubAssembler::GrowElementsCapacity<IntPtrT>(
  TNode<HeapObject>, TNode<FixedArrayBase>, ElementsKind, ElementsKind,
  TNode<IntPtrT>, TNode<IntPtrT>, compiler::CodeAssemblerLabel*);

5376namespace {

5378// Helper function for folded memento allocation.
5379// Memento objects are designed to be put right after the objects they are
5380// tracking on. So memento allocations have to be folded together with previous
5381// object allocations.
5382TNode<HeapObject> InnerAllocateMemento(CodeStubAssembler* csa,
                                     TNode<HeapObject> previous,
                                     TNode<IntPtrT> offset) {
return csa->UncheckedCast<HeapObject>(csa->BitcastWordToTagged(
    csa->IntPtrAdd(csa->BitcastTaggedToWord(previous), offset)));
5387}

5389}  // namespace

5391void CodeStubAssembler::InitializeAllocationMemento(
  TNode<HeapObject> base, TNode<IntPtrT> base_allocation_size,
  TNode<AllocationSite> allocation_site) {
DCHECK(V8_ALLOCATION_SITE_TRACKING_BOOL)((void) 0);
Comment("[Initialize AllocationMemento");
TNode<HeapObject> memento =
    InnerAllocateMemento(this, base, base_allocation_size);
StoreMapNoWriteBarrier(memento, RootIndex::kAllocationMementoMap);
StoreObjectFieldNoWriteBarrier(
    memento, AllocationMemento::kAllocationSiteOffset, allocation_site);
if (FLAG_allocation_site_pretenuring) {
  TNode<Int32T> count = LoadObjectField<Int32T>(
      allocation_site, AllocationSite::kPretenureCreateCountOffset);

  TNode<Int32T> incremented_count = Int32Add(count, Int32Constant(1));
  StoreObjectFieldNoWriteBarrier(allocation_site,
                                 AllocationSite::kPretenureCreateCountOffset,
                                 incremented_count);
}
Comment("]");
5411}

5413TNode<IntPtrT> CodeStubAssembler::TryTaggedToInt32AsIntPtr(
  TNode<Object> acc, Label* if_not_possible) {
TVARIABLE(IntPtrT, acc_intptr)TVariable<IntPtrT> acc_intptr(this);
Label is_not_smi(this), have_int32(this);

GotoIfNot(TaggedIsSmi(acc), &is_not_smi);
acc_intptr = SmiUntag(CAST(acc)Cast(acc));
Goto(&have_int32);

BIND(&is_not_smi)Bind(&is_not_smi);
GotoIfNot(IsHeapNumber(CAST(acc)Cast(acc)), if_not_possible);
TNode<Float64T> value = LoadHeapNumberValue(CAST(acc)Cast(acc));
TNode<Int32T> value32 = RoundFloat64ToInt32(value);
TNode<Float64T> value64 = ChangeInt32ToFloat64(value32);
GotoIfNot(Float64Equal(value, value64), if_not_possible);
acc_intptr = ChangeInt32ToIntPtr(value32);
Goto(&have_int32);

BIND(&have_int32)Bind(&have_int32);
return acc_intptr.value();
5433}

5435TNode<Float64T> CodeStubAssembler::TryTaggedToFloat64(
  TNode<Object> value, Label* if_valueisnotnumber) {
return Select<Float64T>(
    TaggedIsSmi(value), [&]() { return SmiToFloat64(CAST(value)Cast(value)); },
    [&]() {
      GotoIfNot(IsHeapNumber(CAST(value)Cast(value)), if_valueisnotnumber);
      return LoadHeapNumberValue(CAST(value)Cast(value));
    });
5443}

5445TNode<Float64T> CodeStubAssembler::TruncateTaggedToFloat64(
  TNode<Context> context, TNode<Object> value) {
// We might need to loop once due to ToNumber conversion.
TVARIABLE(Object, var_value, value)TVariable<Object> var_value(value, this);
TVARIABLE(Float64T, var_result)TVariable<Float64T> var_result(this);
Label loop(this, &var_value), done_loop(this, &var_result);
Goto(&loop);
BIND(&loop)Bind(&loop);
{
  Label if_valueisnotnumber(this, Label::kDeferred);

  // Load the current {value}.
  value = var_value.value();

  // Convert {value} to Float64 if it is a number and convert it to a number
  // otherwise.
  var_result = TryTaggedToFloat64(value, &if_valueisnotnumber);
  Goto(&done_loop);

  BIND(&if_valueisnotnumber)Bind(&if_valueisnotnumber);
  {
    // Convert the {value} to a Number first.
    var_value = CallBuiltin(Builtin::kNonNumberToNumber, context, value);
    Goto(&loop);
  }
}
BIND(&done_loop)Bind(&done_loop);
return var_result.value();
5473}

5475TNode<Word32T> CodeStubAssembler::TruncateTaggedToWord32(TNode<Context> context,
                                                       TNode<Object> value) {
TVARIABLE(Word32T, var_result)TVariable<Word32T> var_result(this);
Label done(this);
TaggedToWord32OrBigIntImpl<Object::Conversion::kToNumber>(
    context, value, &done, &var_result, IsKnownTaggedPointer::kNo);
BIND(&done)Bind(&done);
return var_result.value();
5483}

5485// Truncate {value} to word32 and jump to {if_number} if it is a Number,
5486// or find that it is a BigInt and jump to {if_bigint}.
5487void CodeStubAssembler::TaggedToWord32OrBigInt(
  TNode<Context> context, TNode<Object> value, Label* if_number,
  TVariable<Word32T>* var_word32, Label* if_bigint,
  TVariable<BigInt>* var_maybe_bigint) {
TaggedToWord32OrBigIntImpl<Object::Conversion::kToNumeric>(
    context, value, if_number, var_word32, IsKnownTaggedPointer::kNo,
    if_bigint, var_maybe_bigint);
5494}

5496// Truncate {value} to word32 and jump to {if_number} if it is a Number,
5497// or find that it is a BigInt and jump to {if_bigint}. In either case,
5498// store the type feedback in {var_feedback}.
5499void CodeStubAssembler::TaggedToWord32OrBigIntWithFeedback(
  TNode<Context> context, TNode<Object> value, Label* if_number,
  TVariable<Word32T>* var_word32, Label* if_bigint,
  TVariable<BigInt>* var_maybe_bigint, TVariable<Smi>* var_feedback) {
TaggedToWord32OrBigIntImpl<Object::Conversion::kToNumeric>(
    context, value, if_number, var_word32, IsKnownTaggedPointer::kNo,
    if_bigint, var_maybe_bigint, var_feedback);
5506}

5508// Truncate {pointer} to word32 and jump to {if_number} if it is a Number,
5509// or find that it is a BigInt and jump to {if_bigint}. In either case,
5510// store the type feedback in {var_feedback}.
5511void CodeStubAssembler::TaggedPointerToWord32OrBigIntWithFeedback(
  TNode<Context> context, TNode<HeapObject> pointer, Label* if_number,
  TVariable<Word32T>* var_word32, Label* if_bigint,
  TVariable<BigInt>* var_maybe_bigint, TVariable<Smi>* var_feedback) {
TaggedToWord32OrBigIntImpl<Object::Conversion::kToNumeric>(
    context, pointer, if_number, var_word32, IsKnownTaggedPointer::kYes,
    if_bigint, var_maybe_bigint, var_feedback);
5518}

5520template <Object::Conversion conversion>
5521void CodeStubAssembler::TaggedToWord32OrBigIntImpl(
  TNode<Context> context, TNode<Object> value, Label* if_number,
  TVariable<Word32T>* var_word32,
  IsKnownTaggedPointer is_known_tagged_pointer, Label* if_bigint,
  TVariable<BigInt>* var_maybe_bigint, TVariable<Smi>* var_feedback) {
// We might need to loop after conversion.
TVARIABLE(Object, var_value, value)TVariable<Object> var_value(value, this);
OverwriteFeedback(var_feedback, BinaryOperationFeedback::kNone);
VariableList loop_vars({&var_value}, zone());
if (var_feedback != nullptr) loop_vars.push_back(var_feedback);
Label loop(this, loop_vars);
if (is_known_tagged_pointer == IsKnownTaggedPointer::kNo) {
  GotoIf(TaggedIsNotSmi(value), &loop);

  // {value} is a Smi.
  *var_word32 = SmiToInt32(CAST(value)Cast(value));
  CombineFeedback(var_feedback, BinaryOperationFeedback::kSignedSmall);
  Goto(if_number);
} else {
  Goto(&loop);
}
BIND(&loop)Bind(&loop);
{
  value = var_value.value();
  Label not_smi(this), is_heap_number(this), is_oddball(this),
      is_bigint(this), check_if_smi(this);

  TNode<HeapObject> value_heap_object = CAST(value)Cast(value);
  TNode<Map> map = LoadMap(value_heap_object);
  GotoIf(IsHeapNumberMap(map), &is_heap_number);
  TNode<Uint16T> instance_type = LoadMapInstanceType(map);
  if (conversion == Object::Conversion::kToNumeric) {
    GotoIf(IsBigIntInstanceType(instance_type), &is_bigint);
  }

  // Not HeapNumber (or BigInt if conversion == kToNumeric).
  {
    if (var_feedback != nullptr) {
      // We do not require an Or with earlier feedback here because once we
      // convert the value to a Numeric, we cannot reach this path. We can
      // only reach this path on the first pass when the feedback is kNone.
      CSA_DCHECK(this, SmiEqual(var_feedback->value(),((void)0)
                                SmiConstant(BinaryOperationFeedback::kNone)))((void)0);
    }
    GotoIf(InstanceTypeEqual(instance_type, ODDBALL_TYPE), &is_oddball);
    // Not an oddball either -> convert.
    auto builtin = conversion == Object::Conversion::kToNumeric
                       ? Builtin::kNonNumberToNumeric
                       : Builtin::kNonNumberToNumber;
    var_value = CallBuiltin(builtin, context, value);
    OverwriteFeedback(var_feedback, BinaryOperationFeedback::kAny);
    Goto(&check_if_smi);

    BIND(&is_oddball)Bind(&is_oddball);
    var_value = LoadObjectField(value_heap_object, Oddball::kToNumberOffset);
    OverwriteFeedback(var_feedback,
                      BinaryOperationFeedback::kNumberOrOddball);
    Goto(&check_if_smi);
  }

  BIND(&is_heap_number)Bind(&is_heap_number);
  *var_word32 = TruncateHeapNumberValueToWord32(CAST(value)Cast(value));
  CombineFeedback(var_feedback, BinaryOperationFeedback::kNumber);
  Goto(if_number);

  if (conversion == Object::Conversion::kToNumeric) {
    BIND(&is_bigint)Bind(&is_bigint);
    *var_maybe_bigint = CAST(value)Cast(value);
    CombineFeedback(var_feedback, BinaryOperationFeedback::kBigInt);
    Goto(if_bigint);
  }

  BIND(&check_if_smi)Bind(&check_if_smi);
  value = var_value.value();
  GotoIf(TaggedIsNotSmi(value), &loop);

  // {value} is a Smi.
  *var_word32 = SmiToInt32(CAST(value)Cast(value));
  CombineFeedback(var_feedback, BinaryOperationFeedback::kSignedSmall);
  Goto(if_number);
}
5602}

5604TNode<Int32T> CodeStubAssembler::TruncateNumberToWord32(TNode<Number> number) {
TVARIABLE(Int32T, var_result)TVariable<Int32T> var_result(this);
Label done(this), if_heapnumber(this);
GotoIfNot(TaggedIsSmi(number), &if_heapnumber);
var_result = SmiToInt32(CAST(number)Cast(number));
Goto(&done);

BIND(&if_heapnumber)Bind(&if_heapnumber);
TNode<Float64T> value = LoadHeapNumberValue(CAST(number)Cast(number));
var_result = Signed(TruncateFloat64ToWord32(value));
Goto(&done);

BIND(&done)Bind(&done);
return var_result.value();
5618}

5620TNode<Int32T> CodeStubAssembler::TruncateHeapNumberValueToWord32(
  TNode<HeapNumber> object) {
TNode<Float64T> value = LoadHeapNumberValue(object);
return Signed(TruncateFloat64ToWord32(value));
5624}

5626void CodeStubAssembler::TryHeapNumberToSmi(TNode<HeapNumber> number,
                                         TVariable<Smi>* var_result_smi,
                                         Label* if_smi) {
TNode<Float64T> value = LoadHeapNumberValue(number);
TryFloat64ToSmi(value, var_result_smi, if_smi);
5631}

5633void CodeStubAssembler::TryFloat32ToSmi(TNode<Float32T> value,
                                      TVariable<Smi>* var_result_smi,
                                      Label* if_smi) {
TNode<Int32T> ivalue = TruncateFloat32ToInt32(value);
TNode<Float32T> fvalue = RoundInt32ToFloat32(ivalue);

Label if_int32(this), if_heap_number(this);

GotoIfNot(Float32Equal(value, fvalue), &if_heap_number);
GotoIfNot(Word32Equal(ivalue, Int32Constant(0)), &if_int32);
Branch(Int32LessThan(UncheckedCast<Int32T>(BitcastFloat32ToInt32(value)),
                     Int32Constant(0)),
       &if_heap_number, &if_int32);

TVARIABLE(Number, var_result)TVariable<Number> var_result(this);
BIND(&if_int32)Bind(&if_int32);
{
  if (SmiValuesAre32Bits()) {
    *var_result_smi = SmiTag(ChangeInt32ToIntPtr(ivalue));
  } else {
    DCHECK(SmiValuesAre31Bits())((void) 0);
    TNode<PairT<Int32T, BoolT>> pair = Int32AddWithOverflow(ivalue, ivalue);
    TNode<BoolT> overflow = Projection<1>(pair);
    GotoIf(overflow, &if_heap_number);
    *var_result_smi =
        BitcastWordToTaggedSigned(ChangeInt32ToIntPtr(Projection<0>(pair)));
  }
  Goto(if_smi);
}
BIND(&if_heap_number)Bind(&if_heap_number);
5663}

5665void CodeStubAssembler::TryFloat64ToSmi(TNode<Float64T> value,
                                      TVariable<Smi>* var_result_smi,
                                      Label* if_smi) {
TNode<Int32T> value32 = RoundFloat64ToInt32(value);
TNode<Float64T> value64 = ChangeInt32ToFloat64(value32);

Label if_int32(this), if_heap_number(this, Label::kDeferred);

GotoIfNot(Float64Equal(value, value64), &if_heap_number);
GotoIfNot(Word32Equal(value32, Int32Constant(0)), &if_int32);
Branch(Int32LessThan(UncheckedCast<Int32T>(Float64ExtractHighWord32(value)),
                     Int32Constant(0)),
       &if_heap_number, &if_int32);

TVARIABLE(Number, var_result)TVariable<Number> var_result(this);
BIND(&if_int32)Bind(&if_int32);
{
  if (SmiValuesAre32Bits()) {
    *var_result_smi = SmiTag(ChangeInt32ToIntPtr(value32));
  } else {
    DCHECK(SmiValuesAre31Bits())((void) 0);
    TNode<PairT<Int32T, BoolT>> pair = Int32AddWithOverflow(value32, value32);
    TNode<BoolT> overflow = Projection<1>(pair);
    GotoIf(overflow, &if_heap_number);
    *var_result_smi =
        BitcastWordToTaggedSigned(ChangeInt32ToIntPtr(Projection<0>(pair)));
  }
  Goto(if_smi);
}
BIND(&if_heap_number)Bind(&if_heap_number);
5695}

5697TNode<Number> CodeStubAssembler::ChangeFloat32ToTagged(TNode<Float32T> value) {
Label if_smi(this), done(this);
TVARIABLE(Smi, var_smi_result)TVariable<Smi> var_smi_result(this);
TVARIABLE(Number, var_result)TVariable<Number> var_result(this);
TryFloat32ToSmi(value, &var_smi_result, &if_smi);

var_result = AllocateHeapNumberWithValue(ChangeFloat32ToFloat64(value));
Goto(&done);

BIND(&if_smi)Bind(&if_smi);
{
  var_result = var_smi_result.value();
  Goto(&done);
}
BIND(&done)Bind(&done);
return var_result.value();
5713}

5715TNode<Number> CodeStubAssembler::ChangeFloat64ToTagged(TNode<Float64T> value) {
Label if_smi(this), done(this);
TVARIABLE(Smi, var_smi_result)TVariable<Smi> var_smi_result(this);
TVARIABLE(Number, var_result)TVariable<Number> var_result(this);
TryFloat64ToSmi(value, &var_smi_result, &if_smi);

var_result = AllocateHeapNumberWithValue(value);
Goto(&done);

BIND(&if_smi)Bind(&if_smi);
{
  var_result = var_smi_result.value();
  Goto(&done);
}
BIND(&done)Bind(&done);
return var_result.value();
5731}

5733TNode<Number> CodeStubAssembler::ChangeInt32ToTagged(TNode<Int32T> value) {
if (SmiValuesAre32Bits()) {
  return SmiTag(ChangeInt32ToIntPtr(value));
}
DCHECK(SmiValuesAre31Bits())((void) 0);
TVARIABLE(Number, var_result)TVariable<Number> var_result(this);
TNode<PairT<Int32T, BoolT>> pair = Int32AddWithOverflow(value, value);
TNode<BoolT> overflow = Projection<1>(pair);
Label if_overflow(this, Label::kDeferred), if_notoverflow(this),
    if_join(this);
Branch(overflow, &if_overflow, &if_notoverflow);
BIND(&if_overflow)Bind(&if_overflow);
{
  TNode<Float64T> value64 = ChangeInt32ToFloat64(value);
  TNode<HeapNumber> result = AllocateHeapNumberWithValue(value64);
  var_result = result;
  Goto(&if_join);
}
BIND(&if_notoverflow)Bind(&if_notoverflow);
{
  TNode<IntPtrT> almost_tagged_value =
      ChangeInt32ToIntPtr(Projection<0>(pair));
  TNode<Smi> result = BitcastWordToTaggedSigned(almost_tagged_value);
  var_result = result;
  Goto(&if_join);
}
BIND(&if_join)Bind(&if_join);
return var_result.value();
5761}

5763TNode<Number> CodeStubAssembler::ChangeInt32ToTaggedNoOverflow(
  TNode<Int32T> value) {
if (SmiValuesAre32Bits()) {
  return SmiTag(ChangeInt32ToIntPtr(value));
}
DCHECK(SmiValuesAre31Bits())((void) 0);
TNode<Int32T> result_int32 = Int32Add(value, value);
TNode<IntPtrT> almost_tagged_value = ChangeInt32ToIntPtr(result_int32);
TNode<Smi> result = BitcastWordToTaggedSigned(almost_tagged_value);
return result;
5773}

5775TNode<Number> CodeStubAssembler::ChangeUint32ToTagged(TNode<Uint32T> value) {
Label if_overflow(this, Label::kDeferred), if_not_overflow(this),
    if_join(this);
TVARIABLE(Number, var_result)TVariable<Number> var_result(this);
// If {value} > 2^31 - 1, we need to store it in a HeapNumber.
Branch(Uint32LessThan(Uint32Constant(Smi::kMaxValue), value), &if_overflow,
       &if_not_overflow);

BIND(&if_not_overflow)Bind(&if_not_overflow);
{
  // The {value} is definitely in valid Smi range.
  var_result = SmiTag(Signed(ChangeUint32ToWord(value)));
}
Goto(&if_join);

BIND(&if_overflow)Bind(&if_overflow);
{
  TNode<Float64T> float64_value = ChangeUint32ToFloat64(value);
  var_result = AllocateHeapNumberWithValue(float64_value);
}
Goto(&if_join);

BIND(&if_join)Bind(&if_join);
return var_result.value();
5799}

5801TNode<Number> CodeStubAssembler::ChangeUintPtrToTagged(TNode<UintPtrT> value) {
Label if_overflow(this, Label::kDeferred), if_not_overflow(this),
    if_join(this);
TVARIABLE(Number, var_result)TVariable<Number> var_result(this);
// If {value} > 2^31 - 1, we need to store it in a HeapNumber.
Branch(UintPtrLessThan(UintPtrConstant(Smi::kMaxValue), value), &if_overflow,
       &if_not_overflow);

BIND(&if_not_overflow)Bind(&if_not_overflow);
{
  // The {value} is definitely in valid Smi range.
  var_result = SmiTag(Signed(value));
}
Goto(&if_join);

BIND(&if_overflow)Bind(&if_overflow);
{
  TNode<Float64T> float64_value = ChangeUintPtrToFloat64(value);
  var_result = AllocateHeapNumberWithValue(float64_value);
}
Goto(&if_join);

BIND(&if_join)Bind(&if_join);
return var_result.value();
5825}

5827TNode<Int32T> CodeStubAssembler::ChangeBoolToInt32(TNode<BoolT> b) {
return UncheckedCast<Int32T>(b);
5829}

5831TNode<String> CodeStubAssembler::ToThisString(TNode<Context> context,
                                            TNode<Object> value,
                                            TNode<String> method_name) {
TVARIABLE(Object, var_value, value)TVariable<Object> var_value(value, this);

// Check if the {value} is a Smi or a HeapObject.
Label if_valueissmi(this, Label::kDeferred), if_valueisnotsmi(this),
    if_valueisstring(this);
Branch(TaggedIsSmi(value), &if_valueissmi, &if_valueisnotsmi);
BIND(&if_valueisnotsmi)Bind(&if_valueisnotsmi);
{
  // Load the instance type of the {value}.
  TNode<Uint16T> value_instance_type = LoadInstanceType(CAST(value)Cast(value));

  // Check if the {value} is already String.
  Label if_valueisnotstring(this, Label::kDeferred);
  Branch(IsStringInstanceType(value_instance_type), &if_valueisstring,
         &if_valueisnotstring);
  BIND(&if_valueisnotstring)Bind(&if_valueisnotstring);
  {
    // Check if the {value} is null.
    Label if_valueisnullorundefined(this, Label::kDeferred);
    GotoIf(IsNullOrUndefined(value), &if_valueisnullorundefined);
    // Convert the {value} to a String.
    var_value = CallBuiltin(Builtin::kToString, context, value);
    Goto(&if_valueisstring);

    BIND(&if_valueisnullorundefined)Bind(&if_valueisnullorundefined);
    {
      // The {value} is either null or undefined.
      ThrowTypeError(context, MessageTemplate::kCalledOnNullOrUndefined,
                     method_name);
    }
  }
}
BIND(&if_valueissmi)Bind(&if_valueissmi);
{
  // The {value} is a Smi, convert it to a String.
  var_value = CallBuiltin(Builtin::kNumberToString, context, value);
  Goto(&if_valueisstring);
}
BIND(&if_valueisstring)Bind(&if_valueisstring);
return CAST(var_value.value())Cast(var_value.value());
5874}

5876TNode<Uint32T> CodeStubAssembler::ChangeNumberToUint32(TNode<Number> value) {
TVARIABLE(Uint32T, var_result)TVariable<Uint32T> var_result(this);
Label if_smi(this), if_heapnumber(this, Label::kDeferred), done(this);
Branch(TaggedIsSmi(value), &if_smi, &if_heapnumber);
BIND(&if_smi)Bind(&if_smi);
{
  var_result = Unsigned(SmiToInt32(CAST(value)Cast(value)));
  Goto(&done);
}
BIND(&if_heapnumber)Bind(&if_heapnumber);
{
  var_result = ChangeFloat64ToUint32(LoadHeapNumberValue(CAST(value)Cast(value)));
  Goto(&done);
}
BIND(&done)Bind(&done);
return var_result.value();
5892}

5894TNode<Float64T> CodeStubAssembler::ChangeNumberToFloat64(TNode<Number> value) {
TVARIABLE(Float64T, result)TVariable<Float64T> result(this);
Label smi(this);
Label done(this, &result);
GotoIf(TaggedIsSmi(value), &smi);
result = LoadHeapNumberValue(CAST(value)Cast(value));
Goto(&done);

BIND(&smi)Bind(&smi);
{
  result = SmiToFloat64(CAST(value)Cast(value));
  Goto(&done);
}

BIND(&done)Bind(&done);
return result.value();
5910}

5912TNode<Int32T> CodeStubAssembler::ChangeTaggedNonSmiToInt32(
  TNode<Context> context, TNode<HeapObject> input) {
return Select<Int32T>(
    IsHeapNumber(input),
    [=] {
      return Signed(TruncateFloat64ToWord32(LoadHeapNumberValue(input)));
    },
    [=] {
      return TruncateNumberToWord32(
          CAST(CallBuiltin(Builtin::kNonNumberToNumber, context, input))Cast(CallBuiltin(Builtin::kNonNumberToNumber, context, input)
));
    });
5923}

5925TNode<Float64T> CodeStubAssembler::ChangeTaggedToFloat64(TNode<Context> context,
                                                       TNode<Object> input) {
TVARIABLE(Float64T, var_result)TVariable<Float64T> var_result(this);
Label end(this), not_smi(this);

GotoIfNot(TaggedIsSmi(input), &not_smi);
var_result = SmiToFloat64(CAST(input)Cast(input));
Goto(&end);

BIND(&not_smi)Bind(&not_smi);
var_result = Select<Float64T>(
    IsHeapNumber(CAST(input)Cast(input)),
    [=] { return LoadHeapNumberValue(CAST(input)Cast(input)); },
    [=] {
      return ChangeNumberToFloat64(
          CAST(CallBuiltin(Builtin::kNonNumberToNumber, context, input))Cast(CallBuiltin(Builtin::kNonNumberToNumber, context, input)
));
    });
Goto(&end);

BIND(&end)Bind(&end);
return var_result.value();
5946}

5948TNode<WordT> CodeStubAssembler::TimesSystemPointerSize(TNode<WordT> value) {
return WordShl(value, kSystemPointerSizeLog2);
5950}

5952TNode<WordT> CodeStubAssembler::TimesTaggedSize(TNode<WordT> value) {
return WordShl(value, kTaggedSizeLog2);
5954}

5956TNode<WordT> CodeStubAssembler::TimesDoubleSize(TNode<WordT> value) {
return WordShl(value, kDoubleSizeLog2);
5958}

5960TNode<Object> CodeStubAssembler::ToThisValue(TNode<Context> context,
                                           TNode<Object> input_value,
                                           PrimitiveType primitive_type,
                                           char const* method_name) {
// We might need to loop once due to JSPrimitiveWrapper unboxing.
TVARIABLE(Object, var_value, input_value)TVariable<Object> var_value(input_value, this);
Label loop(this, &var_value), done_loop(this),
    done_throw(this, Label::kDeferred);
Goto(&loop);
BIND(&loop)Bind(&loop);
{
  // Check if the {value} is a Smi or a HeapObject.
  GotoIf(
      TaggedIsSmi(var_value.value()),
      (primitive_type == PrimitiveType::kNumber) ? &done_loop : &done_throw);

  TNode<HeapObject> value = CAST(var_value.value())Cast(var_value.value());

  // Load the map of the {value}.
  TNode<Map> value_map = LoadMap(value);

  // Load the instance type of the {value}.
  TNode<Uint16T> value_instance_type = LoadMapInstanceType(value_map);

  // Check if {value} is a JSPrimitiveWrapper.
  Label if_valueiswrapper(this, Label::kDeferred), if_valueisnotwrapper(this);
  Branch(InstanceTypeEqual(value_instance_type, JS_PRIMITIVE_WRAPPER_TYPE),
         &if_valueiswrapper, &if_valueisnotwrapper);

  BIND(&if_valueiswrapper)Bind(&if_valueiswrapper);
  {
    // Load the actual value from the {value}.
    var_value = LoadObjectField(value, JSPrimitiveWrapper::kValueOffset);
    Goto(&loop);
  }

  BIND(&if_valueisnotwrapper)Bind(&if_valueisnotwrapper);
  {
    switch (primitive_type) {
      case PrimitiveType::kBoolean:
        GotoIf(TaggedEqual(value_map, BooleanMapConstant()), &done_loop);
        break;
      case PrimitiveType::kNumber:
        GotoIf(TaggedEqual(value_map, HeapNumberMapConstant()), &done_loop);
        break;
      case PrimitiveType::kString:
        GotoIf(IsStringInstanceType(value_instance_type), &done_loop);
        break;
      case PrimitiveType::kSymbol:
        GotoIf(TaggedEqual(value_map, SymbolMapConstant()), &done_loop);
        break;
    }
    Goto(&done_throw);
  }
}

BIND(&done_throw)Bind(&done_throw);
{
  const char* primitive_name = nullptr;
  switch (primitive_type) {
    case PrimitiveType::kBoolean:
      primitive_name = "Boolean";
      break;
    case PrimitiveType::kNumber:
      primitive_name = "Number";
      break;
    case PrimitiveType::kString:
      primitive_name = "String";
      break;
    case PrimitiveType::kSymbol:
      primitive_name = "Symbol";
      break;
  }
  CHECK_NOT_NULL(primitive_name)do { if ((__builtin_expect(!!(!((primitive_name) != nullptr))
, 0))) { V8_Fatal("Check failed: %s.", "(primitive_name) != nullptr"
); } } while (false);

  // The {value} is not a compatible receiver for this method.
  ThrowTypeError(context, MessageTemplate::kNotGeneric, method_name,
                 primitive_name);
}

BIND(&done_loop)Bind(&done_loop);
return var_value.value();
6042}

6044void CodeStubAssembler::ThrowIfNotInstanceType(TNode<Context> context,
                                             TNode<Object> value,
                                             InstanceType instance_type,
                                             char const* method_name) {
Label out(this), throw_exception(this, Label::kDeferred);

GotoIf(TaggedIsSmi(value), &throw_exception);

// Load the instance type of the {value}.
TNode<Map> map = LoadMap(CAST(value)Cast(value));
const TNode<Uint16T> value_instance_type = LoadMapInstanceType(map);

Branch(Word32Equal(value_instance_type, Int32Constant(instance_type)), &out,
       &throw_exception);

// The {value} is not a compatible receiver for this method.
BIND(&throw_exception)Bind(&throw_exception);
ThrowTypeError(context, MessageTemplate::kIncompatibleMethodReceiver,
               StringConstant(method_name), value);

BIND(&out)Bind(&out);
6065}

6067void CodeStubAssembler::ThrowIfNotJSReceiver(TNode<Context> context,
                                           TNode<Object> value,
                                           MessageTemplate msg_template,
                                           const char* method_name) {
Label done(this), throw_exception(this, Label::kDeferred);

GotoIf(TaggedIsSmi(value), &throw_exception);

// Load the instance type of the {value}.
TNode<Map> value_map = LoadMap(CAST(value)Cast(value));
const TNode<Uint16T> value_instance_type = LoadMapInstanceType(value_map);

Branch(IsJSReceiverInstanceType(value_instance_type), &done,
       &throw_exception);

// The {value} is not a compatible receiver for this method.
BIND(&throw_exception)Bind(&throw_exception);
ThrowTypeError(context, msg_template, StringConstant(method_name), value);

BIND(&done)Bind(&done);
6087}

6089void CodeStubAssembler::ThrowIfNotCallable(TNode<Context> context,
                                         TNode<Object> value,
                                         const char* method_name) {
Label out(this), throw_exception(this, Label::kDeferred);

GotoIf(TaggedIsSmi(value), &throw_exception);
Branch(IsCallable(CAST(value)Cast(value)), &out, &throw_exception);

// The {value} is not a compatible receiver for this method.
BIND(&throw_exception)Bind(&throw_exception);
ThrowTypeError(context, MessageTemplate::kCalledNonCallable, method_name);

BIND(&out)Bind(&out);
6102}

6104void CodeStubAssembler::ThrowRangeError(TNode<Context> context,
                                      MessageTemplate message,
                                      base::Optional<TNode<Object>> arg0,
                                      base::Optional<TNode<Object>> arg1,
                                      base::Optional<TNode<Object>> arg2) {
TNode<Smi> template_index = SmiConstant(static_cast<int>(message));
if (!arg0) {
  CallRuntime(Runtime::kThrowRangeError, context, template_index);
} else if (!arg1) {
  CallRuntime(Runtime::kThrowRangeError, context, template_index, *arg0);
} else if (!arg2) {
  CallRuntime(Runtime::kThrowRangeError, context, template_index, *arg0,
              *arg1);
} else {
  CallRuntime(Runtime::kThrowRangeError, context, template_index, *arg0,
              *arg1, *arg2);
}
Unreachable();
6122}

6124void CodeStubAssembler::ThrowTypeError(TNode<Context> context,
                                     MessageTemplate message,
                                     char const* arg0, char const* arg1) {
base::Optional<TNode<Object>> arg0_node;
if (arg0) arg0_node = StringConstant(arg0);
base::Optional<TNode<Object>> arg1_node;
if (arg1) arg1_node = StringConstant(arg1);
ThrowTypeError(context, message, arg0_node, arg1_node);
6132}

6134void CodeStubAssembler::ThrowTypeError(TNode<Context> context,
                                     MessageTemplate message,
                                     base::Optional<TNode<Object>> arg0,
                                     base::Optional<TNode<Object>> arg1,
                                     base::Optional<TNode<Object>> arg2) {
TNode<Smi> template_index = SmiConstant(static_cast<int>(message));
if (!arg0) {
  CallRuntime(Runtime::kThrowTypeError, context, template_index);
} else if (!arg1) {
  CallRuntime(Runtime::kThrowTypeError, context, template_index, *arg0);
} else if (!arg2) {
  CallRuntime(Runtime::kThrowTypeError, context, template_index, *arg0,
              *arg1);
} else {
  CallRuntime(Runtime::kThrowTypeError, context, template_index, *arg0, *arg1,
              *arg2);
}
Unreachable();
6152}

6154TNode<HeapObject> CodeStubAssembler::GetPendingMessage() {
TNode<ExternalReference> pending_message = ExternalConstant(
    ExternalReference::address_of_pending_message(isolate()));
return UncheckedCast<HeapObject>(LoadFullTagged(pending_message));
6158}
6159void CodeStubAssembler::SetPendingMessage(TNode<HeapObject> message) {
CSA_DCHECK(this, Word32Or(IsTheHole(message),((void)0)
                          InstanceTypeEqual(LoadInstanceType(message),((void)0)
                                            JS_MESSAGE_OBJECT_TYPE)))((void)0);
TNode<ExternalReference> pending_message = ExternalConstant(
    ExternalReference::address_of_pending_message(isolate()));
StoreFullTaggedNoWriteBarrier(pending_message, message);
6166}

6168TNode<BoolT> CodeStubAssembler::InstanceTypeEqual(TNode<Int32T> instance_type,
                                                int type) {
return Word32Equal(instance_type, Int32Constant(type));
6171}

6173TNode<BoolT> CodeStubAssembler::IsDictionaryMap(TNode<Map> map) {
return IsSetWord32<Map::Bits3::IsDictionaryMapBit>(LoadMapBitField3(map));
6175}

6177TNode<BoolT> CodeStubAssembler::IsExtensibleMap(TNode<Map> map) {
return IsSetWord32<Map::Bits3::IsExtensibleBit>(LoadMapBitField3(map));
6179}

6181TNode<BoolT> CodeStubAssembler::IsExtensibleNonPrototypeMap(TNode<Map> map) {
int kMask =
    Map::Bits3::IsExtensibleBit::kMask | Map::Bits3::IsPrototypeMapBit::kMask;
int kExpected = Map::Bits3::IsExtensibleBit::kMask;
return Word32Equal(Word32And(LoadMapBitField3(map), Int32Constant(kMask)),
                   Int32Constant(kExpected));
6187}

6189TNode<BoolT> CodeStubAssembler::IsCallableMap(TNode<Map> map) {
return IsSetWord32<Map::Bits1::IsCallableBit>(LoadMapBitField(map));
6191}

6193TNode<BoolT> CodeStubAssembler::IsDeprecatedMap(TNode<Map> map) {
return IsSetWord32<Map::Bits3::IsDeprecatedBit>(LoadMapBitField3(map));
6195}

6197TNode<BoolT> CodeStubAssembler::IsUndetectableMap(TNode<Map> map) {
return IsSetWord32<Map::Bits1::IsUndetectableBit>(LoadMapBitField(map));
6199}

6201TNode<BoolT> CodeStubAssembler::IsNoElementsProtectorCellInvalid() {
TNode<Smi> invalid = SmiConstant(Protectors::kProtectorInvalid);
TNode<PropertyCell> cell = NoElementsProtectorConstant();
TNode<Object> cell_value = LoadObjectField(cell, PropertyCell::kValueOffset);
return TaggedEqual(cell_value, invalid);
6206}

6208TNode<BoolT> CodeStubAssembler::IsMegaDOMProtectorCellInvalid() {
TNode<Smi> invalid = SmiConstant(Protectors::kProtectorInvalid);
TNode<PropertyCell> cell = MegaDOMProtectorConstant();
TNode<Object> cell_value = LoadObjectField(cell, PropertyCell::kValueOffset);
return TaggedEqual(cell_value, invalid);
6213}

6215TNode<BoolT> CodeStubAssembler::IsArrayIteratorProtectorCellInvalid() {
TNode<Smi> invalid = SmiConstant(Protectors::kProtectorInvalid);
TNode<PropertyCell> cell = ArrayIteratorProtectorConstant();
TNode<Object> cell_value = LoadObjectField(cell, PropertyCell::kValueOffset);
return TaggedEqual(cell_value, invalid);
6220}

6222TNode<BoolT> CodeStubAssembler::IsPromiseResolveProtectorCellInvalid() {
TNode<Smi> invalid = SmiConstant(Protectors::kProtectorInvalid);
TNode<PropertyCell> cell = PromiseResolveProtectorConstant();
TNode<Object> cell_value = LoadObjectField(cell, PropertyCell::kValueOffset);
return TaggedEqual(cell_value, invalid);
6227}

6229TNode<BoolT> CodeStubAssembler::IsPromiseThenProtectorCellInvalid() {
TNode<Smi> invalid = SmiConstant(Protectors::kProtectorInvalid);
TNode<PropertyCell> cell = PromiseThenProtectorConstant();
TNode<Object> cell_value = LoadObjectField(cell, PropertyCell::kValueOffset);
return TaggedEqual(cell_value, invalid);
6234}

6236TNode<BoolT> CodeStubAssembler::IsArraySpeciesProtectorCellInvalid() {
TNode<Smi> invalid = SmiConstant(Protectors::kProtectorInvalid);
TNode<PropertyCell> cell = ArraySpeciesProtectorConstant();
TNode<Object> cell_value = LoadObjectField(cell, PropertyCell::kValueOffset);
return TaggedEqual(cell_value, invalid);
6241}

6243TNode<BoolT> CodeStubAssembler::IsIsConcatSpreadableProtectorCellInvalid() {
TNode<Smi> invalid = SmiConstant(Protectors::kProtectorInvalid);
TNode<PropertyCell> cell = IsConcatSpreadableProtectorConstant();
TNode<Object> cell_value = LoadObjectField(cell, PropertyCell::kValueOffset);
return TaggedEqual(cell_value, invalid);
6248}

6250TNode<BoolT> CodeStubAssembler::IsTypedArraySpeciesProtectorCellInvalid() {
TNode<Smi> invalid = SmiConstant(Protectors::kProtectorInvalid);
TNode<PropertyCell> cell = TypedArraySpeciesProtectorConstant();
TNode<Object> cell_value = LoadObjectField(cell, PropertyCell::kValueOffset);
return TaggedEqual(cell_value, invalid);
6255}

6257TNode<BoolT> CodeStubAssembler::IsRegExpSpeciesProtectorCellInvalid() {
TNode<Smi> invalid = SmiConstant(Protectors::kProtectorInvalid);
TNode<PropertyCell> cell = RegExpSpeciesProtectorConstant();
TNode<Object> cell_value = LoadObjectField(cell, PropertyCell::kValueOffset);
return TaggedEqual(cell_value, invalid);
6262}

6264TNode<BoolT> CodeStubAssembler::IsPromiseSpeciesProtectorCellInvalid() {
TNode<Smi> invalid = SmiConstant(Protectors::kProtectorInvalid);
TNode<PropertyCell> cell = PromiseSpeciesProtectorConstant();
TNode<Object> cell_value = LoadObjectField(cell, PropertyCell::kValueOffset);
return TaggedEqual(cell_value, invalid);
6269}

6271TNode<BoolT> CodeStubAssembler::IsPrototypeInitialArrayPrototype(
  TNode<Context> context, TNode<Map> map) {
const TNode<NativeContext> native_context = LoadNativeContext(context);
const TNode<Object> initial_array_prototype = LoadContextElement(
    native_context, Context::INITIAL_ARRAY_PROTOTYPE_INDEX);
TNode<HeapObject> proto = LoadMapPrototype(map);
return TaggedEqual(proto, initial_array_prototype);
6278}

6280TNode<BoolT> CodeStubAssembler::IsPrototypeTypedArrayPrototype(
  TNode<Context> context, TNode<Map> map) {
const TNode<NativeContext> native_context = LoadNativeContext(context);
const TNode<Object> typed_array_prototype =
    LoadContextElement(native_context, Context::TYPED_ARRAY_PROTOTYPE_INDEX);
TNode<HeapObject> proto = LoadMapPrototype(map);
TNode<HeapObject> proto_of_proto = Select<HeapObject>(
    IsJSObject(proto), [=] { return LoadMapPrototype(LoadMap(proto)); },
    [=] { return NullConstant(); });
return TaggedEqual(proto_of_proto, typed_array_prototype);
6290}

6292TNode<BoolT> CodeStubAssembler::IsFastAliasedArgumentsMap(
  TNode<Context> context, TNode<Map> map) {
const TNode<NativeContext> native_context = LoadNativeContext(context);
const TNode<Object> arguments_map = LoadContextElement(
    native_context, Context::FAST_ALIASED_ARGUMENTS_MAP_INDEX);
return TaggedEqual(arguments_map, map);
6298}

6300TNode<BoolT> CodeStubAssembler::IsSlowAliasedArgumentsMap(
  TNode<Context> context, TNode<Map> map) {
const TNode<NativeContext> native_context = LoadNativeContext(context);
const TNode<Object> arguments_map = LoadContextElement(
    native_context, Context::SLOW_ALIASED_ARGUMENTS_MAP_INDEX);
return TaggedEqual(arguments_map, map);
6306}

6308TNode<BoolT> CodeStubAssembler::IsSloppyArgumentsMap(TNode<Context> context,
                                                   TNode<Map> map) {
const TNode<NativeContext> native_context = LoadNativeContext(context);
const TNode<Object> arguments_map =
    LoadContextElement(native_context, Context::SLOPPY_ARGUMENTS_MAP_INDEX);
return TaggedEqual(arguments_map, map);
6314}

6316TNode<BoolT> CodeStubAssembler::IsStrictArgumentsMap(TNode<Context> context,
                                                   TNode<Map> map) {
const TNode<NativeContext> native_context = LoadNativeContext(context);
const TNode<Object> arguments_map =
    LoadContextElement(native_context, Context::STRICT_ARGUMENTS_MAP_INDEX);
return TaggedEqual(arguments_map, map);
6322}

6324TNode<BoolT> CodeStubAssembler::TaggedIsCallable(TNode<Object> object) {
return Select<BoolT>(
    TaggedIsSmi(object), [=] { return Int32FalseConstant(); },
    [=] {
      return IsCallableMap(LoadMap(UncheckedCast<HeapObject>(object)));
    });
6330}

6332TNode<BoolT> CodeStubAssembler::IsCallable(TNode<HeapObject> object) {
return IsCallableMap(LoadMap(object));
6334}

6336TNode<BoolT> CodeStubAssembler::IsConstructorMap(TNode<Map> map) {
return IsSetWord32<Map::Bits1::IsConstructorBit>(LoadMapBitField(map));
6338}

6340TNode<BoolT> CodeStubAssembler::IsConstructor(TNode<HeapObject> object) {
return IsConstructorMap(LoadMap(object));
6342}

6344TNode<BoolT> CodeStubAssembler::IsFunctionWithPrototypeSlotMap(TNode<Map> map) {
return IsSetWord32<Map::Bits1::HasPrototypeSlotBit>(LoadMapBitField(map));
6346}

6348TNode<BoolT> CodeStubAssembler::IsSpecialReceiverInstanceType(
  TNode<Int32T> instance_type) {
STATIC_ASSERT(JS_GLOBAL_OBJECT_TYPE <= LAST_SPECIAL_RECEIVER_TYPE)static_assert(JS_GLOBAL_OBJECT_TYPE <= LAST_SPECIAL_RECEIVER_TYPE
, "JS_GLOBAL_OBJECT_TYPE <= LAST_SPECIAL_RECEIVER_TYPE");
return Int32LessThanOrEqual(instance_type,
                            Int32Constant(LAST_SPECIAL_RECEIVER_TYPE));
6353}

6355TNode<BoolT> CodeStubAssembler::IsCustomElementsReceiverInstanceType(
  TNode<Int32T> instance_type) {
return Int32LessThanOrEqual(instance_type,
                            Int32Constant(LAST_CUSTOM_ELEMENTS_RECEIVER));
6359}

6361TNode<BoolT> CodeStubAssembler::IsStringInstanceType(
  TNode<Int32T> instance_type) {
STATIC_ASSERT(INTERNALIZED_STRING_TYPE == FIRST_TYPE)static_assert(INTERNALIZED_STRING_TYPE == FIRST_TYPE, "INTERNALIZED_STRING_TYPE == FIRST_TYPE"
);
return Int32LessThan(instance_type, Int32Constant(FIRST_NONSTRING_TYPE));
6365}

6367TNode<BoolT> CodeStubAssembler::IsTemporalInstantInstanceType(
  TNode<Int32T> instance_type) {
return InstanceTypeEqual(instance_type, JS_TEMPORAL_INSTANT_TYPE);
6370}

6372TNode<BoolT> CodeStubAssembler::IsOneByteStringInstanceType(
  TNode<Int32T> instance_type) {
CSA_DCHECK(this, IsStringInstanceType(instance_type))((void)0);
return Word32Equal(
    Word32And(instance_type, Int32Constant(kStringEncodingMask)),
    Int32Constant(kOneByteStringTag));
6378}

6380TNode<BoolT> CodeStubAssembler::IsSequentialStringInstanceType(
  TNode<Int32T> instance_type) {
CSA_DCHECK(this, IsStringInstanceType(instance_type))((void)0);
return Word32Equal(
    Word32And(instance_type, Int32Constant(kStringRepresentationMask)),
    Int32Constant(kSeqStringTag));
6386}

6388TNode<BoolT> CodeStubAssembler::IsSeqOneByteStringInstanceType(
  TNode<Int32T> instance_type) {
CSA_DCHECK(this, IsStringInstanceType(instance_type))((void)0);
return Word32Equal(
    Word32And(instance_type,
              Int32Constant(kStringRepresentationAndEncodingMask)),
    Int32Constant(kSeqOneByteStringTag));
6395}

6397TNode<BoolT> CodeStubAssembler::IsConsStringInstanceType(
  TNode<Int32T> instance_type) {
CSA_DCHECK(this, IsStringInstanceType(instance_type))((void)0);
return Word32Equal(
    Word32And(instance_type, Int32Constant(kStringRepresentationMask)),
    Int32Constant(kConsStringTag));
6403}

6405TNode<BoolT> CodeStubAssembler::IsIndirectStringInstanceType(
  TNode<Int32T> instance_type) {
CSA_DCHECK(this, IsStringInstanceType(instance_type))((void)0);
STATIC_ASSERT(kIsIndirectStringMask == 0x1)static_assert(kIsIndirectStringMask == 0x1, "kIsIndirectStringMask == 0x1"
);
STATIC_ASSERT(kIsIndirectStringTag == 0x1)static_assert(kIsIndirectStringTag == 0x1, "kIsIndirectStringTag == 0x1"
);
return UncheckedCast<BoolT>(
    Word32And(instance_type, Int32Constant(kIsIndirectStringMask)));
6412}

6414TNode<BoolT> CodeStubAssembler::IsExternalStringInstanceType(
  TNode<Int32T> instance_type) {
CSA_DCHECK(this, IsStringInstanceType(instance_type))((void)0);
return Word32Equal(
    Word32And(instance_type, Int32Constant(kStringRepresentationMask)),
    Int32Constant(kExternalStringTag));
6420}

6422TNode<BoolT> CodeStubAssembler::IsUncachedExternalStringInstanceType(
  TNode<Int32T> instance_type) {
CSA_DCHECK(this, IsStringInstanceType(instance_type))((void)0);
STATIC_ASSERT(kUncachedExternalStringTag != 0)static_assert(kUncachedExternalStringTag != 0, "kUncachedExternalStringTag != 0"
);
return IsSetWord32(instance_type, kUncachedExternalStringMask);
6427}

6429TNode<BoolT> CodeStubAssembler::IsJSReceiverInstanceType(
  TNode<Int32T> instance_type) {
STATIC_ASSERT(LAST_JS_RECEIVER_TYPE == LAST_TYPE)static_assert(LAST_JS_RECEIVER_TYPE == LAST_TYPE, "LAST_JS_RECEIVER_TYPE == LAST_TYPE"
);
return Int32GreaterThanOrEqual(instance_type,
                               Int32Constant(FIRST_JS_RECEIVER_TYPE));
6434}

6436TNode<BoolT> CodeStubAssembler::IsJSReceiverMap(TNode<Map> map) {
return IsJSReceiverInstanceType(LoadMapInstanceType(map));
6438}

6440TNode<BoolT> CodeStubAssembler::IsJSReceiver(TNode<HeapObject> object) {
return IsJSReceiverMap(LoadMap(object));
6442}

6444TNode<BoolT> CodeStubAssembler::IsNullOrJSReceiver(TNode<HeapObject> object) {
return UncheckedCast<BoolT>(Word32Or(IsJSReceiver(object), IsNull(object)));
6446}

6448TNode<BoolT> CodeStubAssembler::IsNullOrUndefined(TNode<Object> value) {
return UncheckedCast<BoolT>(Word32Or(IsUndefined(value), IsNull(value)));
6450}

6452TNode<BoolT> CodeStubAssembler::IsJSGlobalProxyInstanceType(
  TNode<Int32T> instance_type) {
return InstanceTypeEqual(instance_type, JS_GLOBAL_PROXY_TYPE);
6455}

6457TNode<BoolT> CodeStubAssembler::IsJSGlobalProxyMap(TNode<Map> map) {
return IsJSGlobalProxyInstanceType(LoadMapInstanceType(map));
6459}

6461TNode<BoolT> CodeStubAssembler::IsJSGlobalProxy(TNode<HeapObject> object) {
return IsJSGlobalProxyMap(LoadMap(object));
6463}

6465TNode<BoolT> CodeStubAssembler::IsJSGeneratorMap(TNode<Map> map) {
return InstanceTypeEqual(LoadMapInstanceType(map), JS_GENERATOR_OBJECT_TYPE);
6467}

6469TNode<BoolT> CodeStubAssembler::IsJSObjectInstanceType(
  TNode<Int32T> instance_type) {
STATIC_ASSERT(LAST_JS_OBJECT_TYPE == LAST_TYPE)static_assert(LAST_JS_OBJECT_TYPE == LAST_TYPE, "LAST_JS_OBJECT_TYPE == LAST_TYPE"
);
return Int32GreaterThanOrEqual(instance_type,
                               Int32Constant(FIRST_JS_OBJECT_TYPE));
6474}

6476TNode<BoolT> CodeStubAssembler::IsJSApiObjectInstanceType(
  TNode<Int32T> instance_type) {
return InstanceTypeEqual(instance_type, JS_API_OBJECT_TYPE);
6479}

6481TNode<BoolT> CodeStubAssembler::IsJSObjectMap(TNode<Map> map) {
return IsJSObjectInstanceType(LoadMapInstanceType(map));
6483}

6485TNode<BoolT> CodeStubAssembler::IsJSApiObjectMap(TNode<Map> map) {
return IsJSApiObjectInstanceType(LoadMapInstanceType(map));
6487}

6489TNode<BoolT> CodeStubAssembler::IsJSObject(TNode<HeapObject> object) {
return IsJSObjectMap(LoadMap(object));
6491}

6493TNode<BoolT> CodeStubAssembler::IsJSApiObject(TNode<HeapObject> object) {
return IsJSApiObjectMap(LoadMap(object));
6495}

6497TNode<BoolT> CodeStubAssembler::IsJSFinalizationRegistryMap(TNode<Map> map) {
return InstanceTypeEqual(LoadMapInstanceType(map),
                         JS_FINALIZATION_REGISTRY_TYPE);
6500}

6502TNode<BoolT> CodeStubAssembler::IsJSFinalizationRegistry(
  TNode<HeapObject> object) {
return IsJSFinalizationRegistryMap(LoadMap(object));
6505}

6507TNode<BoolT> CodeStubAssembler::IsJSPromiseMap(TNode<Map> map) {
return InstanceTypeEqual(LoadMapInstanceType(map), JS_PROMISE_TYPE);
6509}

6511TNode<BoolT> CodeStubAssembler::IsJSPromise(TNode<HeapObject> object) {
return IsJSPromiseMap(LoadMap(object));
6513}

6515TNode<BoolT> CodeStubAssembler::IsJSProxy(TNode<HeapObject> object) {
return HasInstanceType(object, JS_PROXY_TYPE);
6517}

6519TNode<BoolT> CodeStubAssembler::IsJSStringIterator(TNode<HeapObject> object) {
return HasInstanceType(object, JS_STRING_ITERATOR_TYPE);
6521}

6523TNode<BoolT> CodeStubAssembler::IsJSRegExpStringIterator(
  TNode<HeapObject> object) {
return HasInstanceType(object, JS_REG_EXP_STRING_ITERATOR_TYPE);
6526}

6528TNode<BoolT> CodeStubAssembler::IsMap(TNode<HeapObject> map) {
return IsMetaMap(LoadMap(map));
6530}

6532TNode<BoolT> CodeStubAssembler::IsJSPrimitiveWrapperInstanceType(
  TNode<Int32T> instance_type) {
return InstanceTypeEqual(instance_type, JS_PRIMITIVE_WRAPPER_TYPE);
6535}

6537TNode<BoolT> CodeStubAssembler::IsJSPrimitiveWrapper(TNode<HeapObject> object) {
return IsJSPrimitiveWrapperMap(LoadMap(object));
6539}

6541TNode<BoolT> CodeStubAssembler::IsJSPrimitiveWrapperMap(TNode<Map> map) {
return IsJSPrimitiveWrapperInstanceType(LoadMapInstanceType(map));
6543}

6545TNode<BoolT> CodeStubAssembler::IsJSWrappedFunction(TNode<HeapObject> object) {
return HasInstanceType(object, JS_WRAPPED_FUNCTION_TYPE);
6547}

6549TNode<BoolT> CodeStubAssembler::IsJSArrayInstanceType(
  TNode<Int32T> instance_type) {
return InstanceTypeEqual(instance_type, JS_ARRAY_TYPE);
6552}

6554TNode<BoolT> CodeStubAssembler::IsJSArray(TNode<HeapObject> object) {
return IsJSArrayMap(LoadMap(object));
6556}

6558TNode<BoolT> CodeStubAssembler::IsJSArrayMap(TNode<Map> map) {
return IsJSArrayInstanceType(LoadMapInstanceType(map));
6560}

6562TNode<BoolT> CodeStubAssembler::IsJSArrayIterator(TNode<HeapObject> object) {
return HasInstanceType(object, JS_ARRAY_ITERATOR_TYPE);
6564}

6566TNode<BoolT> CodeStubAssembler::IsJSSharedStructInstanceType(
  TNode<Int32T> instance_type) {
return InstanceTypeEqual(instance_type, JS_SHARED_STRUCT_TYPE);
6569}

6571TNode<BoolT> CodeStubAssembler::IsJSSharedStructMap(TNode<Map> map) {
return IsJSSharedStructInstanceType(LoadMapInstanceType(map));
6573}

6575TNode<BoolT> CodeStubAssembler::IsJSSharedStruct(TNode<HeapObject> object) {
return IsJSSharedStructMap(LoadMap(object));
6577}

6579TNode<BoolT> CodeStubAssembler::IsJSSharedStruct(TNode<Object> object) {
return Select<BoolT>(
    TaggedIsSmi(object), [=] { return Int32FalseConstant(); },
    [=] {
      TNode<HeapObject> heap_object = CAST(object)Cast(object);
      return IsJSSharedStruct(heap_object);
    });
6586}

6588TNode<BoolT> CodeStubAssembler::IsJSAsyncGeneratorObject(
  TNode<HeapObject> object) {
return HasInstanceType(object, JS_ASYNC_GENERATOR_OBJECT_TYPE);
6591}

6593TNode<BoolT> CodeStubAssembler::IsFixedArray(TNode<HeapObject> object) {
return HasInstanceType(object, FIXED_ARRAY_TYPE);
6595}

6597TNode<BoolT> CodeStubAssembler::IsFixedArraySubclass(TNode<HeapObject> object) {
TNode<Uint16T> instance_type = LoadInstanceType(object);
return UncheckedCast<BoolT>(
    Word32And(Int32GreaterThanOrEqual(instance_type,
                                      Int32Constant(FIRST_FIXED_ARRAY_TYPE)),
              Int32LessThanOrEqual(instance_type,
                                   Int32Constant(LAST_FIXED_ARRAY_TYPE))));
6604}

6606TNode<BoolT> CodeStubAssembler::IsNotWeakFixedArraySubclass(
  TNode<HeapObject> object) {
TNode<Uint16T> instance_type = LoadInstanceType(object);
return UncheckedCast<BoolT>(Word32Or(
    Int32LessThan(instance_type, Int32Constant(FIRST_WEAK_FIXED_ARRAY_TYPE)),
    Int32GreaterThan(instance_type,
                     Int32Constant(LAST_WEAK_FIXED_ARRAY_TYPE))));
6613}

6615TNode<BoolT> CodeStubAssembler::IsPropertyArray(TNode<HeapObject> object) {
return HasInstanceType(object, PROPERTY_ARRAY_TYPE);
6617}

6619TNode<BoolT> CodeStubAssembler::IsPromiseReactionJobTask(
  TNode<HeapObject> object) {
TNode<Uint16T> instance_type = LoadInstanceType(object);
return IsInRange(instance_type, FIRST_PROMISE_REACTION_JOB_TASK_TYPE,
                 LAST_PROMISE_REACTION_JOB_TASK_TYPE);
6624}

6626// This complicated check is due to elements oddities. If a smi array is empty
6627// after Array.p.shift, it is replaced by the empty array constant. If it is
6628// later filled with a double element, we try to grow it but pass in a double
6629// elements kind. Usually this would cause a size mismatch (since the source
6630// fixed array has HOLEY_ELEMENTS and destination has
6631// HOLEY_DOUBLE_ELEMENTS), but we don't have to worry about it when the
6632// source array is empty.
6633// TODO(jgruber): It might we worth creating an empty_double_array constant to
6634// simplify this case.
6635TNode<BoolT> CodeStubAssembler::IsFixedArrayWithKindOrEmpty(
  TNode<FixedArrayBase> object, ElementsKind kind) {
Label out(this);
TVARIABLE(BoolT, var_result, Int32TrueConstant())TVariable<BoolT> var_result(Int32TrueConstant(), this);

GotoIf(IsFixedArrayWithKind(object, kind), &out);

const TNode<Smi> length = LoadFixedArrayBaseLength(object);
GotoIf(SmiEqual(length, SmiConstant(0)), &out);

var_result = Int32FalseConstant();
Goto(&out);

BIND(&out)Bind(&out);
return var_result.value();
6650}

6652TNode<BoolT> CodeStubAssembler::IsFixedArrayWithKind(TNode<HeapObject> object,
                                                   ElementsKind kind) {
if (IsDoubleElementsKind(kind)) {
  return IsFixedDoubleArray(object);
} else {
  DCHECK(IsSmiOrObjectElementsKind(kind) || IsSealedElementsKind(kind) ||((void) 0)
         IsNonextensibleElementsKind(kind))((void) 0);
  return IsFixedArraySubclass(object);
}
6661}

6663TNode<BoolT> CodeStubAssembler::IsBoolean(TNode<HeapObject> object) {
return IsBooleanMap(LoadMap(object));
6665}

6667TNode<BoolT> CodeStubAssembler::IsPropertyCell(TNode<HeapObject> object) {
return IsPropertyCellMap(LoadMap(object));
6669}

6671TNode<BoolT> CodeStubAssembler::IsHeapNumberInstanceType(
  TNode<Int32T> instance_type) {
return InstanceTypeEqual(instance_type, HEAP_NUMBER_TYPE);
6674}

6676TNode<BoolT> CodeStubAssembler::IsOddball(TNode<HeapObject> object) {
return IsOddballInstanceType(LoadInstanceType(object));
6678}

6680TNode<BoolT> CodeStubAssembler::IsOddballInstanceType(
  TNode<Int32T> instance_type) {
return InstanceTypeEqual(instance_type, ODDBALL_TYPE);
6683}

6685TNode<BoolT> CodeStubAssembler::IsName(TNode<HeapObject> object) {
return IsNameInstanceType(LoadInstanceType(object));
6687}

6689TNode<BoolT> CodeStubAssembler::IsNameInstanceType(
  TNode<Int32T> instance_type) {
return Int32LessThanOrEqual(instance_type, Int32Constant(LAST_NAME_TYPE));
6692}

6694TNode<BoolT> CodeStubAssembler::IsString(TNode<HeapObject> object) {
return IsStringInstanceType(LoadInstanceType(object));
6696}

6698TNode<BoolT> CodeStubAssembler::IsSeqOneByteString(TNode<HeapObject> object) {
return IsSeqOneByteStringInstanceType(LoadInstanceType(object));
6700}

6702TNode<BoolT> CodeStubAssembler::IsSymbolInstanceType(
  TNode<Int32T> instance_type) {
return InstanceTypeEqual(instance_type, SYMBOL_TYPE);
6705}

6707TNode<BoolT> CodeStubAssembler::IsInternalizedStringInstanceType(
  TNode<Int32T> instance_type) {
STATIC_ASSERT(kNotInternalizedTag != 0)static_assert(kNotInternalizedTag != 0, "kNotInternalizedTag != 0"
);
return Word32Equal(
    Word32And(instance_type,
              Int32Constant(kIsNotStringMask | kIsNotInternalizedMask)),
    Int32Constant(kStringTag | kInternalizedTag));
6714}

6716TNode<BoolT> CodeStubAssembler::IsSharedStringInstanceType(
  TNode<Int32T> instance_type) {
TNode<BoolT> is_shared = Word32Equal(
    Word32And(instance_type,
              Int32Constant(kIsNotStringMask | kSharedStringMask)),
    Int32Constant(kStringTag | kSharedStringTag));
// TODO(v8:12007): Internalized strings do not have kSharedStringTag until
// the shared string table ships.
return Word32Or(is_shared,
                Word32And(HasSharedStringTableFlag(),
                          IsInternalizedStringInstanceType(instance_type)));
6727}

6729TNode<BoolT> CodeStubAssembler::IsUniqueName(TNode<HeapObject> object) {
TNode<Uint16T> instance_type = LoadInstanceType(object);
return Select<BoolT>(
    IsInternalizedStringInstanceType(instance_type),
    [=] { return Int32TrueConstant(); },
    [=] { return IsSymbolInstanceType(instance_type); });
6735}

6737// Semantics: guaranteed not to be an integer index (i.e. contains non-digit
6738// characters, or is outside MAX_SAFE_INTEGER/size_t range). Note that for
6739// non-TypedArray receivers, there are additional strings that must be treated
6740// as named property keys, namely the range [0xFFFFFFFF, MAX_SAFE_INTEGER].
6741TNode<BoolT> CodeStubAssembler::IsUniqueNameNoIndex(TNode<HeapObject> object) {
TNode<Uint16T> instance_type = LoadInstanceType(object);
return Select<BoolT>(
    IsInternalizedStringInstanceType(instance_type),
    [=] {
      return IsNotEqualInWord32<Name::HashFieldTypeBits>(
          LoadNameRawHashField(CAST(object)Cast(object)),
          Name::HashFieldType::kIntegerIndex);
    },
    [=] { return IsSymbolInstanceType(instance_type); });
6751}

6753// Semantics: {object} is a Symbol, or a String that doesn't have a cached
6754// index. This returns {true} for strings containing representations of
6755// integers in the range above 9999999 (per kMaxCachedArrayIndexLength)
6756// and below MAX_SAFE_INTEGER. For CSA_DCHECKs ensuring correct usage, this is
6757// better than no checking; and we don't have a good/fast way to accurately
6758// check such strings for being within "array index" (uint32_t) range.
6759TNode<BoolT> CodeStubAssembler::IsUniqueNameNoCachedIndex(
  TNode<HeapObject> object) {
TNode<Uint16T> instance_type = LoadInstanceType(object);
return Select<BoolT>(
    IsInternalizedStringInstanceType(instance_type),
    [=] {
      return IsSetWord32(LoadNameRawHashField(CAST(object)Cast(object)),
                         Name::kDoesNotContainCachedArrayIndexMask);
    },
    [=] { return IsSymbolInstanceType(instance_type); });
6769}

6771TNode<BoolT> CodeStubAssembler::IsBigIntInstanceType(
  TNode<Int32T> instance_type) {
return InstanceTypeEqual(instance_type, BIGINT_TYPE);
6774}

6776TNode<BoolT> CodeStubAssembler::IsBigInt(TNode<HeapObject> object) {
return IsBigIntInstanceType(LoadInstanceType(object));
6778}

6780TNode<BoolT> CodeStubAssembler::IsPrimitiveInstanceType(
  TNode<Int32T> instance_type) {
return Int32LessThanOrEqual(instance_type,
                            Int32Constant(LAST_PRIMITIVE_HEAP_OBJECT_TYPE));
6784}

6786TNode<BoolT> CodeStubAssembler::IsPrivateName(TNode<Symbol> symbol) {
TNode<Uint32T> flags = LoadObjectField<Uint32T>(symbol, Symbol::kFlagsOffset);
return IsSetWord32<Symbol::IsPrivateNameBit>(flags);
6789}

6791TNode<BoolT> CodeStubAssembler::IsHashTable(TNode<HeapObject> object) {
TNode<Uint16T> instance_type = LoadInstanceType(object);
return UncheckedCast<BoolT>(
    Word32And(Int32GreaterThanOrEqual(instance_type,
                                      Int32Constant(FIRST_HASH_TABLE_TYPE)),
              Int32LessThanOrEqual(instance_type,
                                   Int32Constant(LAST_HASH_TABLE_TYPE))));
6798}

6800TNode<BoolT> CodeStubAssembler::IsEphemeronHashTable(TNode<HeapObject> object) {
return HasInstanceType(object, EPHEMERON_HASH_TABLE_TYPE);
6802}

6804TNode<BoolT> CodeStubAssembler::IsNameDictionary(TNode<HeapObject> object) {
return HasInstanceType(object, NAME_DICTIONARY_TYPE);
6806}
6807TNode<BoolT> CodeStubAssembler::IsOrderedNameDictionary(
  TNode<HeapObject> object) {
return HasInstanceType(object, ORDERED_NAME_DICTIONARY_TYPE);
6810}

6812TNode<BoolT> CodeStubAssembler::IsSwissNameDictionary(
  TNode<HeapObject> object) {
return HasInstanceType(object, SWISS_NAME_DICTIONARY_TYPE);
6815}

6817TNode<BoolT> CodeStubAssembler::IsGlobalDictionary(TNode<HeapObject> object) {
return HasInstanceType(object, GLOBAL_DICTIONARY_TYPE);
6819}

6821TNode<BoolT> CodeStubAssembler::IsNumberDictionary(TNode<HeapObject> object) {
return HasInstanceType(object, NUMBER_DICTIONARY_TYPE);
6823}

6825TNode<BoolT> CodeStubAssembler::IsJSGeneratorObject(TNode<HeapObject> object) {
return HasInstanceType(object, JS_GENERATOR_OBJECT_TYPE);
6827}

6829TNode<BoolT> CodeStubAssembler::IsFunctionInstanceType(
  TNode<Int32T> instance_type) {
return IsInRange(instance_type,
                 FIRST_JS_FUNCTION_OR_BOUND_FUNCTION_OR_WRAPPED_FUNCTION_TYPE,
                 LAST_JS_FUNCTION_OR_BOUND_FUNCTION_OR_WRAPPED_FUNCTION_TYPE);
6834}
6835TNode<BoolT> CodeStubAssembler::IsJSFunctionInstanceType(
  TNode<Int32T> instance_type) {
return IsInRange(instance_type, FIRST_JS_FUNCTION_TYPE,
                 LAST_JS_FUNCTION_TYPE);
6839}

6841TNode<BoolT> CodeStubAssembler::IsJSFunction(TNode<HeapObject> object) {
return IsJSFunctionMap(LoadMap(object));
6843}

6845TNode<BoolT> CodeStubAssembler::IsJSBoundFunction(TNode<HeapObject> object) {
return HasInstanceType(object, JS_BOUND_FUNCTION_TYPE);
6847}

6849TNode<BoolT> CodeStubAssembler::IsJSFunctionMap(TNode<Map> map) {
return IsJSFunctionInstanceType(LoadMapInstanceType(map));
6851}

6853TNode<BoolT> CodeStubAssembler::IsJSTypedArrayInstanceType(
  TNode<Int32T> instance_type) {
return InstanceTypeEqual(instance_type, JS_TYPED_ARRAY_TYPE);
6856}

6858TNode<BoolT> CodeStubAssembler::IsJSTypedArrayMap(TNode<Map> map) {
return IsJSTypedArrayInstanceType(LoadMapInstanceType(map));
6860}

6862TNode<BoolT> CodeStubAssembler::IsJSTypedArray(TNode<HeapObject> object) {
return IsJSTypedArrayMap(LoadMap(object));
6864}

6866TNode<BoolT> CodeStubAssembler::IsJSArrayBuffer(TNode<HeapObject> object) {
return HasInstanceType(object, JS_ARRAY_BUFFER_TYPE);
6868}

6870TNode<BoolT> CodeStubAssembler::IsJSDataView(TNode<HeapObject> object) {
return HasInstanceType(object, JS_DATA_VIEW_TYPE);
6872}

6874TNode<BoolT> CodeStubAssembler::IsJSRegExp(TNode<HeapObject> object) {
return HasInstanceType(object, JS_REG_EXP_TYPE);
6876}

6878TNode<BoolT> CodeStubAssembler::IsNumeric(TNode<Object> object) {
return Select<BoolT>(
    TaggedIsSmi(object), [=] { return Int32TrueConstant(); },
    [=] {
      return UncheckedCast<BoolT>(
          Word32Or(IsHeapNumber(CAST(object)Cast(object)), IsBigInt(CAST(object)Cast(object))));
    });
6885}

6887TNode<BoolT> CodeStubAssembler::IsNumberNormalized(TNode<Number> number) {
TVARIABLE(BoolT, var_result, Int32TrueConstant())TVariable<BoolT> var_result(Int32TrueConstant(), this);
Label out(this);

GotoIf(TaggedIsSmi(number), &out);

TNode<Float64T> value = LoadHeapNumberValue(CAST(number)Cast(number));
TNode<Float64T> smi_min =
    Float64Constant(static_cast<double>(Smi::kMinValue));
TNode<Float64T> smi_max =
    Float64Constant(static_cast<double>(Smi::kMaxValue));

GotoIf(Float64LessThan(value, smi_min), &out);
GotoIf(Float64GreaterThan(value, smi_max), &out);
GotoIfNot(Float64Equal(value, value), &out);  // NaN.

var_result = Int32FalseConstant();
Goto(&out);

BIND(&out)Bind(&out);
return var_result.value();
6908}

6910TNode<BoolT> CodeStubAssembler::IsNumberPositive(TNode<Number> number) {
return Select<BoolT>(
    TaggedIsSmi(number), [=] { return TaggedIsPositiveSmi(number); },
    [=] { return IsHeapNumberPositive(CAST(number)Cast(number)); });
6914}

6916// TODO(cbruni): Use TNode<HeapNumber> instead of custom name.
6917TNode<BoolT> CodeStubAssembler::IsHeapNumberPositive(TNode<HeapNumber> number) {
TNode<Float64T> value = LoadHeapNumberValue(number);
TNode<Float64T> float_zero = Float64Constant(0.);
return Float64GreaterThanOrEqual(value, float_zero);
6921}

6923TNode<BoolT> CodeStubAssembler::IsNumberNonNegativeSafeInteger(
  TNode<Number> number) {
return Select<BoolT>(
    // TODO(cbruni): Introduce TaggedIsNonNegateSmi to avoid confusion.
    TaggedIsSmi(number), [=] { return TaggedIsPositiveSmi(number); },
    [=] {
      TNode<HeapNumber> heap_number = CAST(number)Cast(number);
      return Select<BoolT>(
          IsInteger(heap_number),
          [=] { return IsHeapNumberPositive(heap_number); },
          [=] { return Int32FalseConstant(); });
    });
6935}

6937TNode<BoolT> CodeStubAssembler::IsSafeInteger(TNode<Object> number) {
return Select<BoolT>(
    TaggedIsSmi(number), [=] { return Int32TrueConstant(); },
    [=] {
      return Select<BoolT>(
          IsHeapNumber(CAST(number)Cast(number)),
          [=] { return IsSafeInteger(UncheckedCast<HeapNumber>(number)); },
          [=] { return Int32FalseConstant(); });
    });
6946}

6948TNode<BoolT> CodeStubAssembler::IsSafeInteger(TNode<HeapNumber> number) {
// Load the actual value of {number}.
TNode<Float64T> number_value = LoadHeapNumberValue(number);
// Truncate the value of {number} to an integer (or an infinity).
TNode<Float64T> integer = Float64Trunc(number_value);

return Select<BoolT>(
    // Check if {number}s value matches the integer (ruling out the
    // infinities).
    Float64Equal(Float64Sub(number_value, integer), Float64Constant(0.0)),
    [=] {
      // Check if the {integer} value is in safe integer range.
      return Float64LessThanOrEqual(Float64Abs(integer),
                                    Float64Constant(kMaxSafeInteger));
    },
    [=] { return Int32FalseConstant(); });
6964}

6966TNode<BoolT> CodeStubAssembler::IsInteger(TNode<Object> number) {
return Select<BoolT>(
    TaggedIsSmi(number), [=] { return Int32TrueConstant(); },
    [=] {
      return Select<BoolT>(
          IsHeapNumber(CAST(number)Cast(number)),
          [=] { return IsInteger(UncheckedCast<HeapNumber>(number)); },
          [=] { return Int32FalseConstant(); });
    });
6975}

6977TNode<BoolT> CodeStubAssembler::IsInteger(TNode<HeapNumber> number) {
TNode<Float64T> number_value = LoadHeapNumberValue(number);
// Truncate the value of {number} to an integer (or an infinity).
TNode<Float64T> integer = Float64Trunc(number_value);
// Check if {number}s value matches the integer (ruling out the infinities).
return Float64Equal(Float64Sub(number_value, integer), Float64Constant(0.0));
6983}

6985TNode<BoolT> CodeStubAssembler::IsHeapNumberUint32(TNode<HeapNumber> number) {
// Check that the HeapNumber is a valid uint32
return Select<BoolT>(
    IsHeapNumberPositive(number),
    [=] {
      TNode<Float64T> value = LoadHeapNumberValue(number);
      TNode<Uint32T> int_value = TruncateFloat64ToWord32(value);
      return Float64Equal(value, ChangeUint32ToFloat64(int_value));
    },
    [=] { return Int32FalseConstant(); });
6995}

6997TNode<BoolT> CodeStubAssembler::IsNumberArrayIndex(TNode<Number> number) {
return Select<BoolT>(
    TaggedIsSmi(number), [=] { return TaggedIsPositiveSmi(number); },
    [=] { return IsHeapNumberUint32(CAST(number)Cast(number)); });
7001}

7003TNode<IntPtrT> CodeStubAssembler::LoadBasicMemoryChunkFlags(
  TNode<HeapObject> object) {
TNode<IntPtrT> object_word = BitcastTaggedToWord(object);
TNode<IntPtrT> page = PageFromAddress(object_word);
return UncheckedCast<IntPtrT>(
    Load(MachineType::Pointer(), page,
         IntPtrConstant(BasicMemoryChunk::kFlagsOffset)));
7010}

7012template <typename TIndex>
7013TNode<BoolT> CodeStubAssembler::FixedArraySizeDoesntFitInNewSpace(
  TNode<TIndex> element_count, int base_size) {
static_assert(
    std::is_same<TIndex, Smi>::value || std::is_same<TIndex, IntPtrT>::value,
    "Only Smi or IntPtrT element_count is allowed");
int max_newspace_elements =
    (kMaxRegularHeapObjectSize - base_size) / kTaggedSize;
return IntPtrOrSmiGreaterThan(
    element_count, IntPtrOrSmiConstant<TIndex>(max_newspace_elements));
7022}

7024TNode<Uint16T> CodeStubAssembler::StringCharCodeAt(TNode<String> string,
                                                 TNode<UintPtrT> index) {
CSA_DCHECK(this, UintPtrLessThan(index, LoadStringLengthAsWord(string)))((void)0);

TVARIABLE(Uint16T, var_result)TVariable<Uint16T> var_result(this);

Label return_result(this), if_runtime(this, Label::kDeferred),
    if_stringistwobyte(this), if_stringisonebyte(this);

ToDirectStringAssembler to_direct(state(), string);
to_direct.TryToDirect(&if_runtime);
const TNode<UintPtrT> offset =
    UintPtrAdd(index, Unsigned(to_direct.offset()));
const TNode<Int32T> instance_type = to_direct.instance_type();
const TNode<RawPtrT> string_data = to_direct.PointerToData(&if_runtime);

// Check if the {string} is a TwoByteSeqString or a OneByteSeqString.
Branch(IsOneByteStringInstanceType(instance_type), &if_stringisonebyte,
       &if_stringistwobyte);

BIND(&if_stringisonebyte)Bind(&if_stringisonebyte);
{
  var_result = Load<Uint8T>(string_data, offset);
  Goto(&return_result);
}

BIND(&if_stringistwobyte)Bind(&if_stringistwobyte);
{
  var_result = Load<Uint16T>(string_data, WordShl(offset, IntPtrConstant(1)));
  Goto(&return_result);
}

BIND(&if_runtime)Bind(&if_runtime);
{
  TNode<Object> result =
      CallRuntime(Runtime::kStringCharCodeAt, NoContextConstant(), string,
                  ChangeUintPtrToTagged(index));
  var_result = UncheckedCast<Uint16T>(SmiToInt32(CAST(result)Cast(result)));
  Goto(&return_result);
}

BIND(&return_result)Bind(&return_result);
return var_result.value();
7067}

7069TNode<String> CodeStubAssembler::StringFromSingleCharCode(TNode<Int32T> code) {
TVARIABLE(String, var_result)TVariable<String> var_result(this);

// Check if the {code} is a one-byte char code.
Label if_codeisonebyte(this), if_codeistwobyte(this, Label::kDeferred),
    if_done(this);
Branch(Int32LessThanOrEqual(code, Int32Constant(String::kMaxOneByteCharCode)),
       &if_codeisonebyte, &if_codeistwobyte);
BIND(&if_codeisonebyte)Bind(&if_codeisonebyte);
{
  // Load the isolate wide single character string cache.
  TNode<FixedArray> cache = SingleCharacterStringCacheConstant();
  TNode<IntPtrT> code_index = Signed(ChangeUint32ToWord(code));

  // Check if we have an entry for the {code} in the single character string
  // cache already.
  Label if_entryisundefined(this, Label::kDeferred),
      if_entryisnotundefined(this);
  TNode<Object> entry = UnsafeLoadFixedArrayElement(cache, code_index);
  Branch(IsUndefined(entry), &if_entryisundefined, &if_entryisnotundefined);

  BIND(&if_entryisundefined)Bind(&if_entryisundefined);
  {
    // Allocate a new SeqOneByteString for {code} and store it in the {cache}.
    TNode<String> result = AllocateSeqOneByteString(1);
    StoreNoWriteBarrier(
        MachineRepresentation::kWord8, result,
        IntPtrConstant(SeqOneByteString::kHeaderSize - kHeapObjectTag), code);
    StoreFixedArrayElement(cache, code_index, result);
    var_result = result;
    Goto(&if_done);
  }

  BIND(&if_entryisnotundefined)Bind(&if_entryisnotundefined);
  {
    // Return the entry from the {cache}.
    var_result = CAST(entry)Cast(entry);
    Goto(&if_done);
  }
}

BIND(&if_codeistwobyte)Bind(&if_codeistwobyte);
{
  // Allocate a new SeqTwoByteString for {code}.
  TNode<String> result = AllocateSeqTwoByteString(1);
  StoreNoWriteBarrier(
      MachineRepresentation::kWord16, result,
      IntPtrConstant(SeqTwoByteString::kHeaderSize - kHeapObjectTag), code);
  var_result = result;
  Goto(&if_done);
}

BIND(&if_done)Bind(&if_done);
return var_result.value();
7123}

7125ToDirectStringAssembler::ToDirectStringAssembler(
  compiler::CodeAssemblerState* state, TNode<String> string, Flags flags)
  : CodeStubAssembler(state),
    var_string_(string, this),
    var_instance_type_(LoadInstanceType(string), this),
    var_offset_(IntPtrConstant(0), this),
    var_is_external_(Int32Constant(0), this),
    flags_(flags) {}

7134TNode<String> ToDirectStringAssembler::TryToDirect(Label* if_bailout) {
Label dispatch(this, {&var_string_, &var_offset_, &var_instance_type_});
Label if_iscons(this);
Label if_isexternal(this);
Label if_issliced(this);
Label if_isthin(this);
Label out(this);

Branch(IsSequentialStringInstanceType(var_instance_type_.value()), &out,
       &dispatch);

// Dispatch based on string representation.
BIND(&dispatch)Bind(&dispatch);
{
  int32_t values[] = {
      kSeqStringTag,    kConsStringTag, kExternalStringTag,
      kSlicedStringTag, kThinStringTag,
  };
  Label* labels[] = {
      &out, &if_iscons, &if_isexternal, &if_issliced, &if_isthin,
  };
  STATIC_ASSERT(arraysize(values) == arraysize(labels))static_assert((sizeof(ArraySizeHelper(values))) == (sizeof(ArraySizeHelper
(labels))), "arraysize(values) == arraysize(labels)");

  const TNode<Int32T> representation = Word32And(
      var_instance_type_.value(), Int32Constant(kStringRepresentationMask));
  Switch(representation, if_bailout, values, labels, arraysize(values)(sizeof(ArraySizeHelper(values))));
}

// Cons string.  Check whether it is flat, then fetch first part.
// Flat cons strings have an empty second part.
BIND(&if_iscons)Bind(&if_iscons);
{
  const TNode<String> string = var_string_.value();
  GotoIfNot(IsEmptyString(
                LoadObjectField<String>(string, ConsString::kSecondOffset)),
            if_bailout);

  const TNode<String> lhs =
      LoadObjectField<String>(string, ConsString::kFirstOffset);
  var_string_ = lhs;
  var_instance_type_ = LoadInstanceType(lhs);

  Goto(&dispatch);
}

// Sliced string. Fetch parent and correct start index by offset.
BIND(&if_issliced)Bind(&if_issliced);
{
  if (!FLAG_string_slices || (flags_ & kDontUnpackSlicedStrings)) {
    Goto(if_bailout);
  } else {
    const TNode<String> string = var_string_.value();
    const TNode<IntPtrT> sliced_offset =
        LoadAndUntagObjectField(string, SlicedString::kOffsetOffset);
    var_offset_ = IntPtrAdd(var_offset_.value(), sliced_offset);

    const TNode<String> parent =
        LoadObjectField<String>(string, SlicedString::kParentOffset);
    var_string_ = parent;
    var_instance_type_ = LoadInstanceType(parent);

    Goto(&dispatch);
  }
}

// Thin string. Fetch the actual string.
BIND(&if_isthin)Bind(&if_isthin);
{
  const TNode<String> string = var_string_.value();
  const TNode<String> actual_string =
      LoadObjectField<String>(string, ThinString::kActualOffset);
  const TNode<Uint16T> actual_instance_type = LoadInstanceType(actual_string);

  var_string_ = actual_string;
  var_instance_type_ = actual_instance_type;

  Goto(&dispatch);
}

// External string.
BIND(&if_isexternal)Bind(&if_isexternal);
var_is_external_ = Int32Constant(1);
Goto(&out);

BIND(&out)Bind(&out);
return var_string_.value();
7220}

7222TNode<RawPtrT> ToDirectStringAssembler::TryToSequential(
  StringPointerKind ptr_kind, Label* if_bailout) {
CHECK(ptr_kind == PTR_TO_DATA || ptr_kind == PTR_TO_STRING)do { if ((__builtin_expect(!!(!(ptr_kind == PTR_TO_DATA || ptr_kind
 == PTR_TO_STRING)), 0))) { V8_Fatal("Check failed: %s.", "ptr_kind == PTR_TO_DATA || ptr_kind == PTR_TO_STRING"
); } } while (false);

TVARIABLE(RawPtrT, var_result)TVariable<RawPtrT> var_result(this);
Label out(this), if_issequential(this), if_isexternal(this, Label::kDeferred);
Branch(is_external(), &if_isexternal, &if_issequential);

BIND(&if_issequential)Bind(&if_issequential);
{
  STATIC_ASSERT(SeqOneByteString::kHeaderSize ==static_assert(SeqOneByteString::kHeaderSize == SeqTwoByteString
::kHeaderSize, "SeqOneByteString::kHeaderSize == SeqTwoByteString::kHeaderSize"
)
                SeqTwoByteString::kHeaderSize)static_assert(SeqOneByteString::kHeaderSize == SeqTwoByteString
::kHeaderSize, "SeqOneByteString::kHeaderSize == SeqTwoByteString::kHeaderSize"
);
  TNode<RawPtrT> result =
      ReinterpretCast<RawPtrT>(BitcastTaggedToWord(var_string_.value()));
  if (ptr_kind == PTR_TO_DATA) {
    result = RawPtrAdd(result, IntPtrConstant(SeqOneByteString::kHeaderSize -
                                              kHeapObjectTag));
  }
  var_result = result;
  Goto(&out);
}

BIND(&if_isexternal)Bind(&if_isexternal);
{
  GotoIf(IsUncachedExternalStringInstanceType(var_instance_type_.value()),
         if_bailout);

  TNode<String> string = var_string_.value();
  TNode<RawPtrT> result = LoadExternalStringResourceDataPtr(CAST(string)Cast(string));
  if (ptr_kind == PTR_TO_STRING) {
    result = RawPtrSub(result, IntPtrConstant(SeqOneByteString::kHeaderSize -
                                              kHeapObjectTag));
  }
  var_result = result;
  Goto(&out);
}

BIND(&out)Bind(&out);
return var_result.value();
7261}

7263TNode<Number> CodeStubAssembler::StringToNumber(TNode<String> input) {
Label runtime(this, Label::kDeferred);
Label end(this);

TVARIABLE(Number, var_result)TVariable<Number> var_result(this);

// Check if string has a cached array index.
TNode<Uint32T> raw_hash_field = LoadNameRawHashField(input);
GotoIf(IsSetWord32(raw_hash_field, Name::kDoesNotContainCachedArrayIndexMask),
       &runtime);

var_result = SmiTag(Signed(
    DecodeWordFromWord32<String::ArrayIndexValueBits>(raw_hash_field)));
Goto(&end);

BIND(&runtime)Bind(&runtime);
{
  var_result =
      CAST(CallRuntime(Runtime::kStringToNumber, NoContextConstant(), input))Cast(CallRuntime(Runtime::kStringToNumber, NoContextConstant(
), input));
  Goto(&end);
}

BIND(&end)Bind(&end);
return var_result.value();
7287}

7289TNode<String> CodeStubAssembler::NumberToString(TNode<Number> input,
                                              Label* bailout) {
TVARIABLE(String, result)TVariable<String> result(this);
TVARIABLE(Smi, smi_input)TVariable<Smi> smi_input(this);
Label if_smi(this), if_heap_number(this), done(this, &result);

// Load the number string cache.
TNode<FixedArray> number_string_cache = NumberStringCacheConstant();

// Make the hash mask from the length of the number string cache. It
// contains two elements (number and string) for each cache entry.
TNode<IntPtrT> number_string_cache_length =
    LoadAndUntagFixedArrayBaseLength(number_string_cache);
TNode<Int32T> one = Int32Constant(1);
TNode<Word32T> mask = Int32Sub(
    Word32Shr(TruncateWordToInt32(number_string_cache_length), one), one);

GotoIfNot(TaggedIsSmi(input), &if_heap_number);
smi_input = CAST(input)Cast(input);
Goto(&if_smi);

BIND(&if_heap_number)Bind(&if_heap_number);
{
  Comment("NumberToString - HeapNumber");
  TNode<HeapNumber> heap_number_input = CAST(input)Cast(input);
  // Try normalizing the HeapNumber.
  TryHeapNumberToSmi(heap_number_input, &smi_input, &if_smi);

  // Make a hash from the two 32-bit values of the double.
  TNode<Int32T> low =
      LoadObjectField<Int32T>(heap_number_input, HeapNumber::kValueOffset);
  TNode<Int32T> high = LoadObjectField<Int32T>(
      heap_number_input, HeapNumber::kValueOffset + kIntSize);
  TNode<Word32T> hash = Word32And(Word32Xor(low, high), mask);
  TNode<IntPtrT> entry_index =
      Signed(ChangeUint32ToWord(Int32Add(hash, hash)));

  // Cache entry's key must be a heap number
  TNode<Object> number_key =
      UnsafeLoadFixedArrayElement(number_string_cache, entry_index);
  GotoIf(TaggedIsSmi(number_key), bailout);
  TNode<HeapObject> number_key_heap_object = CAST(number_key)Cast(number_key);
  GotoIfNot(IsHeapNumber(number_key_heap_object), bailout);

  // Cache entry's key must match the heap number value we're looking for.
  TNode<Int32T> low_compare = LoadObjectField<Int32T>(
      number_key_heap_object, HeapNumber::kValueOffset);
  TNode<Int32T> high_compare = LoadObjectField<Int32T>(
      number_key_heap_object, HeapNumber::kValueOffset + kIntSize);
  GotoIfNot(Word32Equal(low, low_compare), bailout);
  GotoIfNot(Word32Equal(high, high_compare), bailout);

  // Heap number match, return value from cache entry.
  result = CAST(UnsafeLoadFixedArrayElement(number_string_cache, entry_index,Cast(UnsafeLoadFixedArrayElement(number_string_cache, entry_index
, kTaggedSize))
                                            kTaggedSize))Cast(UnsafeLoadFixedArrayElement(number_string_cache, entry_index
, kTaggedSize));
  Goto(&done);
}

BIND(&if_smi)Bind(&if_smi);
{
  Comment("NumberToString - Smi");
  // Load the smi key, make sure it matches the smi we're looking for.
  TNode<Word32T> hash = Word32And(SmiToInt32(smi_input.value()), mask);
  TNode<IntPtrT> entry_index =
      Signed(ChangeUint32ToWord(Int32Add(hash, hash)));
  TNode<Object> smi_key =
      UnsafeLoadFixedArrayElement(number_string_cache, entry_index);
  Label if_smi_cache_missed(this);
  GotoIf(TaggedNotEqual(smi_key, smi_input.value()), &if_smi_cache_missed);

  // Smi match, return value from cache entry.
  result = CAST(UnsafeLoadFixedArrayElement(number_string_cache, entry_index,Cast(UnsafeLoadFixedArrayElement(number_string_cache, entry_index
, kTaggedSize))
                                            kTaggedSize))Cast(UnsafeLoadFixedArrayElement(number_string_cache, entry_index
, kTaggedSize));
  Goto(&done);

  BIND(&if_smi_cache_missed)Bind(&if_smi_cache_missed);
  {
    Label store_to_cache(this);

    // Bailout when the cache is not full-size.
    const int kFullCacheSize =
        isolate()->heap()->MaxNumberToStringCacheSize();
    Branch(IntPtrLessThan(number_string_cache_length,
                          IntPtrConstant(kFullCacheSize)),
           bailout, &store_to_cache);

    BIND(&store_to_cache)Bind(&store_to_cache);
    {
      // Generate string and update string hash field.
      result = NumberToStringSmi(SmiToInt32(smi_input.value()),
                                 Int32Constant(10), bailout);

      // Store string into cache.
      StoreFixedArrayElement(number_string_cache, entry_index,
                             smi_input.value());
      StoreFixedArrayElement(number_string_cache,
                             IntPtrAdd(entry_index, IntPtrConstant(1)),
                             result.value());
      Goto(&done);
    }
  }
}
BIND(&done)Bind(&done);
return result.value();
7393}

7395TNode<String> CodeStubAssembler::NumberToString(TNode<Number> input) {
TVARIABLE(String, result)TVariable<String> result(this);
Label runtime(this, Label::kDeferred), done(this, &result);

GotoIfForceSlowPath(&runtime);

result = NumberToString(input, &runtime);
Goto(&done);

BIND(&runtime)Bind(&runtime);
{
  // No cache entry, go to the runtime.
  result = CAST(Cast(CallRuntime(Runtime::kNumberToStringSlow, NoContextConstant
(), input))
      CallRuntime(Runtime::kNumberToStringSlow, NoContextConstant(), input))Cast(CallRuntime(Runtime::kNumberToStringSlow, NoContextConstant
(), input));
  Goto(&done);
}
BIND(&done)Bind(&done);
return result.value();
7413}

7415TNode<Numeric> CodeStubAssembler::NonNumberToNumberOrNumeric(
  TNode<Context> context, TNode<HeapObject> input, Object::Conversion mode,
  BigIntHandling bigint_handling) {
CSA_DCHECK(this, Word32BinaryNot(IsHeapNumber(input)))((void)0);

TVARIABLE(HeapObject, var_input, input)TVariable<HeapObject> var_input(input, this);
TVARIABLE(Numeric, var_result)TVariable<Numeric> var_result(this);
TVARIABLE(Uint16T, instance_type, LoadInstanceType(var_input.value()))TVariable<Uint16T> instance_type(LoadInstanceType(var_input
.value()), this);
Label end(this), if_inputisreceiver(this, Label::kDeferred),
    if_inputisnotreceiver(this);

// We need to handle JSReceiver first since we might need to do two
// conversions due to ToPritmive.
Branch(IsJSReceiverInstanceType(instance_type.value()), &if_inputisreceiver,
       &if_inputisnotreceiver);

BIND(&if_inputisreceiver)Bind(&if_inputisreceiver);
{
  // The {var_input.value()} is a JSReceiver, we need to convert it to a
  // Primitive first using the ToPrimitive type conversion, preferably
  // yielding a Number.
  Callable callable = CodeFactory::NonPrimitiveToPrimitive(
      isolate(), ToPrimitiveHint::kNumber);
  TNode<Object> result = CallStub(callable, context, var_input.value());

  // Check if the {result} is already a Number/Numeric.
  Label if_done(this), if_notdone(this);
  Branch(mode == Object::Conversion::kToNumber ? IsNumber(result)
                                               : IsNumeric(result),
         &if_done, &if_notdone);

  BIND(&if_done)Bind(&if_done);
  {
    // The ToPrimitive conversion already gave us a Number/Numeric, so
    // we're done.
    var_result = CAST(result)Cast(result);
    Goto(&end);
  }

  BIND(&if_notdone)Bind(&if_notdone);
  {
    // We now have a Primitive {result}, but it's not yet a
    // Number/Numeric.
    var_input = CAST(result)Cast(result);
    // We have a new input. Redo the check and reload instance_type.
    CSA_DCHECK(this, Word32BinaryNot(IsHeapNumber(var_input.value())))((void)0);
    instance_type = LoadInstanceType(var_input.value());
    Goto(&if_inputisnotreceiver);
  }
}

BIND(&if_inputisnotreceiver)Bind(&if_inputisnotreceiver);
{
  Label not_plain_primitive(this), if_inputisbigint(this),
      if_inputisother(this, Label::kDeferred);

  // String and Oddball cases.
  TVARIABLE(Number, var_result_number)TVariable<Number> var_result_number(this);
  TryPlainPrimitiveNonNumberToNumber(var_input.value(), &var_result_number,
                                     &not_plain_primitive);
  var_result = var_result_number.value();
  Goto(&end);

  BIND(&not_plain_primitive)Bind(&not_plain_primitive);
  {
    Branch(IsBigIntInstanceType(instance_type.value()), &if_inputisbigint,
           &if_inputisother);

    BIND(&if_inputisbigint)Bind(&if_inputisbigint);
    {
      if (mode == Object::Conversion::kToNumeric) {
        var_result = CAST(var_input.value())Cast(var_input.value());
        Goto(&end);
      } else {
        DCHECK_EQ(mode, Object::Conversion::kToNumber)((void) 0);
        if (bigint_handling == BigIntHandling::kThrow) {
          Goto(&if_inputisother);
        } else {
          DCHECK_EQ(bigint_handling, BigIntHandling::kConvertToNumber)((void) 0);
          var_result = CAST(CallRuntime(Runtime::kBigIntToNumber, context,Cast(CallRuntime(Runtime::kBigIntToNumber, context, var_input
.value()))
                                        var_input.value()))Cast(CallRuntime(Runtime::kBigIntToNumber, context, var_input
.value()));
          Goto(&end);
        }
      }
    }

    BIND(&if_inputisother)Bind(&if_inputisother);
    {
      // The {var_input.value()} is something else (e.g. Symbol), let the
      // runtime figure out the correct exception. Note: We cannot tail call
      // to the runtime here, as js-to-wasm trampolines also use this code
      // currently, and they declare all outgoing parameters as untagged,
      // while we would push a tagged object here.
      auto function_id = mode == Object::Conversion::kToNumber
                             ? Runtime::kToNumber
                             : Runtime::kToNumeric;
      var_result = CAST(CallRuntime(function_id, context, var_input.value()))Cast(CallRuntime(function_id, context, var_input.value()));
      Goto(&end);
    }
  }
}

BIND(&end)Bind(&end);
if (mode == Object::Conversion::kToNumber) {
  CSA_DCHECK(this, IsNumber(var_result.value()))((void)0);
}
return var_result.value();
7522}

7524TNode<Number> CodeStubAssembler::NonNumberToNumber(
  TNode<Context> context, TNode<HeapObject> input,
  BigIntHandling bigint_handling) {
return CAST(NonNumberToNumberOrNumeric(Cast(NonNumberToNumberOrNumeric( context, input, Object::Conversion
::kToNumber, bigint_handling))
    context, input, Object::Conversion::kToNumber, bigint_handling))Cast(NonNumberToNumberOrNumeric( context, input, Object::Conversion
::kToNumber, bigint_handling));
7529}

7531void CodeStubAssembler::TryPlainPrimitiveNonNumberToNumber(
  TNode<HeapObject> input, TVariable<Number>* var_result, Label* if_bailout) {
CSA_DCHECK(this, Word32BinaryNot(IsHeapNumber(input)))((void)0);
Label done(this);

// Dispatch on the {input} instance type.
TNode<Uint16T> input_instance_type = LoadInstanceType(input);
Label if_inputisstring(this);
GotoIf(IsStringInstanceType(input_instance_type), &if_inputisstring);
GotoIfNot(InstanceTypeEqual(input_instance_type, ODDBALL_TYPE), if_bailout);

// The {input} is an Oddball, we just need to load the Number value of it.
*var_result = LoadObjectField<Number>(input, Oddball::kToNumberOffset);
Goto(&done);

BIND(&if_inputisstring)Bind(&if_inputisstring);
{
  // The {input} is a String, use the fast stub to convert it to a Number.
  *var_result = StringToNumber(CAST(input)Cast(input));
  Goto(&done);
}

BIND(&done)Bind(&done);
7554}

7556TNode<Numeric> CodeStubAssembler::NonNumberToNumeric(TNode<Context> context,
                                                   TNode<HeapObject> input) {
return NonNumberToNumberOrNumeric(context, input,
                                  Object::Conversion::kToNumeric);
7560}

7562TNode<Number> CodeStubAssembler::ToNumber(TNode<Context> context,
                                        TNode<Object> input,
                                        BigIntHandling bigint_handling) {
return CAST(ToNumberOrNumeric([context] { return context; }, input, nullptr,Cast(ToNumberOrNumeric([context] { return context; }, input, nullptr
, Object::Conversion::kToNumber, bigint_handling))
                              Object::Conversion::kToNumber,Cast(ToNumberOrNumeric([context] { return context; }, input, nullptr
, Object::Conversion::kToNumber, bigint_handling))
                              bigint_handling))Cast(ToNumberOrNumeric([context] { return context; }, input, nullptr
, Object::Conversion::kToNumber, bigint_handling));
7568}

7570TNode<Number> CodeStubAssembler::ToNumber_Inline(TNode<Context> context,
                                               TNode<Object> input) {
TVARIABLE(Number, var_result)TVariable<Number> var_result(this);
Label end(this), not_smi(this, Label::kDeferred);

GotoIfNot(TaggedIsSmi(input), &not_smi);
var_result = CAST(input)Cast(input);
Goto(&end);

BIND(&not_smi)Bind(&not_smi);
{
  var_result = Select<Number>(
      IsHeapNumber(CAST(input)Cast(input)), [=] { return CAST(input)Cast(input); },
      [=] {
        return CAST(CallBuiltin(Builtin::kNonNumberToNumber, context, input))Cast(CallBuiltin(Builtin::kNonNumberToNumber, context, input)
);
      });
  Goto(&end);
}

BIND(&end)Bind(&end);
return var_result.value();
7591}

7593TNode<Numeric> CodeStubAssembler::ToNumberOrNumeric(
  LazyNode<Context> context, TNode<Object> input,
  TVariable<Smi>* var_type_feedback, Object::Conversion mode,
  BigIntHandling bigint_handling) {
TVARIABLE(Numeric, var_result)TVariable<Numeric> var_result(this);
Label end(this);

Label not_smi(this, Label::kDeferred);
GotoIfNot(TaggedIsSmi(input), &not_smi);
TNode<Smi> input_smi = CAST(input)Cast(input);
var_result = input_smi;
if (var_type_feedback) {
  *var_type_feedback = SmiConstant(BinaryOperationFeedback::kSignedSmall);
}
Goto(&end);

BIND(&not_smi)Bind(&not_smi);
{
  Label not_heap_number(this, Label::kDeferred);
  TNode<HeapObject> input_ho = CAST(input)Cast(input);
  GotoIfNot(IsHeapNumber(input_ho), &not_heap_number);

  TNode<HeapNumber> input_hn = CAST(input_ho)Cast(input_ho);
  var_result = input_hn;
  if (var_type_feedback) {
    *var_type_feedback = SmiConstant(BinaryOperationFeedback::kNumber);
  }
  Goto(&end);

  BIND(&not_heap_number)Bind(&not_heap_number);
  {
    if (mode == Object::Conversion::kToNumeric) {
      // Special case for collecting BigInt feedback.
      Label not_bigint(this);
      GotoIfNot(IsBigInt(input_ho), &not_bigint);
      {
        var_result = CAST(input_ho)Cast(input_ho);
        *var_type_feedback = SmiConstant(BinaryOperationFeedback::kBigInt);
        Goto(&end);
      }
      BIND(&not_bigint)Bind(&not_bigint);
    }
    var_result = NonNumberToNumberOrNumeric(context(), input_ho, mode,
                                            bigint_handling);
    if (var_type_feedback) {
      *var_type_feedback = SmiConstant(BinaryOperationFeedback::kAny);
    }
    Goto(&end);
  }
}

BIND(&end)Bind(&end);
return var_result.value();
7646}

7648TNode<Number> CodeStubAssembler::PlainPrimitiveToNumber(TNode<Object> input) {
TVARIABLE(Number, var_result)TVariable<Number> var_result(this);
Label end(this), fallback(this);

Label not_smi(this, Label::kDeferred);
GotoIfNot(TaggedIsSmi(input), &not_smi);
TNode<Smi> input_smi = CAST(input)Cast(input);
var_result = input_smi;
Goto(&end);

BIND(&not_smi)Bind(&not_smi);
{
  Label not_heap_number(this, Label::kDeferred);
  TNode<HeapObject> input_ho = CAST(input)Cast(input);
  GotoIfNot(IsHeapNumber(input_ho), &not_heap_number);

  TNode<HeapNumber> input_hn = CAST(input_ho)Cast(input_ho);
  var_result = input_hn;
  Goto(&end);

  BIND(&not_heap_number)Bind(&not_heap_number);
  {
    TryPlainPrimitiveNonNumberToNumber(input_ho, &var_result, &fallback);
    Goto(&end);
    BIND(&fallback)Bind(&fallback);
    Unreachable();
  }
}

BIND(&end)Bind(&end);
return var_result.value();
7679}

7681TNode<BigInt> CodeStubAssembler::ToBigInt(TNode<Context> context,
                                        TNode<Object> input) {
TVARIABLE(BigInt, var_result)TVariable<BigInt> var_result(this);
Label if_bigint(this), done(this), if_throw(this);

GotoIf(TaggedIsSmi(input), &if_throw);
GotoIf(IsBigInt(CAST(input)Cast(input)), &if_bigint);
var_result = CAST(CallRuntime(Runtime::kToBigInt, context, input))Cast(CallRuntime(Runtime::kToBigInt, context, input));
Goto(&done);

BIND(&if_bigint)Bind(&if_bigint);
var_result = CAST(input)Cast(input);
Goto(&done);

BIND(&if_throw)Bind(&if_throw);
ThrowTypeError(context, MessageTemplate::kBigIntFromObject, input);

BIND(&done)Bind(&done);
return var_result.value();
7700}

7702void CodeStubAssembler::TaggedToNumeric(TNode<Context> context,
                                      TNode<Object> value,
                                      TVariable<Numeric>* var_numeric) {
TaggedToNumeric(context, value, var_numeric, nullptr);
7706}

7708void CodeStubAssembler::TaggedToNumericWithFeedback(
  TNode<Context> context, TNode<Object> value,
  TVariable<Numeric>* var_numeric, TVariable<Smi>* var_feedback) {
DCHECK_NOT_NULL(var_feedback)((void) 0);
TaggedToNumeric(context, value, var_numeric, var_feedback);
7713}

7715void CodeStubAssembler::TaggedToNumeric(TNode<Context> context,
                                      TNode<Object> value,
                                      TVariable<Numeric>* var_numeric,
                                      TVariable<Smi>* var_feedback) {
Label done(this), if_smi(this), if_heapnumber(this), if_bigint(this),
    if_oddball(this);
GotoIf(TaggedIsSmi(value), &if_smi);
TNode<HeapObject> heap_object_value = CAST(value)Cast(value);
TNode<Map> map = LoadMap(heap_object_value);
GotoIf(IsHeapNumberMap(map), &if_heapnumber);
TNode<Uint16T> instance_type = LoadMapInstanceType(map);
GotoIf(IsBigIntInstanceType(instance_type), &if_bigint);

// {heap_object_value} is not a Numeric yet.
GotoIf(Word32Equal(instance_type, Int32Constant(ODDBALL_TYPE)), &if_oddball);
*var_numeric = CAST(Cast(CallBuiltin(Builtin::kNonNumberToNumeric, context, heap_object_value
))
    CallBuiltin(Builtin::kNonNumberToNumeric, context, heap_object_value))Cast(CallBuiltin(Builtin::kNonNumberToNumeric, context, heap_object_value
));
OverwriteFeedback(var_feedback, BinaryOperationFeedback::kAny);
Goto(&done);

BIND(&if_smi)Bind(&if_smi);
*var_numeric = CAST(value)Cast(value);
OverwriteFeedback(var_feedback, BinaryOperationFeedback::kSignedSmall);
Goto(&done);

BIND(&if_heapnumber)Bind(&if_heapnumber);
*var_numeric = CAST(value)Cast(value);
OverwriteFeedback(var_feedback, BinaryOperationFeedback::kNumber);
Goto(&done);

BIND(&if_bigint)Bind(&if_bigint);
*var_numeric = CAST(value)Cast(value);
OverwriteFeedback(var_feedback, BinaryOperationFeedback::kBigInt);
Goto(&done);

BIND(&if_oddball)Bind(&if_oddball);
OverwriteFeedback(var_feedback, BinaryOperationFeedback::kNumberOrOddball);
*var_numeric =
    CAST(LoadObjectField(heap_object_value, Oddball::kToNumberOffset))Cast(LoadObjectField(heap_object_value, Oddball::kToNumberOffset
));
Goto(&done);

Bind(&done);
7757}

7759// ES#sec-touint32
7760TNode<Number> CodeStubAssembler::ToUint32(TNode<Context> context,
                                        TNode<Object> input) {
const TNode<Float64T> float_zero = Float64Constant(0.0);
const TNode<Float64T> float_two_32 =
    Float64Constant(static_cast<double>(1ULL << 32));

Label out(this);

TVARIABLE(Object, var_result, input)TVariable<Object> var_result(input, this);

// Early exit for positive smis.
{
  // TODO(jgruber): This branch and the recheck below can be removed once we
  // have a ToNumber with multiple exits.
  Label next(this, Label::kDeferred);
  Branch(TaggedIsPositiveSmi(input), &out, &next);
  BIND(&next)Bind(&next);
}

const TNode<Number> number = ToNumber(context, input);
var_result = number;

// Perhaps we have a positive smi now.
{
  Label next(this, Label::kDeferred);
  Branch(TaggedIsPositiveSmi(number), &out, &next);
  BIND(&next)Bind(&next);
}

Label if_isnegativesmi(this), if_isheapnumber(this);
Branch(TaggedIsSmi(number), &if_isnegativesmi, &if_isheapnumber);

BIND(&if_isnegativesmi)Bind(&if_isnegativesmi);
{
  const TNode<Int32T> uint32_value = SmiToInt32(CAST(number)Cast(number));
  TNode<Float64T> float64_value = ChangeUint32ToFloat64(uint32_value);
  var_result = AllocateHeapNumberWithValue(float64_value);
  Goto(&out);
}

BIND(&if_isheapnumber)Bind(&if_isheapnumber);
{
  Label return_zero(this);
  const TNode<Float64T> value = LoadHeapNumberValue(CAST(number)Cast(number));

  {
    // +-0.
    Label next(this);
    Branch(Float64Equal(value, float_zero), &return_zero, &next);
    BIND(&next)Bind(&next);
  }

  {
    // NaN.
    Label next(this);
    Branch(Float64Equal(value, value), &next, &return_zero);
    BIND(&next)Bind(&next);
  }

  {
    // +Infinity.
    Label next(this);
    const TNode<Float64T> positive_infinity =
        Float64Constant(std::numeric_limits<double>::infinity());
    Branch(Float64Equal(value, positive_infinity), &return_zero, &next);
    BIND(&next)Bind(&next);
  }

  {
    // -Infinity.
    Label next(this);
    const TNode<Float64T> negative_infinity =
        Float64Constant(-1.0 * std::numeric_limits<double>::infinity());
    Branch(Float64Equal(value, negative_infinity), &return_zero, &next);
    BIND(&next)Bind(&next);
  }

  // * Let int be the mathematical value that is the same sign as number and
  //   whose magnitude is floor(abs(number)).
  // * Let int32bit be int modulo 2^32.
  // * Return int32bit.
  {
    TNode<Float64T> x = Float64Trunc(value);
    x = Float64Mod(x, float_two_32);
    x = Float64Add(x, float_two_32);
    x = Float64Mod(x, float_two_32);

    const TNode<Number> result = ChangeFloat64ToTagged(x);
    var_result = result;
    Goto(&out);
  }

  BIND(&return_zero)Bind(&return_zero);
  {
    var_result = SmiConstant(0);
    Goto(&out);
  }
}

BIND(&out)Bind(&out);
return CAST(var_result.value())Cast(var_result.value());
7861}

7863TNode<String> CodeStubAssembler::ToString_Inline(TNode<Context> context,
                                               TNode<Object> input) {
TVARIABLE(Object, var_result, input)TVariable<Object> var_result(input, this);
Label stub_call(this, Label::kDeferred), out(this);

GotoIf(TaggedIsSmi(input), &stub_call);
Branch(IsString(CAST(input)Cast(input)), &out, &stub_call);

BIND(&stub_call)Bind(&stub_call);
var_result = CallBuiltin(Builtin::kToString, context, input);
Goto(&out);

BIND(&out)Bind(&out);
return CAST(var_result.value())Cast(var_result.value());
7877}

7879TNode<JSReceiver> CodeStubAssembler::ToObject(TNode<Context> context,
                                            TNode<Object> input) {
return CAST(CallBuiltin(Builtin::kToObject, context, input))Cast(CallBuiltin(Builtin::kToObject, context, input));
7882}

7884TNode<JSReceiver> CodeStubAssembler::ToObject_Inline(TNode<Context> context,
                                                   TNode<Object> input) {
TVARIABLE(JSReceiver, result)TVariable<JSReceiver> result(this);
Label if_isreceiver(this), if_isnotreceiver(this, Label::kDeferred);
Label done(this);

BranchIfJSReceiver(input, &if_isreceiver, &if_isnotreceiver);

BIND(&if_isreceiver)Bind(&if_isreceiver);
{
  result = CAST(input)Cast(input);
  Goto(&done);
}

BIND(&if_isnotreceiver)Bind(&if_isnotreceiver);
{
  result = ToObject(context, input);
  Goto(&done);
}

BIND(&done)Bind(&done);
return result.value();
7906}

7908TNode<Number> CodeStubAssembler::ToLength_Inline(TNode<Context> context,
                                               TNode<Object> input) {
TNode<Smi> smi_zero = SmiConstant(0);
return Select<Number>(
    TaggedIsSmi(input), [=] { return SmiMax(CAST(input)Cast(input), smi_zero); },
    [=] { return CAST(CallBuiltin(Builtin::kToLength, context, input))Cast(CallBuiltin(Builtin::kToLength, context, input)); });
7914}

7916TNode<Object> CodeStubAssembler::OrdinaryToPrimitive(
  TNode<Context> context, TNode<Object> input, OrdinaryToPrimitiveHint hint) {
Callable callable = CodeFactory::OrdinaryToPrimitive(isolate(), hint);
return CallStub(callable, context, input);
7920}

7922TNode<Uint32T> CodeStubAssembler::DecodeWord32(TNode<Word32T> word32,
                                             uint32_t shift, uint32_t mask) {
DCHECK_EQ((mask >> shift) << shift, mask)((void) 0);
if ((std::numeric_limits<uint32_t>::max() >> shift) ==
    ((std::numeric_limits<uint32_t>::max() & mask) >> shift)) {
  return Unsigned(Word32Shr(word32, static_cast<int>(shift)));
} else {
  return Unsigned(Word32And(Word32Shr(word32, static_cast<int>(shift)),
                            Int32Constant(mask >> shift)));
}
7932}

7934TNode<UintPtrT> CodeStubAssembler::DecodeWord(TNode<WordT> word, uint32_t shift,
                                            uintptr_t mask) {
DCHECK_EQ((mask >> shift) << shift, mask)((void) 0);
if ((std::numeric_limits<uintptr_t>::max() >> shift) ==
    ((std::numeric_limits<uintptr_t>::max() & mask) >> shift)) {
  return Unsigned(WordShr(word, static_cast<int>(shift)));
} else {
  return Unsigned(WordAnd(WordShr(word, static_cast<int>(shift)),
                          IntPtrConstant(mask >> shift)));
}
7944}

7946TNode<Word32T> CodeStubAssembler::UpdateWord32(TNode<Word32T> word,
                                             TNode<Uint32T> value,
                                             uint32_t shift, uint32_t mask,
                                             bool starts_as_zero) {
DCHECK_EQ((mask >> shift) << shift, mask)((void) 0);
// Ensure the {value} fits fully in the mask.
CSA_DCHECK(this, Uint32LessThanOrEqual(value, Uint32Constant(mask >> shift)))((void)0);
TNode<Word32T> encoded_value = Word32Shl(value, Int32Constant(shift));
TNode<Word32T> masked_word;
if (starts_as_zero) {
  CSA_DCHECK(this, Word32Equal(Word32And(word, Int32Constant(~mask)), word))((void)0);
  masked_word = word;
} else {
  masked_word = Word32And(word, Int32Constant(~mask));
}
return Word32Or(masked_word, encoded_value);
7962}

7964TNode<WordT> CodeStubAssembler::UpdateWord(TNode<WordT> word,
                                         TNode<UintPtrT> value,
                                         uint32_t shift, uintptr_t mask,
                                         bool starts_as_zero) {
DCHECK_EQ((mask >> shift) << shift, mask)((void) 0);
// Ensure the {value} fits fully in the mask.
CSA_DCHECK(this,((void)0)
           UintPtrLessThanOrEqual(value, UintPtrConstant(mask >> shift)))((void)0);
TNode<WordT> encoded_value = WordShl(value, static_cast<int>(shift));
TNode<WordT> masked_word;
if (starts_as_zero) {
  CSA_DCHECK(this, WordEqual(WordAnd(word, UintPtrConstant(~mask)), word))((void)0);
  masked_word = word;
} else {
  masked_word = WordAnd(word, UintPtrConstant(~mask));
}
return WordOr(masked_word, encoded_value);
7981}

7983void CodeStubAssembler::SetCounter(StatsCounter* counter, int value) {
if (FLAG_native_code_counters && counter->Enabled()) {
  TNode<ExternalReference> counter_address =
      ExternalConstant(ExternalReference::Create(counter));
  StoreNoWriteBarrier(MachineRepresentation::kWord32, counter_address,
                      Int32Constant(value));
}
7990}

7992void CodeStubAssembler::IncrementCounter(StatsCounter* counter, int delta) {
DCHECK_GT(delta, 0)((void) 0);
if (FLAG_native_code_counters && counter->Enabled()) {
  TNode<ExternalReference> counter_address =
      ExternalConstant(ExternalReference::Create(counter));
  // This operation has to be exactly 32-bit wide in case the external
  // reference table redirects the counter to a uint32_t dummy_stats_counter_
  // field.
  TNode<Int32T> value = Load<Int32T>(counter_address);
  value = Int32Add(value, Int32Constant(delta));
  StoreNoWriteBarrier(MachineRepresentation::kWord32, counter_address, value);
}
8004}

8006void CodeStubAssembler::DecrementCounter(StatsCounter* counter, int delta) {
DCHECK_GT(delta, 0)((void) 0);
if (FLAG_native_code_counters && counter->Enabled()) {
  TNode<ExternalReference> counter_address =
      ExternalConstant(ExternalReference::Create(counter));
  // This operation has to be exactly 32-bit wide in case the external
  // reference table redirects the counter to a uint32_t dummy_stats_counter_
  // field.
  TNode<Int32T> value = Load<Int32T>(counter_address);
  value = Int32Sub(value, Int32Constant(delta));
  StoreNoWriteBarrier(MachineRepresentation::kWord32, counter_address, value);
}
8018}

8020template <typename TIndex>
8021void CodeStubAssembler::Increment(TVariable<TIndex>* variable, int value) {
*variable =
    IntPtrOrSmiAdd(variable->value(), IntPtrOrSmiConstant<TIndex>(value));
8024}

8026// Instantiate Increment for Smi and IntPtrT.
8027// TODO(v8:9708): Consider renaming to [Smi|IntPtrT|RawPtrT]Increment.
8028template void CodeStubAssembler::Increment<Smi>(TVariable<Smi>* variable,
                                              int value);
8030template void CodeStubAssembler::Increment<IntPtrT>(
  TVariable<IntPtrT>* variable, int value);
8032template void CodeStubAssembler::Increment<RawPtrT>(
  TVariable<RawPtrT>* variable, int value);

8035void CodeStubAssembler::Use(Label* label) {
GotoIf(Word32Equal(Int32Constant(0), Int32Constant(1)), label);
8037}

8039void CodeStubAssembler::TryToName(TNode<Object> key, Label* if_keyisindex,
                                TVariable<IntPtrT>* var_index,
                                Label* if_keyisunique,
                                TVariable<Name>* var_unique,
                                Label* if_bailout,
                                Label* if_notinternalized) {
Comment("TryToName");

TVARIABLE(Int32T, var_instance_type)TVariable<Int32T> var_instance_type(this);
Label if_keyisnotindex(this);
*var_index = TryToIntptr(key, &if_keyisnotindex, &var_instance_type);
Goto(if_keyisindex);

BIND(&if_keyisnotindex)Bind(&if_keyisnotindex);
{
  Label if_symbol(this), if_string(this),
      if_keyisother(this, Label::kDeferred);

  // Symbols are unique.
  GotoIf(IsSymbolInstanceType(var_instance_type.value()), &if_symbol);

  // Miss if |key| is not a String.
  STATIC_ASSERT(FIRST_NAME_TYPE == FIRST_TYPE)static_assert(FIRST_NAME_TYPE == FIRST_TYPE, "FIRST_NAME_TYPE == FIRST_TYPE"
);
  Branch(IsStringInstanceType(var_instance_type.value()), &if_string,
         &if_keyisother);

  // Symbols are unique.
  BIND(&if_symbol)Bind(&if_symbol);
  {
    *var_unique = CAST(key)Cast(key);
    Goto(if_keyisunique);
  }

  BIND(&if_string)Bind(&if_string);
  {
    Label if_thinstring(this), if_has_cached_index(this);

    TNode<Uint32T> raw_hash_field = LoadNameRawHashField(CAST(key)Cast(key));
    GotoIf(IsClearWord32(raw_hash_field,
                         Name::kDoesNotContainCachedArrayIndexMask),
           &if_has_cached_index);
    // No cached array index. If the string knows that it contains an index,
    // then it must be an uncacheable index. Handle this case in the runtime.
    GotoIf(IsEqualInWord32<Name::HashFieldTypeBits>(
               raw_hash_field, Name::HashFieldType::kIntegerIndex),
           if_bailout);

    GotoIf(InstanceTypeEqual(var_instance_type.value(), THIN_STRING_TYPE),
           &if_thinstring);
    GotoIf(InstanceTypeEqual(var_instance_type.value(),
                             THIN_ONE_BYTE_STRING_TYPE),
           &if_thinstring);
    // Finally, check if |key| is internalized.
    STATIC_ASSERT(kNotInternalizedTag != 0)static_assert(kNotInternalizedTag != 0, "kNotInternalizedTag != 0"
);
    GotoIf(IsSetWord32(var_instance_type.value(), kIsNotInternalizedMask),
           if_notinternalized != nullptr ? if_notinternalized : if_bailout);

    *var_unique = CAST(key)Cast(key);
    Goto(if_keyisunique);

    BIND(&if_thinstring)Bind(&if_thinstring);
    {
      *var_unique =
          LoadObjectField<String>(CAST(key)Cast(key), ThinString::kActualOffset);
      Goto(if_keyisunique);
    }

    BIND(&if_has_cached_index)Bind(&if_has_cached_index);
    {
      TNode<IntPtrT> index = Signed(
          DecodeWordFromWord32<String::ArrayIndexValueBits>(raw_hash_field));
      CSA_DCHECK(this, IntPtrLessThan(index, IntPtrConstant(INT_MAX)))((void)0);
      *var_index = index;
      Goto(if_keyisindex);
    }
  }

  BIND(&if_keyisother)Bind(&if_keyisother);
  {
    GotoIfNot(InstanceTypeEqual(var_instance_type.value(), ODDBALL_TYPE),
              if_bailout);
    *var_unique =
        LoadObjectField<String>(CAST(key)Cast(key), Oddball::kToStringOffset);
    Goto(if_keyisunique);
  }
}
8125}

8127void CodeStubAssembler::StringWriteToFlatOneByte(TNode<String> source,
                                               TNode<RawPtrT> sink,
                                               TNode<Int32T> start,
                                               TNode<Int32T> length) {
TNode<ExternalReference> function =
    ExternalConstant(ExternalReference::string_write_to_flat_one_byte());
CallCFunction(function, base::nullopt,
              std::make_pair(MachineType::AnyTagged(), source),
              std::make_pair(MachineType::Pointer(), sink),
              std::make_pair(MachineType::Int32(), start),
              std::make_pair(MachineType::Int32(), length));
8138}

8140void CodeStubAssembler::StringWriteToFlatTwoByte(TNode<String> source,
                                               TNode<RawPtrT> sink,
                                               TNode<Int32T> start,
                                               TNode<Int32T> length) {
TNode<ExternalReference> function =
    ExternalConstant(ExternalReference::string_write_to_flat_two_byte());
CallCFunction(function, base::nullopt,
              std::make_pair(MachineType::AnyTagged(), source),
              std::make_pair(MachineType::Pointer(), sink),
              std::make_pair(MachineType::Int32(), start),
              std::make_pair(MachineType::Int32(), length));
8151}

8153TNode<RawPtr<Uint8T>> CodeStubAssembler::ExternalOneByteStringGetChars(
  TNode<ExternalOneByteString> string) {
TNode<ExternalReference> function =
    ExternalConstant(ExternalReference::external_one_byte_string_get_chars());
return UncheckedCast<RawPtr<Uint8T>>(
    CallCFunction(function, MachineType::Pointer(),
                  std::make_pair(MachineType::AnyTagged(), string)));
8160}

8162TNode<RawPtr<Uint16T>> CodeStubAssembler::ExternalTwoByteStringGetChars(
  TNode<ExternalTwoByteString> string) {
TNode<ExternalReference> function =
    ExternalConstant(ExternalReference::external_two_byte_string_get_chars());
return UncheckedCast<RawPtr<Uint16T>>(
    CallCFunction(function, MachineType::Pointer(),
                  std::make_pair(MachineType::AnyTagged(), string)));
8169}

8171TNode<RawPtr<Uint8T>> CodeStubAssembler::IntlAsciiCollationWeightsL1() {
8172#ifdef V8_INTL_SUPPORT1
TNode<RawPtrT> ptr =
    ExternalConstant(ExternalReference::intl_ascii_collation_weights_l1());
return ReinterpretCast<RawPtr<Uint8T>>(ptr);
8176#else
UNREACHABLE()V8_Fatal("unreachable code");
8178#endif
8179}
8180TNode<RawPtr<Uint8T>> CodeStubAssembler::IntlAsciiCollationWeightsL3() {
8181#ifdef V8_INTL_SUPPORT1
TNode<RawPtrT> ptr =
    ExternalConstant(ExternalReference::intl_ascii_collation_weights_l3());
return ReinterpretCast<RawPtr<Uint8T>>(ptr);
8185#else
UNREACHABLE()V8_Fatal("unreachable code");
8187#endif
8188}

8190void CodeStubAssembler::TryInternalizeString(
  TNode<String> string, Label* if_index, TVariable<IntPtrT>* var_index,
  Label* if_internalized, TVariable<Name>* var_internalized,
  Label* if_not_internalized, Label* if_bailout) {
TNode<ExternalReference> function = ExternalConstant(
    ExternalReference::try_string_to_index_or_lookup_existing());
const TNode<ExternalReference> isolate_ptr =
    ExternalConstant(ExternalReference::isolate_address(isolate()));
TNode<Object> result =
    CAST(CallCFunction(function, MachineType::AnyTagged(),Cast(CallCFunction(function, MachineType::AnyTagged(), std::make_pair
(MachineType::Pointer(), isolate_ptr), std::make_pair(MachineType
::AnyTagged(), string)))
                       std::make_pair(MachineType::Pointer(), isolate_ptr),Cast(CallCFunction(function, MachineType::AnyTagged(), std::make_pair
(MachineType::Pointer(), isolate_ptr), std::make_pair(MachineType
::AnyTagged(), string)))
                       std::make_pair(MachineType::AnyTagged(), string)))Cast(CallCFunction(function, MachineType::AnyTagged(), std::make_pair
(MachineType::Pointer(), isolate_ptr), std::make_pair(MachineType
::AnyTagged(), string)));
Label internalized(this);
GotoIf(TaggedIsNotSmi(result), &internalized);
TNode<IntPtrT> word_result = SmiUntag(CAST(result)Cast(result));
GotoIf(IntPtrEqual(word_result, IntPtrConstant(ResultSentinel::kNotFound)),
       if_not_internalized);
GotoIf(IntPtrEqual(word_result, IntPtrConstant(ResultSentinel::kUnsupported)),
       if_bailout);
*var_index = word_result;
Goto(if_index);

BIND(&internalized)Bind(&internalized);
*var_internalized = CAST(result)Cast(result);
Goto(if_internalized);
8215}

8217template <typename Dictionary>
8218TNode<IntPtrT> CodeStubAssembler::EntryToIndex(TNode<IntPtrT> entry,
                                             int field_index) {
TNode<IntPtrT> entry_index =
    IntPtrMul(entry, IntPtrConstant(Dictionary::kEntrySize));
return IntPtrAdd(entry_index, IntPtrConstant(Dictionary::kElementsStartIndex +
                                             field_index));
8224}

8226template <typename T>
8227TNode<T> CodeStubAssembler::LoadDescriptorArrayElement(
  TNode<DescriptorArray> object, TNode<IntPtrT> index,
  int additional_offset) {
return LoadArrayElement<DescriptorArray, IntPtrT, T>(
    object, DescriptorArray::kHeaderSize, index, additional_offset);
8232}

8234TNode<Name> CodeStubAssembler::LoadKeyByKeyIndex(
  TNode<DescriptorArray> container, TNode<IntPtrT> key_index) {
return CAST(LoadDescriptorArrayElement<HeapObject>(container, key_index, 0))Cast(LoadDescriptorArrayElement<HeapObject>(container, key_index
, 0));
8237}

8239TNode<Uint32T> CodeStubAssembler::LoadDetailsByKeyIndex(
  TNode<DescriptorArray> container, TNode<IntPtrT> key_index) {
const int kKeyToDetailsOffset =
    DescriptorArray::kEntryDetailsOffset - DescriptorArray::kEntryKeyOffset;
return Unsigned(LoadAndUntagToWord32ArrayElement(
    container, DescriptorArray::kHeaderSize, key_index, kKeyToDetailsOffset));
8245}

8247TNode<Object> CodeStubAssembler::LoadValueByKeyIndex(
  TNode<DescriptorArray> container, TNode<IntPtrT> key_index) {
const int kKeyToValueOffset =
    DescriptorArray::kEntryValueOffset - DescriptorArray::kEntryKeyOffset;
return LoadDescriptorArrayElement<Object>(container, key_index,
                                          kKeyToValueOffset);
8253}

8255TNode<MaybeObject> CodeStubAssembler::LoadFieldTypeByKeyIndex(
  TNode<DescriptorArray> container, TNode<IntPtrT> key_index) {
const int kKeyToValueOffset =
    DescriptorArray::kEntryValueOffset - DescriptorArray::kEntryKeyOffset;
return LoadDescriptorArrayElement<MaybeObject>(container, key_index,
                                               kKeyToValueOffset);
8261}

8263TNode<IntPtrT> CodeStubAssembler::DescriptorEntryToIndex(
  TNode<IntPtrT> descriptor_entry) {
return IntPtrMul(descriptor_entry,
                 IntPtrConstant(DescriptorArray::kEntrySize));
8267}

8269TNode<Name> CodeStubAssembler::LoadKeyByDescriptorEntry(
  TNode<DescriptorArray> container, TNode<IntPtrT> descriptor_entry) {
return CAST(LoadDescriptorArrayElement<HeapObject>(Cast(LoadDescriptorArrayElement<HeapObject>( container,
 DescriptorEntryToIndex(descriptor_entry), DescriptorArray::ToKeyIndex
(0) * kTaggedSize))
    container, DescriptorEntryToIndex(descriptor_entry),Cast(LoadDescriptorArrayElement<HeapObject>( container,
 DescriptorEntryToIndex(descriptor_entry), DescriptorArray::ToKeyIndex
(0) * kTaggedSize))
    DescriptorArray::ToKeyIndex(0) * kTaggedSize))Cast(LoadDescriptorArrayElement<HeapObject>( container,
 DescriptorEntryToIndex(descriptor_entry), DescriptorArray::ToKeyIndex
(0) * kTaggedSize));
8274}

8276TNode<Name> CodeStubAssembler::LoadKeyByDescriptorEntry(
  TNode<DescriptorArray> container, int descriptor_entry) {
return CAST(LoadDescriptorArrayElement<HeapObject>(Cast(LoadDescriptorArrayElement<HeapObject>( container,
 IntPtrConstant(0), DescriptorArray::ToKeyIndex(descriptor_entry
) * kTaggedSize))
    container, IntPtrConstant(0),Cast(LoadDescriptorArrayElement<HeapObject>( container,
 IntPtrConstant(0), DescriptorArray::ToKeyIndex(descriptor_entry
) * kTaggedSize))
    DescriptorArray::ToKeyIndex(descriptor_entry) * kTaggedSize))Cast(LoadDescriptorArrayElement<HeapObject>( container,
 IntPtrConstant(0), DescriptorArray::ToKeyIndex(descriptor_entry
) * kTaggedSize));
8281}

8283TNode<Uint32T> CodeStubAssembler::LoadDetailsByDescriptorEntry(
  TNode<DescriptorArray> container, TNode<IntPtrT> descriptor_entry) {
return Unsigned(LoadAndUntagToWord32ArrayElement(
    container, DescriptorArray::kHeaderSize,
    DescriptorEntryToIndex(descriptor_entry),
    DescriptorArray::ToDetailsIndex(0) * kTaggedSize));
8289}

8291TNode<Uint32T> CodeStubAssembler::LoadDetailsByDescriptorEntry(
  TNode<DescriptorArray> container, int descriptor_entry) {
return Unsigned(LoadAndUntagToWord32ArrayElement(
    container, DescriptorArray::kHeaderSize, IntPtrConstant(0),
    DescriptorArray::ToDetailsIndex(descriptor_entry) * kTaggedSize));
8296}

8298TNode<Object> CodeStubAssembler::LoadValueByDescriptorEntry(
  TNode<DescriptorArray> container, TNode<IntPtrT> descriptor_entry) {
return LoadDescriptorArrayElement<Object>(
    container, DescriptorEntryToIndex(descriptor_entry),
    DescriptorArray::ToValueIndex(0) * kTaggedSize);
8303}

8305TNode<Object> CodeStubAssembler::LoadValueByDescriptorEntry(
  TNode<DescriptorArray> container, int descriptor_entry) {
return LoadDescriptorArrayElement<Object>(
    container, IntPtrConstant(0),
    DescriptorArray::ToValueIndex(descriptor_entry) * kTaggedSize);
8310}

8312TNode<MaybeObject> CodeStubAssembler::LoadFieldTypeByDescriptorEntry(
  TNode<DescriptorArray> container, TNode<IntPtrT> descriptor_entry) {
return LoadDescriptorArrayElement<MaybeObject>(
    container, DescriptorEntryToIndex(descriptor_entry),
    DescriptorArray::ToValueIndex(0) * kTaggedSize);
8317}

8319// Loads the value for the entry with the given key_index.
8320// Returns a tagged value.
8321template <class ContainerType>
8322TNode<Object> CodeStubAssembler::LoadValueByKeyIndex(
  TNode<ContainerType> container, TNode<IntPtrT> key_index) {
static_assert(!std::is_same<ContainerType, DescriptorArray>::value,
              "Use the non-templatized version for DescriptorArray");
const int kKeyToValueOffset =
    (ContainerType::kEntryValueIndex - ContainerType::kEntryKeyIndex) *
    kTaggedSize;
return LoadFixedArrayElement(container, key_index, kKeyToValueOffset);
8330}

8332template <>
8333V8_EXPORT_PRIVATE TNode<Object> CodeStubAssembler::LoadValueByKeyIndex(
  TNode<SwissNameDictionary> container, TNode<IntPtrT> key_index) {
TNode<IntPtrT> offset_minus_tag = SwissNameDictionaryOffsetIntoDataTableMT(
    container, key_index, SwissNameDictionary::kDataTableValueEntryIndex);

return Load<Object>(container, offset_minus_tag);
8339}

8341template <class ContainerType>
8342TNode<Uint32T> CodeStubAssembler::LoadDetailsByKeyIndex(
  TNode<ContainerType> container, TNode<IntPtrT> key_index) {
static_assert(!std::is_same<ContainerType, DescriptorArray>::value,
              "Use the non-templatized version for DescriptorArray");
const int kKeyToDetailsOffset =
    (ContainerType::kEntryDetailsIndex - ContainerType::kEntryKeyIndex) *
    kTaggedSize;
return Unsigned(LoadAndUntagToWord32FixedArrayElement(container, key_index,
                                                      kKeyToDetailsOffset));
8351}

8353template <>
8354V8_EXPORT_PRIVATE TNode<Uint32T> CodeStubAssembler::LoadDetailsByKeyIndex(
  TNode<SwissNameDictionary> container, TNode<IntPtrT> key_index) {
TNode<IntPtrT> capacity =
    ChangeInt32ToIntPtr(LoadSwissNameDictionaryCapacity(container));
return LoadSwissNameDictionaryPropertyDetails(container, capacity, key_index);
8359}

8361// Stores the details for the entry with the given key_index.
8362// |details| must be a Smi.
8363template <class ContainerType>
8364void CodeStubAssembler::StoreDetailsByKeyIndex(TNode<ContainerType> container,
                                             TNode<IntPtrT> key_index,
                                             TNode<Smi> details) {
const int kKeyToDetailsOffset =
    (ContainerType::kEntryDetailsIndex - ContainerType::kEntryKeyIndex) *
    kTaggedSize;
StoreFixedArrayElement(container, key_index, details, kKeyToDetailsOffset);
8371}

8373template <>
8374V8_EXPORT_PRIVATE void CodeStubAssembler::StoreDetailsByKeyIndex(
  TNode<SwissNameDictionary> container, TNode<IntPtrT> key_index,
  TNode<Smi> details) {
TNode<IntPtrT> capacity =
    ChangeInt32ToIntPtr(LoadSwissNameDictionaryCapacity(container));
TNode<Uint8T> details_byte = UncheckedCast<Uint8T>(SmiToInt32(details));
StoreSwissNameDictionaryPropertyDetails(container, capacity, key_index,
                                        details_byte);
8382}

8384// Stores the value for the entry with the given key_index.
8385template <class ContainerType>
8386void CodeStubAssembler::StoreValueByKeyIndex(TNode<ContainerType> container,
                                           TNode<IntPtrT> key_index,
                                           TNode<Object> value,
                                           WriteBarrierMode write_barrier) {
const int kKeyToValueOffset =
    (ContainerType::kEntryValueIndex - ContainerType::kEntryKeyIndex) *
    kTaggedSize;
StoreFixedArrayElement(container, key_index, value, write_barrier,
                       kKeyToValueOffset);
8395}

8397template <>
8398V8_EXPORT_PRIVATE void CodeStubAssembler::StoreValueByKeyIndex(
  TNode<SwissNameDictionary> container, TNode<IntPtrT> key_index,
  TNode<Object> value, WriteBarrierMode write_barrier) {
TNode<IntPtrT> offset_minus_tag = SwissNameDictionaryOffsetIntoDataTableMT(
    container, key_index, SwissNameDictionary::kDataTableValueEntryIndex);

StoreToObjectWriteBarrier mode;
switch (write_barrier) {
  case UNSAFE_SKIP_WRITE_BARRIER:
  case SKIP_WRITE_BARRIER:
    mode = StoreToObjectWriteBarrier::kNone;
    break;
  case UPDATE_WRITE_BARRIER:
    mode = StoreToObjectWriteBarrier::kFull;
    break;
  default:
    // We shouldn't see anything else.
    UNREACHABLE()V8_Fatal("unreachable code");
}
StoreToObject(MachineRepresentation::kTagged, container, offset_minus_tag,
              value, mode);
8419}

8421template V8_EXPORT_PRIVATE TNode<IntPtrT>
8422CodeStubAssembler::EntryToIndex<NameDictionary>(TNode<IntPtrT>, int);
8423template V8_EXPORT_PRIVATE TNode<IntPtrT>
8424CodeStubAssembler::EntryToIndex<GlobalDictionary>(TNode<IntPtrT>, int);
8425template V8_EXPORT_PRIVATE TNode<IntPtrT>
8426CodeStubAssembler::EntryToIndex<NumberDictionary>(TNode<IntPtrT>, int);

8428template TNode<Object> CodeStubAssembler::LoadValueByKeyIndex(
  TNode<NameDictionary> container, TNode<IntPtrT> key_index);
8430template TNode<Object> CodeStubAssembler::LoadValueByKeyIndex(
  TNode<GlobalDictionary> container, TNode<IntPtrT> key_index);
8432template TNode<Uint32T> CodeStubAssembler::LoadDetailsByKeyIndex(
  TNode<NameDictionary> container, TNode<IntPtrT> key_index);
8434template void CodeStubAssembler::StoreDetailsByKeyIndex(
  TNode<NameDictionary> container, TNode<IntPtrT> key_index,
  TNode<Smi> details);
8437template void CodeStubAssembler::StoreValueByKeyIndex(
  TNode<NameDictionary> container, TNode<IntPtrT> key_index,
  TNode<Object> value, WriteBarrierMode write_barrier);

8441// This must be kept in sync with HashTableBase::ComputeCapacity().
8442TNode<IntPtrT> CodeStubAssembler::HashTableComputeCapacity(
  TNode<IntPtrT> at_least_space_for) {
TNode<IntPtrT> capacity = IntPtrRoundUpToPowerOfTwo32(
    IntPtrAdd(at_least_space_for, WordShr(at_least_space_for, 1)));
return IntPtrMax(capacity, IntPtrConstant(HashTableBase::kMinCapacity));
8447}

8449TNode<IntPtrT> CodeStubAssembler::IntPtrMax(TNode<IntPtrT> left,
                                          TNode<IntPtrT> right) {
intptr_t left_constant;
intptr_t right_constant;
if (TryToIntPtrConstant(left, &left_constant) &&
    TryToIntPtrConstant(right, &right_constant)) {
  return IntPtrConstant(std::max(left_constant, right_constant));
}
return SelectConstant<IntPtrT>(IntPtrGreaterThanOrEqual(left, right), left,
                               right);
8459}

8461TNode<IntPtrT> CodeStubAssembler::IntPtrMin(TNode<IntPtrT> left,
                                          TNode<IntPtrT> right) {
intptr_t left_constant;
intptr_t right_constant;
if (TryToIntPtrConstant(left, &left_constant) &&
    TryToIntPtrConstant(right, &right_constant)) {
  return IntPtrConstant(std::min(left_constant, right_constant));
}
return SelectConstant<IntPtrT>(IntPtrLessThanOrEqual(left, right), left,
                               right);
8471}

8473TNode<UintPtrT> CodeStubAssembler::UintPtrMin(TNode<UintPtrT> left,
                                            TNode<UintPtrT> right) {
intptr_t left_constant;
intptr_t right_constant;
if (TryToIntPtrConstant(left, &left_constant) &&
    TryToIntPtrConstant(right, &right_constant)) {
  return UintPtrConstant(std::min(static_cast<uintptr_t>(left_constant),
                                  static_cast<uintptr_t>(right_constant)));
}
return SelectConstant<UintPtrT>(UintPtrLessThanOrEqual(left, right), left,
                                right);
8484}

8486template <>
8487TNode<HeapObject> CodeStubAssembler::LoadName<NameDictionary>(
  TNode<HeapObject> key) {
CSA_DCHECK(this, Word32Or(IsTheHole(key), IsName(key)))((void)0);
return key;
8491}

8493template <>
8494TNode<HeapObject> CodeStubAssembler::LoadName<GlobalDictionary>(
  TNode<HeapObject> key) {
TNode<PropertyCell> property_cell = CAST(key)Cast(key);
return CAST(LoadObjectField(property_cell, PropertyCell::kNameOffset))Cast(LoadObjectField(property_cell, PropertyCell::kNameOffset
));
8498}

8500template <>
8501TNode<HeapObject> CodeStubAssembler::LoadName<NameToIndexHashTable>(
  TNode<HeapObject> key) {
CSA_DCHECK(this, IsName(key))((void)0);
return key;
8505}

8507// The implementation should be in sync with NameToIndexHashTable::Lookup.
8508TNode<IntPtrT> CodeStubAssembler::NameToIndexHashTableLookup(
  TNode<NameToIndexHashTable> table, TNode<Name> name, Label* not_found) {
TVARIABLE(IntPtrT, var_entry)TVariable<IntPtrT> var_entry(this);
Label index_found(this, {&var_entry});
NameDictionaryLookup<NameToIndexHashTable>(table, name, &index_found,
                                           &var_entry, not_found,
                                           LookupMode::kFindExisting);
BIND(&index_found)Bind(&index_found);
TNode<Smi> value =
    CAST(LoadValueByKeyIndex<NameToIndexHashTable>(table, var_entry.value()))Cast(LoadValueByKeyIndex<NameToIndexHashTable>(table, var_entry
.value()));
return SmiToIntPtr(value);
8519}

8521template <typename Dictionary>
8522void CodeStubAssembler::NameDictionaryLookup(
  TNode<Dictionary> dictionary, TNode<Name> unique_name, Label* if_found,
  TVariable<IntPtrT>* var_name_index, Label* if_not_found, LookupMode mode) {
static_assert(std::is_same<Dictionary, NameDictionary>::value ||
                  std::is_same<Dictionary, GlobalDictionary>::value ||
                  std::is_same<Dictionary, NameToIndexHashTable>::value,
              "Unexpected NameDictionary");
DCHECK_EQ(MachineType::PointerRepresentation(), var_name_index->rep())((void) 0);
DCHECK_IMPLIES(mode == kFindInsertionIndex, if_found == nullptr)((void) 0);
Comment("NameDictionaryLookup");
CSA_DCHECK(this, IsUniqueName(unique_name))((void)0);

TNode<IntPtrT> capacity = SmiUntag(GetCapacity<Dictionary>(dictionary));
TNode<IntPtrT> mask = IntPtrSub(capacity, IntPtrConstant(1));
TNode<UintPtrT> hash = ChangeUint32ToWord(LoadNameHash(unique_name));

// See Dictionary::FirstProbe().
TNode<IntPtrT> count = IntPtrConstant(0);
TNode<IntPtrT> initial_entry = Signed(WordAnd(hash, mask));
TNode<Oddball> undefined = UndefinedConstant();

// Appease the variable merging algorithm for "Goto(&loop)" below.
*var_name_index = IntPtrConstant(0);

TVARIABLE(IntPtrT, var_count, count)TVariable<IntPtrT> var_count(count, this);
TVARIABLE(IntPtrT, var_entry, initial_entry)TVariable<IntPtrT> var_entry(initial_entry, this);
Label loop(this, {&var_count, &var_entry, var_name_index});
Goto(&loop);
BIND(&loop)Bind(&loop);
{
  Label next_probe(this);
  TNode<IntPtrT> entry = var_entry.value();

  TNode<IntPtrT> index = EntryToIndex<Dictionary>(entry);
  *var_name_index = index;

  TNode<HeapObject> current =
      CAST(UnsafeLoadFixedArrayElement(dictionary, index))Cast(UnsafeLoadFixedArrayElement(dictionary, index));
  GotoIf(TaggedEqual(current, undefined), if_not_found);
  if (mode == kFindExisting) {
    if (Dictionary::ShapeT::kMatchNeedsHoleCheck) {
      GotoIf(TaggedEqual(current, TheHoleConstant()), &next_probe);
    }
    current = LoadName<Dictionary>(current);
    GotoIf(TaggedEqual(current, unique_name), if_found);
  } else {
    DCHECK_EQ(kFindInsertionIndex, mode)((void) 0);
    GotoIf(TaggedEqual(current, TheHoleConstant()), if_not_found);
  }
  Goto(&next_probe);

  BIND(&next_probe)Bind(&next_probe);
  // See Dictionary::NextProbe().
  Increment(&var_count);
  entry = Signed(WordAnd(IntPtrAdd(entry, var_count.value()), mask));

  var_entry = entry;
  Goto(&loop);
}
8581}

8583// Instantiate template methods to workaround GCC compilation issue.
8584template V8_EXPORT_PRIVATE void
8585CodeStubAssembler::NameDictionaryLookup<NameDictionary>(TNode<NameDictionary>,
                                                      TNode<Name>, Label*,
                                                      TVariable<IntPtrT>*,
                                                      Label*, LookupMode);
8589template V8_EXPORT_PRIVATE void CodeStubAssembler::NameDictionaryLookup<
  GlobalDictionary>(TNode<GlobalDictionary>, TNode<Name>, Label*,
                    TVariable<IntPtrT>*, Label*, LookupMode);

8593TNode<Word32T> CodeStubAssembler::ComputeSeededHash(TNode<IntPtrT> key) {
const TNode<ExternalReference> function_addr =
    ExternalConstant(ExternalReference::compute_integer_hash());
const TNode<ExternalReference> isolate_ptr =
    ExternalConstant(ExternalReference::isolate_address(isolate()));

MachineType type_ptr = MachineType::Pointer();
MachineType type_uint32 = MachineType::Uint32();
MachineType type_int32 = MachineType::Int32();

return UncheckedCast<Word32T>(CallCFunction(
    function_addr, type_uint32, std::make_pair(type_ptr, isolate_ptr),
    std::make_pair(type_int32, TruncateIntPtrToInt32(key))));
8606}

8608template <>
8609void CodeStubAssembler::NameDictionaryLookup(
  TNode<SwissNameDictionary> dictionary, TNode<Name> unique_name,
  Label* if_found, TVariable<IntPtrT>* var_name_index, Label* if_not_found,
  LookupMode mode) {
SwissNameDictionaryFindEntry(dictionary, unique_name, if_found,
                             var_name_index, if_not_found);
8615}

8617void CodeStubAssembler::NumberDictionaryLookup(
  TNode<NumberDictionary> dictionary, TNode<IntPtrT> intptr_index,
  Label* if_found, TVariable<IntPtrT>* var_entry, Label* if_not_found) {
CSA_DCHECK(this, IsNumberDictionary(dictionary))((void)0);
DCHECK_EQ(MachineType::PointerRepresentation(), var_entry->rep())((void) 0);
Comment("NumberDictionaryLookup");

TNode<IntPtrT> capacity = SmiUntag(GetCapacity<NumberDictionary>(dictionary));
TNode<IntPtrT> mask = IntPtrSub(capacity, IntPtrConstant(1));

TNode<UintPtrT> hash = ChangeUint32ToWord(ComputeSeededHash(intptr_index));
TNode<Float64T> key_as_float64 = RoundIntPtrToFloat64(intptr_index);

// See Dictionary::FirstProbe().
TNode<IntPtrT> count = IntPtrConstant(0);
TNode<IntPtrT> initial_entry = Signed(WordAnd(hash, mask));

TNode<Oddball> undefined = UndefinedConstant();
TNode<Oddball> the_hole = TheHoleConstant();

TVARIABLE(IntPtrT, var_count, count)TVariable<IntPtrT> var_count(count, this);
Label loop(this, {&var_count, var_entry});
*var_entry = initial_entry;
Goto(&loop);
BIND(&loop)Bind(&loop);
{
  TNode<IntPtrT> entry = var_entry->value();

  TNode<IntPtrT> index = EntryToIndex<NumberDictionary>(entry);
  TNode<Object> current = UnsafeLoadFixedArrayElement(dictionary, index);
  GotoIf(TaggedEqual(current, undefined), if_not_found);
  Label next_probe(this);
  {
    Label if_currentissmi(this), if_currentisnotsmi(this);
    Branch(TaggedIsSmi(current), &if_currentissmi, &if_currentisnotsmi);
    BIND(&if_currentissmi)Bind(&if_currentissmi);
    {
      TNode<IntPtrT> current_value = SmiUntag(CAST(current)Cast(current));
      Branch(WordEqual(current_value, intptr_index), if_found, &next_probe);
    }
    BIND(&if_currentisnotsmi)Bind(&if_currentisnotsmi);
    {
      GotoIf(TaggedEqual(current, the_hole), &next_probe);
      // Current must be the Number.
      TNode<Float64T> current_value = LoadHeapNumberValue(CAST(current)Cast(current));
      Branch(Float64Equal(current_value, key_as_float64), if_found,
             &next_probe);
    }
  }

  BIND(&next_probe)Bind(&next_probe);
  // See Dictionary::NextProbe().
  Increment(&var_count);
  entry = Signed(WordAnd(IntPtrAdd(entry, var_count.value()), mask));

  *var_entry = entry;
  Goto(&loop);
}
8675}

8677TNode<Object> CodeStubAssembler::BasicLoadNumberDictionaryElement(
  TNode<NumberDictionary> dictionary, TNode<IntPtrT> intptr_index,
  Label* not_data, Label* if_hole) {
TVARIABLE(IntPtrT, var_entry)TVariable<IntPtrT> var_entry(this);
Label if_found(this);
NumberDictionaryLookup(dictionary, intptr_index, &if_found, &var_entry,
                       if_hole);
BIND(&if_found)Bind(&if_found);

// Check that the value is a data property.
TNode<IntPtrT> index = EntryToIndex<NumberDictionary>(var_entry.value());
TNode<Uint32T> details = LoadDetailsByKeyIndex(dictionary, index);
TNode<Uint32T> kind = DecodeWord32<PropertyDetails::KindField>(details);
// TODO(jkummerow): Support accessors without missing?
GotoIfNot(
    Word32Equal(kind, Int32Constant(static_cast<int>(PropertyKind::kData))),
    not_data);
// Finally, load the value.
return LoadValueByKeyIndex(dictionary, index);
8696}

8698template <class Dictionary>
8699void CodeStubAssembler::FindInsertionEntry(TNode<Dictionary> dictionary,
                                         TNode<Name> key,
                                         TVariable<IntPtrT>* var_key_index) {
UNREACHABLE()V8_Fatal("unreachable code");
8703}

8705template <>
8706void CodeStubAssembler::FindInsertionEntry<NameDictionary>(
  TNode<NameDictionary> dictionary, TNode<Name> key,
  TVariable<IntPtrT>* var_key_index) {
Label done(this);
NameDictionaryLookup<NameDictionary>(dictionary, key, nullptr, var_key_index,
                                     &done, kFindInsertionIndex);
BIND(&done)Bind(&done);
8713}

8715template <class Dictionary>
8716void CodeStubAssembler::InsertEntry(TNode<Dictionary> dictionary,
                                  TNode<Name> key, TNode<Object> value,
                                  TNode<IntPtrT> index,
                                  TNode<Smi> enum_index) {
UNREACHABLE()V8_Fatal("unreachable code");  // Use specializations instead.
8721}

8723template <>
8724void CodeStubAssembler::InsertEntry<NameDictionary>(
  TNode<NameDictionary> dictionary, TNode<Name> name, TNode<Object> value,
  TNode<IntPtrT> index, TNode<Smi> enum_index) {
// This should only be used for adding, not updating existing mappings.
CSA_DCHECK(this,((void)0)
           Word32Or(TaggedEqual(LoadFixedArrayElement(dictionary, index),((void)0)
                                UndefinedConstant()),((void)0)
                    TaggedEqual(LoadFixedArrayElement(dictionary, index),((void)0)
                                TheHoleConstant())))((void)0);

// Store name and value.
StoreFixedArrayElement(dictionary, index, name);
StoreValueByKeyIndex<NameDictionary>(dictionary, index, value);

// Prepare details of the new property.
PropertyDetails d(PropertyKind::kData, NONE,
                  PropertyDetails::kConstIfDictConstnessTracking);

enum_index =
    SmiShl(enum_index, PropertyDetails::DictionaryStorageField::kShift);
// We OR over the actual index below, so we expect the initial value to be 0.
DCHECK_EQ(0, d.dictionary_index())((void) 0);
TVARIABLE(Smi, var_details, SmiOr(SmiConstant(d.AsSmi()), enum_index))TVariable<Smi> var_details(SmiOr(SmiConstant(d.AsSmi())
, enum_index), this);

// Private names must be marked non-enumerable.
Label not_private(this, &var_details);
GotoIfNot(IsPrivateSymbol(name), &not_private);
TNode<Smi> dont_enum =
    SmiShl(SmiConstant(DONT_ENUM), PropertyDetails::AttributesField::kShift);
var_details = SmiOr(var_details.value(), dont_enum);
Goto(&not_private);
BIND(&not_private)Bind(&not_private);

// Finally, store the details.
StoreDetailsByKeyIndex<NameDictionary>(dictionary, index,
                                       var_details.value());
8760}

8762template <>
8763void CodeStubAssembler::InsertEntry<GlobalDictionary>(
  TNode<GlobalDictionary> dictionary, TNode<Name> key, TNode<Object> value,
  TNode<IntPtrT> index, TNode<Smi> enum_index) {
UNIMPLEMENTED()V8_Fatal("unimplemented code");
8767}

8769template <class Dictionary>
8770void CodeStubAssembler::Add(TNode<Dictionary> dictionary, TNode<Name> key,
                          TNode<Object> value, Label* bailout) {
CSA_DCHECK(this, Word32BinaryNot(IsEmptyPropertyDictionary(dictionary)))((void)0);
TNode<Smi> capacity = GetCapacity<Dictionary>(dictionary);
TNode<Smi> nof = GetNumberOfElements<Dictionary>(dictionary);
TNode<Smi> new_nof = SmiAdd(nof, SmiConstant(1));
// Require 33% to still be free after adding additional_elements.
// Computing "x + (x >> 1)" on a Smi x does not return a valid Smi!
// But that's OK here because it's only used for a comparison.
TNode<Smi> required_capacity_pseudo_smi = SmiAdd(new_nof, SmiShr(new_nof, 1));
GotoIf(SmiBelow(capacity, required_capacity_pseudo_smi), bailout);
// Require rehashing if more than 50% of free elements are deleted elements.
TNode<Smi> deleted = GetNumberOfDeletedElements<Dictionary>(dictionary);
CSA_DCHECK(this, SmiAbove(capacity, new_nof))((void)0);
TNode<Smi> half_of_free_elements = SmiShr(SmiSub(capacity, new_nof), 1);
GotoIf(SmiAbove(deleted, half_of_free_elements), bailout);

TNode<Smi> enum_index = GetNextEnumerationIndex<Dictionary>(dictionary);
TNode<Smi> new_enum_index = SmiAdd(enum_index, SmiConstant(1));
TNode<Smi> max_enum_index =
    SmiConstant(PropertyDetails::DictionaryStorageField::kMax);
GotoIf(SmiAbove(new_enum_index, max_enum_index), bailout);

// No more bailouts after this point.
// Operations from here on can have side effects.

SetNextEnumerationIndex<Dictionary>(dictionary, new_enum_index);
SetNumberOfElements<Dictionary>(dictionary, new_nof);

TVARIABLE(IntPtrT, var_key_index)TVariable<IntPtrT> var_key_index(this);
FindInsertionEntry<Dictionary>(dictionary, key, &var_key_index);
InsertEntry<Dictionary>(dictionary, key, value, var_key_index.value(),
                        enum_index);
8803}

8805template <>
8806void CodeStubAssembler::Add(TNode<SwissNameDictionary> dictionary,
                          TNode<Name> key, TNode<Object> value,
                          Label* bailout) {
PropertyDetails d(PropertyKind::kData, NONE,
                  PropertyDetails::kConstIfDictConstnessTracking);

PropertyDetails d_dont_enum(PropertyKind::kData, DONT_ENUM,
                            PropertyDetails::kConstIfDictConstnessTracking);
TNode<Uint8T> details_byte_enum =
    UncheckedCast<Uint8T>(Uint32Constant(d.ToByte()));
TNode<Uint8T> details_byte_dont_enum =
    UncheckedCast<Uint8T>(Uint32Constant(d_dont_enum.ToByte()));

Label not_private(this);
TVARIABLE(Uint8T, var_details, details_byte_enum)TVariable<Uint8T> var_details(details_byte_enum, this);

GotoIfNot(IsPrivateSymbol(key), &not_private);
var_details = details_byte_dont_enum;
Goto(&not_private);

BIND(&not_private)Bind(&not_private);
SwissNameDictionaryAdd(dictionary, key, value, var_details.value(), bailout);
8828}

8830template void CodeStubAssembler::Add<NameDictionary>(TNode<NameDictionary>,
                                                   TNode<Name>, TNode<Object>,
                                                   Label*);

8834template <class Dictionary>
8835TNode<Smi> CodeStubAssembler::GetNumberOfElements(
  TNode<Dictionary> dictionary) {
return CAST(Cast(LoadFixedArrayElement(dictionary, Dictionary::kNumberOfElementsIndex
))
    LoadFixedArrayElement(dictionary, Dictionary::kNumberOfElementsIndex))Cast(LoadFixedArrayElement(dictionary, Dictionary::kNumberOfElementsIndex
));
8839}

8841template <>
8842TNode<Smi> CodeStubAssembler::GetNumberOfElements(
  TNode<SwissNameDictionary> dictionary) {
TNode<IntPtrT> capacity =
    ChangeInt32ToIntPtr(LoadSwissNameDictionaryCapacity(dictionary));
return SmiFromIntPtr(
    LoadSwissNameDictionaryNumberOfElements(dictionary, capacity));
8848}

8850template TNode<Smi> CodeStubAssembler::GetNumberOfElements(
  TNode<NameDictionary> dictionary);
8852template TNode<Smi> CodeStubAssembler::GetNumberOfElements(
  TNode<NumberDictionary> dictionary);
8854template TNode<Smi> CodeStubAssembler::GetNumberOfElements(
  TNode<GlobalDictionary> dictionary);

8857template <typename Array>
8858void CodeStubAssembler::LookupLinear(TNode<Name> unique_name,
                                   TNode<Array> array,
                                   TNode<Uint32T> number_of_valid_entries,
                                   Label* if_found,
                                   TVariable<IntPtrT>* var_name_index,
                                   Label* if_not_found) {
static_assert(std::is_base_of<FixedArray, Array>::value ||
                  std::is_base_of<WeakFixedArray, Array>::value ||
                  std::is_base_of<DescriptorArray, Array>::value,
              "T must be a descendant of FixedArray or a WeakFixedArray");
Comment("LookupLinear");
CSA_DCHECK(this, IsUniqueName(unique_name))((void)0);
TNode<IntPtrT> first_inclusive = IntPtrConstant(Array::ToKeyIndex(0));
TNode<IntPtrT> factor = IntPtrConstant(Array::kEntrySize);
TNode<IntPtrT> last_exclusive = IntPtrAdd(
    first_inclusive,
    IntPtrMul(ChangeInt32ToIntPtr(number_of_valid_entries), factor));

BuildFastLoop<IntPtrT>(
    last_exclusive, first_inclusive,
    [=](TNode<IntPtrT> name_index) {
      TNode<MaybeObject> element =
          LoadArrayElement(array, Array::kHeaderSize, name_index);
      TNode<Name> candidate_name = CAST(element)Cast(element);
      *var_name_index = name_index;
      GotoIf(TaggedEqual(candidate_name, unique_name), if_found);
    },
    -Array::kEntrySize, IndexAdvanceMode::kPre);
Goto(if_not_found);
8887}

8889template <>
8890TNode<Uint32T> CodeStubAssembler::NumberOfEntries<DescriptorArray>(
  TNode<DescriptorArray> descriptors) {
return Unsigned(LoadNumberOfDescriptors(descriptors));
8893}

8895template <>
8896TNode<Uint32T> CodeStubAssembler::NumberOfEntries<TransitionArray>(
  TNode<TransitionArray> transitions) {
TNode<IntPtrT> length = LoadAndUntagWeakFixedArrayLength(transitions);
return Select<Uint32T>(
    UintPtrLessThan(length, IntPtrConstant(TransitionArray::kFirstIndex)),
    [=] { return Unsigned(Int32Constant(0)); },
    [=] {
      return Unsigned(LoadAndUntagToWord32ArrayElement(
          transitions, WeakFixedArray::kHeaderSize,
          IntPtrConstant(TransitionArray::kTransitionLengthIndex)));
    });
8907}

8909template <typename Array>
8910TNode<IntPtrT> CodeStubAssembler::EntryIndexToIndex(
  TNode<Uint32T> entry_index) {
TNode<Int32T> entry_size = Int32Constant(Array::kEntrySize);
TNode<Word32T> index = Int32Mul(entry_index, entry_size);
return ChangeInt32ToIntPtr(index);
8915}

8917template <typename Array>
8918TNode<IntPtrT> CodeStubAssembler::ToKeyIndex(TNode<Uint32T> entry_index) {
return IntPtrAdd(IntPtrConstant(Array::ToKeyIndex(0)),
                 EntryIndexToIndex<Array>(entry_index));
8921}

8923template TNode<IntPtrT> CodeStubAssembler::ToKeyIndex<DescriptorArray>(
  TNode<Uint32T>);
8925template TNode<IntPtrT> CodeStubAssembler::ToKeyIndex<TransitionArray>(
  TNode<Uint32T>);

8928template <>
8929TNode<Uint32T> CodeStubAssembler::GetSortedKeyIndex<DescriptorArray>(
  TNode<DescriptorArray> descriptors, TNode<Uint32T> descriptor_number) {
TNode<Uint32T> details =
    DescriptorArrayGetDetails(descriptors, descriptor_number);
return DecodeWord32<PropertyDetails::DescriptorPointer>(details);
8934}

8936template <>
8937TNode<Uint32T> CodeStubAssembler::GetSortedKeyIndex<TransitionArray>(
  TNode<TransitionArray> transitions, TNode<Uint32T> transition_number) {
return transition_number;
8940}

8942template <typename Array>
8943TNode<Name> CodeStubAssembler::GetKey(TNode<Array> array,
                                    TNode<Uint32T> entry_index) {
static_assert(std::is_base_of<TransitionArray, Array>::value ||
                  std::is_base_of<DescriptorArray, Array>::value,
              "T must be a descendant of DescriptorArray or TransitionArray");
const int key_offset = Array::ToKeyIndex(0) * kTaggedSize;
TNode<MaybeObject> element =
    LoadArrayElement(array, Array::kHeaderSize,
                     EntryIndexToIndex<Array>(entry_index), key_offset);
return CAST(element)Cast(element);
8953}

8955template TNode<Name> CodeStubAssembler::GetKey<DescriptorArray>(
  TNode<DescriptorArray>, TNode<Uint32T>);
8957template TNode<Name> CodeStubAssembler::GetKey<TransitionArray>(
  TNode<TransitionArray>, TNode<Uint32T>);

8960TNode<Uint32T> CodeStubAssembler::DescriptorArrayGetDetails(
  TNode<DescriptorArray> descriptors, TNode<Uint32T> descriptor_number) {
const int details_offset = DescriptorArray::ToDetailsIndex(0) * kTaggedSize;
return Unsigned(LoadAndUntagToWord32ArrayElement(
    descriptors, DescriptorArray::kHeaderSize,
    EntryIndexToIndex<DescriptorArray>(descriptor_number), details_offset));
8966}

8968template <typename Array>
8969void CodeStubAssembler::LookupBinary(TNode<Name> unique_name,
                                   TNode<Array> array,
                                   TNode<Uint32T> number_of_valid_entries,
                                   Label* if_found,
                                   TVariable<IntPtrT>* var_name_index,
                                   Label* if_not_found) {
Comment("LookupBinary");
TVARIABLE(Uint32T, var_low, Unsigned(Int32Constant(0)))TVariable<Uint32T> var_low(Unsigned(Int32Constant(0)), this
);
TNode<Uint32T> limit =
    Unsigned(Int32Sub(NumberOfEntries<Array>(array), Int32Constant(1)));
TVARIABLE(Uint32T, var_high, limit)TVariable<Uint32T> var_high(limit, this);
TNode<Uint32T> hash = LoadNameHashAssumeComputed(unique_name);
CSA_DCHECK(this, Word32NotEqual(hash, Int32Constant(0)))((void)0);

// Assume non-empty array.
CSA_DCHECK(this, Uint32LessThanOrEqual(var_low.value(), var_high.value()))((void)0);

Label binary_loop(this, {&var_high, &var_low});
Goto(&binary_loop);
BIND(&binary_loop)Bind(&binary_loop);
{
  // mid = low + (high - low) / 2 (to avoid overflow in "(low + high) / 2").
  TNode<Uint32T> mid = Unsigned(
      Int32Add(var_low.value(),
               Word32Shr(Int32Sub(var_high.value(), var_low.value()), 1)));
  // mid_name = array->GetSortedKey(mid).
  TNode<Uint32T> sorted_key_index = GetSortedKeyIndex<Array>(array, mid);
  TNode<Name> mid_name = GetKey<Array>(array, sorted_key_index);

  TNode<Uint32T> mid_hash = LoadNameHashAssumeComputed(mid_name);

  Label mid_greater(this), mid_less(this), merge(this);
  Branch(Uint32GreaterThanOrEqual(mid_hash, hash), &mid_greater, &mid_less);
  BIND(&mid_greater)Bind(&mid_greater);
  {
    var_high = mid;
    Goto(&merge);
  }
  BIND(&mid_less)Bind(&mid_less);
  {
    var_low = Unsigned(Int32Add(mid, Int32Constant(1)));
    Goto(&merge);
  }
  BIND(&merge)Bind(&merge);
  GotoIf(Word32NotEqual(var_low.value(), var_high.value()), &binary_loop);
}

Label scan_loop(this, &var_low);
Goto(&scan_loop);
BIND(&scan_loop)Bind(&scan_loop);
{
  GotoIf(Int32GreaterThan(var_low.value(), limit), if_not_found);

  TNode<Uint32T> sort_index =
      GetSortedKeyIndex<Array>(array, var_low.value());
  TNode<Name> current_name = GetKey<Array>(array, sort_index);
  TNode<Uint32T> current_hash = LoadNameHashAssumeComputed(current_name);
  GotoIf(Word32NotEqual(current_hash, hash), if_not_found);
  Label next(this);
  GotoIf(TaggedNotEqual(current_name, unique_name), &next);
  GotoIf(Uint32GreaterThanOrEqual(sort_index, number_of_valid_entries),
         if_not_found);
  *var_name_index = ToKeyIndex<Array>(sort_index);
  Goto(if_found);

  BIND(&next)Bind(&next);
  var_low = Unsigned(Int32Add(var_low.value(), Int32Constant(1)));
  Goto(&scan_loop);
}
9038}

9040void CodeStubAssembler::ForEachEnumerableOwnProperty(
  TNode<Context> context, TNode<Map> map, TNode<JSObject> object,
  PropertiesEnumerationMode mode, const ForEachKeyValueFunction& body,
  Label* bailout) {
TNode<Uint16T> type = LoadMapInstanceType(map);
TNode<Uint32T> bit_field3 = EnsureOnlyHasSimpleProperties(map, type, bailout);

TVARIABLE(DescriptorArray, var_descriptors, LoadMapDescriptors(map))TVariable<DescriptorArray> var_descriptors(LoadMapDescriptors
(map), this);
TNode<Uint32T> nof_descriptors =
    DecodeWord32<Map::Bits3::NumberOfOwnDescriptorsBits>(bit_field3);

TVARIABLE(BoolT, var_stable, Int32TrueConstant())TVariable<BoolT> var_stable(Int32TrueConstant(), this);

TVARIABLE(BoolT, var_has_symbol, Int32FalseConstant())TVariable<BoolT> var_has_symbol(Int32FalseConstant(), this
);
// false - iterate only string properties, true - iterate only symbol
// properties
TVARIABLE(BoolT, var_is_symbol_processing_loop, Int32FalseConstant())TVariable<BoolT> var_is_symbol_processing_loop(Int32FalseConstant
(), this);
TVARIABLE(IntPtrT, var_start_key_index,TVariable<IntPtrT> var_start_key_index(ToKeyIndex<DescriptorArray
>(Unsigned(Int32Constant(0))), this)
          ToKeyIndex<DescriptorArray>(Unsigned(Int32Constant(0))))TVariable<IntPtrT> var_start_key_index(ToKeyIndex<DescriptorArray
>(Unsigned(Int32Constant(0))), this);
// Note: var_end_key_index is exclusive for the loop
TVARIABLE(IntPtrT, var_end_key_index,TVariable<IntPtrT> var_end_key_index(ToKeyIndex<DescriptorArray
>(nof_descriptors), this)
          ToKeyIndex<DescriptorArray>(nof_descriptors))TVariable<IntPtrT> var_end_key_index(ToKeyIndex<DescriptorArray
>(nof_descriptors), this);
VariableList list({&var_descriptors, &var_stable, &var_has_symbol,
                   &var_is_symbol_processing_loop, &var_start_key_index,
                   &var_end_key_index},
                  zone());
Label descriptor_array_loop(this, list);

Goto(&descriptor_array_loop);
BIND(&descriptor_array_loop)Bind(&descriptor_array_loop);

BuildFastLoop<IntPtrT>(
    list, var_start_key_index.value(), var_end_key_index.value(),
    [&](TNode<IntPtrT> descriptor_key_index) {
      TNode<Name> next_key =
          LoadKeyByKeyIndex(var_descriptors.value(), descriptor_key_index);

      TVARIABLE(Object, var_value, SmiConstant(0))TVariable<Object> var_value(SmiConstant(0), this);
      Label callback(this), next_iteration(this);

      if (mode == kEnumerationOrder) {
        // |next_key| is either a string or a symbol
        // Skip strings or symbols depending on
        // |var_is_symbol_processing_loop|.
        Label if_string(this), if_symbol(this), if_name_ok(this);
        Branch(IsSymbol(next_key), &if_symbol, &if_string);
        BIND(&if_symbol)Bind(&if_symbol);
        {
          // Process symbol property when |var_is_symbol_processing_loop| is
          // true.
          GotoIf(var_is_symbol_processing_loop.value(), &if_name_ok);
          // First iteration need to calculate smaller range for processing
          // symbols
          Label if_first_symbol(this);
          // var_end_key_index is still inclusive at this point.
          var_end_key_index = descriptor_key_index;
          Branch(var_has_symbol.value(), &next_iteration, &if_first_symbol);
          BIND(&if_first_symbol)Bind(&if_first_symbol);
          {
            var_start_key_index = descriptor_key_index;
            var_has_symbol = Int32TrueConstant();
            Goto(&next_iteration);
          }
        }
        BIND(&if_string)Bind(&if_string);
        {
          CSA_DCHECK(this, IsString(next_key))((void)0);
          // Process string property when |var_is_symbol_processing_loop| is
          // false.
          Branch(var_is_symbol_processing_loop.value(), &next_iteration,
                 &if_name_ok);
        }
        BIND(&if_name_ok)Bind(&if_name_ok);
      }
      {
        TVARIABLE(Map, var_map)TVariable<Map> var_map(this);
        TVARIABLE(HeapObject, var_meta_storage)TVariable<HeapObject> var_meta_storage(this);
        TVARIABLE(IntPtrT, var_entry)TVariable<IntPtrT> var_entry(this);
        TVARIABLE(Uint32T, var_details)TVariable<Uint32T> var_details(this);
        Label if_found(this);

        Label if_found_fast(this), if_found_dict(this);

        Label if_stable(this), if_not_stable(this);
        Branch(var_stable.value(), &if_stable, &if_not_stable);
        BIND(&if_stable)Bind(&if_stable);
        {
          // Directly decode from the descriptor array if |object| did not
          // change shape.
          var_map = map;
          var_meta_storage = var_descriptors.value();
          var_entry = Signed(descriptor_key_index);
          Goto(&if_found_fast);
        }
        BIND(&if_not_stable)Bind(&if_not_stable);
        {
          // If the map did change, do a slower lookup. We are still
          // guaranteed that the object has a simple shape, and that the key
          // is a name.
          var_map = LoadMap(object);
          TryLookupPropertyInSimpleObject(object, var_map.value(), next_key,
                                          &if_found_fast, &if_found_dict,
                                          &var_meta_storage, &var_entry,
                                          &next_iteration, bailout);
        }

        BIND(&if_found_fast)Bind(&if_found_fast);
        {
          TNode<DescriptorArray> descriptors = CAST(var_meta_storage.value())Cast(var_meta_storage.value());
          TNode<IntPtrT> name_index = var_entry.value();

          // Skip non-enumerable properties.
          var_details = LoadDetailsByKeyIndex(descriptors, name_index);
          GotoIf(IsSetWord32(var_details.value(),
                             PropertyDetails::kAttributesDontEnumMask),
                 &next_iteration);

          LoadPropertyFromFastObject(object, var_map.value(), descriptors,
                                     name_index, var_details.value(),
                                     &var_value);
          Goto(&if_found);
        }
        BIND(&if_found_dict)Bind(&if_found_dict);
        {
          TNode<PropertyDictionary> dictionary =
              CAST(var_meta_storage.value())Cast(var_meta_storage.value());
          TNode<IntPtrT> entry = var_entry.value();

          TNode<Uint32T> details = LoadDetailsByKeyIndex(dictionary, entry);
          // Skip non-enumerable properties.
          GotoIf(
              IsSetWord32(details, PropertyDetails::kAttributesDontEnumMask),
              &next_iteration);

          var_details = details;
          var_value =
              LoadValueByKeyIndex<PropertyDictionary>(dictionary, entry);
          Goto(&if_found);
        }

        // Here we have details and value which could be an accessor.
        BIND(&if_found)Bind(&if_found);
        {
          Label slow_load(this, Label::kDeferred);

          var_value = CallGetterIfAccessor(
              var_value.value(), object, var_details.value(), context, object,
              next_key, &slow_load, kCallJSGetterUseCachedName);
          Goto(&callback);

          BIND(&slow_load)Bind(&slow_load);
          var_value =
              CallRuntime(Runtime::kGetProperty, context, object, next_key);
          Goto(&callback);

          BIND(&callback)Bind(&callback);
          body(next_key, var_value.value());

          // Check if |object| is still stable, i.e. the descriptors in the
          // preloaded |descriptors| are still the same modulo in-place
          // representation changes.
          GotoIfNot(var_stable.value(), &next_iteration);
          var_stable = TaggedEqual(LoadMap(object), map);
          // Reload the descriptors just in case the actual array changed, and
          // any of the field representations changed in-place.
          var_descriptors = LoadMapDescriptors(map);

          Goto(&next_iteration);
        }
      }
      BIND(&next_iteration)Bind(&next_iteration);
    },
    DescriptorArray::kEntrySize, IndexAdvanceMode::kPost);

if (mode == kEnumerationOrder) {
  Label done(this);
  GotoIf(var_is_symbol_processing_loop.value(), &done);
  GotoIfNot(var_has_symbol.value(), &done);
  // All string properties are processed, now process symbol properties.
  var_is_symbol_processing_loop = Int32TrueConstant();
  // Add DescriptorArray::kEntrySize to make the var_end_key_index exclusive
  // as BuildFastLoop() expects.
  Increment(&var_end_key_index, DescriptorArray::kEntrySize);
  Goto(&descriptor_array_loop);

  BIND(&done)Bind(&done);
}
9227}

9229TNode<Object> CodeStubAssembler::GetConstructor(TNode<Map> map) {
TVARIABLE(HeapObject, var_maybe_constructor)TVariable<HeapObject> var_maybe_constructor(this);
var_maybe_constructor = map;
Label loop(this, &var_maybe_constructor), done(this);
GotoIfNot(IsMap(var_maybe_constructor.value()), &done);
Goto(&loop);

BIND(&loop)Bind(&loop);
{
  var_maybe_constructor = CAST(Cast(LoadObjectField(var_maybe_constructor.value(), Map::kConstructorOrBackPointerOrNativeContextOffset
))
      LoadObjectField(var_maybe_constructor.value(),Cast(LoadObjectField(var_maybe_constructor.value(), Map::kConstructorOrBackPointerOrNativeContextOffset
))
                      Map::kConstructorOrBackPointerOrNativeContextOffset))Cast(LoadObjectField(var_maybe_constructor.value(), Map::kConstructorOrBackPointerOrNativeContextOffset
));
  GotoIf(IsMap(var_maybe_constructor.value()), &loop);
  Goto(&done);
}

BIND(&done)Bind(&done);
return var_maybe_constructor.value();
9247}

9249TNode<NativeContext> CodeStubAssembler::GetCreationContext(
  TNode<JSReceiver> receiver, Label* if_bailout) {
TNode<Map> receiver_map = LoadMap(receiver);
TNode<Object> constructor = GetConstructor(receiver_map);

TVARIABLE(JSFunction, var_function)TVariable<JSFunction> var_function(this);

Label done(this), if_jsfunction(this), if_jsgenerator(this);
GotoIf(TaggedIsSmi(constructor), if_bailout);

TNode<Map> function_map = LoadMap(CAST(constructor)Cast(constructor));
GotoIf(IsJSFunctionMap(function_map), &if_jsfunction);
GotoIf(IsJSGeneratorMap(function_map), &if_jsgenerator);
// Remote objects don't have a creation context.
GotoIf(IsFunctionTemplateInfoMap(function_map), if_bailout);

CSA_DCHECK(this, IsJSFunctionMap(receiver_map))((void)0);
var_function = CAST(receiver)Cast(receiver);
Goto(&done);

BIND(&if_jsfunction)Bind(&if_jsfunction);
{
  var_function = CAST(constructor)Cast(constructor);
  Goto(&done);
}

BIND(&if_jsgenerator)Bind(&if_jsgenerator);
{
  var_function = LoadJSGeneratorObjectFunction(CAST(receiver)Cast(receiver));
  Goto(&done);
}

BIND(&done)Bind(&done);
TNode<Context> context = LoadJSFunctionContext(var_function.value());

GotoIfNot(IsContext(context), if_bailout);

TNode<NativeContext> native_context = LoadNativeContext(context);
return native_context;
9288}

9290TNode<NativeContext> CodeStubAssembler::GetFunctionRealm(
  TNode<Context> context, TNode<JSReceiver> receiver, Label* if_bailout) {
TVARIABLE(JSReceiver, current)TVariable<JSReceiver> current(this);
Label loop(this, VariableList({&current}, zone())), is_proxy(this),
    is_function(this), is_bound_function(this), is_wrapped_function(this),
    proxy_revoked(this, Label::kDeferred);
CSA_DCHECK(this, IsCallable(receiver))((void)0);
current = receiver;
Goto(&loop);

BIND(&loop)Bind(&loop);
{
  TNode<JSReceiver> current_value = current.value();
  GotoIf(IsJSProxy(current_value), &is_proxy);
  GotoIf(IsJSFunction(current_value), &is_function);
  GotoIf(IsJSBoundFunction(current_value), &is_bound_function);
  GotoIf(IsJSWrappedFunction(current_value), &is_wrapped_function);
  Goto(if_bailout);
}

BIND(&is_proxy)Bind(&is_proxy);
{
  TNode<JSProxy> proxy = CAST(current.value())Cast(current.value());
  TNode<HeapObject> handler =
      CAST(LoadObjectField(proxy, JSProxy::kHandlerOffset))Cast(LoadObjectField(proxy, JSProxy::kHandlerOffset));
  // Proxy is revoked.
  GotoIfNot(IsJSReceiver(handler), &proxy_revoked);
  TNode<JSReceiver> target =
      CAST(LoadObjectField(proxy, JSProxy::kTargetOffset))Cast(LoadObjectField(proxy, JSProxy::kTargetOffset));
  current = target;
  Goto(&loop);
}

BIND(&proxy_revoked)Bind(&proxy_revoked);
{ ThrowTypeError(context, MessageTemplate::kProxyRevoked, "apply"); }

BIND(&is_bound_function)Bind(&is_bound_function);
{
  TNode<JSBoundFunction> bound_function = CAST(current.value())Cast(current.value());
  TNode<JSReceiver> target = CAST(LoadObjectField(Cast(LoadObjectField( bound_function, JSBoundFunction::kBoundTargetFunctionOffset
))
      bound_function, JSBoundFunction::kBoundTargetFunctionOffset))Cast(LoadObjectField( bound_function, JSBoundFunction::kBoundTargetFunctionOffset
));
  current = target;
  Goto(&loop);
}

BIND(&is_wrapped_function)Bind(&is_wrapped_function);
{
  TNode<JSWrappedFunction> wrapped_function = CAST(current.value())Cast(current.value());
  TNode<JSReceiver> target = CAST(LoadObjectField(Cast(LoadObjectField( wrapped_function, JSWrappedFunction::kWrappedTargetFunctionOffset
))
      wrapped_function, JSWrappedFunction::kWrappedTargetFunctionOffset))Cast(LoadObjectField( wrapped_function, JSWrappedFunction::kWrappedTargetFunctionOffset
));
  current = target;
  Goto(&loop);
}

BIND(&is_function)Bind(&is_function);
{
  TNode<JSFunction> function = CAST(current.value())Cast(current.value());
  TNode<Context> context =
      CAST(LoadObjectField(function, JSFunction::kContextOffset))Cast(LoadObjectField(function, JSFunction::kContextOffset));
  TNode<NativeContext> native_context = LoadNativeContext(context);
  return native_context;
}
9352}

9354void CodeStubAssembler::DescriptorLookup(TNode<Name> unique_name,
                                       TNode<DescriptorArray> descriptors,
                                       TNode<Uint32T> bitfield3,
                                       Label* if_found,
                                       TVariable<IntPtrT>* var_name_index,
                                       Label* if_not_found) {
Comment("DescriptorArrayLookup");
TNode<Uint32T> nof =
    DecodeWord32<Map::Bits3::NumberOfOwnDescriptorsBits>(bitfield3);
Lookup<DescriptorArray>(unique_name, descriptors, nof, if_found,
                        var_name_index, if_not_found);
9365}

9367void CodeStubAssembler::TransitionLookup(TNode<Name> unique_name,
                                       TNode<TransitionArray> transitions,
                                       Label* if_found,
                                       TVariable<IntPtrT>* var_name_index,
                                       Label* if_not_found) {
Comment("TransitionArrayLookup");
TNode<Uint32T> number_of_valid_transitions =
    NumberOfEntries<TransitionArray>(transitions);
Lookup<TransitionArray>(unique_name, transitions, number_of_valid_transitions,
                        if_found, var_name_index, if_not_found);
9377}

9379template <typename Array>
9380void CodeStubAssembler::Lookup(TNode<Name> unique_name, TNode<Array> array,
                             TNode<Uint32T> number_of_valid_entries,
                             Label* if_found,
                             TVariable<IntPtrT>* var_name_index,
                             Label* if_not_found) {
Comment("ArrayLookup");
if (!number_of_valid_entries) {
  number_of_valid_entries = NumberOfEntries(array);
}
GotoIf(Word32Equal(number_of_valid_entries, Int32Constant(0)), if_not_found);
Label linear_search(this), binary_search(this);
const int kMaxElementsForLinearSearch = 32;
Branch(Uint32LessThanOrEqual(number_of_valid_entries,
                             Int32Constant(kMaxElementsForLinearSearch)),
       &linear_search, &binary_search);
BIND(&linear_search)Bind(&linear_search);
{
  LookupLinear<Array>(unique_name, array, number_of_valid_entries, if_found,
                      var_name_index, if_not_found);
}
BIND(&binary_search)Bind(&binary_search);
{
  LookupBinary<Array>(unique_name, array, number_of_valid_entries, if_found,
                      var_name_index, if_not_found);
}
9405}

9407void CodeStubAssembler::TryLookupPropertyInSimpleObject(
  TNode<JSObject> object, TNode<Map> map, TNode<Name> unique_name,
  Label* if_found_fast, Label* if_found_dict,
  TVariable<HeapObject>* var_meta_storage, TVariable<IntPtrT>* var_name_index,
  Label* if_not_found, Label* bailout) {
CSA_DCHECK(this, IsSimpleObjectMap(map))((void)0);
CSA_DCHECK(this, IsUniqueNameNoCachedIndex(unique_name))((void)0);

TNode<Uint32T> bit_field3 = LoadMapBitField3(map);
Label if_isfastmap(this), if_isslowmap(this);
Branch(IsSetWord32<Map::Bits3::IsDictionaryMapBit>(bit_field3), &if_isslowmap,
       &if_isfastmap);
BIND(&if_isfastmap)Bind(&if_isfastmap);
{
  TNode<DescriptorArray> descriptors = LoadMapDescriptors(map);
  *var_meta_storage = descriptors;

  DescriptorLookup(unique_name, descriptors, bit_field3, if_found_fast,
                   var_name_index, if_not_found);
}
BIND(&if_isslowmap)Bind(&if_isslowmap);
{
  TNode<PropertyDictionary> dictionary = CAST(LoadSlowProperties(object))Cast(LoadSlowProperties(object));
  *var_meta_storage = dictionary;

  NameDictionaryLookup<PropertyDictionary>(
      dictionary, unique_name, if_found_dict, var_name_index, if_not_found);
}
9435}

9437void CodeStubAssembler::TryLookupProperty(
  TNode<HeapObject> object, TNode<Map> map, TNode<Int32T> instance_type,
  TNode<Name> unique_name, Label* if_found_fast, Label* if_found_dict,
  Label* if_found_global, TVariable<HeapObject>* var_meta_storage,
  TVariable<IntPtrT>* var_name_index, Label* if_not_found,
  Label* if_bailout) {
Label if_objectisspecial(this);
GotoIf(IsSpecialReceiverInstanceType(instance_type), &if_objectisspecial);

TryLookupPropertyInSimpleObject(CAST(object)Cast(object), map, unique_name, if_found_fast,
                                if_found_dict, var_meta_storage,
                                var_name_index, if_not_found, if_bailout);

BIND(&if_objectisspecial)Bind(&if_objectisspecial);
{
  // Handle global object here and bailout for other special objects.
  GotoIfNot(InstanceTypeEqual(instance_type, JS_GLOBAL_OBJECT_TYPE),
            if_bailout);

  // Handle interceptors and access checks in runtime.
  TNode<Int32T> bit_field = LoadMapBitField(map);
  int mask = Map::Bits1::HasNamedInterceptorBit::kMask |
             Map::Bits1::IsAccessCheckNeededBit::kMask;
  GotoIf(IsSetWord32(bit_field, mask), if_bailout);

  TNode<GlobalDictionary> dictionary = CAST(LoadSlowProperties(CAST(object)))Cast(LoadSlowProperties(Cast(object)));
  *var_meta_storage = dictionary;

  NameDictionaryLookup<GlobalDictionary>(
      dictionary, unique_name, if_found_global, var_name_index, if_not_found);
}
9468}

9470void CodeStubAssembler::TryHasOwnProperty(TNode<HeapObject> object,
                                        TNode<Map> map,
                                        TNode<Int32T> instance_type,
                                        TNode<Name> unique_name,
                                        Label* if_found, Label* if_not_found,
                                        Label* if_bailout) {
Comment("TryHasOwnProperty");
CSA_DCHECK(this, IsUniqueNameNoCachedIndex(unique_name))((void)0);
TVARIABLE(HeapObject, var_meta_storage)TVariable<HeapObject> var_meta_storage(this);
TVARIABLE(IntPtrT, var_name_index)TVariable<IntPtrT> var_name_index(this);

Label if_found_global(this);
TryLookupProperty(object, map, instance_type, unique_name, if_found, if_found,
                  &if_found_global, &var_meta_storage, &var_name_index,
                  if_not_found, if_bailout);

BIND(&if_found_global)Bind(&if_found_global);
{
  TVARIABLE(Object, var_value)TVariable<Object> var_value(this);
  TVARIABLE(Uint32T, var_details)TVariable<Uint32T> var_details(this);
  // Check if the property cell is not deleted.
  LoadPropertyFromGlobalDictionary(CAST(var_meta_storage.value())Cast(var_meta_storage.value()),
                                   var_name_index.value(), &var_details,
                                   &var_value, if_not_found);
  Goto(if_found);
}
9496}

9498TNode<Object> CodeStubAssembler::GetMethod(TNode<Context> context,
                                         TNode<Object> object,
                                         Handle<Name> name,
                                         Label* if_null_or_undefined) {
TNode<Object> method = GetProperty(context, object, name);

GotoIf(IsUndefined(method), if_null_or_undefined);
GotoIf(IsNull(method), if_null_or_undefined);

return method;
9508}

9510TNode<Object> CodeStubAssembler::GetIteratorMethod(
  TNode<Context> context, TNode<HeapObject> heap_obj,
  Label* if_iteratorundefined) {
return GetMethod(context, heap_obj, isolate()->factory()->iterator_symbol(),
                 if_iteratorundefined);
9515}

9517TNode<Object> CodeStubAssembler::CreateAsyncFromSyncIterator(
  TNode<Context> context, TNode<Object> sync_iterator) {
Label not_receiver(this, Label::kDeferred);
Label done(this);
TVARIABLE(Object, return_value)TVariable<Object> return_value(this);

GotoIf(TaggedIsSmi(sync_iterator), &not_receiver);
GotoIfNot(IsJSReceiver(CAST(sync_iterator)Cast(sync_iterator)), &not_receiver);

const TNode<Object> next =
    GetProperty(context, sync_iterator, factory()->next_string());

const TNode<NativeContext> native_context = LoadNativeContext(context);
const TNode<Map> map = CAST(LoadContextElement(Cast(LoadContextElement( native_context, Context::ASYNC_FROM_SYNC_ITERATOR_MAP_INDEX
))
    native_context, Context::ASYNC_FROM_SYNC_ITERATOR_MAP_INDEX))Cast(LoadContextElement( native_context, Context::ASYNC_FROM_SYNC_ITERATOR_MAP_INDEX
));
const TNode<JSObject> iterator = AllocateJSObjectFromMap(map);

StoreObjectFieldNoWriteBarrier(
    iterator, JSAsyncFromSyncIterator::kSyncIteratorOffset, sync_iterator);
StoreObjectFieldNoWriteBarrier(iterator, JSAsyncFromSyncIterator::kNextOffset,
                               next);

return_value = iterator;
Goto(&done);

BIND(&not_receiver)Bind(&not_receiver);
{
  return_value = CallRuntime(Runtime::kThrowSymbolIteratorInvalid, context);

  // Unreachable due to the Throw in runtime call.
  Goto(&done);
}

BIND(&done)Bind(&done);
return return_value.value();
9552}

9554void CodeStubAssembler::LoadPropertyFromFastObject(
  TNode<HeapObject> object, TNode<Map> map,
  TNode<DescriptorArray> descriptors, TNode<IntPtrT> name_index,
  TVariable<Uint32T>* var_details, TVariable<Object>* var_value) {
TNode<Uint32T> details = LoadDetailsByKeyIndex(descriptors, name_index);
*var_details = details;

LoadPropertyFromFastObject(object, map, descriptors, name_index, details,
                           var_value);
9563}

9565void CodeStubAssembler::LoadPropertyFromFastObject(
  TNode<HeapObject> object, TNode<Map> map,
  TNode<DescriptorArray> descriptors, TNode<IntPtrT> name_index,
  TNode<Uint32T> details, TVariable<Object>* var_value) {
Comment("[ LoadPropertyFromFastObject");

TNode<Uint32T> location =
    DecodeWord32<PropertyDetails::LocationField>(details);

Label if_in_field(this), if_in_descriptor(this), done(this);
Branch(Word32Equal(location, Int32Constant(static_cast<int32_t>(
                                 PropertyLocation::kField))),
       &if_in_field, &if_in_descriptor);
BIND(&if_in_field)Bind(&if_in_field);
{
  TNode<IntPtrT> field_index =
      Signed(DecodeWordFromWord32<PropertyDetails::FieldIndexField>(details));
  TNode<Uint32T> representation =
      DecodeWord32<PropertyDetails::RepresentationField>(details);

  // TODO(ishell): support WasmValues.
  CSA_DCHECK(this, Word32NotEqual(representation,((void)0)
                                  Int32Constant(Representation::kWasmValue)))((void)0);
  field_index =
      IntPtrAdd(field_index, LoadMapInobjectPropertiesStartInWords(map));
  TNode<IntPtrT> instance_size_in_words = LoadMapInstanceSizeInWords(map);

  Label if_inobject(this), if_backing_store(this);
  TVARIABLE(Float64T, var_double_value)TVariable<Float64T> var_double_value(this);
  Label rebox_double(this, &var_double_value);
  Branch(UintPtrLessThan(field_index, instance_size_in_words), &if_inobject,
         &if_backing_store);
  BIND(&if_inobject)Bind(&if_inobject);
  {
    Comment("if_inobject");
    TNode<IntPtrT> field_offset = TimesTaggedSize(field_index);

    Label if_double(this), if_tagged(this);
    Branch(Word32NotEqual(representation,
                          Int32Constant(Representation::kDouble)),
           &if_tagged, &if_double);
    BIND(&if_tagged)Bind(&if_tagged);
    {
      *var_value = LoadObjectField(object, field_offset);
      Goto(&done);
    }
    BIND(&if_double)Bind(&if_double);
    {
      TNode<HeapNumber> heap_number =
          CAST(LoadObjectField(object, field_offset))Cast(LoadObjectField(object, field_offset));
      var_double_value = LoadHeapNumberValue(heap_number);
      Goto(&rebox_double);
    }
  }
  BIND(&if_backing_store)Bind(&if_backing_store);
  {
    Comment("if_backing_store");
    TNode<HeapObject> properties = LoadFastProperties(CAST(object)Cast(object));
    field_index = Signed(IntPtrSub(field_index, instance_size_in_words));
    TNode<Object> value =
        LoadPropertyArrayElement(CAST(properties)Cast(properties), field_index);

    Label if_double(this), if_tagged(this);
    Branch(Word32NotEqual(representation,
                          Int32Constant(Representation::kDouble)),
           &if_tagged, &if_double);
    BIND(&if_tagged)Bind(&if_tagged);
    {
      *var_value = value;
      Goto(&done);
    }
    BIND(&if_double)Bind(&if_double);
    {
      var_double_value = LoadHeapNumberValue(CAST(value)Cast(value));
      Goto(&rebox_double);
    }
  }
  BIND(&rebox_double)Bind(&rebox_double);
  {
    Comment("rebox_double");
    TNode<HeapNumber> heap_number =
        AllocateHeapNumberWithValue(var_double_value.value());
    *var_value = heap_number;
    Goto(&done);
  }
}
BIND(&if_in_descriptor)Bind(&if_in_descriptor);
{
  *var_value = LoadValueByKeyIndex(descriptors, name_index);
  Goto(&done);
}
BIND(&done)Bind(&done);

Comment("] LoadPropertyFromFastObject");
9659}

9661template <typename Dictionary>
9662void CodeStubAssembler::LoadPropertyFromDictionary(
  TNode<Dictionary> dictionary, TNode<IntPtrT> name_index,
  TVariable<Uint32T>* var_details, TVariable<Object>* var_value) {
Comment("LoadPropertyFromNameDictionary");
*var_details = LoadDetailsByKeyIndex(dictionary, name_index);
*var_value = LoadValueByKeyIndex(dictionary, name_index);

Comment("] LoadPropertyFromNameDictionary");
9670}

9672void CodeStubAssembler::LoadPropertyFromGlobalDictionary(
  TNode<GlobalDictionary> dictionary, TNode<IntPtrT> name_index,
  TVariable<Uint32T>* var_details, TVariable<Object>* var_value,
  Label* if_deleted) {
Comment("[ LoadPropertyFromGlobalDictionary");
TNode<PropertyCell> property_cell =
    CAST(LoadFixedArrayElement(dictionary, name_index))Cast(LoadFixedArrayElement(dictionary, name_index));

TNode<Object> value =
    LoadObjectField(property_cell, PropertyCell::kValueOffset);
GotoIf(TaggedEqual(value, TheHoleConstant()), if_deleted);

*var_value = value;

TNode<Uint32T> details = Unsigned(LoadAndUntagToWord32ObjectField(
    property_cell, PropertyCell::kPropertyDetailsRawOffset));
*var_details = details;

Comment("] LoadPropertyFromGlobalDictionary");
9691}

9693template void CodeStubAssembler::LoadPropertyFromDictionary(
  TNode<NameDictionary> dictionary, TNode<IntPtrT> name_index,
  TVariable<Uint32T>* var_details, TVariable<Object>* var_value);

9697template void CodeStubAssembler::LoadPropertyFromDictionary(
  TNode<SwissNameDictionary> dictionary, TNode<IntPtrT> name_index,
  TVariable<Uint32T>* var_details, TVariable<Object>* var_value);

9701// |value| is the property backing store's contents, which is either a value or
9702// an accessor pair, as specified by |details|. |holder| is a JSObject or a
9703// PropertyCell (TODO: use UnionT). Returns either the original value, or the
9704// result of the getter call.
9705TNode<Object> CodeStubAssembler::CallGetterIfAccessor(
  TNode<Object> value, TNode<HeapObject> holder, TNode<Uint32T> details,
  TNode<Context> context, TNode<Object> receiver, TNode<Object> name,
  Label* if_bailout, GetOwnPropertyMode mode) {
TVARIABLE(Object, var_value, value)TVariable<Object> var_value(value, this);
Label done(this), if_accessor_info(this, Label::kDeferred);

TNode<Uint32T> kind = DecodeWord32<PropertyDetails::KindField>(details);
GotoIf(
    Word32Equal(kind, Int32Constant(static_cast<int>(PropertyKind::kData))),
    &done);

// Accessor case.
GotoIfNot(IsAccessorPair(CAST(value)Cast(value)), &if_accessor_info);

// AccessorPair case.
{
  if (mode == kCallJSGetterUseCachedName ||
      mode == kCallJSGetterDontUseCachedName) {
    Label if_callable(this), if_function_template_info(this);
    TNode<AccessorPair> accessor_pair = CAST(value)Cast(value);
    TNode<HeapObject> getter =
        CAST(LoadObjectField(accessor_pair, AccessorPair::kGetterOffset))Cast(LoadObjectField(accessor_pair, AccessorPair::kGetterOffset
));
    TNode<Map> getter_map = LoadMap(getter);

    GotoIf(IsCallableMap(getter_map), &if_callable);
    GotoIf(IsFunctionTemplateInfoMap(getter_map), &if_function_template_info);

    // Return undefined if the {getter} is not callable.
    var_value = UndefinedConstant();
    Goto(&done);

    BIND(&if_callable)Bind(&if_callable);
    {
      // Call the accessor. No need to check side-effect mode here, since it
      // will be checked later in DebugOnFunctionCall.
      var_value = Call(context, getter, receiver);
      Goto(&done);
    }

    BIND(&if_function_template_info)Bind(&if_function_template_info);
    {
      Label runtime(this, Label::kDeferred);
      Label use_cached_property(this);
      GotoIf(IsSideEffectFreeDebuggingActive(), &runtime);
      TNode<HeapObject> cached_property_name = LoadObjectField<HeapObject>(
          getter, FunctionTemplateInfo::kCachedPropertyNameOffset);

      Label* has_cached_property = mode == kCallJSGetterUseCachedName
                                       ? &use_cached_property
                                       : if_bailout;
      GotoIfNot(IsTheHole(cached_property_name), has_cached_property);

      TNode<NativeContext> creation_context =
          GetCreationContext(CAST(holder)Cast(holder), if_bailout);
      var_value = CallBuiltin(
          Builtin::kCallFunctionTemplate_CheckAccessAndCompatibleReceiver,
          creation_context, getter, IntPtrConstant(i::JSParameterCount(0)),
          receiver);
      Goto(&done);

      if (mode == kCallJSGetterUseCachedName) {
        Bind(&use_cached_property);

        var_value = GetProperty(context, holder, cached_property_name);

        Goto(&done);
      }

      BIND(&runtime)Bind(&runtime);
      {
        var_value = CallRuntime(Runtime::kGetProperty, context, holder, name,
                                receiver);
        Goto(&done);
      }
    }
  } else {
    DCHECK_EQ(mode, kReturnAccessorPair)((void) 0);
    Goto(&done);
  }
}

// AccessorInfo case.
BIND(&if_accessor_info)Bind(&if_accessor_info);
{
  TNode<AccessorInfo> accessor_info = CAST(value)Cast(value);
  Label if_array(this), if_function(this), if_wrapper(this);

  // Dispatch based on {holder} instance type.
  TNode<Map> holder_map = LoadMap(holder);
  TNode<Uint16T> holder_instance_type = LoadMapInstanceType(holder_map);
  GotoIf(IsJSArrayInstanceType(holder_instance_type), &if_array);
  GotoIf(IsJSFunctionInstanceType(holder_instance_type), &if_function);
  Branch(IsJSPrimitiveWrapperInstanceType(holder_instance_type), &if_wrapper,
         if_bailout);

  // JSArray AccessorInfo case.
  BIND(&if_array)Bind(&if_array);
  {
    // We only deal with the "length" accessor on JSArray.
    GotoIfNot(IsLengthString(
                  LoadObjectField(accessor_info, AccessorInfo::kNameOffset)),
              if_bailout);
    TNode<JSArray> array = CAST(holder)Cast(holder);
    var_value = LoadJSArrayLength(array);
    Goto(&done);
  }

  // JSFunction AccessorInfo case.
  BIND(&if_function)Bind(&if_function);
  {
    // We only deal with the "prototype" accessor on JSFunction here.
    GotoIfNot(IsPrototypeString(
                  LoadObjectField(accessor_info, AccessorInfo::kNameOffset)),
              if_bailout);

    TNode<JSFunction> function = CAST(holder)Cast(holder);
    GotoIfPrototypeRequiresRuntimeLookup(function, holder_map, if_bailout);
    var_value = LoadJSFunctionPrototype(function, if_bailout);
    Goto(&done);
  }

  // JSPrimitiveWrapper AccessorInfo case.
  BIND(&if_wrapper)Bind(&if_wrapper);
  {
    // We only deal with the "length" accessor on JSPrimitiveWrapper string
    // wrappers.
    GotoIfNot(IsLengthString(
                  LoadObjectField(accessor_info, AccessorInfo::kNameOffset)),
              if_bailout);
    TNode<Object> holder_value = LoadJSPrimitiveWrapperValue(CAST(holder)Cast(holder));
    GotoIfNot(TaggedIsNotSmi(holder_value), if_bailout);
    GotoIfNot(IsString(CAST(holder_value)Cast(holder_value)), if_bailout);
    var_value = LoadStringLengthAsSmi(CAST(holder_value)Cast(holder_value));
    Goto(&done);
  }
}

BIND(&done)Bind(&done);
return var_value.value();
9845}

9847void CodeStubAssembler::TryGetOwnProperty(
  TNode<Context> context, TNode<Object> receiver, TNode<JSReceiver> object,
  TNode<Map> map, TNode<Int32T> instance_type, TNode<Name> unique_name,
  Label* if_found_value, TVariable<Object>* var_value, Label* if_not_found,
  Label* if_bailout) {
TryGetOwnProperty(context, receiver, object, map, instance_type, unique_name,
                  if_found_value, var_value, nullptr, nullptr, if_not_found,
                  if_bailout, kCallJSGetterUseCachedName);
9855}

9857void CodeStubAssembler::TryGetOwnProperty(
  TNode<Context> context, TNode<Object> receiver, TNode<JSReceiver> object,
  TNode<Map> map, TNode<Int32T> instance_type, TNode<Name> unique_name,
  Label* if_found_value, TVariable<Object>* var_value,
  TVariable<Uint32T>* var_details, TVariable<Object>* var_raw_value,
  Label* if_not_found, Label* if_bailout, GetOwnPropertyMode mode) {
DCHECK_EQ(MachineRepresentation::kTagged, var_value->rep())((void) 0);
Comment("TryGetOwnProperty");
CSA_DCHECK(this, IsUniqueNameNoCachedIndex(unique_name))((void)0);
TVARIABLE(HeapObject, var_meta_storage)TVariable<HeapObject> var_meta_storage(this);
TVARIABLE(IntPtrT, var_entry)TVariable<IntPtrT> var_entry(this);

Label if_found_fast(this), if_found_dict(this), if_found_global(this);

TVARIABLE(Uint32T, local_var_details)TVariable<Uint32T> local_var_details(this);
if (!var_details) {
  var_details = &local_var_details;
}
Label if_found(this);

TryLookupProperty(object, map, instance_type, unique_name, &if_found_fast,
                  &if_found_dict, &if_found_global, &var_meta_storage,
                  &var_entry, if_not_found, if_bailout);
BIND(&if_found_fast)Bind(&if_found_fast);
{
  TNode<DescriptorArray> descriptors = CAST(var_meta_storage.value())Cast(var_meta_storage.value());
  TNode<IntPtrT> name_index = var_entry.value();

  LoadPropertyFromFastObject(object, map, descriptors, name_index,
                             var_details, var_value);
  Goto(&if_found);
}
BIND(&if_found_dict)Bind(&if_found_dict);
{
  TNode<PropertyDictionary> dictionary = CAST(var_meta_storage.value())Cast(var_meta_storage.value());
  TNode<IntPtrT> entry = var_entry.value();
  LoadPropertyFromDictionary(dictionary, entry, var_details, var_value);

  Goto(&if_found);
}
BIND(&if_found_global)Bind(&if_found_global);
{
  TNode<GlobalDictionary> dictionary = CAST(var_meta_storage.value())Cast(var_meta_storage.value());
  TNode<IntPtrT> entry = var_entry.value();

  LoadPropertyFromGlobalDictionary(dictionary, entry, var_details, var_value,
                                   if_not_found);
  Goto(&if_found);
}
// Here we have details and value which could be an accessor.
BIND(&if_found)Bind(&if_found);
{
  // TODO(ishell): Execute C++ accessor in case of accessor info
  if (var_raw_value) {
    *var_raw_value = *var_value;
  }
  TNode<Object> value =
      CallGetterIfAccessor(var_value->value(), object, var_details->value(),
                           context, receiver, unique_name, if_bailout, mode);
  *var_value = value;
  Goto(if_found_value);
}
9919}

9921void CodeStubAssembler::TryLookupElement(
  TNode<HeapObject> object, TNode<Map> map, TNode<Int32T> instance_type,
  TNode<IntPtrT> intptr_index, Label* if_found, Label* if_absent,
  Label* if_not_found, Label* if_bailout) {
// Handle special objects in runtime.
GotoIf(IsSpecialReceiverInstanceType(instance_type), if_bailout);

TNode<Int32T> elements_kind = LoadMapElementsKind(map);

// TODO(verwaest): Support other elements kinds as well.
Label if_isobjectorsmi(this), if_isdouble(this), if_isdictionary(this),
    if_isfaststringwrapper(this), if_isslowstringwrapper(this), if_oob(this),
    if_typedarray(this), if_rab_gsab_typedarray(this);
// clang-format off
int32_t values[] = {
    // Handled by {if_isobjectorsmi}.
    PACKED_SMI_ELEMENTS, HOLEY_SMI_ELEMENTS, PACKED_ELEMENTS, HOLEY_ELEMENTS,
    PACKED_NONEXTENSIBLE_ELEMENTS, PACKED_SEALED_ELEMENTS,
    HOLEY_NONEXTENSIBLE_ELEMENTS, HOLEY_SEALED_ELEMENTS,
    PACKED_FROZEN_ELEMENTS, HOLEY_FROZEN_ELEMENTS,
    // Handled by {if_isdouble}.
    PACKED_DOUBLE_ELEMENTS, HOLEY_DOUBLE_ELEMENTS,
    // Handled by {if_isdictionary}.
    DICTIONARY_ELEMENTS,
    // Handled by {if_isfaststringwrapper}.
    FAST_STRING_WRAPPER_ELEMENTS,
    // Handled by {if_isslowstringwrapper}.
    SLOW_STRING_WRAPPER_ELEMENTS,
    // Handled by {if_not_found}.
    NO_ELEMENTS,
    // Handled by {if_typed_array}.
    UINT8_ELEMENTS,
    INT8_ELEMENTS,
    UINT16_ELEMENTS,
    INT16_ELEMENTS,
    UINT32_ELEMENTS,
    INT32_ELEMENTS,
    FLOAT32_ELEMENTS,
    FLOAT64_ELEMENTS,
    UINT8_CLAMPED_ELEMENTS,
    BIGUINT64_ELEMENTS,
    BIGINT64_ELEMENTS,
    RAB_GSAB_UINT8_ELEMENTS,
    RAB_GSAB_INT8_ELEMENTS,
    RAB_GSAB_UINT16_ELEMENTS,
    RAB_GSAB_INT16_ELEMENTS,
    RAB_GSAB_UINT32_ELEMENTS,
    RAB_GSAB_INT32_ELEMENTS,
    RAB_GSAB_FLOAT32_ELEMENTS,
    RAB_GSAB_FLOAT64_ELEMENTS,
    RAB_GSAB_UINT8_CLAMPED_ELEMENTS,
    RAB_GSAB_BIGUINT64_ELEMENTS,
    RAB_GSAB_BIGINT64_ELEMENTS,
};
Label* labels[] = {
    &if_isobjectorsmi, &if_isobjectorsmi, &if_isobjectorsmi,
    &if_isobjectorsmi, &if_isobjectorsmi, &if_isobjectorsmi,
    &if_isobjectorsmi, &if_isobjectorsmi, &if_isobjectorsmi,
    &if_isobjectorsmi,
    &if_isdouble, &if_isdouble,
    &if_isdictionary,
    &if_isfaststringwrapper,
    &if_isslowstringwrapper,
    if_not_found,
    &if_typedarray,
    &if_typedarray,
    &if_typedarray,
    &if_typedarray,
    &if_typedarray,
    &if_typedarray,
    &if_typedarray,
    &if_typedarray,
    &if_typedarray,
    &if_typedarray,
    &if_typedarray,
    &if_rab_gsab_typedarray,
    &if_rab_gsab_typedarray,
    &if_rab_gsab_typedarray,
    &if_rab_gsab_typedarray,
    &if_rab_gsab_typedarray,
    &if_rab_gsab_typedarray,
    &if_rab_gsab_typedarray,
    &if_rab_gsab_typedarray,
    &if_rab_gsab_typedarray,
    &if_rab_gsab_typedarray,
    &if_rab_gsab_typedarray,
};
// clang-format on
STATIC_ASSERT(arraysize(values) == arraysize(labels))static_assert((sizeof(ArraySizeHelper(values))) == (sizeof(ArraySizeHelper
(labels))), "arraysize(values) == arraysize(labels)");
Switch(elements_kind, if_bailout, values, labels, arraysize(values)(sizeof(ArraySizeHelper(values))));

BIND(&if_isobjectorsmi)Bind(&if_isobjectorsmi);
{
  TNode<FixedArray> elements = CAST(LoadElements(CAST(object)))Cast(LoadElements(Cast(object)));
  TNode<IntPtrT> length = LoadAndUntagFixedArrayBaseLength(elements);

  GotoIfNot(UintPtrLessThan(intptr_index, length), &if_oob);

  TNode<Object> element = UnsafeLoadFixedArrayElement(elements, intptr_index);
  TNode<Oddball> the_hole = TheHoleConstant();
  Branch(TaggedEqual(element, the_hole), if_not_found, if_found);
}
BIND(&if_isdouble)Bind(&if_isdouble);
{
  TNode<FixedArrayBase> elements = LoadElements(CAST(object)Cast(object));
  TNode<IntPtrT> length = LoadAndUntagFixedArrayBaseLength(elements);

  GotoIfNot(UintPtrLessThan(intptr_index, length), &if_oob);

  // Check if the element is a double hole, but don't load it.
  LoadFixedDoubleArrayElement(CAST(elements)Cast(elements), intptr_index, if_not_found,
                              MachineType::None());
  Goto(if_found);
}
BIND(&if_isdictionary)Bind(&if_isdictionary);
{
  // Negative and too-large keys must be converted to property names.
  if (Is64()) {
    GotoIf(UintPtrLessThan(IntPtrConstant(JSObject::kMaxElementIndex),
                           intptr_index),
           if_bailout);
  } else {
    GotoIf(IntPtrLessThan(intptr_index, IntPtrConstant(0)), if_bailout);
  }

  TVARIABLE(IntPtrT, var_entry)TVariable<IntPtrT> var_entry(this);
  TNode<NumberDictionary> elements = CAST(LoadElements(CAST(object)))Cast(LoadElements(Cast(object)));
  NumberDictionaryLookup(elements, intptr_index, if_found, &var_entry,
                         if_not_found);
}
BIND(&if_isfaststringwrapper)Bind(&if_isfaststringwrapper);
{
  TNode<String> string = CAST(LoadJSPrimitiveWrapperValue(CAST(object)))Cast(LoadJSPrimitiveWrapperValue(Cast(object)));
  TNode<IntPtrT> length = LoadStringLengthAsWord(string);
  GotoIf(UintPtrLessThan(intptr_index, length), if_found);
  Goto(&if_isobjectorsmi);
}
BIND(&if_isslowstringwrapper)Bind(&if_isslowstringwrapper);
{
  TNode<String> string = CAST(LoadJSPrimitiveWrapperValue(CAST(object)))Cast(LoadJSPrimitiveWrapperValue(Cast(object)));
  TNode<IntPtrT> length = LoadStringLengthAsWord(string);
  GotoIf(UintPtrLessThan(intptr_index, length), if_found);
  Goto(&if_isdictionary);
}
BIND(&if_typedarray)Bind(&if_typedarray);
{
  TNode<JSArrayBuffer> buffer = LoadJSArrayBufferViewBuffer(CAST(object)Cast(object));
  GotoIf(IsDetachedBuffer(buffer), if_absent);

  TNode<UintPtrT> length = LoadJSTypedArrayLength(CAST(object)Cast(object));
  Branch(UintPtrLessThan(intptr_index, length), if_found, if_absent);
}
BIND(&if_rab_gsab_typedarray)Bind(&if_rab_gsab_typedarray);
{
  TNode<JSArrayBuffer> buffer = LoadJSArrayBufferViewBuffer(CAST(object)Cast(object));
  TNode<UintPtrT> length =
      LoadVariableLengthJSTypedArrayLength(CAST(object)Cast(object), buffer, if_absent);
  Branch(UintPtrLessThan(intptr_index, length), if_found, if_absent);
}
BIND(&if_oob)Bind(&if_oob);
{
  // Positive OOB indices mean "not found", negative indices and indices
  // out of array index range must be converted to property names.
  if (Is64()) {
    GotoIf(UintPtrLessThan(IntPtrConstant(JSObject::kMaxElementIndex),
                           intptr_index),
           if_bailout);
  } else {
    GotoIf(IntPtrLessThan(intptr_index, IntPtrConstant(0)), if_bailout);
  }
  Goto(if_not_found);
}
10093}

10095void CodeStubAssembler::BranchIfMaybeSpecialIndex(TNode<String> name_string,
                                                Label* if_maybe_special_index,
                                                Label* if_not_special_index) {
// TODO(cwhan.tunz): Implement fast cases more.

// If a name is empty or too long, it's not a special index
// Max length of canonical double: -X.XXXXXXXXXXXXXXXXX-eXXX
const int kBufferSize = 24;
TNode<Smi> string_length = LoadStringLengthAsSmi(name_string);
GotoIf(SmiEqual(string_length, SmiConstant(0)), if_not_special_index);
GotoIf(SmiGreaterThan(string_length, SmiConstant(kBufferSize)),
       if_not_special_index);

// If the first character of name is not a digit or '-', or we can't match it
// to Infinity or NaN, then this is not a special index.
TNode<Int32T> first_char = StringCharCodeAt(name_string, UintPtrConstant(0));
// If the name starts with '-', it can be a negative index.
GotoIf(Word32Equal(first_char, Int32Constant('-')), if_maybe_special_index);
// If the name starts with 'I', it can be "Infinity".
GotoIf(Word32Equal(first_char, Int32Constant('I')), if_maybe_special_index);
// If the name starts with 'N', it can be "NaN".
GotoIf(Word32Equal(first_char, Int32Constant('N')), if_maybe_special_index);
// Finally, if the first character is not a digit either, then we are sure
// that the name is not a special index.
GotoIf(Uint32LessThan(first_char, Int32Constant('0')), if_not_special_index);
GotoIf(Uint32LessThan(Int32Constant('9'), first_char), if_not_special_index);
Goto(if_maybe_special_index);
10122}

10124void CodeStubAssembler::TryPrototypeChainLookup(
  TNode<Object> receiver, TNode<Object> object_arg, TNode<Object> key,
  const LookupPropertyInHolder& lookup_property_in_holder,
  const LookupElementInHolder& lookup_element_in_holder, Label* if_end,
  Label* if_bailout, Label* if_proxy, bool handle_private_names) {
// Ensure receiver is JSReceiver, otherwise bailout.
GotoIf(TaggedIsSmi(receiver), if_bailout);
TNode<HeapObject> object = CAST(object_arg)Cast(object_arg);

TNode<Map> map = LoadMap(object);
TNode<Uint16T> instance_type = LoadMapInstanceType(map);
{
  Label if_objectisreceiver(this);
  Branch(IsJSReceiverInstanceType(instance_type), &if_objectisreceiver,
         if_bailout);
  BIND(&if_objectisreceiver)Bind(&if_objectisreceiver);

  GotoIf(InstanceTypeEqual(instance_type, JS_PROXY_TYPE), if_proxy);
}

TVARIABLE(IntPtrT, var_index)TVariable<IntPtrT> var_index(this);
TVARIABLE(Name, var_unique)TVariable<Name> var_unique(this);

Label if_keyisindex(this), if_iskeyunique(this);
TryToName(key, &if_keyisindex, &var_index, &if_iskeyunique, &var_unique,
          if_bailout);

BIND(&if_iskeyunique)Bind(&if_iskeyunique);
{
  TVARIABLE(HeapObject, var_holder, object)TVariable<HeapObject> var_holder(object, this);
  TVARIABLE(Map, var_holder_map, map)TVariable<Map> var_holder_map(map, this);
  TVARIABLE(Int32T, var_holder_instance_type, instance_type)TVariable<Int32T> var_holder_instance_type(instance_type
, this);

  Label loop(this, {&var_holder, &var_holder_map, &var_holder_instance_type});
  Goto(&loop);
  BIND(&loop)Bind(&loop);
  {
    TNode<Map> holder_map = var_holder_map.value();
    TNode<Int32T> holder_instance_type = var_holder_instance_type.value();

    Label next_proto(this), check_integer_indexed_exotic(this);
    lookup_property_in_holder(CAST(receiver)Cast(receiver), var_holder.value(), holder_map,
                              holder_instance_type, var_unique.value(),
                              &check_integer_indexed_exotic, if_bailout);

    BIND(&check_integer_indexed_exotic)Bind(&check_integer_indexed_exotic);
    {
      // Bailout if it can be an integer indexed exotic case.
      GotoIfNot(InstanceTypeEqual(holder_instance_type, JS_TYPED_ARRAY_TYPE),
                &next_proto);
      GotoIfNot(IsString(var_unique.value()), &next_proto);
      BranchIfMaybeSpecialIndex(CAST(var_unique.value())Cast(var_unique.value()), if_bailout,
                                &next_proto);
    }

    BIND(&next_proto)Bind(&next_proto);

    if (handle_private_names) {
      // Private name lookup doesn't walk the prototype chain.
      GotoIf(IsPrivateSymbol(CAST(key)Cast(key)), if_end);
    }

    TNode<HeapObject> proto = LoadMapPrototype(holder_map);

    GotoIf(IsNull(proto), if_end);

    TNode<Map> proto_map = LoadMap(proto);
    TNode<Uint16T> proto_instance_type = LoadMapInstanceType(proto_map);

    var_holder = proto;
    var_holder_map = proto_map;
    var_holder_instance_type = proto_instance_type;
    Goto(&loop);
  }
}
BIND(&if_keyisindex)Bind(&if_keyisindex);
{
  TVARIABLE(HeapObject, var_holder, object)TVariable<HeapObject> var_holder(object, this);
  TVARIABLE(Map, var_holder_map, map)TVariable<Map> var_holder_map(map, this);
  TVARIABLE(Int32T, var_holder_instance_type, instance_type)TVariable<Int32T> var_holder_instance_type(instance_type
, this);

  Label loop(this, {&var_holder, &var_holder_map, &var_holder_instance_type});
  Goto(&loop);
  BIND(&loop)Bind(&loop);
  {
    Label next_proto(this);
    lookup_element_in_holder(CAST(receiver)Cast(receiver), var_holder.value(),
                             var_holder_map.value(),
                             var_holder_instance_type.value(),
                             var_index.value(), &next_proto, if_bailout);
    BIND(&next_proto)Bind(&next_proto);

    TNode<HeapObject> proto = LoadMapPrototype(var_holder_map.value());

    GotoIf(IsNull(proto), if_end);

    TNode<Map> proto_map = LoadMap(proto);
    TNode<Uint16T> proto_instance_type = LoadMapInstanceType(proto_map);

    var_holder = proto;
    var_holder_map = proto_map;
    var_holder_instance_type = proto_instance_type;
    Goto(&loop);
  }
}
10229}

10231TNode<Oddball> CodeStubAssembler::HasInPrototypeChain(TNode<Context> context,
                                                    TNode<HeapObject> object,
                                                    TNode<Object> prototype) {
TVARIABLE(Oddball, var_result)TVariable<Oddball> var_result(this);
Label return_false(this), return_true(this),
    return_runtime(this, Label::kDeferred), return_result(this);

// Loop through the prototype chain looking for the {prototype}.
TVARIABLE(Map, var_object_map, LoadMap(object))TVariable<Map> var_object_map(LoadMap(object), this);
Label loop(this, &var_object_map);
Goto(&loop);
BIND(&loop)Bind(&loop);
{
  // Check if we can determine the prototype directly from the {object_map}.
  Label if_objectisdirect(this), if_objectisspecial(this, Label::kDeferred);
  TNode<Map> object_map = var_object_map.value();
  TNode<Uint16T> object_instance_type = LoadMapInstanceType(object_map);
  Branch(IsSpecialReceiverInstanceType(object_instance_type),
         &if_objectisspecial, &if_objectisdirect);
  BIND(&if_objectisspecial)Bind(&if_objectisspecial);
  {
    // The {object_map} is a special receiver map or a primitive map, check
    // if we need to use the if_objectisspecial path in the runtime.
    GotoIf(InstanceTypeEqual(object_instance_type, JS_PROXY_TYPE),
           &return_runtime);
    TNode<Int32T> object_bitfield = LoadMapBitField(object_map);
    int mask = Map::Bits1::HasNamedInterceptorBit::kMask |
               Map::Bits1::IsAccessCheckNeededBit::kMask;
    Branch(IsSetWord32(object_bitfield, mask), &return_runtime,
           &if_objectisdirect);
  }
  BIND(&if_objectisdirect)Bind(&if_objectisdirect);

  // Check the current {object} prototype.
  TNode<HeapObject> object_prototype = LoadMapPrototype(object_map);
  GotoIf(IsNull(object_prototype), &return_false);
  GotoIf(TaggedEqual(object_prototype, prototype), &return_true);

  // Continue with the prototype.
  CSA_DCHECK(this, TaggedIsNotSmi(object_prototype))((void)0);
  var_object_map = LoadMap(object_prototype);
  Goto(&loop);
}

BIND(&return_true)Bind(&return_true);
var_result = TrueConstant();
Goto(&return_result);

BIND(&return_false)Bind(&return_false);
var_result = FalseConstant();
Goto(&return_result);

BIND(&return_runtime)Bind(&return_runtime);
{
  // Fallback to the runtime implementation.
  var_result = CAST(Cast(CallRuntime(Runtime::kHasInPrototypeChain, context, object
, prototype))
      CallRuntime(Runtime::kHasInPrototypeChain, context, object, prototype))Cast(CallRuntime(Runtime::kHasInPrototypeChain, context, object
, prototype));
}
Goto(&return_result);

BIND(&return_result)Bind(&return_result);
return var_result.value();
10293}

10295TNode<Oddball> CodeStubAssembler::OrdinaryHasInstance(
  TNode<Context> context, TNode<Object> callable_maybe_smi,
  TNode<Object> object_maybe_smi) {
TVARIABLE(Oddball, var_result)TVariable<Oddball> var_result(this);
Label return_runtime(this, Label::kDeferred), return_result(this);

GotoIfForceSlowPath(&return_runtime);

// Goto runtime if {object} is a Smi.
GotoIf(TaggedIsSmi(object_maybe_smi), &return_runtime);

// Goto runtime if {callable} is a Smi.
GotoIf(TaggedIsSmi(callable_maybe_smi), &return_runtime);

{
  // Load map of {callable}.
  TNode<HeapObject> object = CAST(object_maybe_smi)Cast(object_maybe_smi);
  TNode<HeapObject> callable = CAST(callable_maybe_smi)Cast(callable_maybe_smi);
  TNode<Map> callable_map = LoadMap(callable);

  // Goto runtime if {callable} is not a JSFunction.
  TNode<Uint16T> callable_instance_type = LoadMapInstanceType(callable_map);
  GotoIfNot(IsJSFunctionInstanceType(callable_instance_type),
            &return_runtime);

  GotoIfPrototypeRequiresRuntimeLookup(CAST(callable)Cast(callable), callable_map,
                                       &return_runtime);

  // Get the "prototype" (or initial map) of the {callable}.
  TNode<HeapObject> callable_prototype = LoadObjectField<HeapObject>(
      callable, JSFunction::kPrototypeOrInitialMapOffset);
  {
    Label no_initial_map(this), walk_prototype_chain(this);
    TVARIABLE(HeapObject, var_callable_prototype, callable_prototype)TVariable<HeapObject> var_callable_prototype(callable_prototype
, this);

    // Resolve the "prototype" if the {callable} has an initial map.
    GotoIfNot(IsMap(callable_prototype), &no_initial_map);
    var_callable_prototype = LoadObjectField<HeapObject>(
        callable_prototype, Map::kPrototypeOffset);
    Goto(&walk_prototype_chain);

    BIND(&no_initial_map)Bind(&no_initial_map);
    // {callable_prototype} is the hole if the "prototype" property hasn't
    // been requested so far.
    Branch(TaggedEqual(callable_prototype, TheHoleConstant()),
           &return_runtime, &walk_prototype_chain);

    BIND(&walk_prototype_chain)Bind(&walk_prototype_chain);
    callable_prototype = var_callable_prototype.value();
  }

  // Loop through the prototype chain looking for the {callable} prototype.
  var_result = HasInPrototypeChain(context, object, callable_prototype);
  Goto(&return_result);
}

BIND(&return_runtime)Bind(&return_runtime);
{
  // Fallback to the runtime implementation.
  var_result = CAST(CallRuntime(Runtime::kOrdinaryHasInstance, context,Cast(CallRuntime(Runtime::kOrdinaryHasInstance, context, callable_maybe_smi
, object_maybe_smi))
                                callable_maybe_smi, object_maybe_smi))Cast(CallRuntime(Runtime::kOrdinaryHasInstance, context, callable_maybe_smi
, object_maybe_smi));
}
Goto(&return_result);

BIND(&return_result)Bind(&return_result);
return var_result.value();
10361}

10363template <typename TIndex>
10364TNode<IntPtrT> CodeStubAssembler::ElementOffsetFromIndex(
  TNode<TIndex> index_node, ElementsKind kind, int base_size) {
// TODO(v8:9708): Remove IntPtrT variant in favor of UintPtrT.
static_assert(std::is_same<TIndex, Smi>::value ||
                  std::is_same<TIndex, TaggedIndex>::value ||
                  std::is_same<TIndex, IntPtrT>::value ||
                  std::is_same<TIndex, UintPtrT>::value,
              "Only Smi, UintPtrT or IntPtrT index nodes are allowed");
int element_size_shift = ElementsKindToShiftSize(kind);
int element_size = 1 << element_size_shift;
intptr_t index = 0;
TNode<IntPtrT> intptr_index_node;
bool constant_index = false;
if (std::is_same<TIndex, Smi>::value) {
  TNode<Smi> smi_index_node = ReinterpretCast<Smi>(index_node);
  int const kSmiShiftBits = kSmiShiftSize + kSmiTagSize;
  element_size_shift -= kSmiShiftBits;
  Smi smi_index;
  constant_index = TryToSmiConstant(smi_index_node, &smi_index);
  if (constant_index) {
    index = smi_index.value();
  } else {
    if (COMPRESS_POINTERS_BOOLfalse) {
      smi_index_node = NormalizeSmiIndex(smi_index_node);
    }
  }
  intptr_index_node = BitcastTaggedToWordForTagAndSmiBits(smi_index_node);
} else if (std::is_same<TIndex, TaggedIndex>::value) {
  TNode<TaggedIndex> tagged_index_node =
      ReinterpretCast<TaggedIndex>(index_node);
  element_size_shift -= kSmiTagSize;
  intptr_index_node = BitcastTaggedToWordForTagAndSmiBits(tagged_index_node);
  constant_index = TryToIntPtrConstant(intptr_index_node, &index);
} else {
  intptr_index_node = ReinterpretCast<IntPtrT>(index_node);
  constant_index = TryToIntPtrConstant(intptr_index_node, &index);
}
if (constant_index) {
  return IntPtrConstant(base_size + element_size * index);
}

TNode<IntPtrT> shifted_index =
    (element_size_shift == 0)
        ? intptr_index_node
        : ((element_size_shift > 0)
               ? WordShl(intptr_index_node,
                         IntPtrConstant(element_size_shift))
               : WordSar(intptr_index_node,
                         IntPtrConstant(-element_size_shift)));
return IntPtrAdd(IntPtrConstant(base_size), Signed(shifted_index));
10414}

10416// Instantiate ElementOffsetFromIndex for Smi and IntPtrT.
10417template V8_EXPORT_PRIVATE TNode<IntPtrT>
10418CodeStubAssembler::ElementOffsetFromIndex<Smi>(TNode<Smi> index_node,
                                             ElementsKind kind,
                                             int base_size);
10421template V8_EXPORT_PRIVATE TNode<IntPtrT>
10422CodeStubAssembler::ElementOffsetFromIndex<TaggedIndex>(
  TNode<TaggedIndex> index_node, ElementsKind kind, int base_size);
10424template V8_EXPORT_PRIVATE TNode<IntPtrT>
10425CodeStubAssembler::ElementOffsetFromIndex<IntPtrT>(TNode<IntPtrT> index_node,
                                                 ElementsKind kind,
                                                 int base_size);

10429TNode<BoolT> CodeStubAssembler::IsOffsetInBounds(TNode<IntPtrT> offset,
                                               TNode<IntPtrT> length,
                                               int header_size,
                                               ElementsKind kind) {
// Make sure we point to the last field.
int element_size = 1 << ElementsKindToShiftSize(kind);
int correction = header_size - kHeapObjectTag - element_size;
TNode<IntPtrT> last_offset = ElementOffsetFromIndex(length, kind, correction);
return IntPtrLessThanOrEqual(offset, last_offset);
10438}

10440TNode<HeapObject> CodeStubAssembler::LoadFeedbackCellValue(
  TNode<JSFunction> closure) {
TNode<FeedbackCell> feedback_cell =
    LoadObjectField<FeedbackCell>(closure, JSFunction::kFeedbackCellOffset);
return LoadObjectField<HeapObject>(feedback_cell, FeedbackCell::kValueOffset);
10445}

10447TNode<HeapObject> CodeStubAssembler::LoadFeedbackVector(
  TNode<JSFunction> closure) {
TVARIABLE(HeapObject, maybe_vector, LoadFeedbackCellValue(closure))TVariable<HeapObject> maybe_vector(LoadFeedbackCellValue
(closure), this);
Label done(this);

// If the closure doesn't have a feedback vector allocated yet, return
// undefined. FeedbackCell can contain Undefined / FixedArray (for lazy
// allocations) / FeedbackVector.
GotoIf(IsFeedbackVector(maybe_vector.value()), &done);

// In all other cases return Undefined.
maybe_vector = UndefinedConstant();
Goto(&done);

BIND(&done)Bind(&done);
return maybe_vector.value();
10463}

10465TNode<ClosureFeedbackCellArray> CodeStubAssembler::LoadClosureFeedbackArray(
  TNode<JSFunction> closure) {
TVARIABLE(HeapObject, feedback_cell_array, LoadFeedbackCellValue(closure))TVariable<HeapObject> feedback_cell_array(LoadFeedbackCellValue
(closure), this);
Label end(this);

// When feedback vectors are not yet allocated feedback cell contains a
// an array of feedback cells used by create closures.
GotoIf(HasInstanceType(feedback_cell_array.value(),
                       CLOSURE_FEEDBACK_CELL_ARRAY_TYPE),
       &end);

// Load FeedbackCellArray from feedback vector.
TNode<FeedbackVector> vector = CAST(feedback_cell_array.value())Cast(feedback_cell_array.value());
feedback_cell_array = CAST(Cast(LoadObjectField(vector, FeedbackVector::kClosureFeedbackCellArrayOffset
))
    LoadObjectField(vector, FeedbackVector::kClosureFeedbackCellArrayOffset))Cast(LoadObjectField(vector, FeedbackVector::kClosureFeedbackCellArrayOffset
));
Goto(&end);

BIND(&end)Bind(&end);
return CAST(feedback_cell_array.value())Cast(feedback_cell_array.value());
10484}

10486TNode<FeedbackVector> CodeStubAssembler::LoadFeedbackVectorForStub() {
TNode<JSFunction> function =
    CAST(LoadFromParentFrame(StandardFrameConstants::kFunctionOffset))Cast(LoadFromParentFrame(StandardFrameConstants::kFunctionOffset
));
return CAST(LoadFeedbackVector(function))Cast(LoadFeedbackVector(function));
10490}

10492TNode<FeedbackVector> CodeStubAssembler::LoadFeedbackVectorFromBaseline() {
return CAST(Cast(LoadFromParentFrame(InterpreterFrameConstants::kBytecodeOffsetFromFp
))
    LoadFromParentFrame(InterpreterFrameConstants::kBytecodeOffsetFromFp))Cast(LoadFromParentFrame(InterpreterFrameConstants::kBytecodeOffsetFromFp
));
10495}

10497TNode<Context> CodeStubAssembler::LoadContextFromBaseline() {
return CAST(LoadFromParentFrame(InterpreterFrameConstants::kContextOffset))Cast(LoadFromParentFrame(InterpreterFrameConstants::kContextOffset
));
10499}

10501TNode<FeedbackVector>
10502CodeStubAssembler::LoadFeedbackVectorForStubWithTrampoline() {
TNode<RawPtrT> frame_pointer = LoadParentFramePointer();
TNode<RawPtrT> parent_frame_pointer = Load<RawPtrT>(frame_pointer);
TNode<JSFunction> function = CAST(Cast(LoadFullTagged(parent_frame_pointer, IntPtrConstant(StandardFrameConstants
::kFunctionOffset)))
    LoadFullTagged(parent_frame_pointer,Cast(LoadFullTagged(parent_frame_pointer, IntPtrConstant(StandardFrameConstants
::kFunctionOffset)))
                   IntPtrConstant(StandardFrameConstants::kFunctionOffset)))Cast(LoadFullTagged(parent_frame_pointer, IntPtrConstant(StandardFrameConstants
::kFunctionOffset)));
return CAST(LoadFeedbackVector(function))Cast(LoadFeedbackVector(function));
10509}

10511void CodeStubAssembler::UpdateFeedback(TNode<Smi> feedback,
                                     TNode<HeapObject> maybe_feedback_vector,
                                     TNode<UintPtrT> slot_id,
                                     UpdateFeedbackMode mode) {
switch (mode) {
  case UpdateFeedbackMode::kOptionalFeedback:
    MaybeUpdateFeedback(feedback, maybe_feedback_vector, slot_id);
    break;
  case UpdateFeedbackMode::kGuaranteedFeedback:
    CSA_DCHECK(this, IsFeedbackVector(maybe_feedback_vector))((void)0);
    UpdateFeedback(feedback, CAST(maybe_feedback_vector)Cast(maybe_feedback_vector), slot_id);
    break;
}
10524}

10526void CodeStubAssembler::MaybeUpdateFeedback(TNode<Smi> feedback,
                                          TNode<HeapObject> maybe_vector,
                                          TNode<UintPtrT> slot_id) {
Label end(this);
GotoIf(IsUndefined(maybe_vector), &end);
{
  UpdateFeedback(feedback, CAST(maybe_vector)Cast(maybe_vector), slot_id);
  Goto(&end);
}
BIND(&end)Bind(&end);
10536}

10538void CodeStubAssembler::UpdateFeedback(TNode<Smi> feedback,
                                     TNode<FeedbackVector> feedback_vector,
                                     TNode<UintPtrT> slot_id) {
Label end(this);

// This method is used for binary op and compare feedback. These
// vector nodes are initialized with a smi 0, so we can simply OR
// our new feedback in place.
TNode<MaybeObject> feedback_element =
    LoadFeedbackVectorSlot(feedback_vector, slot_id);
TNode<Smi> previous_feedback = CAST(feedback_element)Cast(feedback_element);
TNode<Smi> combined_feedback = SmiOr(previous_feedback, feedback);

GotoIf(SmiEqual(previous_feedback, combined_feedback), &end);
{
  StoreFeedbackVectorSlot(feedback_vector, slot_id, combined_feedback,
                          SKIP_WRITE_BARRIER);
  ReportFeedbackUpdate(feedback_vector, slot_id, "UpdateFeedback");
  Goto(&end);
}

BIND(&end)Bind(&end);
10560}

10562void CodeStubAssembler::ReportFeedbackUpdate(
  TNode<FeedbackVector> feedback_vector, TNode<UintPtrT> slot_id,
  const char* reason) {
// Reset profiler ticks.
StoreObjectFieldNoWriteBarrier(
    feedback_vector, FeedbackVector::kProfilerTicksOffset, Int32Constant(0));

10569#ifdef V8_TRACE_FEEDBACK_UPDATES
// Trace the update.
CallRuntime(Runtime::kTraceUpdateFeedback, NoContextConstant(),
            LoadFromParentFrame(StandardFrameConstants::kFunctionOffset),
            SmiTag(Signed(slot_id)), StringConstant(reason));
10574#endif  // V8_TRACE_FEEDBACK_UPDATES
10575}

10577void CodeStubAssembler::OverwriteFeedback(TVariable<Smi>* existing_feedback,
                                        int new_feedback) {
if (existing_feedback == nullptr) return;
*existing_feedback = SmiConstant(new_feedback);
10581}

10583void CodeStubAssembler::CombineFeedback(TVariable<Smi>* existing_feedback,
                                      int feedback) {
if (existing_feedback == nullptr) return;
*existing_feedback = SmiOr(existing_feedback->value(), SmiConstant(feedback));
10587}

10589void CodeStubAssembler::CombineFeedback(TVariable<Smi>* existing_feedback,
                                      TNode<Smi> feedback) {
if (existing_feedback == nullptr) return;
*existing_feedback = SmiOr(existing_feedback->value(), feedback);
10593}

10595void CodeStubAssembler::CheckForAssociatedProtector(TNode<Name> name,
                                                  Label* if_protector) {
// This list must be kept in sync with LookupIterator::UpdateProtector!
// TODO(jkummerow): Would it be faster to have a bit in Symbol::flags()?
GotoIf(TaggedEqual(name, ConstructorStringConstant()), if_protector);
GotoIf(TaggedEqual(name, IteratorSymbolConstant()), if_protector);
GotoIf(TaggedEqual(name, NextStringConstant()), if_protector);
GotoIf(TaggedEqual(name, SpeciesSymbolConstant()), if_protector);
GotoIf(TaggedEqual(name, IsConcatSpreadableSymbolConstant()), if_protector);
GotoIf(TaggedEqual(name, ResolveStringConstant()), if_protector);
GotoIf(TaggedEqual(name, ThenStringConstant()), if_protector);
// Fall through if no case matched.
10607}

10609TNode<Map> CodeStubAssembler::LoadReceiverMap(TNode<Object> receiver) {
return Select<Map>(
    TaggedIsSmi(receiver), [=] { return HeapNumberMapConstant(); },
    [=] { return LoadMap(UncheckedCast<HeapObject>(receiver)); });
10613}

10615TNode<IntPtrT> CodeStubAssembler::TryToIntptr(
  TNode<Object> key, Label* if_not_intptr,
  TVariable<Int32T>* var_instance_type) {
TVARIABLE(IntPtrT, var_intptr_key)TVariable<IntPtrT> var_intptr_key(this);
Label done(this, &var_intptr_key), key_is_smi(this), key_is_heapnumber(this);
GotoIf(TaggedIsSmi(key), &key_is_smi);

TNode<Int32T> instance_type = LoadInstanceType(CAST(key)Cast(key));
if (var_instance_type != nullptr) {
  *var_instance_type = instance_type;
}

Branch(IsHeapNumberInstanceType(instance_type), &key_is_heapnumber,
       if_not_intptr);

BIND(&key_is_smi)Bind(&key_is_smi);
{
  var_intptr_key = SmiUntag(CAST(key)Cast(key));
  Goto(&done);
}

BIND(&key_is_heapnumber)Bind(&key_is_heapnumber);
{
  TNode<Float64T> value = LoadHeapNumberValue(CAST(key)Cast(key));
  TNode<IntPtrT> int_value = ChangeFloat64ToIntPtr(value);
  GotoIfNot(Float64Equal(value, RoundIntPtrToFloat64(int_value)),
            if_not_intptr);
10642#if V8_TARGET_ARCH_64_BIT1
  // We can't rely on Is64() alone because 32-bit compilers rightly complain
  // about kMaxSafeIntegerUint64 not fitting into an intptr_t.
  DCHECK(Is64())((void) 0);
  // TODO(jkummerow): Investigate whether we can drop support for
  // negative indices.
  GotoIfNot(IsInRange(int_value, static_cast<intptr_t>(-kMaxSafeInteger),
                      static_cast<intptr_t>(kMaxSafeIntegerUint64)),
            if_not_intptr);
10651#else
  DCHECK(!Is64())((void) 0);
10653#endif
  var_intptr_key = int_value;
  Goto(&done);
}

BIND(&done)Bind(&done);
return var_intptr_key.value();
10660}

10662TNode<Context> CodeStubAssembler::LoadScriptContext(
  TNode<Context> context, TNode<IntPtrT> context_index) {
TNode<NativeContext> native_context = LoadNativeContext(context);
TNode<ScriptContextTable> script_context_table = CAST(Cast(LoadContextElement(native_context, Context::SCRIPT_CONTEXT_TABLE_INDEX
))
    LoadContextElement(native_context, Context::SCRIPT_CONTEXT_TABLE_INDEX))Cast(LoadContextElement(native_context, Context::SCRIPT_CONTEXT_TABLE_INDEX
));

TNode<Context> script_context = CAST(LoadFixedArrayElement(Cast(LoadFixedArrayElement( script_context_table, context_index
, ScriptContextTable::kFirstContextSlotIndex * kTaggedSize))
    script_context_table, context_index,Cast(LoadFixedArrayElement( script_context_table, context_index
, ScriptContextTable::kFirstContextSlotIndex * kTaggedSize))
    ScriptContextTable::kFirstContextSlotIndex * kTaggedSize))Cast(LoadFixedArrayElement( script_context_table, context_index
, ScriptContextTable::kFirstContextSlotIndex * kTaggedSize));
return script_context;
10672}

10674namespace {

10676// Converts typed array elements kind to a machine representations.
10677MachineRepresentation ElementsKindToMachineRepresentation(ElementsKind kind) {
switch (kind) {
  case UINT8_CLAMPED_ELEMENTS:
  case UINT8_ELEMENTS:
  case INT8_ELEMENTS:
    return MachineRepresentation::kWord8;
  case UINT16_ELEMENTS:
  case INT16_ELEMENTS:
    return MachineRepresentation::kWord16;
  case UINT32_ELEMENTS:
  case INT32_ELEMENTS:
    return MachineRepresentation::kWord32;
  case FLOAT32_ELEMENTS:
    return MachineRepresentation::kFloat32;
  case FLOAT64_ELEMENTS:
    return MachineRepresentation::kFloat64;
  default:
    UNREACHABLE()V8_Fatal("unreachable code");
}
10696}

10698}  // namespace

10700// TODO(solanes): Since we can't use `if constexpr` until we enable C++17 we
10701// have to specialize the BigInt and Word32T cases. Since we can't partly
10702// specialize, we have to specialize all used combinations.
10703template <typename TIndex>
10704void CodeStubAssembler::StoreElementTypedArrayBigInt(TNode<RawPtrT> elements,
                                                   ElementsKind kind,
                                                   TNode<TIndex> index,
                                                   TNode<BigInt> value) {
static_assert(std::is_same<TIndex, UintPtrT>::value ||
                  std::is_same<TIndex, IntPtrT>::value,
              "Only UintPtrT or IntPtrT indices is allowed");
DCHECK(kind == BIGINT64_ELEMENTS || kind == BIGUINT64_ELEMENTS)((void) 0);
TNode<IntPtrT> offset = ElementOffsetFromIndex(index, kind, 0);
TVARIABLE(UintPtrT, var_low)TVariable<UintPtrT> var_low(this);
// Only used on 32-bit platforms.
TVARIABLE(UintPtrT, var_high)TVariable<UintPtrT> var_high(this);
BigIntToRawBytes(value, &var_low, &var_high);

MachineRepresentation rep = WordT::kMachineRepresentation;
10719#if defined(V8_TARGET_BIG_ENDIAN)
  if (!Is64()) {
    StoreNoWriteBarrier(rep, elements, offset, var_high.value());
    StoreNoWriteBarrier(rep, elements,
                        IntPtrAdd(offset, IntPtrConstant(kSystemPointerSize)),
                        var_low.value());
  } else {
    StoreNoWriteBarrier(rep, elements, offset, var_low.value());
  }
10728#else
  StoreNoWriteBarrier(rep, elements, offset, var_low.value());
  if (!Is64()) {
    StoreNoWriteBarrier(rep, elements,
                        IntPtrAdd(offset, IntPtrConstant(kSystemPointerSize)),
                        var_high.value());
  }
10735#endif
10736}

10738template <>
10739void CodeStubAssembler::StoreElementTypedArray(TNode<RawPtrT> elements,
                                             ElementsKind kind,
                                             TNode<UintPtrT> index,
                                             TNode<BigInt> value) {
StoreElementTypedArrayBigInt(elements, kind, index, value);
10744}

10746template <>
10747void CodeStubAssembler::StoreElementTypedArray(TNode<RawPtrT> elements,
                                             ElementsKind kind,
                                             TNode<IntPtrT> index,
                                             TNode<BigInt> value) {
StoreElementTypedArrayBigInt(elements, kind, index, value);
10752}

10754template <typename TIndex>
10755void CodeStubAssembler::StoreElementTypedArrayWord32(TNode<RawPtrT> elements,
                                                   ElementsKind kind,
                                                   TNode<TIndex> index,
                                                   TNode<Word32T> value) {
static_assert(std::is_same<TIndex, UintPtrT>::value ||
                  std::is_same<TIndex, IntPtrT>::value,
              "Only UintPtrT or IntPtrT indices is allowed");
DCHECK(IsTypedArrayElementsKind(kind))((void) 0);
if (kind == UINT8_CLAMPED_ELEMENTS) {
  CSA_DCHECK(this, Word32Equal(value, Word32And(Int32Constant(0xFF), value)))((void)0);
}
TNode<IntPtrT> offset = ElementOffsetFromIndex(index, kind, 0);
// TODO(cbruni): Add OOB check once typed.
MachineRepresentation rep = ElementsKindToMachineRepresentation(kind);
StoreNoWriteBarrier(rep, elements, offset, value);
10770}

10772template <>
10773void CodeStubAssembler::StoreElementTypedArray(TNode<RawPtrT> elements,
                                             ElementsKind kind,
                                             TNode<UintPtrT> index,
                                             TNode<Word32T> value) {
StoreElementTypedArrayWord32(elements, kind, index, value);
10778}

10780template <>
10781void CodeStubAssembler::StoreElementTypedArray(TNode<RawPtrT> elements,
                                             ElementsKind kind,
                                             TNode<IntPtrT> index,
                                             TNode<Word32T> value) {
StoreElementTypedArrayWord32(elements, kind, index, value);
10786}

10788template <typename TArray, typename TIndex, typename TValue>
10789void CodeStubAssembler::StoreElementTypedArray(TNode<TArray> elements,
                                             ElementsKind kind,
                                             TNode<TIndex> index,
                                             TNode<TValue> value) {
// TODO(v8:9708): Do we want to keep both IntPtrT and UintPtrT variants?
static_assert(std::is_same<TIndex, Smi>::value ||
                  std::is_same<TIndex, UintPtrT>::value ||
                  std::is_same<TIndex, IntPtrT>::value,
              "Only Smi, UintPtrT or IntPtrT indices is allowed");
static_assert(std::is_same<TArray, RawPtrT>::value ||
                  std::is_same<TArray, FixedArrayBase>::value,
              "Only RawPtrT or FixedArrayBase elements are allowed");
static_assert(std::is_same<TValue, Int32T>::value ||
                  std::is_same<TValue, Float32T>::value ||
                  std::is_same<TValue, Float64T>::value ||
                  std::is_same<TValue, Object>::value,
              "Only Int32T, Float32T, Float64T or object value "
              "types are allowed");
DCHECK(IsTypedArrayElementsKind(kind))((void) 0);
TNode<IntPtrT> offset = ElementOffsetFromIndex(index, kind, 0);
// TODO(cbruni): Add OOB check once typed.
MachineRepresentation rep = ElementsKindToMachineRepresentation(kind);
StoreNoWriteBarrier(rep, elements, offset, value);
10812}

10814template <typename TIndex>
10815void CodeStubAssembler::StoreElement(TNode<FixedArrayBase> elements,
                                   ElementsKind kind, TNode<TIndex> index,
                                   TNode<Object> value) {
static_assert(
    std::is_same<TIndex, Smi>::value || std::is_same<TIndex, IntPtrT>::value,
    "Only Smi or IntPtrT indices are allowed");
DCHECK(!IsDoubleElementsKind(kind))((void) 0);
if (IsTypedArrayElementsKind(kind)) {
  StoreElementTypedArray(elements, kind, index, value);
} else if (IsSmiElementsKind(kind)) {
  TNode<Smi> smi_value = CAST(value)Cast(value);
  StoreFixedArrayElement(CAST(elements)Cast(elements), index, smi_value);
} else {
  StoreFixedArrayElement(CAST(elements)Cast(elements), index, value);
}
10830}

10832template <typename TIndex>
10833void CodeStubAssembler::StoreElement(TNode<FixedArrayBase> elements,
                                   ElementsKind kind, TNode<TIndex> index,
                                   TNode<Float64T> value) {
static_assert(
    std::is_same<TIndex, Smi>::value || std::is_same<TIndex, IntPtrT>::value,
    "Only Smi or IntPtrT indices are allowed");
DCHECK(IsDoubleElementsKind(kind))((void) 0);
StoreFixedDoubleArrayElement(CAST(elements)Cast(elements), index, value);
10841}

10843template <typename TIndex, typename TValue>
10844void CodeStubAssembler::StoreElement(TNode<RawPtrT> elements, ElementsKind kind,
                                   TNode<TIndex> index, TNode<TValue> value) {
static_assert(std::is_same<TIndex, Smi>::value ||
                  std::is_same<TIndex, IntPtrT>::value ||
                  std::is_same<TIndex, UintPtrT>::value,
              "Only Smi, IntPtrT or UintPtrT indices are allowed");
static_assert(
    std::is_same<TValue, Int32T>::value ||
        std::is_same<TValue, Word32T>::value ||
        std::is_same<TValue, Float32T>::value ||
        std::is_same<TValue, Float64T>::value ||
        std::is_same<TValue, BigInt>::value,
    "Only Int32T, Word32T, Float32T, Float64T or BigInt value types "
    "are allowed");

DCHECK(IsTypedArrayElementsKind(kind))((void) 0);
StoreElementTypedArray(elements, kind, index, value);
10861}
10862template V8_EXPORT_PRIVATE void CodeStubAssembler::StoreElement(TNode<RawPtrT>,
                                                              ElementsKind,
                                                              TNode<UintPtrT>,
                                                              TNode<Int32T>);
10866template V8_EXPORT_PRIVATE void CodeStubAssembler::StoreElement(TNode<RawPtrT>,
                                                              ElementsKind,
                                                              TNode<UintPtrT>,
                                                              TNode<Word32T>);
10870template V8_EXPORT_PRIVATE void CodeStubAssembler::StoreElement(
  TNode<RawPtrT>, ElementsKind, TNode<UintPtrT>, TNode<Float32T>);
10872template V8_EXPORT_PRIVATE void CodeStubAssembler::StoreElement(
  TNode<RawPtrT>, ElementsKind, TNode<UintPtrT>, TNode<Float64T>);
10874template V8_EXPORT_PRIVATE void CodeStubAssembler::StoreElement(TNode<RawPtrT>,
                                                              ElementsKind,
                                                              TNode<UintPtrT>,
                                                              TNode<BigInt>);

10879TNode<Uint8T> CodeStubAssembler::Int32ToUint8Clamped(
  TNode<Int32T> int32_value) {
Label done(this);
TNode<Int32T> int32_zero = Int32Constant(0);
TNode<Int32T> int32_255 = Int32Constant(255);
TVARIABLE(Word32T, var_value, int32_value)TVariable<Word32T> var_value(int32_value, this);
GotoIf(Uint32LessThanOrEqual(int32_value, int32_255), &done);
var_value = int32_zero;
GotoIf(Int32LessThan(int32_value, int32_zero), &done);
var_value = int32_255;
Goto(&done);
BIND(&done)Bind(&done);
return UncheckedCast<Uint8T>(var_value.value());
10892}

10894TNode<Uint8T> CodeStubAssembler::Float64ToUint8Clamped(
  TNode<Float64T> float64_value) {
Label done(this);
TVARIABLE(Word32T, var_value, Int32Constant(0))TVariable<Word32T> var_value(Int32Constant(0), this);
GotoIf(Float64LessThanOrEqual(float64_value, Float64Constant(0.0)), &done);
var_value = Int32Constant(255);
GotoIf(Float64LessThanOrEqual(Float64Constant(255.0), float64_value), &done);
{
  TNode<Float64T> rounded_value = Float64RoundToEven(float64_value);
  var_value = TruncateFloat64ToWord32(rounded_value);
  Goto(&done);
}
BIND(&done)Bind(&done);
return UncheckedCast<Uint8T>(var_value.value());
10908}

10910template <>
10911TNode<Word32T> CodeStubAssembler::PrepareValueForWriteToTypedArray<Word32T>(
  TNode<Object> input, ElementsKind elements_kind, TNode<Context> context) {
DCHECK(IsTypedArrayElementsKind(elements_kind))((void) 0);

switch (elements_kind) {
  case UINT8_ELEMENTS:
  case INT8_ELEMENTS:
  case UINT16_ELEMENTS:
  case INT16_ELEMENTS:
  case UINT32_ELEMENTS:
  case INT32_ELEMENTS:
  case UINT8_CLAMPED_ELEMENTS:
    break;
  default:
    UNREACHABLE()V8_Fatal("unreachable code");
}

TVARIABLE(Word32T, var_result)TVariable<Word32T> var_result(this);
TVARIABLE(Object, var_input, input)TVariable<Object> var_input(input, this);
Label done(this, &var_result), if_smi(this), if_heapnumber_or_oddball(this),
    convert(this), loop(this, &var_input);
Goto(&loop);
BIND(&loop)Bind(&loop);
GotoIf(TaggedIsSmi(var_input.value()), &if_smi);
// We can handle both HeapNumber and Oddball here, since Oddball has the
// same layout as the HeapNumber for the HeapNumber::value field. This
// way we can also properly optimize stores of oddballs to typed arrays.
TNode<HeapObject> heap_object = CAST(var_input.value())Cast(var_input.value());
GotoIf(IsHeapNumber(heap_object), &if_heapnumber_or_oddball);
STATIC_ASSERT_FIELD_OFFSETS_EQUAL(HeapNumber::kValueOffset,static_assert(static_cast<int>(HeapNumber::kValueOffset
) == Oddball::kToNumberRawOffset, "static_cast<int>(HeapNumber::kValueOffset) == Oddball::kToNumberRawOffset"
)
                                  Oddball::kToNumberRawOffset)static_assert(static_cast<int>(HeapNumber::kValueOffset
) == Oddball::kToNumberRawOffset, "static_cast<int>(HeapNumber::kValueOffset) == Oddball::kToNumberRawOffset"
);
Branch(HasInstanceType(heap_object, ODDBALL_TYPE), &if_heapnumber_or_oddball,
       &convert);

BIND(&if_heapnumber_or_oddball)Bind(&if_heapnumber_or_oddball);
{
  TNode<Float64T> value =
      LoadObjectField<Float64T>(heap_object, HeapNumber::kValueOffset);
  if (elements_kind == UINT8_CLAMPED_ELEMENTS) {
    var_result = Float64ToUint8Clamped(value);
  } else {
    var_result = TruncateFloat64ToWord32(value);
  }
  Goto(&done);
}

BIND(&if_smi)Bind(&if_smi);
{
  TNode<Int32T> value = SmiToInt32(CAST(var_input.value())Cast(var_input.value()));
  if (elements_kind == UINT8_CLAMPED_ELEMENTS) {
    var_result = Int32ToUint8Clamped(value);
  } else {
    var_result = value;
  }
  Goto(&done);
}

BIND(&convert)Bind(&convert);
{
  var_input = CallBuiltin(Builtin::kNonNumberToNumber, context, input);
  Goto(&loop);
}

BIND(&done)Bind(&done);
return var_result.value();
10976}

10978template <>
10979TNode<Float32T> CodeStubAssembler::PrepareValueForWriteToTypedArray<Float32T>(
  TNode<Object> input, ElementsKind elements_kind, TNode<Context> context) {
DCHECK(IsTypedArrayElementsKind(elements_kind))((void) 0);
CHECK_EQ(elements_kind, FLOAT32_ELEMENTS)do { bool _cmp = ::v8::base::CmpEQImpl< typename ::v8::base
::pass_value_or_ref<decltype(elements_kind)>::type, typename
 ::v8::base::pass_value_or_ref<decltype(FLOAT32_ELEMENTS)>
::type>((elements_kind), (FLOAT32_ELEMENTS)); do { if ((__builtin_expect
(!!(!(_cmp)), 0))) { V8_Fatal("Check failed: %s.", "elements_kind"
 " " "==" " " "FLOAT32_ELEMENTS"); } } while (false); } while
 (false);

TVARIABLE(Float32T, var_result)TVariable<Float32T> var_result(this);
TVARIABLE(Object, var_input, input)TVariable<Object> var_input(input, this);
Label done(this, &var_result), if_smi(this), if_heapnumber_or_oddball(this),
    convert(this), loop(this, &var_input);
Goto(&loop);
BIND(&loop)Bind(&loop);
GotoIf(TaggedIsSmi(var_input.value()), &if_smi);
// We can handle both HeapNumber and Oddball here, since Oddball has the
// same layout as the HeapNumber for the HeapNumber::value field. This
// way we can also properly optimize stores of oddballs to typed arrays.
TNode<HeapObject> heap_object = CAST(var_input.value())Cast(var_input.value());
GotoIf(IsHeapNumber(heap_object), &if_heapnumber_or_oddball);
STATIC_ASSERT_FIELD_OFFSETS_EQUAL(HeapNumber::kValueOffset,static_assert(static_cast<int>(HeapNumber::kValueOffset
) == Oddball::kToNumberRawOffset, "static_cast<int>(HeapNumber::kValueOffset) == Oddball::kToNumberRawOffset"
)
                                  Oddball::kToNumberRawOffset)static_assert(static_cast<int>(HeapNumber::kValueOffset
) == Oddball::kToNumberRawOffset, "static_cast<int>(HeapNumber::kValueOffset) == Oddball::kToNumberRawOffset"
);
Branch(HasInstanceType(heap_object, ODDBALL_TYPE), &if_heapnumber_or_oddball,
       &convert);

BIND(&if_heapnumber_or_oddball)Bind(&if_heapnumber_or_oddball);
{
  TNode<Float64T> value =
      LoadObjectField<Float64T>(heap_object, HeapNumber::kValueOffset);
  var_result = TruncateFloat64ToFloat32(value);
  Goto(&done);
}

BIND(&if_smi)Bind(&if_smi);
{
  TNode<Int32T> value = SmiToInt32(CAST(var_input.value())Cast(var_input.value()));
  var_result = RoundInt32ToFloat32(value);
  Goto(&done);
}

BIND(&convert)Bind(&convert);
{
  var_input = CallBuiltin(Builtin::kNonNumberToNumber, context, input);
  Goto(&loop);
}

BIND(&done)Bind(&done);
return var_result.value();
11024}

11026template <>
11027TNode<Float64T> CodeStubAssembler::PrepareValueForWriteToTypedArray<Float64T>(
  TNode<Object> input, ElementsKind elements_kind, TNode<Context> context) {
DCHECK(IsTypedArrayElementsKind(elements_kind))((void) 0);
CHECK_EQ(elements_kind, FLOAT64_ELEMENTS)do { bool _cmp = ::v8::base::CmpEQImpl< typename ::v8::base
::pass_value_or_ref<decltype(elements_kind)>::type, typename
 ::v8::base::pass_value_or_ref<decltype(FLOAT64_ELEMENTS)>
::type>((elements_kind), (FLOAT64_ELEMENTS)); do { if ((__builtin_expect
(!!(!(_cmp)), 0))) { V8_Fatal("Check failed: %s.", "elements_kind"
 " " "==" " " "FLOAT64_ELEMENTS"); } } while (false); } while
 (false);

TVARIABLE(Float64T, var_result)TVariable<Float64T> var_result(this);
TVARIABLE(Object, var_input, input)TVariable<Object> var_input(input, this);
Label done(this, &var_result), if_smi(this), if_heapnumber_or_oddball(this),
    convert(this), loop(this, &var_input);
Goto(&loop);
BIND(&loop)Bind(&loop);
GotoIf(TaggedIsSmi(var_input.value()), &if_smi);
// We can handle both HeapNumber and Oddball here, since Oddball has the
// same layout as the HeapNumber for the HeapNumber::value field. This
// way we can also properly optimize stores of oddballs to typed arrays.
TNode<HeapObject> heap_object = CAST(var_input.value())Cast(var_input.value());
GotoIf(IsHeapNumber(heap_object), &if_heapnumber_or_oddball);
STATIC_ASSERT_FIELD_OFFSETS_EQUAL(HeapNumber::kValueOffset,static_assert(static_cast<int>(HeapNumber::kValueOffset
) == Oddball::kToNumberRawOffset, "static_cast<int>(HeapNumber::kValueOffset) == Oddball::kToNumberRawOffset"
)
                                  Oddball::kToNumberRawOffset)static_assert(static_cast<int>(HeapNumber::kValueOffset
) == Oddball::kToNumberRawOffset, "static_cast<int>(HeapNumber::kValueOffset) == Oddball::kToNumberRawOffset"
);
Branch(HasInstanceType(heap_object, ODDBALL_TYPE), &if_heapnumber_or_oddball,
       &convert);

BIND(&if_heapnumber_or_oddball)Bind(&if_heapnumber_or_oddball);
{
  var_result =
      LoadObjectField<Float64T>(heap_object, HeapNumber::kValueOffset);
  Goto(&done);
}

BIND(&if_smi)Bind(&if_smi);
{
  TNode<Int32T> value = SmiToInt32(CAST(var_input.value())Cast(var_input.value()));
  var_result = ChangeInt32ToFloat64(value);
  Goto(&done);
}

BIND(&convert)Bind(&convert);
{
  var_input = CallBuiltin(Builtin::kNonNumberToNumber, context, input);
  Goto(&loop);
}

BIND(&done)Bind(&done);
return var_result.value();
11071}

11073template <>
11074TNode<BigInt> CodeStubAssembler::PrepareValueForWriteToTypedArray<BigInt>(
  TNode<Object> input, ElementsKind elements_kind, TNode<Context> context) {
DCHECK(elements_kind == BIGINT64_ELEMENTS ||((void) 0)
       elements_kind == BIGUINT64_ELEMENTS)((void) 0);
return ToBigInt(context, input);
11079}

11081void CodeStubAssembler::BigIntToRawBytes(TNode<BigInt> bigint,
                                       TVariable<UintPtrT>* var_low,
                                       TVariable<UintPtrT>* var_high) {
Label done(this);
*var_low = Unsigned(IntPtrConstant(0));
*var_high = Unsigned(IntPtrConstant(0));
TNode<Word32T> bitfield = LoadBigIntBitfield(bigint);
TNode<Uint32T> length = DecodeWord32<BigIntBase::LengthBits>(bitfield);
TNode<Uint32T> sign = DecodeWord32<BigIntBase::SignBits>(bitfield);
GotoIf(Word32Equal(length, Int32Constant(0)), &done);
*var_low = LoadBigIntDigit(bigint, 0);
if (!Is64()) {
  Label load_done(this);
  GotoIf(Word32Equal(length, Int32Constant(1)), &load_done);
  *var_high = LoadBigIntDigit(bigint, 1);
  Goto(&load_done);
  BIND(&load_done)Bind(&load_done);
}
GotoIf(Word32Equal(sign, Int32Constant(0)), &done);
// Negative value. Simulate two's complement.
if (!Is64()) {
  *var_high = Unsigned(IntPtrSub(IntPtrConstant(0), var_high->value()));
  Label no_carry(this);
  GotoIf(IntPtrEqual(var_low->value(), IntPtrConstant(0)), &no_carry);
  *var_high = Unsigned(IntPtrSub(var_high->value(), IntPtrConstant(1)));
  Goto(&no_carry);
  BIND(&no_carry)Bind(&no_carry);
}
*var_low = Unsigned(IntPtrSub(IntPtrConstant(0), var_low->value()));
Goto(&done);
BIND(&done)Bind(&done);
11112}

11114template <>
11115void CodeStubAssembler::EmitElementStoreTypedArrayUpdateValue(
  TNode<Object> value, ElementsKind elements_kind,
  TNode<Word32T> converted_value, TVariable<Object>* maybe_converted_value) {
switch (elements_kind) {
  case UINT8_ELEMENTS:
  case INT8_ELEMENTS:
  case UINT16_ELEMENTS:
  case INT16_ELEMENTS:
  case UINT8_CLAMPED_ELEMENTS:
    *maybe_converted_value =
        SmiFromInt32(UncheckedCast<Int32T>(converted_value));
    break;
  case UINT32_ELEMENTS:
    *maybe_converted_value =
        ChangeUint32ToTagged(UncheckedCast<Uint32T>(converted_value));
    break;
  case INT32_ELEMENTS:
    *maybe_converted_value =
        ChangeInt32ToTagged(UncheckedCast<Int32T>(converted_value));
    break;
  default:
    UNREACHABLE()V8_Fatal("unreachable code");
}
11138}

11140template <>
11141void CodeStubAssembler::EmitElementStoreTypedArrayUpdateValue(
  TNode<Object> value, ElementsKind elements_kind,
  TNode<Float32T> converted_value, TVariable<Object>* maybe_converted_value) {
Label dont_allocate_heap_number(this), end(this);
GotoIf(TaggedIsSmi(value), &dont_allocate_heap_number);
GotoIf(IsHeapNumber(CAST(value)Cast(value)), &dont_allocate_heap_number);
{
  *maybe_converted_value =
      AllocateHeapNumberWithValue(ChangeFloat32ToFloat64(converted_value));
  Goto(&end);
}
BIND(&dont_allocate_heap_number)Bind(&dont_allocate_heap_number);
{
  *maybe_converted_value = value;
  Goto(&end);
}
BIND(&end)Bind(&end);
11158}

11160template <>
11161void CodeStubAssembler::EmitElementStoreTypedArrayUpdateValue(
  TNode<Object> value, ElementsKind elements_kind,
  TNode<Float64T> converted_value, TVariable<Object>* maybe_converted_value) {
Label dont_allocate_heap_number(this), end(this);
GotoIf(TaggedIsSmi(value), &dont_allocate_heap_number);
GotoIf(IsHeapNumber(CAST(value)Cast(value)), &dont_allocate_heap_number);
{
  *maybe_converted_value = AllocateHeapNumberWithValue(converted_value);
  Goto(&end);
}
BIND(&dont_allocate_heap_number)Bind(&dont_allocate_heap_number);
{
  *maybe_converted_value = value;
  Goto(&end);
}
BIND(&end)Bind(&end);
11177}

11179template <>
11180void CodeStubAssembler::EmitElementStoreTypedArrayUpdateValue(
  TNode<Object> value, ElementsKind elements_kind,
  TNode<BigInt> converted_value, TVariable<Object>* maybe_converted_value) {
*maybe_converted_value = converted_value;
11184}

11186template <typename TValue>
11187void CodeStubAssembler::EmitElementStoreTypedArray(
  TNode<JSTypedArray> typed_array, TNode<IntPtrT> key, TNode<Object> value,
  ElementsKind elements_kind, KeyedAccessStoreMode store_mode, Label* bailout,
  TNode<Context> context, TVariable<Object>* maybe_converted_value) {
Label done(this), update_value_and_bailout(this, Label::kDeferred);

bool is_rab_gsab = false;
if (IsRabGsabTypedArrayElementsKind(elements_kind)) {
  is_rab_gsab = true;
  // For the rest of the function, use the corresponding non-RAB/GSAB
  // ElementsKind.
  elements_kind = GetCorrespondingNonRabGsabElementsKind(elements_kind);
}

TNode<TValue> converted_value =
    PrepareValueForWriteToTypedArray<TValue>(value, elements_kind, context);

// There must be no allocations between the buffer load and
// and the actual store to backing store, because GC may decide that
// the buffer is not alive or move the elements.
// TODO(ishell): introduce DisallowGarbageCollectionCode scope here.

// Check if buffer has been detached. (For RAB / GSAB this is part of loading
// the length, so no additional check is needed.)
TNode<JSArrayBuffer> buffer = LoadJSArrayBufferViewBuffer(typed_array);
if (!is_rab_gsab) {
  GotoIf(IsDetachedBuffer(buffer), &update_value_and_bailout);
}

// Bounds check.
TNode<UintPtrT> length;
if (is_rab_gsab) {
  length = LoadVariableLengthJSTypedArrayLength(
      typed_array, buffer,
      store_mode == STORE_IGNORE_OUT_OF_BOUNDS ? &done
                                               : &update_value_and_bailout);
} else {
  length = LoadJSTypedArrayLength(typed_array);
}

if (store_mode == STORE_IGNORE_OUT_OF_BOUNDS) {
  // Skip the store if we write beyond the length or
  // to a property with a negative integer index.
  GotoIfNot(UintPtrLessThan(key, length), &done);
} else {
  DCHECK_EQ(store_mode, STANDARD_STORE)((void) 0);
  GotoIfNot(UintPtrLessThan(key, length), &update_value_and_bailout);
}

TNode<RawPtrT> data_ptr = LoadJSTypedArrayDataPtr(typed_array);
StoreElement(data_ptr, elements_kind, key, converted_value);
Goto(&done);

if (!is_rab_gsab || store_mode != STORE_IGNORE_OUT_OF_BOUNDS) {
  BIND(&update_value_and_bailout)Bind(&update_value_and_bailout);
  // We already prepared the incoming value for storing into a typed array.
  // This might involve calling ToNumber in some cases. We shouldn't call
  // ToNumber again in the runtime so pass the converted value to the runtime.
  // The prepared value is an untagged value. Convert it to a tagged value
  // to pass it to runtime. It is not possible to do the detached buffer check
  // before we prepare the value, since ToNumber can detach the ArrayBuffer.
  // The spec specifies the order of these operations.
  if (maybe_converted_value != nullptr) {
    EmitElementStoreTypedArrayUpdateValue(
        value, elements_kind, converted_value, maybe_converted_value);
  }
  Goto(bailout);
}

BIND(&done)Bind(&done);
11257}

11259void CodeStubAssembler::EmitElementStore(
  TNode<JSObject> object, TNode<Object> key, TNode<Object> value,
  ElementsKind elements_kind, KeyedAccessStoreMode store_mode, Label* bailout,
  TNode<Context> context, TVariable<Object>* maybe_converted_value) {
CSA_DCHECK(this, Word32BinaryNot(IsJSProxy(object)))((void)0);

TNode<FixedArrayBase> elements = LoadElements(object);
if (!(IsSmiOrObjectElementsKind(elements_kind) ||
      IsSealedElementsKind(elements_kind) ||
      IsNonextensibleElementsKind(elements_kind))) {
  CSA_DCHECK(this, Word32BinaryNot(IsFixedCOWArrayMap(LoadMap(elements))))((void)0);
} else if (!IsCOWHandlingStoreMode(store_mode)) {
  GotoIf(IsFixedCOWArrayMap(LoadMap(elements)), bailout);
}

// TODO(ishell): introduce TryToIntPtrOrSmi() and use BInt.
TNode<IntPtrT> intptr_key = TryToIntptr(key, bailout);

// TODO(rmcilroy): TNodify the converted value once this funciton and
// StoreElement are templated based on the type elements_kind type.
if (IsTypedArrayOrRabGsabTypedArrayElementsKind(elements_kind)) {
  TNode<JSTypedArray> typed_array = CAST(object)Cast(object);
  switch (elements_kind) {
    case UINT8_ELEMENTS:
    case INT8_ELEMENTS:
    case UINT16_ELEMENTS:
    case INT16_ELEMENTS:
    case UINT32_ELEMENTS:
    case INT32_ELEMENTS:
    case UINT8_CLAMPED_ELEMENTS:
    case RAB_GSAB_UINT8_ELEMENTS:
    case RAB_GSAB_INT8_ELEMENTS:
    case RAB_GSAB_UINT16_ELEMENTS:
    case RAB_GSAB_INT16_ELEMENTS:
    case RAB_GSAB_UINT32_ELEMENTS:
    case RAB_GSAB_INT32_ELEMENTS:
    case RAB_GSAB_UINT8_CLAMPED_ELEMENTS:
      EmitElementStoreTypedArray<Word32T>(typed_array, intptr_key, value,
                                          elements_kind, store_mode, bailout,
                                          context, maybe_converted_value);
      break;
    case FLOAT32_ELEMENTS:
    case RAB_GSAB_FLOAT32_ELEMENTS:
      EmitElementStoreTypedArray<Float32T>(typed_array, intptr_key, value,
                                           elements_kind, store_mode, bailout,
                                           context, maybe_converted_value);
      break;
    case FLOAT64_ELEMENTS:
    case RAB_GSAB_FLOAT64_ELEMENTS:
      EmitElementStoreTypedArray<Float64T>(typed_array, intptr_key, value,
                                           elements_kind, store_mode, bailout,
                                           context, maybe_converted_value);
      break;
    case BIGINT64_ELEMENTS:
    case BIGUINT64_ELEMENTS:
    case RAB_GSAB_BIGINT64_ELEMENTS:
    case RAB_GSAB_BIGUINT64_ELEMENTS:
      EmitElementStoreTypedArray<BigInt>(typed_array, intptr_key, value,
                                         elements_kind, store_mode, bailout,
                                         context, maybe_converted_value);
      break;
    default:
      UNREACHABLE()V8_Fatal("unreachable code");
  }
  return;
}
DCHECK(IsFastElementsKind(elements_kind) ||((void) 0)
       IsSealedElementsKind(elements_kind) ||((void) 0)
       IsNonextensibleElementsKind(elements_kind))((void) 0);

// In case value is stored into a fast smi array, assure that the value is
// a smi before manipulating the backing store. Otherwise the backing store
// may be left in an invalid state.
base::Optional<TNode<Float64T>> float_value;
if (IsSmiElementsKind(elements_kind)) {
  GotoIfNot(TaggedIsSmi(value), bailout);
} else if (IsDoubleElementsKind(elements_kind)) {
  float_value = TryTaggedToFloat64(value, bailout);
}

TNode<Smi> smi_length = Select<Smi>(
    IsJSArray(object),
    [=]() {
      // This is casting Number -> Smi which may not actually be safe.
      return CAST(LoadJSArrayLength(CAST(object)))Cast(LoadJSArrayLength(Cast(object)));
    },
    [=]() { return LoadFixedArrayBaseLength(elements); });

TNode<UintPtrT> length = Unsigned(SmiUntag(smi_length));
if (IsGrowStoreMode(store_mode) &&
    !(IsSealedElementsKind(elements_kind) ||
      IsNonextensibleElementsKind(elements_kind))) {
  elements = CheckForCapacityGrow(object, elements, elements_kind, length,
                                  intptr_key, bailout);
} else {
  GotoIfNot(UintPtrLessThan(Unsigned(intptr_key), length), bailout);
}

// Cannot store to a hole in holey sealed elements so bailout.
if (elements_kind == HOLEY_SEALED_ELEMENTS ||
    elements_kind == HOLEY_NONEXTENSIBLE_ELEMENTS) {
  TNode<Object> target_value =
      LoadFixedArrayElement(CAST(elements)Cast(elements), intptr_key);
  GotoIf(IsTheHole(target_value), bailout);
}

// If we didn't grow {elements}, it might still be COW, in which case we
// copy it now.
if (!(IsSmiOrObjectElementsKind(elements_kind) ||
      IsSealedElementsKind(elements_kind) ||
      IsNonextensibleElementsKind(elements_kind))) {
  CSA_DCHECK(this, Word32BinaryNot(IsFixedCOWArrayMap(LoadMap(elements))))((void)0);
} else if (IsCOWHandlingStoreMode(store_mode)) {
  elements = CopyElementsOnWrite(object, elements, elements_kind,
                                 Signed(length), bailout);
}

CSA_DCHECK(this, Word32BinaryNot(IsFixedCOWArrayMap(LoadMap(elements))))((void)0);
if (float_value) {
  StoreElement(elements, elements_kind, intptr_key, float_value.value());
} else {
  StoreElement(elements, elements_kind, intptr_key, value);
}
11382}

11384TNode<FixedArrayBase> CodeStubAssembler::CheckForCapacityGrow(
  TNode<JSObject> object, TNode<FixedArrayBase> elements, ElementsKind kind,
  TNode<UintPtrT> length, TNode<IntPtrT> key, Label* bailout) {
DCHECK(IsFastElementsKind(kind))((void) 0);
TVARIABLE(FixedArrayBase, checked_elements)TVariable<FixedArrayBase> checked_elements(this);
Label grow_case(this), no_grow_case(this), done(this),
    grow_bailout(this, Label::kDeferred);

TNode<BoolT> condition;
if (IsHoleyElementsKind(kind)) {
  condition = UintPtrGreaterThanOrEqual(key, length);
} else {
  // We don't support growing here unless the value is being appended.
  condition = WordEqual(key, length);
}
Branch(condition, &grow_case, &no_grow_case);

BIND(&grow_case)Bind(&grow_case);
{
  TNode<IntPtrT> current_capacity =
      SmiUntag(LoadFixedArrayBaseLength(elements));
  checked_elements = elements;
  Label fits_capacity(this);
  // If key is negative, we will notice in Runtime::kGrowArrayElements.
  GotoIf(UintPtrLessThan(key, current_capacity), &fits_capacity);

  {
    TNode<FixedArrayBase> new_elements = TryGrowElementsCapacity(
        object, elements, kind, key, current_capacity, &grow_bailout);
    checked_elements = new_elements;
    Goto(&fits_capacity);
  }

  BIND(&grow_bailout)Bind(&grow_bailout);
  {
    GotoIf(IntPtrLessThan(key, IntPtrConstant(0)), bailout);
    TNode<Number> tagged_key = ChangeUintPtrToTagged(Unsigned(key));
    TNode<Object> maybe_elements = CallRuntime(
        Runtime::kGrowArrayElements, NoContextConstant(), object, tagged_key);
    GotoIf(TaggedIsSmi(maybe_elements), bailout);
    TNode<FixedArrayBase> new_elements = CAST(maybe_elements)Cast(maybe_elements);
    CSA_DCHECK(this, IsFixedArrayWithKind(new_elements, kind))((void)0);
    checked_elements = new_elements;
    Goto(&fits_capacity);
  }

  BIND(&fits_capacity)Bind(&fits_capacity);
  GotoIfNot(IsJSArray(object), &done);

  TNode<IntPtrT> new_length = IntPtrAdd(key, IntPtrConstant(1));
  StoreObjectFieldNoWriteBarrier(object, JSArray::kLengthOffset,
                                 SmiTag(new_length));
  Goto(&done);
}

BIND(&no_grow_case)Bind(&no_grow_case);
{
  GotoIfNot(UintPtrLessThan(key, length), bailout);
  checked_elements = elements;
  Goto(&done);
}

BIND(&done)Bind(&done);
return checked_elements.value();
11448}

11450TNode<FixedArrayBase> CodeStubAssembler::CopyElementsOnWrite(
  TNode<HeapObject> object, TNode<FixedArrayBase> elements, ElementsKind kind,
  TNode<IntPtrT> length, Label* bailout) {
TVARIABLE(FixedArrayBase, new_elements_var, elements)TVariable<FixedArrayBase> new_elements_var(elements, this
);
Label done(this);

GotoIfNot(IsFixedCOWArrayMap(LoadMap(elements)), &done);
{
  TNode<IntPtrT> capacity = SmiUntag(LoadFixedArrayBaseLength(elements));
  TNode<FixedArrayBase> new_elements = GrowElementsCapacity(
      object, elements, kind, kind, length, capacity, bailout);
  new_elements_var = new_elements;
  Goto(&done);
}

BIND(&done)Bind(&done);
return new_elements_var.value();
11467}

11469void CodeStubAssembler::TransitionElementsKind(TNode<JSObject> object,
                                             TNode<Map> map,
                                             ElementsKind from_kind,
                                             ElementsKind to_kind,
                                             Label* bailout) {
DCHECK(!IsHoleyElementsKind(from_kind) || IsHoleyElementsKind(to_kind))((void) 0);
if (AllocationSite::ShouldTrack(from_kind, to_kind)) {
  TrapAllocationMemento(object, bailout);
}

if (!IsSimpleMapChangeTransition(from_kind, to_kind)) {
  Comment("Non-simple map transition");
  TNode<FixedArrayBase> elements = LoadElements(object);

  Label done(this);
  GotoIf(TaggedEqual(elements, EmptyFixedArrayConstant()), &done);

  // TODO(ishell): Use BInt for elements_length and array_length.
  TNode<IntPtrT> elements_length =
      SmiUntag(LoadFixedArrayBaseLength(elements));
  TNode<IntPtrT> array_length = Select<IntPtrT>(
      IsJSArray(object),
      [=]() {
        CSA_DCHECK(this, IsFastElementsKind(LoadElementsKind(object)))((void)0);
        return SmiUntag(LoadFastJSArrayLength(CAST(object)Cast(object)));
      },
      [=]() { return elements_length; });

  CSA_DCHECK(this, WordNotEqual(elements_length, IntPtrConstant(0)))((void)0);

  GrowElementsCapacity(object, elements, from_kind, to_kind, array_length,
                       elements_length, bailout);
  Goto(&done);
  BIND(&done)Bind(&done);
}

StoreMap(object, map);
11506}

11508void CodeStubAssembler::TrapAllocationMemento(TNode<JSObject> object,
                                            Label* memento_found) {
DCHECK(V8_ALLOCATION_SITE_TRACKING_BOOL)((void) 0);
Comment("[ TrapAllocationMemento");
Label no_memento_found(this);
Label top_check(this), map_check(this);

TNode<ExternalReference> new_space_top_address = ExternalConstant(
    ExternalReference::new_space_allocation_top_address(isolate()));
const int kMementoMapOffset = JSArray::kHeaderSize;
const int kMementoLastWordOffset =
    kMementoMapOffset + AllocationMemento::kSize - kTaggedSize;

// Bail out if the object is not in new space.
TNode<IntPtrT> object_word = BitcastTaggedToWord(object);
// TODO(v8:11641): Skip TrapAllocationMemento when allocation-site
// tracking is disabled.
TNode<IntPtrT> object_page = PageFromAddress(object_word);
{
  TNode<IntPtrT> page_flags =
      Load<IntPtrT>(object_page, IntPtrConstant(Page::kFlagsOffset));
  GotoIf(WordEqual(
             WordAnd(page_flags,
                     IntPtrConstant(MemoryChunk::kIsInYoungGenerationMask)),
             IntPtrConstant(0)),
         &no_memento_found);
  // TODO(v8:11799): Support allocation memento for a large object by
  // allocating additional word for the memento after the large object.
  GotoIf(WordNotEqual(WordAnd(page_flags,
                              IntPtrConstant(MemoryChunk::kIsLargePageMask)),
                      IntPtrConstant(0)),
         &no_memento_found);
}

TNode<IntPtrT> memento_last_word = IntPtrAdd(
    object_word, IntPtrConstant(kMementoLastWordOffset - kHeapObjectTag));
TNode<IntPtrT> memento_last_word_page = PageFromAddress(memento_last_word);

TNode<IntPtrT> new_space_top = Load<IntPtrT>(new_space_top_address);
TNode<IntPtrT> new_space_top_page = PageFromAddress(new_space_top);

// If the object is in new space, we need to check whether respective
// potential memento object is on the same page as the current top.
GotoIf(WordEqual(memento_last_word_page, new_space_top_page), &top_check);

// The object is on a different page than allocation top. Bail out if the
// object sits on the page boundary as no memento can follow and we cannot
// touch the memory following it.
Branch(WordEqual(object_page, memento_last_word_page), &map_check,
       &no_memento_found);

// If top is on the same page as the current object, we need to check whether
// we are below top.
BIND(&top_check)Bind(&top_check);
{
  Branch(UintPtrGreaterThanOrEqual(memento_last_word, new_space_top),
         &no_memento_found, &map_check);
}

// Memento map check.
BIND(&map_check)Bind(&map_check);
{
  TNode<AnyTaggedT> maybe_mapword =
      LoadObjectField(object, kMementoMapOffset);
  TNode<AnyTaggedT> memento_mapword =
      LoadRootMapWord(RootIndex::kAllocationMementoMap);
  Branch(TaggedEqual(maybe_mapword, memento_mapword), memento_found,
         &no_memento_found);
}
BIND(&no_memento_found)Bind(&no_memento_found);
Comment("] TrapAllocationMemento");
11579}

11581TNode<IntPtrT> CodeStubAssembler::PageFromAddress(TNode<IntPtrT> address) {
DCHECK(!V8_ENABLE_THIRD_PARTY_HEAP_BOOL)((void) 0);
return WordAnd(address, IntPtrConstant(~kPageAlignmentMask));
11584}

11586TNode<AllocationSite> CodeStubAssembler::CreateAllocationSiteInFeedbackVector(
  TNode<FeedbackVector> feedback_vector, TNode<UintPtrT> slot) {
TNode<IntPtrT> size = IntPtrConstant(AllocationSite::kSizeWithWeakNext);
TNode<HeapObject> site = Allocate(size, AllocationFlag::kPretenured);
StoreMapNoWriteBarrier(site, RootIndex::kAllocationSiteWithWeakNextMap);
// Should match AllocationSite::Initialize.
TNode<WordT> field = UpdateWord<AllocationSite::ElementsKindBits>(
    IntPtrConstant(0), UintPtrConstant(GetInitialFastElementsKind()));
StoreObjectFieldNoWriteBarrier(
    site, AllocationSite::kTransitionInfoOrBoilerplateOffset,
    SmiTag(Signed(field)));

// Unlike literals, constructed arrays don't have nested sites
TNode<Smi> zero = SmiConstant(0);
StoreObjectFieldNoWriteBarrier(site, AllocationSite::kNestedSiteOffset, zero);

// Pretenuring calculation field.
StoreObjectFieldNoWriteBarrier(site, AllocationSite::kPretenureDataOffset,
                               Int32Constant(0));

// Pretenuring memento creation count field.
StoreObjectFieldNoWriteBarrier(
    site, AllocationSite::kPretenureCreateCountOffset, Int32Constant(0));

// Store an empty fixed array for the code dependency.
StoreObjectFieldRoot(site, AllocationSite::kDependentCodeOffset,
                     DependentCode::kEmptyDependentCode);

// Link the object to the allocation site list
TNode<ExternalReference> site_list = ExternalConstant(
    ExternalReference::allocation_sites_list_address(isolate()));
TNode<Object> next_site =
    LoadBufferObject(ReinterpretCast<RawPtrT>(site_list), 0);

// TODO(mvstanton): This is a store to a weak pointer, which we may want to
// mark as such in order to skip the write barrier, once we have a unified
// system for weakness. For now we decided to keep it like this because having
// an initial write barrier backed store makes this pointer strong until the
// next GC, and allocation sites are designed to survive several GCs anyway.
StoreObjectField(site, AllocationSite::kWeakNextOffset, next_site);
StoreFullTaggedNoWriteBarrier(site_list, site);

StoreFeedbackVectorSlot(feedback_vector, slot, site);
return CAST(site)Cast(site);
11630}

11632TNode<MaybeObject> CodeStubAssembler::StoreWeakReferenceInFeedbackVector(
  TNode<FeedbackVector> feedback_vector, TNode<UintPtrT> slot,
  TNode<HeapObject> value, int additional_offset) {
TNode<MaybeObject> weak_value = MakeWeak(value);
StoreFeedbackVectorSlot(feedback_vector, slot, weak_value,
                        UPDATE_WRITE_BARRIER, additional_offset);
return weak_value;
11639}

11641TNode<BoolT> CodeStubAssembler::HasBoilerplate(
  TNode<Object> maybe_literal_site) {
return TaggedIsNotSmi(maybe_literal_site);
11644}

11646TNode<Smi> CodeStubAssembler::LoadTransitionInfo(
  TNode<AllocationSite> allocation_site) {
TNode<Smi> transition_info = CAST(LoadObjectField(Cast(LoadObjectField( allocation_site, AllocationSite::kTransitionInfoOrBoilerplateOffset
))
    allocation_site, AllocationSite::kTransitionInfoOrBoilerplateOffset))Cast(LoadObjectField( allocation_site, AllocationSite::kTransitionInfoOrBoilerplateOffset
));
return transition_info;
11651}

11653TNode<JSObject> CodeStubAssembler::LoadBoilerplate(
  TNode<AllocationSite> allocation_site) {
TNode<JSObject> boilerplate = CAST(LoadObjectField(Cast(LoadObjectField( allocation_site, AllocationSite::kTransitionInfoOrBoilerplateOffset
))
    allocation_site, AllocationSite::kTransitionInfoOrBoilerplateOffset))Cast(LoadObjectField( allocation_site, AllocationSite::kTransitionInfoOrBoilerplateOffset
));
return boilerplate;
11658}

11660TNode<Int32T> CodeStubAssembler::LoadElementsKind(
  TNode<AllocationSite> allocation_site) {
TNode<Smi> transition_info = LoadTransitionInfo(allocation_site);
TNode<Int32T> elements_kind =
    Signed(DecodeWord32<AllocationSite::ElementsKindBits>(
        SmiToInt32(transition_info)));
CSA_DCHECK(this, IsFastElementsKind(elements_kind))((void)0);
return elements_kind;
11668}

11670template <typename TIndex>
11671TNode<TIndex> CodeStubAssembler::BuildFastLoop(const VariableList& vars,
                                             TNode<TIndex> start_index,
                                             TNode<TIndex> end_index,
                                             const FastLoopBody<TIndex>& body,
                                             int increment,
                                             IndexAdvanceMode advance_mode) {
TVARIABLE(TIndex, var, start_index)TVariable<TIndex> var(start_index, this);
VariableList vars_copy(vars.begin(), vars.end(), zone());
vars_copy.push_back(&var);
Label loop(this, vars_copy);
Label after_loop(this);
// Introduce an explicit second check of the termination condition before the
// loop that helps turbofan generate better code. If there's only a single
// check, then the CodeStubAssembler forces it to be at the beginning of the
// loop requiring a backwards branch at the end of the loop (it's not possible
// to force the loop header check at the end of the loop and branch forward to
// it from the pre-header). The extra branch is slower in the case that the
// loop actually iterates.
TNode<BoolT> first_check = IntPtrOrSmiEqual(var.value(), end_index);
int32_t first_check_val;
if (TryToInt32Constant(first_check, &first_check_val)) {
  if (first_check_val) return var.value();
  Goto(&loop);
} else {
  Branch(first_check, &after_loop, &loop);
}

BIND(&loop)Bind(&loop);
{
  if (advance_mode == IndexAdvanceMode::kPre) {
    Increment(&var, increment);
  }
  body(var.value());
  if (advance_mode == IndexAdvanceMode::kPost) {
    Increment(&var, increment);
  }
  Branch(IntPtrOrSmiNotEqual(var.value(), end_index), &loop, &after_loop);
}
BIND(&after_loop)Bind(&after_loop);
return var.value();
11711}

11713// Instantiate BuildFastLoop for IntPtrT and UintPtrT.
11714template V8_EXPORT_PRIVATE TNode<IntPtrT>
11715CodeStubAssembler::BuildFastLoop<IntPtrT>(const VariableList& vars,
                                        TNode<IntPtrT> start_index,
                                        TNode<IntPtrT> end_index,
                                        const FastLoopBody<IntPtrT>& body,
                                        int increment,
                                        IndexAdvanceMode advance_mode);
11721template V8_EXPORT_PRIVATE TNode<UintPtrT>
11722CodeStubAssembler::BuildFastLoop<UintPtrT>(const VariableList& vars,
                                         TNode<UintPtrT> start_index,
                                         TNode<UintPtrT> end_index,
                                         const FastLoopBody<UintPtrT>& body,
                                         int increment,
                                         IndexAdvanceMode advance_mode);

11729template <typename TIndex>
11730void CodeStubAssembler::BuildFastArrayForEach(
  TNode<UnionT<UnionT<FixedArray, PropertyArray>, HeapObject>> array,
  ElementsKind kind, TNode<TIndex> first_element_inclusive,
  TNode<TIndex> last_element_exclusive, const FastArrayForEachBody& body,
  ForEachDirection direction) {
STATIC_ASSERT(FixedArray::kHeaderSize == FixedDoubleArray::kHeaderSize)static_assert(FixedArray::kHeaderSize == FixedDoubleArray::kHeaderSize
, "FixedArray::kHeaderSize == FixedDoubleArray::kHeaderSize");
CSA_SLOW_DCHECK(this, Word32Or(IsFixedArrayWithKind(array, kind),((void)0)
                               IsPropertyArray(array)))((void)0);

intptr_t first_val;
bool constant_first =
    TryToIntPtrConstant(first_element_inclusive, &first_val);
intptr_t last_val;
bool constent_last = TryToIntPtrConstant(last_element_exclusive, &last_val);
if (constant_first && constent_last) {
  intptr_t delta = last_val - first_val;
  DCHECK_GE(delta, 0)((void) 0);
  if (delta <= kElementLoopUnrollThreshold) {
    if (direction == ForEachDirection::kForward) {
      for (intptr_t i = first_val; i < last_val; ++i) {
        TNode<IntPtrT> index = IntPtrConstant(i);
        TNode<IntPtrT> offset = ElementOffsetFromIndex(
            index, kind, FixedArray::kHeaderSize - kHeapObjectTag);
        body(array, offset);
      }
    } else {
      for (intptr_t i = last_val - 1; i >= first_val; --i) {
        TNode<IntPtrT> index = IntPtrConstant(i);
        TNode<IntPtrT> offset = ElementOffsetFromIndex(
            index, kind, FixedArray::kHeaderSize - kHeapObjectTag);
        body(array, offset);
      }
    }
    return;
  }
}

TNode<IntPtrT> start = ElementOffsetFromIndex(
    first_element_inclusive, kind, FixedArray::kHeaderSize - kHeapObjectTag);
TNode<IntPtrT> limit = ElementOffsetFromIndex(
    last_element_exclusive, kind, FixedArray::kHeaderSize - kHeapObjectTag);
if (direction == ForEachDirection::kReverse) std::swap(start, limit);

int increment = IsDoubleElementsKind(kind) ? kDoubleSize : kTaggedSize;
BuildFastLoop<IntPtrT>(
    start, limit, [&](TNode<IntPtrT> offset) { body(array, offset); },
    direction == ForEachDirection::kReverse ? -increment : increment,
    direction == ForEachDirection::kReverse ? IndexAdvanceMode::kPre
                                            : IndexAdvanceMode::kPost);
11779}

11781template <typename TIndex>
11782void CodeStubAssembler::GotoIfFixedArraySizeDoesntFitInNewSpace(
  TNode<TIndex> element_count, Label* doesnt_fit, int base_size) {
GotoIf(FixedArraySizeDoesntFitInNewSpace(element_count, base_size),
       doesnt_fit);
11786}

11788void CodeStubAssembler::InitializeFieldsWithRoot(TNode<HeapObject> object,
                                               TNode<IntPtrT> start_offset,
                                               TNode<IntPtrT> end_offset,
                                               RootIndex root_index) {
CSA_SLOW_DCHECK(this, TaggedIsNotSmi(object))((void)0);
start_offset = IntPtrAdd(start_offset, IntPtrConstant(-kHeapObjectTag));
end_offset = IntPtrAdd(end_offset, IntPtrConstant(-kHeapObjectTag));
TNode<AnyTaggedT> root_value;
if (root_index == RootIndex::kOnePointerFillerMap) {
  root_value = LoadRootMapWord(root_index);
} else {
  root_value = LoadRoot(root_index);
}
BuildFastLoop<IntPtrT>(
    end_offset, start_offset,
    [=](TNode<IntPtrT> current) {
      StoreNoWriteBarrier(MachineRepresentation::kTagged, object, current,
                          root_value);
    },
    -kTaggedSize, CodeStubAssembler::IndexAdvanceMode::kPre);
11808}

11810void CodeStubAssembler::BranchIfNumberRelationalComparison(Operation op,
                                                         TNode<Number> left,
                                                         TNode<Number> right,
                                                         Label* if_true,
                                                         Label* if_false) {
Label do_float_comparison(this);
TVARIABLE(Float64T, var_left_float)TVariable<Float64T> var_left_float(this);
TVARIABLE(Float64T, var_right_float)TVariable<Float64T> var_right_float(this);

Branch(
    TaggedIsSmi(left),
    [&] {
      TNode<Smi> smi_left = CAST(left)Cast(left);

      Branch(
          TaggedIsSmi(right),
          [&] {
            TNode<Smi> smi_right = CAST(right)Cast(right);

            // Both {left} and {right} are Smi, so just perform a fast
            // Smi comparison.
            switch (op) {
              case Operation::kEqual:
                BranchIfSmiEqual(smi_left, smi_right, if_true, if_false);
                break;
              case Operation::kLessThan:
                BranchIfSmiLessThan(smi_left, smi_right, if_true, if_false);
                break;
              case Operation::kLessThanOrEqual:
                BranchIfSmiLessThanOrEqual(smi_left, smi_right, if_true,
                                           if_false);
                break;
              case Operation::kGreaterThan:
                BranchIfSmiLessThan(smi_right, smi_left, if_true, if_false);
                break;
              case Operation::kGreaterThanOrEqual:
                BranchIfSmiLessThanOrEqual(smi_right, smi_left, if_true,
                                           if_false);
                break;
              default:
                UNREACHABLE()V8_Fatal("unreachable code");
            }
          },
          [&] {
            var_left_float = SmiToFloat64(smi_left);
            var_right_float = LoadHeapNumberValue(CAST(right)Cast(right));
            Goto(&do_float_comparison);
          });
    },
    [&] {
      var_left_float = LoadHeapNumberValue(CAST(left)Cast(left));

      Branch(
          TaggedIsSmi(right),
          [&] {
            var_right_float = SmiToFloat64(CAST(right)Cast(right));
            Goto(&do_float_comparison);
          },
          [&] {
            var_right_float = LoadHeapNumberValue(CAST(right)Cast(right));
            Goto(&do_float_comparison);
          });
    });

BIND(&do_float_comparison)Bind(&do_float_comparison);
{
  switch (op) {
    case Operation::kEqual:
      Branch(Float64Equal(var_left_float.value(), var_right_float.value()),
             if_true, if_false);
      break;
    case Operation::kLessThan:
      Branch(Float64LessThan(var_left_float.value(), var_right_float.value()),
             if_true, if_false);
      break;
    case Operation::kLessThanOrEqual:
      Branch(Float64LessThanOrEqual(var_left_float.value(),
                                    var_right_float.value()),
             if_true, if_false);
      break;
    case Operation::kGreaterThan:
      Branch(
          Float64GreaterThan(var_left_float.value(), var_right_float.value()),
          if_true, if_false);
      break;
    case Operation::kGreaterThanOrEqual:
      Branch(Float64GreaterThanOrEqual(var_left_float.value(),
                                       var_right_float.value()),
             if_true, if_false);
      break;
    default:
      UNREACHABLE()V8_Fatal("unreachable code");
  }
}
11904}

11906void CodeStubAssembler::GotoIfNumberGreaterThanOrEqual(TNode<Number> left,
                                                     TNode<Number> right,
                                                     Label* if_true) {
Label if_false(this);
BranchIfNumberRelationalComparison(Operation::kGreaterThanOrEqual, left,
                                   right, if_true, &if_false);
BIND(&if_false)Bind(&if_false);
11913}

11915namespace {
11916Operation Reverse(Operation op) {
switch (op) {
  case Operation::kLessThan:
    return Operation::kGreaterThan;
  case Operation::kLessThanOrEqual:
    return Operation::kGreaterThanOrEqual;
  case Operation::kGreaterThan:
    return Operation::kLessThan;
  case Operation::kGreaterThanOrEqual:
    return Operation::kLessThanOrEqual;
  default:
    break;
}
UNREACHABLE()V8_Fatal("unreachable code");
11930}
11931}  // anonymous namespace

11933TNode<Context> CodeStubAssembler::GotoIfHasContextExtensionUpToDepth(
  TNode<Context> context, TNode<Uint32T> depth, Label* target) {
TVARIABLE(Context, cur_context, context)TVariable<Context> cur_context(context, this);
TVARIABLE(Uint32T, cur_depth, depth)TVariable<Uint32T> cur_depth(depth, this);

Label context_search(this, {&cur_depth, &cur_context});
Label exit_loop(this);
Label no_extension(this);

// Loop until the depth is 0.
CSA_DCHECK(this, Word32NotEqual(cur_depth.value(), Int32Constant(0)))((void)0);
Goto(&context_search);
BIND(&context_search)Bind(&context_search);
{
  // Check if context has an extension slot.
  TNode<BoolT> has_extension =
      LoadScopeInfoHasExtensionField(LoadScopeInfo(cur_context.value()));
  GotoIfNot(has_extension, &no_extension);

  // Jump to the target if the extension slot is not an undefined value.
  TNode<Object> extension_slot =
      LoadContextElement(cur_context.value(), Context::EXTENSION_INDEX);
  Branch(TaggedNotEqual(extension_slot, UndefinedConstant()), target,
         &no_extension);

  BIND(&no_extension)Bind(&no_extension);
  {
    cur_depth = Unsigned(Int32Sub(cur_depth.value(), Int32Constant(1)));
    cur_context = CAST(Cast(LoadContextElement(cur_context.value(), Context::PREVIOUS_INDEX
))
        LoadContextElement(cur_context.value(), Context::PREVIOUS_INDEX))Cast(LoadContextElement(cur_context.value(), Context::PREVIOUS_INDEX
));

    Branch(Word32NotEqual(cur_depth.value(), Int32Constant(0)),
           &context_search, &exit_loop);
  }
}
BIND(&exit_loop)Bind(&exit_loop);
return cur_context.value();
11970}

11972TNode<Oddball> CodeStubAssembler::RelationalComparison(
  Operation op, TNode<Object> left, TNode<Object> right,
  const LazyNode<Context>& context, TVariable<Smi>* var_type_feedback) {
Label return_true(this), return_false(this), do_float_comparison(this),
    end(this);
TVARIABLE(Oddball, var_result)TVariable<Oddball> var_result(this);  // Actually only "true" or "false".
TVARIABLE(Float64T, var_left_float)TVariable<Float64T> var_left_float(this);
TVARIABLE(Float64T, var_right_float)TVariable<Float64T> var_right_float(this);

// We might need to loop several times due to ToPrimitive and/or ToNumeric
// conversions.
TVARIABLE(Object, var_left, left)TVariable<Object> var_left(left, this);
TVARIABLE(Object, var_right, right)TVariable<Object> var_right(right, this);
VariableList loop_variable_list({&var_left, &var_right}, zone());
if (var_type_feedback != nullptr) {
  // Initialize the type feedback to None. The current feedback is combined
  // with the previous feedback.
  *var_type_feedback = SmiConstant(CompareOperationFeedback::kNone);
  loop_variable_list.push_back(var_type_feedback);
}
Label loop(this, loop_variable_list);
Goto(&loop);
BIND(&loop)Bind(&loop);
{
  left = var_left.value();
  right = var_right.value();

  Label if_left_smi(this), if_left_not_smi(this);
  Branch(TaggedIsSmi(left), &if_left_smi, &if_left_not_smi);

  BIND(&if_left_smi)Bind(&if_left_smi);
  {
    TNode<Smi> smi_left = CAST(left)Cast(left);
    Label if_right_smi(this), if_right_heapnumber(this),
        if_right_bigint(this, Label::kDeferred),
        if_right_not_numeric(this, Label::kDeferred);
    GotoIf(TaggedIsSmi(right), &if_right_smi);
    TNode<Map> right_map = LoadMap(CAST(right)Cast(right));
    GotoIf(IsHeapNumberMap(right_map), &if_right_heapnumber);
    TNode<Uint16T> right_instance_type = LoadMapInstanceType(right_map);
    Branch(IsBigIntInstanceType(right_instance_type), &if_right_bigint,
           &if_right_not_numeric);

    BIND(&if_right_smi)Bind(&if_right_smi);
    {
      TNode<Smi> smi_right = CAST(right)Cast(right);
      CombineFeedback(var_type_feedback,
                      CompareOperationFeedback::kSignedSmall);
      switch (op) {
        case Operation::kLessThan:
          BranchIfSmiLessThan(smi_left, smi_right, &return_true,
                              &return_false);
          break;
        case Operation::kLessThanOrEqual:
          BranchIfSmiLessThanOrEqual(smi_left, smi_right, &return_true,
                                     &return_false);
          break;
        case Operation::kGreaterThan:
          BranchIfSmiLessThan(smi_right, smi_left, &return_true,
                              &return_false);
          break;
        case Operation::kGreaterThanOrEqual:
          BranchIfSmiLessThanOrEqual(smi_right, smi_left, &return_true,
                                     &return_false);
          break;
        default:
          UNREACHABLE()V8_Fatal("unreachable code");
      }
    }

    BIND(&if_right_heapnumber)Bind(&if_right_heapnumber);
    {
      CombineFeedback(var_type_feedback, CompareOperationFeedback::kNumber);
      var_left_float = SmiToFloat64(smi_left);
      var_right_float = LoadHeapNumberValue(CAST(right)Cast(right));
      Goto(&do_float_comparison);
    }

    BIND(&if_right_bigint)Bind(&if_right_bigint);
    {
      OverwriteFeedback(var_type_feedback, CompareOperationFeedback::kAny);
      var_result = CAST(CallRuntime(Runtime::kBigIntCompareToNumber,Cast(CallRuntime(Runtime::kBigIntCompareToNumber, NoContextConstant
(), SmiConstant(Reverse(op)), right, left))
                                    NoContextConstant(),Cast(CallRuntime(Runtime::kBigIntCompareToNumber, NoContextConstant
(), SmiConstant(Reverse(op)), right, left))
                                    SmiConstant(Reverse(op)), right, left))Cast(CallRuntime(Runtime::kBigIntCompareToNumber, NoContextConstant
(), SmiConstant(Reverse(op)), right, left));
      Goto(&end);
    }

    BIND(&if_right_not_numeric)Bind(&if_right_not_numeric);
    {
      OverwriteFeedback(var_type_feedback, CompareOperationFeedback::kAny);
      // Convert {right} to a Numeric; we don't need to perform the
      // dedicated ToPrimitive(right, hint Number) operation, as the
      // ToNumeric(right) will by itself already invoke ToPrimitive with
      // a Number hint.
      var_right = CallBuiltin(Builtin::kNonNumberToNumeric, context(), right);
      Goto(&loop);
    }
  }

  BIND(&if_left_not_smi)Bind(&if_left_not_smi);
  {
    TNode<Map> left_map = LoadMap(CAST(left)Cast(left));

    Label if_right_smi(this), if_right_not_smi(this);
    Branch(TaggedIsSmi(right), &if_right_smi, &if_right_not_smi);

    BIND(&if_right_smi)Bind(&if_right_smi);
    {
      Label if_left_heapnumber(this), if_left_bigint(this, Label::kDeferred),
          if_left_not_numeric(this, Label::kDeferred);
      GotoIf(IsHeapNumberMap(left_map), &if_left_heapnumber);
      TNode<Uint16T> left_instance_type = LoadMapInstanceType(left_map);
      Branch(IsBigIntInstanceType(left_instance_type), &if_left_bigint,
             &if_left_not_numeric);

      BIND(&if_left_heapnumber)Bind(&if_left_heapnumber);
      {
        CombineFeedback(var_type_feedback, CompareOperationFeedback::kNumber);
        var_left_float = LoadHeapNumberValue(CAST(left)Cast(left));
        var_right_float = SmiToFloat64(CAST(right)Cast(right));
        Goto(&do_float_comparison);
      }

      BIND(&if_left_bigint)Bind(&if_left_bigint);
      {
        OverwriteFeedback(var_type_feedback, CompareOperationFeedback::kAny);
        var_result = CAST(CallRuntime(Runtime::kBigIntCompareToNumber,Cast(CallRuntime(Runtime::kBigIntCompareToNumber, NoContextConstant
(), SmiConstant(op), left, right))
                                      NoContextConstant(), SmiConstant(op),Cast(CallRuntime(Runtime::kBigIntCompareToNumber, NoContextConstant
(), SmiConstant(op), left, right))
                                      left, right))Cast(CallRuntime(Runtime::kBigIntCompareToNumber, NoContextConstant
(), SmiConstant(op), left, right));
        Goto(&end);
      }

      BIND(&if_left_not_numeric)Bind(&if_left_not_numeric);
      {
        OverwriteFeedback(var_type_feedback, CompareOperationFeedback::kAny);
        // Convert {left} to a Numeric; we don't need to perform the
        // dedicated ToPrimitive(left, hint Number) operation, as the
        // ToNumeric(left) will by itself already invoke ToPrimitive with
        // a Number hint.
        var_left = CallBuiltin(Builtin::kNonNumberToNumeric, context(), left);
        Goto(&loop);
      }
    }

    BIND(&if_right_not_smi)Bind(&if_right_not_smi);
    {
      TNode<Map> right_map = LoadMap(CAST(right)Cast(right));

      Label if_left_heapnumber(this), if_left_bigint(this, Label::kDeferred),
          if_left_string(this, Label::kDeferred),
          if_left_other(this, Label::kDeferred);
      GotoIf(IsHeapNumberMap(left_map), &if_left_heapnumber);
      TNode<Uint16T> left_instance_type = LoadMapInstanceType(left_map);
      GotoIf(IsBigIntInstanceType(left_instance_type), &if_left_bigint);
      Branch(IsStringInstanceType(left_instance_type), &if_left_string,
             &if_left_other);

      BIND(&if_left_heapnumber)Bind(&if_left_heapnumber);
      {
        Label if_right_heapnumber(this),
            if_right_bigint(this, Label::kDeferred),
            if_right_not_numeric(this, Label::kDeferred);
        GotoIf(TaggedEqual(right_map, left_map), &if_right_heapnumber);
        TNode<Uint16T> right_instance_type = LoadMapInstanceType(right_map);
        Branch(IsBigIntInstanceType(right_instance_type), &if_right_bigint,
               &if_right_not_numeric);

        BIND(&if_right_heapnumber)Bind(&if_right_heapnumber);
        {
          CombineFeedback(var_type_feedback,
                          CompareOperationFeedback::kNumber);
          var_left_float = LoadHeapNumberValue(CAST(left)Cast(left));
          var_right_float = LoadHeapNumberValue(CAST(right)Cast(right));
          Goto(&do_float_comparison);
        }

        BIND(&if_right_bigint)Bind(&if_right_bigint);
        {
          OverwriteFeedback(var_type_feedback,
                            CompareOperationFeedback::kAny);
          var_result = CAST(CallRuntime(Cast(CallRuntime( Runtime::kBigIntCompareToNumber, NoContextConstant
(), SmiConstant(Reverse(op)), right, left))
              Runtime::kBigIntCompareToNumber, NoContextConstant(),Cast(CallRuntime( Runtime::kBigIntCompareToNumber, NoContextConstant
(), SmiConstant(Reverse(op)), right, left))
              SmiConstant(Reverse(op)), right, left))Cast(CallRuntime( Runtime::kBigIntCompareToNumber, NoContextConstant
(), SmiConstant(Reverse(op)), right, left));
          Goto(&end);
        }

        BIND(&if_right_not_numeric)Bind(&if_right_not_numeric);
        {
          OverwriteFeedback(var_type_feedback,
                            CompareOperationFeedback::kAny);
          // Convert {right} to a Numeric; we don't need to perform
          // dedicated ToPrimitive(right, hint Number) operation, as the
          // ToNumeric(right) will by itself already invoke ToPrimitive with
          // a Number hint.
          var_right =
              CallBuiltin(Builtin::kNonNumberToNumeric, context(), right);
          Goto(&loop);
        }
      }

      BIND(&if_left_bigint)Bind(&if_left_bigint);
      {
        Label if_right_heapnumber(this), if_right_bigint(this),
            if_right_string(this), if_right_other(this);
        GotoIf(IsHeapNumberMap(right_map), &if_right_heapnumber);
        TNode<Uint16T> right_instance_type = LoadMapInstanceType(right_map);
        GotoIf(IsBigIntInstanceType(right_instance_type), &if_right_bigint);
        Branch(IsStringInstanceType(right_instance_type), &if_right_string,
               &if_right_other);

        BIND(&if_right_heapnumber)Bind(&if_right_heapnumber);
        {
          OverwriteFeedback(var_type_feedback,
                            CompareOperationFeedback::kAny);
          var_result = CAST(CallRuntime(Runtime::kBigIntCompareToNumber,Cast(CallRuntime(Runtime::kBigIntCompareToNumber, NoContextConstant
(), SmiConstant(op), left, right))
                                        NoContextConstant(), SmiConstant(op),Cast(CallRuntime(Runtime::kBigIntCompareToNumber, NoContextConstant
(), SmiConstant(op), left, right))
                                        left, right))Cast(CallRuntime(Runtime::kBigIntCompareToNumber, NoContextConstant
(), SmiConstant(op), left, right));
          Goto(&end);
        }

        BIND(&if_right_bigint)Bind(&if_right_bigint);
        {
          CombineFeedback(var_type_feedback,
                          CompareOperationFeedback::kBigInt);
          var_result = CAST(CallRuntime(Runtime::kBigIntCompareToBigInt,Cast(CallRuntime(Runtime::kBigIntCompareToBigInt, NoContextConstant
(), SmiConstant(op), left, right))
                                        NoContextConstant(), SmiConstant(op),Cast(CallRuntime(Runtime::kBigIntCompareToBigInt, NoContextConstant
(), SmiConstant(op), left, right))
                                        left, right))Cast(CallRuntime(Runtime::kBigIntCompareToBigInt, NoContextConstant
(), SmiConstant(op), left, right));
          Goto(&end);
        }

        BIND(&if_right_string)Bind(&if_right_string);
        {
          OverwriteFeedback(var_type_feedback,
                            CompareOperationFeedback::kAny);
          var_result = CAST(CallRuntime(Runtime::kBigIntCompareToString,Cast(CallRuntime(Runtime::kBigIntCompareToString, NoContextConstant
(), SmiConstant(op), left, right))
                                        NoContextConstant(), SmiConstant(op),Cast(CallRuntime(Runtime::kBigIntCompareToString, NoContextConstant
(), SmiConstant(op), left, right))
                                        left, right))Cast(CallRuntime(Runtime::kBigIntCompareToString, NoContextConstant
(), SmiConstant(op), left, right));
          Goto(&end);
        }

        // {right} is not a Number, BigInt, or String.
        BIND(&if_right_other)Bind(&if_right_other);
        {
          OverwriteFeedback(var_type_feedback,
                            CompareOperationFeedback::kAny);
          // Convert {right} to a Numeric; we don't need to perform
          // dedicated ToPrimitive(right, hint Number) operation, as the
          // ToNumeric(right) will by itself already invoke ToPrimitive with
          // a Number hint.
          var_right =
              CallBuiltin(Builtin::kNonNumberToNumeric, context(), right);
          Goto(&loop);
        }
      }

      BIND(&if_left_string)Bind(&if_left_string);
      {
        TNode<Uint16T> right_instance_type = LoadMapInstanceType(right_map);

        Label if_right_not_string(this, Label::kDeferred);
        GotoIfNot(IsStringInstanceType(right_instance_type),
                  &if_right_not_string);

        // Both {left} and {right} are strings.
        CombineFeedback(var_type_feedback, CompareOperationFeedback::kString);
        Builtin builtin;
        switch (op) {
          case Operation::kLessThan:
            builtin = Builtin::kStringLessThan;
            break;
          case Operation::kLessThanOrEqual:
            builtin = Builtin::kStringLessThanOrEqual;
            break;
          case Operation::kGreaterThan:
            builtin = Builtin::kStringGreaterThan;
            break;
          case Operation::kGreaterThanOrEqual:
            builtin = Builtin::kStringGreaterThanOrEqual;
            break;
          default:
            UNREACHABLE()V8_Fatal("unreachable code");
        }
        var_result = CAST(CallBuiltin(builtin, context(), left, right))Cast(CallBuiltin(builtin, context(), left, right));
        Goto(&end);

        BIND(&if_right_not_string)Bind(&if_right_not_string);
        {
          OverwriteFeedback(var_type_feedback,
                            CompareOperationFeedback::kAny);
          // {left} is a String, while {right} isn't. Check if {right} is
          // a BigInt, otherwise call ToPrimitive(right, hint Number) if
          // {right} is a receiver, or ToNumeric(left) and then
          // ToNumeric(right) in the other cases.
          STATIC_ASSERT(LAST_JS_RECEIVER_TYPE == LAST_TYPE)static_assert(LAST_JS_RECEIVER_TYPE == LAST_TYPE, "LAST_JS_RECEIVER_TYPE == LAST_TYPE"
);
          Label if_right_bigint(this),
              if_right_receiver(this, Label::kDeferred);
          GotoIf(IsBigIntInstanceType(right_instance_type), &if_right_bigint);
          GotoIf(IsJSReceiverInstanceType(right_instance_type),
                 &if_right_receiver);

          var_left =
              CallBuiltin(Builtin::kNonNumberToNumeric, context(), left);
          var_right = CallBuiltin(Builtin::kToNumeric, context(), right);
          Goto(&loop);

          BIND(&if_right_bigint)Bind(&if_right_bigint);
          {
            var_result = CAST(CallRuntime(Cast(CallRuntime( Runtime::kBigIntCompareToString, NoContextConstant
(), SmiConstant(Reverse(op)), right, left))
                Runtime::kBigIntCompareToString, NoContextConstant(),Cast(CallRuntime( Runtime::kBigIntCompareToString, NoContextConstant
(), SmiConstant(Reverse(op)), right, left))
                SmiConstant(Reverse(op)), right, left))Cast(CallRuntime( Runtime::kBigIntCompareToString, NoContextConstant
(), SmiConstant(Reverse(op)), right, left));
            Goto(&end);
          }

          BIND(&if_right_receiver)Bind(&if_right_receiver);
          {
            Callable callable = CodeFactory::NonPrimitiveToPrimitive(
                isolate(), ToPrimitiveHint::kNumber);
            var_right = CallStub(callable, context(), right);
            Goto(&loop);
          }
        }
      }

      BIND(&if_left_other)Bind(&if_left_other);
      {
        // {left} is neither a Numeric nor a String, and {right} is not a Smi.
        if (var_type_feedback != nullptr) {
          // Collect NumberOrOddball feedback if {left} is an Oddball
          // and {right} is either a HeapNumber or Oddball. Otherwise collect
          // Any feedback.
          Label collect_any_feedback(this), collect_oddball_feedback(this),
              collect_feedback_done(this);
          GotoIfNot(InstanceTypeEqual(left_instance_type, ODDBALL_TYPE),
                    &collect_any_feedback);

          GotoIf(IsHeapNumberMap(right_map), &collect_oddball_feedback);
          TNode<Uint16T> right_instance_type = LoadMapInstanceType(right_map);
          Branch(InstanceTypeEqual(right_instance_type, ODDBALL_TYPE),
                 &collect_oddball_feedback, &collect_any_feedback);

          BIND(&collect_oddball_feedback)Bind(&collect_oddball_feedback);
          {
            CombineFeedback(var_type_feedback,
                            CompareOperationFeedback::kNumberOrOddball);
            Goto(&collect_feedback_done);
          }

          BIND(&collect_any_feedback)Bind(&collect_any_feedback);
          {
            OverwriteFeedback(var_type_feedback,
                              CompareOperationFeedback::kAny);
            Goto(&collect_feedback_done);
          }

          BIND(&collect_feedback_done)Bind(&collect_feedback_done);
        }

        // If {left} is a receiver, call ToPrimitive(left, hint Number).
        // Otherwise call ToNumeric(right) and then ToNumeric(left), the
        // order here is important as it's observable by user code.
        STATIC_ASSERT(LAST_JS_RECEIVER_TYPE == LAST_TYPE)static_assert(LAST_JS_RECEIVER_TYPE == LAST_TYPE, "LAST_JS_RECEIVER_TYPE == LAST_TYPE"
);
        Label if_left_receiver(this, Label::kDeferred);
        GotoIf(IsJSReceiverInstanceType(left_instance_type),
               &if_left_receiver);

        var_right = CallBuiltin(Builtin::kToNumeric, context(), right);
        var_left = CallBuiltin(Builtin::kNonNumberToNumeric, context(), left);
        Goto(&loop);

        BIND(&if_left_receiver)Bind(&if_left_receiver);
        {
          Callable callable = CodeFactory::NonPrimitiveToPrimitive(
              isolate(), ToPrimitiveHint::kNumber);
          var_left = CallStub(callable, context(), left);
          Goto(&loop);
        }
      }
    }
  }
}

BIND(&do_float_comparison)Bind(&do_float_comparison);
{
  switch (op) {
    case Operation::kLessThan:
      Branch(Float64LessThan(var_left_float.value(), var_right_float.value()),
             &return_true, &return_false);
      break;
    case Operation::kLessThanOrEqual:
      Branch(Float64LessThanOrEqual(var_left_float.value(),
                                    var_right_float.value()),
             &return_true, &return_false);
      break;
    case Operation::kGreaterThan:
      Branch(
          Float64GreaterThan(var_left_float.value(), var_right_float.value()),
          &return_true, &return_false);
      break;
    case Operation::kGreaterThanOrEqual:
      Branch(Float64GreaterThanOrEqual(var_left_float.value(),
                                       var_right_float.value()),
             &return_true, &return_false);
      break;
    default:
      UNREACHABLE()V8_Fatal("unreachable code");
  }
}

BIND(&return_true)Bind(&return_true);
{
  var_result = TrueConstant();
  Goto(&end);
}

BIND(&return_false)Bind(&return_false);
{
  var_result = FalseConstant();
  Goto(&end);
}

BIND(&end)Bind(&end);
return var_result.value();
12394}

12396TNode<Smi> CodeStubAssembler::CollectFeedbackForString(
  TNode<Int32T> instance_type) {
TNode<Smi> feedback = SelectSmiConstant(
    Word32Equal(
        Word32And(instance_type, Int32Constant(kIsNotInternalizedMask)),
        Int32Constant(kInternalizedTag)),
    CompareOperationFeedback::kInternalizedString,
    CompareOperationFeedback::kString);
return feedback;
12405}

12407void CodeStubAssembler::GenerateEqual_Same(TNode<Object> value, Label* if_equal,
                                         Label* if_notequal,
                                         TVariable<Smi>* var_type_feedback) {
// In case of abstract or strict equality checks, we need additional checks
// for NaN values because they are not considered equal, even if both the
// left and the right hand side reference exactly the same value.

Label if_smi(this), if_heapnumber(this);
GotoIf(TaggedIsSmi(value), &if_smi);

TNode<HeapObject> value_heapobject = CAST(value)Cast(value);
TNode<Map> value_map = LoadMap(value_heapobject);
GotoIf(IsHeapNumberMap(value_map), &if_heapnumber);

// For non-HeapNumbers, all we do is collect type feedback.
if (var_type_feedback != nullptr) {
  TNode<Uint16T> instance_type = LoadMapInstanceType(value_map);

  Label if_string(this), if_receiver(this), if_oddball(this), if_symbol(this),
      if_bigint(this);
  GotoIf(IsStringInstanceType(instance_type), &if_string);
  GotoIf(IsJSReceiverInstanceType(instance_type), &if_receiver);
  GotoIf(IsOddballInstanceType(instance_type), &if_oddball);
  Branch(IsBigIntInstanceType(instance_type), &if_bigint, &if_symbol);

  BIND(&if_string)Bind(&if_string);
  {
    CSA_DCHECK(this, IsString(value_heapobject))((void)0);
    CombineFeedback(var_type_feedback,
                    CollectFeedbackForString(instance_type));
    Goto(if_equal);
  }

  BIND(&if_symbol)Bind(&if_symbol);
  {
    CSA_DCHECK(this, IsSymbol(value_heapobject))((void)0);
    CombineFeedback(var_type_feedback, CompareOperationFeedback::kSymbol);
    Goto(if_equal);
  }

  BIND(&if_receiver)Bind(&if_receiver);
  {
    CSA_DCHECK(this, IsJSReceiver(value_heapobject))((void)0);
    CombineFeedback(var_type_feedback, CompareOperationFeedback::kReceiver);
    Goto(if_equal);
  }

  BIND(&if_bigint)Bind(&if_bigint);
  {
    CSA_DCHECK(this, IsBigInt(value_heapobject))((void)0);
    CombineFeedback(var_type_feedback, CompareOperationFeedback::kBigInt);
    Goto(if_equal);
  }

  BIND(&if_oddball)Bind(&if_oddball);
  {
    CSA_DCHECK(this, IsOddball(value_heapobject))((void)0);
    Label if_boolean(this), if_not_boolean(this);
    Branch(IsBooleanMap(value_map), &if_boolean, &if_not_boolean);

    BIND(&if_boolean)Bind(&if_boolean);
    {
      CombineFeedback(var_type_feedback, CompareOperationFeedback::kBoolean);
      Goto(if_equal);
    }

    BIND(&if_not_boolean)Bind(&if_not_boolean);
    {
      CSA_DCHECK(this, IsNullOrUndefined(value_heapobject))((void)0);
      CombineFeedback(var_type_feedback,
                      CompareOperationFeedback::kReceiverOrNullOrUndefined);
      Goto(if_equal);
    }
  }
} else {
  Goto(if_equal);
}

BIND(&if_heapnumber)Bind(&if_heapnumber);
{
  CombineFeedback(var_type_feedback, CompareOperationFeedback::kNumber);
  TNode<Float64T> number_value = LoadHeapNumberValue(value_heapobject);
  BranchIfFloat64IsNaN(number_value, if_notequal, if_equal);
}

BIND(&if_smi)Bind(&if_smi);
{
  CombineFeedback(var_type_feedback, CompareOperationFeedback::kSignedSmall);
  Goto(if_equal);
}
12497}

12499// ES6 section 7.2.12 Abstract Equality Comparison
12500TNode<Oddball> CodeStubAssembler::Equal(TNode<Object> left, TNode<Object> right,
                                      const LazyNode<Context>& context,
                                      TVariable<Smi>* var_type_feedback) {
// This is a slightly optimized version of Object::Equals. Whenever you
// change something functionality wise in here, remember to update the
// Object::Equals method as well.

Label if_equal(this), if_notequal(this), do_float_comparison(this),
    do_right_stringtonumber(this, Label::kDeferred), end(this);
TVARIABLE(Oddball, result)TVariable<Oddball> result(this);
TVARIABLE(Float64T, var_left_float)TVariable<Float64T> var_left_float(this);
TVARIABLE(Float64T, var_right_float)TVariable<Float64T> var_right_float(this);

// We can avoid code duplication by exploiting the fact that abstract equality
// is symmetric.
Label use_symmetry(this);

// We might need to loop several times due to ToPrimitive and/or ToNumber
// conversions.
TVARIABLE(Object, var_left, left)TVariable<Object> var_left(left, this);
TVARIABLE(Object, var_right, right)TVariable<Object> var_right(right, this);
VariableList loop_variable_list({&var_left, &var_right}, zone());
if (var_type_feedback != nullptr) {
  // Initialize the type feedback to None. The current feedback will be
  // combined with the previous feedback.
  OverwriteFeedback(var_type_feedback, CompareOperationFeedback::kNone);
  loop_variable_list.push_back(var_type_feedback);
}
Label loop(this, loop_variable_list);
Goto(&loop);
BIND(&loop)Bind(&loop);
{
  left = var_left.value();
  right = var_right.value();

  Label if_notsame(this);
  GotoIf(TaggedNotEqual(left, right), &if_notsame);
  {
    // {left} and {right} reference the exact same value, yet we need special
    // treatment for HeapNumber, as NaN is not equal to NaN.
    GenerateEqual_Same(left, &if_equal, &if_notequal, var_type_feedback);
  }

  BIND(&if_notsame)Bind(&if_notsame);
  Label if_left_smi(this), if_left_not_smi(this);
  Branch(TaggedIsSmi(left), &if_left_smi, &if_left_not_smi);

  BIND(&if_left_smi)Bind(&if_left_smi);
  {
    Label if_right_smi(this), if_right_not_smi(this);
    CombineFeedback(var_type_feedback,
                    CompareOperationFeedback::kSignedSmall);
    Branch(TaggedIsSmi(right), &if_right_smi, &if_right_not_smi);

    BIND(&if_right_smi)Bind(&if_right_smi);
    {
      // We have already checked for {left} and {right} being the same value,
      // so when we get here they must be different Smis.
      Goto(&if_notequal);
    }

    BIND(&if_right_not_smi)Bind(&if_right_not_smi);
    {
      TNode<Map> right_map = LoadMap(CAST(right)Cast(right));
      Label if_right_heapnumber(this), if_right_oddball(this),
          if_right_bigint(this, Label::kDeferred),
          if_right_receiver(this, Label::kDeferred);
      GotoIf(IsHeapNumberMap(right_map), &if_right_heapnumber);

      // {left} is Smi and {right} is not HeapNumber or Smi.
      TNode<Uint16T> right_type = LoadMapInstanceType(right_map);
      GotoIf(IsStringInstanceType(right_type), &do_right_stringtonumber);
      GotoIf(IsOddballInstanceType(right_type), &if_right_oddball);
      GotoIf(IsBigIntInstanceType(right_type), &if_right_bigint);
      GotoIf(IsJSReceiverInstanceType(right_type), &if_right_receiver);
      CombineFeedback(var_type_feedback, CompareOperationFeedback::kAny);
      Goto(&if_notequal);

      BIND(&if_right_heapnumber)Bind(&if_right_heapnumber);
      {
        CombineFeedback(var_type_feedback, CompareOperationFeedback::kNumber);
        var_left_float = SmiToFloat64(CAST(left)Cast(left));
        var_right_float = LoadHeapNumberValue(CAST(right)Cast(right));
        Goto(&do_float_comparison);
      }

      BIND(&if_right_oddball)Bind(&if_right_oddball);
      {
        Label if_right_boolean(this);
        GotoIf(IsBooleanMap(right_map), &if_right_boolean);
        CombineFeedback(var_type_feedback,
                        CompareOperationFeedback::kOddball);
        Goto(&if_notequal);

        BIND(&if_right_boolean)Bind(&if_right_boolean);
        {
          CombineFeedback(var_type_feedback,
                          CompareOperationFeedback::kBoolean);
          var_right = LoadObjectField(CAST(right)Cast(right), Oddball::kToNumberOffset);
          Goto(&loop);
        }
      }

      BIND(&if_right_bigint)Bind(&if_right_bigint);
      {
        CombineFeedback(var_type_feedback, CompareOperationFeedback::kBigInt);
        result = CAST(CallRuntime(Runtime::kBigIntEqualToNumber,Cast(CallRuntime(Runtime::kBigIntEqualToNumber, NoContextConstant
(), right, left))
                                  NoContextConstant(), right, left))Cast(CallRuntime(Runtime::kBigIntEqualToNumber, NoContextConstant
(), right, left));
        Goto(&end);
      }

      BIND(&if_right_receiver)Bind(&if_right_receiver);
      {
        CombineFeedback(var_type_feedback,
                        CompareOperationFeedback::kReceiver);
        Callable callable = CodeFactory::NonPrimitiveToPrimitive(isolate());
        var_right = CallStub(callable, context(), right);
        Goto(&loop);
      }
    }
  }

  BIND(&if_left_not_smi)Bind(&if_left_not_smi);
  {
    GotoIf(TaggedIsSmi(right), &use_symmetry);

    Label if_left_symbol(this), if_left_number(this),
        if_left_string(this, Label::kDeferred),
        if_left_bigint(this, Label::kDeferred), if_left_oddball(this),
        if_left_receiver(this);

    TNode<Map> left_map = LoadMap(CAST(left)Cast(left));
    TNode<Map> right_map = LoadMap(CAST(right)Cast(right));
    TNode<Uint16T> left_type = LoadMapInstanceType(left_map);
    TNode<Uint16T> right_type = LoadMapInstanceType(right_map);

    GotoIf(IsStringInstanceType(left_type), &if_left_string);
    GotoIf(IsSymbolInstanceType(left_type), &if_left_symbol);
    GotoIf(IsHeapNumberInstanceType(left_type), &if_left_number);
    GotoIf(IsOddballInstanceType(left_type), &if_left_oddball);
    Branch(IsBigIntInstanceType(left_type), &if_left_bigint,
           &if_left_receiver);

    BIND(&if_left_string)Bind(&if_left_string);
    {
      GotoIfNot(IsStringInstanceType(right_type), &use_symmetry);
      result =
          CAST(CallBuiltin(Builtin::kStringEqual, context(), left, right))Cast(CallBuiltin(Builtin::kStringEqual, context(), left, right
));
      CombineFeedback(var_type_feedback,
                      SmiOr(CollectFeedbackForString(left_type),
                            CollectFeedbackForString(right_type)));
      Goto(&end);
    }

    BIND(&if_left_number)Bind(&if_left_number);
    {
      Label if_right_not_number(this);

      CombineFeedback(var_type_feedback, CompareOperationFeedback::kNumber);
      GotoIf(Word32NotEqual(left_type, right_type), &if_right_not_number);

      var_left_float = LoadHeapNumberValue(CAST(left)Cast(left));
      var_right_float = LoadHeapNumberValue(CAST(right)Cast(right));
      Goto(&do_float_comparison);

      BIND(&if_right_not_number)Bind(&if_right_not_number);
      {
        Label if_right_oddball(this);

        GotoIf(IsStringInstanceType(right_type), &do_right_stringtonumber);
        GotoIf(IsOddballInstanceType(right_type), &if_right_oddball);
        GotoIf(IsBigIntInstanceType(right_type), &use_symmetry);
        GotoIf(IsJSReceiverInstanceType(right_type), &use_symmetry);
        CombineFeedback(var_type_feedback, CompareOperationFeedback::kAny);
        Goto(&if_notequal);

        BIND(&if_right_oddball)Bind(&if_right_oddball);
        {
          Label if_right_boolean(this);
          GotoIf(IsBooleanMap(right_map), &if_right_boolean);
          CombineFeedback(var_type_feedback,
                          CompareOperationFeedback::kOddball);
          Goto(&if_notequal);

          BIND(&if_right_boolean)Bind(&if_right_boolean);
          {
            CombineFeedback(var_type_feedback,
                            CompareOperationFeedback::kBoolean);
            var_right =
                LoadObjectField(CAST(right)Cast(right), Oddball::kToNumberOffset);
            Goto(&loop);
          }
        }
      }
    }

    BIND(&if_left_bigint)Bind(&if_left_bigint);
    {
      Label if_right_heapnumber(this), if_right_bigint(this),
          if_right_string(this), if_right_boolean(this);
      CombineFeedback(var_type_feedback, CompareOperationFeedback::kBigInt);

      GotoIf(IsHeapNumberMap(right_map), &if_right_heapnumber);
      GotoIf(IsBigIntInstanceType(right_type), &if_right_bigint);
      GotoIf(IsStringInstanceType(right_type), &if_right_string);
      GotoIf(IsBooleanMap(right_map), &if_right_boolean);
      Branch(IsJSReceiverInstanceType(right_type), &use_symmetry,
             &if_notequal);

      BIND(&if_right_heapnumber)Bind(&if_right_heapnumber);
      {
        CombineFeedback(var_type_feedback, CompareOperationFeedback::kNumber);
        result = CAST(CallRuntime(Runtime::kBigIntEqualToNumber,Cast(CallRuntime(Runtime::kBigIntEqualToNumber, NoContextConstant
(), left, right))
                                  NoContextConstant(), left, right))Cast(CallRuntime(Runtime::kBigIntEqualToNumber, NoContextConstant
(), left, right));
        Goto(&end);
      }

      BIND(&if_right_bigint)Bind(&if_right_bigint);
      {
        // We already have BigInt feedback.
        result = CAST(CallRuntime(Runtime::kBigIntEqualToBigInt,Cast(CallRuntime(Runtime::kBigIntEqualToBigInt, NoContextConstant
(), left, right))
                                  NoContextConstant(), left, right))Cast(CallRuntime(Runtime::kBigIntEqualToBigInt, NoContextConstant
(), left, right));
        Goto(&end);
      }

      BIND(&if_right_string)Bind(&if_right_string);
      {
        CombineFeedback(var_type_feedback, CompareOperationFeedback::kString);
        result = CAST(CallRuntime(Runtime::kBigIntEqualToString,Cast(CallRuntime(Runtime::kBigIntEqualToString, NoContextConstant
(), left, right))
                                  NoContextConstant(), left, right))Cast(CallRuntime(Runtime::kBigIntEqualToString, NoContextConstant
(), left, right));
        Goto(&end);
      }

      BIND(&if_right_boolean)Bind(&if_right_boolean);
      {
        CombineFeedback(var_type_feedback,
                        CompareOperationFeedback::kBoolean);
        var_right = LoadObjectField(CAST(right)Cast(right), Oddball::kToNumberOffset);
        Goto(&loop);
      }
    }

    BIND(&if_left_oddball)Bind(&if_left_oddball);
    {
      Label if_left_boolean(this), if_left_not_boolean(this);
      GotoIf(IsBooleanMap(left_map), &if_left_boolean);
      if (var_type_feedback != nullptr) {
        CombineFeedback(var_type_feedback,
                        CompareOperationFeedback::kNullOrUndefined);
        GotoIf(IsUndetectableMap(left_map), &if_left_not_boolean);
      }
      Goto(&if_left_not_boolean);

      BIND(&if_left_not_boolean)Bind(&if_left_not_boolean);
      {
        // {left} is either Null or Undefined. Check if {right} is
        // undetectable (which includes Null and Undefined).
        Label if_right_undetectable(this), if_right_number(this),
            if_right_oddball(this),
            if_right_not_number_or_oddball_or_undetectable(this);
        GotoIf(IsUndetectableMap(right_map), &if_right_undetectable);
        GotoIf(IsHeapNumberInstanceType(right_type), &if_right_number);
        GotoIf(IsOddballInstanceType(right_type), &if_right_oddball);
        Goto(&if_right_not_number_or_oddball_or_undetectable);

        BIND(&if_right_undetectable)Bind(&if_right_undetectable);
        {
          // If {right} is undetectable, it must be either also
          // Null or Undefined, or a Receiver (aka document.all).
          CombineFeedback(
              var_type_feedback,
              CompareOperationFeedback::kReceiverOrNullOrUndefined);
          Goto(&if_equal);
        }

        BIND(&if_right_number)Bind(&if_right_number);
        {
          CombineFeedback(var_type_feedback,
                          CompareOperationFeedback::kNumber);
          Goto(&if_notequal);
        }

        BIND(&if_right_oddball)Bind(&if_right_oddball);
        {
          CombineFeedback(var_type_feedback,
                          CompareOperationFeedback::kOddball);
          Goto(&if_notequal);
        }

        BIND(&if_right_not_number_or_oddball_or_undetectable)Bind(&if_right_not_number_or_oddball_or_undetectable);
        {
          if (var_type_feedback != nullptr) {
            // Track whether {right} is Null, Undefined or Receiver.
            CombineFeedback(
                var_type_feedback,
                CompareOperationFeedback::kReceiverOrNullOrUndefined);
            GotoIf(IsJSReceiverInstanceType(right_type), &if_notequal);
            CombineFeedback(var_type_feedback,
                            CompareOperationFeedback::kAny);
          }
          Goto(&if_notequal);
        }
      }

      BIND(&if_left_boolean)Bind(&if_left_boolean);
      {
        CombineFeedback(var_type_feedback,
                        CompareOperationFeedback::kBoolean);

        // If {right} is a Boolean too, it must be a different Boolean.
        GotoIf(TaggedEqual(right_map, left_map), &if_notequal);

        // Otherwise, convert {left} to number and try again.
        var_left = LoadObjectField(CAST(left)Cast(left), Oddball::kToNumberOffset);
        Goto(&loop);
      }
    }

    BIND(&if_left_symbol)Bind(&if_left_symbol);
    {
      Label if_right_receiver(this);
      GotoIf(IsJSReceiverInstanceType(right_type), &if_right_receiver);
      // {right} is not a JSReceiver and also not the same Symbol as {left},
      // so the result is "not equal".
      if (var_type_feedback != nullptr) {
        Label if_right_symbol(this);
        GotoIf(IsSymbolInstanceType(right_type), &if_right_symbol);
        *var_type_feedback = SmiConstant(CompareOperationFeedback::kAny);
        Goto(&if_notequal);

        BIND(&if_right_symbol)Bind(&if_right_symbol);
        {
          CombineFeedback(var_type_feedback,
                          CompareOperationFeedback::kSymbol);
          Goto(&if_notequal);
        }
      } else {
        Goto(&if_notequal);
      }

      BIND(&if_right_receiver)Bind(&if_right_receiver);
      {
        // {left} is a Primitive and {right} is a JSReceiver, so swapping
        // the order is not observable.
        if (var_type_feedback != nullptr) {
          *var_type_feedback = SmiConstant(CompareOperationFeedback::kAny);
        }
        Goto(&use_symmetry);
      }
    }

    BIND(&if_left_receiver)Bind(&if_left_receiver);
    {
      CSA_DCHECK(this, IsJSReceiverInstanceType(left_type))((void)0);
      Label if_right_receiver(this), if_right_not_receiver(this);
      Branch(IsJSReceiverInstanceType(right_type), &if_right_receiver,
             &if_right_not_receiver);

      BIND(&if_right_receiver)Bind(&if_right_receiver);
      {
        // {left} and {right} are different JSReceiver references.
        CombineFeedback(var_type_feedback,
                        CompareOperationFeedback::kReceiver);
        Goto(&if_notequal);
      }

      BIND(&if_right_not_receiver)Bind(&if_right_not_receiver);
      {
        // Check if {right} is undetectable, which means it must be Null
        // or Undefined, since we already ruled out Receiver for {right}.
        Label if_right_undetectable(this),
            if_right_not_undetectable(this, Label::kDeferred);
        Branch(IsUndetectableMap(right_map), &if_right_undetectable,
               &if_right_not_undetectable);

        BIND(&if_right_undetectable)Bind(&if_right_undetectable);
        {
          // When we get here, {right} must be either Null or Undefined.
          CSA_DCHECK(this, IsNullOrUndefined(right))((void)0);
          if (var_type_feedback != nullptr) {
            *var_type_feedback = SmiConstant(
                CompareOperationFeedback::kReceiverOrNullOrUndefined);
          }
          Branch(IsUndetectableMap(left_map), &if_equal, &if_notequal);
        }

        BIND(&if_right_not_undetectable)Bind(&if_right_not_undetectable);
        {
          // {right} is a Primitive, and neither Null or Undefined;
          // convert {left} to Primitive too.
          CombineFeedback(var_type_feedback, CompareOperationFeedback::kAny);
          Callable callable = CodeFactory::NonPrimitiveToPrimitive(isolate());
          var_left = CallStub(callable, context(), left);
          Goto(&loop);
        }
      }
    }
  }

  BIND(&do_right_stringtonumber)Bind(&do_right_stringtonumber);
  {
    if (var_type_feedback != nullptr) {
      TNode<Map> right_map = LoadMap(CAST(right)Cast(right));
      TNode<Uint16T> right_type = LoadMapInstanceType(right_map);
      CombineFeedback(var_type_feedback,
                      CollectFeedbackForString(right_type));
    }
    var_right = CallBuiltin(Builtin::kStringToNumber, context(), right);
    Goto(&loop);
  }

  BIND(&use_symmetry)Bind(&use_symmetry);
  {
    var_left = right;
    var_right = left;
    Goto(&loop);
  }
}

BIND(&do_float_comparison)Bind(&do_float_comparison);
{
  Branch(Float64Equal(var_left_float.value(), var_right_float.value()),
         &if_equal, &if_notequal);
}

BIND(&if_equal)Bind(&if_equal);
{
  result = TrueConstant();
  Goto(&end);
}

BIND(&if_notequal)Bind(&if_notequal);
{
  result = FalseConstant();
  Goto(&end);
}

BIND(&end)Bind(&end);
return result.value();
12939}

12941TNode<Oddball> CodeStubAssembler::StrictEqual(
  TNode<Object> lhs, TNode<Object> rhs, TVariable<Smi>* var_type_feedback) {
// Pseudo-code for the algorithm below:
//
// if (lhs == rhs) {
//   if (lhs->IsHeapNumber()) return HeapNumber::cast(lhs)->value() != NaN;
//   return true;
// }
// if (!lhs->IsSmi()) {
//   if (lhs->IsHeapNumber()) {
//     if (rhs->IsSmi()) {
//       return Smi::ToInt(rhs) == HeapNumber::cast(lhs)->value();
//     } else if (rhs->IsHeapNumber()) {
//       return HeapNumber::cast(rhs)->value() ==
//       HeapNumber::cast(lhs)->value();
//     } else {
//       return false;
//     }
//   } else {
//     if (rhs->IsSmi()) {
//       return false;
//     } else {
//       if (lhs->IsString()) {
//         if (rhs->IsString()) {
//           return %StringEqual(lhs, rhs);
//         } else {
//           return false;
//         }
//       } else if (lhs->IsBigInt()) {
//         if (rhs->IsBigInt()) {
//           return %BigIntEqualToBigInt(lhs, rhs);
//         } else {
//           return false;
//         }
//       } else {
//         return false;
//       }
//     }
//   }
// } else {
//   if (rhs->IsSmi()) {
//     return false;
//   } else {
//     if (rhs->IsHeapNumber()) {
//       return Smi::ToInt(lhs) == HeapNumber::cast(rhs)->value();
//     } else {
//       return false;
//     }
//   }
// }

Label if_equal(this), if_notequal(this), if_not_equivalent_types(this),
    end(this);
TVARIABLE(Oddball, result)TVariable<Oddball> result(this);

OverwriteFeedback(var_type_feedback, CompareOperationFeedback::kNone);

// Check if {lhs} and {rhs} refer to the same object.
Label if_same(this), if_notsame(this);
Branch(TaggedEqual(lhs, rhs), &if_same, &if_notsame);

BIND(&if_same)Bind(&if_same);
{
  // The {lhs} and {rhs} reference the exact same value, yet we need special
  // treatment for HeapNumber, as NaN is not equal to NaN.
  GenerateEqual_Same(lhs, &if_equal, &if_notequal, var_type_feedback);
}

BIND(&if_notsame)Bind(&if_notsame);
{
  // The {lhs} and {rhs} reference different objects, yet for Smi, HeapNumber,
  // BigInt and String they can still be considered equal.

  // Check if {lhs} is a Smi or a HeapObject.
  Label if_lhsissmi(this), if_lhsisnotsmi(this);
  Branch(TaggedIsSmi(lhs), &if_lhsissmi, &if_lhsisnotsmi);

  BIND(&if_lhsisnotsmi)Bind(&if_lhsisnotsmi);
  {
    // Load the map of {lhs}.
    TNode<Map> lhs_map = LoadMap(CAST(lhs)Cast(lhs));

    // Check if {lhs} is a HeapNumber.
    Label if_lhsisnumber(this), if_lhsisnotnumber(this);
    Branch(IsHeapNumberMap(lhs_map), &if_lhsisnumber, &if_lhsisnotnumber);

    BIND(&if_lhsisnumber)Bind(&if_lhsisnumber);
    {
      // Check if {rhs} is a Smi or a HeapObject.
      Label if_rhsissmi(this), if_rhsisnotsmi(this);
      Branch(TaggedIsSmi(rhs), &if_rhsissmi, &if_rhsisnotsmi);

      BIND(&if_rhsissmi)Bind(&if_rhsissmi);
      {
        // Convert {lhs} and {rhs} to floating point values.
        TNode<Float64T> lhs_value = LoadHeapNumberValue(CAST(lhs)Cast(lhs));
        TNode<Float64T> rhs_value = SmiToFloat64(CAST(rhs)Cast(rhs));

        CombineFeedback(var_type_feedback, CompareOperationFeedback::kNumber);

        // Perform a floating point comparison of {lhs} and {rhs}.
        Branch(Float64Equal(lhs_value, rhs_value), &if_equal, &if_notequal);
      }

      BIND(&if_rhsisnotsmi)Bind(&if_rhsisnotsmi);
      {
        TNode<HeapObject> rhs_ho = CAST(rhs)Cast(rhs);
        // Load the map of {rhs}.
        TNode<Map> rhs_map = LoadMap(rhs_ho);

        // Check if {rhs} is also a HeapNumber.
        Label if_rhsisnumber(this), if_rhsisnotnumber(this);
        Branch(IsHeapNumberMap(rhs_map), &if_rhsisnumber, &if_rhsisnotnumber);

        BIND(&if_rhsisnumber)Bind(&if_rhsisnumber);
        {
          // Convert {lhs} and {rhs} to floating point values.
          TNode<Float64T> lhs_value = LoadHeapNumberValue(CAST(lhs)Cast(lhs));
          TNode<Float64T> rhs_value = LoadHeapNumberValue(CAST(rhs)Cast(rhs));

          CombineFeedback(var_type_feedback,
                          CompareOperationFeedback::kNumber);

          // Perform a floating point comparison of {lhs} and {rhs}.
          Branch(Float64Equal(lhs_value, rhs_value), &if_equal, &if_notequal);
        }

        BIND(&if_rhsisnotnumber)Bind(&if_rhsisnotnumber);
        Goto(&if_not_equivalent_types);
      }
    }

    BIND(&if_lhsisnotnumber)Bind(&if_lhsisnotnumber);
    {
      // Check if {rhs} is a Smi or a HeapObject.
      Label if_rhsissmi(this), if_rhsisnotsmi(this);
      Branch(TaggedIsSmi(rhs), &if_rhsissmi, &if_rhsisnotsmi);

      BIND(&if_rhsissmi)Bind(&if_rhsissmi);
      Goto(&if_not_equivalent_types);

      BIND(&if_rhsisnotsmi)Bind(&if_rhsisnotsmi);
      {
        // Load the instance type of {lhs}.
        TNode<Uint16T> lhs_instance_type = LoadMapInstanceType(lhs_map);

        // Check if {lhs} is a String.
        Label if_lhsisstring(this, Label::kDeferred), if_lhsisnotstring(this);
        Branch(IsStringInstanceType(lhs_instance_type), &if_lhsisstring,
               &if_lhsisnotstring);

        BIND(&if_lhsisstring)Bind(&if_lhsisstring);
        {
          // Load the instance type of {rhs}.
          TNode<Uint16T> rhs_instance_type = LoadInstanceType(CAST(rhs)Cast(rhs));

          // Check if {rhs} is also a String.
          Label if_rhsisstring(this, Label::kDeferred),
              if_rhsisnotstring(this);
          Branch(IsStringInstanceType(rhs_instance_type), &if_rhsisstring,
                 &if_rhsisnotstring);

          BIND(&if_rhsisstring)Bind(&if_rhsisstring);
          {
            if (var_type_feedback != nullptr) {
              TNode<Smi> lhs_feedback =
                  CollectFeedbackForString(lhs_instance_type);
              TNode<Smi> rhs_feedback =
                  CollectFeedbackForString(rhs_instance_type);
              *var_type_feedback = SmiOr(lhs_feedback, rhs_feedback);
            }
            result = CAST(CallBuiltin(Builtin::kStringEqual,Cast(CallBuiltin(Builtin::kStringEqual, NoContextConstant(), lhs
, rhs))
                                      NoContextConstant(), lhs, rhs))Cast(CallBuiltin(Builtin::kStringEqual, NoContextConstant(), lhs
, rhs));
            Goto(&end);
          }

          BIND(&if_rhsisnotstring)Bind(&if_rhsisnotstring);
          Goto(&if_not_equivalent_types);
        }

        BIND(&if_lhsisnotstring)Bind(&if_lhsisnotstring);
        {
          // Check if {lhs} is a BigInt.
          Label if_lhsisbigint(this), if_lhsisnotbigint(this);
          Branch(IsBigIntInstanceType(lhs_instance_type), &if_lhsisbigint,
                 &if_lhsisnotbigint);

          BIND(&if_lhsisbigint)Bind(&if_lhsisbigint);
          {
            // Load the instance type of {rhs}.
            TNode<Uint16T> rhs_instance_type = LoadInstanceType(CAST(rhs)Cast(rhs));

            // Check if {rhs} is also a BigInt.
            Label if_rhsisbigint(this, Label::kDeferred),
                if_rhsisnotbigint(this);
            Branch(IsBigIntInstanceType(rhs_instance_type), &if_rhsisbigint,
                   &if_rhsisnotbigint);

            BIND(&if_rhsisbigint)Bind(&if_rhsisbigint);
            {
              CombineFeedback(var_type_feedback,
                              CompareOperationFeedback::kBigInt);
              result = CAST(CallRuntime(Runtime::kBigIntEqualToBigInt,Cast(CallRuntime(Runtime::kBigIntEqualToBigInt, NoContextConstant
(), lhs, rhs))
                                        NoContextConstant(), lhs, rhs))Cast(CallRuntime(Runtime::kBigIntEqualToBigInt, NoContextConstant
(), lhs, rhs));
              Goto(&end);
            }

            BIND(&if_rhsisnotbigint)Bind(&if_rhsisnotbigint);
            Goto(&if_not_equivalent_types);
          }

          BIND(&if_lhsisnotbigint)Bind(&if_lhsisnotbigint);
          if (var_type_feedback != nullptr) {
            // Load the instance type of {rhs}.
            TNode<Map> rhs_map = LoadMap(CAST(rhs)Cast(rhs));
            TNode<Uint16T> rhs_instance_type = LoadMapInstanceType(rhs_map);

            Label if_lhsissymbol(this), if_lhsisreceiver(this),
                if_lhsisoddball(this);
            GotoIf(IsJSReceiverInstanceType(lhs_instance_type),
                   &if_lhsisreceiver);
            GotoIf(IsBooleanMap(lhs_map), &if_not_equivalent_types);
            GotoIf(IsOddballInstanceType(lhs_instance_type),
                   &if_lhsisoddball);
            Branch(IsSymbolInstanceType(lhs_instance_type), &if_lhsissymbol,
                   &if_not_equivalent_types);

            BIND(&if_lhsisreceiver)Bind(&if_lhsisreceiver);
            {
              GotoIf(IsBooleanMap(rhs_map), &if_not_equivalent_types);
              OverwriteFeedback(var_type_feedback,
                                CompareOperationFeedback::kReceiver);
              GotoIf(IsJSReceiverInstanceType(rhs_instance_type),
                     &if_notequal);
              OverwriteFeedback(
                  var_type_feedback,
                  CompareOperationFeedback::kReceiverOrNullOrUndefined);
              GotoIf(IsOddballInstanceType(rhs_instance_type), &if_notequal);
              Goto(&if_not_equivalent_types);
            }

            BIND(&if_lhsisoddball)Bind(&if_lhsisoddball);
            {
              Label if_lhsisboolean(this), if_lhsisnotboolean(this);
              Branch(IsBooleanMap(lhs_map), &if_lhsisboolean,
                     &if_lhsisnotboolean);

              BIND(&if_lhsisboolean)Bind(&if_lhsisboolean);
              {
                OverwriteFeedback(var_type_feedback,
                                  CompareOperationFeedback::kNumberOrOddball);
                GotoIf(IsBooleanMap(rhs_map), &if_notequal);
                Goto(&if_not_equivalent_types);
              }

              BIND(&if_lhsisnotboolean)Bind(&if_lhsisnotboolean);
              {
                Label if_rhsisheapnumber(this), if_rhsisnotheapnumber(this);

                STATIC_ASSERT(LAST_PRIMITIVE_HEAP_OBJECT_TYPE ==static_assert(LAST_PRIMITIVE_HEAP_OBJECT_TYPE == ODDBALL_TYPE
, "LAST_PRIMITIVE_HEAP_OBJECT_TYPE == ODDBALL_TYPE")
                              ODDBALL_TYPE)static_assert(LAST_PRIMITIVE_HEAP_OBJECT_TYPE == ODDBALL_TYPE
, "LAST_PRIMITIVE_HEAP_OBJECT_TYPE == ODDBALL_TYPE");
                GotoIf(Int32LessThan(rhs_instance_type,
                                     Int32Constant(ODDBALL_TYPE)),
                       &if_not_equivalent_types);

                Branch(IsHeapNumberMap(rhs_map), &if_rhsisheapnumber,
                       &if_rhsisnotheapnumber);

                BIND(&if_rhsisheapnumber)Bind(&if_rhsisheapnumber);
                {
                  OverwriteFeedback(
                      var_type_feedback,
                      CompareOperationFeedback::kNumberOrOddball);
                  Goto(&if_not_equivalent_types);
                }

                BIND(&if_rhsisnotheapnumber)Bind(&if_rhsisnotheapnumber);
                {
                  OverwriteFeedback(
                      var_type_feedback,
                      CompareOperationFeedback::kReceiverOrNullOrUndefined);
                  Goto(&if_notequal);
                }
              }
            }

            BIND(&if_lhsissymbol)Bind(&if_lhsissymbol);
            {
              GotoIfNot(IsSymbolInstanceType(rhs_instance_type),
                        &if_not_equivalent_types);
              OverwriteFeedback(var_type_feedback,
                                CompareOperationFeedback::kSymbol);
              Goto(&if_notequal);
            }
          } else {
            Goto(&if_notequal);
          }
        }
      }
    }
  }

  BIND(&if_lhsissmi)Bind(&if_lhsissmi);
  {
    // We already know that {lhs} and {rhs} are not reference equal, and {lhs}
    // is a Smi; so {lhs} and {rhs} can only be strictly equal if {rhs} is a
    // HeapNumber with an equal floating point value.

    // Check if {rhs} is a Smi or a HeapObject.
    Label if_rhsissmi(this), if_rhsisnotsmi(this);
    Branch(TaggedIsSmi(rhs), &if_rhsissmi, &if_rhsisnotsmi);

    BIND(&if_rhsissmi)Bind(&if_rhsissmi);
    CombineFeedback(var_type_feedback,
                    CompareOperationFeedback::kSignedSmall);
    Goto(&if_notequal);

    BIND(&if_rhsisnotsmi)Bind(&if_rhsisnotsmi);
    {
      // Load the map of the {rhs}.
      TNode<Map> rhs_map = LoadMap(CAST(rhs)Cast(rhs));

      // The {rhs} could be a HeapNumber with the same value as {lhs}.
      Label if_rhsisnumber(this), if_rhsisnotnumber(this);
      Branch(IsHeapNumberMap(rhs_map), &if_rhsisnumber, &if_rhsisnotnumber);

      BIND(&if_rhsisnumber)Bind(&if_rhsisnumber);
      {
        // Convert {lhs} and {rhs} to floating point values.
        TNode<Float64T> lhs_value = SmiToFloat64(CAST(lhs)Cast(lhs));
        TNode<Float64T> rhs_value = LoadHeapNumberValue(CAST(rhs)Cast(rhs));

        CombineFeedback(var_type_feedback, CompareOperationFeedback::kNumber);

        // Perform a floating point comparison of {lhs} and {rhs}.
        Branch(Float64Equal(lhs_value, rhs_value), &if_equal, &if_notequal);
      }

      BIND(&if_rhsisnotnumber)Bind(&if_rhsisnotnumber);
      {
        TNode<Uint16T> rhs_instance_type = LoadMapInstanceType(rhs_map);
        GotoIfNot(IsOddballInstanceType(rhs_instance_type),
                  &if_not_equivalent_types);
        OverwriteFeedback(var_type_feedback,
                          CompareOperationFeedback::kNumberOrOddball);
        Goto(&if_notequal);
      }
    }
  }
}

BIND(&if_equal)Bind(&if_equal);
{
  result = TrueConstant();
  Goto(&end);
}

BIND(&if_not_equivalent_types)Bind(&if_not_equivalent_types);
{
  OverwriteFeedback(var_type_feedback, CompareOperationFeedback::kAny);
  Goto(&if_notequal);
}

BIND(&if_notequal)Bind(&if_notequal);
{
  result = FalseConstant();
  Goto(&end);
}

BIND(&end)Bind(&end);
return result.value();
13312}

13314// ECMA#sec-samevalue
13315// This algorithm differs from the Strict Equality Comparison Algorithm in its
13316// treatment of signed zeroes and NaNs.
13317void CodeStubAssembler::BranchIfSameValue(TNode<Object> lhs, TNode<Object> rhs,
                                        Label* if_true, Label* if_false,
                                        SameValueMode mode) {
TVARIABLE(Float64T, var_lhs_value)TVariable<Float64T> var_lhs_value(this);
TVARIABLE(Float64T, var_rhs_value)TVariable<Float64T> var_rhs_value(this);
Label do_fcmp(this);

// Immediately jump to {if_true} if {lhs} == {rhs}, because - unlike
// StrictEqual - SameValue considers two NaNs to be equal.
GotoIf(TaggedEqual(lhs, rhs), if_true);

// Check if the {lhs} is a Smi.
Label if_lhsissmi(this), if_lhsisheapobject(this);
Branch(TaggedIsSmi(lhs), &if_lhsissmi, &if_lhsisheapobject);

BIND(&if_lhsissmi)Bind(&if_lhsissmi);
{
  // Since {lhs} is a Smi, the comparison can only yield true
  // iff the {rhs} is a HeapNumber with the same float64 value.
  Branch(TaggedIsSmi(rhs), if_false, [&] {
    GotoIfNot(IsHeapNumber(CAST(rhs)Cast(rhs)), if_false);
    var_lhs_value = SmiToFloat64(CAST(lhs)Cast(lhs));
    var_rhs_value = LoadHeapNumberValue(CAST(rhs)Cast(rhs));
    Goto(&do_fcmp);
  });
}

BIND(&if_lhsisheapobject)Bind(&if_lhsisheapobject);
{
  // Check if the {rhs} is a Smi.
  Branch(
      TaggedIsSmi(rhs),
      [&] {
        // Since {rhs} is a Smi, the comparison can only yield true
        // iff the {lhs} is a HeapNumber with the same float64 value.
        GotoIfNot(IsHeapNumber(CAST(lhs)Cast(lhs)), if_false);
        var_lhs_value = LoadHeapNumberValue(CAST(lhs)Cast(lhs));
        var_rhs_value = SmiToFloat64(CAST(rhs)Cast(rhs));
        Goto(&do_fcmp);
      },
      [&] {
        // Now this can only yield true if either both {lhs} and {rhs} are
        // HeapNumbers with the same value, or both are Strings with the
        // same character sequence, or both are BigInts with the same
        // value.
        Label if_lhsisheapnumber(this), if_lhsisstring(this),
            if_lhsisbigint(this);
        const TNode<Map> lhs_map = LoadMap(CAST(lhs)Cast(lhs));
        GotoIf(IsHeapNumberMap(lhs_map), &if_lhsisheapnumber);
        if (mode != SameValueMode::kNumbersOnly) {
          const TNode<Uint16T> lhs_instance_type =
              LoadMapInstanceType(lhs_map);
          GotoIf(IsStringInstanceType(lhs_instance_type), &if_lhsisstring);
          GotoIf(IsBigIntInstanceType(lhs_instance_type), &if_lhsisbigint);
        }
        Goto(if_false);

        BIND(&if_lhsisheapnumber)Bind(&if_lhsisheapnumber);
        {
          GotoIfNot(IsHeapNumber(CAST(rhs)Cast(rhs)), if_false);
          var_lhs_value = LoadHeapNumberValue(CAST(lhs)Cast(lhs));
          var_rhs_value = LoadHeapNumberValue(CAST(rhs)Cast(rhs));
          Goto(&do_fcmp);
        }

        if (mode != SameValueMode::kNumbersOnly) {
          BIND(&if_lhsisstring)Bind(&if_lhsisstring);
          {
            // Now we can only yield true if {rhs} is also a String
            // with the same sequence of characters.
            GotoIfNot(IsString(CAST(rhs)Cast(rhs)), if_false);
            const TNode<Object> result = CallBuiltin(
                Builtin::kStringEqual, NoContextConstant(), lhs, rhs);
            Branch(IsTrue(result), if_true, if_false);
          }

          BIND(&if_lhsisbigint)Bind(&if_lhsisbigint);
          {
            GotoIfNot(IsBigInt(CAST(rhs)Cast(rhs)), if_false);
            const TNode<Object> result = CallRuntime(
                Runtime::kBigIntEqualToBigInt, NoContextConstant(), lhs, rhs);
            Branch(IsTrue(result), if_true, if_false);
          }
        }
      });
}

BIND(&do_fcmp)Bind(&do_fcmp);
{
  TNode<Float64T> lhs_value = UncheckedCast<Float64T>(var_lhs_value.value());
  TNode<Float64T> rhs_value = UncheckedCast<Float64T>(var_rhs_value.value());
  BranchIfSameNumberValue(lhs_value, rhs_value, if_true, if_false);
}
13410}

13412void CodeStubAssembler::BranchIfSameNumberValue(TNode<Float64T> lhs_value,
                                              TNode<Float64T> rhs_value,
                                              Label* if_true,
                                              Label* if_false) {
Label if_equal(this), if_notequal(this);
Branch(Float64Equal(lhs_value, rhs_value), &if_equal, &if_notequal);

BIND(&if_equal)Bind(&if_equal);
{
  // We still need to handle the case when {lhs} and {rhs} are -0.0 and
  // 0.0 (or vice versa). Compare the high word to
  // distinguish between the two.
  const TNode<Uint32T> lhs_hi_word = Float64ExtractHighWord32(lhs_value);
  const TNode<Uint32T> rhs_hi_word = Float64ExtractHighWord32(rhs_value);

  // If x is +0 and y is -0, return false.
  // If x is -0 and y is +0, return false.
  Branch(Word32Equal(lhs_hi_word, rhs_hi_word), if_true, if_false);
}

BIND(&if_notequal)Bind(&if_notequal);
{
  // Return true iff both {rhs} and {lhs} are NaN.
  GotoIf(Float64Equal(lhs_value, lhs_value), if_false);
  Branch(Float64Equal(rhs_value, rhs_value), if_false, if_true);
}
13438}

13440TNode<Oddball> CodeStubAssembler::HasProperty(TNode<Context> context,
                                            TNode<Object> object,
                                            TNode<Object> key,
                                            HasPropertyLookupMode mode) {
Label call_runtime(this, Label::kDeferred), return_true(this),
    return_false(this), end(this), if_proxy(this, Label::kDeferred);

CodeStubAssembler::LookupPropertyInHolder lookup_property_in_holder =
    [this, &return_true](
        TNode<HeapObject> receiver, TNode<HeapObject> holder,
        TNode<Map> holder_map, TNode<Int32T> holder_instance_type,
        TNode<Name> unique_name, Label* next_holder, Label* if_bailout) {
      TryHasOwnProperty(holder, holder_map, holder_instance_type, unique_name,
                        &return_true, next_holder, if_bailout);
    };

CodeStubAssembler::LookupElementInHolder lookup_element_in_holder =
    [this, &return_true, &return_false](
        TNode<HeapObject> receiver, TNode<HeapObject> holder,
        TNode<Map> holder_map, TNode<Int32T> holder_instance_type,
        TNode<IntPtrT> index, Label* next_holder, Label* if_bailout) {
      TryLookupElement(holder, holder_map, holder_instance_type, index,
                       &return_true, &return_false, next_holder, if_bailout);
    };

const bool kHandlePrivateNames = mode == HasPropertyLookupMode::kHasProperty;
TryPrototypeChainLookup(object, object, key, lookup_property_in_holder,
                        lookup_element_in_holder, &return_false,
                        &call_runtime, &if_proxy, kHandlePrivateNames);

TVARIABLE(Oddball, result)TVariable<Oddball> result(this);

BIND(&if_proxy)Bind(&if_proxy);
{
  TNode<Name> name = CAST(CallBuiltin(Builtin::kToName, context, key))Cast(CallBuiltin(Builtin::kToName, context, key));
  switch (mode) {
    case kHasProperty:
      GotoIf(IsPrivateSymbol(name), &call_runtime);

      result = CAST(Cast(CallBuiltin(Builtin::kProxyHasProperty, context, object,
 name))
          CallBuiltin(Builtin::kProxyHasProperty, context, object, name))Cast(CallBuiltin(Builtin::kProxyHasProperty, context, object,
 name));
      Goto(&end);
      break;
    case kForInHasProperty:
      Goto(&call_runtime);
      break;
  }
}

BIND(&return_true)Bind(&return_true);
{
  result = TrueConstant();
  Goto(&end);
}

BIND(&return_false)Bind(&return_false);
{
  result = FalseConstant();
  Goto(&end);
}

BIND(&call_runtime)Bind(&call_runtime);
{
  Runtime::FunctionId fallback_runtime_function_id;
  switch (mode) {
    case kHasProperty:
      fallback_runtime_function_id = Runtime::kHasProperty;
      break;
    case kForInHasProperty:
      fallback_runtime_function_id = Runtime::kForInHasProperty;
      break;
  }

  result =
      CAST(CallRuntime(fallback_runtime_function_id, context, object, key))Cast(CallRuntime(fallback_runtime_function_id, context, object
, key));
  Goto(&end);
}

BIND(&end)Bind(&end);
CSA_DCHECK(this, IsBoolean(result.value()))((void)0);
return result.value();
13521}

13523void CodeStubAssembler::ForInPrepare(TNode<HeapObject> enumerator,
                                   TNode<UintPtrT> slot,
                                   TNode<HeapObject> maybe_feedback_vector,
                                   TNode<FixedArray>* cache_array_out,
                                   TNode<Smi>* cache_length_out,
                                   UpdateFeedbackMode update_feedback_mode) {
// Check if we're using an enum cache.
TVARIABLE(FixedArray, cache_array)TVariable<FixedArray> cache_array(this);
TVARIABLE(Smi, cache_length)TVariable<Smi> cache_length(this);
Label if_fast(this), if_slow(this, Label::kDeferred), out(this);
Branch(IsMap(enumerator), &if_fast, &if_slow);

BIND(&if_fast)Bind(&if_fast);
{
  // Load the enumeration length and cache from the {enumerator}.
  TNode<Map> map_enumerator = CAST(enumerator)Cast(enumerator);
  TNode<WordT> enum_length = LoadMapEnumLength(map_enumerator);
  CSA_DCHECK(this, WordNotEqual(enum_length,((void)0)
                                IntPtrConstant(kInvalidEnumCacheSentinel)))((void)0);
  TNode<DescriptorArray> descriptors = LoadMapDescriptors(map_enumerator);
  TNode<EnumCache> enum_cache = LoadObjectField<EnumCache>(
      descriptors, DescriptorArray::kEnumCacheOffset);
  TNode<FixedArray> enum_keys =
      LoadObjectField<FixedArray>(enum_cache, EnumCache::kKeysOffset);

  // Check if we have enum indices available.
  TNode<FixedArray> enum_indices =
      LoadObjectField<FixedArray>(enum_cache, EnumCache::kIndicesOffset);
  TNode<IntPtrT> enum_indices_length =
      LoadAndUntagFixedArrayBaseLength(enum_indices);
  TNode<Smi> feedback = SelectSmiConstant(
      IntPtrLessThanOrEqual(enum_length, enum_indices_length),
      static_cast<int>(ForInFeedback::kEnumCacheKeysAndIndices),
      static_cast<int>(ForInFeedback::kEnumCacheKeys));
  UpdateFeedback(feedback, maybe_feedback_vector, slot, update_feedback_mode);

  cache_array = enum_keys;
  cache_length = SmiTag(Signed(enum_length));
  Goto(&out);
}

BIND(&if_slow)Bind(&if_slow);
{
  // The {enumerator} is a FixedArray with all the keys to iterate.
  TNode<FixedArray> array_enumerator = CAST(enumerator)Cast(enumerator);

  // Record the fact that we hit the for-in slow-path.
  UpdateFeedback(SmiConstant(ForInFeedback::kAny), maybe_feedback_vector,
                 slot, update_feedback_mode);

  cache_array = array_enumerator;
  cache_length = LoadFixedArrayBaseLength(array_enumerator);
  Goto(&out);
}

BIND(&out)Bind(&out);
*cache_array_out = cache_array.value();
*cache_length_out = cache_length.value();
13581}

13583TNode<String> CodeStubAssembler::Typeof(TNode<Object> value) {
TVARIABLE(String, result_var)TVariable<String> result_var(this);

Label return_number(this, Label::kDeferred), if_oddball(this),
    return_function(this), return_undefined(this), return_object(this),
    return_string(this), return_bigint(this), return_result(this);

GotoIf(TaggedIsSmi(value), &return_number);

TNode<HeapObject> value_heap_object = CAST(value)Cast(value);
TNode<Map> map = LoadMap(value_heap_object);

GotoIf(IsHeapNumberMap(map), &return_number);

TNode<Uint16T> instance_type = LoadMapInstanceType(map);

GotoIf(InstanceTypeEqual(instance_type, ODDBALL_TYPE), &if_oddball);

TNode<Int32T> callable_or_undetectable_mask =
    Word32And(LoadMapBitField(map),
              Int32Constant(Map::Bits1::IsCallableBit::kMask |
                            Map::Bits1::IsUndetectableBit::kMask));

GotoIf(Word32Equal(callable_or_undetectable_mask,
                   Int32Constant(Map::Bits1::IsCallableBit::kMask)),
       &return_function);

GotoIfNot(Word32Equal(callable_or_undetectable_mask, Int32Constant(0)),
          &return_undefined);

GotoIf(IsJSReceiverInstanceType(instance_type), &return_object);

GotoIf(IsStringInstanceType(instance_type), &return_string);

GotoIf(IsBigIntInstanceType(instance_type), &return_bigint);

CSA_DCHECK(this, InstanceTypeEqual(instance_type, SYMBOL_TYPE))((void)0);
result_var = HeapConstant(isolate()->factory()->symbol_string());
Goto(&return_result);

BIND(&return_number)Bind(&return_number);
{
  result_var = HeapConstant(isolate()->factory()->number_string());
  Goto(&return_result);
}

BIND(&if_oddball)Bind(&if_oddball);
{
  TNode<String> type =
      CAST(LoadObjectField(value_heap_object, Oddball::kTypeOfOffset))Cast(LoadObjectField(value_heap_object, Oddball::kTypeOfOffset
));
  result_var = type;
  Goto(&return_result);
}

BIND(&return_function)Bind(&return_function);
{
  result_var = HeapConstant(isolate()->factory()->function_string());
  Goto(&return_result);
}

BIND(&return_undefined)Bind(&return_undefined);
{
  result_var = HeapConstant(isolate()->factory()->undefined_string());
  Goto(&return_result);
}

BIND(&return_object)Bind(&return_object);
{
  result_var = HeapConstant(isolate()->factory()->object_string());
  Goto(&return_result);
}

BIND(&return_string)Bind(&return_string);
{
  result_var = HeapConstant(isolate()->factory()->string_string());
  Goto(&return_result);
}

BIND(&return_bigint)Bind(&return_bigint);
{
  result_var = HeapConstant(isolate()->factory()->bigint_string());
  Goto(&return_result);
}

BIND(&return_result)Bind(&return_result);
return result_var.value();
13669}

13671TNode<HeapObject> CodeStubAssembler::GetSuperConstructor(
  TNode<JSFunction> active_function) {
TNode<Map> map = LoadMap(active_function);
return LoadMapPrototype(map);
13675}

13677TNode<JSReceiver> CodeStubAssembler::SpeciesConstructor(
  TNode<Context> context, TNode<Object> object,
  TNode<JSReceiver> default_constructor) {
Isolate* isolate = this->isolate();
TVARIABLE(JSReceiver, var_result, default_constructor)TVariable<JSReceiver> var_result(default_constructor, this
);

// 2. Let C be ? Get(O, "constructor").
TNode<Object> constructor =
    GetProperty(context, object, isolate->factory()->constructor_string());

// 3. If C is undefined, return defaultConstructor.
Label out(this);
GotoIf(IsUndefined(constructor), &out);

// 4. If Type(C) is not Object, throw a TypeError exception.
ThrowIfNotJSReceiver(context, constructor,
                     MessageTemplate::kConstructorNotReceiver, "");

// 5. Let S be ? Get(C, @@species).
TNode<Object> species =
    GetProperty(context, constructor, isolate->factory()->species_symbol());

// 6. If S is either undefined or null, return defaultConstructor.
GotoIf(IsNullOrUndefined(species), &out);

// 7. If IsConstructor(S) is true, return S.
Label throw_error(this);
GotoIf(TaggedIsSmi(species), &throw_error);
GotoIfNot(IsConstructorMap(LoadMap(CAST(species)Cast(species))), &throw_error);
var_result = CAST(species)Cast(species);
Goto(&out);

// 8. Throw a TypeError exception.
BIND(&throw_error)Bind(&throw_error);
ThrowTypeError(context, MessageTemplate::kSpeciesNotConstructor);

BIND(&out)Bind(&out);
return var_result.value();
13715}

13717TNode<Oddball> CodeStubAssembler::InstanceOf(TNode<Object> object,
                                           TNode<Object> callable,
                                           TNode<Context> context) {
TVARIABLE(Oddball, var_result)TVariable<Oddball> var_result(this);
Label if_notcallable(this, Label::kDeferred),
    if_notreceiver(this, Label::kDeferred), if_otherhandler(this),
    if_nohandler(this, Label::kDeferred), return_true(this),
    return_false(this), return_result(this, &var_result);

// Ensure that the {callable} is actually a JSReceiver.
GotoIf(TaggedIsSmi(callable), &if_notreceiver);
GotoIfNot(IsJSReceiver(CAST(callable)Cast(callable)), &if_notreceiver);

// Load the @@hasInstance property from {callable}.
TNode<Object> inst_of_handler =
    GetProperty(context, callable, HasInstanceSymbolConstant());

// Optimize for the likely case where {inst_of_handler} is the builtin
// Function.prototype[@@hasInstance] method, and emit a direct call in
// that case without any additional checking.
TNode<NativeContext> native_context = LoadNativeContext(context);
TNode<Object> function_has_instance =
    LoadContextElement(native_context, Context::FUNCTION_HAS_INSTANCE_INDEX);
GotoIfNot(TaggedEqual(inst_of_handler, function_has_instance),
          &if_otherhandler);
{
  // Call to Function.prototype[@@hasInstance] directly.
  Callable builtin(BUILTIN_CODE(isolate(), FunctionPrototypeHasInstance)(isolate())->builtins()->code_handle(i::Builtin::kFunctionPrototypeHasInstance
),
                   CallTrampolineDescriptor{});
  var_result =
      CAST(CallJS(builtin, context, inst_of_handler, callable, object))Cast(CallJS(builtin, context, inst_of_handler, callable, object
));
  Goto(&return_result);
}

BIND(&if_otherhandler)Bind(&if_otherhandler);
{
  // Check if there's actually an {inst_of_handler}.
  GotoIf(IsNull(inst_of_handler), &if_nohandler);
  GotoIf(IsUndefined(inst_of_handler), &if_nohandler);

  // Call the {inst_of_handler} for {callable} and {object}.
  TNode<Object> result = Call(context, inst_of_handler, callable, object);

  // Convert the {result} to a Boolean.
  BranchIfToBooleanIsTrue(result, &return_true, &return_false);
}

BIND(&if_nohandler)Bind(&if_nohandler);
{
  // Ensure that the {callable} is actually Callable.
  GotoIfNot(IsCallable(CAST(callable)Cast(callable)), &if_notcallable);

  // Use the OrdinaryHasInstance algorithm.
  var_result = CAST(Cast(CallBuiltin(Builtin::kOrdinaryHasInstance, context, callable
, object))
      CallBuiltin(Builtin::kOrdinaryHasInstance, context, callable, object))Cast(CallBuiltin(Builtin::kOrdinaryHasInstance, context, callable
, object));
  Goto(&return_result);
}

BIND(&if_notcallable)Bind(&if_notcallable);
{ ThrowTypeError(context, MessageTemplate::kNonCallableInInstanceOfCheck); }

BIND(&if_notreceiver)Bind(&if_notreceiver);
{ ThrowTypeError(context, MessageTemplate::kNonObjectInInstanceOfCheck); }

BIND(&return_true)Bind(&return_true);
var_result = TrueConstant();
Goto(&return_result);

BIND(&return_false)Bind(&return_false);
var_result = FalseConstant();
Goto(&return_result);

BIND(&return_result)Bind(&return_result);
return var_result.value();
13791}

13793TNode<Number> CodeStubAssembler::NumberInc(TNode<Number> value) {
TVARIABLE(Number, var_result)TVariable<Number> var_result(this);
TVARIABLE(Float64T, var_finc_value)TVariable<Float64T> var_finc_value(this);
Label if_issmi(this), if_isnotsmi(this), do_finc(this), end(this);
Branch(TaggedIsSmi(value), &if_issmi, &if_isnotsmi);

BIND(&if_issmi)Bind(&if_issmi);
{
  Label if_overflow(this);
  TNode<Smi> smi_value = CAST(value)Cast(value);
  TNode<Smi> one = SmiConstant(1);
  var_result = TrySmiAdd(smi_value, one, &if_overflow);
  Goto(&end);

  BIND(&if_overflow)Bind(&if_overflow);
  {
    var_finc_value = SmiToFloat64(smi_value);
    Goto(&do_finc);
  }
}

BIND(&if_isnotsmi)Bind(&if_isnotsmi);
{
  TNode<HeapNumber> heap_number_value = CAST(value)Cast(value);

  // Load the HeapNumber value.
  var_finc_value = LoadHeapNumberValue(heap_number_value);
  Goto(&do_finc);
}

BIND(&do_finc)Bind(&do_finc);
{
  TNode<Float64T> finc_value = var_finc_value.value();
  TNode<Float64T> one = Float64Constant(1.0);
  TNode<Float64T> finc_result = Float64Add(finc_value, one);
  var_result = AllocateHeapNumberWithValue(finc_result);
  Goto(&end);
}

BIND(&end)Bind(&end);
return var_result.value();
13834}

13836TNode<Number> CodeStubAssembler::NumberDec(TNode<Number> value) {
TVARIABLE(Number, var_result)TVariable<Number> var_result(this);
TVARIABLE(Float64T, var_fdec_value)TVariable<Float64T> var_fdec_value(this);
Label if_issmi(this), if_isnotsmi(this), do_fdec(this), end(this);
Branch(TaggedIsSmi(value), &if_issmi, &if_isnotsmi);

BIND(&if_issmi)Bind(&if_issmi);
{
  TNode<Smi> smi_value = CAST(value)Cast(value);
  TNode<Smi> one = SmiConstant(1);
  Label if_overflow(this);
  var_result = TrySmiSub(smi_value, one, &if_overflow);
  Goto(&end);

  BIND(&if_overflow)Bind(&if_overflow);
  {
    var_fdec_value = SmiToFloat64(smi_value);
    Goto(&do_fdec);
  }
}

BIND(&if_isnotsmi)Bind(&if_isnotsmi);
{
  TNode<HeapNumber> heap_number_value = CAST(value)Cast(value);

  // Load the HeapNumber value.
  var_fdec_value = LoadHeapNumberValue(heap_number_value);
  Goto(&do_fdec);
}

BIND(&do_fdec)Bind(&do_fdec);
{
  TNode<Float64T> fdec_value = var_fdec_value.value();
  TNode<Float64T> minus_one = Float64Constant(-1.0);
  TNode<Float64T> fdec_result = Float64Add(fdec_value, minus_one);
  var_result = AllocateHeapNumberWithValue(fdec_result);
  Goto(&end);
}

BIND(&end)Bind(&end);
return var_result.value();
13877}

13879TNode<Number> CodeStubAssembler::NumberAdd(TNode<Number> a, TNode<Number> b) {
TVARIABLE(Number, var_result)TVariable<Number> var_result(this);
Label float_add(this, Label::kDeferred), end(this);
GotoIf(TaggedIsNotSmi(a), &float_add);
GotoIf(TaggedIsNotSmi(b), &float_add);

// Try fast Smi addition first.
var_result = TrySmiAdd(CAST(a)Cast(a), CAST(b)Cast(b), &float_add);
Goto(&end);

BIND(&float_add)Bind(&float_add);
{
  var_result = ChangeFloat64ToTagged(
      Float64Add(ChangeNumberToFloat64(a), ChangeNumberToFloat64(b)));
  Goto(&end);
}

BIND(&end)Bind(&end);
return var_result.value();
13898}

13900TNode<Number> CodeStubAssembler::NumberSub(TNode<Number> a, TNode<Number> b) {
TVARIABLE(Number, var_result)TVariable<Number> var_result(this);
Label float_sub(this, Label::kDeferred), end(this);
GotoIf(TaggedIsNotSmi(a), &float_sub);
GotoIf(TaggedIsNotSmi(b), &float_sub);

// Try fast Smi subtraction first.
var_result = TrySmiSub(CAST(a)Cast(a), CAST(b)Cast(b), &float_sub);
Goto(&end);

BIND(&float_sub)Bind(&float_sub);
{
  var_result = ChangeFloat64ToTagged(
      Float64Sub(ChangeNumberToFloat64(a), ChangeNumberToFloat64(b)));
  Goto(&end);
}

BIND(&end)Bind(&end);
return var_result.value();
13919}

13921void CodeStubAssembler::GotoIfNotNumber(TNode<Object> input,
                                      Label* is_not_number) {
Label is_number(this);
GotoIf(TaggedIsSmi(input), &is_number);
Branch(IsHeapNumber(CAST(input)Cast(input)), &is_number, is_not_number);
BIND(&is_number)Bind(&is_number);
13927}

13929void CodeStubAssembler::GotoIfNumber(TNode<Object> input, Label* is_number) {
GotoIf(TaggedIsSmi(input), is_number);
GotoIf(IsHeapNumber(CAST(input)Cast(input)), is_number);
13932}

13934TNode<Number> CodeStubAssembler::BitwiseOp(TNode<Word32T> left32,
                                         TNode<Word32T> right32,
                                         Operation bitwise_op) {
switch (bitwise_op) {
  case Operation::kBitwiseAnd:
    return ChangeInt32ToTagged(Signed(Word32And(left32, right32)));
  case Operation::kBitwiseOr:
    return ChangeInt32ToTagged(Signed(Word32Or(left32, right32)));
  case Operation::kBitwiseXor:
    return ChangeInt32ToTagged(Signed(Word32Xor(left32, right32)));
  case Operation::kShiftLeft:
    if (!Word32ShiftIsSafe()) {
      right32 = Word32And(right32, Int32Constant(0x1F));
    }
    return ChangeInt32ToTagged(Signed(Word32Shl(left32, right32)));
  case Operation::kShiftRight:
    if (!Word32ShiftIsSafe()) {
      right32 = Word32And(right32, Int32Constant(0x1F));
    }
    return ChangeInt32ToTagged(Signed(Word32Sar(left32, right32)));
  case Operation::kShiftRightLogical:
    if (!Word32ShiftIsSafe()) {
      right32 = Word32And(right32, Int32Constant(0x1F));
    }
    return ChangeUint32ToTagged(Unsigned(Word32Shr(left32, right32)));
  default:
    break;
}
UNREACHABLE()V8_Fatal("unreachable code");
13963}

13965TNode<Number> CodeStubAssembler::BitwiseSmiOp(TNode<Smi> left, TNode<Smi> right,
                                            Operation bitwise_op) {
switch (bitwise_op) {
  case Operation::kBitwiseAnd:
    return SmiAnd(left, right);
  case Operation::kBitwiseOr:
    return SmiOr(left, right);
  case Operation::kBitwiseXor:
    return SmiXor(left, right);
  // Smi shift left and logical shift rihgt can have (Heap)Number output, so
  // perform int32 operation.
  case Operation::kShiftLeft:
  case Operation::kShiftRightLogical:
    return BitwiseOp(SmiToInt32(left), SmiToInt32(right), bitwise_op);
  // Arithmetic shift right of a Smi can't overflow to the heap number, so
  // perform int32 operation but don't check for overflow.
  case Operation::kShiftRight: {
    TNode<Int32T> left32 = SmiToInt32(left);
    TNode<Int32T> right32 = SmiToInt32(right);
    if (!Word32ShiftIsSafe()) {
      right32 = Word32And(right32, Int32Constant(0x1F));
    }
    return ChangeInt32ToTaggedNoOverflow(Word32Sar(left32, right32));
  }
  default:
    break;
}
UNREACHABLE()V8_Fatal("unreachable code");
13993}

13995TNode<JSObject> CodeStubAssembler::AllocateJSIteratorResult(
  TNode<Context> context, TNode<Object> value, TNode<Oddball> done) {
CSA_DCHECK(this, IsBoolean(done))((void)0);
TNode<NativeContext> native_context = LoadNativeContext(context);
TNode<Map> map = CAST(Cast(LoadContextElement(native_context, Context::ITERATOR_RESULT_MAP_INDEX
))
    LoadContextElement(native_context, Context::ITERATOR_RESULT_MAP_INDEX))Cast(LoadContextElement(native_context, Context::ITERATOR_RESULT_MAP_INDEX
));
TNode<HeapObject> result = Allocate(JSIteratorResult::kSize);
StoreMapNoWriteBarrier(result, map);
StoreObjectFieldRoot(result, JSIteratorResult::kPropertiesOrHashOffset,
                     RootIndex::kEmptyFixedArray);
StoreObjectFieldRoot(result, JSIteratorResult::kElementsOffset,
                     RootIndex::kEmptyFixedArray);
StoreObjectFieldNoWriteBarrier(result, JSIteratorResult::kValueOffset, value);
StoreObjectFieldNoWriteBarrier(result, JSIteratorResult::kDoneOffset, done);
return CAST(result)Cast(result);
14010}

14012TNode<JSObject> CodeStubAssembler::AllocateJSIteratorResultForEntry(
  TNode<Context> context, TNode<Object> key, TNode<Object> value) {
TNode<NativeContext> native_context = LoadNativeContext(context);
TNode<Smi> length = SmiConstant(2);
int const elements_size = FixedArray::SizeFor(2);
TNode<FixedArray> elements =
    UncheckedCast<FixedArray>(Allocate(elements_size));
StoreObjectFieldRoot(elements, FixedArray::kMapOffset,
                     RootIndex::kFixedArrayMap);
StoreObjectFieldNoWriteBarrier(elements, FixedArray::kLengthOffset, length);
StoreFixedArrayElement(elements, 0, key);
StoreFixedArrayElement(elements, 1, value);
TNode<Map> array_map = CAST(LoadContextElement(Cast(LoadContextElement( native_context, Context::JS_ARRAY_PACKED_ELEMENTS_MAP_INDEX
))
    native_context, Context::JS_ARRAY_PACKED_ELEMENTS_MAP_INDEX))Cast(LoadContextElement( native_context, Context::JS_ARRAY_PACKED_ELEMENTS_MAP_INDEX
));
TNode<HeapObject> array = Allocate(JSArray::kHeaderSize);
StoreMapNoWriteBarrier(array, array_map);
StoreObjectFieldRoot(array, JSArray::kPropertiesOrHashOffset,
                     RootIndex::kEmptyFixedArray);
StoreObjectFieldNoWriteBarrier(array, JSArray::kElementsOffset, elements);
StoreObjectFieldNoWriteBarrier(array, JSArray::kLengthOffset, length);
TNode<Map> iterator_map = CAST(Cast(LoadContextElement(native_context, Context::ITERATOR_RESULT_MAP_INDEX
))
    LoadContextElement(native_context, Context::ITERATOR_RESULT_MAP_INDEX))Cast(LoadContextElement(native_context, Context::ITERATOR_RESULT_MAP_INDEX
));
TNode<HeapObject> result = Allocate(JSIteratorResult::kSize);
StoreMapNoWriteBarrier(result, iterator_map);
StoreObjectFieldRoot(result, JSIteratorResult::kPropertiesOrHashOffset,
                     RootIndex::kEmptyFixedArray);
StoreObjectFieldRoot(result, JSIteratorResult::kElementsOffset,
                     RootIndex::kEmptyFixedArray);
StoreObjectFieldNoWriteBarrier(result, JSIteratorResult::kValueOffset, array);
StoreObjectFieldRoot(result, JSIteratorResult::kDoneOffset,
                     RootIndex::kFalseValue);
return CAST(result)Cast(result);
14044}

14046TNode<JSReceiver> CodeStubAssembler::ArraySpeciesCreate(TNode<Context> context,
                                                      TNode<Object> o,
                                                      TNode<Number> len) {
TNode<JSReceiver> constructor =
    CAST(CallRuntime(Runtime::kArraySpeciesConstructor, context, o))Cast(CallRuntime(Runtime::kArraySpeciesConstructor, context, o
));
return Construct(context, constructor, len);
14052}

14054void CodeStubAssembler::ThrowIfArrayBufferIsDetached(
  TNode<Context> context, TNode<JSArrayBuffer> array_buffer,
  const char* method_name) {
Label if_detached(this, Label::kDeferred), if_not_detached(this);
Branch(IsDetachedBuffer(array_buffer), &if_detached, &if_not_detached);
BIND(&if_detached)Bind(&if_detached);
ThrowTypeError(context, MessageTemplate::kDetachedOperation, method_name);
BIND(&if_not_detached)Bind(&if_not_detached);
14062}

14064void CodeStubAssembler::ThrowIfArrayBufferViewBufferIsDetached(
  TNode<Context> context, TNode<JSArrayBufferView> array_buffer_view,
  const char* method_name) {
TNode<JSArrayBuffer> buffer = LoadJSArrayBufferViewBuffer(array_buffer_view);
ThrowIfArrayBufferIsDetached(context, buffer, method_name);
14069}

14071TNode<RawPtrT> CodeStubAssembler::LoadJSArrayBufferBackingStorePtr(
  TNode<JSArrayBuffer> array_buffer) {
return LoadSandboxedPointerFromObject(array_buffer,
                                      JSArrayBuffer::kBackingStoreOffset);
14075}

14077TNode<JSArrayBuffer> CodeStubAssembler::LoadJSArrayBufferViewBuffer(
  TNode<JSArrayBufferView> array_buffer_view) {
return LoadObjectField<JSArrayBuffer>(array_buffer_view,
                                      JSArrayBufferView::kBufferOffset);
14081}

14083TNode<UintPtrT> CodeStubAssembler::LoadJSArrayBufferViewByteLength(
  TNode<JSArrayBufferView> array_buffer_view) {
return LoadObjectField<UintPtrT>(array_buffer_view,
                                 JSArrayBufferView::kByteLengthOffset);
14087}

14089TNode<UintPtrT> CodeStubAssembler::LoadJSArrayBufferViewByteOffset(
  TNode<JSArrayBufferView> array_buffer_view) {
return LoadObjectField<UintPtrT>(array_buffer_view,
                                 JSArrayBufferView::kByteOffsetOffset);
14093}

14095TNode<UintPtrT> CodeStubAssembler::LoadJSTypedArrayLengthAndCheckDetached(
  TNode<JSTypedArray> typed_array, Label* detached) {
TVARIABLE(UintPtrT, result)TVariable<UintPtrT> result(this);
TNode<JSArrayBuffer> buffer = LoadJSArrayBufferViewBuffer(typed_array);

Label variable_length(this), fixed_length(this), end(this);
Branch(IsVariableLengthJSArrayBufferView(typed_array), &variable_length,
       &fixed_length);
BIND(&variable_length)Bind(&variable_length);
{
  result =
      LoadVariableLengthJSTypedArrayLength(typed_array, buffer, detached);
  Goto(&end);
}

BIND(&fixed_length)Bind(&fixed_length);
{
  Label not_detached(this);
  Branch(IsDetachedBuffer(buffer), detached, &not_detached);
  BIND(&not_detached)Bind(&not_detached);
  result = LoadJSTypedArrayLength(typed_array);
  Goto(&end);
}
BIND(&end)Bind(&end);
return result.value();
14120}

14122// ES #sec-integerindexedobjectlength
14123TNode<UintPtrT> CodeStubAssembler::LoadVariableLengthJSTypedArrayLength(
  TNode<JSTypedArray> array, TNode<JSArrayBuffer> buffer,
  Label* detached_or_out_of_bounds) {
// byte_length already takes array's offset into account.
TNode<UintPtrT> byte_length = LoadVariableLengthJSArrayBufferViewByteLength(
    array, buffer, detached_or_out_of_bounds);
TNode<IntPtrT> element_size =
    RabGsabElementsKindToElementByteSize(LoadElementsKind(array));
return Unsigned(IntPtrDiv(Signed(byte_length), element_size));
14132}

14134TNode<UintPtrT>
14135CodeStubAssembler::LoadVariableLengthJSArrayBufferViewByteLength(
  TNode<JSArrayBufferView> array, TNode<JSArrayBuffer> buffer,
  Label* detached_or_out_of_bounds) {
Label is_gsab(this), is_rab(this), end(this);
TVARIABLE(UintPtrT, result)TVariable<UintPtrT> result(this);
TNode<UintPtrT> array_byte_offset = LoadJSArrayBufferViewByteOffset(array);

Branch(IsSharedArrayBuffer(buffer), &is_gsab, &is_rab);
BIND(&is_gsab)Bind(&is_gsab);
{
  // Non-length-tracking GSAB-backed ArrayBufferViews shouldn't end up here.
  CSA_DCHECK(this, IsLengthTrackingJSArrayBufferView(array))((void)0);
  // Read the byte length from the BackingStore.
  const TNode<ExternalReference> byte_length_function =
      ExternalConstant(ExternalReference::gsab_byte_length());
  TNode<ExternalReference> isolate_ptr =
      ExternalConstant(ExternalReference::isolate_address(isolate()));
  TNode<UintPtrT> buffer_byte_length = UncheckedCast<UintPtrT>(
      CallCFunction(byte_length_function, MachineType::UintPtr(),
                    std::make_pair(MachineType::Pointer(), isolate_ptr),
                    std::make_pair(MachineType::AnyTagged(), buffer)));
  // Since the SharedArrayBuffer can't shrink, and we've managed to create
  // this JSArrayBufferDataView without throwing an exception, we know that
  // buffer_byte_length >= array_byte_offset.
  CSA_CHECK(this,(this)->FastCheck(UintPtrGreaterThanOrEqual(buffer_byte_length
, array_byte_offset))
            UintPtrGreaterThanOrEqual(buffer_byte_length, array_byte_offset))(this)->FastCheck(UintPtrGreaterThanOrEqual(buffer_byte_length
, array_byte_offset));
  result = UintPtrSub(buffer_byte_length, array_byte_offset);
  Goto(&end);
}

BIND(&is_rab)Bind(&is_rab);
{
  GotoIf(IsDetachedBuffer(buffer), detached_or_out_of_bounds);

  TNode<UintPtrT> buffer_byte_length = LoadJSArrayBufferByteLength(buffer);

  Label is_length_tracking(this), not_length_tracking(this);
  Branch(IsLengthTrackingJSArrayBufferView(array), &is_length_tracking,
         &not_length_tracking);

  BIND(&is_length_tracking)Bind(&is_length_tracking);
  {
    // The backing RAB might have been shrunk so that the start of the
    // TypedArray is already out of bounds.
    GotoIfNot(UintPtrLessThanOrEqual(array_byte_offset, buffer_byte_length),
              detached_or_out_of_bounds);
    result = UintPtrSub(buffer_byte_length, array_byte_offset);
    Goto(&end);
  }

  BIND(&not_length_tracking)Bind(&not_length_tracking);
  {
    // Check if the backing RAB has shrunk so that the buffer is out of
    // bounds.
    TNode<UintPtrT> array_byte_length =
        LoadJSArrayBufferViewByteLength(array);
    GotoIfNot(UintPtrGreaterThanOrEqual(
                  buffer_byte_length,
                  UintPtrAdd(array_byte_offset, array_byte_length)),
              detached_or_out_of_bounds);
    result = array_byte_length;
    Goto(&end);
  }
}
BIND(&end)Bind(&end);
return result.value();
14201}

14203void CodeStubAssembler::IsJSArrayBufferViewDetachedOrOutOfBounds(
  TNode<JSArrayBufferView> array_buffer_view, Label* detached_or_oob,
  Label* not_detached_nor_oob) {
TNode<JSArrayBuffer> buffer = LoadJSArrayBufferViewBuffer(array_buffer_view);

GotoIf(IsDetachedBuffer(buffer), detached_or_oob);
GotoIfNot(IsVariableLengthJSArrayBufferView(array_buffer_view),
          not_detached_nor_oob);
GotoIf(IsSharedArrayBuffer(buffer), not_detached_nor_oob);

{
  TNode<UintPtrT> buffer_byte_length = LoadJSArrayBufferByteLength(buffer);
  TNode<UintPtrT> array_byte_offset =
      LoadJSArrayBufferViewByteOffset(array_buffer_view);

  Label length_tracking(this), not_length_tracking(this);
  Branch(IsLengthTrackingJSArrayBufferView(array_buffer_view),
         &length_tracking, &not_length_tracking);

  BIND(&length_tracking)Bind(&length_tracking);
  {
    // The backing RAB might have been shrunk so that the start of the
    // TypedArray is already out of bounds.
    Branch(UintPtrLessThanOrEqual(array_byte_offset, buffer_byte_length),
           not_detached_nor_oob, detached_or_oob);
  }

  BIND(&not_length_tracking)Bind(&not_length_tracking);
  {
    // Check if the backing RAB has shrunk so that the buffer is out of
    // bounds.
    TNode<UintPtrT> array_byte_length =
        LoadJSArrayBufferViewByteLength(array_buffer_view);
    Branch(UintPtrGreaterThanOrEqual(
               buffer_byte_length,
               UintPtrAdd(array_byte_offset, array_byte_length)),
           not_detached_nor_oob, detached_or_oob);
  }
}
14242}

14244TNode<BoolT> CodeStubAssembler::IsJSArrayBufferViewDetachedOrOutOfBoundsBoolean(
  TNode<JSArrayBufferView> array_buffer_view) {
Label is_detached_or_out_of_bounds(this),
    not_detached_nor_out_of_bounds(this), end(this);
TVARIABLE(BoolT, result)TVariable<BoolT> result(this);

IsJSArrayBufferViewDetachedOrOutOfBounds(array_buffer_view,
                                         &is_detached_or_out_of_bounds,
                                         &not_detached_nor_out_of_bounds);
BIND(&is_detached_or_out_of_bounds)Bind(&is_detached_or_out_of_bounds);
{
  result = BoolConstant(true);
  Goto(&end);
}
BIND(&not_detached_nor_out_of_bounds)Bind(&not_detached_nor_out_of_bounds);
{
  result = BoolConstant(false);
  Goto(&end);
}
BIND(&end)Bind(&end);
return result.value();
14265}

14267void CodeStubAssembler::CheckJSTypedArrayIndex(
  TNode<UintPtrT> index, TNode<JSTypedArray> typed_array,
  Label* detached_or_out_of_bounds) {
TNode<UintPtrT> len = LoadJSTypedArrayLengthAndCheckDetached(
    typed_array, detached_or_out_of_bounds);

GotoIf(UintPtrGreaterThanOrEqual(index, len), detached_or_out_of_bounds);
14274}

14276// ES #sec-integerindexedobjectbytelength
14277TNode<UintPtrT> CodeStubAssembler::LoadVariableLengthJSTypedArrayByteLength(
  TNode<Context> context, TNode<JSTypedArray> array,
  TNode<JSArrayBuffer> buffer) {
Label miss(this), end(this);
TVARIABLE(UintPtrT, result)TVariable<UintPtrT> result(this);

TNode<UintPtrT> length =
    LoadVariableLengthJSTypedArrayLength(array, buffer, &miss);
TNode<IntPtrT> element_size =
    RabGsabElementsKindToElementByteSize(LoadElementsKind(array));
// Conversion to signed is OK since length < JSArrayBuffer::kMaxByteLength.
TNode<IntPtrT> byte_length = IntPtrMul(Signed(length), element_size);
result = Unsigned(byte_length);
Goto(&end);
BIND(&miss)Bind(&miss);
{
  result = UintPtrConstant(0);
  Goto(&end);
}
BIND(&end)Bind(&end);
return result.value();
14298}

14300TNode<IntPtrT> CodeStubAssembler::RabGsabElementsKindToElementByteSize(
  TNode<Int32T> elements_kind) {
TVARIABLE(IntPtrT, result)TVariable<IntPtrT> result(this);
Label elements_8(this), elements_16(this), elements_32(this),
    elements_64(this), not_found(this), end(this);
int32_t elements_kinds[] = {
    RAB_GSAB_UINT8_ELEMENTS,    RAB_GSAB_UINT8_CLAMPED_ELEMENTS,
    RAB_GSAB_INT8_ELEMENTS,     RAB_GSAB_UINT16_ELEMENTS,
    RAB_GSAB_INT16_ELEMENTS,    RAB_GSAB_UINT32_ELEMENTS,
    RAB_GSAB_INT32_ELEMENTS,    RAB_GSAB_FLOAT32_ELEMENTS,
    RAB_GSAB_FLOAT64_ELEMENTS,  RAB_GSAB_BIGINT64_ELEMENTS,
    RAB_GSAB_BIGUINT64_ELEMENTS};
Label* elements_kind_labels[] = {&elements_8,  &elements_8,  &elements_8,
                                 &elements_16, &elements_16, &elements_32,
                                 &elements_32, &elements_32, &elements_64,
                                 &elements_64, &elements_64};
const size_t kTypedElementsKindCount =
    LAST_RAB_GSAB_FIXED_TYPED_ARRAY_ELEMENTS_KIND -
    FIRST_RAB_GSAB_FIXED_TYPED_ARRAY_ELEMENTS_KIND + 1;
DCHECK_EQ(kTypedElementsKindCount, arraysize(elements_kinds))((void) 0);
DCHECK_EQ(kTypedElementsKindCount, arraysize(elements_kind_labels))((void) 0);
Switch(elements_kind, &not_found, elements_kinds, elements_kind_labels,
       kTypedElementsKindCount);
BIND(&elements_8)Bind(&elements_8);
{
  result = IntPtrConstant(1);
  Goto(&end);
}
BIND(&elements_16)Bind(&elements_16);
{
  result = IntPtrConstant(2);
  Goto(&end);
}
BIND(&elements_32)Bind(&elements_32);
{
  result = IntPtrConstant(4);
  Goto(&end);
}
BIND(&elements_64)Bind(&elements_64);
{
  result = IntPtrConstant(8);
  Goto(&end);
}
BIND(&not_found)Bind(&not_found);
{ Unreachable(); }
BIND(&end)Bind(&end);
return result.value();
14347}

14349TNode<JSArrayBuffer> CodeStubAssembler::GetTypedArrayBuffer(
  TNode<Context> context, TNode<JSTypedArray> array) {
Label call_runtime(this), done(this);
TVARIABLE(Object, var_result)TVariable<Object> var_result(this);

GotoIf(IsOnHeapTypedArray(array), &call_runtime);

TNode<JSArrayBuffer> buffer = LoadJSArrayBufferViewBuffer(array);
GotoIf(IsDetachedBuffer(buffer), &call_runtime);
var_result = buffer;
Goto(&done);

BIND(&call_runtime)Bind(&call_runtime);
{
  var_result = CallRuntime(Runtime::kTypedArrayGetBuffer, context, array);
  Goto(&done);
}

BIND(&done)Bind(&done);
return CAST(var_result.value())Cast(var_result.value());
14369}

14371CodeStubArguments::CodeStubArguments(CodeStubAssembler* assembler,
                                   TNode<IntPtrT> argc, TNode<RawPtrT> fp)
  : assembler_(assembler),
    argc_(argc),
    base_(),
    fp_(fp != nullptr ? fp : assembler_->LoadFramePointer()) {
TNode<IntPtrT> offset = assembler_->IntPtrConstant(
    (StandardFrameConstants::kFixedSlotCountAboveFp + 1) *
    kSystemPointerSize);
DCHECK_NOT_NULL(argc_)((void) 0);
// base_ points to the first argument, not the receiver
// whether present or not.
base_ = assembler_->RawPtrAdd(fp_, offset);
14384}

14386TNode<Object> CodeStubArguments::GetReceiver() const {
intptr_t offset = -kSystemPointerSize;
return assembler_->LoadFullTagged(base_, assembler_->IntPtrConstant(offset));
14389}

14391void CodeStubArguments::SetReceiver(TNode<Object> object) const {
intptr_t offset = -kSystemPointerSize;
assembler_->StoreFullTaggedNoWriteBarrier(
    base_, assembler_->IntPtrConstant(offset), object);
14395}

14397TNode<RawPtrT> CodeStubArguments::AtIndexPtr(TNode<IntPtrT> index) const {
TNode<IntPtrT> offset =
    assembler_->ElementOffsetFromIndex(index, SYSTEM_POINTER_ELEMENTS, 0);
return assembler_->RawPtrAdd(base_, offset);
14401}

14403TNode<Object> CodeStubArguments::AtIndex(TNode<IntPtrT> index) const {
CSA_DCHECK(assembler_, assembler_->UintPtrOrSmiLessThan(((void)0)
                           index, GetLengthWithoutReceiver()))((void)0);
return assembler_->LoadFullTagged(AtIndexPtr(index));
14407}

14409TNode<Object> CodeStubArguments::AtIndex(int index) const {
return AtIndex(assembler_->IntPtrConstant(index));
14411}

14413TNode<IntPtrT> CodeStubArguments::GetLengthWithoutReceiver() const {
return assembler_->IntPtrSub(
    argc_, assembler_->IntPtrConstant(kJSArgcReceiverSlots));
14416}

14418TNode<IntPtrT> CodeStubArguments::GetLengthWithReceiver() const {
return argc_;
14420}

14422TNode<Object> CodeStubArguments::GetOptionalArgumentValue(
  TNode<IntPtrT> index, TNode<Object> default_value) {
CodeStubAssembler::TVariable<Object> result(assembler_);
CodeStubAssembler::Label argument_missing(assembler_),
    argument_done(assembler_, &result);

assembler_->GotoIf(
    assembler_->UintPtrGreaterThanOrEqual(index, GetLengthWithoutReceiver()),
    &argument_missing);
result = AtIndex(index);
assembler_->Goto(&argument_done);

assembler_->BIND(&argument_missing)Bind(&argument_missing);
result = default_value;
assembler_->Goto(&argument_done);

assembler_->BIND(&argument_done)Bind(&argument_done);
return result.value();
14440}

14442void CodeStubArguments::ForEach(
  const CodeStubAssembler::VariableList& vars,
  const CodeStubArguments::ForEachBodyFunction& body, TNode<IntPtrT> first,
  TNode<IntPtrT> last) const {
assembler_->Comment("CodeStubArguments::ForEach");
if (first == nullptr) {
  first = assembler_->IntPtrConstant(0);
}
if (last == nullptr) {
  last = GetLengthWithoutReceiver();
}
TNode<RawPtrT> start = AtIndexPtr(first);
TNode<RawPtrT> end = AtIndexPtr(last);
const int increment = kSystemPointerSize;
assembler_->BuildFastLoop<RawPtrT>(
    vars, start, end,
    [&](TNode<RawPtrT> current) {
      TNode<Object> arg = assembler_->LoadFullTagged(current);
      body(arg);
    },
    increment, CodeStubAssembler::IndexAdvanceMode::kPost);
14463}

14465void CodeStubArguments::PopAndReturn(TNode<Object> value) {
TNode<IntPtrT> pop_count = GetLengthWithReceiver();
assembler_->PopAndReturn(pop_count, value);
14468}

14470TNode<BoolT> CodeStubAssembler::IsFastElementsKind(
  TNode<Int32T> elements_kind) {
STATIC_ASSERT(FIRST_ELEMENTS_KIND == FIRST_FAST_ELEMENTS_KIND)static_assert(FIRST_ELEMENTS_KIND == FIRST_FAST_ELEMENTS_KIND
, "FIRST_ELEMENTS_KIND == FIRST_FAST_ELEMENTS_KIND");
return Uint32LessThanOrEqual(elements_kind,
                             Int32Constant(LAST_FAST_ELEMENTS_KIND));
14475}

14477TNode<BoolT> CodeStubAssembler::IsFastOrNonExtensibleOrSealedElementsKind(
  TNode<Int32T> elements_kind) {
STATIC_ASSERT(FIRST_ELEMENTS_KIND == FIRST_FAST_ELEMENTS_KIND)static_assert(FIRST_ELEMENTS_KIND == FIRST_FAST_ELEMENTS_KIND
, "FIRST_ELEMENTS_KIND == FIRST_FAST_ELEMENTS_KIND");
STATIC_ASSERT(LAST_FAST_ELEMENTS_KIND + 1 == PACKED_NONEXTENSIBLE_ELEMENTS)static_assert(LAST_FAST_ELEMENTS_KIND + 1 == PACKED_NONEXTENSIBLE_ELEMENTS
, "LAST_FAST_ELEMENTS_KIND + 1 == PACKED_NONEXTENSIBLE_ELEMENTS"
);
STATIC_ASSERT(PACKED_NONEXTENSIBLE_ELEMENTS + 1 ==static_assert(PACKED_NONEXTENSIBLE_ELEMENTS + 1 == HOLEY_NONEXTENSIBLE_ELEMENTS
, "PACKED_NONEXTENSIBLE_ELEMENTS + 1 == HOLEY_NONEXTENSIBLE_ELEMENTS"
)
              HOLEY_NONEXTENSIBLE_ELEMENTS)static_assert(PACKED_NONEXTENSIBLE_ELEMENTS + 1 == HOLEY_NONEXTENSIBLE_ELEMENTS
, "PACKED_NONEXTENSIBLE_ELEMENTS + 1 == HOLEY_NONEXTENSIBLE_ELEMENTS"
);
STATIC_ASSERT(HOLEY_NONEXTENSIBLE_ELEMENTS + 1 == PACKED_SEALED_ELEMENTS)static_assert(HOLEY_NONEXTENSIBLE_ELEMENTS + 1 == PACKED_SEALED_ELEMENTS
, "HOLEY_NONEXTENSIBLE_ELEMENTS + 1 == PACKED_SEALED_ELEMENTS"
);
STATIC_ASSERT(PACKED_SEALED_ELEMENTS + 1 == HOLEY_SEALED_ELEMENTS)static_assert(PACKED_SEALED_ELEMENTS + 1 == HOLEY_SEALED_ELEMENTS
, "PACKED_SEALED_ELEMENTS + 1 == HOLEY_SEALED_ELEMENTS");
return Uint32LessThanOrEqual(elements_kind,
                             Int32Constant(HOLEY_SEALED_ELEMENTS));
14487}

14489TNode<BoolT> CodeStubAssembler::IsDoubleElementsKind(
  TNode<Int32T> elements_kind) {
STATIC_ASSERT(FIRST_ELEMENTS_KIND == FIRST_FAST_ELEMENTS_KIND)static_assert(FIRST_ELEMENTS_KIND == FIRST_FAST_ELEMENTS_KIND
, "FIRST_ELEMENTS_KIND == FIRST_FAST_ELEMENTS_KIND");
STATIC_ASSERT((PACKED_DOUBLE_ELEMENTS & 1) == 0)static_assert((PACKED_DOUBLE_ELEMENTS & 1) == 0, "(PACKED_DOUBLE_ELEMENTS & 1) == 0"
);
STATIC_ASSERT(PACKED_DOUBLE_ELEMENTS + 1 == HOLEY_DOUBLE_ELEMENTS)static_assert(PACKED_DOUBLE_ELEMENTS + 1 == HOLEY_DOUBLE_ELEMENTS
, "PACKED_DOUBLE_ELEMENTS + 1 == HOLEY_DOUBLE_ELEMENTS");
return Word32Equal(Word32Shr(elements_kind, Int32Constant(1)),
                   Int32Constant(PACKED_DOUBLE_ELEMENTS / 2));
14496}

14498TNode<BoolT> CodeStubAssembler::IsFastSmiOrTaggedElementsKind(
  TNode<Int32T> elements_kind) {
STATIC_ASSERT(FIRST_ELEMENTS_KIND == FIRST_FAST_ELEMENTS_KIND)static_assert(FIRST_ELEMENTS_KIND == FIRST_FAST_ELEMENTS_KIND
, "FIRST_ELEMENTS_KIND == FIRST_FAST_ELEMENTS_KIND");
STATIC_ASSERT(PACKED_DOUBLE_ELEMENTS > TERMINAL_FAST_ELEMENTS_KIND)static_assert(PACKED_DOUBLE_ELEMENTS > TERMINAL_FAST_ELEMENTS_KIND
, "PACKED_DOUBLE_ELEMENTS > TERMINAL_FAST_ELEMENTS_KIND");
STATIC_ASSERT(HOLEY_DOUBLE_ELEMENTS > TERMINAL_FAST_ELEMENTS_KIND)static_assert(HOLEY_DOUBLE_ELEMENTS > TERMINAL_FAST_ELEMENTS_KIND
, "HOLEY_DOUBLE_ELEMENTS > TERMINAL_FAST_ELEMENTS_KIND");
return Uint32LessThanOrEqual(elements_kind,
                             Int32Constant(TERMINAL_FAST_ELEMENTS_KIND));
14505}

14507TNode<BoolT> CodeStubAssembler::IsFastSmiElementsKind(
  TNode<Int32T> elements_kind) {
return Uint32LessThanOrEqual(elements_kind,
                             Int32Constant(HOLEY_SMI_ELEMENTS));
14511}

14513TNode<BoolT> CodeStubAssembler::IsHoleyFastElementsKind(
  TNode<Int32T> elements_kind) {
CSA_DCHECK(this, IsFastElementsKind(elements_kind))((void)0);

STATIC_ASSERT(HOLEY_SMI_ELEMENTS == (PACKED_SMI_ELEMENTS | 1))static_assert(HOLEY_SMI_ELEMENTS == (PACKED_SMI_ELEMENTS | 1)
, "HOLEY_SMI_ELEMENTS == (PACKED_SMI_ELEMENTS | 1)");
STATIC_ASSERT(HOLEY_ELEMENTS == (PACKED_ELEMENTS | 1))static_assert(HOLEY_ELEMENTS == (PACKED_ELEMENTS | 1), "HOLEY_ELEMENTS == (PACKED_ELEMENTS | 1)"
);
STATIC_ASSERT(HOLEY_DOUBLE_ELEMENTS == (PACKED_DOUBLE_ELEMENTS | 1))static_assert(HOLEY_DOUBLE_ELEMENTS == (PACKED_DOUBLE_ELEMENTS
 | 1), "HOLEY_DOUBLE_ELEMENTS == (PACKED_DOUBLE_ELEMENTS | 1)"
);
return IsSetWord32(elements_kind, 1);
14521}

14523TNode<BoolT> CodeStubAssembler::IsHoleyFastElementsKindForRead(
  TNode<Int32T> elements_kind) {
CSA_DCHECK(this, Uint32LessThanOrEqual(((void)0)
                     elements_kind,((void)0)
                     Int32Constant(LAST_ANY_NONEXTENSIBLE_ELEMENTS_KIND)))((void)0);

STATIC_ASSERT(HOLEY_SMI_ELEMENTS == (PACKED_SMI_ELEMENTS | 1))static_assert(HOLEY_SMI_ELEMENTS == (PACKED_SMI_ELEMENTS | 1)
, "HOLEY_SMI_ELEMENTS == (PACKED_SMI_ELEMENTS | 1)");
STATIC_ASSERT(HOLEY_ELEMENTS == (PACKED_ELEMENTS | 1))static_assert(HOLEY_ELEMENTS == (PACKED_ELEMENTS | 1), "HOLEY_ELEMENTS == (PACKED_ELEMENTS | 1)"
);
STATIC_ASSERT(HOLEY_DOUBLE_ELEMENTS == (PACKED_DOUBLE_ELEMENTS | 1))static_assert(HOLEY_DOUBLE_ELEMENTS == (PACKED_DOUBLE_ELEMENTS
 | 1), "HOLEY_DOUBLE_ELEMENTS == (PACKED_DOUBLE_ELEMENTS | 1)"
);
STATIC_ASSERT(HOLEY_NONEXTENSIBLE_ELEMENTS ==static_assert(HOLEY_NONEXTENSIBLE_ELEMENTS == (PACKED_NONEXTENSIBLE_ELEMENTS
 | 1), "HOLEY_NONEXTENSIBLE_ELEMENTS == (PACKED_NONEXTENSIBLE_ELEMENTS | 1)"
)
              (PACKED_NONEXTENSIBLE_ELEMENTS | 1))static_assert(HOLEY_NONEXTENSIBLE_ELEMENTS == (PACKED_NONEXTENSIBLE_ELEMENTS
 | 1), "HOLEY_NONEXTENSIBLE_ELEMENTS == (PACKED_NONEXTENSIBLE_ELEMENTS | 1)"
);
STATIC_ASSERT(HOLEY_SEALED_ELEMENTS == (PACKED_SEALED_ELEMENTS | 1))static_assert(HOLEY_SEALED_ELEMENTS == (PACKED_SEALED_ELEMENTS
 | 1), "HOLEY_SEALED_ELEMENTS == (PACKED_SEALED_ELEMENTS | 1)"
);
STATIC_ASSERT(HOLEY_FROZEN_ELEMENTS == (PACKED_FROZEN_ELEMENTS | 1))static_assert(HOLEY_FROZEN_ELEMENTS == (PACKED_FROZEN_ELEMENTS
 | 1), "HOLEY_FROZEN_ELEMENTS == (PACKED_FROZEN_ELEMENTS | 1)"
);
return IsSetWord32(elements_kind, 1);
14537}

14539TNode<BoolT> CodeStubAssembler::IsElementsKindGreaterThan(
  TNode<Int32T> target_kind, ElementsKind reference_kind) {
return Int32GreaterThan(target_kind, Int32Constant(reference_kind));
14542}

14544TNode<BoolT> CodeStubAssembler::IsElementsKindGreaterThanOrEqual(
  TNode<Int32T> target_kind, ElementsKind reference_kind) {
return Int32GreaterThanOrEqual(target_kind, Int32Constant(reference_kind));
14547}

14549TNode<BoolT> CodeStubAssembler::IsElementsKindLessThanOrEqual(
  TNode<Int32T> target_kind, ElementsKind reference_kind) {
return Int32LessThanOrEqual(target_kind, Int32Constant(reference_kind));
14552}

14554TNode<BoolT> CodeStubAssembler::IsDebugActive() {
TNode<Uint8T> is_debug_active = Load<Uint8T>(
    ExternalConstant(ExternalReference::debug_is_active_address(isolate())));
return Word32NotEqual(is_debug_active, Int32Constant(0));
14558}

14560TNode<BoolT> CodeStubAssembler::IsSideEffectFreeDebuggingActive() {
TNode<Uint8T> debug_execution_mode = Load<Uint8T>(ExternalConstant(
    ExternalReference::debug_execution_mode_address(isolate())));

TNode<BoolT> is_active =
    Word32Equal(debug_execution_mode,
                Int32Constant(DebugInfo::ExecutionMode::kSideEffects));

return is_active;
14569}

14571TNode<BoolT> CodeStubAssembler::HasAsyncEventDelegate() {
const TNode<RawPtrT> async_event_delegate = Load<RawPtrT>(ExternalConstant(
    ExternalReference::async_event_delegate_address(isolate())));
return WordNotEqual(async_event_delegate, IntPtrConstant(0));
14575}

14577TNode<Uint32T> CodeStubAssembler::PromiseHookFlags() {
return Load<Uint32T>(ExternalConstant(
  ExternalReference::promise_hook_flags_address(isolate())));
14580}

14582TNode<BoolT> CodeStubAssembler::IsAnyPromiseHookEnabled(TNode<Uint32T> flags) {
uint32_t mask = Isolate::PromiseHookFields::HasContextPromiseHook::kMask |
                Isolate::PromiseHookFields::HasIsolatePromiseHook::kMask;
return IsSetWord32(flags, mask);
14586}

14588TNode<BoolT> CodeStubAssembler::IsIsolatePromiseHookEnabled(
  TNode<Uint32T> flags) {
return IsSetWord32<Isolate::PromiseHookFields::HasIsolatePromiseHook>(flags);
14591}

14593#ifdef V8_ENABLE_JAVASCRIPT_PROMISE_HOOKS1
14594TNode<BoolT> CodeStubAssembler::IsContextPromiseHookEnabled(
  TNode<Uint32T> flags) {
return IsSetWord32<Isolate::PromiseHookFields::HasContextPromiseHook>(flags);
14597}
14598#endif

14600TNode<BoolT> CodeStubAssembler::
  IsIsolatePromiseHookEnabledOrHasAsyncEventDelegate(TNode<Uint32T> flags) {
uint32_t mask = Isolate::PromiseHookFields::HasIsolatePromiseHook::kMask |
                Isolate::PromiseHookFields::HasAsyncEventDelegate::kMask;
return IsSetWord32(flags, mask);
14605}

14607TNode<BoolT> CodeStubAssembler::
  IsIsolatePromiseHookEnabledOrDebugIsActiveOrHasAsyncEventDelegate(
      TNode<Uint32T> flags) {
uint32_t mask = Isolate::PromiseHookFields::HasIsolatePromiseHook::kMask |
                Isolate::PromiseHookFields::HasAsyncEventDelegate::kMask |
                Isolate::PromiseHookFields::IsDebugActive::kMask;
return IsSetWord32(flags, mask);
14614}

14616TNode<BoolT> CodeStubAssembler::NeedsAnyPromiseHooks(TNode<Uint32T> flags) {
return Word32NotEqual(flags, Int32Constant(0));
14618}

14620TNode<CodeT> CodeStubAssembler::LoadBuiltin(TNode<Smi> builtin_id) {
CSA_DCHECK(this, SmiBelow(builtin_id, SmiConstant(Builtins::kBuiltinCount)))((void)0);

TNode<IntPtrT> offset =
    ElementOffsetFromIndex(SmiToBInt(builtin_id), SYSTEM_POINTER_ELEMENTS);

TNode<ExternalReference> table =
    ExternalConstant(ExternalReference::builtins_table(isolate()));

return CAST(BitcastWordToTagged(Load<RawPtrT>(table, offset)))Cast(BitcastWordToTagged(Load<RawPtrT>(table, offset)));
14630}

14632TNode<CodeT> CodeStubAssembler::GetSharedFunctionInfoCode(
  TNode<SharedFunctionInfo> shared_info, TVariable<Uint16T>* data_type_out,
  Label* if_compile_lazy) {
TNode<Object> sfi_data =
    LoadObjectField(shared_info, SharedFunctionInfo::kFunctionDataOffset);

TVARIABLE(CodeT, sfi_code)TVariable<CodeT> sfi_code(this);

Label done(this);
Label check_instance_type(this);

// IsSmi: Is builtin
GotoIf(TaggedIsNotSmi(sfi_data), &check_instance_type);
if (data_type_out) {
  *data_type_out = Uint16Constant(0);
}
if (if_compile_lazy) {
  GotoIf(SmiEqual(CAST(sfi_data)Cast(sfi_data), SmiConstant(Builtin::kCompileLazy)),
         if_compile_lazy);
}
sfi_code = LoadBuiltin(CAST(sfi_data)Cast(sfi_data));
Goto(&done);

// Switch on data's instance type.
BIND(&check_instance_type)Bind(&check_instance_type);
TNode<Uint16T> data_type = LoadInstanceType(CAST(sfi_data)Cast(sfi_data));
if (data_type_out) {
  *data_type_out = data_type;
}

int32_t case_values[] = {
  BYTECODE_ARRAY_TYPE,
  CODET_TYPE,
  UNCOMPILED_DATA_WITHOUT_PREPARSE_DATA_TYPE,
  UNCOMPILED_DATA_WITH_PREPARSE_DATA_TYPE,
  UNCOMPILED_DATA_WITHOUT_PREPARSE_DATA_WITH_JOB_TYPE,
  UNCOMPILED_DATA_WITH_PREPARSE_DATA_AND_JOB_TYPE,
  FUNCTION_TEMPLATE_INFO_TYPE,
14670#if V8_ENABLE_WEBASSEMBLY1
  WASM_CAPI_FUNCTION_DATA_TYPE,
  WASM_EXPORTED_FUNCTION_DATA_TYPE,
  WASM_JS_FUNCTION_DATA_TYPE,
  ASM_WASM_DATA_TYPE,
  WASM_ON_FULFILLED_DATA_TYPE,
14676#endif  // V8_ENABLE_WEBASSEMBLY
};
Label check_is_bytecode_array(this);
Label check_is_baseline_data(this);
Label check_is_asm_wasm_data(this);
Label check_is_uncompiled_data(this);
Label check_is_function_template_info(this);
Label check_is_interpreter_data(this);
Label check_is_wasm_function_data(this);
Label check_is_wasm_on_fulfilled(this);
Label* case_labels[] = {
  &check_is_bytecode_array,
  &check_is_baseline_data,
  &check_is_uncompiled_data,
  &check_is_uncompiled_data,
  &check_is_uncompiled_data,
  &check_is_uncompiled_data,
  &check_is_function_template_info,
14694#if V8_ENABLE_WEBASSEMBLY1
  &check_is_wasm_function_data,
  &check_is_wasm_function_data,
  &check_is_wasm_function_data,
  &check_is_asm_wasm_data,
  &check_is_wasm_on_fulfilled,
14700#endif  // V8_ENABLE_WEBASSEMBLY
};
STATIC_ASSERT(arraysize(case_values) == arraysize(case_labels))static_assert((sizeof(ArraySizeHelper(case_values))) == (sizeof
(ArraySizeHelper(case_labels))), "arraysize(case_values) == arraysize(case_labels)"
);
Switch(data_type, &check_is_interpreter_data, case_values, case_labels,
       arraysize(case_labels)(sizeof(ArraySizeHelper(case_labels))));

// IsBytecodeArray: Interpret bytecode
BIND(&check_is_bytecode_array)Bind(&check_is_bytecode_array);
sfi_code = HeapConstant(BUILTIN_CODE(isolate(), InterpreterEntryTrampoline)(isolate())->builtins()->code_handle(i::Builtin::kInterpreterEntryTrampoline
));
Goto(&done);

// IsBaselineData: Execute baseline code
BIND(&check_is_baseline_data)Bind(&check_is_baseline_data);
{
  TNode<CodeT> baseline_code = CAST(sfi_data)Cast(sfi_data);
  sfi_code = baseline_code;
  Goto(&done);
}

// IsUncompiledDataWithPreparseData | IsUncompiledDataWithoutPreparseData:
// Compile lazy
BIND(&check_is_uncompiled_data)Bind(&check_is_uncompiled_data);
sfi_code = HeapConstant(BUILTIN_CODE(isolate(), CompileLazy)(isolate())->builtins()->code_handle(i::Builtin::kCompileLazy
));
Goto(if_compile_lazy ? if_compile_lazy : &done);

// IsFunctionTemplateInfo: API call
BIND(&check_is_function_template_info)Bind(&check_is_function_template_info);
sfi_code = HeapConstant(BUILTIN_CODE(isolate(), HandleApiCall)(isolate())->builtins()->code_handle(i::Builtin::kHandleApiCall
));
Goto(&done);

// IsInterpreterData: Interpret bytecode
BIND(&check_is_interpreter_data)Bind(&check_is_interpreter_data);
// This is the default branch, so assert that we have the expected data type.
CSA_DCHECK(this,((void)0)
           Word32Equal(data_type, Int32Constant(INTERPRETER_DATA_TYPE)))((void)0);
{
  TNode<CodeT> trampoline =
      LoadInterpreterDataInterpreterTrampoline(CAST(sfi_data)Cast(sfi_data));
  sfi_code = trampoline;
}
Goto(&done);

14742#if V8_ENABLE_WEBASSEMBLY1
// IsWasmFunctionData: Use the wrapper code
BIND(&check_is_wasm_function_data)Bind(&check_is_wasm_function_data);
sfi_code = CAST(LoadObjectField(Cast(LoadObjectField( Cast(sfi_data), WasmExportedFunctionData
::kWrapperCodeOffset))
    CAST(sfi_data), WasmExportedFunctionData::kWrapperCodeOffset))Cast(LoadObjectField( Cast(sfi_data), WasmExportedFunctionData
::kWrapperCodeOffset));
Goto(&done);

// IsAsmWasmData: Instantiate using AsmWasmData
BIND(&check_is_asm_wasm_data)Bind(&check_is_asm_wasm_data);
sfi_code = HeapConstant(BUILTIN_CODE(isolate(), InstantiateAsmJs)(isolate())->builtins()->code_handle(i::Builtin::kInstantiateAsmJs
));
Goto(&done);

// IsWasmOnFulfilledData: Resume the suspended wasm continuation.
BIND(&check_is_wasm_on_fulfilled)Bind(&check_is_wasm_on_fulfilled);
sfi_code = HeapConstant(BUILTIN_CODE(isolate(), WasmResume)(isolate())->builtins()->code_handle(i::Builtin::kWasmResume
));
Goto(&done);
14758#endif  // V8_ENABLE_WEBASSEMBLY

BIND(&done)Bind(&done);
return sfi_code.value();
14762}

14764TNode<RawPtrT> CodeStubAssembler::GetCodeEntry(TNode<CodeT> code) {
14765#ifdef V8_EXTERNAL_CODE_SPACE
TNode<CodeDataContainer> cdc = CodeDataContainerFromCodeT(code);
return LoadExternalPointerFromObject(
    cdc, IntPtrConstant(CodeDataContainer::kCodeEntryPointOffset),
    kCodeEntryPointTag);
14770#else
TNode<IntPtrT> object = BitcastTaggedToWord(code);
return ReinterpretCast<RawPtrT>(
    IntPtrAdd(object, IntPtrConstant(Code::kHeaderSize - kHeapObjectTag)));
14774#endif
14775}

14777TNode<JSFunction> CodeStubAssembler::AllocateFunctionWithMapAndContext(
  TNode<Map> map, TNode<SharedFunctionInfo> shared_info,
  TNode<Context> context) {
const TNode<CodeT> code = GetSharedFunctionInfoCode(shared_info);

// TODO(ishell): All the callers of this function pass map loaded from
// Context::STRICT_FUNCTION_WITHOUT_PROTOTYPE_MAP_INDEX. So we can remove
// map parameter.
CSA_DCHECK(this, Word32BinaryNot(IsConstructorMap(map)))((void)0);
CSA_DCHECK(this, Word32BinaryNot(IsFunctionWithPrototypeSlotMap(map)))((void)0);
const TNode<HeapObject> fun = Allocate(JSFunction::kSizeWithoutPrototype);
STATIC_ASSERT(JSFunction::kSizeWithoutPrototype == 7 * kTaggedSize)static_assert(JSFunction::kSizeWithoutPrototype == 7 * kTaggedSize
, "JSFunction::kSizeWithoutPrototype == 7 * kTaggedSize");
StoreMapNoWriteBarrier(fun, map);
StoreObjectFieldRoot(fun, JSObject::kPropertiesOrHashOffset,
                     RootIndex::kEmptyFixedArray);
StoreObjectFieldRoot(fun, JSObject::kElementsOffset,
                     RootIndex::kEmptyFixedArray);
StoreObjectFieldRoot(fun, JSFunction::kFeedbackCellOffset,
                     RootIndex::kManyClosuresCell);
StoreObjectFieldNoWriteBarrier(fun, JSFunction::kSharedFunctionInfoOffset,
                               shared_info);
StoreObjectFieldNoWriteBarrier(fun, JSFunction::kContextOffset, context);
StoreObjectField(fun, JSFunction::kCodeOffset, code);
return CAST(fun)Cast(fun);
14801}

14803void CodeStubAssembler::CheckPrototypeEnumCache(TNode<JSReceiver> receiver,
                                              TNode<Map> receiver_map,
                                              Label* if_fast,
                                              Label* if_slow) {
TVARIABLE(JSReceiver, var_object, receiver)TVariable<JSReceiver> var_object(receiver, this);
TVARIABLE(Map, object_map, receiver_map)TVariable<Map> object_map(receiver_map, this);

Label loop(this, {&var_object, &object_map}), done_loop(this);
Goto(&loop);
BIND(&loop)Bind(&loop);
{
  // Check that there are no elements on the current {var_object}.
  Label if_no_elements(this);

  // The following relies on the elements only aliasing with JSProxy::target,
  // which is a JavaScript value and hence cannot be confused with an elements
  // backing store.
  STATIC_ASSERT(static_cast<int>(JSObject::kElementsOffset) ==static_assert(static_cast<int>(JSObject::kElementsOffset
) == static_cast<int>(JSProxy::kTargetOffset), "static_cast<int>(JSObject::kElementsOffset) == static_cast<int>(JSProxy::kTargetOffset)"
)
                static_cast<int>(JSProxy::kTargetOffset))static_assert(static_cast<int>(JSObject::kElementsOffset
) == static_cast<int>(JSProxy::kTargetOffset), "static_cast<int>(JSObject::kElementsOffset) == static_cast<int>(JSProxy::kTargetOffset)"
);
  TNode<Object> object_elements =
      LoadObjectField(var_object.value(), JSObject::kElementsOffset);
  GotoIf(IsEmptyFixedArray(object_elements), &if_no_elements);
  GotoIf(IsEmptySlowElementDictionary(object_elements), &if_no_elements);

  // It might still be an empty JSArray.
  GotoIfNot(IsJSArrayMap(object_map.value()), if_slow);
  TNode<Number> object_length = LoadJSArrayLength(CAST(var_object.value())Cast(var_object.value()));
  Branch(TaggedEqual(object_length, SmiConstant(0)), &if_no_elements,
         if_slow);

  // Continue with {var_object}'s prototype.
  BIND(&if_no_elements)Bind(&if_no_elements);
  TNode<HeapObject> object = LoadMapPrototype(object_map.value());
  GotoIf(IsNull(object), if_fast);

  // For all {object}s but the {receiver}, check that the cache is empty.
  var_object = CAST(object)Cast(object);
  object_map = LoadMap(object);
  TNode<WordT> object_enum_length = LoadMapEnumLength(object_map.value());
  Branch(WordEqual(object_enum_length, IntPtrConstant(0)), &loop, if_slow);
}
14844}

14846TNode<Map> CodeStubAssembler::CheckEnumCache(TNode<JSReceiver> receiver,
                                           Label* if_empty,
                                           Label* if_runtime) {
Label if_fast(this), if_cache(this), if_no_cache(this, Label::kDeferred);
TNode<Map> receiver_map = LoadMap(receiver);

// Check if the enum length field of the {receiver} is properly initialized,
// indicating that there is an enum cache.
TNode<WordT> receiver_enum_length = LoadMapEnumLength(receiver_map);
Branch(WordEqual(receiver_enum_length,
                 IntPtrConstant(kInvalidEnumCacheSentinel)),
       &if_no_cache, &if_cache);

BIND(&if_no_cache)Bind(&if_no_cache);
{
  // Avoid runtime-call for empty dictionary receivers.
  GotoIfNot(IsDictionaryMap(receiver_map), if_runtime);
  TNode<Smi> length;
  TNode<HeapObject> properties = LoadSlowProperties(receiver);

  if (V8_ENABLE_SWISS_NAME_DICTIONARY_BOOLfalse) {
    CSA_DCHECK(this, Word32Or(IsSwissNameDictionary(properties),((void)0)
                              IsGlobalDictionary(properties)))((void)0);

    length = Select<Smi>(
        IsSwissNameDictionary(properties),
        [=] {
          return GetNumberOfElements(
              UncheckedCast<SwissNameDictionary>(properties));
        },
        [=] {
          return GetNumberOfElements(
              UncheckedCast<GlobalDictionary>(properties));
        });

  } else {
    CSA_DCHECK(this, Word32Or(IsNameDictionary(properties),((void)0)
                              IsGlobalDictionary(properties)))((void)0);
    STATIC_ASSERT(static_cast<int>(NameDictionary::kNumberOfElementsIndex) ==static_assert(static_cast<int>(NameDictionary::kNumberOfElementsIndex
) == static_cast<int>(GlobalDictionary::kNumberOfElementsIndex
), "static_cast<int>(NameDictionary::kNumberOfElementsIndex) == static_cast<int>(GlobalDictionary::kNumberOfElementsIndex)"
)
                  static_cast<int>(GlobalDictionary::kNumberOfElementsIndex))static_assert(static_cast<int>(NameDictionary::kNumberOfElementsIndex
) == static_cast<int>(GlobalDictionary::kNumberOfElementsIndex
), "static_cast<int>(NameDictionary::kNumberOfElementsIndex) == static_cast<int>(GlobalDictionary::kNumberOfElementsIndex)"
);
    length = GetNumberOfElements(UncheckedCast<HashTableBase>(properties));
  }

  GotoIfNot(TaggedEqual(length, SmiConstant(0)), if_runtime);
  // Check that there are no elements on the {receiver} and its prototype
  // chain. Given that we do not create an EnumCache for dict-mode objects,
  // directly jump to {if_empty} if there are no elements and no properties
  // on the {receiver}.
  CheckPrototypeEnumCache(receiver, receiver_map, if_empty, if_runtime);
}

// Check that there are no elements on the fast {receiver} and its
// prototype chain.
BIND(&if_cache)Bind(&if_cache);
CheckPrototypeEnumCache(receiver, receiver_map, &if_fast, if_runtime);

BIND(&if_fast)Bind(&if_fast);
return receiver_map;
14904}

14906TNode<Object> CodeStubAssembler::GetArgumentValue(TorqueStructArguments args,
                                                TNode<IntPtrT> index) {
return CodeStubArguments(this, args).GetOptionalArgumentValue(index);
14909}

14911TorqueStructArguments CodeStubAssembler::GetFrameArguments(
  TNode<RawPtrT> frame, TNode<IntPtrT> argc,
  FrameArgumentsArgcType argc_type) {
if (argc_type == FrameArgumentsArgcType::kCountExcludesReceiver) {
  argc = IntPtrAdd(argc, IntPtrConstant(kJSArgcReceiverSlots));
}
return CodeStubArguments(this, argc, frame).GetTorqueArguments();
14918}

14920void CodeStubAssembler::Print(const char* s) {
std::string formatted(s);
formatted += "\n";
CallRuntime(Runtime::kGlobalPrint, NoContextConstant(),
            StringConstant(formatted.c_str()));
14925}

14927void CodeStubAssembler::Print(const char* prefix,
                            TNode<MaybeObject> tagged_value) {
if (prefix != nullptr) {
  std::string formatted(prefix);
  formatted += ": ";
  Handle<String> string = isolate()->factory()->NewStringFromAsciiChecked(
      formatted.c_str(), AllocationType::kOld);
  CallRuntime(Runtime::kGlobalPrint, NoContextConstant(),
              HeapConstant(string));
}
// CallRuntime only accepts Objects, so do an UncheckedCast to object.
// DebugPrint explicitly checks whether the tagged value is a MaybeObject.
TNode<Object> arg = UncheckedCast<Object>(tagged_value);
CallRuntime(Runtime::kDebugPrint, NoContextConstant(), arg);
14941}

14943IntegerLiteral CodeStubAssembler::ConstexprIntegerLiteralAdd(
  const IntegerLiteral& lhs, const IntegerLiteral& rhs) {
return lhs + rhs;
14946}
14947IntegerLiteral CodeStubAssembler::ConstexprIntegerLiteralLeftShift(
  const IntegerLiteral& lhs, const IntegerLiteral& rhs) {
return lhs << rhs;
14950}
14951IntegerLiteral CodeStubAssembler::ConstexprIntegerLiteralBitwiseOr(
  const IntegerLiteral& lhs, const IntegerLiteral& rhs) {
return lhs | rhs;
14954}

14956void CodeStubAssembler::PerformStackCheck(TNode<Context> context) {
Label ok(this), stack_check_interrupt(this, Label::kDeferred);

TNode<UintPtrT> stack_limit = UncheckedCast<UintPtrT>(
    Load(MachineType::Pointer(),
         ExternalConstant(ExternalReference::address_of_jslimit(isolate()))));
TNode<BoolT> sp_within_limit = StackPointerGreaterThan(stack_limit);

Branch(sp_within_limit, &ok, &stack_check_interrupt);

BIND(&stack_check_interrupt)Bind(&stack_check_interrupt);
CallRuntime(Runtime::kStackGuard, context);
Goto(&ok);

BIND(&ok)Bind(&ok);
14971}

14973TNode<Object> CodeStubAssembler::CallApiCallback(
  TNode<Object> context, TNode<RawPtrT> callback, TNode<IntPtrT> argc,
  TNode<Object> data, TNode<Object> holder, TNode<Object> receiver) {
Callable callable = CodeFactory::CallApiCallback(isolate());
return CallStub(callable, context, callback, argc, data, holder, receiver);
14978}

14980TNode<Object> CodeStubAssembler::CallApiCallback(
  TNode<Object> context, TNode<RawPtrT> callback, TNode<IntPtrT> argc,
  TNode<Object> data, TNode<Object> holder, TNode<Object> receiver,
  TNode<Object> value) {
Callable callable = CodeFactory::CallApiCallback(isolate());
return CallStub(callable, context, callback, argc, data, holder, receiver,
                value);
14987}

14989TNode<Object> CodeStubAssembler::CallRuntimeNewArray(
  TNode<Context> context, TNode<Object> receiver, TNode<Object> length,
  TNode<Object> new_target, TNode<Object> allocation_site) {
// Runtime_NewArray receives arguments in the JS order (to avoid unnecessary
// copy). Except the last two (new_target and allocation_site) which are add
// on top of the stack later.
return CallRuntime(Runtime::kNewArray, context, length, receiver, new_target,
                   allocation_site);
14997}

14999void CodeStubAssembler::TailCallRuntimeNewArray(TNode<Context> context,
                                              TNode<Object> receiver,
                                              TNode<Object> length,
                                              TNode<Object> new_target,
                                              TNode<Object> allocation_site) {
// Runtime_NewArray receives arguments in the JS order (to avoid unnecessary
// copy). Except the last two (new_target and allocation_site) which are add
// on top of the stack later.
return TailCallRuntime(Runtime::kNewArray, context, length, receiver,
                       new_target, allocation_site);
15009}

15011TNode<JSArray> CodeStubAssembler::ArrayCreate(TNode<Context> context,
                                            TNode<Number> length) {
TVARIABLE(JSArray, array)TVariable<JSArray> array(this);
Label allocate_js_array(this);

Label done(this), next(this), runtime(this, Label::kDeferred);
TNode<Smi> limit = SmiConstant(JSArray::kInitialMaxFastElementArray);
CSA_DCHECK_BRANCH(this, [=](Label* ok, Label* not_ok) {((void)0)
  BranchIfNumberRelationalComparison(Operation::kGreaterThanOrEqual, length,((void)0)
                                     SmiConstant(0), ok, not_ok);((void)0)
})((void)0);
// This check also transitively covers the case where length is too big
// to be representable by a SMI and so is not usable with
// AllocateJSArray.
BranchIfNumberRelationalComparison(Operation::kGreaterThanOrEqual, length,
                                   limit, &runtime, &next);

BIND(&runtime)Bind(&runtime);
{
  TNode<NativeContext> native_context = LoadNativeContext(context);
  TNode<JSFunction> array_function =
      CAST(LoadContextElement(native_context, Context::ARRAY_FUNCTION_INDEX))Cast(LoadContextElement(native_context, Context::ARRAY_FUNCTION_INDEX
));
  array = CAST(CallRuntimeNewArray(context, array_function, length,Cast(CallRuntimeNewArray(context, array_function, length, array_function
, UndefinedConstant()))
                                   array_function, UndefinedConstant()))Cast(CallRuntimeNewArray(context, array_function, length, array_function
, UndefinedConstant()));
  Goto(&done);
}

BIND(&next)Bind(&next);
TNode<Smi> length_smi = CAST(length)Cast(length);

TNode<Map> array_map = CAST(LoadContextElement(Cast(LoadContextElement( context, Context::JS_ARRAY_PACKED_SMI_ELEMENTS_MAP_INDEX
))
    context, Context::JS_ARRAY_PACKED_SMI_ELEMENTS_MAP_INDEX))Cast(LoadContextElement( context, Context::JS_ARRAY_PACKED_SMI_ELEMENTS_MAP_INDEX
));

// TODO(delphick): Consider using
// AllocateUninitializedJSArrayWithElements to avoid initializing an
// array and then writing over it.
array = AllocateJSArray(PACKED_SMI_ELEMENTS, array_map, length_smi,
                        SmiConstant(0));
Goto(&done);

BIND(&done)Bind(&done);
return array.value();
15053}

15055void CodeStubAssembler::SetPropertyLength(TNode<Context> context,
                                        TNode<Object> array,
                                        TNode<Number> length) {
SetPropertyStrict(context, array, CodeStubAssembler::LengthStringConstant(),
                  length);
15060}

15062TNode<Smi> CodeStubAssembler::RefillMathRandom(
  TNode<NativeContext> native_context) {
// Cache exhausted, populate the cache. Return value is the new index.
const TNode<ExternalReference> refill_math_random =
    ExternalConstant(ExternalReference::refill_math_random());
const TNode<ExternalReference> isolate_ptr =
    ExternalConstant(ExternalReference::isolate_address(isolate()));
MachineType type_tagged = MachineType::AnyTagged();
MachineType type_ptr = MachineType::Pointer();

return CAST(CallCFunction(refill_math_random, type_tagged,Cast(CallCFunction(refill_math_random, type_tagged, std::make_pair
(type_ptr, isolate_ptr), std::make_pair(type_tagged, native_context
)))
                          std::make_pair(type_ptr, isolate_ptr),Cast(CallCFunction(refill_math_random, type_tagged, std::make_pair
(type_ptr, isolate_ptr), std::make_pair(type_tagged, native_context
)))
                          std::make_pair(type_tagged, native_context)))Cast(CallCFunction(refill_math_random, type_tagged, std::make_pair
(type_ptr, isolate_ptr), std::make_pair(type_tagged, native_context
)));
15075}

15077TNode<String> CodeStubAssembler::TaggedToDirectString(TNode<Object> value,
                                                    Label* fail) {
ToDirectStringAssembler to_direct(state(), CAST(value)Cast(value));
to_direct.TryToDirect(fail);
to_direct.PointerToData(fail);
return CAST(value)Cast(value);
15083}

15085void CodeStubAssembler::RemoveFinalizationRegistryCellFromUnregisterTokenMap(
  TNode<JSFinalizationRegistry> finalization_registry,
  TNode<WeakCell> weak_cell) {
const TNode<ExternalReference> remove_cell = ExternalConstant(
    ExternalReference::
        js_finalization_registry_remove_cell_from_unregister_token_map());
const TNode<ExternalReference> isolate_ptr =
    ExternalConstant(ExternalReference::isolate_address(isolate()));

CallCFunction(remove_cell, MachineType::Pointer(),
              std::make_pair(MachineType::Pointer(), isolate_ptr),
              std::make_pair(MachineType::AnyTagged(), finalization_registry),
              std::make_pair(MachineType::AnyTagged(), weak_cell));
15098}

15100PrototypeCheckAssembler::PrototypeCheckAssembler(
  compiler::CodeAssemblerState* state, Flags flags,
  TNode<NativeContext> native_context, TNode<Map> initial_prototype_map,
  base::Vector<DescriptorIndexNameValue> properties)
  : CodeStubAssembler(state),
    flags_(flags),
    native_context_(native_context),
    initial_prototype_map_(initial_prototype_map),
    properties_(properties) {}

15110void PrototypeCheckAssembler::CheckAndBranch(TNode<HeapObject> prototype,
                                           Label* if_unmodified,
                                           Label* if_modified) {
TNode<Map> prototype_map = LoadMap(prototype);
TNode<DescriptorArray> descriptors = LoadMapDescriptors(prototype_map);

// The continuation of a failed fast check: if property identity checks are
// enabled, we continue there (since they may still classify the prototype as
// fast), otherwise we bail out.
Label property_identity_check(this, Label::kDeferred);
Label* if_fast_check_failed =
    ((flags_ & kCheckPrototypePropertyIdentity) == 0)
        ? if_modified
        : &property_identity_check;

if ((flags_ & kCheckPrototypePropertyConstness) != 0) {
  // A simple prototype map identity check. Note that map identity does not
  // guarantee unmodified properties. It does guarantee that no new properties
  // have been added, or old properties deleted.

  GotoIfNot(TaggedEqual(prototype_map, initial_prototype_map_),
            if_fast_check_failed);

  // We need to make sure that relevant properties in the prototype have
  // not been tampered with. We do this by checking that their slots
  // in the prototype's descriptor array are still marked as const.

  TNode<Uint32T> combined_details;
  for (int i = 0; i < properties_.length(); i++) {
    // Assert the descriptor index is in-bounds.
    int descriptor = properties_[i].descriptor_index;
    CSA_DCHECK(this, Int32LessThan(Int32Constant(descriptor),((void)0)
                                   LoadNumberOfDescriptors(descriptors)))((void)0);

    // Assert that the name is correct. This essentially checks that
    // the descriptor index corresponds to the insertion order in
    // the bootstrapper.
    CSA_DCHECK(((void)0)
        this,((void)0)
        TaggedEqual(LoadKeyByDescriptorEntry(descriptors, descriptor),((void)0)
                    CodeAssembler::LoadRoot(properties_[i].name_root_index)))((void)0);

    TNode<Uint32T> details =
        DescriptorArrayGetDetails(descriptors, Uint32Constant(descriptor));

    if (i == 0) {
      combined_details = details;
    } else {
      combined_details = Word32And(combined_details, details);
    }
  }

  TNode<Uint32T> constness =
      DecodeWord32<PropertyDetails::ConstnessField>(combined_details);

  Branch(
      Word32Equal(constness,
                  Int32Constant(static_cast<int>(PropertyConstness::kConst))),
      if_unmodified, if_fast_check_failed);
}

if ((flags_ & kCheckPrototypePropertyIdentity) != 0) {
  // The above checks have failed, for whatever reason (maybe the prototype
  // map has changed, or a property is no longer const). This block implements
  // a more thorough check that can also accept maps which 1. do not have the
  // initial map, 2. have mutable relevant properties, but 3. still match the
  // expected value for all relevant properties.

  BIND(&property_identity_check)Bind(&property_identity_check);

  int max_descriptor_index = -1;
  for (int i = 0; i < properties_.length(); i++) {
    max_descriptor_index =
        std::max(max_descriptor_index, properties_[i].descriptor_index);
  }

  // If the greatest descriptor index is out of bounds, the map cannot be
  // fast.
  GotoIfNot(Int32LessThan(Int32Constant(max_descriptor_index),
                          LoadNumberOfDescriptors(descriptors)),
            if_modified);

  // Logic below only handles maps with fast properties.
  GotoIfMapHasSlowProperties(prototype_map, if_modified);

  for (int i = 0; i < properties_.length(); i++) {
    const DescriptorIndexNameValue& p = properties_[i];
    const int descriptor = p.descriptor_index;

    // Check if the name is correct. This essentially checks that
    // the descriptor index corresponds to the insertion order in
    // the bootstrapper.
    GotoIfNot(TaggedEqual(LoadKeyByDescriptorEntry(descriptors, descriptor),
                          CodeAssembler::LoadRoot(p.name_root_index)),
              if_modified);

    // Finally, check whether the actual value equals the expected value.
    TNode<Uint32T> details =
        DescriptorArrayGetDetails(descriptors, Uint32Constant(descriptor));
    TVARIABLE(Uint32T, var_details, details)TVariable<Uint32T> var_details(details, this);
    TVARIABLE(Object, var_value)TVariable<Object> var_value(this);

    const int key_index = DescriptorArray::ToKeyIndex(descriptor);
    LoadPropertyFromFastObject(prototype, prototype_map, descriptors,
                               IntPtrConstant(key_index), &var_details,
                               &var_value);

    TNode<Object> actual_value = var_value.value();
    TNode<Object> expected_value =
        LoadContextElement(native_context_, p.expected_value_context_index);
    GotoIfNot(TaggedEqual(actual_value, expected_value), if_modified);
  }

  Goto(if_unmodified);
}
15225}

15227//
15228// Begin of SwissNameDictionary macros
15229//

15231namespace {

15233// Provides load and store functions that abstract over the details of accessing
15234// the meta table in memory. Instead they allow using logical indices that are
15235// independent from the underlying entry size in the meta table of a
15236// SwissNameDictionary.
15237class MetaTableAccessor {
public:
MetaTableAccessor(CodeStubAssembler& csa, MachineType mt)
    : csa{csa}, mt{mt} {}

TNode<Uint32T> Load(TNode<ByteArray> meta_table, TNode<IntPtrT> index) {
  TNode<IntPtrT> offset = OverallOffset(meta_table, index);

  return csa.UncheckedCast<Uint32T>(
      csa.LoadFromObject(mt, meta_table, offset));
}

TNode<Uint32T> Load(TNode<ByteArray> meta_table, int index) {
  return Load(meta_table, csa.IntPtrConstant(index));
}

void Store(TNode<ByteArray> meta_table, TNode<IntPtrT> index,
           TNode<Uint32T> data) {
  TNode<IntPtrT> offset = OverallOffset(meta_table, index);

15257#ifdef DEBUG
  int bits = mt.MemSize() * 8;
  TNode<UintPtrT> max_value = csa.UintPtrConstant((1ULL << bits) - 1);

  CSA_DCHECK(&csa, csa.UintPtrLessThanOrEqual(csa.ChangeUint32ToWord(data),((void)0)
                                              max_value))((void)0);
15263#endif

  csa.StoreToObject(mt.representation(), meta_table, offset, data,
                    StoreToObjectWriteBarrier::kNone);
}

void Store(TNode<ByteArray> meta_table, int index, TNode<Uint32T> data) {
  Store(meta_table, csa.IntPtrConstant(index), data);
}

private:
TNode<IntPtrT> OverallOffset(TNode<ByteArray> meta_table,
                             TNode<IntPtrT> index) {
  // TODO(v8:11330): consider using ElementOffsetFromIndex().

  int offset_to_data_minus_tag = ByteArray::kHeaderSize - kHeapObjectTag;

  TNode<IntPtrT> overall_offset;
  int size = mt.MemSize();
  intptr_t constant;
  if (csa.TryToIntPtrConstant(index, &constant)) {
    intptr_t index_offset = constant * size;
    overall_offset =
        csa.IntPtrConstant(offset_to_data_minus_tag + index_offset);
  } else {
    TNode<IntPtrT> index_offset =
        csa.IntPtrMul(index, csa.IntPtrConstant(size));
    overall_offset = csa.IntPtrAdd(
        csa.IntPtrConstant(offset_to_data_minus_tag), index_offset);
  }

15294#ifdef DEBUG
  TNode<IntPtrT> byte_array_data_bytes =
      csa.SmiToIntPtr(csa.LoadFixedArrayBaseLength(meta_table));
  TNode<IntPtrT> max_allowed_offset = csa.IntPtrAdd(
      byte_array_data_bytes, csa.IntPtrConstant(offset_to_data_minus_tag));
  CSA_DCHECK(&csa, csa.UintPtrLessThan(overall_offset, max_allowed_offset))((void)0);
15300#endif

  return overall_offset;
}

CodeStubAssembler& csa;
MachineType mt;
15307};

15309// Type of functions that given a MetaTableAccessor, use its load and store
15310// functions to generate code for operating on the meta table.
15311using MetaTableAccessFunction = std::function<void(MetaTableAccessor&)>;

15313// Helper function for macros operating on the meta table of a
15314// SwissNameDictionary. Given a MetaTableAccessFunction, generates branching
15315// code and uses the builder to generate code for each of the three possible
15316// sizes per entry a meta table can have.
15317void GenerateMetaTableAccess(CodeStubAssembler* csa, TNode<IntPtrT> capacity,
                           MetaTableAccessFunction builder) {
MetaTableAccessor mta8 = MetaTableAccessor(*csa, MachineType::Uint8());
MetaTableAccessor mta16 = MetaTableAccessor(*csa, MachineType::Uint16());
MetaTableAccessor mta32 = MetaTableAccessor(*csa, MachineType::Uint32());

using Label = compiler::CodeAssemblerLabel;
Label small(csa), medium(csa), done(csa);

csa->GotoIf(
    csa->IntPtrLessThanOrEqual(
        capacity,
        csa->IntPtrConstant(SwissNameDictionary::kMax1ByteMetaTableCapacity)),
    &small);
csa->GotoIf(
    csa->IntPtrLessThanOrEqual(
        capacity,
        csa->IntPtrConstant(SwissNameDictionary::kMax2ByteMetaTableCapacity)),
    &medium);

builder(mta32);
csa->Goto(&done);

csa->Bind(&medium);
builder(mta16);
csa->Goto(&done);

csa->Bind(&small);
builder(mta8);
csa->Goto(&done);
csa->Bind(&done);
15348}

15350}  // namespace

15352TNode<IntPtrT> CodeStubAssembler::LoadSwissNameDictionaryNumberOfElements(
  TNode<SwissNameDictionary> table, TNode<IntPtrT> capacity) {
TNode<ByteArray> meta_table = LoadSwissNameDictionaryMetaTable(table);

TVARIABLE(Uint32T, nof, Uint32Constant(0))TVariable<Uint32T> nof(Uint32Constant(0), this);
MetaTableAccessFunction builder = [&](MetaTableAccessor& mta) {
  nof = mta.Load(meta_table,
                 SwissNameDictionary::kMetaTableElementCountFieldIndex);
};

GenerateMetaTableAccess(this, capacity, builder);
return ChangeInt32ToIntPtr(nof.value());
15364}

15366TNode<IntPtrT>
15367CodeStubAssembler::LoadSwissNameDictionaryNumberOfDeletedElements(
  TNode<SwissNameDictionary> table, TNode<IntPtrT> capacity) {
TNode<ByteArray> meta_table = LoadSwissNameDictionaryMetaTable(table);

TVARIABLE(Uint32T, nod, Uint32Constant(0))TVariable<Uint32T> nod(Uint32Constant(0), this);
MetaTableAccessFunction builder = [&](MetaTableAccessor& mta) {
  nod =
      mta.Load(meta_table,
               SwissNameDictionary::kMetaTableDeletedElementCountFieldIndex);
};

GenerateMetaTableAccess(this, capacity, builder);
return ChangeInt32ToIntPtr(nod.value());
15380}

15382void CodeStubAssembler::StoreSwissNameDictionaryEnumToEntryMapping(
  TNode<SwissNameDictionary> table, TNode<IntPtrT> capacity,
  TNode<IntPtrT> enum_index, TNode<Int32T> entry) {
TNode<ByteArray> meta_table = LoadSwissNameDictionaryMetaTable(table);
TNode<IntPtrT> meta_table_index = IntPtrAdd(
    IntPtrConstant(SwissNameDictionary::kMetaTableEnumerationDataStartIndex),
    enum_index);

MetaTableAccessFunction builder = [&](MetaTableAccessor& mta) {
  mta.Store(meta_table, meta_table_index, Unsigned(entry));
};

GenerateMetaTableAccess(this, capacity, builder);
15395}

15397TNode<Uint32T>
15398CodeStubAssembler::SwissNameDictionaryIncreaseElementCountOrBailout(
  TNode<ByteArray> meta_table, TNode<IntPtrT> capacity,
  TNode<Uint32T> max_usable_capacity, Label* bailout) {
TVARIABLE(Uint32T, used_var, Uint32Constant(0))TVariable<Uint32T> used_var(Uint32Constant(0), this);

MetaTableAccessFunction builder = [&](MetaTableAccessor& mta) {
  TNode<Uint32T> nof = mta.Load(
      meta_table, SwissNameDictionary::kMetaTableElementCountFieldIndex);
  TNode<Uint32T> nod =
      mta.Load(meta_table,
               SwissNameDictionary::kMetaTableDeletedElementCountFieldIndex);
  TNode<Uint32T> used = Uint32Add(nof, nod);
  GotoIf(Uint32GreaterThanOrEqual(used, max_usable_capacity), bailout);
  TNode<Uint32T> inc_nof = Uint32Add(nof, Uint32Constant(1));
  mta.Store(meta_table, SwissNameDictionary::kMetaTableElementCountFieldIndex,
            inc_nof);
  used_var = used;
};

GenerateMetaTableAccess(this, capacity, builder);
return used_var.value();
15419}

15421TNode<Uint32T> CodeStubAssembler::SwissNameDictionaryUpdateCountsForDeletion(
  TNode<ByteArray> meta_table, TNode<IntPtrT> capacity) {
TVARIABLE(Uint32T, new_nof_var, Uint32Constant(0))TVariable<Uint32T> new_nof_var(Uint32Constant(0), this);

MetaTableAccessFunction builder = [&](MetaTableAccessor& mta) {
  TNode<Uint32T> nof = mta.Load(
      meta_table, SwissNameDictionary::kMetaTableElementCountFieldIndex);
  TNode<Uint32T> nod =
      mta.Load(meta_table,
               SwissNameDictionary::kMetaTableDeletedElementCountFieldIndex);

  TNode<Uint32T> new_nof = Uint32Sub(nof, Uint32Constant(1));
  TNode<Uint32T> new_nod = Uint32Add(nod, Uint32Constant(1));

  mta.Store(meta_table, SwissNameDictionary::kMetaTableElementCountFieldIndex,
            new_nof);
  mta.Store(meta_table,
            SwissNameDictionary::kMetaTableDeletedElementCountFieldIndex,
            new_nod);

  new_nof_var = new_nof;
};

GenerateMetaTableAccess(this, capacity, builder);
return new_nof_var.value();
15446}

15448TNode<SwissNameDictionary> CodeStubAssembler::AllocateSwissNameDictionary(
  TNode<IntPtrT> at_least_space_for) {
// Note that as AllocateNameDictionary, we return a table with initial
// (non-zero) capacity even if |at_least_space_for| is 0.

TNode<IntPtrT> capacity =
    IntPtrMax(IntPtrConstant(SwissNameDictionary::kInitialCapacity),
              SwissNameDictionaryCapacityFor(at_least_space_for));

return AllocateSwissNameDictionaryWithCapacity(capacity);
15458}

15460TNode<SwissNameDictionary> CodeStubAssembler::AllocateSwissNameDictionary(
  int at_least_space_for) {
return AllocateSwissNameDictionary(IntPtrConstant(at_least_space_for));
15463}

15465TNode<SwissNameDictionary>
15466CodeStubAssembler::AllocateSwissNameDictionaryWithCapacity(
  TNode<IntPtrT> capacity) {
Comment("[ AllocateSwissNameDictionaryWithCapacity");
CSA_DCHECK(this, WordIsPowerOfTwo(capacity))((void)0);
CSA_DCHECK(this, UintPtrGreaterThanOrEqual(((void)0)
                     capacity,((void)0)
                     IntPtrConstant(SwissNameDictionary::kInitialCapacity)))((void)0);
CSA_DCHECK(this,((void)0)
           UintPtrLessThanOrEqual(((void)0)
               capacity, IntPtrConstant(SwissNameDictionary::MaxCapacity())))((void)0);

Comment("Size check.");
intptr_t capacity_constant;
if (ToParameterConstant(capacity, &capacity_constant)) {
  CHECK_LE(capacity_constant, SwissNameDictionary::MaxCapacity())do { bool _cmp = ::v8::base::CmpLEImpl< typename ::v8::base
::pass_value_or_ref<decltype(capacity_constant)>::type,
 typename ::v8::base::pass_value_or_ref<decltype(SwissNameDictionary
::MaxCapacity())>::type>((capacity_constant), (SwissNameDictionary
::MaxCapacity())); do { if ((__builtin_expect(!!(!(_cmp)), 0)
)) { V8_Fatal("Check failed: %s.", "capacity_constant" " " "<="
 " " "SwissNameDictionary::MaxCapacity()"); } } while (false)
; } while (false);
} else {
  Label if_out_of_memory(this, Label::kDeferred), next(this);
  Branch(UintPtrGreaterThan(
             capacity, IntPtrConstant(SwissNameDictionary::MaxCapacity())),
         &if_out_of_memory, &next);

  BIND(&if_out_of_memory)Bind(&if_out_of_memory);
  CallRuntime(Runtime::kFatalProcessOutOfMemoryInAllocateRaw,
              NoContextConstant());
  Unreachable();

  BIND(&next)Bind(&next);
}

// TODO(v8:11330) Consider adding dedicated handling for constant capacties,
// similar to AllocateOrderedHashTableWithCapacity.

// We must allocate the ByteArray first. Otherwise, allocating the ByteArray
// may trigger GC, which may try to verify the un-initialized
// SwissNameDictionary.
Comment("Meta table allocation.");
TNode<IntPtrT> meta_table_payload_size =
    SwissNameDictionaryMetaTableSizeFor(capacity);

TNode<ByteArray> meta_table =
    AllocateNonEmptyByteArray(Unsigned(meta_table_payload_size),
                              AllocationFlag::kAllowLargeObjectAllocation);

Comment("SwissNameDictionary allocation.");
TNode<IntPtrT> total_size = SwissNameDictionarySizeFor(capacity);

TNode<SwissNameDictionary> table = UncheckedCast<SwissNameDictionary>(
    Allocate(total_size, AllocationFlag::kAllowLargeObjectAllocation));

StoreMapNoWriteBarrier(table, RootIndex::kSwissNameDictionaryMap);

Comment(
    "Initialize the hash, capacity, meta table pointer, and number of "
    "(deleted) elements.");

StoreSwissNameDictionaryHash(table,
                             Uint32Constant(PropertyArray::kNoHashSentinel));
StoreSwissNameDictionaryCapacity(table, TruncateIntPtrToInt32(capacity));
StoreSwissNameDictionaryMetaTable(table, meta_table);

// Set present and deleted element count without doing branching needed for
// meta table access twice.
MetaTableAccessFunction builder = [&](MetaTableAccessor& mta) {
  mta.Store(meta_table, SwissNameDictionary::kMetaTableElementCountFieldIndex,
            Uint32Constant(0));
  mta.Store(meta_table,
            SwissNameDictionary::kMetaTableDeletedElementCountFieldIndex,
            Uint32Constant(0));
};
GenerateMetaTableAccess(this, capacity, builder);

Comment("Initialize the ctrl table.");

TNode<IntPtrT> ctrl_table_start_offset_minus_tag =
    SwissNameDictionaryCtrlTableStartOffsetMT(capacity);

TNode<IntPtrT> table_address_with_tag = BitcastTaggedToWord(table);
TNode<IntPtrT> ctrl_table_size_bytes =
    IntPtrAdd(capacity, IntPtrConstant(SwissNameDictionary::kGroupWidth));
TNode<IntPtrT> ctrl_table_start_ptr =
    IntPtrAdd(table_address_with_tag, ctrl_table_start_offset_minus_tag);
TNode<IntPtrT> ctrl_table_end_ptr =
    IntPtrAdd(ctrl_table_start_ptr, ctrl_table_size_bytes);

// |ctrl_table_size_bytes| (= capacity + kGroupWidth) is divisble by four:
STATIC_ASSERT(SwissNameDictionary::kGroupWidth % 4 == 0)static_assert(SwissNameDictionary::kGroupWidth % 4 == 0, "SwissNameDictionary::kGroupWidth % 4 == 0"
);
STATIC_ASSERT(SwissNameDictionary::kInitialCapacity % 4 == 0)static_assert(SwissNameDictionary::kInitialCapacity % 4 == 0,
 "SwissNameDictionary::kInitialCapacity % 4 == 0");

// TODO(v8:11330) For all capacities except 4, we know that
// |ctrl_table_size_bytes| is divisible by 8. Consider initializing the ctrl
// table with WordTs in those cases. Alternatively, always initialize as many
// bytes as possbible with WordT and then, if necessary, the remaining 4 bytes
// with Word32T.

constexpr uint8_t kEmpty = swiss_table::Ctrl::kEmpty;
constexpr uint32_t kEmpty32 =
    (kEmpty << 24) | (kEmpty << 16) | (kEmpty << 8) | kEmpty;
TNode<Int32T> empty32 = Int32Constant(kEmpty32);
BuildFastLoop<IntPtrT>(
    ctrl_table_start_ptr, ctrl_table_end_ptr,
    [=](TNode<IntPtrT> current) {
      UnsafeStoreNoWriteBarrier(MachineRepresentation::kWord32, current,
                                empty32);
    },
    sizeof(uint32_t), IndexAdvanceMode::kPost);

Comment("Initialize the data table.");

TNode<IntPtrT> data_table_start_offset_minus_tag =
    SwissNameDictionaryDataTableStartOffsetMT();
TNode<IntPtrT> data_table_ptr =
    IntPtrAdd(table_address_with_tag, data_table_start_offset_minus_tag);
TNode<IntPtrT> data_table_size = IntPtrMul(
    IntPtrConstant(SwissNameDictionary::kDataTableEntryCount * kTaggedSize),
    capacity);

StoreFieldsNoWriteBarrier(data_table_ptr,
                          IntPtrAdd(data_table_ptr, data_table_size),
                          TheHoleConstant());

Comment("AllocateSwissNameDictionaryWithCapacity ]");

return table;
15589}

15591TNode<SwissNameDictionary> CodeStubAssembler::CopySwissNameDictionary(
  TNode<SwissNameDictionary> original) {
Comment("[ CopySwissNameDictionary");

TNode<IntPtrT> capacity =
    Signed(ChangeUint32ToWord(LoadSwissNameDictionaryCapacity(original)));

// We must allocate the ByteArray first. Otherwise, allocating the ByteArray
// may trigger GC, which may try to verify the un-initialized
// SwissNameDictionary.
Comment("Meta table allocation.");
TNode<IntPtrT> meta_table_payload_size =
    SwissNameDictionaryMetaTableSizeFor(capacity);

TNode<ByteArray> meta_table =
    AllocateNonEmptyByteArray(Unsigned(meta_table_payload_size),
                              AllocationFlag::kAllowLargeObjectAllocation);

Comment("SwissNameDictionary allocation.");
TNode<IntPtrT> total_size = SwissNameDictionarySizeFor(capacity);

TNode<SwissNameDictionary> table = UncheckedCast<SwissNameDictionary>(
    Allocate(total_size, AllocationFlag::kAllowLargeObjectAllocation));

StoreMapNoWriteBarrier(table, RootIndex::kSwissNameDictionaryMap);

Comment("Copy the hash and capacity.");

StoreSwissNameDictionaryHash(table, LoadSwissNameDictionaryHash(original));
StoreSwissNameDictionaryCapacity(table, TruncateIntPtrToInt32(capacity));
StoreSwissNameDictionaryMetaTable(table, meta_table);
// Not setting up number of (deleted elements), copying whole meta table
// instead.

TNode<ExternalReference> memcpy =
    ExternalConstant(ExternalReference::libc_memcpy_function());

TNode<IntPtrT> old_table_address_with_tag = BitcastTaggedToWord(original);
TNode<IntPtrT> new_table_address_with_tag = BitcastTaggedToWord(table);

TNode<IntPtrT> ctrl_table_start_offset_minus_tag =
    SwissNameDictionaryCtrlTableStartOffsetMT(capacity);

TNode<IntPtrT> ctrl_table_size_bytes =
    IntPtrAdd(capacity, IntPtrConstant(SwissNameDictionary::kGroupWidth));

Comment("Copy the ctrl table.");
{
  TNode<IntPtrT> old_ctrl_table_start_ptr = IntPtrAdd(
      old_table_address_with_tag, ctrl_table_start_offset_minus_tag);
  TNode<IntPtrT> new_ctrl_table_start_ptr = IntPtrAdd(
      new_table_address_with_tag, ctrl_table_start_offset_minus_tag);

  CallCFunction(
      memcpy, MachineType::Pointer(),
      std::make_pair(MachineType::Pointer(), new_ctrl_table_start_ptr),
      std::make_pair(MachineType::Pointer(), old_ctrl_table_start_ptr),
      std::make_pair(MachineType::UintPtr(), ctrl_table_size_bytes));
}

Comment("Copy the data table.");
{
  TNode<IntPtrT> start_offset =
      IntPtrConstant(SwissNameDictionary::DataTableStartOffset());
  TNode<IntPtrT> data_table_size = IntPtrMul(
      IntPtrConstant(SwissNameDictionary::kDataTableEntryCount * kTaggedSize),
      capacity);

  BuildFastLoop<IntPtrT>(
      start_offset, IntPtrAdd(start_offset, data_table_size),
      [=](TNode<IntPtrT> offset) {
        TNode<Object> table_field = LoadObjectField(original, offset);
        StoreObjectField(table, offset, table_field);
      },
      kTaggedSize, IndexAdvanceMode::kPost);
}

Comment("Copy the meta table");
{
  TNode<IntPtrT> old_meta_table_address_with_tag =
      BitcastTaggedToWord(LoadSwissNameDictionaryMetaTable(original));
  TNode<IntPtrT> new_meta_table_address_with_tag =
      BitcastTaggedToWord(meta_table);

  TNode<IntPtrT> meta_table_size =
      SwissNameDictionaryMetaTableSizeFor(capacity);

  TNode<IntPtrT> old_data_start =
      IntPtrAdd(old_meta_table_address_with_tag,
                IntPtrConstant(ByteArray::kHeaderSize - kHeapObjectTag));
  TNode<IntPtrT> new_data_start =
      IntPtrAdd(new_meta_table_address_with_tag,
                IntPtrConstant(ByteArray::kHeaderSize - kHeapObjectTag));

  CallCFunction(memcpy, MachineType::Pointer(),
                std::make_pair(MachineType::Pointer(), new_data_start),
                std::make_pair(MachineType::Pointer(), old_data_start),
                std::make_pair(MachineType::UintPtr(), meta_table_size));
}

Comment("Copy the PropertyDetails table");
{
  TNode<IntPtrT> property_details_start_offset_minus_tag =
      SwissNameDictionaryOffsetIntoPropertyDetailsTableMT(table, capacity,
                                                          IntPtrConstant(0));

  // Offset to property details entry
  TVARIABLE(IntPtrT, details_table_offset_minus_tag,TVariable<IntPtrT> details_table_offset_minus_tag(property_details_start_offset_minus_tag
, this)
            property_details_start_offset_minus_tag)TVariable<IntPtrT> details_table_offset_minus_tag(property_details_start_offset_minus_tag
, this);

  TNode<IntPtrT> start = ctrl_table_start_offset_minus_tag;

  VariableList in_loop_variables({&details_table_offset_minus_tag}, zone());
  BuildFastLoop<IntPtrT>(
      in_loop_variables, start, IntPtrAdd(start, ctrl_table_size_bytes),
      [&](TNode<IntPtrT> ctrl_table_offset) {
        TNode<Uint8T> ctrl = Load<Uint8T>(original, ctrl_table_offset);

        // TODO(v8:11330) Entries in the PropertyDetails table may be
        // uninitialized if the corresponding buckets in the data/ctrl table
        // are empty. Therefore, to avoid accessing un-initialized memory
        // here, we need to check the ctrl table to determine whether we
        // should copy a certain PropertyDetails entry or not.
        // TODO(v8:11330) If this function becomes performance-critical, we
        // may consider always initializing the PropertyDetails table entirely
        // during allocation, to avoid the branching during copying.
        Label done(this);
        // |kNotFullMask| catches kEmpty and kDeleted, both of which indicate
        // entries that we don't want to copy the PropertyDetails for.
        GotoIf(IsSetWord32(ctrl, swiss_table::kNotFullMask), &done);

        TNode<Uint8T> details =
            Load<Uint8T>(original, details_table_offset_minus_tag.value());

        StoreToObject(MachineRepresentation::kWord8, table,
                      details_table_offset_minus_tag.value(), details,
                      StoreToObjectWriteBarrier::kNone);
        Goto(&done);
        BIND(&done)Bind(&done);

        details_table_offset_minus_tag =
            IntPtrAdd(details_table_offset_minus_tag.value(),
                      IntPtrConstant(kOneByteSize));
      },
      kOneByteSize, IndexAdvanceMode::kPost);
}

Comment("CopySwissNameDictionary ]");

return table;
15741}

15743TNode<IntPtrT> CodeStubAssembler::SwissNameDictionaryOffsetIntoDataTableMT(
  TNode<SwissNameDictionary> dict, TNode<IntPtrT> index, int field_index) {
TNode<IntPtrT> data_table_start = SwissNameDictionaryDataTableStartOffsetMT();

TNode<IntPtrT> offset_within_data_table = IntPtrMul(
    index,
    IntPtrConstant(SwissNameDictionary::kDataTableEntryCount * kTaggedSize));

if (field_index != 0) {
  offset_within_data_table = IntPtrAdd(
      offset_within_data_table, IntPtrConstant(field_index * kTaggedSize));
}

return IntPtrAdd(data_table_start, offset_within_data_table);
15757}

15759TNode<IntPtrT>
15760CodeStubAssembler::SwissNameDictionaryOffsetIntoPropertyDetailsTableMT(
  TNode<SwissNameDictionary> dict, TNode<IntPtrT> capacity,
  TNode<IntPtrT> index) {
CSA_DCHECK(this,((void)0)
           WordEqual(capacity, ChangeUint32ToWord(((void)0)
                                   LoadSwissNameDictionaryCapacity(dict))))((void)0);

TNode<IntPtrT> data_table_start = SwissNameDictionaryDataTableStartOffsetMT();

TNode<IntPtrT> gw = IntPtrConstant(SwissNameDictionary::kGroupWidth);
TNode<IntPtrT> data_and_ctrl_table_size = IntPtrAdd(
    IntPtrMul(capacity,
              IntPtrConstant(kOneByteSize +
                             SwissNameDictionary::kDataTableEntryCount *
                                 kTaggedSize)),
    gw);

TNode<IntPtrT> property_details_table_start =
    IntPtrAdd(data_table_start, data_and_ctrl_table_size);

CSA_DCHECK(((void)0)
    this,((void)0)
    WordEqual(FieldSliceSwissNameDictionaryPropertyDetailsTable(dict).offset,((void)0)
              // Our calculation subtracted the tag, Torque's offset didn't.((void)0)
              IntPtrAdd(property_details_table_start,((void)0)
                        IntPtrConstant(kHeapObjectTag))))((void)0);

TNode<IntPtrT> offset_within_details_table = index;
return IntPtrAdd(property_details_table_start, offset_within_details_table);
15789}

15791void CodeStubAssembler::StoreSwissNameDictionaryCapacity(
  TNode<SwissNameDictionary> table, TNode<Int32T> capacity) {
StoreObjectFieldNoWriteBarrier<Word32T>(
    table, SwissNameDictionary::CapacityOffset(), capacity);
15795}

15797TNode<Name> CodeStubAssembler::LoadSwissNameDictionaryKey(
  TNode<SwissNameDictionary> dict, TNode<IntPtrT> entry) {
TNode<IntPtrT> offset_minus_tag = SwissNameDictionaryOffsetIntoDataTableMT(
    dict, entry, SwissNameDictionary::kDataTableKeyEntryIndex);

// TODO(v8:11330) Consider using LoadObjectField here.
return CAST(Load<Object>(dict, offset_minus_tag))Cast(Load<Object>(dict, offset_minus_tag));
15804}

15806TNode<Uint8T> CodeStubAssembler::LoadSwissNameDictionaryPropertyDetails(
  TNode<SwissNameDictionary> table, TNode<IntPtrT> capacity,
  TNode<IntPtrT> entry) {
TNode<IntPtrT> offset_minus_tag =
    SwissNameDictionaryOffsetIntoPropertyDetailsTableMT(table, capacity,
                                                        entry);
// TODO(v8:11330) Consider using LoadObjectField here.
return Load<Uint8T>(table, offset_minus_tag);
15814}

15816void CodeStubAssembler::StoreSwissNameDictionaryPropertyDetails(
  TNode<SwissNameDictionary> table, TNode<IntPtrT> capacity,
  TNode<IntPtrT> entry, TNode<Uint8T> details) {
TNode<IntPtrT> offset_minus_tag =
    SwissNameDictionaryOffsetIntoPropertyDetailsTableMT(table, capacity,
                                                        entry);

// TODO(v8:11330) Consider using StoreObjectField here.
StoreToObject(MachineRepresentation::kWord8, table, offset_minus_tag, details,
              StoreToObjectWriteBarrier::kNone);
15826}

15828void CodeStubAssembler::StoreSwissNameDictionaryKeyAndValue(
  TNode<SwissNameDictionary> dict, TNode<IntPtrT> entry, TNode<Object> key,
  TNode<Object> value) {
STATIC_ASSERT(SwissNameDictionary::kDataTableKeyEntryIndex == 0)static_assert(SwissNameDictionary::kDataTableKeyEntryIndex ==
 0, "SwissNameDictionary::kDataTableKeyEntryIndex == 0");
STATIC_ASSERT(SwissNameDictionary::kDataTableValueEntryIndex == 1)static_assert(SwissNameDictionary::kDataTableValueEntryIndex ==
 1, "SwissNameDictionary::kDataTableValueEntryIndex == 1");

// TODO(v8:11330) Consider using StoreObjectField here.
TNode<IntPtrT> key_offset_minus_tag =
    SwissNameDictionaryOffsetIntoDataTableMT(
        dict, entry, SwissNameDictionary::kDataTableKeyEntryIndex);
StoreToObject(MachineRepresentation::kTagged, dict, key_offset_minus_tag, key,
              StoreToObjectWriteBarrier::kFull);

TNode<IntPtrT> value_offset_minus_tag =
    IntPtrAdd(key_offset_minus_tag, IntPtrConstant(kTaggedSize));
StoreToObject(MachineRepresentation::kTagged, dict, value_offset_minus_tag,
              value, StoreToObjectWriteBarrier::kFull);
15845}

15847TNode<Uint64T> CodeStubAssembler::LoadSwissNameDictionaryCtrlTableGroup(
  TNode<IntPtrT> address) {
TNode<RawPtrT> ptr = ReinterpretCast<RawPtrT>(address);
TNode<Uint64T> data = UnalignedLoad<Uint64T>(ptr, IntPtrConstant(0));

15852#ifdef V8_TARGET_LITTLE_ENDIAN1
return data;
15854#else
// Reverse byte order.
// TODO(v8:11330) Doing this without using dedicated instructions (which we
// don't have access to here) will destroy any performance benefit Swiss
// Tables have. So we just support this so that we don't have to disable the
// test suite for SwissNameDictionary on big endian platforms.

TNode<Uint64T> result = Uint64Constant(0);
constexpr int count = sizeof(uint64_t);
for (int i = 0; i < count; ++i) {
  int src_offset = i * 8;
  int dest_offset = (count - i - 1) * 8;

  TNode<Uint64T> mask = Uint64Constant(0xffULL << src_offset);
  TNode<Uint64T> src_data = Word64And(data, mask);

  TNode<Uint64T> shifted =
      src_offset < dest_offset
          ? Word64Shl(src_data, Uint64Constant(dest_offset - src_offset))
          : Word64Shr(src_data, Uint64Constant(src_offset - dest_offset));
  result = Unsigned(Word64Or(result, shifted));
}
return result;
15877#endif
15878}

15880void CodeStubAssembler::SwissNameDictionarySetCtrl(
  TNode<SwissNameDictionary> table, TNode<IntPtrT> capacity,
  TNode<IntPtrT> entry, TNode<Uint8T> ctrl) {
CSA_DCHECK(this,((void)0)
           WordEqual(capacity, ChangeUint32ToWord(((void)0)
                                   LoadSwissNameDictionaryCapacity(table))))((void)0);
CSA_DCHECK(this, UintPtrLessThan(entry, capacity))((void)0);

TNode<IntPtrT> one = IntPtrConstant(1);
TNode<IntPtrT> offset = SwissNameDictionaryCtrlTableStartOffsetMT(capacity);

CSA_DCHECK(this,((void)0)
           WordEqual(FieldSliceSwissNameDictionaryCtrlTable(table).offset,((void)0)
                     IntPtrAdd(offset, one)))((void)0);

TNode<IntPtrT> offset_entry = IntPtrAdd(offset, entry);
StoreToObject(MachineRepresentation::kWord8, table, offset_entry, ctrl,
              StoreToObjectWriteBarrier::kNone);

TNode<IntPtrT> mask = IntPtrSub(capacity, one);
TNode<IntPtrT> group_width = IntPtrConstant(SwissNameDictionary::kGroupWidth);

// See SwissNameDictionary::SetCtrl for description of what's going on here.

// ((entry - Group::kWidth) & mask) + 1
TNode<IntPtrT> copy_entry_lhs =
    IntPtrAdd(WordAnd(IntPtrSub(entry, group_width), mask), one);
// ((Group::kWidth - 1) & mask)
TNode<IntPtrT> copy_entry_rhs = WordAnd(IntPtrSub(group_width, one), mask);
TNode<IntPtrT> copy_entry = IntPtrAdd(copy_entry_lhs, copy_entry_rhs);
TNode<IntPtrT> offset_copy_entry = IntPtrAdd(offset, copy_entry);

// |entry| < |kGroupWidth| implies |copy_entry| == |capacity| + |entry|
CSA_DCHECK(this, Word32Or(UintPtrGreaterThanOrEqual(entry, group_width),((void)0)
                          WordEqual(copy_entry, IntPtrAdd(capacity, entry))))((void)0);

// |entry| >= |kGroupWidth| implies |copy_entry| == |entry|
CSA_DCHECK(this, Word32Or(UintPtrLessThan(entry, group_width),((void)0)
                          WordEqual(copy_entry, entry)))((void)0);

// TODO(v8:11330): consider using StoreObjectFieldNoWriteBarrier here.
StoreToObject(MachineRepresentation::kWord8, table, offset_copy_entry, ctrl,
              StoreToObjectWriteBarrier::kNone);
15923}

15925void CodeStubAssembler::SwissNameDictionaryFindEntry(
  TNode<SwissNameDictionary> table, TNode<Name> key, Label* found,
  TVariable<IntPtrT>* var_found_entry, Label* not_found) {
if (SwissNameDictionary::kUseSIMD) {
  SwissNameDictionaryFindEntrySIMD(table, key, found, var_found_entry,
                                   not_found);
} else {
  SwissNameDictionaryFindEntryPortable(table, key, found, var_found_entry,
                                       not_found);
}
15935}

15937void CodeStubAssembler::SwissNameDictionaryAdd(TNode<SwissNameDictionary> table,
                                             TNode<Name> key,
                                             TNode<Object> value,
                                             TNode<Uint8T> property_details,
                                             Label* needs_resize) {
if (SwissNameDictionary::kUseSIMD) {
  SwissNameDictionaryAddSIMD(table, key, value, property_details,
                             needs_resize);
} else {
  SwissNameDictionaryAddPortable(table, key, value, property_details,
                                 needs_resize);
}
15949}

15951void CodeStubAssembler::SharedValueBarrier(
  TNode<Context> context, TVariable<Object>* var_shared_value) {
// The barrier ensures that the value can be shared across Isolates.
// The fast paths should be kept in sync with Object::Share.

TNode<Object> value = var_shared_value->value();
Label check_in_shared_heap(this), slow(this), skip_barrier(this), done(this);

// Fast path: Smis are trivially shared.
GotoIf(TaggedIsSmi(value), &done);
// Fast path: Shared memory features imply shared RO space, so RO objects are
// trivially shared.
CSA_DCHECK(this, BoolConstant(ReadOnlyHeap::IsReadOnlySpaceShared()))((void)0);
TNode<IntPtrT> page_flags = LoadBasicMemoryChunkFlags(CAST(value)Cast(value));
GotoIf(WordNotEqual(WordAnd(page_flags,
                            IntPtrConstant(BasicMemoryChunk::READ_ONLY_HEAP)),
                    IntPtrConstant(0)),
       &skip_barrier);

// Fast path: Check if the HeapObject is already shared.
TNode<Uint16T> value_instance_type =
    LoadMapInstanceType(LoadMap(CAST(value)Cast(value)));
GotoIf(IsSharedStringInstanceType(value_instance_type), &skip_barrier);
GotoIf(IsJSSharedStructInstanceType(value_instance_type), &skip_barrier);
GotoIf(IsHeapNumberInstanceType(value_instance_type), &check_in_shared_heap);
Goto(&slow);

BIND(&check_in_shared_heap)Bind(&check_in_shared_heap);
{
  Branch(
      WordNotEqual(WordAnd(page_flags,
                           IntPtrConstant(BasicMemoryChunk::IN_SHARED_HEAP)),
                   IntPtrConstant(0)),
      &skip_barrier, &slow);
}

// Slow path: Call out to runtime to share primitives and to throw on
// non-shared JS objects.
BIND(&slow)Bind(&slow);
{
  *var_shared_value =
      CallRuntime(Runtime::kSharedValueBarrierSlow, context, value);
  Goto(&skip_barrier);
}

BIND(&skip_barrier)Bind(&skip_barrier);
{
  CSA_DCHECK(((void)0)
      this,((void)0)
      WordNotEqual(((void)0)
          WordAnd(LoadBasicMemoryChunkFlags(CAST(var_shared_value->value())),((void)0)
                  IntPtrConstant(BasicMemoryChunk::READ_ONLY_HEAP |((void)0)
                                 BasicMemoryChunk::IN_SHARED_HEAP)),((void)0)
          IntPtrConstant(0)))((void)0);
  Goto(&done);
}

BIND(&done)Bind(&done);
16009}

16011}  // namespace internal
16012}  // namespace v8

←

../deps/v8/src/base/bit-field.h

1// Copyright 2019 the V8 project authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4 
5#ifndef V8_BASE_BIT_FIELD_H_
6#define V8_BASE_BIT_FIELD_H_
7 
8#include <stdint.h>
9 
10#include "src/base/macros.h"
11 
12namespace v8 {
13namespace base {
14 
15// ----------------------------------------------------------------------------
16// BitField is a help template for encoding and decode bitfield with
17// unsigned content.
18// Instantiate them via 'using', which is cheaper than deriving a new class:
19// using MyBitField = base::BitField<MyEnum, 4, 2>;
20// The BitField class is final to enforce this style over derivation.
21 
22template <class T, int shift, int size, class U = uint32_t>
23class BitField final {
24 public:
25  STATIC_ASSERT(std::is_unsigned<U>::value)static_assert(std::is_unsigned<U>::value, "std::is_unsigned<U>::value"
);
26  STATIC_ASSERT(shift < 8 * sizeof(U))static_assert(shift < 8 * sizeof(U), "shift < 8 * sizeof(U)"
);  // Otherwise shifts by {shift} are UB.
27  STATIC_ASSERT(size < 8 * sizeof(U))static_assert(size < 8 * sizeof(U), "size < 8 * sizeof(U)"
);   // Otherwise shifts by {size} are UB.
28  STATIC_ASSERT(shift + size <= 8 * sizeof(U))static_assert(shift + size <= 8 * sizeof(U), "shift + size <= 8 * sizeof(U)"
);
29  STATIC_ASSERT(size > 0)static_assert(size > 0, "size > 0");
30 
31  using FieldType = T;
32 
33  // A type U mask of bit field.  To use all bits of a type U of x bits
34  // in a bitfield without compiler warnings we have to compute 2^x
35  // without using a shift count of x in the computation.
36  static constexpr int kShift = shift;
37  static constexpr int kSize = size;
38  static constexpr U kMask = ((U{1} << kShift) << kSize) - (U{1} << kShift);
39  static constexpr int kLastUsedBit = kShift + kSize - 1;
40  static constexpr U kNumValues = U{1} << kSize;
41 
42  // Value for the field with all bits set.
43  static constexpr T kMax = static_cast<T>(kNumValues - 1);
44 
45  template <class T2, int size2>
46  using Next = BitField<T2, kShift + kSize, size2, U>;
47 
48  // Tells whether the provided value fits into the bit field.
49  static constexpr bool is_valid(T value) {
50    return (static_cast<U>(value) & ~static_cast<U>(kMax)) == 0;
51  }
52 
53  // Returns a type U with the bit field value encoded.
54  static constexpr U encode(T value) {
55    DCHECK(is_valid(value))((void) 0);
56    return static_cast<U>(value) << kShift;
14
←
The result of the '<<' expression is undefined
57  }
58 
59  // Returns a type U with the bit field value updated.
60  static constexpr U update(U previous, T value) {
61    return (previous & ~kMask) | encode(value);
62  }
63 
64  // Extracts the bit field from the value.
65  static constexpr T decode(U value) {
66    return static_cast<T>((value & kMask) >> kShift);
67  }
68};
69 
70template <class T, int shift, int size>
71using BitField8 = BitField<T, shift, size, uint8_t>;
72 
73template <class T, int shift, int size>
74using BitField16 = BitField<T, shift, size, uint16_t>;
75 
76template <class T, int shift, int size>
77using BitField64 = BitField<T, shift, size, uint64_t>;
78 
79// Helper macros for defining a contiguous sequence of bit fields. Example:
80// (backslashes at the ends of respective lines of this multi-line macro
81// definition are omitted here to please the compiler)
82//
83// #define MAP_BIT_FIELD1(V, _)
84//   V(IsAbcBit, bool, 1, _)
85//   V(IsBcdBit, bool, 1, _)
86//   V(CdeBits, int, 5, _)
87//   V(DefBits, MutableMode, 1, _)
88//
89// DEFINE_BIT_FIELDS(MAP_BIT_FIELD1)
90// or
91// DEFINE_BIT_FIELDS_64(MAP_BIT_FIELD1)
92//
93#define DEFINE_BIT_FIELD_RANGE_TYPE(Name, Type, Size, _)kNameStart, kNameEnd = kNameStart + Size - 1, \
94  k##Name##Start, k##Name##End = k##Name##Start + Size - 1,
95 
96#define DEFINE_BIT_RANGES(LIST_MACRO)struct LIST_MACRO_Ranges { enum { LIST_MACRO(DEFINE_BIT_FIELD_RANGE_TYPE
, _) kBitsCount }; };                               \
97  struct LIST_MACRO##_Ranges {                                      \
98    enum { LIST_MACRO(DEFINE_BIT_FIELD_RANGE_TYPE, _) kBitsCount }; \
99  };
100 
101#define DEFINE_BIT_FIELD_TYPE(Name, Type, Size, RangesName)using Name = base::BitField<Type, RangesName::kNameStart, Size
>; \
102  using Name = base::BitField<Type, RangesName::k##Name##Start, Size>;
103 
104#define DEFINE_BIT_FIELD_64_TYPE(Name, Type, Size, RangesName)using Name = base::BitField64<Type, RangesName::kNameStart
, Size>; \
105  using Name = base::BitField64<Type, RangesName::k##Name##Start, Size>;
106 
107#define DEFINE_BIT_FIELDS(LIST_MACRO)struct LIST_MACRO_Ranges { enum { LIST_MACRO(DEFINE_BIT_FIELD_RANGE_TYPE
, _) kBitsCount }; }; LIST_MACRO(DEFINE_BIT_FIELD_TYPE, LIST_MACRO_Ranges
) \
108  DEFINE_BIT_RANGES(LIST_MACRO)struct LIST_MACRO_Ranges { enum { LIST_MACRO(DEFINE_BIT_FIELD_RANGE_TYPE
, _) kBitsCount }; };       \
109  LIST_MACRO(DEFINE_BIT_FIELD_TYPE, LIST_MACRO##_Ranges)
110 
111#define DEFINE_BIT_FIELDS_64(LIST_MACRO)struct LIST_MACRO_Ranges { enum { LIST_MACRO(DEFINE_BIT_FIELD_RANGE_TYPE
, _) kBitsCount }; }; LIST_MACRO(DEFINE_BIT_FIELD_64_TYPE, LIST_MACRO_Ranges
) \
112  DEFINE_BIT_RANGES(LIST_MACRO)struct LIST_MACRO_Ranges { enum { LIST_MACRO(DEFINE_BIT_FIELD_RANGE_TYPE
, _) kBitsCount }; };          \
113  LIST_MACRO(DEFINE_BIT_FIELD_64_TYPE, LIST_MACRO##_Ranges)
114 
115// ----------------------------------------------------------------------------
116// BitSetComputer is a help template for encoding and decoding information for
117// a variable number of items in an array.
118//
119// To encode boolean data in a smi array you would use:
120//  using BoolComputer = BitSetComputer<bool, 1, kSmiValueSize, uint32_t>;
121//
122template <class T, int kBitsPerItem, int kBitsPerWord, class U>
123class BitSetComputer {
124 public:
125  static const int kItemsPerWord = kBitsPerWord / kBitsPerItem;
126  static const int kMask = (1 << kBitsPerItem) - 1;
127 
128  // The number of array elements required to embed T information for each item.
129  static int word_count(int items) {
130    if (items == 0) return 0;
131    return (items - 1) / kItemsPerWord + 1;
132  }
133 
134  // The array index to look at for item.
135  static int index(int base_index, int item) {
136    return base_index + item / kItemsPerWord;
137  }
138 
139  // Extract T data for a given item from data.
140  static T decode(U data, int item) {
141    return static_cast<T>((data >> shift(item)) & kMask);
142  }
143 
144  // Return the encoding for a store of value for item in previous.
145  static U encode(U previous, int item, T value) {
146    int shift_value = shift(item);
147    int set_bits = (static_cast<int>(value) << shift_value);
148    return (previous & ~(kMask << shift_value)) | set_bits;
149  }
150 
151  static int shift(int item) { return (item % kItemsPerWord) * kBitsPerItem; }
152};
153 
154}  // namespace base
155}  // namespace v8
156 
157#endif  // V8_BASE_BIT_FIELD_H_