// Copyright 2018 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. #ifndef V8_COMPILER_MACHINE_GRAPH_H_ #define V8_COMPILER_MACHINE_GRAPH_H_ #include "src/base/compiler-specific.h" #include "src/compiler/common-node-cache.h" #include "src/compiler/common-operator.h" #include "src/compiler/graph.h" #include "src/compiler/machine-operator.h" #include "src/globals.h" #include "src/runtime/runtime.h" namespace v8 { namespace internal { namespace compiler { // Implements a facade on a Graph, enhancing the graph with machine-specific // notions, including a builder for common and machine operators, as well // as caching primitive constants. class V8_EXPORT_PRIVATE MachineGraph : public NON_EXPORTED_BASE(ZoneObject) { public: MachineGraph(Graph* graph, CommonOperatorBuilder* common, MachineOperatorBuilder* machine) : graph_(graph), common_(common), machine_(machine), cache_(zone()) {} // Creates a Int32Constant node, usually canonicalized. Node* Int32Constant(int32_t value); Node* Uint32Constant(uint32_t value) { return Int32Constant(bit_cast<int32_t>(value)); } // Creates a Int64Constant node, usually canonicalized. Node* Int64Constant(int64_t value); Node* Uint64Constant(uint64_t value) { return Int64Constant(bit_cast<int64_t>(value)); } // Creates a Int32Constant/Int64Constant node, depending on the word size of // the target machine. // TODO(turbofan): Code using Int32Constant/Int64Constant to store pointer // constants is probably not serializable. Node* IntPtrConstant(intptr_t value); Node* RelocatableInt32Constant(int32_t value, RelocInfo::Mode rmode); Node* RelocatableInt64Constant(int64_t value, RelocInfo::Mode rmode); Node* RelocatableIntPtrConstant(intptr_t value, RelocInfo::Mode rmode); // Creates a Float32Constant node, usually canonicalized. Node* Float32Constant(float value); // Creates a Float64Constant node, usually canonicalized. Node* Float64Constant(double value); // Creates a PointerConstant node. Node* PointerConstant(intptr_t value); template <typename T> Node* PointerConstant(T* value) { return PointerConstant(bit_cast<intptr_t>(value)); } // Creates an ExternalConstant node, usually canonicalized. Node* ExternalConstant(ExternalReference ref); Node* ExternalConstant(Runtime::FunctionId function_id); // Global cache of the dead node. Node* Dead() { return Dead_ ? Dead_ : Dead_ = graph_->NewNode(common_->Dead()); } CommonOperatorBuilder* common() const { return common_; } MachineOperatorBuilder* machine() const { return machine_; } Graph* graph() const { return graph_; } Zone* zone() const { return graph()->zone(); } protected: Graph* graph_; CommonOperatorBuilder* common_; MachineOperatorBuilder* machine_; CommonNodeCache cache_; Node* Dead_ = nullptr; DISALLOW_COPY_AND_ASSIGN(MachineGraph); }; } // namespace compiler } // namespace internal } // namespace v8 #endif // V8_COMPILER_MACHINE_GRAPH_H_