Lines Matching refs:node
10 #include "src/compiler/node-properties.h"
20 bool IsRename(Node* node) {
21 switch (node->opcode()) {
25 return !node->IsDead();
31 Node* ResolveRenames(Node* node) {
32 while (IsRename(node)) {
33 node = node->InputAt(0);
35 return node;
74 Reduction LoadElimination::Reduce(Node* node) {
76 if (node->op()->EffectInputCount() > 0) {
77 PrintF(" visit #%d:%s", node->id(), node->op()->mnemonic());
78 if (node->op()->ValueInputCount() > 0) {
80 for (int i = 0; i < node->op()->ValueInputCount(); ++i) {
82 Node* const value = NodeProperties::GetValueInput(node, i);
88 for (int i = 0; i < node->op()->EffectInputCount(); ++i) {
89 Node* const effect = NodeProperties::GetEffectInput(node, i);
101 switch (node->opcode()) {
103 return ReduceMapGuard(node);
105 return ReduceCheckMaps(node);
107 return ReduceCompareMaps(node);
109 return ReduceEnsureWritableFastElements(node);
111 return ReduceMaybeGrowFastElements(node);
113 return ReduceTransitionElementsKind(node);
115 return ReduceLoadField(node, FieldAccessOf(node->op()));
117 return ReduceStoreField(node, FieldAccessOf(node->op()));
119 return ReduceLoadElement(node);
121 return ReduceStoreElement(node);
123 return ReduceTransitionAndStoreElement(node);
125 return ReduceStoreTypedElement(node);
127 return ReduceEffectPhi(node);
131 return ReduceStart(node);
133 return ReduceOtherNode(node);
291 // 'object', we might not have done it on the same node; e.g. we might now
292 // identify the object by a FinishRegion node, whereas the initial const
293 // store was performed on the Allocate node. We therefore remove information
679 // an Allocate node instead of a FinishRegion node), we know that {other}
680 // can only alias with {object} if they refer to exactly the same node.
684 // Decide aliasing based on the node kinds.
725 LoadElimination::AbstractStateForEffectNodes::Get(Node* node) const {
726 size_t const id = node->id();
732 Node* node, AbstractState const* state) {
733 size_t const id = node->id();
738 Reduction LoadElimination::ReduceMapGuard(Node* node) {
739 ZoneHandleSet<Map> const& maps = MapGuardMapsOf(node->op());
740 Node* const object = NodeProperties::GetValueInput(node, 0);
741 Node* const effect = NodeProperties::GetEffectInput(node);
750 return UpdateState(node, state);
753 Reduction LoadElimination::ReduceCheckMaps(Node* node) {
754 ZoneHandleSet<Map> const& maps = CheckMapsParametersOf(node->op()).maps();
755 Node* const object = NodeProperties::GetValueInput(node, 0);
756 Node* const effect = NodeProperties::GetEffectInput(node);
765 return UpdateState(node, state);
768 Reduction LoadElimination::ReduceCompareMaps(Node* node) {
769 ZoneHandleSet<Map> const& maps = CompareMapsParametersOf(node->op());
770 Node* const object = NodeProperties::GetValueInput(node, 0);
771 Node* const effect = NodeProperties::GetEffectInput(node);
778 ReplaceWithValue(node, value, effect);
783 return UpdateState(node, state);
786 Reduction LoadElimination::ReduceEnsureWritableFastElements(Node* node) {
787 Node* const object = NodeProperties::GetValueInput(node, 0);
788 Node* const elements = NodeProperties::GetValueInput(node, 1);
789 Node* const effect = NodeProperties::GetEffectInput(node);
797 ReplaceWithValue(node, elements, effect);
801 state = state->SetMaps(node, fixed_array_maps, zone());
809 {node, MachineRepresentation::kTaggedPointer}, zone());
810 return UpdateState(node, state);
813 Reduction LoadElimination::ReduceMaybeGrowFastElements(Node* node) {
814 GrowFastElementsParameters params = GrowFastElementsParametersOf(node->op());
815 Node* const object = NodeProperties::GetValueInput(node, 0);
816 Node* const effect = NodeProperties::GetEffectInput(node);
822 node, ZoneHandleSet<Map>(factory()->fixed_double_array_map()), zone());
828 state = state->SetMaps(node, fixed_array_maps, zone());
837 {node, MachineRepresentation::kTaggedPointer}, zone());
838 return UpdateState(node, state);
841 Reduction LoadElimination::ReduceTransitionElementsKind(Node* node) {
842 ElementsTransition transition = ElementsTransitionOf(node->op());
843 Node* const object = NodeProperties::GetValueInput(node, 0);
846 Node* const effect = NodeProperties::GetEffectInput(node);
864 // {node} is fully redundant (independent of what {source_map} is).
878 return UpdateState(node, state);
881 Reduction LoadElimination::ReduceTransitionAndStoreElement(Node* node) {
882 Node* const object = NodeProperties::GetValueInput(node, 0);
883 Handle<Map> double_map(DoubleMapParameterOf(node->op()));
884 Handle<Map> fast_map(FastMapParameterOf(node->op()));
885 Node* const effect = NodeProperties::GetEffectInput(node);
903 return UpdateState(node, state);
906 Reduction LoadElimination::ReduceLoadField(Node* node,
908 Node* object = NodeProperties::GetValueInput(node, 0);
909 Node* effect = NodeProperties::GetEffectInput(node);
910 Node* control = NodeProperties::GetControlInput(node);
920 ReplaceWithValue(node, value, effect);
942 // Introduce a TypeGuard if the type of the {replacement} node is not
943 // a subtype of the original {node}'s type.
945 .Is(NodeProperties::GetType(node))) {
947 NodeProperties::GetType(node),
954 ReplaceWithValue(node, replacement, effect);
958 FieldInfo info(node, representation, access.name,
965 state = state->SetMaps(node, ZoneHandleSet<Map>(field_map), zone());
967 return UpdateState(node, state);
970 Reduction LoadElimination::ReduceStoreField(Node* node,
972 Node* const object = NodeProperties::GetValueInput(node, 0);
973 Node* const new_value = NodeProperties::GetValueInput(node, 1);
974 Node* const effect = NodeProperties::GetEffectInput(node);
1017 Node* control = NodeProperties::GetControlInput(node);
1051 return UpdateState(node, state);
1054 Reduction LoadElimination::ReduceLoadElement(Node* node) {
1055 Node* const object = NodeProperties::GetValueInput(node, 0);
1056 Node* const index = NodeProperties::GetValueInput(node, 1);
1057 Node* const effect = NodeProperties::GetEffectInput(node);
1062 ElementAccess const& access = ElementAccessOf(node->op());
1085 // Skip lowering if the type of the {replacement} node is not a subtype
1086 // of the original {node}'s type.
1091 .Is(NodeProperties::GetType(node))) {
1092 ReplaceWithValue(node, replacement, effect);
1096 state = state->AddElement(object, index, node,
1098 return UpdateState(node, state);
1103 Reduction LoadElimination::ReduceStoreElement(Node* node) {
1104 ElementAccess const& access = ElementAccessOf(node->op());
1105 Node* const object = NodeProperties::GetValueInput(node, 0);
1106 Node* const index = NodeProperties::GetValueInput(node, 1);
1107 Node* const new_value = NodeProperties::GetValueInput(node, 2);
1108 Node* const effect = NodeProperties::GetEffectInput(node);
1143 return UpdateState(node, state);
1146 Reduction LoadElimination::ReduceStoreTypedElement(Node* node) {
1147 Node* const effect = NodeProperties::GetEffectInput(node);
1150 return UpdateState(node, state);
1174 Reduction LoadElimination::ReduceEffectPhi(Node* node) {
1175 Node* const effect0 = NodeProperties::GetEffectInput(node, 0);
1176 Node* const control = NodeProperties::GetControlInput(node);
1183 AbstractState const* state = ComputeLoopState(node, state0);
1184 return UpdateState(node, state);
1189 int const input_count = node->op()->EffectInputCount();
1191 Node* const effect = NodeProperties::GetEffectInput(node, i);
1199 Node* const input = NodeProperties::GetEffectInput(node, i);
1208 state_with_phis = UpdateStateForPhi(state_with_phis, node, use);
1212 return UpdateState(node, state_with_phis);
1215 Reduction LoadElimination::ReduceStart(Node* node) {
1216 return UpdateState(node, empty_state());
1219 Reduction LoadElimination::ReduceOtherNode(Node* node) {
1220 if (node->op()->EffectInputCount() == 1) {
1221 if (node->op()->EffectOutputCount() == 1) {
1222 Node* const effect = NodeProperties::GetEffectInput(node);
1228 // Check if this {node} has some uncontrolled side effects.
1229 if (!node->op()->HasProperty(Operator::kNoWrite)) {
1232 return UpdateState(node, state);
1238 DCHECK_EQ(0, node->op()->EffectInputCount());
1239 DCHECK_EQ(0, node->op()->EffectOutputCount());
1243 Reduction LoadElimination::UpdateState(Node* node, AbstractState const* state) {
1244 AbstractState const* original = node_states_.Get(node);
1245 // Only signal that the {node} has Changed, if the information about {state}
1249 node_states_.Set(node, state);
1250 return Changed(node);
1276 Node* node, AbstractState const* state) const {
1277 Node* const control = NodeProperties::GetControlInput(node);
1288 visited.insert(node);
1290 queue.push(node->InputAt(i));