1075 LambdaFormEditor editor() {
1076 return LambdaFormEditor.lambdaFormEditor(this);
1077 }
1078
1079 boolean contains(Name name) {
1080 int pos = name.index();
1081 if (pos >= 0) {
1082 return pos < names.length && name.equals(names[pos]);
1083 }
1084 for (int i = arity; i < names.length; i++) {
1085 if (name.equals(names[i]))
1086 return true;
1087 }
1088 return false;
1089 }
1090
1091 static class NamedFunction {
1092 final MemberName member;
1093 private @Stable MethodHandle resolvedHandle;
1094 @Stable MethodHandle invoker;
1095
1096 NamedFunction(MethodHandle resolvedHandle) {
1097 this(resolvedHandle.internalMemberName(), resolvedHandle);
1098 }
1099 NamedFunction(MemberName member, MethodHandle resolvedHandle) {
1100 this.member = member;
1101 this.resolvedHandle = resolvedHandle;
1102 // The following assert is almost always correct, but will fail for corner cases, such as PrivateInvokeTest.
1103 //assert(!isInvokeBasic(member));
1104 }
1105 NamedFunction(MethodType basicInvokerType) {
1106 assert(basicInvokerType == basicInvokerType.basicType()) : basicInvokerType;
1107 if (basicInvokerType.parameterSlotCount() < MethodType.MAX_MH_INVOKER_ARITY) {
1108 this.resolvedHandle = basicInvokerType.invokers().basicInvoker();
1109 this.member = resolvedHandle.internalMemberName();
1110 } else {
1111 // necessary to pass BigArityTest
1112 this.member = Invokers.invokeBasicMethod(basicInvokerType);
1113 }
1114 assert(isInvokeBasic(member));
1115 }
1116
1117 private static boolean isInvokeBasic(MemberName member) {
1118 return member != null &&
1119 member.getDeclaringClass() == MethodHandle.class &&
1120 "invokeBasic".equals(member.getName());
1121 }
1122
1123 // The next 2 constructors are used to break circular dependencies on MH.invokeStatic, etc.
1124 // Any LambdaForm containing such a member is not interpretable.
1125 // This is OK, since all such LFs are prepared with special primitive vmentry points.
1126 // And even without the resolvedHandle, the name can still be compiled and optimized.
1127 NamedFunction(Method method) {
1128 this(new MemberName(method));
1129 }
1130 NamedFunction(MemberName member) {
1131 this(member, null);
1132 }
1133
1246 }
1247
1248 int arity() {
1249 return methodType().parameterCount();
1250 }
1251
1252 public String toString() {
1253 if (member == null) return String.valueOf(resolvedHandle);
1254 return member.getDeclaringClass().getSimpleName()+"."+member.getName();
1255 }
1256
1257 public boolean isIdentity() {
1258 return this.equals(identity(returnType()));
1259 }
1260
1261 public boolean isConstantZero() {
1262 return this.equals(constantZero(returnType()));
1263 }
1264
1265 public MethodHandleImpl.Intrinsic intrinsicName() {
1266 return resolvedHandle == null ? MethodHandleImpl.Intrinsic.NONE
1267 : resolvedHandle.intrinsicName();
1268 }
1269 }
1270
1271 public static String basicTypeSignature(MethodType type) {
1272 int params = type.parameterCount();
1273 char[] sig = new char[params + 2];
1274 int sigp = 0;
1275 while (sigp < params) {
1276 sig[sigp] = basicTypeChar(type.parameterType(sigp++));
1277 }
1278 sig[sigp++] = '_';
1279 sig[sigp++] = basicTypeChar(type.returnType());
1280 assert(sigp == sig.length);
1281 return String.valueOf(sig);
1282 }
1283 public static String shortenSignature(String signature) {
1284 // Hack to make signatures more readable when they show up in method names.
1285 final int NO_CHAR = -1, MIN_RUN = 3;
1286 int c0, c1 = NO_CHAR, c1reps = 0;
1287 StringBuilder buf = null;
1724 }
1725
1726 NamedFunction idFun;
1727 LambdaForm zeForm;
1728 NamedFunction zeFun;
1729
1730 // Create the LFs and NamedFunctions. Precompiling LFs to byte code is needed to break circular
1731 // bootstrap dependency on this method in case we're interpreting LFs
1732 if (isVoid) {
1733 Name[] idNames = new Name[] { argument(0, L_TYPE) };
1734 idForm = new LambdaForm(1, idNames, VOID_RESULT, Kind.IDENTITY);
1735 idForm.compileToBytecode();
1736 idFun = new NamedFunction(idMem, SimpleMethodHandle.make(idMem.getInvocationType(), idForm));
1737
1738 zeForm = idForm;
1739 zeFun = idFun;
1740 } else {
1741 Name[] idNames = new Name[] { argument(0, L_TYPE), argument(1, type) };
1742 idForm = new LambdaForm(2, idNames, 1, Kind.IDENTITY);
1743 idForm.compileToBytecode();
1744 idFun = new NamedFunction(idMem, MethodHandleImpl.makeIntrinsic(
1745 idMem.getInvocationType(), idForm, MethodHandleImpl.Intrinsic.IDENTITY));
1746
1747 Object zeValue = Wrapper.forBasicType(btChar).zero();
1748 Name[] zeNames = new Name[] { argument(0, L_TYPE), new Name(idFun, zeValue) };
1749 zeForm = new LambdaForm(1, zeNames, 1, Kind.ZERO);
1750 zeForm.compileToBytecode();
1751 zeFun = new NamedFunction(zeMem, MethodHandleImpl.makeIntrinsic(
1752 zeMem.getInvocationType(), zeForm, MethodHandleImpl.Intrinsic.ZERO));
1753 }
1754
1755 LF_zero[ord] = zeForm;
1756 NF_zero[ord] = zeFun;
1757 LF_identity[ord] = idForm;
1758 NF_identity[ord] = idFun;
1759
1760 assert(idFun.isIdentity());
1761 assert(zeFun.isConstantZero());
1762 assert(new Name(zeFun).isConstantZero());
1763 }
1764
1765 // Avoid appealing to ValueConversions at bootstrap time:
1766 private static int identity_I(int x) { return x; }
1767 private static long identity_J(long x) { return x; }
1768 private static float identity_F(float x) { return x; }
1769 private static double identity_D(double x) { return x; }
1770 private static Object identity_L(Object x) { return x; }
1771 private static void identity_V() { return; }
1772 private static int zero_I() { return 0; }
|
1075 LambdaFormEditor editor() {
1076 return LambdaFormEditor.lambdaFormEditor(this);
1077 }
1078
1079 boolean contains(Name name) {
1080 int pos = name.index();
1081 if (pos >= 0) {
1082 return pos < names.length && name.equals(names[pos]);
1083 }
1084 for (int i = arity; i < names.length; i++) {
1085 if (name.equals(names[i]))
1086 return true;
1087 }
1088 return false;
1089 }
1090
1091 static class NamedFunction {
1092 final MemberName member;
1093 private @Stable MethodHandle resolvedHandle;
1094 @Stable MethodHandle invoker;
1095 private final MethodHandleImpl.Intrinsic intrinsicName;
1096
1097 NamedFunction(MethodHandle resolvedHandle) {
1098 this(resolvedHandle.internalMemberName(), resolvedHandle, MethodHandleImpl.Intrinsic.NONE);
1099 }
1100 NamedFunction(MethodHandle resolvedHandle, MethodHandleImpl.Intrinsic intrinsic) {
1101 this(resolvedHandle.internalMemberName(), resolvedHandle, intrinsic);
1102 }
1103 NamedFunction(MemberName member, MethodHandle resolvedHandle) {
1104 this(member, resolvedHandle, MethodHandleImpl.Intrinsic.NONE);
1105 }
1106 NamedFunction(MemberName member, MethodHandle resolvedHandle, MethodHandleImpl.Intrinsic intrinsic) {
1107 this.member = member;
1108 this.resolvedHandle = resolvedHandle;
1109 this.intrinsicName = intrinsic;
1110 assert(resolvedHandle == null ||
1111 resolvedHandle.intrinsicName() == MethodHandleImpl.Intrinsic.NONE ||
1112 resolvedHandle.intrinsicName() == intrinsic) : resolvedHandle.intrinsicName() + " != " + intrinsic;
1113 // The following assert is almost always correct, but will fail for corner cases, such as PrivateInvokeTest.
1114 //assert(!isInvokeBasic(member));
1115 }
1116 NamedFunction(MethodType basicInvokerType) {
1117 assert(basicInvokerType == basicInvokerType.basicType()) : basicInvokerType;
1118 if (basicInvokerType.parameterSlotCount() < MethodType.MAX_MH_INVOKER_ARITY) {
1119 this.resolvedHandle = basicInvokerType.invokers().basicInvoker();
1120 this.member = resolvedHandle.internalMemberName();
1121 } else {
1122 // necessary to pass BigArityTest
1123 this.member = Invokers.invokeBasicMethod(basicInvokerType);
1124 }
1125 this.intrinsicName = MethodHandleImpl.Intrinsic.NONE;
1126 assert(isInvokeBasic(member));
1127 }
1128
1129 private static boolean isInvokeBasic(MemberName member) {
1130 return member != null &&
1131 member.getDeclaringClass() == MethodHandle.class &&
1132 "invokeBasic".equals(member.getName());
1133 }
1134
1135 // The next 2 constructors are used to break circular dependencies on MH.invokeStatic, etc.
1136 // Any LambdaForm containing such a member is not interpretable.
1137 // This is OK, since all such LFs are prepared with special primitive vmentry points.
1138 // And even without the resolvedHandle, the name can still be compiled and optimized.
1139 NamedFunction(Method method) {
1140 this(new MemberName(method));
1141 }
1142 NamedFunction(MemberName member) {
1143 this(member, null);
1144 }
1145
1258 }
1259
1260 int arity() {
1261 return methodType().parameterCount();
1262 }
1263
1264 public String toString() {
1265 if (member == null) return String.valueOf(resolvedHandle);
1266 return member.getDeclaringClass().getSimpleName()+"."+member.getName();
1267 }
1268
1269 public boolean isIdentity() {
1270 return this.equals(identity(returnType()));
1271 }
1272
1273 public boolean isConstantZero() {
1274 return this.equals(constantZero(returnType()));
1275 }
1276
1277 public MethodHandleImpl.Intrinsic intrinsicName() {
1278 return intrinsicName;
1279 }
1280 }
1281
1282 public static String basicTypeSignature(MethodType type) {
1283 int params = type.parameterCount();
1284 char[] sig = new char[params + 2];
1285 int sigp = 0;
1286 while (sigp < params) {
1287 sig[sigp] = basicTypeChar(type.parameterType(sigp++));
1288 }
1289 sig[sigp++] = '_';
1290 sig[sigp++] = basicTypeChar(type.returnType());
1291 assert(sigp == sig.length);
1292 return String.valueOf(sig);
1293 }
1294 public static String shortenSignature(String signature) {
1295 // Hack to make signatures more readable when they show up in method names.
1296 final int NO_CHAR = -1, MIN_RUN = 3;
1297 int c0, c1 = NO_CHAR, c1reps = 0;
1298 StringBuilder buf = null;
1735 }
1736
1737 NamedFunction idFun;
1738 LambdaForm zeForm;
1739 NamedFunction zeFun;
1740
1741 // Create the LFs and NamedFunctions. Precompiling LFs to byte code is needed to break circular
1742 // bootstrap dependency on this method in case we're interpreting LFs
1743 if (isVoid) {
1744 Name[] idNames = new Name[] { argument(0, L_TYPE) };
1745 idForm = new LambdaForm(1, idNames, VOID_RESULT, Kind.IDENTITY);
1746 idForm.compileToBytecode();
1747 idFun = new NamedFunction(idMem, SimpleMethodHandle.make(idMem.getInvocationType(), idForm));
1748
1749 zeForm = idForm;
1750 zeFun = idFun;
1751 } else {
1752 Name[] idNames = new Name[] { argument(0, L_TYPE), argument(1, type) };
1753 idForm = new LambdaForm(2, idNames, 1, Kind.IDENTITY);
1754 idForm.compileToBytecode();
1755 idFun = new NamedFunction(idMem, SimpleMethodHandle.make(idMem.getInvocationType(), idForm),
1756 MethodHandleImpl.Intrinsic.IDENTITY);
1757
1758 Object zeValue = Wrapper.forBasicType(btChar).zero();
1759 Name[] zeNames = new Name[] { argument(0, L_TYPE), new Name(idFun, zeValue) };
1760 zeForm = new LambdaForm(1, zeNames, 1, Kind.ZERO);
1761 zeForm.compileToBytecode();
1762 zeFun = new NamedFunction(zeMem, SimpleMethodHandle.make(zeMem.getInvocationType(), zeForm),
1763 MethodHandleImpl.Intrinsic.ZERO);
1764 }
1765
1766 LF_zero[ord] = zeForm;
1767 NF_zero[ord] = zeFun;
1768 LF_identity[ord] = idForm;
1769 NF_identity[ord] = idFun;
1770
1771 assert(idFun.isIdentity());
1772 assert(zeFun.isConstantZero());
1773 assert(new Name(zeFun).isConstantZero());
1774 }
1775
1776 // Avoid appealing to ValueConversions at bootstrap time:
1777 private static int identity_I(int x) { return x; }
1778 private static long identity_J(long x) { return x; }
1779 private static float identity_F(float x) { return x; }
1780 private static double identity_D(double x) { return x; }
1781 private static Object identity_L(Object x) { return x; }
1782 private static void identity_V() { return; }
1783 private static int zero_I() { return 0; }
|