| // Copyright 2014 the V8 project authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "src/compiler/raw-machine-assembler.h" |
| |
| #include "src/base/small-vector.h" |
| #include "src/compiler/compiler-source-position-table.h" |
| #include "src/compiler/node-properties.h" |
| #include "src/compiler/pipeline.h" |
| #include "src/compiler/scheduler.h" |
| #include "src/heap/factory-inl.h" |
| |
| namespace v8 { |
| namespace internal { |
| namespace compiler { |
| |
| RawMachineAssembler::RawMachineAssembler( |
| Isolate* isolate, Graph* graph, CallDescriptor* call_descriptor, |
| MachineRepresentation word, MachineOperatorBuilder::Flags flags, |
| MachineOperatorBuilder::AlignmentRequirements alignment_requirements, |
| PoisoningMitigationLevel poisoning_level) |
| : isolate_(isolate), |
| graph_(graph), |
| schedule_(zone()->New<Schedule>(zone())), |
| source_positions_(zone()->New<SourcePositionTable>(graph)), |
| machine_(zone(), word, flags, alignment_requirements), |
| common_(zone()), |
| simplified_(zone()), |
| call_descriptor_(call_descriptor), |
| target_parameter_(nullptr), |
| parameters_(parameter_count(), zone()), |
| current_block_(schedule()->start()), |
| poisoning_level_(poisoning_level) { |
| int param_count = static_cast<int>(parameter_count()); |
| // Add an extra input for the JSFunction parameter to the start node. |
| graph->SetStart(graph->NewNode(common_.Start(param_count + 1))); |
| if (call_descriptor->IsJSFunctionCall()) { |
| target_parameter_ = AddNode( |
| common()->Parameter(Linkage::kJSCallClosureParamIndex), graph->start()); |
| } |
| for (size_t i = 0; i < parameter_count(); ++i) { |
| parameters_[i] = |
| AddNode(common()->Parameter(static_cast<int>(i)), graph->start()); |
| } |
| graph->SetEnd(graph->NewNode(common_.End(0))); |
| source_positions_->AddDecorator(); |
| } |
| |
| void RawMachineAssembler::SetCurrentExternalSourcePosition( |
| FileAndLine file_and_line) { |
| int file_id = |
| isolate()->LookupOrAddExternallyCompiledFilename(file_and_line.first); |
| SourcePosition p = SourcePosition::External(file_and_line.second, file_id); |
| DCHECK(p.ExternalLine() == file_and_line.second); |
| source_positions()->SetCurrentPosition(p); |
| } |
| |
| FileAndLine RawMachineAssembler::GetCurrentExternalSourcePosition() const { |
| SourcePosition p = source_positions_->GetCurrentPosition(); |
| if (!p.IsKnown()) return {nullptr, -1}; |
| int file_id = p.ExternalFileId(); |
| const char* file_name = isolate()->GetExternallyCompiledFilename(file_id); |
| int line = p.ExternalLine(); |
| return {file_name, line}; |
| } |
| |
| Node* RawMachineAssembler::NullConstant() { |
| return HeapConstant(isolate()->factory()->null_value()); |
| } |
| |
| Node* RawMachineAssembler::UndefinedConstant() { |
| return HeapConstant(isolate()->factory()->undefined_value()); |
| } |
| |
| Node* RawMachineAssembler::RelocatableIntPtrConstant(intptr_t value, |
| RelocInfo::Mode rmode) { |
| return kSystemPointerSize == 8 |
| ? RelocatableInt64Constant(value, rmode) |
| : RelocatableInt32Constant(static_cast<int>(value), rmode); |
| } |
| |
| Node* RawMachineAssembler::OptimizedAllocate( |
| Node* size, AllocationType allocation, |
| AllowLargeObjects allow_large_objects) { |
| return AddNode( |
| simplified()->AllocateRaw(Type::Any(), allocation, allow_large_objects), |
| size); |
| } |
| |
| Schedule* RawMachineAssembler::ExportForTest() { |
| // Compute the correct codegen order. |
| DCHECK(schedule_->rpo_order()->empty()); |
| if (FLAG_trace_turbo_scheduler) { |
| PrintF("--- RAW SCHEDULE -------------------------------------------\n"); |
| StdoutStream{} << *schedule_; |
| } |
| schedule_->EnsureCFGWellFormedness(); |
| Scheduler::ComputeSpecialRPO(zone(), schedule_); |
| schedule_->PropagateDeferredMark(); |
| if (FLAG_trace_turbo_scheduler) { |
| PrintF("--- EDGE SPLIT AND PROPAGATED DEFERRED SCHEDULE ------------\n"); |
| StdoutStream{} << *schedule_; |
| } |
| // Invalidate RawMachineAssembler. |
| source_positions_->RemoveDecorator(); |
| Schedule* schedule = schedule_; |
| schedule_ = nullptr; |
| return schedule; |
| } |
| |
| Graph* RawMachineAssembler::ExportForOptimization() { |
| // Compute the correct codegen order. |
| DCHECK(schedule_->rpo_order()->empty()); |
| if (FLAG_trace_turbo_scheduler) { |
| PrintF("--- RAW SCHEDULE -------------------------------------------\n"); |
| StdoutStream{} << *schedule_; |
| } |
| schedule_->EnsureCFGWellFormedness(); |
| OptimizeControlFlow(schedule_, graph(), common()); |
| Scheduler::ComputeSpecialRPO(zone(), schedule_); |
| if (FLAG_trace_turbo_scheduler) { |
| PrintF("--- SCHEDULE BEFORE GRAPH CREATION -------------------------\n"); |
| StdoutStream{} << *schedule_; |
| } |
| MakeReschedulable(); |
| // Invalidate RawMachineAssembler. |
| schedule_ = nullptr; |
| return graph(); |
| } |
| |
| void RawMachineAssembler::OptimizeControlFlow(Schedule* schedule, Graph* graph, |
| CommonOperatorBuilder* common) { |
| for (bool changed = true; changed;) { |
| changed = false; |
| for (size_t i = 0; i < schedule->all_blocks()->size(); ++i) { |
| BasicBlock* block = (*schedule->all_blocks())[i]; |
| if (block == nullptr) continue; |
| |
| // Short-circuit a goto if the succeeding block is not a control-flow |
| // merge. This is not really useful on it's own since graph construction |
| // has the same effect, but combining blocks improves the pattern-match on |
| // their structure below. |
| if (block->control() == BasicBlock::kGoto) { |
| DCHECK_EQ(block->SuccessorCount(), 1); |
| BasicBlock* successor = block->SuccessorAt(0); |
| if (successor->PredecessorCount() == 1) { |
| DCHECK_EQ(successor->PredecessorAt(0), block); |
| for (Node* node : *successor) { |
| schedule->SetBlockForNode(nullptr, node); |
| schedule->AddNode(block, node); |
| } |
| block->set_control(successor->control()); |
| Node* control_input = successor->control_input(); |
| block->set_control_input(control_input); |
| if (control_input) { |
| schedule->SetBlockForNode(block, control_input); |
| } |
| if (successor->deferred()) block->set_deferred(true); |
| block->ClearSuccessors(); |
| schedule->MoveSuccessors(successor, block); |
| schedule->ClearBlockById(successor->id()); |
| changed = true; |
| --i; |
| continue; |
| } |
| } |
| // Block-cloning in the simple case where a block consists only of a phi |
| // node and a branch on that phi. This just duplicates the branch block |
| // for each predecessor, replacing the phi node with the corresponding phi |
| // input. |
| if (block->control() == BasicBlock::kBranch && block->NodeCount() == 1) { |
| Node* phi = block->NodeAt(0); |
| if (phi->opcode() != IrOpcode::kPhi) continue; |
| Node* branch = block->control_input(); |
| DCHECK_EQ(branch->opcode(), IrOpcode::kBranch); |
| if (NodeProperties::GetValueInput(branch, 0) != phi) continue; |
| if (phi->UseCount() != 1) continue; |
| DCHECK_EQ(phi->op()->ValueInputCount(), block->PredecessorCount()); |
| |
| // Turn projection blocks into normal blocks. |
| DCHECK_EQ(block->SuccessorCount(), 2); |
| BasicBlock* true_block = block->SuccessorAt(0); |
| BasicBlock* false_block = block->SuccessorAt(1); |
| DCHECK_EQ(true_block->NodeAt(0)->opcode(), IrOpcode::kIfTrue); |
| DCHECK_EQ(false_block->NodeAt(0)->opcode(), IrOpcode::kIfFalse); |
| (*true_block->begin())->Kill(); |
| true_block->RemoveNode(true_block->begin()); |
| (*false_block->begin())->Kill(); |
| false_block->RemoveNode(false_block->begin()); |
| true_block->ClearPredecessors(); |
| false_block->ClearPredecessors(); |
| |
| size_t arity = block->PredecessorCount(); |
| for (size_t i = 0; i < arity; ++i) { |
| BasicBlock* predecessor = block->PredecessorAt(i); |
| predecessor->ClearSuccessors(); |
| if (block->deferred()) predecessor->set_deferred(true); |
| Node* branch_clone = graph->CloneNode(branch); |
| int phi_input = static_cast<int>(i); |
| NodeProperties::ReplaceValueInput( |
| branch_clone, NodeProperties::GetValueInput(phi, phi_input), 0); |
| BasicBlock* new_true_block = schedule->NewBasicBlock(); |
| BasicBlock* new_false_block = schedule->NewBasicBlock(); |
| new_true_block->AddNode( |
| graph->NewNode(common->IfTrue(), branch_clone)); |
| new_false_block->AddNode( |
| graph->NewNode(common->IfFalse(), branch_clone)); |
| schedule->AddGoto(new_true_block, true_block); |
| schedule->AddGoto(new_false_block, false_block); |
| DCHECK_EQ(predecessor->control(), BasicBlock::kGoto); |
| predecessor->set_control(BasicBlock::kNone); |
| schedule->AddBranch(predecessor, branch_clone, new_true_block, |
| new_false_block); |
| } |
| branch->Kill(); |
| schedule->ClearBlockById(block->id()); |
| changed = true; |
| continue; |
| } |
| } |
| } |
| } |
| |
| void RawMachineAssembler::MakeReschedulable() { |
| std::vector<Node*> block_final_control(schedule_->all_blocks_.size()); |
| std::vector<Node*> block_final_effect(schedule_->all_blocks_.size()); |
| |
| struct LoopHeader { |
| BasicBlock* block; |
| Node* loop_node; |
| Node* effect_phi; |
| }; |
| std::vector<LoopHeader> loop_headers; |
| |
| // These are hoisted outside of the loop to avoid re-allocation. |
| std::vector<Node*> merge_inputs; |
| std::vector<Node*> effect_phi_inputs; |
| |
| for (BasicBlock* block : *schedule_->rpo_order()) { |
| Node* current_control; |
| Node* current_effect; |
| if (block == schedule_->start()) { |
| current_control = current_effect = graph()->start(); |
| } else if (block == schedule_->end()) { |
| for (size_t i = 0; i < block->PredecessorCount(); ++i) { |
| NodeProperties::MergeControlToEnd( |
| graph(), common(), block->PredecessorAt(i)->control_input()); |
| } |
| } else if (block->IsLoopHeader()) { |
| // The graph()->start() inputs are just placeholders until we computed the |
| // real back-edges and re-structure the control flow so the loop has |
| // exactly two predecessors. |
| current_control = graph()->NewNode(common()->Loop(2), graph()->start(), |
| graph()->start()); |
| current_effect = |
| graph()->NewNode(common()->EffectPhi(2), graph()->start(), |
| graph()->start(), current_control); |
| |
| Node* terminate = graph()->NewNode(common()->Terminate(), current_effect, |
| current_control); |
| NodeProperties::MergeControlToEnd(graph(), common(), terminate); |
| loop_headers.push_back( |
| LoopHeader{block, current_control, current_effect}); |
| } else if (block->PredecessorCount() == 1) { |
| BasicBlock* predecessor = block->PredecessorAt(0); |
| DCHECK_LT(predecessor->rpo_number(), block->rpo_number()); |
| current_effect = block_final_effect[predecessor->id().ToSize()]; |
| current_control = block_final_control[predecessor->id().ToSize()]; |
| } else { |
| // Create control merge nodes and effect phis for all predecessor blocks. |
| merge_inputs.clear(); |
| effect_phi_inputs.clear(); |
| int predecessor_count = static_cast<int>(block->PredecessorCount()); |
| for (int i = 0; i < predecessor_count; ++i) { |
| BasicBlock* predecessor = block->PredecessorAt(i); |
| DCHECK_LT(predecessor->rpo_number(), block->rpo_number()); |
| merge_inputs.push_back(block_final_control[predecessor->id().ToSize()]); |
| effect_phi_inputs.push_back( |
| block_final_effect[predecessor->id().ToSize()]); |
| } |
| current_control = graph()->NewNode(common()->Merge(predecessor_count), |
| static_cast<int>(merge_inputs.size()), |
| merge_inputs.data()); |
| effect_phi_inputs.push_back(current_control); |
| current_effect = graph()->NewNode( |
| common()->EffectPhi(predecessor_count), |
| static_cast<int>(effect_phi_inputs.size()), effect_phi_inputs.data()); |
| } |
| |
| auto update_current_control_and_effect = [&](Node* node) { |
| bool existing_effect_and_control = |
| IrOpcode::IsIfProjectionOpcode(node->opcode()) || |
| IrOpcode::IsPhiOpcode(node->opcode()); |
| if (node->op()->EffectInputCount() > 0) { |
| DCHECK_EQ(1, node->op()->EffectInputCount()); |
| if (existing_effect_and_control) { |
| NodeProperties::ReplaceEffectInput(node, current_effect); |
| } else { |
| node->AppendInput(graph()->zone(), current_effect); |
| } |
| } |
| if (node->op()->ControlInputCount() > 0) { |
| DCHECK_EQ(1, node->op()->ControlInputCount()); |
| if (existing_effect_and_control) { |
| NodeProperties::ReplaceControlInput(node, current_control); |
| } else { |
| node->AppendInput(graph()->zone(), current_control); |
| } |
| } |
| if (node->op()->EffectOutputCount() > 0) { |
| DCHECK_EQ(1, node->op()->EffectOutputCount()); |
| current_effect = node; |
| } |
| if (node->op()->ControlOutputCount() > 0) { |
| current_control = node; |
| } |
| }; |
| |
| for (Node* node : *block) { |
| update_current_control_and_effect(node); |
| } |
| if (block->deferred()) MarkControlDeferred(current_control); |
| |
| if (Node* block_terminator = block->control_input()) { |
| update_current_control_and_effect(block_terminator); |
| } |
| |
| block_final_effect[block->id().ToSize()] = current_effect; |
| block_final_control[block->id().ToSize()] = current_control; |
| } |
| |
| // Fix-up loop backedges and re-structure control flow so that loop nodes have |
| // exactly two control predecessors. |
| for (const LoopHeader& loop_header : loop_headers) { |
| BasicBlock* block = loop_header.block; |
| std::vector<BasicBlock*> loop_entries; |
| std::vector<BasicBlock*> loop_backedges; |
| for (size_t i = 0; i < block->PredecessorCount(); ++i) { |
| BasicBlock* predecessor = block->PredecessorAt(i); |
| if (block->LoopContains(predecessor)) { |
| loop_backedges.push_back(predecessor); |
| } else { |
| DCHECK(loop_backedges.empty()); |
| loop_entries.push_back(predecessor); |
| } |
| } |
| DCHECK(!loop_entries.empty()); |
| DCHECK(!loop_backedges.empty()); |
| |
| int entrance_count = static_cast<int>(loop_entries.size()); |
| int backedge_count = static_cast<int>(loop_backedges.size()); |
| Node* control_loop_entry = CreateNodeFromPredecessors( |
| loop_entries, block_final_control, common()->Merge(entrance_count), {}); |
| Node* control_backedge = |
| CreateNodeFromPredecessors(loop_backedges, block_final_control, |
| common()->Merge(backedge_count), {}); |
| Node* effect_loop_entry = CreateNodeFromPredecessors( |
| loop_entries, block_final_effect, common()->EffectPhi(entrance_count), |
| {control_loop_entry}); |
| Node* effect_backedge = CreateNodeFromPredecessors( |
| loop_backedges, block_final_effect, common()->EffectPhi(backedge_count), |
| {control_backedge}); |
| |
| loop_header.loop_node->ReplaceInput(0, control_loop_entry); |
| loop_header.loop_node->ReplaceInput(1, control_backedge); |
| loop_header.effect_phi->ReplaceInput(0, effect_loop_entry); |
| loop_header.effect_phi->ReplaceInput(1, effect_backedge); |
| |
| for (Node* node : *block) { |
| if (node->opcode() == IrOpcode::kPhi) { |
| MakePhiBinary(node, static_cast<int>(loop_entries.size()), |
| control_loop_entry, control_backedge); |
| } |
| } |
| } |
| } |
| |
| Node* RawMachineAssembler::CreateNodeFromPredecessors( |
| const std::vector<BasicBlock*>& predecessors, |
| const std::vector<Node*>& sidetable, const Operator* op, |
| const std::vector<Node*>& additional_inputs) { |
| if (predecessors.size() == 1) { |
| return sidetable[predecessors.front()->id().ToSize()]; |
| } |
| std::vector<Node*> inputs; |
| for (BasicBlock* predecessor : predecessors) { |
| inputs.push_back(sidetable[predecessor->id().ToSize()]); |
| } |
| for (Node* additional_input : additional_inputs) { |
| inputs.push_back(additional_input); |
| } |
| return graph()->NewNode(op, static_cast<int>(inputs.size()), inputs.data()); |
| } |
| |
| void RawMachineAssembler::MakePhiBinary(Node* phi, int split_point, |
| Node* left_control, |
| Node* right_control) { |
| int value_count = phi->op()->ValueInputCount(); |
| if (value_count == 2) return; |
| DCHECK_LT(split_point, value_count); |
| DCHECK_GT(split_point, 0); |
| |
| MachineRepresentation rep = PhiRepresentationOf(phi->op()); |
| int left_input_count = split_point; |
| int right_input_count = value_count - split_point; |
| |
| Node* left_input; |
| if (left_input_count == 1) { |
| left_input = NodeProperties::GetValueInput(phi, 0); |
| } else { |
| std::vector<Node*> inputs; |
| for (int i = 0; i < left_input_count; ++i) { |
| inputs.push_back(NodeProperties::GetValueInput(phi, i)); |
| } |
| inputs.push_back(left_control); |
| left_input = |
| graph()->NewNode(common()->Phi(rep, static_cast<int>(left_input_count)), |
| static_cast<int>(inputs.size()), inputs.data()); |
| } |
| |
| Node* right_input; |
| if (right_input_count == 1) { |
| right_input = NodeProperties::GetValueInput(phi, split_point); |
| } else { |
| std::vector<Node*> inputs; |
| for (int i = split_point; i < value_count; ++i) { |
| inputs.push_back(NodeProperties::GetValueInput(phi, i)); |
| } |
| inputs.push_back(right_control); |
| right_input = graph()->NewNode( |
| common()->Phi(rep, static_cast<int>(right_input_count)), |
| static_cast<int>(inputs.size()), inputs.data()); |
| } |
| |
| Node* control = NodeProperties::GetControlInput(phi); |
| phi->TrimInputCount(3); |
| phi->ReplaceInput(0, left_input); |
| phi->ReplaceInput(1, right_input); |
| phi->ReplaceInput(2, control); |
| NodeProperties::ChangeOp(phi, common()->Phi(rep, 2)); |
| } |
| |
| void RawMachineAssembler::MarkControlDeferred(Node* control_node) { |
| BranchHint new_branch_hint; |
| Node* responsible_branch = nullptr; |
| while (responsible_branch == nullptr) { |
| switch (control_node->opcode()) { |
| case IrOpcode::kIfException: |
| // IfException projections are deferred by default. |
| return; |
| case IrOpcode::kIfSuccess: |
| control_node = NodeProperties::GetControlInput(control_node); |
| continue; |
| case IrOpcode::kIfValue: { |
| IfValueParameters parameters = IfValueParametersOf(control_node->op()); |
| if (parameters.hint() != BranchHint::kFalse) { |
| NodeProperties::ChangeOp( |
| control_node, common()->IfValue(parameters.value(), |
| parameters.comparison_order(), |
| BranchHint::kFalse)); |
| } |
| return; |
| } |
| case IrOpcode::kIfDefault: |
| if (BranchHintOf(control_node->op()) != BranchHint::kFalse) { |
| NodeProperties::ChangeOp(control_node, |
| common()->IfDefault(BranchHint::kFalse)); |
| } |
| return; |
| case IrOpcode::kIfTrue: { |
| Node* branch = NodeProperties::GetControlInput(control_node); |
| BranchHint hint = BranchOperatorInfoOf(branch->op()).hint; |
| if (hint == BranchHint::kTrue) { |
| // The other possibility is also deferred, so the responsible branch |
| // has to be before. |
| control_node = NodeProperties::GetControlInput(branch); |
| continue; |
| } |
| new_branch_hint = BranchHint::kFalse; |
| responsible_branch = branch; |
| break; |
| } |
| case IrOpcode::kIfFalse: { |
| Node* branch = NodeProperties::GetControlInput(control_node); |
| BranchHint hint = BranchOperatorInfoOf(branch->op()).hint; |
| if (hint == BranchHint::kFalse) { |
| // The other possibility is also deferred, so the responsible branch |
| // has to be before. |
| control_node = NodeProperties::GetControlInput(branch); |
| continue; |
| } |
| new_branch_hint = BranchHint::kTrue; |
| responsible_branch = branch; |
| break; |
| } |
| case IrOpcode::kMerge: |
| for (int i = 0; i < control_node->op()->ControlInputCount(); ++i) { |
| MarkControlDeferred(NodeProperties::GetControlInput(control_node, i)); |
| } |
| return; |
| case IrOpcode::kLoop: |
| control_node = NodeProperties::GetControlInput(control_node, 0); |
| continue; |
| case IrOpcode::kBranch: |
| case IrOpcode::kSwitch: |
| UNREACHABLE(); |
| case IrOpcode::kStart: |
| return; |
| default: |
| DCHECK_EQ(1, control_node->op()->ControlInputCount()); |
| control_node = NodeProperties::GetControlInput(control_node); |
| continue; |
| } |
| } |
| |
| BranchOperatorInfo info = BranchOperatorInfoOf(responsible_branch->op()); |
| if (info.hint == new_branch_hint) return; |
| NodeProperties::ChangeOp( |
| responsible_branch, |
| common()->Branch(new_branch_hint, info.is_safety_check)); |
| } |
| |
| Node* RawMachineAssembler::TargetParameter() { |
| DCHECK_NOT_NULL(target_parameter_); |
| return target_parameter_; |
| } |
| |
| Node* RawMachineAssembler::Parameter(size_t index) { |
| DCHECK_LT(index, parameter_count()); |
| return parameters_[index]; |
| } |
| |
| |
| void RawMachineAssembler::Goto(RawMachineLabel* label) { |
| DCHECK(current_block_ != schedule()->end()); |
| schedule()->AddGoto(CurrentBlock(), Use(label)); |
| current_block_ = nullptr; |
| } |
| |
| |
| void RawMachineAssembler::Branch(Node* condition, RawMachineLabel* true_val, |
| RawMachineLabel* false_val) { |
| DCHECK(current_block_ != schedule()->end()); |
| Node* branch = MakeNode( |
| common()->Branch(BranchHint::kNone, IsSafetyCheck::kNoSafetyCheck), 1, |
| &condition); |
| BasicBlock* true_block = schedule()->NewBasicBlock(); |
| BasicBlock* false_block = schedule()->NewBasicBlock(); |
| schedule()->AddBranch(CurrentBlock(), branch, true_block, false_block); |
| |
| true_block->AddNode(MakeNode(common()->IfTrue(), 1, &branch)); |
| schedule()->AddGoto(true_block, Use(true_val)); |
| |
| false_block->AddNode(MakeNode(common()->IfFalse(), 1, &branch)); |
| schedule()->AddGoto(false_block, Use(false_val)); |
| |
| current_block_ = nullptr; |
| } |
| |
| void RawMachineAssembler::Continuations(Node* call, RawMachineLabel* if_success, |
| RawMachineLabel* if_exception) { |
| DCHECK_NOT_NULL(schedule_); |
| DCHECK_NOT_NULL(current_block_); |
| schedule()->AddCall(CurrentBlock(), call, Use(if_success), Use(if_exception)); |
| current_block_ = nullptr; |
| } |
| |
| void RawMachineAssembler::Switch(Node* index, RawMachineLabel* default_label, |
| const int32_t* case_values, |
| RawMachineLabel** case_labels, |
| size_t case_count) { |
| DCHECK_NE(schedule()->end(), current_block_); |
| size_t succ_count = case_count + 1; |
| Node* switch_node = MakeNode(common()->Switch(succ_count), 1, &index); |
| BasicBlock** succ_blocks = zone()->NewArray<BasicBlock*>(succ_count); |
| for (size_t index = 0; index < case_count; ++index) { |
| int32_t case_value = case_values[index]; |
| BasicBlock* case_block = schedule()->NewBasicBlock(); |
| Node* case_node = |
| graph()->NewNode(common()->IfValue(case_value), switch_node); |
| schedule()->AddNode(case_block, case_node); |
| schedule()->AddGoto(case_block, Use(case_labels[index])); |
| succ_blocks[index] = case_block; |
| } |
| BasicBlock* default_block = schedule()->NewBasicBlock(); |
| Node* default_node = graph()->NewNode(common()->IfDefault(), switch_node); |
| schedule()->AddNode(default_block, default_node); |
| schedule()->AddGoto(default_block, Use(default_label)); |
| succ_blocks[case_count] = default_block; |
| schedule()->AddSwitch(CurrentBlock(), switch_node, succ_blocks, succ_count); |
| current_block_ = nullptr; |
| } |
| |
| void RawMachineAssembler::Return(Node* value) { |
| Node* values[] = {Int32Constant(0), value}; |
| Node* ret = MakeNode(common()->Return(1), 2, values); |
| schedule()->AddReturn(CurrentBlock(), ret); |
| current_block_ = nullptr; |
| } |
| |
| void RawMachineAssembler::Return(Node* v1, Node* v2) { |
| Node* values[] = {Int32Constant(0), v1, v2}; |
| Node* ret = MakeNode(common()->Return(2), 3, values); |
| schedule()->AddReturn(CurrentBlock(), ret); |
| current_block_ = nullptr; |
| } |
| |
| void RawMachineAssembler::Return(Node* v1, Node* v2, Node* v3) { |
| Node* values[] = {Int32Constant(0), v1, v2, v3}; |
| Node* ret = MakeNode(common()->Return(3), 4, values); |
| schedule()->AddReturn(CurrentBlock(), ret); |
| current_block_ = nullptr; |
| } |
| |
| void RawMachineAssembler::Return(Node* v1, Node* v2, Node* v3, Node* v4) { |
| Node* values[] = {Int32Constant(0), v1, v2, v3, v4}; |
| Node* ret = MakeNode(common()->Return(4), 5, values); |
| schedule()->AddReturn(CurrentBlock(), ret); |
| current_block_ = nullptr; |
| } |
| |
| void RawMachineAssembler::Return(int count, Node* vs[]) { |
| using Node_ptr = Node*; |
| Node** values = new Node_ptr[count + 1]; |
| values[0] = Int32Constant(0); |
| for (int i = 0; i < count; ++i) values[i + 1] = vs[i]; |
| Node* ret = MakeNode(common()->Return(count), count + 1, values); |
| schedule()->AddReturn(CurrentBlock(), ret); |
| current_block_ = nullptr; |
| delete[] values; |
| } |
| |
| void RawMachineAssembler::PopAndReturn(Node* pop, Node* value) { |
| // PopAndReturn is supposed to be using ONLY in CSA/Torque builtins for |
| // dropping ALL JS arguments that are currently located on the stack. |
| // The check below ensures that there are no directly accessible stack |
| // parameters from current builtin, which implies that the builtin with |
| // JS calling convention (TFJ) was created with kDontAdaptArgumentsSentinel. |
| // This simplifies semantics of this instruction because in case of presence |
| // of directly accessible stack parameters it's impossible to distinguish |
| // the following cases: |
| // 1) stack parameter is included in JS arguments (and therefore it will be |
| // dropped as a part of 'pop' number of arguments), |
| // 2) stack parameter is NOT included in JS arguments (and therefore it should |
| // be dropped in ADDITION to the 'pop' number of arguments). |
| // Additionally, in order to simplify assembly code, PopAndReturn is also |
| // not allowed in builtins with stub linkage and parameters on stack. |
| CHECK_EQ(call_descriptor()->StackParameterCount(), 0); |
| Node* values[] = {pop, value}; |
| Node* ret = MakeNode(common()->Return(1), 2, values); |
| schedule()->AddReturn(CurrentBlock(), ret); |
| current_block_ = nullptr; |
| } |
| |
| void RawMachineAssembler::PopAndReturn(Node* pop, Node* v1, Node* v2) { |
| Node* values[] = {pop, v1, v2}; |
| Node* ret = MakeNode(common()->Return(2), 3, values); |
| schedule()->AddReturn(CurrentBlock(), ret); |
| current_block_ = nullptr; |
| } |
| |
| void RawMachineAssembler::PopAndReturn(Node* pop, Node* v1, Node* v2, |
| Node* v3) { |
| Node* values[] = {pop, v1, v2, v3}; |
| Node* ret = MakeNode(common()->Return(3), 4, values); |
| schedule()->AddReturn(CurrentBlock(), ret); |
| current_block_ = nullptr; |
| } |
| |
| void RawMachineAssembler::PopAndReturn(Node* pop, Node* v1, Node* v2, Node* v3, |
| Node* v4) { |
| Node* values[] = {pop, v1, v2, v3, v4}; |
| Node* ret = MakeNode(common()->Return(4), 5, values); |
| schedule()->AddReturn(CurrentBlock(), ret); |
| current_block_ = nullptr; |
| } |
| |
| void RawMachineAssembler::AbortCSAAssert(Node* message) { |
| AddNode(machine()->AbortCSAAssert(), message); |
| } |
| |
| void RawMachineAssembler::DebugBreak() { AddNode(machine()->DebugBreak()); } |
| |
| void RawMachineAssembler::Unreachable() { |
| Node* ret = MakeNode(common()->Throw(), 0, nullptr); |
| schedule()->AddThrow(CurrentBlock(), ret); |
| current_block_ = nullptr; |
| } |
| |
| void RawMachineAssembler::Comment(const std::string& msg) { |
| size_t length = msg.length() + 1; |
| char* zone_buffer = zone()->NewArray<char>(length); |
| MemCopy(zone_buffer, msg.c_str(), length); |
| AddNode(machine()->Comment(zone_buffer)); |
| } |
| |
| void RawMachineAssembler::StaticAssert(Node* value, const char* source) { |
| AddNode(common()->StaticAssert(source), value); |
| } |
| |
| Node* RawMachineAssembler::CallN(CallDescriptor* call_descriptor, |
| int input_count, Node* const* inputs) { |
| DCHECK(!call_descriptor->NeedsFrameState()); |
| // +1 is for target. |
| DCHECK_EQ(input_count, call_descriptor->ParameterCount() + 1); |
| return AddNode(common()->Call(call_descriptor), input_count, inputs); |
| } |
| |
| Node* RawMachineAssembler::CallNWithFrameState(CallDescriptor* call_descriptor, |
| int input_count, |
| Node* const* inputs) { |
| DCHECK(call_descriptor->NeedsFrameState()); |
| // +2 is for target and frame state. |
| DCHECK_EQ(input_count, call_descriptor->ParameterCount() + 2); |
| return AddNode(common()->Call(call_descriptor), input_count, inputs); |
| } |
| |
| void RawMachineAssembler::TailCallN(CallDescriptor* call_descriptor, |
| int input_count, Node* const* inputs) { |
| // +1 is for target. |
| DCHECK_EQ(input_count, call_descriptor->ParameterCount() + 1); |
| Node* tail_call = |
| MakeNode(common()->TailCall(call_descriptor), input_count, inputs); |
| schedule()->AddTailCall(CurrentBlock(), tail_call); |
| current_block_ = nullptr; |
| } |
| |
| namespace { |
| |
| enum FunctionDescriptorMode { kHasFunctionDescriptor, kNoFunctionDescriptor }; |
| |
| Node* CallCFunctionImpl( |
| RawMachineAssembler* rasm, Node* function, MachineType return_type, |
| std::initializer_list<RawMachineAssembler::CFunctionArg> args, |
| bool caller_saved_regs, SaveFPRegsMode mode, |
| FunctionDescriptorMode no_function_descriptor) { |
| static constexpr std::size_t kNumCArgs = 10; |
| |
| MachineSignature::Builder builder(rasm->zone(), 1, args.size()); |
| builder.AddReturn(return_type); |
| for (const auto& arg : args) builder.AddParam(arg.first); |
| |
| bool caller_saved_fp_regs = caller_saved_regs && (mode == kSaveFPRegs); |
| CallDescriptor::Flags flags = CallDescriptor::kNoFlags; |
| if (caller_saved_regs) flags |= CallDescriptor::kCallerSavedRegisters; |
| if (caller_saved_fp_regs) flags |= CallDescriptor::kCallerSavedFPRegisters; |
| if (no_function_descriptor) flags |= CallDescriptor::kNoFunctionDescriptor; |
| auto call_descriptor = |
| Linkage::GetSimplifiedCDescriptor(rasm->zone(), builder.Build(), flags); |
| |
| base::SmallVector<Node*, kNumCArgs> nodes(args.size() + 1); |
| nodes[0] = function; |
| std::transform( |
| args.begin(), args.end(), std::next(nodes.begin()), |
| [](const RawMachineAssembler::CFunctionArg& arg) { return arg.second; }); |
| |
| auto common = rasm->common(); |
| return rasm->AddNode(common->Call(call_descriptor), |
| static_cast<int>(nodes.size()), nodes.begin()); |
| } |
| |
| } // namespace |
| |
| Node* RawMachineAssembler::CallCFunction( |
| Node* function, MachineType return_type, |
| std::initializer_list<RawMachineAssembler::CFunctionArg> args) { |
| return CallCFunctionImpl(this, function, return_type, args, false, |
| kDontSaveFPRegs, kHasFunctionDescriptor); |
| } |
| |
| Node* RawMachineAssembler::CallCFunctionWithoutFunctionDescriptor( |
| Node* function, MachineType return_type, |
| std::initializer_list<RawMachineAssembler::CFunctionArg> args) { |
| return CallCFunctionImpl(this, function, return_type, args, false, |
| kDontSaveFPRegs, kNoFunctionDescriptor); |
| } |
| |
| Node* RawMachineAssembler::CallCFunctionWithCallerSavedRegisters( |
| Node* function, MachineType return_type, SaveFPRegsMode mode, |
| std::initializer_list<RawMachineAssembler::CFunctionArg> args) { |
| return CallCFunctionImpl(this, function, return_type, args, true, mode, |
| kHasFunctionDescriptor); |
| } |
| |
| BasicBlock* RawMachineAssembler::Use(RawMachineLabel* label) { |
| label->used_ = true; |
| return EnsureBlock(label); |
| } |
| |
| BasicBlock* RawMachineAssembler::EnsureBlock(RawMachineLabel* label) { |
| if (label->block_ == nullptr) { |
| label->block_ = schedule()->NewBasicBlock(); |
| } |
| return label->block_; |
| } |
| |
| void RawMachineAssembler::Bind(RawMachineLabel* label) { |
| DCHECK_NULL(current_block_); |
| DCHECK(!label->bound_); |
| label->bound_ = true; |
| current_block_ = EnsureBlock(label); |
| current_block_->set_deferred(label->deferred_); |
| } |
| |
| #if DEBUG |
| void RawMachineAssembler::Bind(RawMachineLabel* label, |
| AssemblerDebugInfo info) { |
| if (current_block_ != nullptr) { |
| std::stringstream str; |
| str << "Binding label without closing previous block:" |
| << "\n# label: " << info |
| << "\n# previous block: " << *current_block_; |
| FATAL("%s", str.str().c_str()); |
| } |
| Bind(label); |
| current_block_->set_debug_info(info); |
| } |
| |
| void RawMachineAssembler::PrintCurrentBlock(std::ostream& os) { |
| os << CurrentBlock(); |
| } |
| |
| void RawMachineAssembler::SetInitialDebugInformation( |
| AssemblerDebugInfo debug_info) { |
| CurrentBlock()->set_debug_info(debug_info); |
| } |
| #endif // DEBUG |
| |
| bool RawMachineAssembler::InsideBlock() { return current_block_ != nullptr; } |
| |
| BasicBlock* RawMachineAssembler::CurrentBlock() { |
| DCHECK(current_block_); |
| return current_block_; |
| } |
| |
| Node* RawMachineAssembler::Phi(MachineRepresentation rep, int input_count, |
| Node* const* inputs) { |
| Node** buffer = zone()->NewArray<Node*>(input_count + 1); |
| std::copy(inputs, inputs + input_count, buffer); |
| buffer[input_count] = graph()->start(); |
| return AddNode(common()->Phi(rep, input_count), input_count + 1, buffer); |
| } |
| |
| void RawMachineAssembler::AppendPhiInput(Node* phi, Node* new_input) { |
| const Operator* op = phi->op(); |
| const Operator* new_op = common()->ResizeMergeOrPhi(op, phi->InputCount()); |
| phi->InsertInput(zone(), phi->InputCount() - 1, new_input); |
| NodeProperties::ChangeOp(phi, new_op); |
| } |
| |
| Node* RawMachineAssembler::AddNode(const Operator* op, int input_count, |
| Node* const* inputs) { |
| DCHECK_NOT_NULL(schedule_); |
| DCHECK_NOT_NULL(current_block_); |
| Node* node = MakeNode(op, input_count, inputs); |
| schedule()->AddNode(CurrentBlock(), node); |
| return node; |
| } |
| |
| Node* RawMachineAssembler::MakeNode(const Operator* op, int input_count, |
| Node* const* inputs) { |
| // The raw machine assembler nodes do not have effect and control inputs, |
| // so we disable checking input counts here. |
| return graph()->NewNodeUnchecked(op, input_count, inputs); |
| } |
| |
| RawMachineLabel::~RawMachineLabel() { |
| #if DEBUG |
| if (bound_ == used_) return; |
| std::stringstream str; |
| if (bound_) { |
| str << "A label has been bound but it's not used." |
| << "\n# label: " << *block_; |
| } else { |
| str << "A label has been used but it's not bound."; |
| } |
| FATAL("%s", str.str().c_str()); |
| #endif // DEBUG |
| } |
| |
| } // namespace compiler |
| } // namespace internal |
| } // namespace v8 |
