raw-machine-assembler.cc | Explore in Territory

// 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 <optional>

#include "src/base/small-vector.h"
#include "src/compiler/compiler-source-position-table.h"
#include "src/compiler/node-properties.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)
    : … { … }

void RawMachineAssembler::SetCurrentExternalSourcePosition(
    FileAndLine file_and_line) { … }

FileAndLine RawMachineAssembler::GetCurrentExternalSourcePosition() const { … }

Node* RawMachineAssembler::NullConstant() { … }

Node* RawMachineAssembler::UndefinedConstant() { … }

Node* RawMachineAssembler::RelocatableIntPtrConstant(intptr_t value,
                                                     RelocInfo::Mode rmode) { … }

Node* RawMachineAssembler::OptimizedAllocate(Node* size,
                                             AllocationType allocation) { … }

Schedule* RawMachineAssembler::ExportForTest() { … }

Graph* RawMachineAssembler::ExportForOptimization() { … }

void RawMachineAssembler::OptimizeControlFlow(Schedule* schedule, Graph* graph,
                                              CommonOperatorBuilder* common) { … }

void RawMachineAssembler::MakeReschedulable() { … }

Node* RawMachineAssembler::CreateNodeFromPredecessors(
    const std::vector<BasicBlock*>& predecessors,
    const std::vector<Node*>& sidetable, const Operator* op,
    const std::vector<Node*>& additional_inputs) { … }

void RawMachineAssembler::MakePhiBinary(Node* phi, int split_point,
                                        Node* left_control,
                                        Node* right_control) { … }

void RawMachineAssembler::MarkControlDeferred(Node* control_node) { … }

Node* RawMachineAssembler::TargetParameter() { … }

Node* RawMachineAssembler::Parameter(size_t index) { … }


void RawMachineAssembler::Goto(RawMachineLabel* label) { … }


void RawMachineAssembler::Branch(Node* condition, RawMachineLabel* true_val,
                                 RawMachineLabel* false_val) { … }

void RawMachineAssembler::Continuations(Node* call, RawMachineLabel* if_success,
                                        RawMachineLabel* if_exception) { … }

void RawMachineAssembler::Switch(Node* index, RawMachineLabel* default_label,
                                 const int32_t* case_values,
                                 RawMachineLabel** case_labels,
                                 size_t case_count) { … }

void RawMachineAssembler::Return(Node* value) { … }

void RawMachineAssembler::Return(Node* v1, Node* v2) { … }

void RawMachineAssembler::Return(Node* v1, Node* v2, Node* v3) { … }

void RawMachineAssembler::Return(Node* v1, Node* v2, Node* v3, Node* v4) { … }

void RawMachineAssembler::Return(int count, Node* vs[]) { … }

void RawMachineAssembler::PopAndReturn(Node* pop, Node* value) { … }

void RawMachineAssembler::PopAndReturn(Node* pop, Node* v1, Node* v2) { … }

void RawMachineAssembler::PopAndReturn(Node* pop, Node* v1, Node* v2,
                                       Node* v3) { … }

void RawMachineAssembler::PopAndReturn(Node* pop, Node* v1, Node* v2, Node* v3,
                                       Node* v4) { … }

void RawMachineAssembler::AbortCSADcheck(Node* message) { … }

void RawMachineAssembler::DebugBreak() { … }

void RawMachineAssembler::Unreachable() { … }

void RawMachineAssembler::Comment(const std::string& msg) { … }

void RawMachineAssembler::StaticAssert(Node* value, const char* source) { … }

Node* RawMachineAssembler::CallN(CallDescriptor* call_descriptor,
                                 int input_count, Node* const* inputs) { … }

Node* RawMachineAssembler::CallNWithFrameState(CallDescriptor* call_descriptor,
                                               int input_count,
                                               Node* const* inputs) { … }

void RawMachineAssembler::TailCallN(CallDescriptor* call_descriptor,
                                    int input_count, Node* const* inputs) { … }

namespace {

enum FunctionDescriptorMode { … };

Node* CallCFunctionImpl(
    RawMachineAssembler* rasm, Node* function,
    std::optional<MachineType> return_type,
    std::initializer_list<RawMachineAssembler::CFunctionArg> args,
    bool caller_saved_regs, SaveFPRegsMode mode,
    FunctionDescriptorMode no_function_descriptor) { … }

}  // namespace

Node* RawMachineAssembler::CallCFunction(
    Node* function, std::optional<MachineType> return_type,
    std::initializer_list<RawMachineAssembler::CFunctionArg> args) { … }

Node* RawMachineAssembler::CallCFunctionWithoutFunctionDescriptor(
    Node* function, MachineType return_type,
    std::initializer_list<RawMachineAssembler::CFunctionArg> args) { … }

Node* RawMachineAssembler::CallCFunctionWithCallerSavedRegisters(
    Node* function, MachineType return_type, SaveFPRegsMode mode,
    std::initializer_list<RawMachineAssembler::CFunctionArg> args) { … }

BasicBlock* RawMachineAssembler::Use(RawMachineLabel* label) { … }

BasicBlock* RawMachineAssembler::EnsureBlock(RawMachineLabel* label) { … }

void RawMachineAssembler::Bind(RawMachineLabel* label) { … }

#if DEBUG
void RawMachineAssembler::Bind(RawMachineLabel* label,
                               AssemblerDebugInfo info) { … }

void RawMachineAssembler::PrintCurrentBlock(std::ostream& os) { … }

void RawMachineAssembler::SetInitialDebugInformation(
    AssemblerDebugInfo debug_info) { … }
#endif  // DEBUG

bool RawMachineAssembler::InsideBlock() { … }

BasicBlock* RawMachineAssembler::CurrentBlock() { … }

Node* RawMachineAssembler::Phi(MachineRepresentation rep, int input_count,
                               Node* const* inputs) { … }

void RawMachineAssembler::AppendPhiInput(Node* phi, Node* new_input) { … }

Node* RawMachineAssembler::AddNode(const Operator* op, int input_count,
                                   Node* const* inputs) { … }

Node* RawMachineAssembler::MakeNode(const Operator* op, int input_count,
                                    Node* const* inputs) { … }

RawMachineLabel::~RawMachineLabel() { … }

}  // namespace compiler
}  // namespace internal
}  // namespace v8
chromium/v8/src/compiler/raw-machine-assembler.cc
