Mercurial > hg > graal-jvmci-8

comparison graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/generator/NodeBaseFactory.java @ 18758:3912400fc33a

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Truffle-DSL: remove type system singleton
author Christian Humer <christian.humer@gmail.com>
date Mon, 29 Dec 2014 23:38:42 +0100
parents 59bf50cc5a32
children a665483c3881
comparison
equal deleted inserted replaced
18757:0ec5f5a2e720 18758:3912400fc33a
929 } 929 }
930 return false; 930 return false;
931 } 931 }
932 932
933 private CodeTree createTypeGuard(CodeTreeBuilder parent, NodeExecutionData execution, Parameter source, TypeData targetType, boolean typedCasts) { 933 private CodeTree createTypeGuard(CodeTreeBuilder parent, NodeExecutionData execution, Parameter source, TypeData targetType, boolean typedCasts) {
934 NodeData childNode = execution.getChild().getNodeData();
935
936 CodeTreeBuilder builder = new CodeTreeBuilder(parent); 934 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
937 935
938 TypeData sourceType = source.getTypeSystemType(); 936 TypeData sourceType = source.getTypeSystemType();
939 937
940 if (!sourceType.needsCastTo(targetType)) { 938 if (!sourceType.needsCastTo(targetType)) {
949 builder.string("("); 947 builder.string("(");
950 builder.string("!").string(valueName(shortCircuit)); 948 builder.string("!").string(valueName(shortCircuit));
951 builder.string(" || "); 949 builder.string(" || ");
952 } 950 }
953 951
954 String castMethodName;
955 String castTypeName = null;
956 List<TypeData> types = getSpecialization().getNode().getTypeSystem().lookupSourceTypes(targetType); 952 List<TypeData> types = getSpecialization().getNode().getTypeSystem().lookupSourceTypes(targetType);
957 if (types.size() > 1) { 953 if (types.size() > 1) {
958 castMethodName = TypeSystemCodeGenerator.isImplicitTypeMethodName(targetType); 954 String castTypeName = null;
959 if (typedCasts) { 955 if (typedCasts) {
960 castTypeName = implicitTypeName(source); 956 castTypeName = implicitTypeName(source);
961 } 957 }
958 CodeTree check;
959 if (castTypeName == null) {
960 check = TypeSystemCodeGenerator.implicitCheck(targetType, valueName(source), null);
961 } else {
962 check = TypeSystemCodeGenerator.implicitCheck(targetType, valueName(source), castTypeName);
963 }
964 builder.tree(check);
962 } else { 965 } else {
963 castMethodName = TypeSystemCodeGenerator.isTypeMethodName(targetType); 966 builder.tree(TypeSystemCodeGenerator.check(targetType, valueName(source)));
964 } 967 }
965
966 startCallTypeSystemMethod(builder, childNode.getTypeSystem(), castMethodName);
967 builder.string(valueName(source));
968 if (castTypeName != null) {
969 builder.string(castTypeName);
970 }
971 builder.end().end(); // call
972 968
973 if (execution.isShortCircuit()) { 969 if (execution.isShortCircuit()) {
974 builder.string(")"); 970 builder.string(")");
975 } 971 }
976 972
979 return builder.getRoot(); 975 return builder.getRoot();
980 } 976 }
981 977
982 // TODO merge redundancies with #createTypeGuard 978 // TODO merge redundancies with #createTypeGuard
983 private CodeTree createCast(CodeTreeBuilder parent, NodeExecutionData execution, Parameter source, TypeData targetType, boolean typedCasts) { 979 private CodeTree createCast(CodeTreeBuilder parent, NodeExecutionData execution, Parameter source, TypeData targetType, boolean typedCasts) {
984 NodeData childNode = execution.getChild().getNodeData();
985 TypeData sourceType = source.getTypeSystemType(); 980 TypeData sourceType = source.getTypeSystemType();
986 981
987 if (!sourceType.needsCastTo(targetType)) { 982 if (!sourceType.needsCastTo(targetType)) {
988 return null; 983 return null;
989 } 984 }
993 Parameter shortCircuit = source.getPreviousParameter(); 988 Parameter shortCircuit = source.getPreviousParameter();
994 assert shortCircuit != null; 989 assert shortCircuit != null;
995 condition = CodeTreeBuilder.singleString(valueName(shortCircuit)); 990 condition = CodeTreeBuilder.singleString(valueName(shortCircuit));
996 } 991 }
997 992
998 String castMethodName; 993 CodeTree cast;
999 String castTypeName = null;
1000 List<TypeData> types = getSpecialization().getNode().getTypeSystem().lookupSourceTypes(targetType); 994 List<TypeData> types = getSpecialization().getNode().getTypeSystem().lookupSourceTypes(targetType);
1001 if (types.size() > 1) { 995 if (types.size() > 1) {
1002 castMethodName = TypeSystemCodeGenerator.asImplicitTypeMethodName(targetType); 996 String castTypeName = null;
1003 if (typedCasts) { 997 if (typedCasts) {
1004 castTypeName = implicitTypeName(source); 998 castTypeName = implicitTypeName(source);
1005 } 999 }
1000 cast = TypeSystemCodeGenerator.implicitCast(targetType, valueName(source), castTypeName);
1006 } else { 1001 } else {
1007 castMethodName = TypeSystemCodeGenerator.asTypeMethodName(targetType); 1002 cast = TypeSystemCodeGenerator.cast(targetType, valueName(source));
1008 } 1003 }
1009
1010 List<CodeTree> args = new ArrayList<>();
1011 args.add(CodeTreeBuilder.singleString(valueName(source)));
1012 if (castTypeName != null) {
1013 args.add(CodeTreeBuilder.singleString(castTypeName));
1014 }
1015
1016 CodeTree cast = createCallTypeSystemMethod(parent, childNode, castMethodName, args.toArray(new CodeTree[0]));
1017 1004
1018 CodeTreeBuilder builder = parent.create(); 1005 CodeTreeBuilder builder = parent.create();
1019 builder.tree(createLazyAssignment(parent, castValueName(source), targetType.getPrimitiveType(), condition, cast)); 1006 builder.tree(createLazyAssignment(parent, castValueName(source), targetType.getPrimitiveType(), condition, cast));
1020 1007
1021 return builder.getRoot(); 1008 return builder.getRoot();
1030 } 1017 }
1031 1018
1032 CodeTreeBuilder builder = parent.create(); 1019 CodeTreeBuilder builder = parent.create();
1033 List<TypeData> types = getSpecialization().getNode().getTypeSystem().lookupSourceTypes(targetType); 1020 List<TypeData> types = getSpecialization().getNode().getTypeSystem().lookupSourceTypes(targetType);
1034 if (types.size() > 1) { 1021 if (types.size() > 1) {
1035 CodeTree castType = createCallTypeSystemMethod(parent, execution.getChild().getNodeData(), TypeSystemCodeGenerator.getImplicitClass(targetType), 1022 CodeTree castType = TypeSystemCodeGenerator.implicitType(targetType, valueName(source));
1036 CodeTreeBuilder.singleString(valueName(source)));
1037 builder.tree(createLazyAssignment(builder, implicitTypeName(source), context.getType(Class.class), condition, castType)); 1023 builder.tree(createLazyAssignment(builder, implicitTypeName(source), context.getType(Class.class), condition, castType));
1038 } 1024 }
1039 return builder.getRoot(); 1025 return builder.getRoot();
1040 } 1026 }
1041 1027
1125 builder.end().startCatchBlock(getUnexpectedValueException(), "ex"); 1111 builder.end().startCatchBlock(getUnexpectedValueException(), "ex");
1126 if (returnVoid) { 1112 if (returnVoid) {
1127 builder.string("// ignore").newLine(); 1113 builder.string("// ignore").newLine();
1128 } else { 1114 } else {
1129 builder.startReturn(); 1115 builder.startReturn();
1130 builder.tree(createExpectExecutableType(node, specialization.getNode().getTypeSystem().getGenericTypeData(), hasUnexpected, executable.getType(), 1116 builder.tree(createExpectExecutableType(specialization.getNode().getTypeSystem().getGenericTypeData(), hasUnexpected, executable.getType(),
1131 CodeTreeBuilder.singleString("ex.getResult()"))); 1117 CodeTreeBuilder.singleString("ex.getResult()")));
1132 builder.end(); 1118 builder.end();
1133 } 1119 }
1134 builder.end(); 1120 builder.end();
1135 1121
1136 if (!returnVoid) { 1122 if (!returnVoid) {
1137 builder.startReturn(); 1123 builder.startReturn();
1138 builder.tree(createExpectExecutableType(node, castExecutable.getReturnType().getTypeSystemType(), hasUnexpected, executable.getType(), CodeTreeBuilder.singleString("value"))); 1124 builder.tree(createExpectExecutableType(castExecutable.getReturnType().getTypeSystemType(), hasUnexpected, executable.getType(), CodeTreeBuilder.singleString("value")));
1139 builder.end(); 1125 builder.end();
1140 } 1126 }
1141 } else { 1127 } else {
1142 if (returnVoid) { 1128 if (returnVoid) {
1143 builder.statement(primaryExecuteCall); 1129 builder.statement(primaryExecuteCall);
1144 } else { 1130 } else {
1145 builder.startReturn(); 1131 builder.startReturn();
1146 builder.tree(createExpectExecutableType(node, castExecutable.getReturnType().getTypeSystemType(), hasUnexpected, executable.getType(), primaryExecuteCall)); 1132 builder.tree(createExpectExecutableType(castExecutable.getReturnType().getTypeSystemType(), hasUnexpected, executable.getType(), primaryExecuteCall));
1147 builder.end(); 1133 builder.end();
1148 } 1134 }
1149 } 1135 }
1150 1136
1151 return builder.getRoot(); 1137 return builder.getRoot();
1152 } 1138 }
1153 1139
1154 private static CodeTree createExpectExecutableType(NodeData node, TypeData sourceType, boolean hasUnexpected, TypeData exepctedType, CodeTree value) { 1140 private static CodeTree createExpectExecutableType(TypeData sourceType, boolean hasUnexpected, TypeData exepctedType, CodeTree value) {
1155 return createCastType(node.getTypeSystem(), sourceType, exepctedType, hasUnexpected, value); 1141 return createCastType(sourceType, exepctedType, hasUnexpected, value);
1156 } 1142 }
1157 1143
1158 protected CodeTree createExecuteChildren(CodeTreeBuilder parent, ExecutableTypeData sourceExecutable, SpecializationData currentSpecialization, List<Parameter> targetParameters, 1144 protected CodeTree createExecuteChildren(CodeTreeBuilder parent, ExecutableTypeData sourceExecutable, SpecializationData currentSpecialization, List<Parameter> targetParameters,
1159 Parameter unexpectedParameter) { 1145 Parameter unexpectedParameter) {
1160 CodeTreeBuilder builder = parent.create(); 1146 CodeTreeBuilder builder = parent.create();
1397 } else { 1383 } else {
1398 expression = CodeTreeBuilder.singleString(valueNameEvaluated(targetParameter)); 1384 expression = CodeTreeBuilder.singleString(valueNameEvaluated(targetParameter));
1399 } 1385 }
1400 1386
1401 // target = expectTargetType(implicitCast(expectCastSourceType(source))) 1387 // target = expectTargetType(implicitCast(expectCastSourceType(source)))
1402 TypeSystemData typeSystem = execution.getChild().getNodeData().getTypeSystem(); 1388 expression = createExpectType(sourceType, castSourceType, expression);
1403 expression = createExpectType(typeSystem, sourceType, castSourceType, expression); 1389 expression = createImplicitCast(cast, expression);
1404 expression = createImplicitCast(parent, typeSystem, cast, expression); 1390 expression = createExpectType(castTargetType, targetType, expression);
1405 expression = createExpectType(typeSystem, castTargetType, targetType, expression);
1406 1391
1407 CodeTreeBuilder builder = parent.create(); 1392 CodeTreeBuilder builder = parent.create();
1408 builder.string(valueName(targetParameter)); 1393 builder.string(valueName(targetParameter));
1409 builder.string(" = "); 1394 builder.string(" = ");
1410 builder.tree(expression); 1395 builder.tree(expression);
1411 return builder.getRoot(); 1396 return builder.getRoot();
1412 } 1397 }
1413 1398
1414 private static CodeTree createImplicitCast(CodeTreeBuilder parent, TypeSystemData typeSystem, ImplicitCastData cast, CodeTree expression) { 1399 private static CodeTree createImplicitCast(ImplicitCastData cast, CodeTree expression) {
1415 if (cast == null) { 1400 if (cast == null) {
1416 return expression; 1401 return expression;
1417 } 1402 }
1418 CodeTreeBuilder builder = parent.create(); 1403 return TypeSystemCodeGenerator.invokeImplicitCast(cast, expression);
1419 startCallTypeSystemMethod(builder, typeSystem, cast.getMethodName());
1420 builder.tree(expression);
1421 builder.end().end();
1422 return builder.getRoot();
1423 } 1404 }
1424 1405
1425 private boolean containsNewLine(CodeTree tree) { 1406 private boolean containsNewLine(CodeTree tree) {
1426 if (tree.getCodeKind() == CodeTreeKind.NEW_LINE) { 1407 if (tree.getCodeKind() == CodeTreeKind.NEW_LINE) {
1427 return true; 1408 return true;
1538 addInternalValueParameterNames(execute, currentSpecialization, polymorphic, param.getLocalName(), true, false, null); 1519 addInternalValueParameterNames(execute, currentSpecialization, polymorphic, param.getLocalName(), true, false, null);
1539 execute.end(); 1520 execute.end();
1540 1521
1541 TypeData sourceType = polymorphic.getReturnType().getTypeSystemType(); 1522 TypeData sourceType = polymorphic.getReturnType().getTypeSystemType();
1542 1523
1543 builder.tree(createExpectExecutableType(node, sourceType, currentExecutable.hasUnexpectedValue(context), currentExecutable.getType(), execute.getRoot())); 1524 builder.tree(createExpectExecutableType(sourceType, currentExecutable.hasUnexpectedValue(context), currentExecutable.getType(), execute.getRoot()));
1544 1525
1545 builder.end(); 1526 builder.end();
1546 return builder.getRoot(); 1527 return builder.getRoot();
1547 } 1528 }
1548 1529
1586 } 1567 }
1587 1568
1588 CodeTree value = CodeTreeBuilder.singleString(localName); 1569 CodeTree value = CodeTreeBuilder.singleString(localName);
1589 1570
1590 if (sourceType.needsCastTo(targetType)) { 1571 if (sourceType.needsCastTo(targetType)) {
1591 value = createCallTypeSystemMethod(builder, getSpecialization().getNode(), TypeSystemCodeGenerator.asTypeMethodName(targetType), value); 1572 value = TypeSystemCodeGenerator.cast(targetType, value);
1592 } 1573 }
1593 builder.tree(value); 1574 builder.tree(value);
1594 } else { 1575 } else {
1595 builder.defaultValue(parameter.getType()); 1576 builder.defaultValue(parameter.getType());
1596 } 1577 }
1655 specializeCall.end().end(); 1636 specializeCall.end().end();
1656 1637
1657 CodeTreeBuilder builder = new CodeTreeBuilder(parent); 1638 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
1658 1639
1659 builder.startReturn(); 1640 builder.startReturn();
1660 builder.tree(createExpectExecutableType(node, generic.getReturnType().getTypeSystemType(), hasUnexpected, returnType, specializeCall.getRoot())); 1641 builder.tree(createExpectExecutableType(generic.getReturnType().getTypeSystemType(), hasUnexpected, returnType, specializeCall.getRoot()));
1661 builder.end(); 1642 builder.end();
1662 1643
1663 return builder.getRoot(); 1644 return builder.getRoot();
1664 } 1645 }
1665 1646
1850 public static String baseClassName(NodeData node) { 1831 public static String baseClassName(NodeData node) {
1851 String nodeid = resolveNodeId(node); 1832 String nodeid = resolveNodeId(node);
1852 String name = ElementUtils.firstLetterUpperCase(nodeid); 1833 String name = ElementUtils.firstLetterUpperCase(nodeid);
1853 name += "NodeGen"; 1834 name += "NodeGen";
1854 return name; 1835 return name;
1855 }
1856
1857 static CodeTree createCallTypeSystemMethod(CodeTreeBuilder parent, NodeData node, String methodName, CodeTree... args) {
1858 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
1859 startCallTypeSystemMethod(builder, node.getTypeSystem(), methodName);
1860 for (CodeTree arg : args) {
1861 builder.tree(arg);
1862 }
1863 builder.end().end();
1864 return builder.getRoot();
1865 }
1866
1867 private static void startCallTypeSystemMethod(CodeTreeBuilder body, TypeSystemData typeSystem, String methodName) {
1868 GeneratedTypeMirror typeMirror = new GeneratedTypeMirror(ElementUtils.getPackageName(typeSystem.getTemplateType()), TypeSystemCodeGenerator.typeName(typeSystem));
1869 body.startGroup();
1870 body.staticReference(typeMirror, TypeSystemCodeGenerator.singletonName(typeSystem));
1871 body.string(".").startCall(methodName);
1872 } 1836 }
1873 1837
1874 /** 1838 /**
1875 * <pre> 1839 * <pre>
1876 * variant1 $condition != null 1840 * variant1 $condition != null
1970 nodeid = nodeid.substring(0, nodeid.length() - 4); 1934 nodeid = nodeid.substring(0, nodeid.length() - 4);
1971 } 1935 }
1972 return nodeid; 1936 return nodeid;
1973 } 1937 }
1974 1938
1975 private static CodeTree createCastType(TypeSystemData typeSystem, TypeData sourceType, TypeData targetType, boolean expect, CodeTree value) { 1939 private static CodeTree createCastType(TypeData sourceType, TypeData targetType, boolean expect, CodeTree value) {
1976 if (targetType == null) { 1940 if (targetType == null) {
1977 return value; 1941 return value;
1978 } else if (sourceType != null && !sourceType.needsCastTo(targetType)) { 1942 } else if (sourceType != null && !sourceType.needsCastTo(targetType)) {
1979 return value; 1943 return value;
1980 } 1944 }
1981 1945
1982 CodeTreeBuilder builder = CodeTreeBuilder.createBuilder();
1983 String targetMethodName;
1984 if (expect) { 1946 if (expect) {
1985 targetMethodName = TypeSystemCodeGenerator.expectTypeMethodName(targetType); 1947 return TypeSystemCodeGenerator.expect(targetType, value);
1986 } else { 1948 } else {
1987 targetMethodName = TypeSystemCodeGenerator.asTypeMethodName(targetType); 1949 return TypeSystemCodeGenerator.cast(targetType, value);
1988 } 1950 }
1989 startCallTypeSystemMethod(builder, typeSystem, targetMethodName); 1951 }
1990 builder.tree(value); 1952
1991 builder.end().end(); 1953 private static CodeTree createExpectType(TypeData sourceType, TypeData targetType, CodeTree expression) {
1992 return builder.getRoot(); 1954 return createCastType(sourceType, targetType, true, expression);
1993 }
1994
1995 private static CodeTree createExpectType(TypeSystemData typeSystem, TypeData sourceType, TypeData targetType, CodeTree expression) {
1996 return createCastType(typeSystem, sourceType, targetType, true, expression);
1997 } 1955 }
1998 1956
1999 static CodeTree createDeoptimize(CodeTreeBuilder parent) { 1957 static CodeTree createDeoptimize(CodeTreeBuilder parent) {
2000 CodeTreeBuilder builder = new CodeTreeBuilder(parent); 1958 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
2001 builder.startStatement(); 1959 builder.startStatement();