Mercurial > hg > graal-compiler

comparison graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/generator/TypeSystemCodeGenerator.java @ 18761:a665483c3881

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Truffle-DSL: new node layout implementation.
author Christian Humer <christian.humer@gmail.com>
date Mon, 29 Dec 2014 23:38:54 +0100
parents 3912400fc33a
children c0fb70634640
comparison
equal deleted inserted replaced
18760:6fa3999631d8 18761:a665483c3881
21 * questions. 21 * questions.
22 */ 22 */
23 package com.oracle.truffle.dsl.processor.generator; 23 package com.oracle.truffle.dsl.processor.generator;
24 24
25 import static com.oracle.truffle.dsl.processor.java.ElementUtils.*; 25 import static com.oracle.truffle.dsl.processor.java.ElementUtils.*;
26 import static com.oracle.truffle.dsl.processor.generator.GeneratorUtils.*;
26 import static javax.lang.model.element.Modifier.*; 27 import static javax.lang.model.element.Modifier.*;
27 28
28 import java.util.*; 29 import java.util.*;
29 30
30 import javax.lang.model.type.*; 31 import javax.lang.model.type.*;
31 32
33 import com.oracle.truffle.api.nodes.*;
32 import com.oracle.truffle.dsl.processor.*; 34 import com.oracle.truffle.dsl.processor.*;
33 import com.oracle.truffle.dsl.processor.java.*; 35 import com.oracle.truffle.dsl.processor.java.*;
34 import com.oracle.truffle.dsl.processor.java.model.*; 36 import com.oracle.truffle.dsl.processor.java.model.*;
35 import com.oracle.truffle.dsl.processor.model.*; 37 import com.oracle.truffle.dsl.processor.model.*;
36 38
38 40
39 public static CodeTree cast(TypeData type, String content) { 41 public static CodeTree cast(TypeData type, String content) {
40 return cast(type, CodeTreeBuilder.singleString(content)); 42 return cast(type, CodeTreeBuilder.singleString(content));
41 } 43 }
42 44
43 public static CodeTree implicitType(TypeData type, String valueName) { 45 public static CodeTree implicitType(TypeData type, CodeTree value) {
44 if (type.isGeneric()) { 46 if (type.isGeneric()) {
45 return CodeTreeBuilder.singleString(valueName); 47 return value;
46 } 48 }
47 CodeTreeBuilder builder = CodeTreeBuilder.createBuilder(); 49 CodeTreeBuilder builder = CodeTreeBuilder.createBuilder();
48 TypeSystemData typeSystem = type.getTypeSystem(); 50 TypeSystemData typeSystem = type.getTypeSystem();
49 builder.startStaticCall(createTypeSystemGen(typeSystem), getImplicitClass(type)).string(valueName); 51 builder.startStaticCall(createTypeSystemGen(typeSystem), getImplicitClass(type)).tree(value);
50 builder.end(); 52 builder.end();
51 return builder.getRoot(); 53 return builder.build();
52 } 54 }
53 55
54 public static CodeTree invokeImplicitCast(ImplicitCastData cast, CodeTree expression) { 56 public static CodeTree invokeImplicitCast(ImplicitCastData cast, CodeTree expression) {
55 CodeTreeBuilder builder = CodeTreeBuilder.createBuilder(); 57 CodeTreeBuilder builder = CodeTreeBuilder.createBuilder();
56 TypeSystemData typeSystem = cast.getTargetType().getTypeSystem(); 58 TypeSystemData typeSystem = cast.getTargetType().getTypeSystem();
57 builder.startStaticCall(createTypeSystemGen(typeSystem), cast.getMethodName()).tree(expression); 59 builder.startStaticCall(createTypeSystemGen(typeSystem), cast.getMethodName()).tree(expression);
58 builder.end(); 60 builder.end();
59 return builder.getRoot(); 61 return builder.build();
60 } 62 }
61 63
62 public static CodeTree implicitCheck(TypeData type, String valueName, String typeHint) { 64 public static CodeTree implicitCheck(TypeData type, CodeTree value, String typeHint) {
63 if (type.isGeneric()) { 65 if (type.isGeneric()) {
64 return CodeTreeBuilder.singleString(valueName); 66 return value;
65 } 67 }
66 CodeTreeBuilder builder = CodeTreeBuilder.createBuilder(); 68 CodeTreeBuilder builder = CodeTreeBuilder.createBuilder();
67 TypeSystemData typeSystem = type.getTypeSystem(); 69 TypeSystemData typeSystem = type.getTypeSystem();
68 builder.startStaticCall(createTypeSystemGen(typeSystem), isImplicitTypeMethodName(type)).string(valueName); 70 builder.startStaticCall(createTypeSystemGen(typeSystem), isImplicitTypeMethodName(type)).tree(value);
69 if (typeHint != null) { 71 if (typeHint != null) {
70 builder.string(typeHint); 72 builder.string(typeHint);
71 } 73 }
72 builder.end(); 74 builder.end();
73 return builder.getRoot(); 75 return builder.build();
74 } 76 }
75 77
76 public static CodeTree implicitCast(TypeData type, String valueName, String typeHint) { 78 public static CodeTree implicitExpect(TypeData type, CodeTree value, String typeHint) {
77 if (type.isGeneric()) { 79 if (type.isGeneric()) {
78 return CodeTreeBuilder.singleString(valueName); 80 return value;
79 } 81 }
80 CodeTreeBuilder builder = CodeTreeBuilder.createBuilder(); 82 CodeTreeBuilder builder = CodeTreeBuilder.createBuilder();
81 TypeSystemData typeSystem = type.getTypeSystem(); 83 TypeSystemData typeSystem = type.getTypeSystem();
82 builder.startStaticCall(createTypeSystemGen(typeSystem), asImplicitTypeMethodName(type)).string(valueName); 84 builder.startStaticCall(createTypeSystemGen(typeSystem), expectImplicitTypeMethodName(type)).tree(value);
83 if (typeHint != null) { 85 if (typeHint != null) {
84 builder.string(typeHint); 86 builder.string(typeHint);
85 } 87 }
86 builder.end(); 88 builder.end();
87 return builder.getRoot(); 89 return builder.build();
90 }
91
92 public static CodeTree implicitCast(TypeData type, CodeTree value, String typeHint) {
93 if (type.isGeneric()) {
94 return value;
95 }
96 CodeTreeBuilder builder = CodeTreeBuilder.createBuilder();
97 TypeSystemData typeSystem = type.getTypeSystem();
98 builder.startStaticCall(createTypeSystemGen(typeSystem), asImplicitTypeMethodName(type)).tree(value);
99 if (typeHint != null) {
100 builder.string(typeHint);
101 }
102 builder.end();
103 return builder.build();
88 } 104 }
89 105
90 public static CodeTree cast(TypeData type, CodeTree content) { 106 public static CodeTree cast(TypeData type, CodeTree content) {
91 if (type.isGeneric()) { 107 if (type.isGeneric()) {
92 return content; 108 return content;
97 if (type.isDefaultCast()) { 113 if (type.isDefaultCast()) {
98 builder.cast(type.getPrimitiveType(), content); 114 builder.cast(type.getPrimitiveType(), content);
99 } else { 115 } else {
100 builder.startStaticCall(typeSystem.getTemplateType().asType(), type.getTypeCasts().get(0).getMethodName()).tree(content).end(); 116 builder.startStaticCall(typeSystem.getTemplateType().asType(), type.getTypeCasts().get(0).getMethodName()).tree(content).end();
101 } 117 }
102 return builder.getRoot(); 118 return builder.build();
103 } 119 }
104 120
105 public static CodeTree expect(TypeData type, CodeTree content) { 121 public static CodeTree expect(TypeData type, CodeTree content) {
106 if (type.isGeneric()) { 122 if (type.isGeneric() || type.isVoid()) {
107 return content; 123 return content;
108 } 124 }
109 CodeTreeBuilder builder = CodeTreeBuilder.createBuilder(); 125 CodeTreeBuilder builder = CodeTreeBuilder.createBuilder();
110 TypeSystemData typeSystem = type.getTypeSystem(); 126 TypeSystemData typeSystem = type.getTypeSystem();
111 builder.startStaticCall(createTypeSystemGen(typeSystem), expectTypeMethodName(type)).tree(content).end(); 127 builder.startStaticCall(createTypeSystemGen(typeSystem), expectTypeMethodName(type)).tree(content).end();
112 return builder.getRoot(); 128 return builder.build();
113 } 129 }
114 130
115 private static CodeTypeMirror createTypeSystemGen(TypeSystemData typeSystem) { 131 public static CodeTree expect(TypeData sourceType, TypeData targetType, CodeTree content) {
132 if (sourceType != null && !sourceType.needsCastTo(targetType)) {
133 return content;
134 } else {
135 return expect(targetType, content);
136 }
137 }
138
139 public static CodeTypeMirror createTypeSystemGen(TypeSystemData typeSystem) {
116 return new GeneratedTypeMirror(ElementUtils.getPackageName(typeSystem.getTemplateType()), typeName(typeSystem)); 140 return new GeneratedTypeMirror(ElementUtils.getPackageName(typeSystem.getTemplateType()), typeName(typeSystem));
117 } 141 }
118 142
119 public static CodeTree check(TypeData type, String content) { 143 public static CodeTree check(TypeData type, String content) {
120 return check(type, CodeTreeBuilder.singleString(content)); 144 return check(type, CodeTreeBuilder.singleString(content));
130 if (type.isDefaultCheck()) { 154 if (type.isDefaultCheck()) {
131 builder.instanceOf(content, type.getBoxedType()); 155 builder.instanceOf(content, type.getBoxedType());
132 } else { 156 } else {
133 builder.startStaticCall(typeSystem.getTemplateType().asType(), type.getTypeChecks().get(0).getMethodName()).tree(content).end(); 157 builder.startStaticCall(typeSystem.getTemplateType().asType(), type.getTypeChecks().get(0).getMethodName()).tree(content).end();
134 } 158 }
135 return builder.getRoot(); 159 return builder.build();
136 } 160 }
137 161
138 public static String isTypeMethodName(TypeData type) { 162 public static String isTypeMethodName(TypeData type) {
139 return "is" + ElementUtils.getTypeId(type.getBoxedType()); 163 return "is" + ElementUtils.getTypeId(type.getBoxedType());
140 } 164 }
147 return "as" + ElementUtils.getTypeId(type.getBoxedType()); 171 return "as" + ElementUtils.getTypeId(type.getBoxedType());
148 } 172 }
149 173
150 static String asImplicitTypeMethodName(TypeData type) { 174 static String asImplicitTypeMethodName(TypeData type) {
151 return "asImplicit" + ElementUtils.getTypeId(type.getBoxedType()); 175 return "asImplicit" + ElementUtils.getTypeId(type.getBoxedType());
176 }
177
178 static String expectImplicitTypeMethodName(TypeData type) {
179 return "expectImplicit" + ElementUtils.getTypeId(type.getBoxedType());
152 } 180 }
153 181
154 static String getImplicitClass(TypeData type) { 182 static String getImplicitClass(TypeData type) {
155 return "getImplicit" + ElementUtils.getTypeId(type.getBoxedType()) + "Class"; 183 return "getImplicit" + ElementUtils.getTypeId(type.getBoxedType()) + "Class";
156 } 184 }
168 return createConstantName(getSimpleName(type.getTemplateType().asType())); 196 return createConstantName(getSimpleName(type.getTemplateType().asType()));
169 } 197 }
170 198
171 @Override 199 @Override
172 public CodeTypeElement create(ProcessorContext context, TypeSystemData typeSystem) { 200 public CodeTypeElement create(ProcessorContext context, TypeSystemData typeSystem) {
173 return new TypeClassFactory(context, typeSystem).create(); 201 CodeTypeElement clazz = new TypeClassFactory(context, typeSystem).create();
202
203 if (typeSystem.getOptions().useNewLayout()) {
204 clazz.add(new TypeSystemNodeFactory(context, typeSystem).create());
205
206 if (typeSystem.getOptions().implicitCastOptimization().isMergeCasts()) {
207 for (TypeData type : typeSystem.getTypes()) {
208 List<TypeData> sourceTypes = typeSystem.lookupSourceTypes(type);
209 if (sourceTypes.size() > 1) {
210 clazz.add(new ImplicitCastNodeFactory(context, type).create());
211 }
212 }
213 }
214 }
215 return clazz;
174 } 216 }
175 217
176 private static class TypeClassFactory { 218 private static class TypeClassFactory {
177 219
178 private static final String LOCAL_VALUE = "value"; 220 private static final String LOCAL_VALUE = "value";
185 this.typeSystem = typeSystem; 227 this.typeSystem = typeSystem;
186 } 228 }
187 229
188 public CodeTypeElement create() { 230 public CodeTypeElement create() {
189 String name = typeName(typeSystem); 231 String name = typeName(typeSystem);
190 CodeTypeElement clazz = GeneratorUtils.createClass(typeSystem, modifiers(PUBLIC, FINAL), name, typeSystem.getTemplateType().asType(), false); 232 CodeTypeElement clazz = GeneratorUtils.createClass(typeSystem, null, modifiers(PUBLIC, FINAL), name, typeSystem.getTemplateType().asType());
191 233
192 clazz.add(GeneratorUtils.createConstructorUsingFields(context, modifiers(PROTECTED), clazz)); 234 clazz.add(GeneratorUtils.createConstructorUsingFields(modifiers(PROTECTED), clazz));
193 CodeVariableElement singleton = createSingleton(clazz); 235 CodeVariableElement singleton = createSingleton(clazz);
194 clazz.add(singleton); 236 clazz.add(singleton);
195 237
196 for (TypeData type : typeSystem.getTypes()) { 238 for (TypeData type : typeSystem.getTypes()) {
197 if (type.isGeneric() || type.isVoid()) { 239 if (type.isVoid() || type.isGeneric()) {
198 continue; 240 continue;
199 } 241 }
242
200 clazz.addOptional(createIsTypeMethod(type)); 243 clazz.addOptional(createIsTypeMethod(type));
201 clazz.addOptional(createAsTypeMethod(type)); 244 clazz.addOptional(createAsTypeMethod(type));
202 245
203 for (TypeData sourceType : collectExpectSourceTypes(type)) { 246 for (TypeData sourceType : collectExpectSourceTypes(type)) {
204 clazz.addOptional(createExpectTypeMethod(type, sourceType)); 247 clazz.addOptional(createExpectTypeMethod(type, sourceType));
205 } 248 }
206 249
207 clazz.addOptional(createAsImplicitTypeMethod(type, true)); 250 if (type.hasImplicitSourceTypes()) {
208 clazz.addOptional(createAsImplicitTypeMethod(type, false)); 251 clazz.add(createAsImplicitTypeMethod(type, false));
209 clazz.addOptional(createIsImplicitTypeMethod(type, true)); 252 if (typeSystem.getOptions().implicitCastOptimization().isNone()) {
210 clazz.addOptional(createIsImplicitTypeMethod(type, false)); 253 clazz.add(createExpectImplicitTypeMethod(type, false));
211 clazz.addOptional(createGetTypeIndex(type)); 254 }
255 clazz.add(createIsImplicitTypeMethod(type, false));
256
257 if (typeSystem.getOptions().implicitCastOptimization().isDuplicateTail()) {
258 clazz.add(createAsImplicitTypeMethod(type, true));
259 clazz.add(createExpectImplicitTypeMethod(type, true));
260 clazz.add(createIsImplicitTypeMethod(type, true));
261 clazz.add(createGetImplicitClass(type));
262 }
263 }
212 } 264 }
213 265
214 return clazz; 266 return clazz;
215 } 267 }
216 268
236 288
237 return field; 289 return field;
238 } 290 }
239 291
240 private CodeExecutableElement createIsImplicitTypeMethod(TypeData type, boolean typed) { 292 private CodeExecutableElement createIsImplicitTypeMethod(TypeData type, boolean typed) {
241 List<ImplicitCastData> casts = typeSystem.lookupByTargetType(type);
242 if (casts.isEmpty()) {
243 return null;
244 }
245 CodeExecutableElement method = new CodeExecutableElement(modifiers(PUBLIC, STATIC), context.getType(boolean.class), TypeSystemCodeGenerator.isImplicitTypeMethodName(type)); 293 CodeExecutableElement method = new CodeExecutableElement(modifiers(PUBLIC, STATIC), context.getType(boolean.class), TypeSystemCodeGenerator.isImplicitTypeMethodName(type));
246 method.addParameter(new CodeVariableElement(context.getType(Object.class), LOCAL_VALUE)); 294 method.addParameter(new CodeVariableElement(context.getType(Object.class), LOCAL_VALUE));
247 if (typed) { 295 if (typed) {
248 method.addParameter(new CodeVariableElement(context.getType(Class.class), "typeHint")); 296 method.addParameter(new CodeVariableElement(context.getType(Class.class), "typeHint"));
249 } 297 }
273 builder.end(); 321 builder.end();
274 builder.end(); 322 builder.end();
275 return method; 323 return method;
276 } 324 }
277 325
278 private CodeExecutableElement createAsImplicitTypeMethod(TypeData type, boolean typed) { 326 private CodeExecutableElement createAsImplicitTypeMethod(TypeData type, boolean useTypeHint) {
279 List<ImplicitCastData> casts = typeSystem.lookupByTargetType(type); 327 String name = asImplicitTypeMethodName(type);
280 if (casts.isEmpty()) { 328 CodeExecutableElement method = new CodeExecutableElement(modifiers(PUBLIC, STATIC), type.getPrimitiveType(), name);
281 return null; 329 method.addParameter(new CodeVariableElement(context.getType(Object.class), LOCAL_VALUE));
282 } 330 if (useTypeHint) {
283 CodeExecutableElement method = new CodeExecutableElement(modifiers(PUBLIC, STATIC), type.getPrimitiveType(), TypeSystemCodeGenerator.asImplicitTypeMethodName(type));
284 method.addParameter(new CodeVariableElement(context.getType(Object.class), LOCAL_VALUE));
285 if (typed) {
286 method.addParameter(new CodeVariableElement(context.getType(Class.class), "typeHint")); 331 method.addParameter(new CodeVariableElement(context.getType(Class.class), "typeHint"));
287 } 332 }
288 333
289 List<TypeData> sourceTypes = typeSystem.lookupSourceTypes(type); 334 List<TypeData> sourceTypes = typeSystem.lookupSourceTypes(type);
290 335
291 CodeTreeBuilder builder = method.createBuilder(); 336 CodeTreeBuilder builder = method.createBuilder();
292 boolean elseIf = false; 337 boolean elseIf = false;
293 for (TypeData sourceType : sourceTypes) { 338 for (TypeData sourceType : sourceTypes) {
294 elseIf = builder.startIf(elseIf); 339 elseIf = builder.startIf(elseIf);
295 if (typed) { 340 if (useTypeHint) {
296 builder.string("typeHint == ").typeLiteral(sourceType.getPrimitiveType()); 341 builder.string("typeHint == ").typeLiteral(sourceType.getPrimitiveType());
297 } else { 342 } else {
298 builder.tree(check(sourceType, LOCAL_VALUE)); 343 builder.tree(check(sourceType, LOCAL_VALUE));
299 } 344 }
300 345
312 builder.end(); 357 builder.end();
313 builder.end(); 358 builder.end();
314 } 359 }
315 360
316 builder.startElseBlock(); 361 builder.startElseBlock();
317 builder.startStatement().startStaticCall(context.getTruffleTypes().getCompilerDirectives(), "transferToInterpreterAndInvalidate").end().end(); 362 builder.tree(createTransferToInterpreterAndInvalidate());
318 builder.startThrow().startNew(context.getType(IllegalArgumentException.class)).doubleQuote("Illegal type ").end().end(); 363 builder.startThrow().startNew(context.getType(IllegalArgumentException.class)).doubleQuote("Illegal type ").end().end();
319 builder.end(); 364 builder.end();
320 return method; 365 return method;
321 } 366 }
322 367
323 private CodeExecutableElement createGetTypeIndex(TypeData type) { 368 private CodeExecutableElement createExpectImplicitTypeMethod(TypeData type, boolean useTypeHint) {
324 List<ImplicitCastData> casts = typeSystem.lookupByTargetType(type); 369 String name = expectImplicitTypeMethodName(type);
325 if (casts.isEmpty()) { 370 CodeExecutableElement method = new CodeExecutableElement(modifiers(PUBLIC, STATIC), type.getPrimitiveType(), name);
326 return null; 371 method.addParameter(new CodeVariableElement(context.getType(Object.class), LOCAL_VALUE));
327 } 372 if (useTypeHint) {
373 method.addParameter(new CodeVariableElement(context.getType(Class.class), "typeHint"));
374 }
375 method.getThrownTypes().add(context.getType(UnexpectedResultException.class));
376
377 List<TypeData> sourceTypes = typeSystem.lookupSourceTypes(type);
378
379 CodeTreeBuilder builder = method.createBuilder();
380 boolean elseIf = false;
381 for (TypeData sourceType : sourceTypes) {
382 elseIf = builder.startIf(elseIf);
383 if (useTypeHint) {
384 builder.string("typeHint == ").typeLiteral(sourceType.getPrimitiveType());
385 builder.string(" && ");
386 }
387 builder.tree(check(sourceType, LOCAL_VALUE));
388
389 builder.end().startBlock();
390
391 builder.startReturn();
392 ImplicitCastData cast = typeSystem.lookupCast(sourceType, type);
393 if (cast != null) {
394 builder.startCall(cast.getMethodName());
395 }
396 builder.tree(cast(sourceType, LOCAL_VALUE)).end();
397 if (cast != null) {
398 builder.end();
399 }
400 builder.end();
401 builder.end();
402 }
403
404 builder.startElseBlock();
405 builder.startThrow().startNew(context.getType(UnexpectedResultException.class)).string(LOCAL_VALUE).end().end();
406 builder.end();
407 return method;
408 }
409
410 private CodeExecutableElement createGetImplicitClass(TypeData type) {
328 CodeExecutableElement method = new CodeExecutableElement(modifiers(PUBLIC, STATIC), context.getType(Class.class), TypeSystemCodeGenerator.getImplicitClass(type)); 411 CodeExecutableElement method = new CodeExecutableElement(modifiers(PUBLIC, STATIC), context.getType(Class.class), TypeSystemCodeGenerator.getImplicitClass(type));
329 method.addParameter(new CodeVariableElement(context.getType(Object.class), LOCAL_VALUE)); 412 method.addParameter(new CodeVariableElement(context.getType(Object.class), LOCAL_VALUE));
330 413
331 List<TypeData> sourceTypes = typeSystem.lookupSourceTypes(type); 414 List<TypeData> sourceTypes = typeSystem.lookupSourceTypes(type);
332 CodeTreeBuilder builder = method.createBuilder(); 415 CodeTreeBuilder builder = method.createBuilder();
338 builder.startReturn().typeLiteral(sourceType.getPrimitiveType()).end(); 421 builder.startReturn().typeLiteral(sourceType.getPrimitiveType()).end();
339 builder.end(); 422 builder.end();
340 } 423 }
341 424
342 builder.startElseBlock(); 425 builder.startElseBlock();
343 builder.startStatement().startStaticCall(context.getTruffleTypes().getCompilerDirectives(), "transferToInterpreterAndInvalidate").end().end(); 426 builder.tree(createTransferToInterpreterAndInvalidate());
344 builder.startThrow().startNew(context.getType(IllegalArgumentException.class)).doubleQuote("Illegal type ").end().end(); 427 builder.startThrow().startNew(context.getType(IllegalArgumentException.class)).doubleQuote("Illegal type ").end().end();
345 builder.end(); 428 builder.end();
346 429
347 return method; 430 return method;
348 } 431 }