graal-compiler: graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/node/NodeCodeGenerator.java comparison

comparison graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/node/NodeCodeGenerator.java @ 11201:7fc3e1fb3965

Truffle-DSL: specialization group fixes.

author	Christian Humer <christian.humer@gmail.com>
date	Mon, 05 Aug 2013 19:50:34 +0200
parents	3479ab380552
children	80de3bbfa8b9

comparison

equal deleted inserted replaced

-:380e0248f873
+:7fc3e1fb3965
 import com.oracle.truffle.api.nodes.*;
 import com.oracle.truffle.dsl.processor.*;
 import com.oracle.truffle.dsl.processor.ast.*;
 import com.oracle.truffle.dsl.processor.node.NodeChildData.Cardinality;
 import com.oracle.truffle.dsl.processor.node.NodeChildData.ExecutionKind;
+import com.oracle.truffle.dsl.processor.node.SpecializationGroup.TypeGuard;
 import com.oracle.truffle.dsl.processor.template.*;
 import com.oracle.truffle.dsl.processor.template.TemplateMethod.Signature;
 import com.oracle.truffle.dsl.processor.typesystem.*;
 public class NodeCodeGenerator extends CompilationUnitFactory<NodeData> {
 @Override
 protected void createChildren(SpecializationData specialization) {
 NodeData node = specialization.getNode();
 CodeTypeElement clazz = getElement();
+SpecializationGroup rootGroup = createSpecializationGroups(node);
 if (node.needsRewrites(context)) {
 if (node.isPolymorphic()) {
 CodeVariableElement var = new CodeVariableElement(modifiers(PROTECTED), clazz.asType(), "next0");
 var.getAnnotationMirrors().add(new CodeAnnotationMirror(getContext().getTruffleTypes().getChildAnnotation()));
 clazz.add(var);
 }
 clazz.add(createCachedExecute(node, polymorph, genericCachedExecute));
 }
 }
-clazz.add(createGenericExecuteAndSpecialize(node));
+clazz.add(createGenericExecuteAndSpecialize(node, rootGroup));
 clazz.add(createInfoMessage(node));
 }
 if (node.getGenericSpecialization() != null && node.getGenericSpecialization().isReachable()) {
-clazz.add(createGenericExecute(node));
+clazz.add(createGenericExecute(node, rootGroup));
 }
 }
 private CodeTree truffleBooleanOption(CodeTreeBuilder parent, String name) {
 CodeTreeBuilder builder = parent.create();
 var.getAnnotationMirrors().add(new CodeAnnotationMirror(annotationType));
 return var;
 }
-private CodeExecutableElement createGenericExecuteAndSpecialize(final NodeData node) {
+private CodeExecutableElement createGenericExecuteAndSpecialize(final NodeData node, SpecializationGroup rootGroup) {
 TypeMirror genericReturnType = node.getGenericSpecialization().getReturnType().getType();
 CodeExecutableElement method = new CodeExecutableElement(modifiers(PROTECTED), genericReturnType, EXECUTE_SPECIALIZE_NAME);
 method.addParameter(new CodeVariableElement(getContext().getType(int.class), "minimumState"));
 addInternalValueParameters(method, node.getGenericSpecialization(), true, false);
 method.addParameter(new CodeVariableElement(getContext().getType(String.class), "reason"));
 builder.startStatement().string("String message = ").startCall("createInfo0").string("reason");
 addInternalValueParameterNames(builder, node.getGenericSpecialization(), node.getGenericSpecialization(), null, false, true);
 builder.end().end();
+final String currentNodeVar = currentNode;
+builder.tree(createExecuteTree(builder, node.getGenericSpecialization(), rootGroup, true, new CodeBlock<SpecializationData>() {
+public CodeTree create(CodeTreeBuilder b, SpecializationData current) {
+return createGenericInvokeAndSpecialize(b, node.getGenericSpecialization(), current, currentNodeVar);
+}
+}));
+boolean firstUnreachable = true;
+for (SpecializationData current : node.getSpecializations()) {
+if (current.isUninitialized() || current.isReachable()) {
+continue;
+}
+if (firstUnreachable) {
+emitEncounteredSynthetic(builder, current);
+firstUnreachable = false;
+}
+}
+emitUnreachableSpecializations(builder, node);
+return method;
+}
+private SpecializationGroup createSpecializationGroups(final NodeData node) {
 List<SpecializationData> specializations = node.getSpecializations();
 List<SpecializationData> filteredSpecializations = new ArrayList<>();
 for (SpecializationData current : specializations) {
 if (current.isUninitialized() || !current.isReachable()) {
 continue;
 }
 filteredSpecializations.add(current);
 }
-List<SpecializationGroup> groups = SpecializationGroup.create(filteredSpecializations);
+return SpecializationGroup.create(filteredSpecializations);
+}
-final String currentNodeVar = currentNode;
-for (SpecializationGroup group : groups) {
+private CodeExecutableElement createGenericExecute(NodeData node, SpecializationGroup group) {
-builder.tree(createExecuteTree(builder, node.getGenericSpecialization(), group, true, new CodeBlock<SpecializationData>() {
+TypeMirror genericReturnType = node.getGenericSpecialization().getReturnType().getType();
+CodeExecutableElement method = new CodeExecutableElement(modifiers(PROTECTED), genericReturnType, EXECUTE_GENERIC_NAME);
-public CodeTree create(CodeTreeBuilder b, SpecializationData current) {
-return createGenericInvokeAndSpecialize(b, node.getGenericSpecialization(), current, currentNodeVar);
+method.getAnnotationMirrors().add(new CodeAnnotationMirror(getContext().getTruffleTypes().getSlowPath()));
-}
-}));
+addInternalValueParameters(method, node.getGenericSpecialization(), node.needsFrame(), false);
-}
+final CodeTreeBuilder builder = method.createBuilder();
-boolean firstUnreachable = true;
+builder.tree(createExecuteTree(builder, node.getGenericSpecialization(), group, false, new CodeBlock<SpecializationData>() {
-for (SpecializationData current : specializations) {
+public CodeTree create(CodeTreeBuilder b, SpecializationData current) {
+return createGenericInvoke(builder, current.getNode().getGenericSpecialization(), current);
+}
+}));
+emitUnreachableSpecializations(builder, node);
+return method;
+}
+private void emitUnreachableSpecializations(final CodeTreeBuilder builder, NodeData node) {
+for (SpecializationData current : node.getSpecializations()) {
 if (current.isUninitialized() || current.isReachable()) {
 continue;
 }
-if (firstUnreachable) {
-emitEncounteredSynthetic(builder, current);
-firstUnreachable = false;
-}
 builder.string("// unreachable ").string(current.getId()).newLine();
 }
-return method;
-}
-private CodeExecutableElement createGenericExecute(NodeData node) {
-TypeMirror genericReturnType = node.getGenericSpecialization().getReturnType().getType();
-CodeExecutableElement method = new CodeExecutableElement(modifiers(PROTECTED), genericReturnType, EXECUTE_GENERIC_NAME);
-method.getAnnotationMirrors().add(new CodeAnnotationMirror(getContext().getTruffleTypes().getSlowPath()));
-addInternalValueParameters(method, node.getGenericSpecialization(), node.needsFrame(), false);
-final CodeTreeBuilder builder = method.createBuilder();
-List<SpecializationData> specializations = node.getSpecializations();
-List<SpecializationData> filteredSpecializations = new ArrayList<>();
-for (SpecializationData current : specializations) {
-if (current.isUninitialized() || !current.isReachable()) {
-continue;
-}
-filteredSpecializations.add(current);
-}
-List<SpecializationGroup> groups = SpecializationGroup.create(filteredSpecializations);
-for (SpecializationGroup group : groups) {
-builder.tree(createExecuteTree(builder, node.getGenericSpecialization(), group, false, new CodeBlock<SpecializationData>() {
-public CodeTree create(CodeTreeBuilder b, SpecializationData current) {
-return createGenericInvoke(builder, current.getNode().getGenericSpecialization(), current);
-}
-}));
-}
-for (SpecializationData current : specializations) {
-if (current.isUninitialized() || current.isReachable()) {
-continue;
-}
-builder.string("// unreachable ").string(current.getId()).newLine();
-}
-return method;
 }
 private CodeTree createExecuteTree(CodeTreeBuilder outerParent, final SpecializationData source, final SpecializationGroup group, final boolean checkMinimumState,
 final CodeBlock<SpecializationData> guardedblock) {
 return guard(outerParent, source, group, checkMinimumState, new CodeBlock<Void>() {
 }
 });
 }
 private CodeTree guard(CodeTreeBuilder parent, SpecializationData source, SpecializationGroup group, boolean checkMinimumState, CodeBlock<Void> bodyBlock) {
+CodeTreeBuilder builder = parent.create();
+int ifCount = emitGuards(builder, source, group, checkMinimumState);
+if (isReachableGroup(group, ifCount, checkMinimumState)) {
+builder.tree(bodyBlock.create(builder, null));
+}
+builder.end(ifCount);
+return builder.getRoot();
+}
+private boolean isReachableGroup(SpecializationGroup group, int ifCount, boolean checkMinimumState) {
+if (ifCount != 0) {
+return true;
+}
+SpecializationGroup previous = group.getPreviousGroup();
+if (previous == null || previous.getElseConnectableGuard() == null) {
+return true;
+}
+/*
+* Hacky else case. In this case the specialization is not reachable due to previous
+* else branch. This is only true if the minimum state is not checked.
+*/
+if (previous.getGuards().size() == 1 && previous.getTypeGuards().isEmpty() && previous.getAssumptions().isEmpty() && !checkMinimumState &&
+(previous.getParent() == null || previous.getMaxSpecializationIndex() != previous.getParent().getMaxSpecializationIndex())) {
+return false;
+}
+return true;
+}
+private int emitGuards(CodeTreeBuilder builder, SpecializationData source, SpecializationGroup group, boolean checkMinimumState) {
 NodeData node = source.getNode();
-CodeTreeBuilder guardsBuilder = parent.create();
+CodeTreeBuilder guardsBuilder = builder.create();
-CodeTreeBuilder castBuilder = parent.create();
+CodeTreeBuilder castBuilder = builder.create();
-CodeTreeBuilder guardsCastBuilder = parent.create();
+CodeTreeBuilder guardsCastBuilder = builder.create();
 String guardsAnd = "";
 String guardsCastAnd = "";
+GuardData elseGuard = group.getElseConnectableGuard();
 boolean minimumState = checkMinimumState;
 if (minimumState) {
 int groupMaxIndex = group.getMaxSpecializationIndex();
 guardsBuilder.string("this");
 guardsBuilder.string(".").string(assumption).string(".isValid()");
 guardsAnd = " && ";
 }
-int argOffset = group.getTypeGuardOffset();
+for (TypeGuard typeGuard : group.getTypeGuards()) {
-int argIndex = argOffset;
+ActualParameter valueParam = source.getSignatureParameter(typeGuard.getSignatureIndex());
-for (TypeData typeData : group.getTypeGuards()) {
-ActualParameter valueParam = source.getSignatureParameter(argIndex);
 if (valueParam == null) {
 /*
 * If used inside a execute evaluated method then the value param may not exist.
 * In that case we assume that the value is executed generic or of the current
 * specialization.
 */
 if (group.getSpecialization() != null) {
-valueParam = group.getSpecialization().getSignatureParameter(argIndex);
+valueParam = group.getSpecialization().getSignatureParameter(typeGuard.getSignatureIndex());
 } else {
-valueParam = node.getGenericSpecialization().getSignatureParameter(argIndex);
+valueParam = node.getGenericSpecialization().getSignatureParameter(typeGuard.getSignatureIndex());
 }
 }
 NodeChildData child = node.findChild(valueParam.getSpecification().getName());
 if (child == null) {
 throw new IllegalStateException();
 }
-CodeTree implicitGuard = createTypeGuard(guardsBuilder, child, valueParam, typeData);
+CodeTree implicitGuard = createTypeGuard(guardsBuilder, child, valueParam, typeGuard.getType());
 if (implicitGuard != null) {
 guardsBuilder.string(guardsAnd);
 guardsBuilder.tree(implicitGuard);
 guardsAnd = " && ";
 }
-CodeTree cast = createCast(castBuilder, child, valueParam, typeData);
+CodeTree cast = createCast(castBuilder, child, valueParam, typeGuard.getType());
 if (cast != null) {
 castBuilder.tree(cast);
 }
+}
-argIndex++;
-}
+for (GuardData guard : group.getGuards()) {
-CodeTreeBuilder builder = parent.create();
+if (elseGuard == guard) {
+continue;
-int ifCount = 0;
+}
-if (isElseConnectableGroup(group)) {
-if (minimumState) {
+if (needsTypeGuard(source, group, guard)) {
-builder.startElseIf().tree(guardsBuilder.getRoot()).end().startBlock();
+guardsCastBuilder.tree(createMethodGuard(builder, guardsCastAnd, source, guard));
+guardsCastAnd = " && ";
 } else {
-builder.startElseBlock();
+guardsBuilder.tree(createMethodGuard(builder, guardsAnd, source, guard));
-}
+guardsAnd = " && ";
-ifCount++;
+}
+}
-} else {
-for (GuardData guard : group.getGuards()) {
+int ifCount = startGuardIf(builder, guardsBuilder, 0, elseGuard);
-if (needsTypeGuard(source, group, guard)) {
+builder.tree(castBuilder.getRoot());
-guardsCastBuilder.tree(createMethodGuard(parent, guardsCastAnd, source, guard));
+ifCount = startGuardIf(builder, guardsCastBuilder, ifCount, elseGuard);
-guardsCastAnd = " && ";
+return ifCount;
-} else {
+}
-guardsBuilder.tree(createMethodGuard(parent, guardsAnd, source, guard));
-guardsAnd = " && ";
+private int startGuardIf(CodeTreeBuilder builder, CodeTreeBuilder conditionBuilder, int ifCount, GuardData elseGuard) {
-}
+int newIfCount = ifCount;
-}
+if (!conditionBuilder.isEmpty()) {
-if (!guardsBuilder.isEmpty()) {
+if (ifCount == 0 && elseGuard != null) {
-builder.startIf().tree(guardsBuilder.getRoot()).end().startBlock();
+builder.startElseIf();
-ifCount++;
+} else {
-}
+builder.startIf();
-builder.tree(castBuilder.getRoot());
+}
+builder.tree(conditionBuilder.getRoot());
-if (!guardsCastBuilder.isEmpty()) {
+builder.end().startBlock();
-builder.startIf().tree(guardsCastBuilder.getRoot()).end().startBlock();
+newIfCount++;
-ifCount++;
+} else if (ifCount == 0 && elseGuard != null) {
-}
+builder.startElseBlock();
-}
+newIfCount++;
+}
-builder.tree(bodyBlock.create(builder, null));
+return newIfCount;
-builder.end(ifCount);
-return builder.getRoot();
-}
-private boolean isElseConnectableGroup(SpecializationGroup group) {
-if (!group.getTypeGuards().isEmpty() || !group.getAssumptions().isEmpty()) {
-return false;
-}
-SpecializationGroup previousGroup = group.getPreviousGroup();
-if (previousGroup != null && group.getGuards().size() == 1 && previousGroup.getGuards().size() == 1) {
-GuardData guard = group.getGuards().get(0);
-GuardData previousGuard = previousGroup.getGuards().get(0);
-if (guard.getMethod().equals(previousGuard.getMethod())) {
-assert guard.isNegated() != previousGuard.isNegated();
-return true;
-}
-}
-return false;
 }
 private boolean needsTypeGuard(SpecializationData source, SpecializationGroup group, GuardData guard) {
-int offset = group.getTypeGuardOffset();
+int signatureIndex = 0;
-int argIndex = 0;
 for (ActualParameter parameter : guard.getParameters()) {
 if (!parameter.getSpecification().isSignature()) {
 continue;
 }
-if (argIndex < offset) {
-// type casted in parent group
+TypeGuard typeGuard = group.findTypeGuard(signatureIndex);
-continue;
+if (typeGuard != null) {
-}
+TypeData requiredType = typeGuard.getType();
-int guardIndex = argIndex - offset;
-if (guardIndex < group.getTypeGuards().size()) {
-TypeData requiredType = group.getTypeGuards().get(guardIndex);
 ActualParameter sourceParameter = source.findParameter(parameter.getLocalName());
 if (sourceParameter == null) {
 sourceParameter = source.getNode().getGenericSpecialization().findParameter(parameter.getLocalName());
 }
 if (sourceParameter.getTypeSystemType().needsCastTo(getContext(), requiredType)) {
 return true;
 }
 }
-argIndex++;
+signatureIndex++;
 }
 return false;
 }
 private CodeTree createMethodGuard(CodeTreeBuilder parent, String prefix, SpecializationData source, GuardData guard) {
 builder.tree(createRewriteGeneric(builder, source, current, currentNodeVar));
 builder.end();
 } else {
 // simple rewrite
 if (current.getExceptions().isEmpty()) {
-builder.tree(createGenericInvoke(builder, source, current, createReplaceCall(builder, current, currentNodeVar, currentNodeVar, null)));
+builder.tree(createGenericInvoke(builder, source, current, createReplaceCall(builder, current, currentNodeVar, currentNodeVar, null), null));
 } else {
 builder.startStatement().string(currentNodeVar).string(" = ").tree(createReplaceCall(builder, current, currentNodeVar, currentNodeVar, null)).end();
-builder.tree(createGenericInvoke(builder, source, current, CodeTreeBuilder.singleString(currentNodeVar)));
+builder.tree(createGenericInvoke(builder, source, current, null, CodeTreeBuilder.singleString(currentNodeVar)));
 }
 }
 CodeTreeBuilder root = parent.create();
 root.tree(prefix.getRoot());
 root.tree(encloseThrowsWithFallThrough(current, builder.getRoot()));
 builder.declaration(getContext().getTruffleTypes().getNode(), "root", currentNode);
 builder.startIf().string(currentNode).string(".next0 != null").end().startBlock();
 builder.tree(createFindRoot(builder, node, false));
 builder.end();
 builder.end();
-builder.tree(createGenericInvoke(builder, source, current, createReplaceCall(builder, current, "root", currentNode, null)));
+builder.tree(createGenericInvoke(builder, source, current, createReplaceCall(builder, current, "root", "(" + baseClassName(node) + ") root", null), null));
 return builder.getRoot();
 }
 protected CodeTree createFindRoot(CodeTreeBuilder parent, NodeData node, boolean countDepth) {
 CodeTreeBuilder builder = parent.create();
 builder.end();
 return builder.getRoot();
 }
-protected CodeTree createGenericInvoke(CodeTreeBuilder parent, SpecializationData source, SpecializationData current, CodeTree replaceCall) {
+protected CodeTree createGenericInvoke(CodeTreeBuilder parent, SpecializationData source, SpecializationData current, CodeTree replaceCall, CodeTree replaceVar) {
+assert replaceCall == null || replaceVar == null;
 CodeTreeBuilder builder = parent.create();
+CodeTree replace = replaceVar;
+if (replace == null) {
+replace = replaceCall;
+}
 if (current.isGeneric()) {
-builder.startReturn().tree(replaceCall).string(".").startCall(EXECUTE_GENERIC_NAME);
+builder.startReturn().tree(replace).string(".").startCall(EXECUTE_GENERIC_NAME);
 addInternalValueParameterNames(builder, source, current, null, current.getNode().needsFrame(), true);
 builder.end().end();
 } else if (current.getMethod() == null) {
-builder.statement(replaceCall);
+if (replaceCall != null) {
+builder.statement(replaceCall);
+}
 emitEncounteredSynthetic(builder, current);
 } else if (!current.canBeAccessedByInstanceOf(getContext(), source.getNode().getNodeType())) {
-builder.statement(replaceCall);
+if (replaceCall != null) {
+builder.statement(replaceCall);
+}
 builder.startReturn().tree(createTemplateMethodCall(parent, null, source, current, null)).end();
 } else {
-replaceCall.add(new CodeTree(CodeTreeKind.STRING, null, "."));
+replace.add(new CodeTree(CodeTreeKind.STRING, null, "."));
-builder.startReturn().tree(createTemplateMethodCall(parent, replaceCall, source, current, null)).end();
+builder.startReturn().tree(createTemplateMethodCall(parent, replace, source, current, null)).end();
 }
 return builder.getRoot();
 }
 protected CodeTree createReplaceCall(CodeTreeBuilder builder, SpecializationData current, String target, String source, String message) {
 builder.startIf().string("depth > ").string(String.valueOf(node.getPolymorphicDepth())).end();
 builder.startBlock();
 String message = ("Polymorphic limit reached (" + node.getPolymorphicDepth() + ")");
 builder.tree(createGenericInvoke(builder, node.getGenericPolymorphicSpecialization(), node.getGenericSpecialization(),
-createReplaceCall(builder, node.getGenericSpecialization(), "root", "this", message)));
+createReplaceCall(builder, node.getGenericSpecialization(), "root", "this", message), null));
 builder.end();
 builder.startElseBlock();
 builder.startStatement().startCall("setNext0");
 builder.startNew(nodeSpecializationClassName(node.getUninitializedSpecialization())).string("this").end();

Mercurial > hg > graal-compiler

comparison graal/com.oracle.truffle.dsl.processor/src/com/oracle/truffle/dsl/processor/node/NodeCodeGenerator.java @ 11201:7fc3e1fb3965