switch (check_bounds) {

case CheckBounds::kAlways:

return true;

case CheckBounds::kDebugOnly:

return DEBUG_BOOL;

}

public:

#ifdef DEBUG

CheckedNode(Node* node, CodeAssembler* code_assembler, const char* location)

: node_(node), code_assembler_(code_assembler), location_(location) {}

#else

CheckedNode(compiler::Node* node, CodeAssembler*, const char*)

: node_(node) {}

#endif

template <class A>

operator TNode<A>() {

static_assert(

!std::is_same<A, MaybeObject>::value,

"Can't cast to MaybeObject, use explicit conversion functions. ");

static_assert(types_have_common_values<A, PreviousType>::value,

"Incompatible types: this cast can never succeed.");

static_assert(std::is_convertible<TNode<A>, TNode<MaybeObject>>::value ||

std::is_convertible<TNode<A>, TNode<Object>>::value,

"Coercion to untagged values cannot be "

"checked.");

static_assert(

!FromTyped ||

!std::is_convertible<TNode<PreviousType>, TNode<A>>::value,

"Unnecessary CAST: types are convertible.");

#ifdef DEBUG

if (v8_flags.debug_code) {

TNode<ExternalReference> function = code_assembler_->ExternalConstant(

ExternalReference::check_object_type());

code_assembler_->CallCFunction(

function, MachineType::AnyTagged(),

std::make_pair(MachineType::AnyTagged(), node_),

std::make_pair(MachineType::TaggedSigned(),

code_assembler_->SmiConstant(

static_cast<int>(ObjectTypeOf<A>::value))),

std::make_pair(MachineType::AnyTagged(),

code_assembler_->StringConstant(location_)));

}

#endif

return TNode<A>::UncheckedCast(node_);

}

Node* node() const { return node_; }

private:

Node* node_;

#ifdef DEBUG

CodeAssembler* code_assembler_;

const char* location_;

#endif

static_assert(types_have_common_values<T, U>::value,

"Incompatible types: this cast can never succeed.");

return TNode<T>::UncheckedCast(value);

int value, cppgc::SourceLocation loc = cppgc::SourceLocation::Current()) {

static_assert(

std::is_convertible<TNode<T>, TNode<Object>>::value,

"Parameter is only for tagged types. Use UncheckedParameter instead.");

std::stringstream message;

message << "Parameter " << value;

if (loc.FileName()) {

message << " at " << loc.FileName() << ":" << loc.Line();

}

size_t buf_size = message.str().size() + 1;

char* message_dup = zone()->AllocateArray<char>(buf_size);

snprintf(message_dup, buf_size, "%s", message.str().c_str());

return Cast(UntypedParameter(value), message_dup);

if (!v8_flags.code_comments) return;

std::ostringstream s;

USE((s << std::forward<Args>(args))...);

Comment(s.str());

CodeAssemblerParameterizedLabel<T...>* if_true,

CodeAssemblerParameterizedLabel<T...>* if_false, Args... args) {

if_true->AddInputs(args...);

if_false->AddInputs(args...);

Branch(condition, if_true->plain_label(), if_false->plain_label());

CodeAssemblerParameterizedLabel<T...>* if_true,

std::vector<Node*> args_true,

CodeAssemblerParameterizedLabel<U...>* if_false,

std::vector<Node*> args_false) {

if_true->AddInputsVector(std::move(args_true));

if_false->AddInputsVector(std::move(args_false));

Branch(condition, if_true->plain_label(), if_false->plain_label());

DCHECK(

IsSubtype(type.representation(), MachineRepresentationOf<Type>::value));

return UncheckedCast<Type>(Load(type, static_cast<Node*>(base)));

TNode<WordT> offset) {

return UncheckedCast<Type>(

AtomicLoad(MachineTypeOf<Type>::value, order, base, offset));