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

167 lines
6.7 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"
[turbofan] Introduce graph assembler to build effect-control-linearizer sub-graphs. Review-Url: https://codereview.chromium.org/2571903004 Cr-Commit-Position: refs/heads/master@{#42013}
2017-01-02 15:50:55 +00:00
#include "src/compiler/graph-assembler.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
#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;
[turbofan] track source positions in EffectControlLinearizer R=jarin@chromium.org BUG= Review-Url: https://codereview.chromium.org/2504913003 Cr-Commit-Position: refs/heads/master@{#41040}
2016-11-16 15:06:05 +00:00
class SourcePositionTable;
[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
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:
[turbofan] track source positions in EffectControlLinearizer R=jarin@chromium.org BUG= Review-Url: https://codereview.chromium.org/2504913003 Cr-Commit-Position: refs/heads/master@{#41040}
2016-11-16 15:06:05 +00:00
EffectControlLinearizer(JSGraph* graph, Schedule* schedule, Zone* temp_zone,
SourcePositionTable* source_positions);
[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
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
[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] Introduce graph assembler to build effect-control-linearizer sub-graphs. Review-Url: https://codereview.chromium.org/2571903004 Cr-Commit-Position: refs/heads/master@{#42013}
2017-01-02 15:50:55 +00:00
Node* LowerChangeBitToTagged(Node* node);
Node* LowerChangeInt31ToTaggedSigned(Node* node);
Node* LowerChangeInt32ToTagged(Node* node);
Node* LowerChangeUint32ToTagged(Node* node);
Node* LowerChangeFloat64ToTagged(Node* node);
Node* LowerChangeFloat64ToTaggedPointer(Node* node);
Node* LowerChangeTaggedSignedToInt32(Node* node);
Node* LowerChangeTaggedToBit(Node* node);
Node* LowerChangeTaggedToInt32(Node* node);
Node* LowerChangeTaggedToUint32(Node* node);
[turbofan] Introduce ChangeTaggedToTaggedSigned operator. We were missing a case for Tagged->TaggedSigned conversions when the input type is known to be Type::SignedSmall. BUG=chromium:687029 R=jarin@chromium.org Review-Url: https://codereview.chromium.org/2666863002 Cr-Commit-Position: refs/heads/master@{#42809}
2017-01-31 08:55:56 +00:00
Node* LowerChangeTaggedToTaggedSigned(Node* node);
[turbofan] Introduce graph assembler to build effect-control-linearizer sub-graphs. Review-Url: https://codereview.chromium.org/2571903004 Cr-Commit-Position: refs/heads/master@{#42013}
2017-01-02 15:50:55 +00:00
Node* LowerCheckBounds(Node* node, Node* frame_state);
Node* LowerCheckInternalizedString(Node* node, Node* frame_state);
Node* LowerCheckMaps(Node* node, Node* frame_state);
Node* LowerCheckNumber(Node* node, Node* frame_state);
[turbofan] Add Receiver feedback for abstract/strict equality. Collect Receiver feedback for abstract/strict equality in Ignition and use it in TurboFan to optimize JSEqual and JSStrictEqual operations to pointer equality instead of having to call Equal/StrictEqual builtins. R=jarin@chromium.org BUG=v8:5267,v8:5400 Review-Url: https://codereview.chromium.org/2639883002 Cr-Commit-Position: refs/heads/master@{#42435}
2017-01-18 07:10:51 +00:00
Node* LowerCheckReceiver(Node* node, Node* frame_state);
[turbofan] Introduce graph assembler to build effect-control-linearizer sub-graphs. Review-Url: https://codereview.chromium.org/2571903004 Cr-Commit-Position: refs/heads/master@{#42013}
2017-01-02 15:50:55 +00:00
Node* LowerCheckString(Node* node, Node* frame_state);
[turbofan] Add Symbol feedback to Equal/StrictEqual. Introduce a new Symbol comparison feedback bit in the lattice and collect that feedback on Equal/StrictEqual in Ignition. Utilize this feedback in TurboFan by adding a dedicated CheckSymbol operator to check for symbol inputs. This way we can optimize Symbol comparison where TurboFan doesn't know anything statically about either side, or abstract equality comparisons where TurboFan doesn't statically know anything about one side. BUG=v8:6278,v8:6344,v8:6423 R=jarin@chromium.org Review-Url: https://codereview.chromium.org/2893263002 Cr-Commit-Position: refs/heads/master@{#45455}
2017-05-22 12:07:40 +00:00
Node* LowerCheckSymbol(Node* node, Node* frame_state);
[turbofan] Introduce graph assembler to build effect-control-linearizer sub-graphs. Review-Url: https://codereview.chromium.org/2571903004 Cr-Commit-Position: refs/heads/master@{#42013}
2017-01-02 15:50:55 +00:00
Node* LowerCheckIf(Node* node, Node* frame_state);
Node* LowerCheckedInt32Add(Node* node, Node* frame_state);
Node* LowerCheckedInt32Sub(Node* node, Node* frame_state);
Node* LowerCheckedInt32Div(Node* node, Node* frame_state);
Node* LowerCheckedInt32Mod(Node* node, Node* frame_state);
Node* LowerCheckedUint32Div(Node* node, Node* frame_state);
Node* LowerCheckedUint32Mod(Node* node, Node* frame_state);
Node* LowerCheckedInt32Mul(Node* node, Node* frame_state);
Node* LowerCheckedInt32ToTaggedSigned(Node* node, Node* frame_state);
Node* LowerCheckedUint32ToInt32(Node* node, Node* frame_state);
Node* LowerCheckedUint32ToTaggedSigned(Node* node, Node* frame_state);
Node* LowerCheckedFloat64ToInt32(Node* node, Node* frame_state);
Node* LowerCheckedTaggedSignedToInt32(Node* node, Node* frame_state);
Node* LowerCheckedTaggedToInt32(Node* node, Node* frame_state);
Node* LowerCheckedTaggedToFloat64(Node* node, Node* frame_state);
Node* LowerCheckedTaggedToTaggedSigned(Node* node, Node* frame_state);
Node* LowerCheckedTaggedToTaggedPointer(Node* node, Node* frame_state);
Node* LowerChangeTaggedToFloat64(Node* node);
Node* LowerTruncateTaggedToBit(Node* node);
[turbofan] Introduce TruncateTaggedPointerToBit operator. Oftentimes we can avoid the Smi check for ToBoolean truncations, since we already know that the input is always going to be a HeapObject. So introduce a dedicated TruncateTaggedPointerToBit operator, which uses the fact that the input is known to be a HeapObject. BUG=v8:5267 R=jarin@chromium.org Review-Url: https://codereview.chromium.org/2738483002 Cr-Commit-Position: refs/heads/master@{#43629}
2017-03-07 10:11:16 +00:00
Node* LowerTruncateTaggedPointerToBit(Node* node);
[turbofan] Introduce graph assembler to build effect-control-linearizer sub-graphs. Review-Url: https://codereview.chromium.org/2571903004 Cr-Commit-Position: refs/heads/master@{#42013}
2017-01-02 15:50:55 +00:00
Node* LowerTruncateTaggedToFloat64(Node* node);
Node* LowerTruncateTaggedToWord32(Node* node);
Node* LowerCheckedTruncateTaggedToWord32(Node* node, Node* frame_state);
Fix typeof optimization for undetectable Currently, typeof o, where o is an undetectable callable object (such as document.all), returns 'function' if optimised. It should, however, return 'undefined'. This CL excludes undetectable objects from the optimization resulting in type 'function' and renames the related code to reflect that. BUG=v8:5972 R=bmeurer@chromium.org Review-Url: https://codereview.chromium.org/2697063002 Cr-Commit-Position: refs/heads/master@{#43298}
2017-02-18 12:43:37 +00:00
Node* LowerObjectIsDetectableCallable(Node* node);
[turbofan] Introduce dedicated ObjectIsNaN operator. We can compile a !== a and Number.isNaN(a) to ObjectIsNaN. The former is commonly used to check for NaN, i.e. in case of equals in AngularJS. R=jarin@chromium.org BUG=v8:5267 Review-Url: https://codereview.chromium.org/2722483003 Cr-Commit-Position: refs/heads/master@{#43572}
2017-03-03 09:08:14 +00:00
Node* LowerObjectIsNaN(Node* node);
[turbofan] Optimize typeof o === "object" checks. Properly recognize and optimize typeof in a strict/abstract equality comparison with the string literal "object" to a check for Null or a check of the map for Receiver instance type and non-callable. Drive-by-fix: Also optimize typeof o === "function" somewhat, now that we have the new types for Callable and NonCallable. R=jarin@chromium.org BUG=v8:5267 Review-Url: https://codereview.chromium.org/2646763003 Cr-Commit-Position: refs/heads/master@{#42501}
2017-01-19 13:16:27 +00:00
Node* LowerObjectIsNonCallable(Node* node);
[turbofan] Introduce graph assembler to build effect-control-linearizer sub-graphs. Review-Url: https://codereview.chromium.org/2571903004 Cr-Commit-Position: refs/heads/master@{#42013}
2017-01-02 15:50:55 +00:00
Node* LowerObjectIsNumber(Node* node);
Node* LowerObjectIsReceiver(Node* node);
Node* LowerObjectIsSmi(Node* node);
Node* LowerObjectIsString(Node* node);
[TurboFan] Add ObjectIsSymbol simplified operator. Used by ReduceJSEqualTypeOf, and will also be used to lower a new TestTypeof bytecode in a followup CL. BUG=v8:5267 Change-Id: I990aa6ac8ac0b9bd01080dda1764c5bfe3a4d7cf Reviewed-on: https://chromium-review.googlesource.com/454797 Reviewed-by: Benedikt Meurer <bmeurer@chromium.org> Commit-Queue: Ross McIlroy <rmcilroy@chromium.org> Cr-Commit-Position: refs/heads/master@{#43802}
2017-03-14 16:14:58 +00:00
Node* LowerObjectIsSymbol(Node* node);
[turbofan] Introduce graph assembler to build effect-control-linearizer sub-graphs. Review-Url: https://codereview.chromium.org/2571903004 Cr-Commit-Position: refs/heads/master@{#42013}
2017-01-02 15:50:55 +00:00
Node* LowerObjectIsUndetectable(Node* node);
[turbofan] escape analysis supports arguments object and rest elements The new NewUnmappedArgumentsElements node now takes two inputs: - the frame holding the arguments (current frame or arguments adaptor frame) - the length of the suffix of passed arguments to be copied into the backing store These inputs are computed with two new node types: ArgumentsFrame() ArgumentsLength[formal_parameter_count,is_rest_length](Node* arguments_frame) The node type NewRestParameterElements can now be expressed with NewUnmappedArgumentsElements and an appropriate length and is thus not needed anymore. In escape analysis, we lower loads from the length field of NewUnmappedArgumentsElements with its length input and if we find out that no write access to the arguments elements exists, we replace element loads with direct stack access and replace the NewUnmappedArgumentsElements node with a node of the new node type ArgumentsElementsState. This corresponds to an ObjectState node and gets translated into a deoptimizer instruction to allocate the backing store. Together with the already existing deoptimizer support for the actual arguments object/rest parameters, this allows to remove all allocations for arguments objects/rest parameters in this case. In the deoptimizer, we read the actual parameters from the stack while transforming the static deopt info into TranslatedValue objects. If escape analysis cannot remove the backing store allocation, NewUnmappedArgumentsElements gets lo BUG=v8:5726 Review-Url: https://codereview.chromium.org/2692753004 Cr-Commit-Position: refs/heads/master@{#43475}
2017-02-28 11:16:27 +00:00
Node* LowerArgumentsFrame(Node* node);
Node* LowerArgumentsLength(Node* node);
[turbofan] Introduce graph assembler to build effect-control-linearizer sub-graphs. Review-Url: https://codereview.chromium.org/2571903004 Cr-Commit-Position: refs/heads/master@{#42013}
2017-01-02 15:50:55 +00:00
Node* LowerNewUnmappedArgumentsElements(Node* node);
Node* LowerArrayBufferWasNeutered(Node* node);
Node* LowerStringCharAt(Node* node);
Node* LowerStringCharCodeAt(Node* node);
Node* LowerStringFromCharCode(Node* node);
Node* LowerStringFromCodePoint(Node* node);
[turbofan] Introduce dedicated StringIndexOf operator. The StringIndexOf operation is pure on the JS level, but the actual stub call must be in the effect chain later so that the Scheduler doesn't place it inside some allocation region (The %StringIndexOf runtime function may trigger a GC for string flattening). BUG=chromium:685580 R=jarin@chromium.org Review-Url: https://codereview.chromium.org/2657243002 Cr-Commit-Position: refs/heads/master@{#42736}
2017-01-27 12:02:42 +00:00
Node* LowerStringIndexOf(Node* node);
[turbofan] Introduce graph assembler to build effect-control-linearizer sub-graphs. Review-Url: https://codereview.chromium.org/2571903004 Cr-Commit-Position: refs/heads/master@{#42013}
2017-01-02 15:50:55 +00:00
Node* LowerStringEqual(Node* node);
Node* LowerStringLessThan(Node* node);
Node* LowerStringLessThanOrEqual(Node* node);
Node* LowerCheckFloat64Hole(Node* node, Node* frame_state);
Node* LowerCheckTaggedHole(Node* node, Node* frame_state);
Node* LowerConvertTaggedHoleToUndefined(Node* node);
Node* LowerPlainPrimitiveToNumber(Node* node);
Node* LowerPlainPrimitiveToWord32(Node* node);
Node* LowerPlainPrimitiveToFloat64(Node* node);
Node* LowerEnsureWritableFastElements(Node* node);
Node* LowerMaybeGrowFastElements(Node* node, Node* frame_state);
void LowerTransitionElementsKind(Node* node);
Node* LowerLoadTypedElement(Node* node);
void LowerStoreTypedElement(Node* node);
[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.
[turbofan] Introduce graph assembler to build effect-control-linearizer sub-graphs. Review-Url: https://codereview.chromium.org/2571903004 Cr-Commit-Position: refs/heads/master@{#42013}
2017-01-02 15:50:55 +00:00
Maybe<Node*> LowerFloat64RoundUp(Node* node);
Maybe<Node*> LowerFloat64RoundDown(Node* node);
Maybe<Node*> LowerFloat64RoundTiesEven(Node* node);
Maybe<Node*> LowerFloat64RoundTruncate(Node* node);
Node* AllocateHeapNumberWithValue(Node* node);
Node* BuildCheckedFloat64ToInt32(CheckForMinusZeroMode mode, Node* value,
Node* frame_state);
Node* BuildCheckedHeapNumberOrOddballToFloat64(CheckTaggedInputMode mode,
Node* value,
Node* frame_state);
Node* BuildFloat64RoundDown(Node* value);
Node* LowerStringComparison(Callable const& callable, Node* node);
[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);
[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 graph assembler to build effect-control-linearizer sub-graphs. Review-Url: https://codereview.chromium.org/2571903004 Cr-Commit-Position: refs/heads/master@{#42013}
2017-01-02 15:50:55 +00:00
GraphAssembler* gasm() { return &graph_assembler_; }
[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
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] track source positions in EffectControlLinearizer R=jarin@chromium.org BUG= Review-Url: https://codereview.chromium.org/2504913003 Cr-Commit-Position: refs/heads/master@{#41040}
2016-11-16 15:06:05 +00:00
SourcePositionTable* source_positions_;
[turbofan] Introduce graph assembler to build effect-control-linearizer sub-graphs. Review-Url: https://codereview.chromium.org/2571903004 Cr-Commit-Position: refs/heads/master@{#42013}
2017-01-02 15:50:55 +00:00
GraphAssembler graph_assembler_;
[compiler] Add instrumentation for tracking down Node::New crashes. R=jarin@chromium.org BUG=chromium:713584 Review-Url: https://codereview.chromium.org/2833783002 Cr-Commit-Position: refs/heads/master@{#44748}
2017-04-20 14:27:57 +00:00
Node* frame_state_zapper_; // For tracking down compiler::Node::New crashes.
[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