Mercurial > hg > truffle

changeset 7750:bdcb3cc47e16

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Generated nodes can now handle the case were a non generic execute methods does not throw an UVE. Optimized casting execute method generation.
author Christian Humer <christian.humer@gmail.com>
date Fri, 08 Feb 2013 15:59:43 +0100
parents d16336557215
children ef1b41ea0a90
files graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/node/NodeCodeGenerator.java graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/typesystem/TypeSystemCodeGenerator.java
diffstat 2 files changed, 67 insertions(+), 39 deletions(-) [+]
line wrap: on
line diff
--- a/graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/node/NodeCodeGenerator.java	Mon Feb 04 17:04:23 2013 +0100
+++ b/graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/node/NodeCodeGenerator.java	Fri Feb 08 15:59:43 2013 +0100
@@ -529,57 +529,77 @@
             NodeData node = specialization.getNode();
             TypeSystemData typeSystem = node.getTypeSystem();
 
-            if (!type.isVoid()) {
-                builder.startStatement().type(specialization.getReturnType().getActualType()).string(" result").end();
-            }
-
+            ExecutableTypeData castedType = node.findExecutableType(type);
             TypeData primaryType = specialization.getReturnType().getActualTypeData(typeSystem);
             ExecutableTypeData execType = specialization.getNode().findExecutableType(primaryType);
 
-            boolean needsTry = !specialization.getReturnType().getActualTypeData(typeSystem).isGeneric();
-            if (needsTry) {
-                builder.startTryBlock();
-            }
+            boolean needsTry = execType.hasUnexpectedValue(getContext());
+            boolean returnVoid = type.isVoid();
 
-            builder.startStatement();
-            if (!type.isVoid()) {
-                builder.string("result = ");
-            }
-            buildExecute(builder, null, execType);
-            builder.end(); // statement
+            CodeTree primaryExecuteCall = null;
+
+            CodeTreeBuilder executeBuilder = CodeTreeBuilder.createBuilder();
+            buildExecute(executeBuilder, null, execType);
+            primaryExecuteCall = executeBuilder.getRoot();
 
             if (needsTry) {
-                builder.end().startCatchBlock(getUnexpectedValueException(), "ex");
+                if (!returnVoid) {
+                    builder.declaration(primaryType.getPrimitiveType(), "value");
+                }
+                builder.startTryBlock();
 
-                if (!type.isVoid()) {
-                    builder.startReturn();
-                    if (!type.isGeneric()) {
-                        startCallTypeSystemMethod(getContext(), builder, node, TypeSystemCodeGenerator.expectTypeMethodName(type));
-                    }
+                if (returnVoid) {
+                    builder.statement(primaryExecuteCall);
+                } else {
+                    builder.startStatement();
+                    builder.string("value = ");
+                    builder.tree(primaryExecuteCall);
+                    builder.end();
+                }
 
-                    builder.string("ex.getResult()");
+                builder.end().startCatchBlock(getUnexpectedValueException(), "ex");
+                if (returnVoid) {
+                    builder.string("// ignore").newLine();
+                } else {
+                    builder.startReturn();
+                    builder.tree(castPrimaryExecute(node, castedType, CodeTreeBuilder.singleString("ex.getResult()")));
+                    builder.end();
+                }
+                builder.end();
 
-                    if (!type.isGeneric()) {
-                        builder.end().end();
-                    }
-                    builder.end(); // return
+                if (!returnVoid) {
+                    builder.startReturn();
+                    builder.tree(castPrimaryExecute(node, castedType, CodeTreeBuilder.singleString("value")));
+                    builder.end();
+                }
+            } else {
+                if (returnVoid) {
+                    builder.statement(primaryExecuteCall);
                 } else {
-                    builder.string("// ignore").newLine();
+                    builder.startReturn();
+                    builder.tree(castPrimaryExecute(node, castedType, primaryExecuteCall));
+                    builder.end();
                 }
             }
-            builder.end(); // try/catch
+        }
+
+        private CodeTree castPrimaryExecute(NodeData node, ExecutableTypeData castedType, CodeTree value) {
+            if (castedType.getType().isVoid()) {
+                return value;
+            }
+            if (castedType.getType().isGeneric()) {
+                return value;
+            }
 
-            if (!type.isVoid()) {
-                builder.startReturn();
-                if (!type.isGeneric()) {
-                    startCallTypeSystemMethod(getContext(), builder, node, TypeSystemCodeGenerator.expectTypeMethodName(type));
-                }
-                builder.string("result");
-                if (!type.isGeneric()) {
-                    builder.end().end();
-                }
-                builder.end(); // return
+            CodeTreeBuilder builder = CodeTreeBuilder.createBuilder();
+            if (castedType.hasUnexpectedValue(getContext())) {
+                startCallTypeSystemMethod(getContext(), builder, node, TypeSystemCodeGenerator.expectTypeMethodName(castedType.getType()));
+            } else {
+                startCallTypeSystemMethod(getContext(), builder, node, TypeSystemCodeGenerator.asTypeMethodName(castedType.getType()));
             }
+            builder.tree(value);
+            builder.end().end();
+            return builder.getRoot();
         }
 
         private void buildFunctionalExecuteMethod(CodeTreeBuilder builder, SpecializationData specialization) {
@@ -794,16 +814,22 @@
             addValueParameterNames(specializeCall, nextSpecialization.getNode().getGenericSpecialization(), exceptionSpec != null ? exceptionSpec.getName() : null, true);
             specializeCall.end().end();
 
+            TypeData expectedType = currentSpecialization.getReturnType().getActualTypeData(currentSpecialization.getNode().getTypeSystem());
             if (canThrowUnexpected) {
                 builder.startReturn();
-                TypeData expectedType = currentSpecialization.getReturnType().getActualTypeData(currentSpecialization.getNode().getTypeSystem());
                 startCallTypeSystemMethod(context, builder, currentSpecialization.getNode(), TypeSystemCodeGenerator.expectTypeMethodName(expectedType));
                 builder.tree(specializeCall.getRoot());
                 builder.end().end();
                 builder.end(); // return
             } else {
                 builder.startReturn();
-                builder.tree(specializeCall.getRoot());
+                if (!expectedType.isVoid() && !expectedType.isGeneric()) {
+                    startCallTypeSystemMethod(context, builder, currentSpecialization.getNode(), TypeSystemCodeGenerator.asTypeMethodName(expectedType));
+                    builder.tree(specializeCall.getRoot());
+                    builder.end().end();
+                } else {
+                    builder.tree(specializeCall.getRoot());
+                }
                 builder.end();
             }
 
--- a/graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/typesystem/TypeSystemCodeGenerator.java	Mon Feb 04 17:04:23 2013 +0100
+++ b/graal/com.oracle.truffle.codegen.processor/src/com/oracle/truffle/codegen/processor/typesystem/TypeSystemCodeGenerator.java	Fri Feb 08 15:59:43 2013 +0100
@@ -215,6 +215,7 @@
             method.addParameter(new CodeVariableElement(getContext().getType(Object.class), LOCAL_VALUE));
 
             CodeTreeBuilder body = method.createBuilder();
+            body.startAssert().startCall(isTypeMethodName(type)).string(LOCAL_VALUE).end().end();
             body.startReturn().cast(type.getPrimitiveType(), body.create().string(LOCAL_VALUE).getTree()).end();
 
             return method;
@@ -233,5 +234,6 @@
 
             return method;
         }
+
     }
 }