Mercurial > hg > graal-compiler

comparison graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/node/SpecializationGroup.java @ 11442:2868b55001d4

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Truffle-DSL: fixed specializationg grouping failed with guards using base types.
author Christian Humer <christian.humer@gmail.com>
date Wed, 28 Aug 2013 01:45:13 +0200
parents 7fc3e1fb3965
children b33783cbd8ce
comparison
equal deleted inserted replaced
11441:fc509b6fbfdf 11442:2868b55001d4
22 */ 22 */
23 package com.oracle.truffle.dsl.processor.node; 23 package com.oracle.truffle.dsl.processor.node;
24 24
25 import java.util.*; 25 import java.util.*;
26 26
27 import javax.lang.model.type.*;
28
29 import com.oracle.truffle.dsl.processor.*;
30 import com.oracle.truffle.dsl.processor.template.*;
27 import com.oracle.truffle.dsl.processor.template.TemplateMethod.Signature; 31 import com.oracle.truffle.dsl.processor.template.TemplateMethod.Signature;
28 import com.oracle.truffle.dsl.processor.typesystem.*; 32 import com.oracle.truffle.dsl.processor.typesystem.*;
29 33
30 /** 34 /**
31 * Class creates groups of specializations to optimize the layout of generated executeAndSpecialize 35 * Class creates groups of specializations to optimize the layout of generated executeAndSpecialize
62 this.guards = guardMatches; 66 this.guards = guardMatches;
63 this.specialization = null; 67 this.specialization = null;
64 updateChildren(children); 68 updateChildren(children);
65 } 69 }
66 70
71 public List<TypeGuard> getAllGuards() {
72 List<TypeGuard> collectedGuards = new ArrayList<>();
73 collectedGuards.addAll(typeGuards);
74 if (parent != null) {
75 collectedGuards.addAll(parent.getAllGuards());
76 }
77 return collectedGuards;
78 }
79
67 public TypeGuard findTypeGuard(int signatureIndex) { 80 public TypeGuard findTypeGuard(int signatureIndex) {
68 for (TypeGuard guard : typeGuards) { 81 for (TypeGuard guard : typeGuards) {
69 if (guard.getSignatureIndex() == signatureIndex) { 82 if (guard.getSignatureIndex() == signatureIndex) {
70 return guard; 83 return guard;
71 } 84 }
72 } 85 }
73 return null; 86 return null;
74 } 87 }
75 88
76 public GuardData getElseConnectableGuard() { 89 public List<GuardData> getElseConnectableGuards() {
77 if (!getTypeGuards().isEmpty() || !getAssumptions().isEmpty()) { 90 if (!getTypeGuards().isEmpty() || !getAssumptions().isEmpty()) {
78 return null; 91 return Collections.emptyList();
79 } 92 }
80 SpecializationGroup previousGroup = getPreviousGroup(); 93
81 if (previousGroup != null && getGuards().size() >= 1 && previousGroup.getGuards().size() == 1) { 94 if (getGuards().isEmpty()) {
82 GuardData guard = getGuards().get(0); 95 return Collections.emptyList();
83 GuardData previousGuard = previousGroup.getGuards().get(0); 96 }
84 97
98 List<GuardData> elseConnectableGuards = new ArrayList<>();
99 int guardIndex = 0;
100 while (guardIndex < getGuards().size() && findNegatedGuardInPrevious(getGuards().get(guardIndex)) != null) {
101 elseConnectableGuards.add(getGuards().get(guardIndex));
102 guardIndex++;
103 }
104
105 return elseConnectableGuards;
106 }
107
108 private GuardData findNegatedGuardInPrevious(GuardData guard) {
109 SpecializationGroup previous = this;
110 while ((previous = previous.getPreviousGroup()) != null) {
111 List<GuardData> elseConnectedGuards = previous.getElseConnectableGuards();
112
113 if (previous == null || previous.getGuards().size() != elseConnectedGuards.size() + 1) {
114 return null;
115 }
116 GuardData previousGuard = previous.getGuards().get(elseConnectedGuards.size());
85 if (guard.getMethod().equals(previousGuard.getMethod())) { 117 if (guard.getMethod().equals(previousGuard.getMethod())) {
86 assert guard.isNegated() != previousGuard.isNegated(); 118 assert guard.isNegated() != previousGuard.isNegated();
87 return guard; 119 return guard;
88 } 120 }
89 } 121 }
167 } 199 }
168 } 200 }
169 guardMatches.add(guard); 201 guardMatches.add(guard);
170 } 202 }
171 203
204 // check for guards for required type casts
205 for (Iterator<GuardData> iterator = guardMatches.iterator(); iterator.hasNext();) {
206 GuardData guardMatch = iterator.next();
207
208 List<TypeMirror> guardTypes = TemplateMethod.getSignatureTypes(guardMatch.getParameters());
209 for (int i = 0; i < guardTypes.size(); i++) {
210 TypeMirror guardType = guardTypes.get(i);
211 int signatureIndex = i + 1;
212
213 // object guards can be safely moved up
214 if (Utils.isObject(guardType)) {
215 continue;
216 }
217
218 // signature index required for moving up guards
219 if (containsIndex(typeGuardsMatches, signatureIndex) || (first.getParent() != null && first.getParent().containsTypeGuardIndex(signatureIndex))) {
220 continue;
221 }
222
223 iterator.remove();
224 break;
225 }
226 }
227
172 if (assumptionMatches.isEmpty() && typeGuardsMatches.isEmpty() && guardMatches.isEmpty()) { 228 if (assumptionMatches.isEmpty() && typeGuardsMatches.isEmpty() && guardMatches.isEmpty()) {
173 return null; 229 return null;
174 } 230 }
175 231
176 for (SpecializationGroup group : groups) { 232 for (SpecializationGroup group : groups) {
179 group.guards.removeAll(guardMatches); 235 group.guards.removeAll(guardMatches);
180 } 236 }
181 237
182 List<SpecializationGroup> newChildren = new ArrayList<>(groups); 238 List<SpecializationGroup> newChildren = new ArrayList<>(groups);
183 return new SpecializationGroup(newChildren, assumptionMatches, typeGuardsMatches, guardMatches); 239 return new SpecializationGroup(newChildren, assumptionMatches, typeGuardsMatches, guardMatches);
240 }
241
242 private boolean containsTypeGuardIndex(int index) {
243 if (containsIndex(typeGuards, index)) {
244 return true;
245 }
246 if (parent != null) {
247 return parent.containsTypeGuardIndex(index);
248 }
249 return false;
250 }
251
252 private static boolean containsIndex(List<TypeGuard> typeGuards, int signatureIndex) {
253 for (TypeGuard guard : typeGuards) {
254 if (guard.signatureIndex == signatureIndex) {
255 return true;
256 }
257 }
258 return false;
184 } 259 }
185 260
186 public static SpecializationGroup create(List<SpecializationData> specializations) { 261 public static SpecializationGroup create(List<SpecializationData> specializations) {
187 List<SpecializationGroup> groups = new ArrayList<>(); 262 List<SpecializationGroup> groups = new ArrayList<>();
188 for (SpecializationData specialization : specializations) { 263 for (SpecializationData specialization : specializations) {