Lines Matching refs:Node
25 using compiler::Node;
77 Node* InterpreterAssembler::GetInterpretedFramePointer() {
88 Node* InterpreterAssembler::BytecodeOffset() {
97 Node* InterpreterAssembler::ReloadBytecodeOffset() {
98 Node* offset = LoadAndUntagRegister(Register::bytecode_offset());
108 Node* offset = BytecodeOffset();
117 Node* InterpreterAssembler::BytecodeArrayTaggedPointer() {
127 Node* InterpreterAssembler::DispatchTableRawPointer() {
137 Node* InterpreterAssembler::GetAccumulatorUnchecked() {
141 Node* InterpreterAssembler::GetAccumulator() {
147 void InterpreterAssembler::SetAccumulator(Node* value) {
153 Node* InterpreterAssembler::GetContext() {
157 void InterpreterAssembler::SetContext(Node* value) {
161 Node* InterpreterAssembler::GetContextAtDepth(Node* context, Node* depth) {
191 void InterpreterAssembler::GotoIfHasContextExtensionUpToDepth(Node* context,
192 Node* depth,
211 Node* extension_slot =
226 Node* InterpreterAssembler::RegisterLocation(Node* reg_index) {
231 Node* InterpreterAssembler::RegisterLocation(Register reg) {
235 Node* InterpreterAssembler::RegisterFrameOffset(Node* index) {
239 Node* InterpreterAssembler::LoadRegister(Node* reg_index) {
244 Node* InterpreterAssembler::LoadRegister(Register reg) {
249 Node* InterpreterAssembler::LoadAndUntagRegister(Register reg) {
254 Node* InterpreterAssembler::LoadRegisterAtOperandIndex(int operand_index) {
259 std::pair<Node*, Node*> InterpreterAssembler::LoadRegisterPairAtOperandIndex(
263 Node* first_reg_index =
265 Node* second_reg_index = NextRegister(first_reg_index);
276 Node* base_reg = RegisterLocation(
278 Node* reg_count = BytecodeOperandCount(operand_index + 1);
282 Node* InterpreterAssembler::LoadRegisterFromRegisterList(
284 Node* location = RegisterLocationInRegisterList(reg_list, index);
289 Node* InterpreterAssembler::RegisterLocationInRegisterList(
293 Node* offset = RegisterFrameOffset(IntPtrConstant(index));
299 void InterpreterAssembler::StoreRegister(Node* value, Register reg) {
305 void InterpreterAssembler::StoreRegister(Node* value, Node* reg_index) {
311 void InterpreterAssembler::StoreAndTagRegister(Node* value, Register reg) {
316 void InterpreterAssembler::StoreRegisterAtOperandIndex(Node* value,
322 void InterpreterAssembler::StoreRegisterPairAtOperandIndex(Node* value1,
323 Node* value2,
327 Node* first_reg_index =
330 Node* second_reg_index = NextRegister(first_reg_index);
335 Node* value1, Node* value2, Node* value3, int operand_index) {
338 Node* first_reg_index =
341 Node* second_reg_index = NextRegister(first_reg_index);
343 Node* third_reg_index = NextRegister(second_reg_index);
347 Node* InterpreterAssembler::NextRegister(Node* reg_index) {
352 Node* InterpreterAssembler::OperandOffset(int operand_index) {
357 Node* InterpreterAssembler::BytecodeOperandUnsignedByte(
362 Node* operand_offset = OperandOffset(operand_index);
367 Node* InterpreterAssembler::BytecodeOperandSignedByte(
372 Node* operand_offset = OperandOffset(operand_index);
377 Node* InterpreterAssembler::BytecodeOperandReadUnaligned(
411 Node* bytes[kMaxCount];
414 Node* offset = IntPtrConstant(relative_offset + msb_offset + i * kStep);
415 Node* array_offset = IntPtrAdd(BytecodeOffset(), offset);
421 Node* result = bytes[--count];
423 Node* shift = Int32Constant(i * kBitsPerByte);
424 Node* value = Word32Shl(bytes[count], shift);
430 Node* InterpreterAssembler::BytecodeOperandUnsignedShort(
448 Node* InterpreterAssembler::BytecodeOperandSignedShort(
466 Node* InterpreterAssembler::BytecodeOperandUnsignedQuad(
483 Node* InterpreterAssembler::BytecodeOperandSignedQuad(
500 Node* InterpreterAssembler::BytecodeSignedOperand(
518 Node* InterpreterAssembler::BytecodeUnsignedOperand(
536 Node* InterpreterAssembler::BytecodeOperandCount(int operand_index) {
544 Node* InterpreterAssembler::BytecodeOperandFlag(int operand_index) {
553 Node* InterpreterAssembler::BytecodeOperandUImm(int operand_index) {
561 Node* InterpreterAssembler::BytecodeOperandUImmWord(int operand_index) {
565 Node* InterpreterAssembler::BytecodeOperandUImmSmi(int operand_index) {
569 Node* InterpreterAssembler::BytecodeOperandImm(int operand_index) {
577 Node* InterpreterAssembler::BytecodeOperandImmIntPtr(int operand_index) {
581 Node* InterpreterAssembler::BytecodeOperandImmSmi(int operand_index) {
585 Node* InterpreterAssembler::BytecodeOperandIdxInt32(int operand_index) {
593 Node* InterpreterAssembler::BytecodeOperandIdx(int operand_index) {
597 Node* InterpreterAssembler::BytecodeOperandIdxSmi(int operand_index) {
601 Node* InterpreterAssembler::BytecodeOperandConstantPoolIdx(
611 Node* InterpreterAssembler::BytecodeOperandReg(
621 Node* InterpreterAssembler::BytecodeOperandRuntimeId(int operand_index) {
630 Node* InterpreterAssembler::BytecodeOperandNativeContextIndex(
640 Node* InterpreterAssembler::BytecodeOperandIntrinsicId(int operand_index) {
649 Node* InterpreterAssembler::LoadConstantPoolEntry(Node* index) {
656 Node* InterpreterAssembler::LoadAndUntagConstantPoolEntry(Node* index) {
660 Node* InterpreterAssembler::LoadConstantPoolEntryAtOperandIndex(
662 Node* index =
667 Node* InterpreterAssembler::LoadAndUntagConstantPoolEntryAtOperandIndex(
697 Node* stack_pointer_after_call = LoadStackPointer();
698 Node* stack_pointer_before_call = stack_pointer_before_call_;
705 void InterpreterAssembler::IncrementCallCount(Node* feedback_vector,
706 Node* slot_id) {
713 Node* new_count = SmiAdd(
720 void InterpreterAssembler::CollectCallableFeedback(Node* target, Node* context,
721 Node* feedback_vector,
722 Node* slot_id) {
734 Node* is_megamorphic = WordEqual(
743 Node* is_uninitialized = WordEqual(
767 Node* current = var_current.value();
769 Node* current_instance_type = LoadInstanceType(current);
779 Node* current_context =
781 Node* current_native_context = LoadNativeContext(current_context);
820 void InterpreterAssembler::CollectCallFeedback(Node* target, Node* context,
821 Node* feedback_vector,
822 Node* slot_id) {
831 Node* function, Node* context, const RegListNodePair& args,
838 Node* args_count;
844 Node* receiver_count = Int32Constant(1);
850 Node* code_target = HeapConstant(callable.code());
860 void InterpreterAssembler::CallJSAndDispatch(Node* function, Node* context,
861 Node* arg_count,
869 Node* code_target = HeapConstant(callable.code());
875 static_cast<Node*>(UndefinedConstant()), args...);
887 Node* function, Node* context, Node* arg_count,
890 Node* function, Node* context, Node* arg_count,
891 ConvertReceiverMode receiver_mode, Node*);
893 Node* function, Node* context, Node* arg_count,
894 ConvertReceiverMode receiver_mode, Node*, Node*);
896 Node* function, Node* context, Node* arg_count,
897 ConvertReceiverMode receiver_mode, Node*, Node*, Node*);
900 Node* function, Node* context, const RegListNodePair& args, Node* slot_id,
901 Node* feedback_vector) {
909 Node* code_target = HeapConstant(callable.code());
911 Node* receiver_count = Int32Constant(1);
912 Node* args_count = Int32Sub(args.reg_count(), receiver_count);
920 Node* InterpreterAssembler::Construct(Node* target, Node* context,
921 Node* new_target,
923 Node* slot_id, Node* feedback_vector) {
946 Node* is_megamorphic = WordEqual(
966 Node* array_function = LoadContextElement(LoadNativeContext(context),
978 Node* is_uninitialized =
995 Node* current = var_current.value();
997 Node* current_instance_type = LoadInstanceType(current);
1007 Node* current_context =
1009 Node* current_native_context = LoadNativeContext(current_context);
1028 Node* array_function = LoadContextElement(LoadNativeContext(context),
1075 Node* code_target = HeapConstant(callable.code());
1088 Node* code_target = HeapConstant(callable.code());
1099 Node* InterpreterAssembler::ConstructWithSpread(Node* target, Node* context,
1100 Node* new_target,
1102 Node* slot_id,
1103 Node* feedback_vector) {
1125 Node* is_megamorphic = WordEqual(
1141 Node* is_uninitialized =
1158 Node* current = var_current.value();
1160 Node* current_instance_type = LoadInstanceType(current);
1170 Node* current_context =
1172 Node* current_native_context = LoadNativeContext(current_context);
1213 Node* code_target = HeapConstant(callable.code());
1219 Node* InterpreterAssembler::CallRuntimeN(Node* function_id, Node* context,
1225 Node* code_target = HeapConstant(callable.code());
1228 Node* function_table = ExternalConstant(
1230 Node* function_offset =
1232 Node* function =
1234 Node* function_entry =
1242 void InterpreterAssembler::UpdateInterruptBudget(Node* weight, bool backward) {
1245 Node* budget_offset =
1254 Node* old_budget =
1257 Node* budget_after_bytecode =
1263 Node* condition =
1290 Node* InterpreterAssembler::Advance() { return Advance(CurrentBytecodeSize()); }
1292 Node* InterpreterAssembler::Advance(int delta) {
1296 Node* InterpreterAssembler::Advance(Node* delta, bool backward) {
1300 Node* next_offset = backward ? IntPtrSub(BytecodeOffset(), delta)
1306 Node* InterpreterAssembler::Jump(Node* delta, bool backward) {
1310 Node* new_bytecode_offset = Advance(delta, backward);
1311 Node* target_bytecode = LoadBytecode(new_bytecode_offset);
1315 Node* InterpreterAssembler::Jump(Node* delta) { return Jump(delta, false); }
1317 Node* InterpreterAssembler::JumpBackward(Node* delta) {
1321 void InterpreterAssembler::JumpConditional(Node* condition, Node* delta) {
1331 void InterpreterAssembler::JumpIfWordEqual(Node* lhs, Node* rhs, Node* delta) {
1335 void InterpreterAssembler::JumpIfWordNotEqual(Node* lhs, Node* rhs,
1336 Node* delta) {
1340 Node* InterpreterAssembler::LoadBytecode(Node* bytecode_offset) {
1341 Node* bytecode =
1346 Node* InterpreterAssembler::StarDispatchLookahead(Node* target_bytecode) {
1352 Node* star_bytecode = IntPtrConstant(static_cast<int>(Bytecode::kStar));
1353 Node* is_star = WordEqual(target_bytecode, star_bytecode);
1386 Node* InterpreterAssembler::Dispatch() {
1389 Node* target_offset = Advance();
1390 Node* target_bytecode = LoadBytecode(target_offset);
1398 Node* InterpreterAssembler::DispatchToBytecode(Node* target_bytecode,
1399 Node* new_bytecode_offset) {
1404 Node* target_code_entry =
1412 Node* InterpreterAssembler::DispatchToBytecodeHandler(Node* handler,
1413 Node* bytecode_offset,
1414 Node* target_bytecode) {
1416 Node* handler_entry =
1423 Node* InterpreterAssembler::DispatchToBytecodeHandlerEntry(
1424 Node* handler_entry, Node* bytecode_offset, Node* target_bytecode) {
1426 Node* poisoned_handler_entry = WordPoisonOnSpeculation(handler_entry);
1442 Node* next_bytecode_offset = Advance(1);
1443 Node* next_bytecode = LoadBytecode(next_bytecode_offset);
1449 Node* base_index;
1460 Node* target_index = IntPtrAdd(base_index, next_bytecode);
1461 Node* target_code_entry =
1489 Node* profiling_weight = Int32Sub(TruncateIntPtrToInt32(BytecodeOffset()),
1494 Node* InterpreterAssembler::LoadOSRNestingLevel() {
1502 Node* abort_id = SmiConstant(abort_reason);
1507 void InterpreterAssembler::AbortIfWordNotEqual(Node* lhs, Node* rhs,
1519 void InterpreterAssembler::MaybeDropFrames(Node* context) {
1520 Node* restart_fp_address =
1523 Node* restart_fp = Load(MachineType::Pointer(), restart_fp_address);
1524 Node* null = IntPtrConstant(0);
1544 void InterpreterAssembler::TraceBytecodeDispatch(Node* target_bytecode) {
1545 Node* counters_table = ExternalConstant(
1547 Node* source_bytecode_table_index = IntPtrConstant(
1550 Node* counter_offset =
1552 Node* old_counter =
1557 Node* counter_reached_max = WordEqual(
1563 Node* new_counter = IntPtrAdd(old_counter, IntPtrConstant(1));
1585 Node* parameters_and_registers, Node* formal_parameter_count,
1586 Node* register_count) {
1587 Node* array_size = LoadAndUntagFixedArrayBaseLength(parameters_and_registers);
1601 Node* InterpreterAssembler::ExportParametersAndRegisterFile(
1608 Node* register_count = ChangeUint32ToWord(registers.reg_count());
1623 Node* reg_base = IntPtrAdd(
1630 Node* index = var_index.value();
1634 Node* reg_index = IntPtrSub(reg_base, index);
1635 Node* value = LoadRegister(reg_index);
1656 Node* index = var_index.value();
1659 Node* reg_index =
1661 Node* value = LoadRegister(reg_index);
1663 Node* array_index = IntPtrAdd(formal_parameter_count_intptr, index);
1675 Node* InterpreterAssembler::ImportRegisterFile(
1723 Node* object = GetAccumulator();
1724 Node* context = GetContext();
1773 Node* slot_index = BytecodeOperandIdx(0);
1774 Node* feedback_vector = LoadFeedbackVector();
1782 Node* context = GetContext();
1783 Node* bytecode_offset = BytecodeOffset();
1784 Node* bytecode = LoadBytecode(bytecode_offset);
1786 Node* target_handler =
