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

238 lines
12 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"
Make unittests work in component build R=machenbach@chromium.org,titzer@chromium.org,bmeurer@chromium.org,jgruber@chromium.org BUG= CQ_INCLUDE_TRYBOTS=master.tryserver.v8:v8_win_dbg,v8_mac_dbg;master.tryserver.chromium.android:android_arm64_dbg_recipe Review-Url: https://codereview.chromium.org/2416243002 Cr-Commit-Position: refs/heads/master@{#40350}
2016-10-17 10:01:42 +00:00
#include "src/globals.h"
[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 v8 {
namespace internal {
[turbofan] Lower StringEqual and friends in EffectControlLinearizer. Turn the StringEqualStub and friends into proper TurboFan builtins, which means that we don't need to do on-demand compilation for those stubs, and use those to defer lowering of the StringEqual, etc. simplified operators to effect/control linearization (i.e. move it to the concurrent recompilation part). BUG=v8:5428 R=jarin@chromium.org Review-Url: https://codereview.chromium.org/2363333003 Cr-Commit-Position: refs/heads/master@{#39762}
2016-09-27 11:24:07 +00:00
// Forward declarations.
class Callable;
[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
class Zone;
namespace compiler {
class CommonOperatorBuilder;
class SimplifiedOperatorBuilder;
class MachineOperatorBuilder;
class JSGraph;
class Graph;
class Schedule;
Make unittests work in component build R=machenbach@chromium.org,titzer@chromium.org,bmeurer@chromium.org,jgruber@chromium.org BUG= CQ_INCLUDE_TRYBOTS=master.tryserver.v8:v8_win_dbg,v8_mac_dbg;master.tryserver.chromium.android:android_arm64_dbg_recipe Review-Url: https://codereview.chromium.org/2416243002 Cr-Commit-Position: refs/heads/master@{#40350}
2016-10-17 10:01:42 +00:00
class V8_EXPORT_PRIVATE EffectControlLinearizer {
[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
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] Improve representation selection for HeapObject checking. For lowering CheckHeapObject, always report TaggedPointer representation and let the RepresentationChanger come up with a reasonable conversion from whatever input representation to TaggedPointer. This way we no longer insert the useless ChangeSomethingToTagged and then check the result for HeapObject, i.e. mostly reduces the amount of useless code being generated. Note there are now two operators ChangeFloat64ToTaggedPointer and the old ChangeFloat64ToTagged, because their semantics different wrt. the strength reduction in the SimplifiedOperatorReducer. Also set the output MachineRepresentation::kTaggedPointer properly in SimplifiedLowering whenever we know that we produce a HeapObject. R=jarin@chromium.org BUG=v8:5267 Review-Url: https://codereview.chromium.org/2476593002 Cr-Commit-Position: refs/heads/master@{#40725}
2016-11-03 12:52:11 +00:00
ValueEffectControl LowerChangeFloat64ToTaggedPointer(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 a dedicated CheckMaps simplified operator. So far we always create explicit control flow for map checks during JSNativeContextSpecialization, or in the monomorphic case we used a CheckIf combined with a map comparison. In either case we cannot currently effectively utilize the map check information during load elimination to optimize (polymorphic) map checks and elements kind transitions. With the introduction of CheckMaps, we can now start optimizing map checks in a more effective fashion. This CL doesn't change anything in that direction yet, but merely changes the fundamental mechanism. This also removes the stable map optimization from the Typer, where it was always a bit odd, and puts it into the typed lowering and the native context specialization instead. R=epertoso@chromium.org BUG=v8:4930,v8:5141 Review-Url: https://codereview.chromium.org/2196653002 Cr-Commit-Position: refs/heads/master@{#38166}
2016-07-29 09:39:34 +00:00
ValueEffectControl LowerCheckMaps(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 CheckString simplified operator. Introduce the CheckString during native context specialization when we have string map feedback on a LOAD_IC/STORE_IC. The CheckString operator, just like its CheckNumber pendant, renames the input and assigns a proper type, which we will use soon to lower access operations on Strings, i.e. charCodeAt calls or keyed accesses. R=jarin@chromium.org BUG=v8:4930,v8:5141 Review-Url: https://codereview.chromium.org/2181943003 Cr-Commit-Position: refs/heads/master@{#38076}
2016-07-27 04:15:34 +00:00
ValueEffectControl LowerCheckString(Node* node, Node* frame_state,
Node* effect, Node* control);
[compiler] Properly guard the speculative optimizations for instanceof. Add a general feedback slot for instanceof similar to what we already have for for-in, which basically has a fast (indicated by the uninitialized sentinel) and a slow (indicated by the megamorphic sentinel) mode. Now we can only take the fast path when the feedback slot says it hasn't seen any funky inputs and nothing funky appeared in the prototype chain. In the TurboFan code we also deoptimize whenever we see a funky object (i.e. a proxy or an object that requires access checks) in the prototype chain (similar to what Crankshaft already did). Drive-by-fix: Also make Crankshaft respect the mode and therefore address the deopt loop in Crankshaft around instanceof. We might want to introduce an InstanceOfIC mechanism at some point and track the map of the right-hand side. BUG=v8:5267 R=mvstanton@chromium.org Review-Url: https://codereview.chromium.org/2370693002 Cr-Commit-Position: refs/heads/master@{#39718}
2016-09-26 12:32:23 +00:00
ValueEffectControl LowerCheckIf(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] Introduce CheckedUint32Div and CheckUint32Mod operators. Checked integer division and modulus can be done more efficiently if we know that the inputs are in Unsigned32 range. Drive-by-fix: Replace the TypeCheckKind on NodeInfo by a proper restriction type, and thread the feedback type through binary Number operations similar to what we do for their speculative versions. Also deal with Unsigned32 inputs for integer multiplication. R=jarin@chromium.org BUG=v8:4583,v8:5141 Review-Url: https://codereview.chromium.org/2149493002 Cr-Commit-Position: refs/heads/master@{#37703}
2016-07-13 08:16:35 +00:00
ValueEffectControl LowerCheckedUint32Div(Node* node, Node* frame_state,
Node* effect, Node* control);
ValueEffectControl LowerCheckedUint32Mod(Node* node, Node* frame_state,
Node* effect, Node* control);
[Turbofan]: Add integer multiplication with overflow to typed lowering. BUG= Review-Url: https://codereview.chromium.org/2141953002 Cr-Commit-Position: refs/heads/master@{#37764}
2016-07-14 13:21:55 +00:00
ValueEffectControl LowerCheckedInt32Mul(Node* node, Node* frame_state,
Node* effect, Node* control);
[turbofan] Improve representation selection for Smi checking. Rename the high-level operators CheckTaggedSigned to CheckSmi and CheckTaggedPointer to CheckHeapObject, to better match the naming convention (i.e. ObjectIsSmi and CheckSmi, ObjectIsString and CheckString, etc.). For lowering CheckSmi, always report TaggedSigned representation and let the RepresentationChanger come up with a reasonable conversion from whatever input representation to TaggedSigned. This way we no longer insert the useless ChangeSomethingToTagged and then Smi check the result sequences, i.e. mostly reduces the amount of useless code being generated. But we also observe a few performance improvements on some crypto benchmarks. This would enable us to avoid the Smi canonicalization when going from Float64 to Tagged completely and thus match the representation selection of Crankshaft in many areas (which might reduce the amount of polymorphism until we fix our object model). A follow-up CL will do the same for CheckHeapObject. BUG=v8:5267 R=jarin@chromium.org Review URL: https://codereview.chromium.org/2362173003 . Cr-Commit-Position: refs/heads/master@{#39654}
2016-09-23 10:32:13 +00:00
ValueEffectControl LowerCheckedInt32ToTaggedSigned(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);
[turbofan] Improve representation selection for Smi checking. Rename the high-level operators CheckTaggedSigned to CheckSmi and CheckTaggedPointer to CheckHeapObject, to better match the naming convention (i.e. ObjectIsSmi and CheckSmi, ObjectIsString and CheckString, etc.). For lowering CheckSmi, always report TaggedSigned representation and let the RepresentationChanger come up with a reasonable conversion from whatever input representation to TaggedSigned. This way we no longer insert the useless ChangeSomethingToTagged and then Smi check the result sequences, i.e. mostly reduces the amount of useless code being generated. But we also observe a few performance improvements on some crypto benchmarks. This would enable us to avoid the Smi canonicalization when going from Float64 to Tagged completely and thus match the representation selection of Crankshaft in many areas (which might reduce the amount of polymorphism until we fix our object model). A follow-up CL will do the same for CheckHeapObject. BUG=v8:5267 R=jarin@chromium.org Review URL: https://codereview.chromium.org/2362173003 . Cr-Commit-Position: refs/heads/master@{#39654}
2016-09-23 10:32:13 +00:00
ValueEffectControl LowerCheckedUint32ToTaggedSigned(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 LowerCheckedFloat64ToInt32(Node* node, Node* frame_state,
Node* effect, Node* control);
[turbofan] Consume SignedSmall feedback for number operations. So far we treated SignedSmall and Signed32 feedback the same for number operations. However it would be beneficial to generate (a lot) less code if we only do a Smi check on the inputs instead of doing the full Smi + HeapNumber + conversion check that we need to do for Signed32 feedback. R=epertoso@chromium.org BUG=v8:4583 Review-Url: https://codereview.chromium.org/2207893002 Cr-Commit-Position: refs/heads/master@{#38290}
2016-08-03 12:45:37 +00:00
ValueEffectControl LowerCheckedTaggedSignedToInt32(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 LowerCheckedTaggedToInt32(Node* node, Node* frame_state,
Node* effect, Node* control);
ValueEffectControl LowerCheckedTaggedToFloat64(Node* node, Node* frame_state,
Node* effect, Node* control);
[turbofan] Improve representation selection for Smi checking. Rename the high-level operators CheckTaggedSigned to CheckSmi and CheckTaggedPointer to CheckHeapObject, to better match the naming convention (i.e. ObjectIsSmi and CheckSmi, ObjectIsString and CheckString, etc.). For lowering CheckSmi, always report TaggedSigned representation and let the RepresentationChanger come up with a reasonable conversion from whatever input representation to TaggedSigned. This way we no longer insert the useless ChangeSomethingToTagged and then Smi check the result sequences, i.e. mostly reduces the amount of useless code being generated. But we also observe a few performance improvements on some crypto benchmarks. This would enable us to avoid the Smi canonicalization when going from Float64 to Tagged completely and thus match the representation selection of Crankshaft in many areas (which might reduce the amount of polymorphism until we fix our object model). A follow-up CL will do the same for CheckHeapObject. BUG=v8:5267 R=jarin@chromium.org Review URL: https://codereview.chromium.org/2362173003 . Cr-Commit-Position: refs/heads/master@{#39654}
2016-09-23 10:32:13 +00:00
ValueEffectControl LowerCheckedTaggedToTaggedSigned(Node* node,
Node* frame_state,
Node* effect,
Node* control);
[turbofan] Improve representation selection for HeapObject checking. For lowering CheckHeapObject, always report TaggedPointer representation and let the RepresentationChanger come up with a reasonable conversion from whatever input representation to TaggedPointer. This way we no longer insert the useless ChangeSomethingToTagged and then check the result for HeapObject, i.e. mostly reduces the amount of useless code being generated. Note there are now two operators ChangeFloat64ToTaggedPointer and the old ChangeFloat64ToTagged, because their semantics different wrt. the strength reduction in the SimplifiedOperatorReducer. Also set the output MachineRepresentation::kTaggedPointer properly in SimplifiedLowering whenever we know that we produce a HeapObject. R=jarin@chromium.org BUG=v8:5267 Review-Url: https://codereview.chromium.org/2476593002 Cr-Commit-Position: refs/heads/master@{#40725}
2016-11-03 12:52:11 +00:00
ValueEffectControl LowerCheckedTaggedToTaggedPointer(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] Introduce TruncateTaggedToBit operator for ToBoolean truncation. Add a dedicated simplified operator to inline the general case for the ToBoolean conversion. In a follow up CL we will also use the ToBoolean hints gathered by the baseline compiler. CQ_INCLUDE_TRYBOTS=master.tryserver.v8:v8_linux_arm64_gc_stress_dbg R=jarin@chromium.org BUG=v8:5267 Committed: https://crrev.com/8c50b51ab3d21efcd2f6900d83962159f21e1590 Review-Url: https://codereview.chromium.org/2167593002 Cr-Original-Commit-Position: refs/heads/master@{#37882} Cr-Commit-Position: refs/heads/master@{#39420}
2016-09-14 13:12:11 +00:00
ValueEffectControl LowerTruncateTaggedToBit(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] Add the CheckedTruncateTaggedToWord32 opcode. This leads to a better handling of the Smi case when we introduce a checked truncation from a number or oddbal to a 32 bit word, which we were previously doing by concatenating a Smi to float64 conversion with a float64 to word32 truncation. BUG= Review-Url: https://codereview.chromium.org/2191503002 Cr-Commit-Position: refs/heads/master@{#38091}
2016-07-27 11:38:15 +00:00
ValueEffectControl LowerCheckedTruncateTaggedToWord32(Node* node,
Node* frame_state,
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] Introduce a dedicated ArrayBufferWasNeutered operator. Using the dedicated simplified operator we are able to eliminate redundant neuterung checks as long as there is no call in the effect chain. This yields a nice speed up for the Octane Mandreel benchmark (and TypedArray-heavy workloads in general). R=jarin@chromium.org BUG=v8:5267 Review-Url: https://codereview.chromium.org/2279213002 Cr-Commit-Position: refs/heads/master@{#38932}
2016-08-26 08:34:38 +00:00
ValueEffectControl LowerArrayBufferWasNeutered(Node* node, Node* effect,
Node* control);
[turbofan] Add support for String.prototype.charCodeAt/charAt. Introduce an appropriate StringCharCodeAt simplified operator and use that to optimize the String.prototype.charCodeAt/.charAt builtins. R=epertoso@chromium.org Review-Url: https://codereview.chromium.org/2180373005 Cr-Commit-Position: refs/heads/master@{#38106}
2016-07-27 17:26:23 +00:00
ValueEffectControl LowerStringCharCodeAt(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);
Reland "[turbofan] inline %StringIteratorPrototype%.next in JSBuiltinReducer" Reland https://codereview.chromium.org/2373983004/, reverted in 4e5a4d9352e7254b349216075d8dc37bf4ffa217. Reason: CL is not responsible for Win32 Debug failures (see https://build.chromium.org/p/client.v8/builders/V8%20Win32%20-%20debug/builds/5031) ------------------------------------------------------------------------------ Implement the logic for StringIterator.prototype.next in the JSBuiltinReducer in order to allow inlining when the receiver is a JS_STRING_ITERATOR_TYPE map, built ontop of the SimplifiedOperators StringCharCodeAt and the newly added StringFromCodePoint. Also introduces a new StringFromCodePoint simplified op which may be useful for other String builtins, such as String.fromCodePoint() BUG=v8:5388 TBR=bmeurer@chromium.org, mstarzinger@chromium.org Review-Url: https://codereview.chromium.org/2394823003 Cr-Commit-Position: refs/heads/master@{#40008}
2016-10-05 18:45:54 +00:00
ValueEffectControl LowerStringFromCodePoint(Node* node, Node* effect,
Node* control);
[turbofan] Lower StringEqual and friends in EffectControlLinearizer. Turn the StringEqualStub and friends into proper TurboFan builtins, which means that we don't need to do on-demand compilation for those stubs, and use those to defer lowering of the StringEqual, etc. simplified operators to effect/control linearization (i.e. move it to the concurrent recompilation part). BUG=v8:5428 R=jarin@chromium.org Review-Url: https://codereview.chromium.org/2363333003 Cr-Commit-Position: refs/heads/master@{#39762}
2016-09-27 11:24:07 +00:00
ValueEffectControl LowerStringEqual(Node* node, Node* effect, Node* control);
ValueEffectControl LowerStringLessThan(Node* node, Node* effect,
Node* control);
ValueEffectControl LowerStringLessThanOrEqual(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 a dedicated ConvertTaggedHoleToUndefined operator. Separate ConvertTaggedHoleToUndefined and CheckTaggedHole into two separate operators, where the former is pure and just turns into trivial control flow in the EffectControlLinearizer. R=jarin@chromium.org Review-Url: https://codereview.chromium.org/2236443004 Cr-Commit-Position: refs/heads/master@{#38559}
2016-08-10 19:15:28 +00:00
ValueEffectControl LowerConvertTaggedHoleToUndefined(Node* node, 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] Add support for copy-on-write element stores. This extends JSNativeContextSpecialization with support for stores to fast object/smi element backing stores that are marked as copy-on-write. In this case we first call the CopyFixedArray builtin to take a copy of the elements backing store, and then store the new elements back to the object, and finally perform the actual element store. R=epertoso@chromium.org BUG=v8:4470 Committed: https://crrev.com/ac98ad22f049a59c48387f1bab1590f135d219c6 Review-Url: https://codereview.chromium.org/2218703003 Cr-Original-Commit-Position: refs/heads/master@{#38370} Cr-Commit-Position: refs/heads/master@{#38392}
2016-08-05 15:28:52 +00:00
ValueEffectControl LowerEnsureWritableFastElements(Node* node, Node* effect,
Node* control);
[turbofan] Add initial support for growing stores. Introduce a dedicated MaybeGrowFastElements simplified operator, which tries to grow a fast elements backing store for a given element that should be added to an array/object. Use that to lower a growing keyed store to a sequence of 1) check index is a valid array index, 2) check stored value, 3) maybe grow elements backing store (and deoptimize if it would normalize), and 4) store the actual element. The actual growing is done by two dedicated GrowFastDoubleElements and GrowFastSmiOrObjectElements builtins, which are very similar to the GrowArrayElementsStub that is used by Crankshaft. Drive-by-fix: Turn CopyFixedArray into CopyFastSmiOrObjectElements builtin, similar to the new growing builtins, so we don't need to inline the store+write barrier for the elements into all optimized code objects anymore. Also fix a bug in the OperationTyper for NumberSilenceNaN, which was triggered by this change. BUG=v8:5272 Review-Url: https://codereview.chromium.org/2227493002 Cr-Commit-Position: refs/heads/master@{#38418}
2016-08-08 08:43:48 +00:00
ValueEffectControl LowerMaybeGrowFastElements(Node* node, Node* frame_state,
Node* effect, Node* control);
[turbofan] Introduce a TransitionElementsKind simplified operator. Instead of wriring the elements kind transitions into the control flow early on, we do instead put this marker into the effect chain, so that the elements transitions are visible to the LoadElimination and can thus be optimized properly there. This CL itself doesn't add any of those optimizations, but just adds the foundations to make them possible later. R=jarin@chromium.org BUG=v8:4930,v8:5141 Review-Url: https://codereview.chromium.org/2164573003 Cr-Commit-Position: refs/heads/master@{#37869}
2016-07-19 13:38:12 +00:00
ValueEffectControl LowerTransitionElementsKind(Node* node, Node* effect,
Node* control);
[turbofan] Introduce initial support for TypedArrays. This adds support for lowering keyed access to JSTypedArray objects to element loads and stores instead of IC calls. There's still a lot of room for improvement, but the improvements can be done incrementally later. We add a dedicated UnsafePointerAdd operator, which sits in the effect chain, and does the (GC invisible) computation of addresses that are potentially inside HeapObjects. Also there's now a dedicated Retain operator, which ensures that we retain a certain tagged value, which is necessary to ensure that we keep a JSArrayBuffer alive as long as we might still potentially access elements in its backing store. R=epertoso@chromium.org Review-Url: https://codereview.chromium.org/2203693002 Cr-Commit-Position: refs/heads/master@{#38235}
2016-08-02 09:39:15 +00:00
ValueEffectControl LowerLoadTypedElement(Node* node, Node* effect,
Node* control);
ValueEffectControl LowerStoreTypedElement(Node* node, 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] Move lowering of Float64 optional operators to EffectControlLinearizer. It's just a refactoring to avoid introducing new floating controls in the SimplifiedLowering phase. R=bmeurer@chromium.org Review-Url: https://codereview.chromium.org/2215183003 Cr-Commit-Position: refs/heads/master@{#38365}
2016-08-05 10:05:49 +00:00
// Lowering of optional operators.
ValueEffectControl LowerFloat64RoundUp(Node* node, Node* effect,
Node* control);
ValueEffectControl LowerFloat64RoundDown(Node* node, Node* effect,
Node* control);
[turbofan] Add support for accessing Uint8ClampedArrays. This adds a new NumberToUint8Clamped simplified operator that does the round ties to even + clamping necessary to store to Uint8ClampedArrays. BUG=v8:4470,v8:5267,v8:5615 R=jarin@chromium.org Review-Url: https://codereview.chromium.org/2489563004 Cr-Commit-Position: refs/heads/master@{#40861}
2016-11-09 13:33:50 +00:00
ValueEffectControl LowerFloat64RoundTiesEven(Node* node, Node* effect,
Node* control);
[turbofan] Move lowering of Float64 optional operators to EffectControlLinearizer. It's just a refactoring to avoid introducing new floating controls in the SimplifiedLowering phase. R=bmeurer@chromium.org Review-Url: https://codereview.chromium.org/2215183003 Cr-Commit-Position: refs/heads/master@{#38365}
2016-08-05 10:05:49 +00:00
ValueEffectControl LowerFloat64RoundTruncate(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] Don't generate unnecessary minus zero checks. When we do a checked conversion from Tagged or Float64 to Int32, we used to always do a minus zero check, even if we already know that the input cannot be minus zero. Now we actually do the check only if we have evidence that the input might be minus zero. R=epertoso@chromium.org BUG=v8:4583 Review-Url: https://codereview.chromium.org/2202993005 Cr-Commit-Position: refs/heads/master@{#38308}
2016-08-03 16:34:04 +00:00
ValueEffectControl BuildCheckedFloat64ToInt32(CheckForMinusZeroMode mode,
Node* value, Node* frame_state,
[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
Node* effect, Node* control);
[turbofan] Also consume number type feedback for abstract equality. This allows us to consume the type hints gathered by the CompareIC for the abstract equality and inequality operators. We need to distinguish Number and NumberOrOddball feedback now, as abstract equality doesn't truncate null and undefined to Number. R=epertoso@chromium.org BUG=v8:4583 Review-Url: https://codereview.chromium.org/2222983002 Cr-Commit-Position: refs/heads/master@{#38432}
2016-08-08 11:09:44 +00:00
ValueEffectControl BuildCheckedHeapNumberOrOddballToFloat64(
CheckTaggedInputMode mode, Node* value, Node* frame_state, Node* effect,
Node* control);
[turbofan] Add support for accessing Uint8ClampedArrays. This adds a new NumberToUint8Clamped simplified operator that does the round ties to even + clamping necessary to store to Uint8ClampedArrays. BUG=v8:4470,v8:5267,v8:5615 R=jarin@chromium.org Review-Url: https://codereview.chromium.org/2489563004 Cr-Commit-Position: refs/heads/master@{#40861}
2016-11-09 13:33:50 +00:00
ValueEffectControl BuildFloat64RoundDown(Node* value, Node* effect,
Node* control);
[turbofan] Lower StringEqual and friends in EffectControlLinearizer. Turn the StringEqualStub and friends into proper TurboFan builtins, which means that we don't need to do on-demand compilation for those stubs, and use those to defer lowering of the StringEqual, etc. simplified operators to effect/control linearization (i.e. move it to the concurrent recompilation part). BUG=v8:5428 R=jarin@chromium.org Review-Url: https://codereview.chromium.org/2363333003 Cr-Commit-Position: refs/heads/master@{#39762}
2016-09-27 11:24:07 +00:00
ValueEffectControl LowerStringComparison(Callable const& callable, Node* node,
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