Changeset 4283 for trunk/ProjectFortress/src

Timestamp:

10/23/09 14:40:53 (5 weeks ago)

Author:

jmaessen

Message:

[codegen] Refactored forwarding method generation into
InstantiatingClassloader so that we don't have 3 (and soon more)
copies of basically the same code. That said, the code is a wee bit
fiddly.

Location:

trunk/ProjectFortress/src/com/sun/fortress

Files:

• compiler/codegen/CodeGen.java (modified) (7 diffs)
• compiler/codegen/ManglingMethodVisitor.java (modified) (3 diffs)
• compiler/nativeInterface/FortressMethodAdapter.java (modified) (1 diff)
• runtimeSystem/InstantiatingClassloader.java (modified) (1 diff)

trunk/ProjectFortress/src/com/sun/fortress/compiler/codegen/CodeGen.java

@@ -629 +629 @@
 
     private void generateGenericMethodClass(FnDecl x, IdOrOp name,
-                                            
                                             int selfIndex) {
         /*
@@ -756 +755 @@
          */
 
-        modifiers = Opcodes.ACC_PUBLIC;
-
-        cg = new CodeGen(this);
-
-        String osig = sig;
-
-        String selfSig =  Naming.nthSigParameter(osig,0);
-        selfSig = Useful.substring(selfSig, 1, -1);
-        // Get rid of explicit self parameter.
-        sig = Naming.removeNthSigParameter(sig, 0);
-
-        // TODO different collision rules for top-level and for
-        // methods.
-        // SAME MNAME
-
-        // trait default OR top level.
-
-        cg.mv = cw.visitCGMethod(modifiers, mname, sig, null, null);
-        cg.mv.visitCode();
-
-        // We received "self" in parameter 0
-        cg.mv.visitVarInsn(ALOAD, 0);
-        // Need to downcast, maybe. this may only matter for weird primitive types.
-        cg.mv.visitTypeInsn(Opcodes.CHECKCAST, selfSig);//NamingCzar.jvmTypeDesc(ty, ifNone, false));
-
-        for (int i = 0; i < params.size(); i++) {
-            // 0 1 2
-            // a self b
-            // self a b
-            if (i < selfIndex) {
-                cg.mv.visitVarInsn(ALOAD, i+1);
-            } else if (i > selfIndex) {
-                cg.mv.visitVarInsn(ALOAD, i);
-            }
-
-        }
-        cg.mv.visitMethodInsn(INVOKESTATIC,
-                              springBoardClass,
-                              mname,
-                              osig);
-
-
-        methodReturnAndFinish(cg);
+        // Dotted method; downcast self and
+        // forward to static method in springboard class
+        // with explicit self parameter.
+        InstantiatingClassloader.forwardingMethod(cw, mname, ACC_PUBLIC, 0,
+                                                  springBoardClass, mname, INVOKESTATIC,
+                                                  sig, params.size(), true);
     }
 
@@ -878 +840 @@
 
         body.accept(this);
-        exitMethodScope(selfIndex, this, selfVar, paramsGen);
+        exitMethodScope(selfIndex, selfVar, paramsGen);
     }
 
@@ -1193 +1155 @@
      * @param paramsGen
      */
-    private void exitMethodScope(int selfIndex, CodeGen cg, VarCodeGen selfVar,
-            List<VarCodeGen> paramsGen) {
+    private void exitMethodScope(int selfIndex, VarCodeGen selfVar, List<VarCodeGen> paramsGen) {
         for (int i = paramsGen.size() - 1; i >= 0; i--) {
             if (i != selfIndex) {
                 VarCodeGen v = paramsGen.get(i);
-                v.outOfScope(cg.mv);
+                v.outOfScope(mv);
             }
         }
         if (selfVar != null)
-            selfVar.outOfScope(cg.mv);
-
-        methodReturnAndFinish(cg);
+            selfVar.outOfScope(mv);
+
+        methodReturnAndFinish();
     }
 
@@ -1220 +1181 @@
                                          com.sun.fortress.nodes.Type returnType,
                                          boolean savedInATrait) {
-        int modifiers = Opcodes.ACC_PUBLIC;
-
-        CodeGen cg = new CodeGen(this);
-        // Just a wrapper around the body itself
-        modifiers |= Opcodes.ACC_STATIC;
+        int modifiers = Opcodes.ACC_PUBLIC + Opcodes.ACC_STATIC;
         String sig =
             NamingCzar.jvmSignatureFor(NodeUtil.getParamType(x), returnType,
                                        component.getName());
 
-        String dottedSig = Naming.removeNthSigParameter(sig, selfIndex);
-
         // TODO different collision rules for top-level and for methods.
         String mname = nonCollidingSingleName(name, sig);
         String dottedName = fmDottedName(singleName(name), selfIndex);
 
-        cg.mv = cw.visitCGMethod(modifiers, mname, sig, null, null);
-        cg.mv.visitCode();
-
-        // Now inside method body. Generate code for the method body.
-        // Start by binding the parameters and setting up the initial
-        // locals.
-        VarCodeGen selfVar = null;
-        List<VarCodeGen> paramsGen =
-            new ArrayList<VarCodeGen>(params.size());
-
-        // Invoke the dotted method, thank you very much.
-        // -----------
-
-        // TODO will have to get smarter with unboxing
-        cg.mv.visitVarInsn(ALOAD, selfIndex);
-        for (int i = 0; i < params.size(); i++) {
-            if (i != selfIndex)
-                cg.mv.visitVarInsn(ALOAD, i);
-
-        }
-        cg.mv.visitMethodInsn(savedInATrait ? INVOKEINTERFACE
-                : INVOKEVIRTUAL, traitOrObjectName, dottedName,
-                dottedSig);
-
-        // -----------
-        // Method body is complete except for returning final result if any.
-        // TODO: Fancy footwork here later on if we need to return a
-        // non-pointer; for now every fortress functional returns a single
-        // pointer result.
-        methodReturnAndFinish(cg);
-        // Method body complete, cg now invalid.
+        int invocation = savedInATrait ? INVOKEINTERFACE : INVOKEVIRTUAL;
+
+        InstantiatingClassloader.forwardingMethod(cw,
+                         mname, modifiers, selfIndex,
+                         traitOrObjectName, dottedName, invocation,
+                         sig, params.size(), true);
+
     }
 
@@ -1271 +1202 @@
      * @param cg
      */
-    private void methodReturnAndFinish(CodeGen cg) {
-        cg.mv.visitInsn(Opcodes.ARETURN);
-        cg.mv.visitMaxs(NamingCzar.ignore, NamingCzar.ignore);
-        cg.mv.visitEnd();
+    private void methodReturnAndFinish() {
+        mv.visitInsn(Opcodes.ARETURN);
+        mv.visitMaxs(NamingCzar.ignore, NamingCzar.ignore);
+        mv.visitEnd();
     }
 
@@ -1340 +1271 @@
         body.accept(cg);
 
-        methodReturnAndFinish(cg);
+        cg.methodReturnAndFinish();
         cg.dumpClass(className);
 

trunk/ProjectFortress/src/com/sun/fortress/compiler/codegen/ManglingMethodVisitor.java

@@ -31 +31 @@
 
 public class ManglingMethodVisitor extends MethodAdapter {
-  
+
 
     public ManglingMethodVisitor(MethodVisitor mvisitor) {
         super(mvisitor);
-     
+
     }
 
@@ -46 +46 @@
     public void visitFieldInsn(int opcode, String owner, String name,
             String desc) {
-        
+
         owner = Naming.mangleFortressIdentifier(owner);
         name = Naming.mangleMemberName(name);
@@ -57 +57 @@
     public void visitLocalVariable(String name, String desc, String signature,
             Label start, Label end, int index) {
-        
+
         signature = Naming.mangleFortressIdentifier(signature);
         name = Naming.mangleMemberName(name);

trunk/ProjectFortress/src/com/sun/fortress/compiler/nativeInterface/FortressMethodAdapter.java

@@ -162 +162 @@
         SignatureParser sp = new SignatureParser(desc);
         String fsig = sp.getFortressifiedSignature();
+
+        // FORWARDING METHOD, only with type conversions on the way in/out!
         MethodVisitor mv = cv.visitMethod(access, name, fsig, signature,
                 exceptions);

trunk/ProjectFortress/src/com/sun/fortress/runtimeSystem/InstantiatingClassloader.java

@@ -354 +354 @@
 
             if (LOG_LOADS) System.err.println(name + ".apply" + sig + " concrete\nparams = " + parameters);
-            mv = cw.visitMethod(ACC_PUBLIC, Naming.APPLY_METHOD, sig, null, null);
-            mv.visitCode();
-            // Is this right?  What about a 2-arg function that takes a void as its second arg?
-            // This can happen with generic instantiations of various sorts (esp the default
-            // seq implementation!).
-            for (int i = 1; i < parameters.size();i++) {
-                String param = parameters.get(i-1);
-                if (! param.equals(Naming.INTERNAL_SNOWMAN))
-                    mv.visitVarInsn(ALOAD, i);
-
+
+            int sz = parameters.size();
+            // Last parameter is actually result type!
+            // But we need to include an extra arg in sz to represent the closure itself (this).
+            if (sz==2 && Naming.INTERNAL_SNOWMAN.equals(parameters.get(0))) {
+                // Arity 1 (sz 2) with void parameter should actually be arity 0 (sz 1).
+                sz = 1;
             }
-            mv.visitMethodInsn(INVOKESTATIC, staticClass, fn, sig);
-            // ARETURN if not void...
-            mv.visitInsn(ARETURN);
-
-            mv.visitMaxs(2, 3);
-            mv.visitEnd();
-        }
+
+            forwardingMethod(cw, Naming.APPLY_METHOD, ACC_PUBLIC, 0,
+                             staticClass, fn, INVOKESTATIC,
+                             sig, sz, false);
+        }
+    }
+
+    /** Create forwarding method that re-pushes its arguments and
+     * chains to another method in another class.
+     * When selfIndex == -1, all arguments are pushed exactly in the order given,
+     * and the input and output signatures are assumed to be the same (so this can
+     * also be used to pass along a self parameter without mucking about).
+     * Otherwise selfIndex indicates the index of a self parameter; when pushSelf
+     * is true this index is pushed first.
+     *
+     * How do we determine incoming and outgoing signatures?
+     */
+    public static void forwardingMethod(ClassWriter cw,
+                                        String thisName, int thisModifiers, int selfIndex,
+                                        String fwdClass, String fwdName, int fwdOp,
+                                        String maximalSig,
+                                        int nparamsIncludingSelf, boolean pushSelf) {
+        String thisSig = maximalSig;
+        String fwdSig = maximalSig;
+        String selfSig = null;
+        if (pushSelf) {
+            selfSig = Naming.nthSigParameter(maximalSig, selfIndex);
+            selfSig = selfSig.substring(1, selfSig.length()-1);
+            if ((thisModifiers & ACC_STATIC) != 0) {
+                if (fwdOp != INVOKESTATIC) {
+                    // receiver has explicit self, fwd is dotted.
+                    fwdSig = Naming.removeNthSigParameter(maximalSig, selfIndex);
+                }
+            } else if (fwdOp == INVOKESTATIC) {
+                thisSig = Naming.removeNthSigParameter(maximalSig, selfIndex);
+            }
+        } else if (selfIndex >= 0 && (thisModifiers & ACC_STATIC) != 0) {
+            // Dropping explicit self parameter, so remove from signature.
+            fwdSig = Naming.removeNthSigParameter(maximalSig, selfIndex);
+        }
+        // System.err.println("Forwarding "+thisName+":"+thisSig+
+        //                    " arity "+nparamsIncludingSelf+"\n"+
+        //                    "  to       "+fwdClass+"."+fwdName+":"+fwdSig);
+        MethodVisitor mv = cw.visitMethod(thisModifiers, thisName, thisSig, null, null);
+        mv.visitCode();
+        if (pushSelf) {
+            mv.visitVarInsn(ALOAD, selfIndex);
+            mv.visitTypeInsn(CHECKCAST, selfSig);
+        }
+        for (int i = 0; i < nparamsIncludingSelf; i++) {
+            if (i==selfIndex) continue;
+            mv.visitVarInsn(ALOAD, i);
+        }
+        mv.visitMethodInsn(fwdOp, fwdClass, fwdName, fwdSig);
+        mv.visitInsn(ARETURN);
+
+        mv.visitMaxs(2, 3);
+        mv.visitEnd();
     }