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 @ 9217:61ba6fc21ba4

Sourcegen can now generate execute methods of signature execute(frame, evaluatedValue).

author	Christian Humer <christian.humer@gmail.com>
date	Mon, 15 Apr 2013 18:50:19 +0200
parents	bd067a48a9c2
children	797bb88bf004

comparison

equal deleted inserted replaced

-:8b9ea2f5c36e
+:61ba6fc21ba4
 }
 if (spec.isLocal()) {
 continue;
 }
-method.addParameter(new CodeVariableElement(parameter.getActualType(), valueName(parameter)));
+method.addParameter(new CodeVariableElement(parameter.getType(), valueName(parameter)));
 }
 }
-private static void addInternalValueParameterNames(CodeTreeBuilder builder, TemplateMethod specialization, String unexpectedValueName, boolean forceFrame, boolean includeImplicit) {
+private static void addInternalValueParameterNames(CodeTreeBuilder builder, TemplateMethod source, TemplateMethod specialization, String unexpectedValueName, boolean forceFrame,
+boolean includeImplicit) {
 if (forceFrame && specialization.getSpecification().findParameterSpec("frame") != null) {
 builder.string("frameValue");
 }
 for (ActualParameter parameter : specialization.getParameters()) {
 ParameterSpec spec = parameter.getSpecification();
 }
 if (parameter.getSpecification().isLocal()) {
 continue;
 }
+ActualParameter sourceParameter = source.findParameter(parameter.getLocalName());
 if (unexpectedValueName != null && parameter.getLocalName().equals(unexpectedValueName)) {
-builder.cast(parameter.getActualType(), CodeTreeBuilder.singleString("ex.getResult()"));
+builder.cast(parameter.getType(), CodeTreeBuilder.singleString("ex.getResult()"));
+} else if (sourceParameter != null) {
+builder.string(valueName(sourceParameter, parameter));
 } else {
 builder.string(valueName(parameter));
 }
+}
+}
+private static String valueName(ActualParameter sourceParameter, ActualParameter targetParameter) {
+if (sourceParameter != null) {
+if (!sourceParameter.getSpecification().isSignature()) {
+return valueName(targetParameter);
+} else if (sourceParameter.getTypeSystemType() != null && targetParameter.getTypeSystemType() != null) {
+if (sourceParameter.getTypeSystemType().needsCastTo(targetParameter.getTypeSystemType())) {
+return castValueName(targetParameter);
+}
+}
+return valueName(targetParameter);
+} else {
+return valueName(targetParameter);
 }
 }
 private static CodeTree createTemplateMethodCall(CodeTreeBuilder parent, TemplateMethod sourceMethod, TemplateMethod targetMethod, String unexpectedValueName) {
 CodeTreeBuilder builder = parent.create();
 if (method == null) {
 throw new IllegalStateException("Cannot call synthetic operation methods.");
 }
 TypeElement targetClass = Utils.findNearestEnclosingType(method.getEnclosingElement());
 NodeData node = (NodeData) targetMethod.getTemplate();
-TypeSystemData typeSystem = node.getTypeSystem();
 boolean accessible = targetMethod.canBeAccessedByInstanceOf(node.getNodeType());
 if (accessible) {
 if (builder.findMethod().getModifiers().contains(STATIC)) {
 if (method.getModifiers().contains(STATIC)) {
 builder.type(targetClass.asType());
 } else {
 builder.string(THIS_NODE_LOCAL_VAR_NAME);
 }
 } else {
-builder.string("super");
+if (targetMethod instanceof ExecutableTypeData) {
+builder.string("this");
+} else {
+builder.string("super");
+}
 }
 } else {
 if (method.getModifiers().contains(STATIC)) {
 builder.type(targetClass.asType());
 } else {
 }
 }
 ActualParameter sourceParameter = sourceMethod.findParameter(parameter.getLocalName());
 assert parameter != null;
-if (castedValues) {
+if (castedValues && sourceParameter != null) {
-NodeFieldData field = node.findField(parameter.getSpecification().getName());
+builder.string(valueName(sourceParameter, parameter));
-if (field == null) {
-builder.string(valueName(parameter));
-} else {
-if (Utils.typeEquals(sourceParameter.getActualType(), parameter.getActualType())) {
-builder.string(valueName(parameter));
-} else {
-builder.string(castValueName(parameter));
-}
-}
 } else {
 builder.string(valueName(parameter));
 }
 }
 }
 for (ActualParameter targetParameter : targetMethod.getParameters()) {
 ActualParameter valueParameter = sourceMethod.findParameter(targetParameter.getLocalName());
 if (valueParameter == null) {
 valueParameter = targetParameter;
 }
-TypeData targetType = targetParameter.getActualTypeData(typeSystem);
+TypeData targetType = targetParameter.getTypeSystemType();
 if (targetParameter.isImplicit() || valueParameter.isImplicit()) {
 continue;
 }
 TypeData valueType = null;
 if (valueParameter != null) {
-valueType = valueParameter.getActualTypeData(typeSystem);
+valueType = valueParameter.getTypeSystemType();
 }
 if (targetParameter.getSpecification().isLocal()) {
 builder.startGroup();
 if (builder.findMethod().getModifiers().contains(Modifier.STATIC)) {
 builder.string(targetParameter.getSpecification().getName());
 builder.end();
 } else if (unexpectedValueName != null && targetParameter.getLocalName().equals(unexpectedValueName)) {
 builder.string("ex.getResult()");
 } else if (targetType == null || targetType.isGeneric() || (valueType != null && valueType.equalsType(targetType))) {
+builder.startGroup();
+if (valueType != null && sourceMethod.getMethodName().equals(targetMethod.getMethodName()) && !valueType.isGeneric() && targetType.isGeneric()) {
+builder.string("(");
+builder.type(targetType.getPrimitiveType());
+builder.string(") ");
+}
 builder.string(valueName(targetParameter));
+builder.end();
 } else {
 builder.string(castValueName(targetParameter));
 }
 }
 prev = current;
 }
 return prefix;
 }
-private static CodeTree createCallTypeSystemMethod(ProcessorContext context, CodeTreeBuilder parent, NodeData node, String methodName, String value) {
+private static CodeTree createCallTypeSystemMethod(ProcessorContext context, CodeTreeBuilder parent, NodeData node, String methodName, CodeTree value) {
 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
 startCallTypeSystemMethod(context, builder, node, methodName);
-builder.string(value);
+builder.tree(value);
 builder.end().end();
 return builder.getRoot();
 }
 private static void startCallTypeSystemMethod(ProcessorContext context, CodeTreeBuilder body, NodeData node, String methodName) {
 for (ActualParameter parameter : guard.getParameters()) {
 NodeFieldData field = node.findField(parameter.getSpecification().getName());
 if (field == null) {
 continue;
 }
-TypeData typeData = parameter.getActualTypeData(node.getTypeSystem());
+TypeData typeData = parameter.getTypeSystemType();
 if (typeData != null && !typeData.isGeneric()) {
 valuesNeedsCast.add(parameter.getLocalName());
 }
 }
 }
 private CodeTree createCasts(CodeTreeBuilder parent, Set<String> castWhiteList, SpecializationData valueSpecialization, SpecializationData guardedSpecialization) {
 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
 // Implict guards based on method signature
 for (ActualParameter guardedParam : guardedSpecialization.getParameters()) {
 NodeFieldData field = guardedSpecialization.getNode().findField(guardedParam.getSpecification().getName());
-if (field == null || field.getKind() == FieldKind.FIELD) {
+if (field == null || field.getKind() == FieldKind.FINAL_FIELD) {
 continue;
 }
 ActualParameter valueParam = valueSpecialization.findParameter(guardedParam.getLocalName());
 if (castWhiteList != null && !castWhiteList.contains(guardedParam.getLocalName())) {
 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
 // Implict guards based on method signature
 String andOperator = conditionPrefix != null ? conditionPrefix + " && " : "";
 for (ActualParameter guardedParam : guardedSpecialization.getParameters()) {
 NodeFieldData field = guardedSpecialization.getNode().findField(guardedParam.getSpecification().getName());
-if (field == null || field.getKind() == FieldKind.FIELD) {
+if (field == null || field.getKind() == FieldKind.FINAL_FIELD) {
 continue;
 }
 ActualParameter valueParam = valueSpecialization.findParameter(guardedParam.getLocalName());
 CodeTree implicitGuard = createImplicitGuard(builder, field, valueParam, guardedParam);
 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 targetType = target.getTypeSystemType();
-TypeData sourceType = source.getActualTypeData(node.getTypeSystem());
+TypeData sourceType = source.getTypeSystemType();
 if (targetType.equalsType(sourceType) || targetType.isGeneric()) {
 return null;
 }
 builder.string("(");
 builder.string("!").string(valueName(shortCircuit));
 builder.string(" || ");
 }
-startCallTypeSystemMethod(getContext(), builder, node, TypeSystemCodeGenerator.isTypeMethodName(target.getActualTypeData(node.getTypeSystem())));
+startCallTypeSystemMethod(getContext(), builder, node, TypeSystemCodeGenerator.isTypeMethodName(target.getTypeSystemType()));
 builder.string(valueName(source));
 builder.end().end(); // call
 if (field.isShortCircuit()) {
 builder.string(")");
 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.getTypeSystemType();
+TypeData targetType = target.getTypeSystemType();
-TypeData sourceType = source.getActualTypeData(typeSystem);
-TypeData targetType = target.getActualTypeData(typeSystem);
+if (!sourceType.needsCastTo(targetType)) {
-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));
+CodeTree value = createCallTypeSystemMethod(context, parent, node, TypeSystemCodeGenerator.asTypeMethodName(targetType), CodeTreeBuilder.singleString(valueName(target)));
-return createLazyAssignment(parent, castValueName(target), target.getActualType(), condition, value);
+return createLazyAssignment(parent, castValueName(target), target.getType(), condition, value);
 }
 /**
 * <pre>
 * variant1 $condition != null
 assert !node.getSpecializations().isEmpty();
 SpecializationData data = node.getSpecializations().get(0);
 for (ActualParameter parameter : data.getParameters()) {
 ParameterSpec spec = parameter.getSpecification();
 NodeFieldData field = node.findField(spec.getName());
-if (field == null || field.getKind() == FieldKind.FIELD) {
+if (field == null || field.getKind() == FieldKind.FINAL_FIELD) {
 continue;
 }
 TypeMirror type;
 if (field.getKind() == FieldKind.CHILDREN && field.getType().getKind() == TypeKind.ARRAY) {
 return method;
 }
 private List<CodeExecutableElement> createGeneratedGenericMethod(NodeData node) {
-TypeMirror genericReturnType = node.getGenericSpecialization().getReturnType().getActualType();
+TypeMirror genericReturnType = node.getGenericSpecialization().getReturnType().getType();
 if (node.needsRewrites(context)) {
 List<CodeExecutableElement> methods = new ArrayList<>();
 List<SpecializationData> specializations = node.getSpecializations();
 SpecializationData prev = null;
 if (next != null) {
 CodeTreeBuilder nextBuilder = builder.create();
 nextBuilder.startReturn().startCall(generatedGenericMethodName(next));
 nextBuilder.string(THIS_NODE_LOCAL_VAR_NAME);
-addInternalValueParameterNames(nextBuilder, next, null, true, true);
+addInternalValueParameterNames(nextBuilder, next, next, null, true, true);
 nextBuilder.end().end();
 invokeMethod = createGuardAndCast(builder, null, current.getNode().getGenericSpecialization(), current, true, invokeMethod, nextBuilder.getRoot());
 }
 for (SpecializationThrowsData exception : specialization.getExceptions()) {
 builder.end().startCatchBlock(exception.getJavaClass(), "ex" + level);
 builder.startReturn().startCall(generatedGenericMethodName(exception.getTransitionTo()));
 builder.string(THIS_NODE_LOCAL_VAR_NAME);
-addInternalValueParameterNames(builder, exception.getTransitionTo(), null, true, true);
+addInternalValueParameterNames(builder, exception.getTransitionTo(), exception.getTransitionTo(), null, true, true);
 builder.end().end();
 }
 builder.end();
 }
 }
 if (superConstructor != null) {
 clazz.add(superConstructor);
 }
 }
-TypeData primaryType = specialization.getReturnType().getActualTypeData(node.getTypeSystem());
 for (ExecutableTypeData execType : node.getExecutableTypes()) {
 if (execType.isFinal()) {
 continue;
 }
+CodeExecutableElement executeMethod = createExecutableTypeOverride(execType);
-if (primaryType == execType.getType()) {
+clazz.add(executeMethod);
-CodeExecutableElement executeMethod = createExecutableTypeOverride(execType);
+CodeTreeBuilder builder = executeMethod.createBuilder();
-clazz.add(executeMethod);
+CodeTree result = createExecuteBody(builder, specialization, execType);
-executeMethod.setBodyTree(createFunctionalExecute(executeMethod.createBuilder(), specialization));
+if (result != null) {
-} else if (needsCastingExecuteMethod(execType, primaryType)) {
+builder.tree(result);
-CodeExecutableElement executeMethod = createExecutableTypeOverride(execType);
+} else {
-clazz.add(executeMethod);
+clazz.remove(executeMethod);
-executeMethod.setBodyTree(createCastingExecute(executeMethod.createBuilder(), specialization, execType.getType()));
+}
-}
 }
 if (node.needsRewrites(getContext()) && !specialization.isGeneric() && !specialization.isUninitialized()) {
 buildSpecializeAndExecute(clazz, specialization);
 }
 }
+private CodeTree createExecuteBody(CodeTreeBuilder parent, SpecializationData specialization, ExecutableTypeData execType) {
+TypeData primaryType = specialization.getReturnType().getTypeSystemType();
+CodeTreeBuilder builder = new CodeTreeBuilder(parent);
+ExecutableTypeData foundEvaluatedPrimaryType = findFunctionalExecutableType(specialization, execType.getEvaluatedCount());
+if (execType == foundEvaluatedPrimaryType || foundEvaluatedPrimaryType == null) {
+builder.tree(createFunctionalExecute(builder, specialization, execType));
+} else if (needsCastingExecuteMethod(execType, primaryType)) {
+builder.tree(createCastingExecute(builder, specialization, execType, foundEvaluatedPrimaryType));
+} else {
+return null;
+}
+return builder.getRoot();
+}
 private CodeExecutableElement createExecutableTypeOverride(ExecutableTypeData execType) {
 CodeExecutableElement method = CodeExecutableElement.clone(getContext().getEnvironment(), execType.getMethod());
-if (method.getParameters().size() == 1) {
-CodeVariableElement var = CodeVariableElement.clone(method.getParameters().get(0));
+int i = 0;
-var.setName("frameValue");
+for (VariableElement param : method.getParameters()) {
-method.getParameters().set(0, var);
+CodeVariableElement var = CodeVariableElement.clone(param);
-}
+var.setName(valueName(execType.getParameters().get(i)));
+method.getParameters().set(i, var);
+i++;
+}
+method.getAnnotationMirrors().clear();
 method.getModifiers().remove(Modifier.ABSTRACT);
 return method;
 }
 private boolean needsCastingExecuteMethod(ExecutableTypeData execType, TypeData primaryType) {
 return true;
 }
 return false;
 }
-private CodeTree createCastingExecute(CodeTreeBuilder parent, SpecializationData specialization, TypeData type) {
+private ExecutableTypeData findFunctionalExecutableType(SpecializationData specialization, int evaluatedCount) {
+TypeData primaryType = specialization.getReturnType().getTypeSystemType();
+List<ExecutableTypeData> otherTypes = specialization.getNode().getExecutableTypes(evaluatedCount);
+List<ExecutableTypeData> filteredTypes = new ArrayList<>();
+for (ExecutableTypeData compareType : otherTypes) {
+if (!Utils.typeEquals(compareType.getType().getPrimitiveType(), primaryType.getPrimitiveType())) {
+continue;
+}
+filteredTypes.add(compareType);
+}
+for (ExecutableTypeData compareType : filteredTypes) {
+if (compareType.startsWithSignature(specialization)) {
+return compareType;
+}
+}
+for (ExecutableTypeData compareType : otherTypes) {
+if (compareType.startsWithSignature(specialization)) {
+return compareType;
+}
+}
+return null;
+}
+private CodeTree createCastingExecute(CodeTreeBuilder parent, SpecializationData specialization, ExecutableTypeData executable, ExecutableTypeData castExecutable) {
+TypeData type = executable.getType();
 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
 NodeData node = specialization.getNode();
-TypeSystemData typeSystem = node.getTypeSystem();
 ExecutableTypeData castedType = node.findExecutableType(type);
-TypeData primaryType = specialization.getReturnType().getActualTypeData(typeSystem);
+TypeData primaryType = castExecutable.getType();
-ExecutableTypeData execType = specialization.getNode().findExecutableType(primaryType);
+boolean needsTry = castExecutable.hasUnexpectedValue(getContext());
-boolean needsTry = execType.hasUnexpectedValue(getContext());
 boolean returnVoid = type.isVoid();
-CodeTree primaryExecuteCall = null;
+List<ActualParameter> executeParameters = new ArrayList<>();
+for (ActualParameter sourceParameter : executable.getParameters()) {
-CodeTreeBuilder executeBuilder = new CodeTreeBuilder(builder);
+NodeFieldData field = specialization.getNode().findField(sourceParameter.getSpecification().getName());
-buildExecute(executeBuilder, null, null, execType);
+if (field == null || field.getKind() == FieldKind.FINAL_FIELD) {
-primaryExecuteCall = executeBuilder.getRoot();
+continue;
+}
+ActualParameter targetParameter = castExecutable.findParameter(sourceParameter.getLocalName());
+if (targetParameter != null) {
+TypeData sourceType = sourceParameter.getTypeSystemType();
+TypeData targetType = targetParameter.getTypeSystemType();
+if (sourceType.needsCastTo(targetType)) {
+executeParameters.add(targetParameter);
+}
+}
+}
+builder.tree(createExecuteChildren(builder, executable, specialization, executeParameters, null, true));
+CodeTree primaryExecuteCall = createTemplateMethodCall(builder, executable, castExecutable, null);
 if (needsTry) {
 if (!returnVoid) {
 builder.declaration(primaryType.getPrimitiveType(), "value");
 }
 builder.startTryBlock();
 builder.tree(value);
 builder.end().end();
 return builder.getRoot();
 }
-private CodeTree createFunctionalExecute(CodeTreeBuilder parent, SpecializationData specialization) {
+private CodeTree createFunctionalExecute(CodeTreeBuilder parent, SpecializationData specialization, ExecutableTypeData executable) {
 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
 if (specialization.isUninitialized()) {
 builder.tree(createDeoptimize(builder));
 }
-builder.tree(createExecuteChildren(builder, specialization));
+builder.tree(createExecuteChildren(builder, executable, specialization, specialization.getParameters(), null, false));
 CodeTree executeNode;
 if (specialization.isUninitialized()) {
-builder.tree(createSpecializeCall(builder, specialization));
+builder.tree(createSpecializeCall(builder, executable, specialization));
 }
-executeNode = createExecute(builder, specialization);
+executeNode = createExecute(builder, executable, specialization);
 SpecializationData next = specialization.findNextSpecialization();
 CodeTree returnSpecialized = null;
 if (next != null) {
-returnSpecialized = createReturnSpecializeAndExecute(builder, next, null);
+returnSpecialized = createReturnSpecializeAndExecute(builder, executable, next, null);
 }
 builder.tree(createGuardAndCast(builder, null, specialization, specialization, true, executeNode, returnSpecialized));
 return builder.getRoot();
 }
 builder.startStaticCall(getContext().getTruffleTypes().getTruffleIntrinsics(), "deoptimize").end();
 builder.end();
 return builder.getRoot();
 }
-private CodeTree createSpecializeCall(CodeTreeBuilder parent, SpecializationData specialization) {
+private CodeTree createSpecializeCall(CodeTreeBuilder parent, ExecutableTypeData executable, SpecializationData specialization) {
 NodeData node = specialization.getNode();
 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
 emitSpecializationListeners(builder, node);
 builder.startCall("replace");
 if (node.needsRewrites(getContext())) {
 builder.startCall(factoryClassName(node), "specialize");
 builder.string("this");
 builder.typeLiteral(builder.findMethod().getEnclosingElement().asType());
-addInternalValueParameterNames(builder, specialization, null, true, true);
+addInternalValueParameterNames(builder, executable, specialization, null, true, true);
 builder.end(); // call replace, call specialize
 } else {
 builder.startCall(factoryClassName(node), "createSpecialized").string("this").string("null").end();
 }
 builder.end().end();
 return builder.getRoot();
 }
-private CodeTree createExecute(CodeTreeBuilder parent, SpecializationData specialization) {
+private CodeTree createExecute(CodeTreeBuilder parent, ExecutableTypeData executable, SpecializationData specialization) {
 NodeData node = specialization.getNode();
 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
 if (!specialization.getExceptions().isEmpty()) {
 builder.startTryBlock();
 }
+CodeTreeBuilder returnBuilder = new CodeTreeBuilder(parent);
 if (specialization.isUninitialized()) {
 String genericMethodName = generatedGenericMethodName(null);
-builder.startReturn().startCall(factoryClassName(node), genericMethodName);
+returnBuilder.startCall(factoryClassName(node), genericMethodName);
-builder.string("this");
+returnBuilder.string("this");
-addInternalValueParameterNames(builder, specialization, null, true, true);
+addInternalValueParameterNames(returnBuilder, executable, specialization, null, true, true);
-builder.end().end();
+returnBuilder.end();
 } else if (specialization.getMethod() == null && !node.needsRewrites(context)) {
 emitEncounteredSynthetic(builder);
 } else if (specialization.isGeneric()) {
 String genericMethodName;
 if (!specialization.isUseSpecializationsForGeneric()) {
 genericMethodName = generatedGenericMethodName(specialization);
 } else {
 genericMethodName = generatedGenericMethodName(null);
 }
-builder.startReturn().startCall(factoryClassName(node), genericMethodName);
+returnBuilder.startCall(factoryClassName(node), genericMethodName);
-builder.string("this");
+returnBuilder.string("this");
-addInternalValueParameterNames(builder, specialization, null, true, true);
+addInternalValueParameterNames(returnBuilder, executable, specialization, null, true, true);
-builder.end().end();
+returnBuilder.end();
 } else {
+returnBuilder.tree(createTemplateMethodCall(returnBuilder, executable, specialization, null));
+}
+if (!returnBuilder.isEmpty()) {
 builder.startReturn();
-builder.tree(createTemplateMethodCall(builder, specialization, specialization, null));
-builder.end(); // return
+TypeData targetType = node.getTypeSystem().findTypeData(builder.findMethod().getReturnType());
+TypeData sourceType = specialization.getReturnType().getTypeSystemType();
+if (targetType == null || sourceType == null) {
+builder.tree(returnBuilder.getRoot());
+} else if (sourceType.needsCastTo(targetType)) {
+builder.tree(createCallTypeSystemMethod(context, parent, node, TypeSystemCodeGenerator.expectTypeMethodName(targetType), returnBuilder.getRoot()));
+} else {
+builder.tree(returnBuilder.getRoot());
+}
+builder.end();
 }
 if (!specialization.getExceptions().isEmpty()) {
 for (SpecializationThrowsData exception : specialization.getExceptions()) {
 builder.end().startCatchBlock(exception.getJavaClass(), "ex");
-builder.tree(createReturnSpecializeAndExecute(parent, exception.getTransitionTo(), null));
+builder.tree(createReturnSpecializeAndExecute(parent, executable, exception.getTransitionTo(), null));
 }
 builder.end();
 }
 return builder.getRoot();
 }
-private CodeTree createExecuteChildren(CodeTreeBuilder parent, SpecializationData specialization) {
+private CodeTree createExecuteChildren(CodeTreeBuilder parent, ExecutableTypeData sourceExecutable, SpecializationData specialization, List<ActualParameter> targetParameters,
+ActualParameter unexpectedParameter, boolean cast) {
+NodeData sourceNode = specialization.getNode();
 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
-for (ActualParameter parameter : specialization.getParameters()) {
+for (ActualParameter targetParameter : targetParameters) {
-NodeFieldData field = specialization.getNode().findField(parameter.getSpecification().getName());
+NodeFieldData field = sourceNode.findField(targetParameter.getSpecification().getName());
-if (field == null || field.getKind() == FieldKind.FIELD) {
+if (field == null || field.getKind() == FieldKind.FINAL_FIELD) {
 continue;
 }
+TypeData targetType = targetParameter.getTypeSystemType();
-buildFieldExecute(builder, specialization, parameter, field, null);
+ExecutableTypeData targetExecutable = field.getNodeData().findExecutableType(targetType);
+ActualParameter sourceParameter = sourceExecutable.findParameter(targetParameter.getLocalName());
+String targetVariableName;
+CodeTree executionExpression;
+if (cast || sourceParameter != null) {
+TypeData sourceType = sourceParameter.getTypeSystemType();
+if (!sourceType.needsCastTo(targetType)) {
+continue;
+}
+executionExpression = createExpectType(sourceNode, targetExecutable, CodeTreeBuilder.singleString(valueName(targetParameter)));
+targetVariableName = castValueName(targetParameter);
+} else {
+if (sourceExecutable.findParameter(targetParameter.getLocalName()) == null) {
+executionExpression = createExecuteChildExpression(builder, field, targetParameter);
+targetVariableName = valueName(targetParameter);
+} else {
+continue;
+}
+}
+CodeTreeVariable executionVar = new CodeTreeVariable();
+CodeTree shortCircuitTree = createShortCircuitTree(builder, executionVar, targetVariableName, sourceExecutable, specialization, targetParameter, unexpectedParameter);
+CodeTree unexpectedTree = createCatchUnexpectedTree(builder, executionExpression, targetVariableName, specialization, sourceExecutable, targetExecutable, targetParameter,
+shortCircuitTree != executionVar);
+executionVar.set(unexpectedTree);
+builder.tree(shortCircuitTree);
 }
 return builder.getRoot();
 }
 private void emitSpecializationListeners(CodeTreeBuilder builder, NodeData node) {
 builder.tree(createTemplateMethodCall(builder, listener, listener, null));
 builder.end(); // statement
 }
 }
-private void buildFieldExecute(CodeTreeBuilder builder, SpecializationData specialization, ActualParameter param, NodeFieldData field, ActualParameter exceptionParam) {
+private CodeTree createCatchUnexpectedTree(CodeTreeBuilder parent, CodeTree body, String targetVariableName, SpecializationData specialization, ExecutableTypeData currentExecutable,
-boolean shortCircuit = startShortCircuit(builder, specialization, param, exceptionParam);
+ExecutableTypeData targetExecutable, ActualParameter param, boolean shortCircuit) {
-ExecutableTypeData execType = field.getNodeData().findExecutableType(param.getActualTypeData(field.getNodeData().getTypeSystem()));
+CodeTreeBuilder builder = new CodeTreeBuilder(parent);
-boolean unexpected = execType.hasUnexpectedValue(getContext());
+boolean unexpected = targetExecutable.hasUnexpectedValue(getContext());
+builder.startStatement();
-if (!shortCircuit && unexpected) {
-builder.startStatement().type(param.getActualType()).string(" ").string(valueName(param)).end();
+if (!shortCircuit) {
+builder.type(param.getType()).string(" ").string(targetVariableName);
 }
 if (unexpected) {
+if (!shortCircuit) {
+builder.end();
+}
 builder.startTryBlock();
-}
+builder.startStatement();
+builder.string(targetVariableName);
-if (!shortCircuit && !unexpected) {
+} else if (shortCircuit) {
-builder.startStatement().type(param.getActualType()).string(" ").string(valueName(param)).string(" = ");
+builder.startStatement();
-} else {
+builder.string(targetVariableName);
-builder.startStatement().string(valueName(param)).string(" = ");
+}
-}
+builder.string(" = ");
-buildExecute(builder, param, field, execType);
+builder.tree(body);
 builder.end();
 if (unexpected) {
 builder.end().startCatchBlock(getUnexpectedValueException(), "ex");
 SpecializationData generic = specialization.getNode().getGenericSpecialization();
-boolean execute = false;
+ActualParameter genericParameter = generic.findParameter(param.getLocalName());
-for (ActualParameter exParam : generic.getParameters()) {
-NodeFieldData exField = generic.getNode().findField(exParam.getSpecification().getName());
+List<ActualParameter> genericParameters = generic.getParametersAfter(genericParameter);
-if (exField == null || field.getKind() == FieldKind.FIELD) {
+builder.tree(createExecuteChildren(parent, currentExecutable, generic, genericParameters, genericParameter, false));
-continue;
+builder.tree(createReturnSpecializeAndExecute(builder, currentExecutable, specialization.findNextSpecialization(), param));
-}
-if (execute) {
-buildFieldExecute(builder, specialization.getNode().getGenericSpecialization(), exParam, exField, param);
-} else if (exParam.getLocalName().equals(param.getLocalName())) {
-execute = true;
-}
-}
-builder.tree(createReturnSpecializeAndExecute(builder, specialization.findNextSpecialization(), param));
 builder.end(); // catch block
 }
-endShortCircuit(builder, shortCircuit);
+return builder.getRoot();
-builder.newLine();
+}
-}
+private CodeTree createExecuteChildExpression(CodeTreeBuilder parent, NodeFieldData targetField, ActualParameter sourceParameter) {
-private void buildExecute(CodeTreeBuilder builder, ActualParameter parameter, NodeFieldData field, ExecutableTypeData execType) {
+TypeData type = sourceParameter.getTypeSystemType();
-if (field != null) {
+ExecutableTypeData execType = targetField.getNodeData().findExecutableType(type);
-Element accessElement = field.getAccessElement();
+CodeTreeBuilder builder = new CodeTreeBuilder(parent);
+if (targetField != null) {
+Element accessElement = targetField.getAccessElement();
 if (accessElement.getKind() == ElementKind.METHOD) {
 builder.startCall(accessElement.getSimpleName().toString()).end();
 } else if (accessElement.getKind() == ElementKind.FIELD) {
 builder.string("this.").string(accessElement.getSimpleName().toString());
 } else {
 throw new AssertionError();
 }
-if (parameter.getSpecification().isIndexed()) {
+if (sourceParameter.getSpecification().isIndexed()) {
-builder.string("[" + parameter.getIndex() + "]");
+builder.string("[" + sourceParameter.getIndex() + "]");
 }
 builder.string(".");
 }
 builder.startCall(execType.getMethodName());
 if (execType.getParameters().size() == 1) {
 builder.string("frameValue");
 }
 builder.end();
-}
+return builder.getRoot();
+}
-private boolean startShortCircuit(CodeTreeBuilder builder, SpecializationData specialization, ActualParameter parameter, ActualParameter exceptionParam) {
+private CodeTree createShortCircuitTree(CodeTreeBuilder parent, CodeTree body, String targetVariableName, ExecutableTypeData currentExecutable, SpecializationData specialization,
+ActualParameter parameter, ActualParameter exceptionParam) {
+CodeTreeBuilder builder = new CodeTreeBuilder(parent);
 NodeFieldData forField = specialization.getNode().findField(parameter.getSpecification().getName());
 if (forField == null) {
-return false;
+return body;
 }
 if (forField.getExecutionKind() != ExecutionKind.SHORT_CIRCUIT) {
-return false;
+return body;
 }
 ActualParameter shortCircuitParam = specialization.getPreviousParam(parameter);
 int shortCircuitIndex = 0;
 }
 shortCircuitIndex++;
 }
 }
-builder.startStatement().type(shortCircuitParam.getActualType()).string(" ").string(valueName(shortCircuitParam)).string(" = ");
+builder.startStatement().type(shortCircuitParam.getType()).string(" ").string(valueName(shortCircuitParam)).string(" = ");
 ShortCircuitData shortCircuitData = specialization.getShortCircuits().get(shortCircuitIndex);
-builder.tree(createTemplateMethodCall(builder, shortCircuitData, shortCircuitData, exceptionParam != null ? exceptionParam.getLocalName() : null));
+builder.tree(createTemplateMethodCall(builder, currentExecutable, shortCircuitData, exceptionParam != null ? exceptionParam.getLocalName() : null));
 builder.end(); // statement
-builder.declaration(parameter.getActualType(), valueName(parameter), CodeTreeBuilder.createBuilder().defaultValue(parameter.getActualType()));
+builder.declaration(parameter.getType(), targetVariableName, CodeTreeBuilder.createBuilder().defaultValue(parameter.getType()));
 builder.startIf().string(shortCircuitParam.getLocalName()).end();
 builder.startBlock();
+builder.tree(body);
-return true;
+builder.end();
-}
+return builder.getRoot();
-private void endShortCircuit(CodeTreeBuilder builder, boolean shortCircuit) {
+}
-if (shortCircuit) {
-builder.end();
+private CodeTree createReturnSpecializeAndExecute(CodeTreeBuilder parent, ExecutableTypeData executable, SpecializationData nextSpecialization, ActualParameter exceptionParam) {
-}
-}
-private CodeTree createReturnSpecializeAndExecute(CodeTreeBuilder parent, SpecializationData nextSpecialization, ActualParameter exceptionParam) {
 CodeTreeBuilder specializeCall = new CodeTreeBuilder(parent);
 specializeCall.startCall("specializeAndExecute");
 specializeCall.string(nodeSpecializationClassName(nextSpecialization) + ".class");
-addInternalValueParameterNames(specializeCall, nextSpecialization.getNode().getGenericSpecialization(), exceptionParam != null ? exceptionParam.getLocalName() : null, true, true);
+addInternalValueParameterNames(specializeCall, executable, nextSpecialization.getNode().getGenericSpecialization(), exceptionParam != null ? exceptionParam.getLocalName() : null, true,
+true);
 specializeCall.end().end();
 CodeTreeBuilder builder = new CodeTreeBuilder(parent);
 builder.startReturn();
-builder.tree(specializeCall.getRoot());
+builder.tree(createExpectType(nextSpecialization.getNode(), executable, specializeCall.getRoot()));
 builder.end();
 return builder.getRoot();
 }
 private void buildSpecializeAndExecute(CodeTypeElement clazz, SpecializationData specialization) {
 NodeData node = specialization.getNode();
-TypeData returnType = specialization.getReturnType().getActualTypeData(node.getTypeSystem());
+TypeData returnType = node.getGenericSpecialization().getReturnType().getTypeSystemType();
-ExecutableTypeData returnExecutableType = node.findExecutableType(returnType);
-boolean canThrowUnexpected = returnExecutableType == null ? true : returnExecutableType.hasUnexpectedValue(getContext());
 CodeExecutableElement method = new CodeExecutableElement(modifiers(PRIVATE), returnType.getPrimitiveType(), "specializeAndExecute");
 method.addParameter(new CodeVariableElement(getContext().getType(Class.class), "minimumState"));
-if (canThrowUnexpected) {
-method.addThrownType(getUnexpectedValueException());
-}
 addInternalValueParameters(method, specialization.getNode().getGenericSpecialization(), true);
 clazz.add(method);
 CodeTreeBuilder builder = method.createBuilder();
 emitSpecializationListeners(builder, specialization.getNode());
 builder.startStatement();
 builder.startCall("replace");
 builder.startCall(factoryClassName(specialization.getNode()), "specialize").string("this").string("minimumState");
-addInternalValueParameterNames(builder, specialization.getNode().getGenericSpecialization(), null, true, true);
+addInternalValueParameterNames(builder, specialization.getNode().getGenericSpecialization(), specialization.getNode().getGenericSpecialization(), null, true, true);
 builder.end();
 builder.end(); // call replace
 builder.end(); // statement
 String generatedMethodName;
 ExecutableElement generatedGeneric = clazz.getEnclosingClass().getMethod(generatedMethodName);
 CodeTreeBuilder genericExecute = CodeTreeBuilder.createBuilder();
 genericExecute.startCall(factoryClassName(specialization.getNode()), generatedMethodName);
 genericExecute.string("this");
-addInternalValueParameterNames(genericExecute, specialization.getNode().getGenericSpecialization(), null, true, true);
+addInternalValueParameterNames(genericExecute, specialization.getNode().getGenericSpecialization(), specialization.getNode().getGenericSpecialization(), null, true, true);
 genericExecute.end(); // call generated generic
-CodeTree genericInvocation = createExpectType(node, returnExecutableType, genericExecute.getRoot());
+CodeTree genericInvocation = 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 @ 9217:61ba6fc21ba4