Mercurial Mercurial > jdk-sandbox / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
jdk/src/share/classes/sun/dyn/MethodHandleImpl.java
changeset 7556 4a5711d43948
parent 7555 a279ebc3b25c
child 8345 9e2483e6cfab
equal deleted inserted replaced
7555:a279ebc3b25c 7556:4a5711d43948 
   243         private C allocate() throws InstantiationException {
 
   243         private C allocate() throws InstantiationException {
 
   244             return (C) unsafe.allocateInstance(allocateClass);
 
   244             return (C) unsafe.allocateInstance(allocateClass);
 
   245         }
 
   245         }
 
   246         private C invoke_V(Object... av) throws Throwable {
 
   246         private C invoke_V(Object... av) throws Throwable {
 
   247             C obj = allocate();
 
   247             C obj = allocate();
 
   248             rawConstructor.<void>invokeExact((Object)obj, av);
 
   248             rawConstructor.invokeExact((Object)obj, av);
 
   249             return obj;
 
   249             return obj;
 
   250         }
 
   250         }
 
   251         private C invoke_L0() throws Throwable {
 
   251         private C invoke_L0() throws Throwable {
 
   252             C obj = allocate();
 
   252             C obj = allocate();
 
   253             rawConstructor.<void>invokeExact((Object)obj);
 
   253             rawConstructor.invokeExact((Object)obj);
 
   254             return obj;
 
   254             return obj;
 
   255         }
 
   255         }
 
   256         private C invoke_L1(Object a0) throws Throwable {
 
   256         private C invoke_L1(Object a0) throws Throwable {
 
   257             C obj = allocate();
 
   257             C obj = allocate();
 
   258             rawConstructor.<void>invokeExact((Object)obj, a0);
 
   258             rawConstructor.invokeExact((Object)obj, a0);
 
   259             return obj;
 
   259             return obj;
 
   260         }
 
   260         }
 
   261         private C invoke_L2(Object a0, Object a1) throws Throwable {
 
   261         private C invoke_L2(Object a0, Object a1) throws Throwable {
 
   262             C obj = allocate();
 
   262             C obj = allocate();
 
   263             rawConstructor.<void>invokeExact((Object)obj, a0, a1);
 
   263             rawConstructor.invokeExact((Object)obj, a0, a1);
 
   264             return obj;
 
   264             return obj;
 
   265         }
 
   265         }
 
   266         private C invoke_L3(Object a0, Object a1, Object a2) throws Throwable {
 
   266         private C invoke_L3(Object a0, Object a1, Object a2) throws Throwable {
 
   267             C obj = allocate();
 
   267             C obj = allocate();
 
   268             rawConstructor.<void>invokeExact((Object)obj, a0, a1, a2);
 
   268             rawConstructor.invokeExact((Object)obj, a0, a1, a2);
 
   269             return obj;
 
   269             return obj;
 
   270         }
 
   270         }
 
   271         private C invoke_L4(Object a0, Object a1, Object a2, Object a3) throws Throwable {
 
   271         private C invoke_L4(Object a0, Object a1, Object a2, Object a3) throws Throwable {
 
   272             C obj = allocate();
 
   272             C obj = allocate();
 
   273             rawConstructor.<void>invokeExact((Object)obj, a0, a1, a2, a3);
 
   273             rawConstructor.invokeExact((Object)obj, a0, a1, a2, a3);
 
   274             return obj;
 
   274             return obj;
 
   275         }
 
   275         }
 
   276         private C invoke_L5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable {
 
   276         private C invoke_L5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable {
 
   277             C obj = allocate();
 
   277             C obj = allocate();
 
   278             rawConstructor.<void>invokeExact((Object)obj, a0, a1, a2, a3, a4);
 
   278             rawConstructor.invokeExact((Object)obj, a0, a1, a2, a3, a4);
 
   279             return obj;
 
   279             return obj;
 
   280         }
 
   280         }
 
   281         private C invoke_L6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable {
 
   281         private C invoke_L6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable {
 
   282             C obj = allocate();
 
   282             C obj = allocate();
 
   283             rawConstructor.<void>invokeExact((Object)obj, a0, a1, a2, a3, a4, a5);
 
   283             rawConstructor.invokeExact((Object)obj, a0, a1, a2, a3, a4, a5);
 
   284             return obj;
 
   284             return obj;
 
   285         }
 
   285         }
 
   286         private C invoke_L7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable {
 
   286         private C invoke_L7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable {
 
   287             C obj = allocate();
 
   287             C obj = allocate();
 
   288             rawConstructor.<void>invokeExact((Object)obj, a0, a1, a2, a3, a4, a5, a6);
 
   288             rawConstructor.invokeExact((Object)obj, a0, a1, a2, a3, a4, a5, a6);
 
   289             return obj;
 
   289             return obj;
 
   290         }
 
   290         }
 
   291         private C invoke_L8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable {
 
   291         private C invoke_L8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable {
 
   292             C obj = allocate();
 
   292             C obj = allocate();
 
   293             rawConstructor.<void>invokeExact((Object)obj, a0, a1, a2, a3, a4, a5, a6, a7);
 
   293             rawConstructor.invokeExact((Object)obj, a0, a1, a2, a3, a4, a5, a6, a7);
 
   294             return obj;
 
   294             return obj;
 
   295         }
 
   295         }
 
   296         static MethodHandle[] makeInvokes() {
 
   296         static MethodHandle[] makeInvokes() {
 
   297             ArrayList<MethodHandle> invokes = new ArrayList<MethodHandle>();
 
   297             ArrayList<MethodHandle> invokes = new ArrayList<MethodHandle>();
 
   298             MethodHandles.Lookup lookup = IMPL_LOOKUP;
 
   298             MethodHandles.Lookup lookup = IMPL_LOOKUP;
 
   949         @Override
 
   949         @Override
 
   950         public String toString() {
 
   950         public String toString() {
 
   951             return addTypeString(target, this);
 
   951             return addTypeString(target, this);
 
   952         }
 
   952         }
 
   953         private Object invoke_V(Object... av) throws Throwable {
 
   953         private Object invoke_V(Object... av) throws Throwable {
 
   954             if (test.<boolean>invokeExact(av))
 
   954             if ((boolean) test.invokeExact(av))
 
   955                 return target.<Object>invokeExact(av);
 
   955                 return target.invokeExact(av);
 
   956             return fallback.<Object>invokeExact(av);
 
   956             return fallback.invokeExact(av);
 
   957         }
 
   957         }
 
   958         private Object invoke_L0() throws Throwable {
 
   958         private Object invoke_L0() throws Throwable {
 
   959             if (test.<boolean>invokeExact())
 
   959             if ((boolean) test.invokeExact())
 
   960                 return target.<Object>invokeExact();
 
   960                 return target.invokeExact();
 
   961             return fallback.<Object>invokeExact();
 
   961             return fallback.invokeExact();
 
   962         }
 
   962         }
 
   963         private Object invoke_L1(Object a0) throws Throwable {
 
   963         private Object invoke_L1(Object a0) throws Throwable {
 
   964             if (test.<boolean>invokeExact(a0))
 
   964             if ((boolean) test.invokeExact(a0))
 
   965                 return target.<Object>invokeExact(a0);
 
   965                 return target.invokeExact(a0);
 
   966             return fallback.<Object>invokeExact(a0);
 
   966             return fallback.invokeExact(a0);
 
   967         }
 
   967         }
 
   968         private Object invoke_L2(Object a0, Object a1) throws Throwable {
 
   968         private Object invoke_L2(Object a0, Object a1) throws Throwable {
 
   969             if (test.<boolean>invokeExact(a0, a1))
 
   969             if ((boolean) test.invokeExact(a0, a1))
 
   970                 return target.<Object>invokeExact(a0, a1);
 
   970                 return target.invokeExact(a0, a1);
 
   971             return fallback.<Object>invokeExact(a0, a1);
 
   971             return fallback.invokeExact(a0, a1);
 
   972         }
 
   972         }
 
   973         private Object invoke_L3(Object a0, Object a1, Object a2) throws Throwable {
 
   973         private Object invoke_L3(Object a0, Object a1, Object a2) throws Throwable {
 
   974             if (test.<boolean>invokeExact(a0, a1, a2))
 
   974             if ((boolean) test.invokeExact(a0, a1, a2))
 
   975                 return target.<Object>invokeExact(a0, a1, a2);
 
   975                 return target.invokeExact(a0, a1, a2);
 
   976             return fallback.<Object>invokeExact(a0, a1, a2);
 
   976             return fallback.invokeExact(a0, a1, a2);
 
   977         }
 
   977         }
 
   978         private Object invoke_L4(Object a0, Object a1, Object a2, Object a3) throws Throwable {
 
   978         private Object invoke_L4(Object a0, Object a1, Object a2, Object a3) throws Throwable {
 
   979             if (test.<boolean>invokeExact(a0, a1, a2, a3))
 
   979             if ((boolean) test.invokeExact(a0, a1, a2, a3))
 
   980                 return target.<Object>invokeExact(a0, a1, a2, a3);
 
   980                 return target.invokeExact(a0, a1, a2, a3);
 
   981             return fallback.<Object>invokeExact(a0, a1, a2, a3);
 
   981             return fallback.invokeExact(a0, a1, a2, a3);
 
   982         }
 
   982         }
 
   983         private Object invoke_L5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable {
 
   983         private Object invoke_L5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable {
 
   984             if (test.<boolean>invokeExact(a0, a1, a2, a3, a4))
 
   984             if ((boolean) test.invokeExact(a0, a1, a2, a3, a4))
 
   985                 return target.<Object>invokeExact(a0, a1, a2, a3, a4);
 
   985                 return target.invokeExact(a0, a1, a2, a3, a4);
 
   986             return fallback.<Object>invokeExact(a0, a1, a2, a3, a4);
 
   986             return fallback.invokeExact(a0, a1, a2, a3, a4);
 
   987         }
 
   987         }
 
   988         private Object invoke_L6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable {
 
   988         private Object invoke_L6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable {
 
   989             if (test.<boolean>invokeExact(a0, a1, a2, a3, a4, a5))
 
   989             if ((boolean) test.invokeExact(a0, a1, a2, a3, a4, a5))
 
   990                 return target.<Object>invokeExact(a0, a1, a2, a3, a4, a5);
 
   990                 return target.invokeExact(a0, a1, a2, a3, a4, a5);
 
   991             return fallback.<Object>invokeExact(a0, a1, a2, a3, a4, a5);
 
   991             return fallback.invokeExact(a0, a1, a2, a3, a4, a5);
 
   992         }
 
   992         }
 
   993         private Object invoke_L7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable {
 
   993         private Object invoke_L7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable {
 
   994             if (test.<boolean>invokeExact(a0, a1, a2, a3, a4, a5, a6))
 
   994             if ((boolean) test.invokeExact(a0, a1, a2, a3, a4, a5, a6))
 
   995                 return target.<Object>invokeExact(a0, a1, a2, a3, a4, a5, a6);
 
   995                 return target.invokeExact(a0, a1, a2, a3, a4, a5, a6);
 
   996             return fallback.<Object>invokeExact(a0, a1, a2, a3, a4, a5, a6);
 
   996             return fallback.invokeExact(a0, a1, a2, a3, a4, a5, a6);
 
   997         }
 
   997         }
 
   998         private Object invoke_L8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable {
 
   998         private Object invoke_L8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable {
 
   999             if (test.<boolean>invokeExact(a0, a1, a2, a3, a4, a5, a6, a7))
 
   999             if ((boolean) test.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7))
 
  1000                 return target.<Object>invokeExact(a0, a1, a2, a3, a4, a5, a6, a7);
 
  1000                 return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7);
 
  1001             return fallback.<Object>invokeExact(a0, a1, a2, a3, a4, a5, a6, a7);
 
  1001             return fallback.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7);
 
  1002         }
 
  1002         }
 
  1003         static MethodHandle[] makeInvokes() {
 
  1003         static MethodHandle[] makeInvokes() {
 
  1004             ArrayList<MethodHandle> invokes = new ArrayList<MethodHandle>();
 
  1004             ArrayList<MethodHandle> invokes = new ArrayList<MethodHandle>();
 
  1005             MethodHandles.Lookup lookup = IMPL_LOOKUP;
 
  1005             MethodHandles.Lookup lookup = IMPL_LOOKUP;
 
  1006             for (;;) {
 
  1006             for (;;) {
 
  1056         public String toString() {
 
  1056         public String toString() {
 
  1057             return addTypeString(target, this);
 
  1057             return addTypeString(target, this);
 
  1058         }
 
  1058         }
 
  1059         private Object invoke_V(Object... av) throws Throwable {
 
  1059         private Object invoke_V(Object... av) throws Throwable {
 
  1060             try {
 
  1060             try {
 
  1061                 return target.<Object>invokeExact(av);
 
  1061                 return target.invokeExact(av);
 
  1062             } catch (Throwable t) {
 
  1062             } catch (Throwable t) {
 
  1063                 if (!exType.isInstance(t))  throw t;
 
  1063                 if (!exType.isInstance(t))  throw t;
 
  1064                 return catcher.<Object>invokeExact(t, av);
 
  1064                 return catcher.invokeExact(t, av);
 
  1065             }
 
  1065             }
 
  1066         }
 
  1066         }
 
  1067         private Object invoke_L0() throws Throwable {
 
  1067         private Object invoke_L0() throws Throwable {
 
  1068             try {
 
  1068             try {
 
  1069                 return target.<Object>invokeExact();
 
  1069                 return target.invokeExact();
 
  1070             } catch (Throwable t) {
 
  1070             } catch (Throwable t) {
 
  1071                 if (!exType.isInstance(t))  throw t;
 
  1071                 if (!exType.isInstance(t))  throw t;
 
  1072                 return catcher.<Object>invokeExact(t);
 
  1072                 return catcher.invokeExact(t);
 
  1073             }
 
  1073             }
 
  1074         }
 
  1074         }
 
  1075         private Object invoke_L1(Object a0) throws Throwable {
 
  1075         private Object invoke_L1(Object a0) throws Throwable {
 
  1076             try {
 
  1076             try {
 
  1077                 return target.<Object>invokeExact(a0);
 
  1077                 return target.invokeExact(a0);
 
  1078             } catch (Throwable t) {
 
  1078             } catch (Throwable t) {
 
  1079                 if (!exType.isInstance(t))  throw t;
 
  1079                 if (!exType.isInstance(t))  throw t;
 
  1080                 return catcher.<Object>invokeExact(t, a0);
 
  1080                 return catcher.invokeExact(t, a0);
 
  1081             }
 
  1081             }
 
  1082         }
 
  1082         }
 
  1083         private Object invoke_L2(Object a0, Object a1) throws Throwable {
 
  1083         private Object invoke_L2(Object a0, Object a1) throws Throwable {
 
  1084             try {
 
  1084             try {
 
  1085                 return target.<Object>invokeExact(a0, a1);
 
  1085                 return target.invokeExact(a0, a1);
 
  1086             } catch (Throwable t) {
 
  1086             } catch (Throwable t) {
 
  1087                 if (!exType.isInstance(t))  throw t;
 
  1087                 if (!exType.isInstance(t))  throw t;
 
  1088                 return catcher.<Object>invokeExact(t, a0, a1);
 
  1088                 return catcher.invokeExact(t, a0, a1);
 
  1089             }
 
  1089             }
 
  1090         }
 
  1090         }
 
  1091         private Object invoke_L3(Object a0, Object a1, Object a2) throws Throwable {
 
  1091         private Object invoke_L3(Object a0, Object a1, Object a2) throws Throwable {
 
  1092             try {
 
  1092             try {
 
  1093                 return target.<Object>invokeExact(a0, a1, a2);
 
  1093                 return target.invokeExact(a0, a1, a2);
 
  1094             } catch (Throwable t) {
 
  1094             } catch (Throwable t) {
 
  1095                 if (!exType.isInstance(t))  throw t;
 
  1095                 if (!exType.isInstance(t))  throw t;
 
  1096                 return catcher.<Object>invokeExact(t, a0, a1, a2);
 
  1096                 return catcher.invokeExact(t, a0, a1, a2);
 
  1097             }
 
  1097             }
 
  1098         }
 
  1098         }
 
  1099         private Object invoke_L4(Object a0, Object a1, Object a2, Object a3) throws Throwable {
 
  1099         private Object invoke_L4(Object a0, Object a1, Object a2, Object a3) throws Throwable {
 
  1100             try {
 
  1100             try {
 
  1101                 return target.<Object>invokeExact(a0, a1, a2, a3);
 
  1101                 return target.invokeExact(a0, a1, a2, a3);
 
  1102             } catch (Throwable t) {
 
  1102             } catch (Throwable t) {
 
  1103                 if (!exType.isInstance(t))  throw t;
 
  1103                 if (!exType.isInstance(t))  throw t;
 
  1104                 return catcher.<Object>invokeExact(t, a0, a1, a2, a3);
 
  1104                 return catcher.invokeExact(t, a0, a1, a2, a3);
 
  1105             }
 
  1105             }
 
  1106         }
 
  1106         }
 
  1107         private Object invoke_L5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable {
 
  1107         private Object invoke_L5(Object a0, Object a1, Object a2, Object a3, Object a4) throws Throwable {
 
  1108             try {
 
  1108             try {
 
  1109                 return target.<Object>invokeExact(a0, a1, a2, a3, a4);
 
  1109                 return target.invokeExact(a0, a1, a2, a3, a4);
 
  1110             } catch (Throwable t) {
 
  1110             } catch (Throwable t) {
 
  1111                 if (!exType.isInstance(t))  throw t;
 
  1111                 if (!exType.isInstance(t))  throw t;
 
  1112                 return catcher.<Object>invokeExact(t, a0, a1, a2, a3, a4);
 
  1112                 return catcher.invokeExact(t, a0, a1, a2, a3, a4);
 
  1113             }
 
  1113             }
 
  1114         }
 
  1114         }
 
  1115         private Object invoke_L6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable {
 
  1115         private Object invoke_L6(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) throws Throwable {
 
  1116             try {
 
  1116             try {
 
  1117                 return target.<Object>invokeExact(a0, a1, a2, a3, a4, a5);
 
  1117                 return target.invokeExact(a0, a1, a2, a3, a4, a5);
 
  1118             } catch (Throwable t) {
 
  1118             } catch (Throwable t) {
 
  1119                 if (!exType.isInstance(t))  throw t;
 
  1119                 if (!exType.isInstance(t))  throw t;
 
  1120                 return catcher.<Object>invokeExact(t, a0, a1, a2, a3, a4, a5);
 
  1120                 return catcher.invokeExact(t, a0, a1, a2, a3, a4, a5);
 
  1121             }
 
  1121             }
 
  1122         }
 
  1122         }
 
  1123         private Object invoke_L7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable {
 
  1123         private Object invoke_L7(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) throws Throwable {
 
  1124             try {
 
  1124             try {
 
  1125                 return target.<Object>invokeExact(a0, a1, a2, a3, a4, a5, a6);
 
  1125                 return target.invokeExact(a0, a1, a2, a3, a4, a5, a6);
 
  1126             } catch (Throwable t) {
 
  1126             } catch (Throwable t) {
 
  1127                 if (!exType.isInstance(t))  throw t;
 
  1127                 if (!exType.isInstance(t))  throw t;
 
  1128                 return catcher.<Object>invokeExact(t, a0, a1, a2, a3, a4, a5, a6);
 
  1128                 return catcher.invokeExact(t, a0, a1, a2, a3, a4, a5, a6);
 
  1129             }
 
  1129             }
 
  1130         }
 
  1130         }
 
  1131         private Object invoke_L8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable {
 
  1131         private Object invoke_L8(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) throws Throwable {
 
  1132             try {
 
  1132             try {
 
  1133                 return target.<Object>invokeExact(a0, a1, a2, a3, a4, a5, a6, a7);
 
  1133                 return target.invokeExact(a0, a1, a2, a3, a4, a5, a6, a7);
 
  1134             } catch (Throwable t) {
 
  1134             } catch (Throwable t) {
 
  1135                 if (!exType.isInstance(t))  throw t;
 
  1135                 if (!exType.isInstance(t))  throw t;
 
  1136                 return catcher.<Object>invokeExact(t, a0, a1, a2, a3, a4, a5, a6, a7);
 
  1136                 return catcher.invokeExact(t, a0, a1, a2, a3, a4, a5, a6, a7);
 
  1137             }
 
  1137             }
 
  1138         }
 
  1138         }
 
  1139         static MethodHandle[] makeInvokes() {
 
  1139         static MethodHandle[] makeInvokes() {
 
  1140             ArrayList<MethodHandle> invokes = new ArrayList<MethodHandle>();
 
  1140             ArrayList<MethodHandle> invokes = new ArrayList<MethodHandle>();
 
  1141             MethodHandles.Lookup lookup = IMPL_LOOKUP;
 
  1141             MethodHandles.Lookup lookup = IMPL_LOOKUP;
jdk-sandbox