Categories:
Audio (13)
Biotech (29)
Bytecode (36)
Database (77)
Framework (7)
Game (7)
General (507)
Graphics (53)
I/O (35)
IDE (2)
JAR Tools (101)
JavaBeans (21)
JDBC (121)
JDK (426)
JSP (20)
Logging (108)
Mail (58)
Messaging (8)
Network (84)
PDF (97)
Report (7)
Scripting (84)
Security (32)
Server (121)
Servlet (26)
SOAP (24)
Testing (54)
Web (15)
XML (309)
Collections:
Other Resources:
JDK 17 jdk.incubator.vector.jmod - JDK Incubator Vector
JDK 17 jdk.incubator.vector.jmod is the JMOD file for JDK 17 HTTP Server module.
JDK 17 Incubator Vector module compiled class files are stored in \fyicenter\jdk-17.0.5\jmods\jdk.incubator.vector.jmod.
JDK 17 Incubator Vector module compiled class files are also linked and stored in the \fyicenter\jdk-17.0.5\lib\modules JImage file.
JDK 17 Incubator Vector module source code files are stored in \fyicenter\jdk-17.0.5\lib\src.zip\jdk.incubator.vector.
You can click and view the content of each source code file in the list below.
✍: FYIcenter
⏎ jdk/incubator/vector/LaneType.java
/* * Copyright (c) 2019, 2020, Oracle and/or its affiliates. All rights reserved. * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. * * * * * * * * * * * * * * * * * * * * */ package jdk.incubator.vector; import jdk.internal.vm.annotation.ForceInline; import jdk.internal.vm.annotation.Stable; import static jdk.internal.vm.vector.VectorSupport.*; import static jdk.incubator.vector.VectorIntrinsics.*; /** * Local type witness for primitive types int.class, etc. * It caches all sorts of goodies that we can't put on java.lang.Class. */ enum LaneType { FLOAT(float.class, Float.class, float[].class, 'F', 24, Float.SIZE, T_FLOAT), DOUBLE(double.class, Double.class, double[].class, 'F', 53, Double.SIZE, T_DOUBLE), BYTE(byte.class, Byte.class, byte[].class, 'I', -1, Byte.SIZE, T_BYTE), SHORT(short.class, Short.class, short[].class, 'I', -1, Short.SIZE, T_SHORT), INT(int.class, Integer.class, int[].class, 'I', -1, Integer.SIZE, T_INT), LONG(long.class, Long.class, long[].class, 'I', -1, Long.SIZE, T_LONG); LaneType(Class<?> elementType, Class<?> genericElementType, Class<?> arrayType, char elementKind, int elementPrecision, int elementSize, int basicType) { if (elementPrecision <= 0) elementPrecision += elementSize; this.elementType = elementType; this.genericElementType = genericElementType; this.arrayType = arrayType; this.elementKind = elementKind; this.elementPrecision = elementPrecision; this.elementSize = elementSize; this.elementSizeLog2 = Integer.numberOfTrailingZeros(elementSize); assert(elementSize == (1 << elementSizeLog2)); this.switchKey = 1+ordinal(); this.printName = elementType.getSimpleName(); // Note: If we ever have non-standard lane sizes, such as // int:128 or int:4 or float:16, report the size in the // printName. If we do unsigned or vector or bit lane types, // report that condition also. this.typeChar = printName.toUpperCase().charAt(0); assert("FDBSIL".indexOf(typeChar) == ordinal()) : this; // Same as in JVMS, org.objectweb.asm.Opcodes, etc.: this.basicType = basicType; assert(basicType == ( (elementSizeLog2 - /*lg(Byte.SIZE)*/ 3) | (elementKind == 'F' ? 4 : 8))) : this; assert("....zcFDBSILoav..".charAt(basicType) == typeChar); } final Class<?> elementType; final Class<?> arrayType; final Class<?> genericElementType; final int elementSize; final int elementSizeLog2; final int elementPrecision; final char elementKind; // 'I' or 'F' final int switchKey; // 1+ordinal(), which is non-zero final String printName; final char typeChar; // one of "BSILFD" final int basicType; // lg(size/8) | (kind=='F'?4:kind=='I'?8) private @Stable LaneType asIntegral; private @Stable LaneType asFloating; @Override public String toString() { return printName; } LaneType asIntegral() { return asIntegral.check(); } LaneType asFloating() { if (asFloating == null) { throw badElementType(elementType, "either int or long, to reinterpret as float or double"); } return asFloating; } /** Decode a class mirror for an element type into an enum. */ @ForceInline static LaneType of(Class<?> elementType) { // The following two lines are expected to // constant fold in the JIT, if the argument // is constant and this method is inlined. int c0 = elementType.getName().charAt(0); LaneType type = ENUM_FROM_C0[c0 & C0_MASK]; // This line can short-circuit if a valid // elementType constant was passed: if (type != null && type.elementType == elementType) { return type; } // Come here if something went wrong. return ofSlow(elementType); } private static LaneType ofSlow(Class<?> elementType) { for (LaneType type : ENUM_VALUES) { if (type.elementType == elementType) { return type; } } throw badElementType(elementType, "a primitive type such as byte.class with a known bit-size"); } /** * Finds a LaneType for the given query-type. * The element type, box type, and array type are * all matched. May be helpful for error messages. */ /*package-private*/ static LaneType forClassOrNull(Class<?> queryType) { for (LaneType type : ENUM_VALUES) { if (type.genericElementType == queryType) { return type; } if (type.elementType == queryType) { return type; } if (type.arrayType == queryType) { return type; } } return null; } LaneType check(Class<?> expectedType) { if (expectedType == this.elementType) return this; throw badElementType(this.elementType, expectedType); } private static RuntimeException badElementType(Class<?> elementType, Object expected) { String msg = String.format("Bad vector element type: %s (should be %s)", elementType, expected); if (expected instanceof Class) { // Failure mode for check(). return new ClassCastException(msg); } else { // Failure mode for VectorSpecies.{of*,withLanes}. return new UnsupportedOperationException(msg); } } // Switch keys for local use. // We need these because switches keyed on enums // don't optimize properly; see JDK-8161245 static final int SK_FLOAT = 1, SK_DOUBLE = 2, SK_BYTE = 3, SK_SHORT = 4, SK_INT = 5, SK_LONG = 6, SK_LIMIT = 7; /*package-private*/ @ForceInline static LaneType ofSwitchKey(int sk) { return ENUM_FROM_SK[sk].check(); } /*package-private*/ @ForceInline static LaneType ofBasicType(int bt) { return ENUM_FROM_BT[bt].check(); } /*package-private*/ @ForceInline final LaneType check() { return this; } // Constant-foldable tables mapping ordinals, switch keys, // and first characters of type names to enum values. @Stable private static final LaneType[] ENUM_VALUES; @Stable private static final LaneType[] ENUM_FROM_SK; @Stable private static final LaneType[] ENUM_FROM_C0; @Stable private static final LaneType[] ENUM_FROM_BT; private static final int C0_MASK = 0x0F, BT_MASK = 0x0F; static { LaneType[] values = values().clone(); LaneType[] valuesByKey = new LaneType[1+values.length]; LaneType[] valuesByC0 = new LaneType[C0_MASK+1]; LaneType[] valuesByBT = new LaneType[BT_MASK+1]; for (int ord = 0; ord < values.length; ord++) { int key = 1+ord; LaneType value = values[ord]; valuesByKey[key] = value; try { assert(LaneType.class .getDeclaredField("SK_"+value.name()) .get(null).equals(key)); } catch (ReflectiveOperationException ex) { throw new AssertionError(ex); } int c0 = value.elementType.getName().charAt(0); c0 &= C0_MASK; assert(valuesByC0[c0] == null); valuesByC0[c0] = value; assert(valuesByBT[value.basicType] == null); valuesByBT[value.basicType] = value; // set up asIntegral if (value.elementKind == 'I') { value.asIntegral = value; } else { for (LaneType v : values) { if (v.elementKind == 'I' && v.elementSize == value.elementSize) { value.asIntegral = v; break; } } } // set up asFloating if (value.elementKind == 'F') { value.asFloating = value; } else { for (LaneType v : values) { if (v.elementKind == 'F' && v.elementSize == value.elementSize) { value.asFloating = v; break; } } } } // Test the asIntegral/asFloating links: for (LaneType lt : values) { if (lt.elementKind == 'I') { assert(lt.asIntegral == lt); if (lt.asFloating == null) { assert(lt.elementSize < Float.SIZE); } else { assert(lt.asFloating.elementKind == 'F' && lt.asFloating.elementSize == lt.elementSize); } } else { assert(lt.elementKind == 'F'); assert(lt.asFloating == lt); assert(lt.asIntegral.elementKind == 'I' && lt.asIntegral.elementSize == lt.elementSize); } } ENUM_VALUES = values; ENUM_FROM_SK = valuesByKey; ENUM_FROM_C0 = valuesByC0; ENUM_FROM_BT = valuesByBT; } static { assert(ofBasicType(T_FLOAT) == FLOAT); assert(ofBasicType(T_DOUBLE) == DOUBLE); assert(ofBasicType(T_BYTE) == BYTE); assert(ofBasicType(T_SHORT) == SHORT); assert(ofBasicType(T_INT) == INT); assert(ofBasicType(T_LONG) == LONG); } }
⏎ jdk/incubator/vector/LaneType.java
Or download all of them as a single archive file:
File name: jdk.incubator.vector-17.0.5-src.zip File size: 350622 bytes Release date: 2022-09-13 Download
⇒ JDK 17 jdk.internal.ed.jmod - Internal Editor Module
2023-10-04, 4049👍, 0💬
Popular Posts:
JasperReports, the world's most popular open source business intelligence and reporting engine and J...
Java Cryptography Extension 1.2.2 JAR File Size and Download Location: File name: jce.jar, jce-1.2.2...
How to run "javac" command from JDK tools.jar file? "javac" is the Java compiler command that allows...
JDK 11 java.management.jmod is the JMOD file for JDK 11 Management module. JDK 11 Management module ...
How to download and install Apache XMLBeans-2.6.0.zip? If you want to try the XMLBeans Java library,...