graal-jvmci-8: graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/node/NodeCodeGenerator.java comparison

comparison graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/node/NodeCodeGenerator.java @ 7847:06a7cd6aaf00

Casting is now done on demand using local variables for explicit guards.

author	Christian Humer <christian.humer@gmail.com>
date	Tue, 19 Feb 2013 17:20:45 +0100
parents	91cc98eae8ee
children	6e4fb0ccebb1

comparison

equal deleted inserted replaced

-:91cc98eae8ee
+:06a7cd6aaf00
 private static String valueName(NodeFieldData field) {
 return field.getName() + "Value";
 }
-private static String valueName(TemplateMethod method, ActualParameter param) {
+private static String valueName(ActualParameter param) {
-NodeData node = (NodeData) method.getTemplate();
+NodeData node = (NodeData) param.getMethod().getTemplate();
 NodeFieldData field = node.findField(param.getSpecification().getName());
 if (field != null) {
 return valueName(field);
 } else {
 return param.getSpecification().getName();
 }
 }
+private static String castValueName(ActualParameter parameter) {
+return valueName(parameter) + "Cast";
+}
+private static String castValueName(NodeFieldData field) {
+return valueName(field) + "Cast";
+}
 private void addValueParameters(CodeExecutableElement method, TemplateMethod specialization, boolean forceFrame) {
 if (forceFrame) {
 method.addParameter(new CodeVariableElement(getContext().getTruffleTypes().getFrame(), "frame"));
 }
 for (ActualParameter parameter : specialization.getParameters()) {
 ParameterSpec spec = parameter.getSpecification();
 if (forceFrame && spec.getName().equals("frame")) {
 continue;
 }
-method.addParameter(new CodeVariableElement(parameter.getActualType(), valueName(specialization, parameter)));
+method.addParameter(new CodeVariableElement(parameter.getActualType(), valueName(parameter)));
 }
 }
 private static void addValueParameterNames(CodeTreeBuilder builder, TemplateMethod specialization, String unexpectedValueName, boolean forceFrame) {
 if (forceFrame) {
 }
 if (unexpectedValueName != null && spec.getName().equals(unexpectedValueName)) {
 builder.string("ex.getResult()");
 } else {
-builder.string(valueName(specialization, parameter));
+builder.string(valueName(parameter));
 }
 }
 }
-private static void addValueParameterNamesWithCasts(ProcessorContext context, CodeTreeBuilder body, SpecializationData valueSpecialization, SpecializationData targetSpecialization) {
+private static void addValueParameterNamesWithCasts(CodeTreeBuilder body, SpecializationData valueSpecialization, SpecializationData targetSpecialization) {
 NodeData node = targetSpecialization.getNode();
 TypeSystemData typeSystem = node.getTypeSystem();
 for (ActualParameter targetParameter : targetSpecialization.getParameters()) {
 ActualParameter valueParameter = valueSpecialization.findParameter(targetParameter.getSpecification().getName());
 if (valueParameter != null) {
 valueType = valueParameter.getActualTypeData(typeSystem);
 }
 if (targetType == null || targetType.isGeneric() || (valueType != null && valueType.equalsType(targetType))) {
-body.string(valueName(targetSpecialization, targetParameter));
+body.string(valueName(targetParameter));
 } else {
-String methodName = TypeSystemCodeGenerator.asTypeMethodName(targetType);
+body.string(castValueName(targetParameter));
-startCallTypeSystemMethod(context, body, node, methodName);
-body.string(valueName(targetSpecialization, targetParameter));
-body.end().end();
 }
 }
 }
 private static String genClassName(Template operation) {
 prev = current;
 }
 return prefix;
 }
+private static CodeTree createCallTypeSystemMethod(ProcessorContext context, CodeTreeBuilder parent, NodeData node, String methodName, String value) {
+CodeTreeBuilder builder = new CodeTreeBuilder(parent);
+startCallTypeSystemMethod(context, builder, node, methodName);
+builder.string(value);
+builder.end().end();
+return builder.getRoot();
+}
 private static void startCallTypeSystemMethod(ProcessorContext context, CodeTreeBuilder body, NodeData node, String methodName) {
 VariableElement singleton = TypeSystemCodeGenerator.findSingleton(context, node.getTypeSystem());
 assert singleton != null;
 body.startGroup();
 body.staticReference(singleton.getEnclosingElement().asType(), singleton.getSimpleName().toString());
 body.string(".").startCall(methodName);
 }
-private static CodeTree createGuardAndCast(ProcessorContext context, CodeTreeBuilder parent, String prefix, SpecializationData valueSpecialization, SpecializationData guardedSpecialization,
+private CodeTree createGuardAndCast(CodeTreeBuilder parent, String conditionPrefix, SpecializationData valueSpecialization, SpecializationData guardedSpecialization, boolean onSpecialization,
-boolean onSpecialization, CodeTree guardedStatements, CodeTree elseStatements) {
+CodeTree guardedStatements, CodeTree elseStatements) {
 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
-CodeTree implicitGuards = createImplicitGuards(context, parent, prefix, valueSpecialization, guardedSpecialization);
+CodeTree implicitGuards = createImplicitGuards(parent, conditionPrefix, valueSpecialization, guardedSpecialization);
-CodeTree explicitGuards = createExplicitGuards(context, parent, implicitGuards == null ? prefix : null, valueSpecialization, guardedSpecialization, onSpecialization);
+CodeTree explicitGuards = createExplicitGuards(parent, implicitGuards == null ? conditionPrefix : null, valueSpecialization, guardedSpecialization, onSpecialization);
 int ifCount = 0;
 if (implicitGuards != null) {
 builder.startIf();
 builder.end();
 builder.startBlock();
 ifCount++;
 }
+if (explicitGuards != null || !onSpecialization) {
+builder.tree(createCasts(parent, valueSpecialization, guardedSpecialization));
+}
 if (explicitGuards != null) {
 builder.startIf();
 builder.tree(explicitGuards);
 builder.end();
 builder.startBlock();
 ifCount++;
 }
-if (implicitGuards == null && explicitGuards == null && prefix != null && !prefix.isEmpty()) {
+if (implicitGuards == null && explicitGuards == null && conditionPrefix != null && !conditionPrefix.isEmpty()) {
-builder.startIf().string(prefix).end().startBlock();
+builder.startIf().string(conditionPrefix).end().startBlock();
 ifCount++;
 }
 builder.tree(guardedStatements);
 }
 return builder.getRoot();
 }
-private static CodeTree createExplicitGuards(ProcessorContext context, CodeTreeBuilder parent, String prefix, SpecializationData valueSpecialization, SpecializationData guardedSpecialization,
+private static CodeTree createExplicitGuards(CodeTreeBuilder parent, String conditionPrefix, SpecializationData valueSpecialization, SpecializationData guardedSpecialization,
 boolean onSpecialization) {
 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
-String andOperator = (prefix != null && !prefix.isEmpty()) ? (prefix + " && ") : "";
+String andOperator = conditionPrefix != null ? conditionPrefix + " && " : "";
 if (guardedSpecialization.getGuards().length > 0) {
 // Explicitly specified guards
 for (SpecializationGuardData guard : guardedSpecialization.getGuards()) {
 if ((guard.isOnSpecialization() && onSpecialization) || (guard.isOnExecution() && !onSpecialization)) {
 builder.string(andOperator);
 startCallOperationMethod(builder, guard.getGuardDeclaration());
-addValueParameterNamesWithCasts(context, builder, valueSpecialization, guardedSpecialization);
+addValueParameterNamesWithCasts(builder, valueSpecialization, guardedSpecialization);
 builder.end().end(); // call
 andOperator = " && ";
 }
 }
 }
 return builder.isEmpty() ? null : builder.getRoot();
 }
-private static CodeTree createImplicitGuards(ProcessorContext context, CodeTreeBuilder parent, String prefix, SpecializationData valueSpecialization, SpecializationData guardedSpecialization) {
+private CodeTree createCasts(CodeTreeBuilder parent, SpecializationData valueSpecialization, SpecializationData guardedSpecialization) {
 NodeData node = guardedSpecialization.getNode();
-TypeSystemData typeSystem = node.getTypeSystem();
 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
 // Implict guards based on method signature
-String andOperator = (prefix != null && !prefix.isEmpty()) ? (prefix + " && ") : "";
 for (NodeFieldData field : node.getFields()) {
 ActualParameter guardedParam = guardedSpecialization.findParameter(field.getName());
 ActualParameter valueParam = valueSpecialization.findParameter(field.getName());
-TypeData guardedType = guardedParam.getActualTypeData(typeSystem);
+CodeTree cast = createCast(parent, field, valueParam, guardedParam);
-TypeData valueType = valueParam.getActualTypeData(typeSystem);
+if (cast == null) {
-if (guardedType.equalsType(valueType) || guardedType.isGeneric()) {
 continue;
 }
+builder.tree(cast);
+}
+return builder.getRoot();
+}
+private CodeTree createImplicitGuards(CodeTreeBuilder parent, String conditionPrefix, SpecializationData valueSpecialization, SpecializationData guardedSpecialization) {
+NodeData node = guardedSpecialization.getNode();
+CodeTreeBuilder builder = new CodeTreeBuilder(parent);
+// Implict guards based on method signature
+String andOperator = conditionPrefix != null ? conditionPrefix + " && " : "";
+for (NodeFieldData field : node.getFields()) {
+ActualParameter guardedParam = guardedSpecialization.findParameter(field.getName());
+ActualParameter valueParam = valueSpecialization.findParameter(field.getName());
+CodeTree implicitGuard = createImplicitGuard(builder, field, valueParam, guardedParam);
+if (implicitGuard == null) {
+continue;
+}
 builder.string(andOperator);
+builder.tree(implicitGuard);
-builder.startGroup();
-if (field.isShortCircuit()) {
-ActualParameter shortCircuit = guardedSpecialization.getPreviousParam(guardedParam);
-builder.string("(");
-builder.string("!").string(valueName(guardedSpecialization, shortCircuit));
-builder.string(" || ");
-}
-startCallTypeSystemMethod(context, builder, guardedSpecialization.getNode(), TypeSystemCodeGenerator.isTypeMethodName(guardedType));
-builder.string(valueName(guardedSpecialization, guardedParam));
-builder.end().end(); // call
-if (field.isShortCircuit()) {
-builder.string(")");
-}
-builder.end(); // group
 andOperator = " && ";
 }
 return builder.isEmpty() ? null : builder.getRoot();
+}
+private CodeTree createImplicitGuard(CodeTreeBuilder parent, NodeFieldData field, ActualParameter source, ActualParameter target) {
+NodeData node = field.getNodeData();
+CodeTreeBuilder builder = new CodeTreeBuilder(parent);
+TypeData targetType = target.getActualTypeData(node.getTypeSystem());
+TypeData sourceType = source.getActualTypeData(node.getTypeSystem());
+if (targetType.equalsType(sourceType) || targetType.isGeneric()) {
+return null;
+}
+builder.startGroup();
+if (field.isShortCircuit()) {
+ActualParameter shortCircuit = target.getPreviousParameter();
+assert shortCircuit != null;
+builder.string("(");
+builder.string("!").string(valueName(shortCircuit));
+builder.string(" || ");
+}
+startCallTypeSystemMethod(getContext(), builder, node, TypeSystemCodeGenerator.isTypeMethodName(target.getActualTypeData(node.getTypeSystem())));
+builder.string(valueName(field));
+builder.end().end(); // call
+if (field.isShortCircuit()) {
+builder.string(")");
+}
+builder.end(); // group
+return builder.getRoot();
+}
+private CodeTree createCast(CodeTreeBuilder parent, NodeFieldData field, ActualParameter source, ActualParameter target) {
+NodeData node = field.getNodeData();
+TypeSystemData typeSystem = node.getTypeSystem();
+TypeData sourceType = source.getActualTypeData(typeSystem);
+TypeData targetType = target.getActualTypeData(typeSystem);
+if (targetType.equalsType(sourceType) || targetType.isGeneric()) {
+return null;
+}
+CodeTree condition = null;
+if (field.isShortCircuit()) {
+ActualParameter shortCircuit = target.getPreviousParameter();
+assert shortCircuit != null;
+condition = CodeTreeBuilder.singleString(valueName(shortCircuit));
+}
+CodeTree value = createCallTypeSystemMethod(context, parent, node, TypeSystemCodeGenerator.asTypeMethodName(targetType), valueName(target));
+return createLazyAssignment(parent, castValueName(field), target.getActualType(), condition, value);
+}
+/**
+* <pre>
+* variant1 $condition != null
+*
+* $type $name = defaultValue($type);
+* if ($condition) {
+*     $name = $value;
+* }
+*
+* variant2 $condition != null
+* $type $name = $value;
+* </pre>
+*
+* .
+*/
+private static CodeTree createLazyAssignment(CodeTreeBuilder parent, String name, TypeMirror type, CodeTree condition, CodeTree value) {
+CodeTreeBuilder builder = new CodeTreeBuilder(parent);
+if (condition == null) {
+builder.declaration(type, name, value);
+} else {
+builder.declaration(type, name, new CodeTreeBuilder(parent).defaultValue(type).getRoot());
+builder.startIf().tree(condition).end();
+builder.startBlock();
+builder.startStatement();
+builder.string(name);
+builder.string(" = ");
+builder.tree(value);
+builder.end(); // statement
+builder.end(); // block
+}
+return builder.getRoot();
 }
 @Override
 protected void createChildren(NodeData node) {
 Map<NodeData, List<TypeElement>> childTypes = new LinkedHashMap<>();
 CodeTreeBuilder guarded = new CodeTreeBuilder(body);
 guarded.startReturn().startNew(nodeClassName(specialization));
 guarded.string(THIS_NODE_LOCAL_VAR_NAME);
 guarded.end().end();
-body.tree(createGuardAndCast(getContext(), body, "allowed", node.getGenericSpecialization(), specialization, true, guarded.getRoot(), null));
+body.tree(createGuardAndCast(body, "allowed", node.getGenericSpecialization(), specialization, true, guarded.getRoot(), null));
 }
 body.startThrow().startNew(getContext().getType(IllegalArgumentException.class)).end().end();
 return method;
 }
 CodeTreeBuilder invokeMethodBuilder = new CodeTreeBuilder(builder);
 emitInvokeDoMethod(invokeMethodBuilder, current, 0);
 CodeTree invokeMethod = invokeMethodBuilder.getRoot();
 if (next != null) {
-invokeMethod = createGuardAndCast(getContext(), builder, "", current.getNode().getGenericSpecialization(), current, false, invokeMethod, null);
+invokeMethod = createGuardAndCast(builder, null, current.getNode().getGenericSpecialization(), current, false, invokeMethod, null);
 }
 builder.tree(invokeMethod);
 if (next != null) {
 builder.startTryBlock();
 }
 builder.startReturn();
 startCallOperationMethod(builder, specialization);
-addValueParameterNamesWithCasts(context, builder, specialization.getNode().getGenericSpecialization(), specialization);
+addValueParameterNamesWithCasts(builder, specialization.getNode().getGenericSpecialization(), specialization);
 builder.end().end(); // start call operation
 builder.end(); // return
 if (specialization.getExceptions().length > 0) {
 for (SpecializationThrowsData exception : specialization.getExceptions()) {
 builder.end().startCatchBlock(getUnexpectedValueException(), "ex");
 if (returnVoid) {
 builder.string("// ignore").newLine();
 } else {
 builder.startReturn();
-builder.tree(castPrimaryExecute(node, castedType, CodeTreeBuilder.singleString("ex.getResult()")));
+builder.tree(createExpectType(node, castedType, CodeTreeBuilder.singleString("ex.getResult()")));
 builder.end();
 }
 builder.end();
 if (!returnVoid) {
 builder.startReturn();
-builder.tree(castPrimaryExecute(node, castedType, CodeTreeBuilder.singleString("value")));
+builder.tree(createExpectType(node, castedType, CodeTreeBuilder.singleString("value")));
 builder.end();
 }
 } else {
 if (returnVoid) {
 builder.statement(primaryExecuteCall);
 } else {
 builder.startReturn();
-builder.tree(castPrimaryExecute(node, castedType, primaryExecuteCall));
+builder.tree(createExpectType(node, castedType, primaryExecuteCall));
 builder.end();
 }
 }
 }
-private CodeTree castPrimaryExecute(NodeData node, ExecutableTypeData castedType, CodeTree value) {
+private CodeTree createExpectType(NodeData node, ExecutableTypeData castedType, CodeTree value) {
 if (castedType == null) {
 return value;
 } else if (castedType.getType().isVoid()) {
 return value;
 } else if (castedType.getType().isGeneric()) {
 return value;
 }
 CodeTreeBuilder builder = CodeTreeBuilder.createBuilder();
+String targetMethodName;
 if (castedType.hasUnexpectedValue(getContext())) {
-startCallTypeSystemMethod(getContext(), builder, node, TypeSystemCodeGenerator.expectTypeMethodName(castedType.getType()));
+targetMethodName = TypeSystemCodeGenerator.expectTypeMethodName(castedType.getType());
 } else {
-startCallTypeSystemMethod(getContext(), builder, node, TypeSystemCodeGenerator.asTypeMethodName(castedType.getType()));
+targetMethodName = TypeSystemCodeGenerator.asTypeMethodName(castedType.getType());
 }
+startCallTypeSystemMethod(getContext(), builder, node, targetMethodName);
 builder.tree(value);
 builder.end().end();
 return builder.getRoot();
 }
 SpecializationData next = specialization.findNextSpecialization();
 CodeTree returnSpecialized = null;
 if (next != null) {
 returnSpecialized = createReturnSpecializeAndExecute(builder, next, null);
 }
-builder.tree(createGuardAndCast(context, builder, "", specialization, specialization, false, executeNode, returnSpecialized));
+builder.tree(createGuardAndCast(builder, null, specialization, specialization, false, executeNode, returnSpecialized));
 }
 private CodeTree createDeoptimize(CodeTreeBuilder parent) {
 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
 builder.startStatement();
 if (!shortCircuit) {
 builder.type(specialization.getNode().getTypeSystem().getGenericType());
 builder.string(" ");
 }
-builder.string(valueName(specialization, specParameter));
+builder.string(valueName(specParameter));
 builder.string(" = ");
 ExecutableTypeData genericExecutableType = field.getNodeData().findGenericExecutableType(getContext(), specParameter.getActualTypeData(node.getTypeSystem()));
 if (genericExecutableType == null) {
 throw new AssertionError("Must have generic executable type. Parser validation most likely failed. " + Arrays.toString(field.getNodeData().getExecutableTypes()));
 }
 private void buildSpecializedValueExecute(CodeTreeBuilder builder, SpecializationData specialization, NodeFieldData field) {
 ActualParameter param = specialization.findParameter(field.getName());
 boolean shortCircuit = startShortCircuit(builder, specialization, field, null);
 if (!shortCircuit) {
-builder.startStatement().type(param.getActualType()).string(" ").string(valueName(specialization, param)).end();
+builder.startStatement().type(param.getActualType()).string(" ").string(valueName(param)).end();
 }
 ExecutableTypeData execType = field.getNodeData().findExecutableType(param.getActualTypeData(field.getNodeData().getTypeSystem()));
 if (execType.hasUnexpectedValue(getContext())) {
 }
 shortCircuitIndex++;
 }
 }
-builder.startStatement().type(shortCircuitParam.getActualType()).string(" ").string(valueName(specialization, shortCircuitParam)).string(" = ");
+builder.startStatement().type(shortCircuitParam.getActualType()).string(" ").string(valueName(shortCircuitParam)).string(" = ");
 ShortCircuitData shortCircuitData = specialization.getShortCircuits()[shortCircuitIndex];
 startCallOperationMethod(builder, shortCircuitData);
 addValueParameterNames(builder, shortCircuitData, exceptionField != null ? exceptionField.getName() : null, false);
 builder.end().end(); // call operation
 builder.end(); // statement
-builder.declaration(parameter.getActualType(), valueName(specialization, parameter), CodeTreeBuilder.createBuilder().defaultValue(parameter.getActualType()));
+builder.declaration(parameter.getActualType(), valueName(parameter), CodeTreeBuilder.createBuilder().defaultValue(parameter.getActualType()));
 builder.startIf().string(shortCircuitParam.getSpecification().getName()).end();
 builder.startBlock();
 return true;
 }
 genericExecute.startCall(factoryClassName(specialization.getNode()), generatedMethodName);
 genericExecute.string("this");
 addValueParameterNames(genericExecute, specialization.getNode().getGenericSpecialization(), null, true);
 genericExecute.end(); // call generated generic
-CodeTree genericInvocation = castPrimaryExecute(node, returnExecutableType, genericExecute.getRoot());
+CodeTree genericInvocation = createExpectType(node, returnExecutableType, genericExecute.getRoot());
 if (generatedGeneric != null && Utils.isVoid(generatedGeneric.getReturnType())) {
 builder.statement(genericInvocation);
 if (!Utils.isVoid(builder.findMethod().asType())) {

Mercurial > hg > graal-jvmci-8

comparison graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/node/NodeCodeGenerator.java @ 7847:06a7cd6aaf00