v8/src/compiler/js-graph.h
sigurds@chromium.org 4ec63ff97e Reland
- "Switch inlining to use simplified instead of machine loads."
- "Add copy support in inliner."

Reland fixes:
 - size_t conversion for 64bit arches
 - Don't call front() on empty vector
   (triggers assertion on windows)
 - turbo_inlining now implies turbo_types, as
   it requires simplified lowering.

R=mstarzinger@chromium.org

Review URL: https://codereview.chromium.org/559843004

git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@23911 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
2014-09-12 11:06:37 +00:00

117 lines
3.5 KiB
C++

// 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.
#ifndef V8_COMPILER_JS_GRAPH_H_
#define V8_COMPILER_JS_GRAPH_H_
#include "src/compiler/common-node-cache.h"
#include "src/compiler/common-operator.h"
#include "src/compiler/graph.h"
#include "src/compiler/js-operator.h"
#include "src/compiler/machine-operator.h"
#include "src/compiler/node-properties.h"
namespace v8 {
namespace internal {
namespace compiler {
class Typer;
// Implements a facade on a Graph, enhancing the graph with JS-specific
// notions, including a builder for for JS* operators, canonicalized global
// constants, and various helper methods.
class JSGraph : public ZoneObject {
public:
JSGraph(Graph* graph, CommonOperatorBuilder* common,
JSOperatorBuilder* javascript, Typer* typer,
MachineOperatorBuilder* machine)
: graph_(graph),
common_(common),
javascript_(javascript),
typer_(typer),
machine_(machine),
cache_(zone()) {}
// Canonicalized global constants.
Node* CEntryStubConstant();
Node* UndefinedConstant();
Node* TheHoleConstant();
Node* TrueConstant();
Node* FalseConstant();
Node* NullConstant();
Node* ZeroConstant();
Node* OneConstant();
Node* NaNConstant();
// Creates a HeapConstant node, possibly canonicalized, without inspecting the
// object.
Node* HeapConstant(Unique<Object> value);
// Creates a HeapConstant node, possibly canonicalized, and may access the
// heap to inspect the object.
Node* HeapConstant(Handle<Object> value);
// Creates a Constant node of the appropriate type for the given object.
// Accesses the heap to inspect the object and determine whether one of the
// canonicalized globals or a number constant should be returned.
Node* Constant(Handle<Object> value);
// Creates a NumberConstant node, usually canonicalized.
Node* Constant(double value);
// Creates a NumberConstant node, usually canonicalized.
Node* Constant(int32_t value);
// Creates a Int32Constant node, usually canonicalized.
Node* Int32Constant(int32_t value);
// Creates a Float64Constant node, usually canonicalized.
Node* Float64Constant(double value);
// Creates an ExternalConstant node, usually canonicalized.
Node* ExternalConstant(ExternalReference ref);
Node* SmiConstant(int32_t immediate) {
DCHECK(Smi::IsValid(immediate));
return Constant(immediate);
}
JSOperatorBuilder* javascript() { return javascript_; }
CommonOperatorBuilder* common() { return common_; }
MachineOperatorBuilder* machine() { return machine_; }
Graph* graph() { return graph_; }
Zone* zone() { return graph()->zone(); }
Isolate* isolate() { return zone()->isolate(); }
private:
Graph* graph_;
CommonOperatorBuilder* common_;
JSOperatorBuilder* javascript_;
Typer* typer_;
MachineOperatorBuilder* machine_;
SetOncePointer<Node> c_entry_stub_constant_;
SetOncePointer<Node> undefined_constant_;
SetOncePointer<Node> the_hole_constant_;
SetOncePointer<Node> true_constant_;
SetOncePointer<Node> false_constant_;
SetOncePointer<Node> null_constant_;
SetOncePointer<Node> zero_constant_;
SetOncePointer<Node> one_constant_;
SetOncePointer<Node> nan_constant_;
CommonNodeCache cache_;
Node* ImmovableHeapConstant(Handle<Object> value);
Node* NumberConstant(double value);
Node* NewNode(const Operator* op);
Factory* factory() { return isolate()->factory(); }
};
} // namespace compiler
} // namespace internal
} // namespace v8
#endif