AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity
08843650db
v8/src/compiler/effect-control-linearizer.h

164 lines
7.8 KiB
C
Raw Normal View History

[turbofan] Effect linearization after representation inference. This introduces a compiler pass that schedules the graph and re-wires effect chain according to the schedule. It also connects allocating representation changes to the effect chain, and removes the BeginRegion and EndRegion nodes - they should not be needed anymore because all effectful nodes should be already wired-in. This is an intermediate CL - the next step is to move lowering of the Change*ToTaggedEffect nodes to StateEffectIntroduction so that we do not have to introduce the effectful versions of nodes. Review URL: https://codereview.chromium.org/1849603002 Cr-Commit-Position: refs/heads/master@{#35565}
2016-04-18 08:28:33 +00:00
// Copyright 2016 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_EFFECT_CONTROL_LINEARIZER_H_
#define V8_COMPILER_EFFECT_CONTROL_LINEARIZER_H_
#include "src/compiler/common-operator.h"
#include "src/compiler/node.h"
#include "src/compiler/simplified-operator.h"
namespace v8 {
namespace internal {
class Zone;
namespace compiler {
class CommonOperatorBuilder;
class SimplifiedOperatorBuilder;
class MachineOperatorBuilder;
class JSGraph;
class Graph;
class Schedule;
class EffectControlLinearizer {
public:
EffectControlLinearizer(JSGraph* graph, Schedule* schedule, Zone* temp_zone);
void Run();
private:
[turbofan] Add frame state propagation to linearizer. This implements propagation of frame states from checkpoints to all deoptimization points inserted by the EffectControlLinearizer. It also allows us to remove the eager frame state input from all the checked conversion operations. R=jarin@chromium.org BUG=v8:5021 Review-Url: https://codereview.chromium.org/2033143002 Cr-Commit-Position: refs/heads/master@{#36710}
2016-06-03 11:37:18 +00:00
void ProcessNode(Node* node, Node** frame_state, Node** effect,
Node** control);
[turbofan] Effect linearization after representation inference. This introduces a compiler pass that schedules the graph and re-wires effect chain according to the schedule. It also connects allocating representation changes to the effect chain, and removes the BeginRegion and EndRegion nodes - they should not be needed anymore because all effectful nodes should be already wired-in. This is an intermediate CL - the next step is to move lowering of the Change*ToTaggedEffect nodes to StateEffectIntroduction so that we do not have to introduce the effectful versions of nodes. Review URL: https://codereview.chromium.org/1849603002 Cr-Commit-Position: refs/heads/master@{#35565}
2016-04-18 08:28:33 +00:00
struct ValueEffectControl {
Node* value;
Node* effect;
Node* control;
ValueEffectControl(Node* value, Node* effect, Node* control)
: value(value), effect(effect), control(control) {}
};
[turbofan] Add frame state propagation to linearizer. This implements propagation of frame states from checkpoints to all deoptimization points inserted by the EffectControlLinearizer. It also allows us to remove the eager frame state input from all the checked conversion operations. R=jarin@chromium.org BUG=v8:5021 Review-Url: https://codereview.chromium.org/2033143002 Cr-Commit-Position: refs/heads/master@{#36710}
2016-06-03 11:37:18 +00:00
bool TryWireInStateEffect(Node* node, Node* frame_state, Node** effect,
Node** control);
[turbofan] Remove left-over change bits from ChangeLowering. Now ChangeLowering is only concerned with lowering memory access and allocation operations, and all changes are consistently lowered during the effect/control linearization pass. The next step is to move the left over lowerings to a pass dedicated to eliminate redundant loads and stores, eliminate write barriers, fold and inline allocations. Drive-by-fix: Rename ChangeBitToBool to ChangeBitToTagged, ChangeBoolToBit to ChangeTaggedToBit, and ChangeInt31ToTagged to ChangeInt31ToTaggedSigned for consistency. CQ_INCLUDE_TRYBOTS=tryserver.v8:v8_linux64_tsan_rel Committed: https://crrev.com/ceca5ae308bddda166651c654f96d71d74f617d0 Cr-Commit-Position: refs/heads/master@{#35924} Review-Url: https://codereview.chromium.org/1941673002 Cr-Commit-Position: refs/heads/master@{#35929}
2016-05-02 10:23:02 +00:00
ValueEffectControl LowerChangeBitToTagged(Node* node, Node* effect,
Node* control);
ValueEffectControl LowerChangeInt31ToTaggedSigned(Node* node, Node* effect,
Node* control);
[turbofan] Effect linearization after representation inference. This introduces a compiler pass that schedules the graph and re-wires effect chain according to the schedule. It also connects allocating representation changes to the effect chain, and removes the BeginRegion and EndRegion nodes - they should not be needed anymore because all effectful nodes should be already wired-in. This is an intermediate CL - the next step is to move lowering of the Change*ToTaggedEffect nodes to StateEffectIntroduction so that we do not have to introduce the effectful versions of nodes. Review URL: https://codereview.chromium.org/1849603002 Cr-Commit-Position: refs/heads/master@{#35565}
2016-04-18 08:28:33 +00:00
ValueEffectControl LowerChangeInt32ToTagged(Node* node, Node* effect,
Node* control);
ValueEffectControl LowerChangeUint32ToTagged(Node* node, Node* effect,
Node* control);
ValueEffectControl LowerChangeFloat64ToTagged(Node* node, Node* effect,
Node* control);
[turbofan] Remove left-over change bits from ChangeLowering. Now ChangeLowering is only concerned with lowering memory access and allocation operations, and all changes are consistently lowered during the effect/control linearization pass. The next step is to move the left over lowerings to a pass dedicated to eliminate redundant loads and stores, eliminate write barriers, fold and inline allocations. Drive-by-fix: Rename ChangeBitToBool to ChangeBitToTagged, ChangeBoolToBit to ChangeTaggedToBit, and ChangeInt31ToTagged to ChangeInt31ToTaggedSigned for consistency. CQ_INCLUDE_TRYBOTS=tryserver.v8:v8_linux64_tsan_rel Committed: https://crrev.com/ceca5ae308bddda166651c654f96d71d74f617d0 Cr-Commit-Position: refs/heads/master@{#35924} Review-Url: https://codereview.chromium.org/1941673002 Cr-Commit-Position: refs/heads/master@{#35929}
2016-05-02 10:23:02 +00:00
ValueEffectControl LowerChangeTaggedSignedToInt32(Node* node, Node* effect,
Node* control);
ValueEffectControl LowerChangeTaggedToBit(Node* node, Node* effect,
Node* control);
[turbofan] Move ChangeTaggedToFoo lowerings to EffectControlLinearizer. These also lower to subgraphs that have to be connected to the effect and control chains, otherwise removing the atomic regions around heap allocations would still be unsound. R=jarin@chromium.org Review URL: https://codereview.chromium.org/1916763003 Cr-Commit-Position: refs/heads/master@{#35762}
2016-04-25 12:40:46 +00:00
ValueEffectControl LowerChangeTaggedToInt32(Node* node, Node* effect,
Node* control);
ValueEffectControl LowerChangeTaggedToUint32(Node* node, Node* effect,
Node* control);
[turbofan] Introduce a dedicated CheckBounds operator. This CheckBounds simplified operator is similar to the HBoundsCheck in Crankshaft, and is hooked up to the new type feedback support in the SimplifiedLowering. We use it to check the index bounds for keyed property accesses. Note to perf sheriffs: This will tank quite a few benchmarks, as the operator makes some redundant branch elimination ineffective for certain patterns of keyed accesses. This does require more serious redundancy elimination, which we will do in a separate CL. So ignore any regressions from this CL, we know there will be a few. R=jarin@chromium.org BUG=v8:4470,v8:5100 Committed: https://crrev.com/85e5567dae66a918500ae94c5568221137a0f5d4 Review-Url: https://codereview.chromium.org/2035893004 Cr-Original-Commit-Position: refs/heads/master@{#36947} Cr-Commit-Position: refs/heads/master@{#37003}
2016-06-15 13:04:36 +00:00
ValueEffectControl LowerCheckBounds(Node* node, Node* frame_state,
Node* effect, Node* control);
[turbofan] Introduce proper CheckNumber operator. We use CheckNumber to guard values as being proper numbers, i.e. if the input value is anything but a Number, we deoptimize. This follows the existing effect/control linearization magic that we already use for the other checks. R=jarin@chromium.org BUG=v8:5141 Review-Url: https://codereview.chromium.org/2109623002 Cr-Commit-Position: refs/heads/master@{#37329}
2016-06-28 13:08:26 +00:00
ValueEffectControl LowerCheckNumber(Node* node, Node* frame_state,
Node* effect, Node* control);
[turbofan] Introduce CheckIf simplified operator. This adds a new CheckIf operator and changes all direct uses of DeoptimizeIf and DeoptimizeUnless on the JavaScript level to use CheckIf (or one of the more concrete check operators) instead. This way we do not depend on particular frame states, but the effect/control linearizer will assign an appropriate frame state instead. R=jarin@chromium.org BUG=v8:5141 Review-Url: https://codereview.chromium.org/2115513002 Cr-Commit-Position: refs/heads/master@{#37423}
2016-06-30 08:39:49 +00:00
ValueEffectControl LowerCheckIf(Node* node, Node* frame_state, Node* effect,
Node* control);
[turbofan] Introduce CheckTaggedSigned and CheckTaggedPointer operators. These are used to check for Smi or HeapObject, and we use them appropriately in JSNativeContextSpecialization, so we don't need to introduce dependencies on concrete control flow and/or concrete frame states. They will be optimized by a proper check elimination reducer, which will be added in a separate CL. R=jarin@chromium.org BUG=v8:4470 Review-Url: https://codereview.chromium.org/2082523002 Cr-Commit-Position: refs/heads/master@{#37096}
2016-06-20 10:46:12 +00:00
ValueEffectControl LowerCheckTaggedPointer(Node* node, Node* frame_state,
Node* effect, Node* control);
ValueEffectControl LowerCheckTaggedSigned(Node* node, Node* frame_state,
Node* effect, Node* control);
[turbofan] Address the useless overflow bit materialization. Add control dependencies to Projection and Int32Add/SubWithOverflow operators, to prevent the scheduler from moving the Projection nodes into the wrong place. This way the instruction selection can combine the Int32Add/SubWithOverflow operations with the DeoptimizeIf and/or DeoptimizeUnless nodes. This needs new operators CheckedInt32Add and CheckedInt32Sub so that we can delay the actual lowering until the effect/control linearizer. This also makes CheckIf operator obsolete, so we can drop it. R=jarin@chromium.org Review-Url: https://codereview.chromium.org/2082993002 Cr-Commit-Position: refs/heads/master@{#37148}
2016-06-21 15:46:10 +00:00
ValueEffectControl LowerCheckedInt32Add(Node* node, Node* frame_state,
Node* effect, Node* control);
ValueEffectControl LowerCheckedInt32Sub(Node* node, Node* frame_state,
Node* effect, Node* control);
[turbofan] Introduce CheckedInt32Div and CheckedInt32Mod operators. Consume Smi/Signed32 feedback for division and modulus and introduce appropriate checked operators. This is especially important for modulus where the Float64Mod operator is significantly slower than Int32Mod on most platforms. For division it's mostly important to propagate integerness, i.e. to avoid follow-up conversions between float and int32. Drive-by-fix: Use Int32Mod for the ModulusStub (and the bytecode handler) when the inputs are both Smi. R=jarin@chromium.org Review-Url: https://codereview.chromium.org/2138633002 Cr-Commit-Position: refs/heads/master@{#37621}
2016-07-11 05:27:14 +00:00
ValueEffectControl LowerCheckedInt32Div(Node* node, Node* frame_state,
Node* effect, Node* control);
ValueEffectControl LowerCheckedInt32Mod(Node* node, Node* frame_state,
Node* effect, Node* control);
[turbofan] Add frame state propagation to linearizer. This implements propagation of frame states from checkpoints to all deoptimization points inserted by the EffectControlLinearizer. It also allows us to remove the eager frame state input from all the checked conversion operations. R=jarin@chromium.org BUG=v8:5021 Review-Url: https://codereview.chromium.org/2033143002 Cr-Commit-Position: refs/heads/master@{#36710}
2016-06-03 11:37:18 +00:00
ValueEffectControl LowerCheckedUint32ToInt32(Node* node, Node* frame_state,
Node* effect, Node* control);
ValueEffectControl LowerCheckedFloat64ToInt32(Node* node, Node* frame_state,
Node* effect, Node* control);
ValueEffectControl LowerCheckedTaggedToInt32(Node* node, Node* frame_state,
Node* effect, Node* control);
ValueEffectControl LowerCheckedTaggedToFloat64(Node* node, Node* frame_state,
Node* effect, Node* control);
[turbofan] Move ChangeTaggedToFoo lowerings to EffectControlLinearizer. These also lower to subgraphs that have to be connected to the effect and control chains, otherwise removing the atomic regions around heap allocations would still be unsound. R=jarin@chromium.org Review URL: https://codereview.chromium.org/1916763003 Cr-Commit-Position: refs/heads/master@{#35762}
2016-04-25 12:40:46 +00:00
ValueEffectControl LowerChangeTaggedToFloat64(Node* node, Node* effect,
Node* control);
[turbofan] Distinguish between change- and truncate-tagged-to-float64. This prevents the compiler from optimizing f64-to-tagged(tagged-to-f64(x)) ==> x for non-number x (such as undefined). Review-Url: https://codereview.chromium.org/2027593002 Cr-Commit-Position: refs/heads/master@{#36613}
2016-05-31 11:59:59 +00:00
ValueEffectControl LowerTruncateTaggedToFloat64(Node* node, Node* effect,
Node* control);
[turbofan] Move ChangeTaggedToFoo lowerings to EffectControlLinearizer. These also lower to subgraphs that have to be connected to the effect and control chains, otherwise removing the atomic regions around heap allocations would still be unsound. R=jarin@chromium.org Review URL: https://codereview.chromium.org/1916763003 Cr-Commit-Position: refs/heads/master@{#35762}
2016-04-25 12:40:46 +00:00
ValueEffectControl LowerTruncateTaggedToWord32(Node* node, Node* effect,
Node* control);
[turbofan] Properly wire ObjectIs<Type> diamonds. The ObjectIs<Type> predicates compile down to diamonds (in the general case), and those should be connected properly to the control and effect chain in the linearization pass. R=jarin@chromium.org Review URL: https://codereview.chromium.org/1912743002 Cr-Commit-Position: refs/heads/master@{#35748}
2016-04-25 06:12:37 +00:00
ValueEffectControl LowerObjectIsCallable(Node* node, Node* effect,
Node* control);
ValueEffectControl LowerObjectIsNumber(Node* node, Node* effect,
Node* control);
ValueEffectControl LowerObjectIsReceiver(Node* node, Node* effect,
Node* control);
[turbofan] Remove left-over change bits from ChangeLowering. Now ChangeLowering is only concerned with lowering memory access and allocation operations, and all changes are consistently lowered during the effect/control linearization pass. The next step is to move the left over lowerings to a pass dedicated to eliminate redundant loads and stores, eliminate write barriers, fold and inline allocations. Drive-by-fix: Rename ChangeBitToBool to ChangeBitToTagged, ChangeBoolToBit to ChangeTaggedToBit, and ChangeInt31ToTagged to ChangeInt31ToTaggedSigned for consistency. CQ_INCLUDE_TRYBOTS=tryserver.v8:v8_linux64_tsan_rel Committed: https://crrev.com/ceca5ae308bddda166651c654f96d71d74f617d0 Cr-Commit-Position: refs/heads/master@{#35924} Review-Url: https://codereview.chromium.org/1941673002 Cr-Commit-Position: refs/heads/master@{#35929}
2016-05-02 10:23:02 +00:00
ValueEffectControl LowerObjectIsSmi(Node* node, Node* effect, Node* control);
[turbofan] Properly wire ObjectIs<Type> diamonds. The ObjectIs<Type> predicates compile down to diamonds (in the general case), and those should be connected properly to the control and effect chain in the linearization pass. R=jarin@chromium.org Review URL: https://codereview.chromium.org/1912743002 Cr-Commit-Position: refs/heads/master@{#35748}
2016-04-25 06:12:37 +00:00
ValueEffectControl LowerObjectIsString(Node* node, Node* effect,
Node* control);
ValueEffectControl LowerObjectIsUndetectable(Node* node, Node* effect,
Node* control);
[turbofan] Add new StringFromCharCode simplified operator. We use StringFromCharCode to optimize calls to String.fromCharCode with a single Number argument for now. We will use it to also implement the charAt method on the String prototype. R=jarin@chromium.org Review-Url: https://codereview.chromium.org/2037453003 Cr-Commit-Position: refs/heads/master@{#36668}
2016-06-02 07:59:29 +00:00
ValueEffectControl LowerStringFromCharCode(Node* node, Node* effect,
Node* control);
[turbofan] Introduce CheckHole and CheckHoleNaN operators. These simplified operators are used to perform the hole checks when loading elements from a holey array. Depending on the CheckHoleMode, they either return the hole as undefined or some NaN, or deoptimize if the value is the hole or the hole NaN. R=jarin@chromium.org Review-Url: https://codereview.chromium.org/2066223002 Cr-Commit-Position: refs/heads/master@{#37001}
2016-06-15 12:24:10 +00:00
ValueEffectControl LowerCheckFloat64Hole(Node* node, Node* frame_state,
Node* effect, Node* control);
ValueEffectControl LowerCheckTaggedHole(Node* node, Node* frame_state,
Node* effect, Node* control);
[turbofan] Introduce PlainPrimitiveToNumber. This should solve the problem with missing checkpoints after JSToNumber (PlainPrimitiveToNumber is marked no-write, so the frame-state propagation should see through it.) Unfortunately, this also duplicates the word32- and float64-truncation magic that we have for JSToNumber in "simplified lowering". Review-Url: https://codereview.chromium.org/2059653002 Cr-Commit-Position: refs/heads/master@{#36881}
2016-06-10 07:41:45 +00:00
ValueEffectControl LowerPlainPrimitiveToNumber(Node* node, Node* effect,
Node* control);
ValueEffectControl LowerPlainPrimitiveToWord32(Node* node, Node* effect,
Node* control);
ValueEffectControl LowerPlainPrimitiveToFloat64(Node* node, Node* effect,
Node* control);
[turbofan] Effect linearization after representation inference. This introduces a compiler pass that schedules the graph and re-wires effect chain according to the schedule. It also connects allocating representation changes to the effect chain, and removes the BeginRegion and EndRegion nodes - they should not be needed anymore because all effectful nodes should be already wired-in. This is an intermediate CL - the next step is to move lowering of the Change*ToTaggedEffect nodes to StateEffectIntroduction so that we do not have to introduce the effectful versions of nodes. Review URL: https://codereview.chromium.org/1849603002 Cr-Commit-Position: refs/heads/master@{#35565}
2016-04-18 08:28:33 +00:00
ValueEffectControl AllocateHeapNumberWithValue(Node* node, Node* effect,
Node* control);
[turbofan] Initial version of number type feedback. This introduces optimized number operations based on type feedback. Summary of changes: 1. Typed lowering produces SpeculativeNumberAdd/Subtract for JSAdd/Subtract if there is suitable feedback. The speculative nodes are connected to both the effect chain and the control chain and they retain the eager frame state. 2. Simplified lowering now executes in three phases: a. Propagation phase computes truncations by traversing the graph from uses to definitions until checkpoint is reached. It also records type-check decisions for later typing phase, and computes representation. b. The typing phase computes more precise types base on the speculative types (and recomputes representation for affected nodes). c. The lowering phase performs lowering and inserts representation changes and/or checks. 3. Effect-control linearization lowers the checks to machine graphs. Notes: - SimplifiedLowering will be refactored to have handling of each operation one place and with clearer input/output protocol for each sub-phase. I would prefer to do this once we have more operations implemented, and the pattern is clearer. - The check operations (Checked<A>To<B>) should have some flags that would affect the kind of truncations that they can handle. E.g., if we know that a node produces a number, we can omit the oddball check in the CheckedTaggedToFloat64 lowering. - In future, we want the typer to reuse the logic from OperationTyper. BUG=v8:4583 LOG=n Review-Url: https://codereview.chromium.org/1921563002 Cr-Commit-Position: refs/heads/master@{#36674}
2016-06-02 09:20:50 +00:00
ValueEffectControl BuildCheckedFloat64ToInt32(Node* value, Node* frame_state,
Node* effect, Node* control);
ValueEffectControl BuildCheckedHeapNumberOrOddballToFloat64(Node* value,
Node* frame_state,
Node* effect,
Node* control);
[turbofan] Introduce PlainPrimitiveToNumber. This should solve the problem with missing checkpoints after JSToNumber (PlainPrimitiveToNumber is marked no-write, so the frame-state propagation should see through it.) Unfortunately, this also duplicates the word32- and float64-truncation magic that we have for JSToNumber in "simplified lowering". Review-Url: https://codereview.chromium.org/2059653002 Cr-Commit-Position: refs/heads/master@{#36881}
2016-06-10 07:41:45 +00:00
[turbofan] Effect linearization after representation inference. This introduces a compiler pass that schedules the graph and re-wires effect chain according to the schedule. It also connects allocating representation changes to the effect chain, and removes the BeginRegion and EndRegion nodes - they should not be needed anymore because all effectful nodes should be already wired-in. This is an intermediate CL - the next step is to move lowering of the Change*ToTaggedEffect nodes to StateEffectIntroduction so that we do not have to introduce the effectful versions of nodes. Review URL: https://codereview.chromium.org/1849603002 Cr-Commit-Position: refs/heads/master@{#35565}
2016-04-18 08:28:33 +00:00
Node* ChangeInt32ToSmi(Node* value);
Node* ChangeUint32ToSmi(Node* value);
Node* ChangeInt32ToFloat64(Node* value);
Node* ChangeUint32ToFloat64(Node* value);
[turbofan] Remove left-over change bits from ChangeLowering. Now ChangeLowering is only concerned with lowering memory access and allocation operations, and all changes are consistently lowered during the effect/control linearization pass. The next step is to move the left over lowerings to a pass dedicated to eliminate redundant loads and stores, eliminate write barriers, fold and inline allocations. Drive-by-fix: Rename ChangeBitToBool to ChangeBitToTagged, ChangeBoolToBit to ChangeTaggedToBit, and ChangeInt31ToTagged to ChangeInt31ToTaggedSigned for consistency. CQ_INCLUDE_TRYBOTS=tryserver.v8:v8_linux64_tsan_rel Committed: https://crrev.com/ceca5ae308bddda166651c654f96d71d74f617d0 Cr-Commit-Position: refs/heads/master@{#35924} Review-Url: https://codereview.chromium.org/1941673002 Cr-Commit-Position: refs/heads/master@{#35929}
2016-05-02 10:23:02 +00:00
Node* ChangeSmiToInt32(Node* value);
Node* ObjectIsSmi(Node* value);
[turbofan] Effect linearization after representation inference. This introduces a compiler pass that schedules the graph and re-wires effect chain according to the schedule. It also connects allocating representation changes to the effect chain, and removes the BeginRegion and EndRegion nodes - they should not be needed anymore because all effectful nodes should be already wired-in. This is an intermediate CL - the next step is to move lowering of the Change*ToTaggedEffect nodes to StateEffectIntroduction so that we do not have to introduce the effectful versions of nodes. Review URL: https://codereview.chromium.org/1849603002 Cr-Commit-Position: refs/heads/master@{#35565}
2016-04-18 08:28:33 +00:00
Node* SmiMaxValueConstant();
Node* SmiShiftBitsConstant();
[turbofan] Add new StringFromCharCode simplified operator. We use StringFromCharCode to optimize calls to String.fromCharCode with a single Number argument for now. We will use it to also implement the charAt method on the String prototype. R=jarin@chromium.org Review-Url: https://codereview.chromium.org/2037453003 Cr-Commit-Position: refs/heads/master@{#36668}
2016-06-02 07:59:29 +00:00
Factory* factory() const;
Isolate* isolate() const;
[turbofan] Effect linearization after representation inference. This introduces a compiler pass that schedules the graph and re-wires effect chain according to the schedule. It also connects allocating representation changes to the effect chain, and removes the BeginRegion and EndRegion nodes - they should not be needed anymore because all effectful nodes should be already wired-in. This is an intermediate CL - the next step is to move lowering of the Change*ToTaggedEffect nodes to StateEffectIntroduction so that we do not have to introduce the effectful versions of nodes. Review URL: https://codereview.chromium.org/1849603002 Cr-Commit-Position: refs/heads/master@{#35565}
2016-04-18 08:28:33 +00:00
JSGraph* jsgraph() const { return js_graph_; }
Graph* graph() const;
Schedule* schedule() const { return schedule_; }
Zone* temp_zone() const { return temp_zone_; }
CommonOperatorBuilder* common() const;
SimplifiedOperatorBuilder* simplified() const;
MachineOperatorBuilder* machine() const;
[turbofan] Introduce PlainPrimitiveToNumber. This should solve the problem with missing checkpoints after JSToNumber (PlainPrimitiveToNumber is marked no-write, so the frame-state propagation should see through it.) Unfortunately, this also duplicates the word32- and float64-truncation magic that we have for JSToNumber in "simplified lowering". Review-Url: https://codereview.chromium.org/2059653002 Cr-Commit-Position: refs/heads/master@{#36881}
2016-06-10 07:41:45 +00:00
Operator const* ToNumberOperator();
[turbofan] Effect linearization after representation inference. This introduces a compiler pass that schedules the graph and re-wires effect chain according to the schedule. It also connects allocating representation changes to the effect chain, and removes the BeginRegion and EndRegion nodes - they should not be needed anymore because all effectful nodes should be already wired-in. This is an intermediate CL - the next step is to move lowering of the Change*ToTaggedEffect nodes to StateEffectIntroduction so that we do not have to introduce the effectful versions of nodes. Review URL: https://codereview.chromium.org/1849603002 Cr-Commit-Position: refs/heads/master@{#35565}
2016-04-18 08:28:33 +00:00
JSGraph* js_graph_;
Schedule* schedule_;
Zone* temp_zone_;
[turbofan] Introduce CheckTaggedSigned and CheckTaggedPointer operators. These are used to check for Smi or HeapObject, and we use them appropriately in JSNativeContextSpecialization, so we don't need to introduce dependencies on concrete control flow and/or concrete frame states. They will be optimized by a proper check elimination reducer, which will be added in a separate CL. R=jarin@chromium.org BUG=v8:4470 Review-Url: https://codereview.chromium.org/2082523002 Cr-Commit-Position: refs/heads/master@{#37096}
2016-06-20 10:46:12 +00:00
RegionObservability region_observability_ = RegionObservability::kObservable;
[turbofan] Introduce PlainPrimitiveToNumber. This should solve the problem with missing checkpoints after JSToNumber (PlainPrimitiveToNumber is marked no-write, so the frame-state propagation should see through it.) Unfortunately, this also duplicates the word32- and float64-truncation magic that we have for JSToNumber in "simplified lowering". Review-Url: https://codereview.chromium.org/2059653002 Cr-Commit-Position: refs/heads/master@{#36881}
2016-06-10 07:41:45 +00:00
SetOncePointer<Operator const> to_number_operator_;
[turbofan] Effect linearization after representation inference. This introduces a compiler pass that schedules the graph and re-wires effect chain according to the schedule. It also connects allocating representation changes to the effect chain, and removes the BeginRegion and EndRegion nodes - they should not be needed anymore because all effectful nodes should be already wired-in. This is an intermediate CL - the next step is to move lowering of the Change*ToTaggedEffect nodes to StateEffectIntroduction so that we do not have to introduce the effectful versions of nodes. Review URL: https://codereview.chromium.org/1849603002 Cr-Commit-Position: refs/heads/master@{#35565}
2016-04-18 08:28:33 +00:00
};
} // namespace compiler
} // namespace internal
} // namespace v8
#endif // V8_COMPILER_EFFECT_CONTROL_LINEARIZER_H_
Reference in New Issue Copy Permalink