Added proper choice of sRGB surface formats and spec-conformant sRGB->linear conversion for colors coming from Java.

Added VK_EXT_extended_dynamic_state and VK_EXT_extended_dynamic_state3 for:
- Dynamic blending mode.
- Dynamic logicOp.
- Dynamic stencil test.

src/hotspot/cpu/riscv/macroAssembler_riscv.cpp

@@ -1454,6 +1454,103 @@ void MacroAssembler::update_word_crc32(Register crc, Register v, Register tmp1,
   xorr(crc, crc, tmp2);
 }
 
+
+// This improvement (vectorization) is based on java.base/share/native/libzip/zlib/zcrc32.c.
+// To make it, following steps are taken:
+//  1. in zcrc32.c, modify N to 16 and related code,
+//  2. re-generate the tables needed, we use tables of (N == 16, W == 4)
+//  3. finally vectorize the code (original implementation in zcrc32.c is just scalar code).
+// New tables for vector version is after table3.
+void MacroAssembler::vector_update_crc32(Register crc, Register buf, Register len,
+                                         Register tmp1, Register tmp2, Register tmp3, Register tmp4, Register tmp5,
+                                         Register table0, Register table3) {
+    assert_different_registers(t1, crc, buf, len, tmp1, tmp2, tmp3, tmp4, tmp5, table0, table3);
+    const int N = 16, W = 4;
+    const int64_t single_table_size = 256;
+    const Register blks = tmp2;
+    const Register tmpTable = tmp3, tableN16 = tmp4;
+    const VectorRegister vcrc = v4, vword = v8, vtmp = v12;
+    Label VectorLoop;
+    Label LastBlock;
+
+    add(tableN16, table3, 1*single_table_size*sizeof(juint), tmp1);
+    mv(tmp5, 0xff);
+
+    if (MaxVectorSize == 16) {
+      vsetivli(zr, N, Assembler::e32, Assembler::m4, Assembler::ma, Assembler::ta);
+    } else if (MaxVectorSize == 32) {
+      vsetivli(zr, N, Assembler::e32, Assembler::m2, Assembler::ma, Assembler::ta);
+    } else {
+      assert(MaxVectorSize > 32, "sanity");
+      vsetivli(zr, N, Assembler::e32, Assembler::m1, Assembler::ma, Assembler::ta);
+    }
+
+    vmv_v_x(vcrc, zr);
+    vmv_s_x(vcrc, crc);
+
+    // multiple of 64
+    srli(blks, len, 6);
+    slli(t1, blks, 6);
+    sub(len, len, t1);
+    sub(blks, blks, 1);
+    blez(blks, LastBlock);
+
+    bind(VectorLoop);
+    {
+      mv(tmpTable, tableN16);
+
+      vle32_v(vword, buf);
+      vxor_vv(vword, vword, vcrc);
+
+      addi(buf, buf, N*4);
+
+      vand_vx(vtmp, vword, tmp5);
+      vsll_vi(vtmp, vtmp, 2);
+      vluxei32_v(vcrc, tmpTable, vtmp);
+
+      mv(tmp1, 1);
+      for (int k = 1; k < W; k++) {
+        addi(tmpTable, tmpTable, single_table_size*4);
+
+        slli(t1, tmp1, 3);
+        vsrl_vx(vtmp, vword, t1);
+
+        vand_vx(vtmp, vtmp, tmp5);
+        vsll_vi(vtmp, vtmp, 2);
+        vluxei32_v(vtmp, tmpTable, vtmp);
+
+        vxor_vv(vcrc, vcrc, vtmp);
+
+        addi(tmp1, tmp1, 1);
+      }
+
+      sub(blks, blks, 1);
+      bgtz(blks, VectorLoop);
+    }
+
+    bind(LastBlock);
+    {
+      vle32_v(vtmp, buf);
+      vxor_vv(vcrc, vcrc, vtmp);
+      mv(crc, zr);
+      for (int i = 0; i < N; i++) {
+        vmv_x_s(tmp2, vcrc);
+        // in vmv_x_s, the value is sign-extended to SEW bits, but we need zero-extended here.
+        zext_w(tmp2, tmp2);
+        vslidedown_vi(vcrc, vcrc, 1);
+        xorr(crc, crc, tmp2);
+        for (int j = 0; j < W; j++) {
+          andr(t1, crc, tmp5);
+          shadd(t1, t1, table0, tmp1, 2);
+          lwu(t1, Address(t1, 0));
+          srli(tmp2, crc, 8);
+          xorr(crc, tmp2, t1);
+        }
+      }
+      addi(buf, buf, N*4);
+    }
+}
+
 /**
  * @param crc   register containing existing CRC (32-bit)
  * @param buf   register pointing to input byte buffer (byte*)
@@ -1465,21 +1562,28 @@ void MacroAssembler::kernel_crc32(Register crc, Register buf, Register len,
         Register table0, Register table1, Register table2, Register table3,
         Register tmp1, Register tmp2, Register tmp3, Register tmp4, Register tmp5, Register tmp6) {
   assert_different_registers(crc, buf, len, table0, table1, table2, table3, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6);
-  Label L_by16_loop, L_unroll_loop, L_unroll_loop_entry, L_by4, L_by4_loop, L_by1, L_by1_loop, L_exit;
+  Label L_by16_loop, L_vector_entry, L_unroll_loop, L_unroll_loop_entry, L_by4, L_by4_loop, L_by1, L_by1_loop, L_exit;
 
+  const int64_t single_table_size = 256;
   const int64_t unroll = 16;
   const int64_t unroll_words = unroll*wordSize;
   mv(tmp5, right_32_bits);
-  subw(len, len, unroll_words);
   andn(crc, tmp5, crc);
 
   const ExternalAddress table_addr = StubRoutines::crc_table_addr();
   la(table0, table_addr);
-  add(table1, table0, 1*256*sizeof(juint), tmp1);
-  add(table2, table0, 2*256*sizeof(juint), tmp1);
-  add(table3, table2, 1*256*sizeof(juint), tmp1);
+  add(table1, table0, 1*single_table_size*sizeof(juint), tmp1);
+  add(table2, table0, 2*single_table_size*sizeof(juint), tmp1);
+  add(table3, table2, 1*single_table_size*sizeof(juint), tmp1);
 
+  if (UseRVV) {
+    const int64_t tmp_limit = MaxVectorSize >= 32 ? unroll_words*3 : unroll_words*5;
+    mv(tmp1, tmp_limit);
+    bge(len, tmp1, L_vector_entry);
+  }
+  subw(len, len, unroll_words);
   bge(len, zr, L_unroll_loop_entry);
+
   addiw(len, len, unroll_words-4);
   bge(len, zr, L_by4_loop);
   addiw(len, len, 4);
@@ -1539,6 +1643,19 @@ void MacroAssembler::kernel_crc32(Register crc, Register buf, Register len,
     andi(tmp2, tmp2, right_8_bits);
     update_byte_crc32(crc, tmp2, table0);
 
+  // put vector code here, otherwise "offset is too large" error occurs.
+  if (UseRVV) {
+    j(L_exit); // only need to jump exit when UseRVV == true, it's a jump from end of block `L_by1_loop`.
+
+    bind(L_vector_entry);
+    vector_update_crc32(crc, buf, len, tmp1, tmp2, tmp3, tmp4, tmp6, table0, table3);
+
+    addiw(len, len, -4);
+    bge(len, zr, L_by4_loop);
+    addiw(len, len, 4);
+    bgt(len, zr, L_by1_loop);
+  }
+
   bind(L_exit);
     andn(crc, tmp5, crc);
 }

src/hotspot/cpu/riscv/macroAssembler_riscv.hpp

@@ -1319,6 +1319,9 @@ public:
         Register table0, Register table1, Register table2, Register table3,
         bool upper);
   void update_byte_crc32(Register crc, Register val, Register table);
+  void vector_update_crc32(Register crc, Register buf, Register len,
+                           Register tmp1, Register tmp2, Register tmp3, Register tmp4, Register tmp5,
+                           Register table0, Register table3);
 
 #ifdef COMPILER2
   void mul_add(Register out, Register in, Register offset,

src/hotspot/cpu/riscv/stubGenerator_riscv.cpp

@@ -5331,7 +5331,7 @@ class StubGenerator: public StubCodeGenerator {
    * NOTE: each field will occupy a single vector register group
    */
   void base64_vector_decode_round(Register src, Register dst, Register codec,
-                    Register size, Register stepSrc, Register stepDst, Register failedIdx, Register minusOne,
+                    Register size, Register stepSrc, Register stepDst, Register failedIdx,
                     VectorRegister inputV1, VectorRegister inputV2, VectorRegister inputV3, VectorRegister inputV4,
                     VectorRegister idxV1, VectorRegister idxV2, VectorRegister idxV3, VectorRegister idxV4,
                     VectorRegister outputV1, VectorRegister outputV2, VectorRegister outputV3,
@@ -5358,8 +5358,11 @@ class StubGenerator: public StubCodeGenerator {
     __ vor_vv(outputV1, outputV1, outputV2);
     __ vmseq_vi(v0, outputV1, -1);
     __ vfirst_m(failedIdx, v0);
-    Label NoFailure;
-    __ beq(failedIdx, minusOne, NoFailure);
+    Label NoFailure, FailureAtIdx0;
+    // valid value can only be -1 when < 0
+    __ bltz(failedIdx, NoFailure);
+    // when the first data (at index 0) fails, no need to process data anymore
+    __ beqz(failedIdx, FailureAtIdx0);
     __ vsetvli(x0, failedIdx, Assembler::e8, lmul, Assembler::mu, Assembler::tu);
     __ slli(stepDst, failedIdx, 1);
     __ add(stepDst, failedIdx, stepDst);
@@ -5382,6 +5385,7 @@ class StubGenerator: public StubCodeGenerator {
 
     // dst = dst + register_group_len_bytes * 3
     __ add(dst, dst, stepDst);
+    __ BIND(FailureAtIdx0);
   }
 
   /**
@@ -5501,7 +5505,7 @@ class StubGenerator: public StubCodeGenerator {
       // Assembler::m2
       __ BIND(ProcessM2);
       base64_vector_decode_round(src, dst, codec,
-                    size, stepSrcM2, stepDst, failedIdx, minusOne,
+                    size, stepSrcM2, stepDst, failedIdx,
                     v2, v4, v6, v8,      // inputs
                     v10, v12, v14, v16,  // indexes
                     v18, v20, v22,       // outputs
@@ -5521,7 +5525,7 @@ class StubGenerator: public StubCodeGenerator {
       __ srli(size, size, 1);
       __ srli(stepDst, stepDst, 1);
       base64_vector_decode_round(src, dst, codec,
-                    size, stepSrcM1, stepDst, failedIdx, minusOne,
+                    size, stepSrcM1, stepDst, failedIdx,
                     v1, v2, v3, v4,      // inputs
                     v5, v6, v7, v8,      // indexes
                     v9, v10, v11,        // outputs

src/hotspot/cpu/riscv/stubRoutines_riscv.cpp

@@ -276,4 +276,219 @@ ATTRIBUTE_ALIGNED(4096) juint StubRoutines::riscv::_crc_table[] =
     0xb1b8e695UL, 0xa30d497bUL, 0x1bb12e1eUL, 0x43d23e48UL, 0xfb6e592dUL,
     0xe9dbf6c3UL, 0x516791a6UL, 0xccb0a91fUL, 0x740cce7aUL, 0x66b96194UL,
     0xde0506f1UL,
+
+    // Tables for vector version
+    // This improvement (vectorization) is based on java.base/share/native/libzip/zlib/zcrc32.c.
+    // To make it, following steps are taken:
+    //  1. in zcrc32.c, modify N to 16 and related code,
+    //  2. re-generate the tables needed, we use tables of (N == 16, W == 4)
+    //  3. finally vectorize the code (original implementation in zcrc32.c is just scalar code).
+    0x00000000, 0x8f352d95, 0xc51b5d6b, 0x4a2e70fe, 0x5147bc97,
+    0xde729102, 0x945ce1fc, 0x1b69cc69, 0xa28f792e, 0x2dba54bb,
+    0x67942445, 0xe8a109d0, 0xf3c8c5b9, 0x7cfde82c, 0x36d398d2,
+    0xb9e6b547, 0x9e6ff41d, 0x115ad988, 0x5b74a976, 0xd44184e3,
+    0xcf28488a, 0x401d651f, 0x0a3315e1, 0x85063874, 0x3ce08d33,
+    0xb3d5a0a6, 0xf9fbd058, 0x76cefdcd, 0x6da731a4, 0xe2921c31,
+    0xa8bc6ccf, 0x2789415a, 0xe7aeee7b, 0x689bc3ee, 0x22b5b310,
+    0xad809e85, 0xb6e952ec, 0x39dc7f79, 0x73f20f87, 0xfcc72212,
+    0x45219755, 0xca14bac0, 0x803aca3e, 0x0f0fe7ab, 0x14662bc2,
+    0x9b530657, 0xd17d76a9, 0x5e485b3c, 0x79c11a66, 0xf6f437f3,
+    0xbcda470d, 0x33ef6a98, 0x2886a6f1, 0xa7b38b64, 0xed9dfb9a,
+    0x62a8d60f, 0xdb4e6348, 0x547b4edd, 0x1e553e23, 0x916013b6,
+    0x8a09dfdf, 0x053cf24a, 0x4f1282b4, 0xc027af21, 0x142cdab7,
+    0x9b19f722, 0xd13787dc, 0x5e02aa49, 0x456b6620, 0xca5e4bb5,
+    0x80703b4b, 0x0f4516de, 0xb6a3a399, 0x39968e0c, 0x73b8fef2,
+    0xfc8dd367, 0xe7e41f0e, 0x68d1329b, 0x22ff4265, 0xadca6ff0,
+    0x8a432eaa, 0x0576033f, 0x4f5873c1, 0xc06d5e54, 0xdb04923d,
+    0x5431bfa8, 0x1e1fcf56, 0x912ae2c3, 0x28cc5784, 0xa7f97a11,
+    0xedd70aef, 0x62e2277a, 0x798beb13, 0xf6bec686, 0xbc90b678,
+    0x33a59bed, 0xf38234cc, 0x7cb71959, 0x369969a7, 0xb9ac4432,
+    0xa2c5885b, 0x2df0a5ce, 0x67ded530, 0xe8ebf8a5, 0x510d4de2,
+    0xde386077, 0x94161089, 0x1b233d1c, 0x004af175, 0x8f7fdce0,
+    0xc551ac1e, 0x4a64818b, 0x6dedc0d1, 0xe2d8ed44, 0xa8f69dba,
+    0x27c3b02f, 0x3caa7c46, 0xb39f51d3, 0xf9b1212d, 0x76840cb8,
+    0xcf62b9ff, 0x4057946a, 0x0a79e494, 0x854cc901, 0x9e250568,
+    0x111028fd, 0x5b3e5803, 0xd40b7596, 0x2859b56e, 0xa76c98fb,
+    0xed42e805, 0x6277c590, 0x791e09f9, 0xf62b246c, 0xbc055492,
+    0x33307907, 0x8ad6cc40, 0x05e3e1d5, 0x4fcd912b, 0xc0f8bcbe,
+    0xdb9170d7, 0x54a45d42, 0x1e8a2dbc, 0x91bf0029, 0xb6364173,
+    0x39036ce6, 0x732d1c18, 0xfc18318d, 0xe771fde4, 0x6844d071,
+    0x226aa08f, 0xad5f8d1a, 0x14b9385d, 0x9b8c15c8, 0xd1a26536,
+    0x5e9748a3, 0x45fe84ca, 0xcacba95f, 0x80e5d9a1, 0x0fd0f434,
+    0xcff75b15, 0x40c27680, 0x0aec067e, 0x85d92beb, 0x9eb0e782,
+    0x1185ca17, 0x5babbae9, 0xd49e977c, 0x6d78223b, 0xe24d0fae,
+    0xa8637f50, 0x275652c5, 0x3c3f9eac, 0xb30ab339, 0xf924c3c7,
+    0x7611ee52, 0x5198af08, 0xdead829d, 0x9483f263, 0x1bb6dff6,
+    0x00df139f, 0x8fea3e0a, 0xc5c44ef4, 0x4af16361, 0xf317d626,
+    0x7c22fbb3, 0x360c8b4d, 0xb939a6d8, 0xa2506ab1, 0x2d654724,
+    0x674b37da, 0xe87e1a4f, 0x3c756fd9, 0xb340424c, 0xf96e32b2,
+    0x765b1f27, 0x6d32d34e, 0xe207fedb, 0xa8298e25, 0x271ca3b0,
+    0x9efa16f7, 0x11cf3b62, 0x5be14b9c, 0xd4d46609, 0xcfbdaa60,
+    0x408887f5, 0x0aa6f70b, 0x8593da9e, 0xa21a9bc4, 0x2d2fb651,
+    0x6701c6af, 0xe834eb3a, 0xf35d2753, 0x7c680ac6, 0x36467a38,
+    0xb97357ad, 0x0095e2ea, 0x8fa0cf7f, 0xc58ebf81, 0x4abb9214,
+    0x51d25e7d, 0xdee773e8, 0x94c90316, 0x1bfc2e83, 0xdbdb81a2,
+    0x54eeac37, 0x1ec0dcc9, 0x91f5f15c, 0x8a9c3d35, 0x05a910a0,
+    0x4f87605e, 0xc0b24dcb, 0x7954f88c, 0xf661d519, 0xbc4fa5e7,
+    0x337a8872, 0x2813441b, 0xa726698e, 0xed081970, 0x623d34e5,
+    0x45b475bf, 0xca81582a, 0x80af28d4, 0x0f9a0541, 0x14f3c928,
+    0x9bc6e4bd, 0xd1e89443, 0x5eddb9d6, 0xe73b0c91, 0x680e2104,
+    0x222051fa, 0xad157c6f, 0xb67cb006, 0x39499d93, 0x7367ed6d,
+    0xfc52c0f8,
+    0x00000000, 0x50b36adc, 0xa166d5b8, 0xf1d5bf64, 0x99bcad31,
+    0xc90fc7ed, 0x38da7889, 0x68691255, 0xe8085c23, 0xb8bb36ff,
+    0x496e899b, 0x19dde347, 0x71b4f112, 0x21079bce, 0xd0d224aa,
+    0x80614e76, 0x0b61be07, 0x5bd2d4db, 0xaa076bbf, 0xfab40163,
+    0x92dd1336, 0xc26e79ea, 0x33bbc68e, 0x6308ac52, 0xe369e224,
+    0xb3da88f8, 0x420f379c, 0x12bc5d40, 0x7ad54f15, 0x2a6625c9,
+    0xdbb39aad, 0x8b00f071, 0x16c37c0e, 0x467016d2, 0xb7a5a9b6,
+    0xe716c36a, 0x8f7fd13f, 0xdfccbbe3, 0x2e190487, 0x7eaa6e5b,
+    0xfecb202d, 0xae784af1, 0x5fadf595, 0x0f1e9f49, 0x67778d1c,
+    0x37c4e7c0, 0xc61158a4, 0x96a23278, 0x1da2c209, 0x4d11a8d5,
+    0xbcc417b1, 0xec777d6d, 0x841e6f38, 0xd4ad05e4, 0x2578ba80,
+    0x75cbd05c, 0xf5aa9e2a, 0xa519f4f6, 0x54cc4b92, 0x047f214e,
+    0x6c16331b, 0x3ca559c7, 0xcd70e6a3, 0x9dc38c7f, 0x2d86f81c,
+    0x7d3592c0, 0x8ce02da4, 0xdc534778, 0xb43a552d, 0xe4893ff1,
+    0x155c8095, 0x45efea49, 0xc58ea43f, 0x953dcee3, 0x64e87187,
+    0x345b1b5b, 0x5c32090e, 0x0c8163d2, 0xfd54dcb6, 0xade7b66a,
+    0x26e7461b, 0x76542cc7, 0x878193a3, 0xd732f97f, 0xbf5beb2a,
+    0xefe881f6, 0x1e3d3e92, 0x4e8e544e, 0xceef1a38, 0x9e5c70e4,
+    0x6f89cf80, 0x3f3aa55c, 0x5753b709, 0x07e0ddd5, 0xf63562b1,
+    0xa686086d, 0x3b458412, 0x6bf6eece, 0x9a2351aa, 0xca903b76,
+    0xa2f92923, 0xf24a43ff, 0x039ffc9b, 0x532c9647, 0xd34dd831,
+    0x83feb2ed, 0x722b0d89, 0x22986755, 0x4af17500, 0x1a421fdc,
+    0xeb97a0b8, 0xbb24ca64, 0x30243a15, 0x609750c9, 0x9142efad,
+    0xc1f18571, 0xa9989724, 0xf92bfdf8, 0x08fe429c, 0x584d2840,
+    0xd82c6636, 0x889f0cea, 0x794ab38e, 0x29f9d952, 0x4190cb07,
+    0x1123a1db, 0xe0f61ebf, 0xb0457463, 0x5b0df038, 0x0bbe9ae4,
+    0xfa6b2580, 0xaad84f5c, 0xc2b15d09, 0x920237d5, 0x63d788b1,
+    0x3364e26d, 0xb305ac1b, 0xe3b6c6c7, 0x126379a3, 0x42d0137f,
+    0x2ab9012a, 0x7a0a6bf6, 0x8bdfd492, 0xdb6cbe4e, 0x506c4e3f,
+    0x00df24e3, 0xf10a9b87, 0xa1b9f15b, 0xc9d0e30e, 0x996389d2,
+    0x68b636b6, 0x38055c6a, 0xb864121c, 0xe8d778c0, 0x1902c7a4,
+    0x49b1ad78, 0x21d8bf2d, 0x716bd5f1, 0x80be6a95, 0xd00d0049,
+    0x4dce8c36, 0x1d7de6ea, 0xeca8598e, 0xbc1b3352, 0xd4722107,
+    0x84c14bdb, 0x7514f4bf, 0x25a79e63, 0xa5c6d015, 0xf575bac9,
+    0x04a005ad, 0x54136f71, 0x3c7a7d24, 0x6cc917f8, 0x9d1ca89c,
+    0xcdafc240, 0x46af3231, 0x161c58ed, 0xe7c9e789, 0xb77a8d55,
+    0xdf139f00, 0x8fa0f5dc, 0x7e754ab8, 0x2ec62064, 0xaea76e12,
+    0xfe1404ce, 0x0fc1bbaa, 0x5f72d176, 0x371bc323, 0x67a8a9ff,
+    0x967d169b, 0xc6ce7c47, 0x768b0824, 0x263862f8, 0xd7eddd9c,
+    0x875eb740, 0xef37a515, 0xbf84cfc9, 0x4e5170ad, 0x1ee21a71,
+    0x9e835407, 0xce303edb, 0x3fe581bf, 0x6f56eb63, 0x073ff936,
+    0x578c93ea, 0xa6592c8e, 0xf6ea4652, 0x7deab623, 0x2d59dcff,
+    0xdc8c639b, 0x8c3f0947, 0xe4561b12, 0xb4e571ce, 0x4530ceaa,
+    0x1583a476, 0x95e2ea00, 0xc55180dc, 0x34843fb8, 0x64375564,
+    0x0c5e4731, 0x5ced2ded, 0xad389289, 0xfd8bf855, 0x6048742a,
+    0x30fb1ef6, 0xc12ea192, 0x919dcb4e, 0xf9f4d91b, 0xa947b3c7,
+    0x58920ca3, 0x0821667f, 0x88402809, 0xd8f342d5, 0x2926fdb1,
+    0x7995976d, 0x11fc8538, 0x414fefe4, 0xb09a5080, 0xe0293a5c,
+    0x6b29ca2d, 0x3b9aa0f1, 0xca4f1f95, 0x9afc7549, 0xf295671c,
+    0xa2260dc0, 0x53f3b2a4, 0x0340d878, 0x8321960e, 0xd392fcd2,
+    0x224743b6, 0x72f4296a, 0x1a9d3b3f, 0x4a2e51e3, 0xbbfbee87,
+    0xeb48845b,
+    0x00000000, 0xb61be070, 0xb746c6a1, 0x015d26d1, 0xb5fc8b03,
+    0x03e76b73, 0x02ba4da2, 0xb4a1add2, 0xb0881047, 0x0693f037,
+    0x07ced6e6, 0xb1d53696, 0x05749b44, 0xb36f7b34, 0xb2325de5,
+    0x0429bd95, 0xba6126cf, 0x0c7ac6bf, 0x0d27e06e, 0xbb3c001e,
+    0x0f9dadcc, 0xb9864dbc, 0xb8db6b6d, 0x0ec08b1d, 0x0ae93688,
+    0xbcf2d6f8, 0xbdaff029, 0x0bb41059, 0xbf15bd8b, 0x090e5dfb,
+    0x08537b2a, 0xbe489b5a, 0xafb34bdf, 0x19a8abaf, 0x18f58d7e,
+    0xaeee6d0e, 0x1a4fc0dc, 0xac5420ac, 0xad09067d, 0x1b12e60d,
+    0x1f3b5b98, 0xa920bbe8, 0xa87d9d39, 0x1e667d49, 0xaac7d09b,
+    0x1cdc30eb, 0x1d81163a, 0xab9af64a, 0x15d26d10, 0xa3c98d60,
+    0xa294abb1, 0x148f4bc1, 0xa02ee613, 0x16350663, 0x176820b2,
+    0xa173c0c2, 0xa55a7d57, 0x13419d27, 0x121cbbf6, 0xa4075b86,
+    0x10a6f654, 0xa6bd1624, 0xa7e030f5, 0x11fbd085, 0x841791ff,
+    0x320c718f, 0x3351575e, 0x854ab72e, 0x31eb1afc, 0x87f0fa8c,
+    0x86addc5d, 0x30b63c2d, 0x349f81b8, 0x828461c8, 0x83d94719,
+    0x35c2a769, 0x81630abb, 0x3778eacb, 0x3625cc1a, 0x803e2c6a,
+    0x3e76b730, 0x886d5740, 0x89307191, 0x3f2b91e1, 0x8b8a3c33,
+    0x3d91dc43, 0x3cccfa92, 0x8ad71ae2, 0x8efea777, 0x38e54707,
+    0x39b861d6, 0x8fa381a6, 0x3b022c74, 0x8d19cc04, 0x8c44ead5,
+    0x3a5f0aa5, 0x2ba4da20, 0x9dbf3a50, 0x9ce21c81, 0x2af9fcf1,
+    0x9e585123, 0x2843b153, 0x291e9782, 0x9f0577f2, 0x9b2cca67,
+    0x2d372a17, 0x2c6a0cc6, 0x9a71ecb6, 0x2ed04164, 0x98cba114,
+    0x999687c5, 0x2f8d67b5, 0x91c5fcef, 0x27de1c9f, 0x26833a4e,
+    0x9098da3e, 0x243977ec, 0x9222979c, 0x937fb14d, 0x2564513d,
+    0x214deca8, 0x97560cd8, 0x960b2a09, 0x2010ca79, 0x94b167ab,
+    0x22aa87db, 0x23f7a10a, 0x95ec417a, 0xd35e25bf, 0x6545c5cf,
+    0x6418e31e, 0xd203036e, 0x66a2aebc, 0xd0b94ecc, 0xd1e4681d,
+    0x67ff886d, 0x63d635f8, 0xd5cdd588, 0xd490f359, 0x628b1329,
+    0xd62abefb, 0x60315e8b, 0x616c785a, 0xd777982a, 0x693f0370,
+    0xdf24e300, 0xde79c5d1, 0x686225a1, 0xdcc38873, 0x6ad86803,
+    0x6b854ed2, 0xdd9eaea2, 0xd9b71337, 0x6facf347, 0x6ef1d596,
+    0xd8ea35e6, 0x6c4b9834, 0xda507844, 0xdb0d5e95, 0x6d16bee5,
+    0x7ced6e60, 0xcaf68e10, 0xcbaba8c1, 0x7db048b1, 0xc911e563,
+    0x7f0a0513, 0x7e5723c2, 0xc84cc3b2, 0xcc657e27, 0x7a7e9e57,
+    0x7b23b886, 0xcd3858f6, 0x7999f524, 0xcf821554, 0xcedf3385,
+    0x78c4d3f5, 0xc68c48af, 0x7097a8df, 0x71ca8e0e, 0xc7d16e7e,
+    0x7370c3ac, 0xc56b23dc, 0xc436050d, 0x722de57d, 0x760458e8,
+    0xc01fb898, 0xc1429e49, 0x77597e39, 0xc3f8d3eb, 0x75e3339b,
+    0x74be154a, 0xc2a5f53a, 0x5749b440, 0xe1525430, 0xe00f72e1,
+    0x56149291, 0xe2b53f43, 0x54aedf33, 0x55f3f9e2, 0xe3e81992,
+    0xe7c1a407, 0x51da4477, 0x508762a6, 0xe69c82d6, 0x523d2f04,
+    0xe426cf74, 0xe57be9a5, 0x536009d5, 0xed28928f, 0x5b3372ff,
+    0x5a6e542e, 0xec75b45e, 0x58d4198c, 0xeecff9fc, 0xef92df2d,
+    0x59893f5d, 0x5da082c8, 0xebbb62b8, 0xeae64469, 0x5cfda419,
+    0xe85c09cb, 0x5e47e9bb, 0x5f1acf6a, 0xe9012f1a, 0xf8faff9f,
+    0x4ee11fef, 0x4fbc393e, 0xf9a7d94e, 0x4d06749c, 0xfb1d94ec,
+    0xfa40b23d, 0x4c5b524d, 0x4872efd8, 0xfe690fa8, 0xff342979,
+    0x492fc909, 0xfd8e64db, 0x4b9584ab, 0x4ac8a27a, 0xfcd3420a,
+    0x429bd950, 0xf4803920, 0xf5dd1ff1, 0x43c6ff81, 0xf7675253,
+    0x417cb223, 0x402194f2, 0xf63a7482, 0xf213c917, 0x44082967,
+    0x45550fb6, 0xf34eefc6, 0x47ef4214, 0xf1f4a264, 0xf0a984b5,
+    0x46b264c5,
+    0x00000000, 0x7dcd4d3f, 0xfb9a9a7e, 0x8657d741, 0x2c4432bd,
+    0x51897f82, 0xd7dea8c3, 0xaa13e5fc, 0x5888657a, 0x25452845,
+    0xa312ff04, 0xdedfb23b, 0x74cc57c7, 0x09011af8, 0x8f56cdb9,
+    0xf29b8086, 0xb110caf4, 0xccdd87cb, 0x4a8a508a, 0x37471db5,
+    0x9d54f849, 0xe099b576, 0x66ce6237, 0x1b032f08, 0xe998af8e,
+    0x9455e2b1, 0x120235f0, 0x6fcf78cf, 0xc5dc9d33, 0xb811d00c,
+    0x3e46074d, 0x438b4a72, 0xb95093a9, 0xc49dde96, 0x42ca09d7,
+    0x3f0744e8, 0x9514a114, 0xe8d9ec2b, 0x6e8e3b6a, 0x13437655,
+    0xe1d8f6d3, 0x9c15bbec, 0x1a426cad, 0x678f2192, 0xcd9cc46e,
+    0xb0518951, 0x36065e10, 0x4bcb132f, 0x0840595d, 0x758d1462,
+    0xf3dac323, 0x8e178e1c, 0x24046be0, 0x59c926df, 0xdf9ef19e,
+    0xa253bca1, 0x50c83c27, 0x2d057118, 0xab52a659, 0xd69feb66,
+    0x7c8c0e9a, 0x014143a5, 0x871694e4, 0xfadbd9db, 0xa9d02113,
+    0xd41d6c2c, 0x524abb6d, 0x2f87f652, 0x859413ae, 0xf8595e91,
+    0x7e0e89d0, 0x03c3c4ef, 0xf1584469, 0x8c950956, 0x0ac2de17,
+    0x770f9328, 0xdd1c76d4, 0xa0d13beb, 0x2686ecaa, 0x5b4ba195,
+    0x18c0ebe7, 0x650da6d8, 0xe35a7199, 0x9e973ca6, 0x3484d95a,
+    0x49499465, 0xcf1e4324, 0xb2d30e1b, 0x40488e9d, 0x3d85c3a2,
+    0xbbd214e3, 0xc61f59dc, 0x6c0cbc20, 0x11c1f11f, 0x9796265e,
+    0xea5b6b61, 0x1080b2ba, 0x6d4dff85, 0xeb1a28c4, 0x96d765fb,
+    0x3cc48007, 0x4109cd38, 0xc75e1a79, 0xba935746, 0x4808d7c0,
+    0x35c59aff, 0xb3924dbe, 0xce5f0081, 0x644ce57d, 0x1981a842,
+    0x9fd67f03, 0xe21b323c, 0xa190784e, 0xdc5d3571, 0x5a0ae230,
+    0x27c7af0f, 0x8dd44af3, 0xf01907cc, 0x764ed08d, 0x0b839db2,
+    0xf9181d34, 0x84d5500b, 0x0282874a, 0x7f4fca75, 0xd55c2f89,
+    0xa89162b6, 0x2ec6b5f7, 0x530bf8c8, 0x88d14467, 0xf51c0958,
+    0x734bde19, 0x0e869326, 0xa49576da, 0xd9583be5, 0x5f0feca4,
+    0x22c2a19b, 0xd059211d, 0xad946c22, 0x2bc3bb63, 0x560ef65c,
+    0xfc1d13a0, 0x81d05e9f, 0x078789de, 0x7a4ac4e1, 0x39c18e93,
+    0x440cc3ac, 0xc25b14ed, 0xbf9659d2, 0x1585bc2e, 0x6848f111,
+    0xee1f2650, 0x93d26b6f, 0x6149ebe9, 0x1c84a6d6, 0x9ad37197,
+    0xe71e3ca8, 0x4d0dd954, 0x30c0946b, 0xb697432a, 0xcb5a0e15,
+    0x3181d7ce, 0x4c4c9af1, 0xca1b4db0, 0xb7d6008f, 0x1dc5e573,
+    0x6008a84c, 0xe65f7f0d, 0x9b923232, 0x6909b2b4, 0x14c4ff8b,
+    0x929328ca, 0xef5e65f5, 0x454d8009, 0x3880cd36, 0xbed71a77,
+    0xc31a5748, 0x80911d3a, 0xfd5c5005, 0x7b0b8744, 0x06c6ca7b,
+    0xacd52f87, 0xd11862b8, 0x574fb5f9, 0x2a82f8c6, 0xd8197840,
+    0xa5d4357f, 0x2383e23e, 0x5e4eaf01, 0xf45d4afd, 0x899007c2,
+    0x0fc7d083, 0x720a9dbc, 0x21016574, 0x5ccc284b, 0xda9bff0a,
+    0xa756b235, 0x0d4557c9, 0x70881af6, 0xf6dfcdb7, 0x8b128088,
+    0x7989000e, 0x04444d31, 0x82139a70, 0xffded74f, 0x55cd32b3,
+    0x28007f8c, 0xae57a8cd, 0xd39ae5f2, 0x9011af80, 0xeddce2bf,
+    0x6b8b35fe, 0x164678c1, 0xbc559d3d, 0xc198d002, 0x47cf0743,
+    0x3a024a7c, 0xc899cafa, 0xb55487c5, 0x33035084, 0x4ece1dbb,
+    0xe4ddf847, 0x9910b578, 0x1f476239, 0x628a2f06, 0x9851f6dd,
+    0xe59cbbe2, 0x63cb6ca3, 0x1e06219c, 0xb415c460, 0xc9d8895f,
+    0x4f8f5e1e, 0x32421321, 0xc0d993a7, 0xbd14de98, 0x3b4309d9,
+    0x468e44e6, 0xec9da11a, 0x9150ec25, 0x17073b64, 0x6aca765b,
+    0x29413c29, 0x548c7116, 0xd2dba657, 0xaf16eb68, 0x05050e94,
+    0x78c843ab, 0xfe9f94ea, 0x8352d9d5, 0x71c95953, 0x0c04146c,
+    0x8a53c32d, 0xf79e8e12, 0x5d8d6bee, 0x204026d1, 0xa617f190,
+    0xdbdabcaf
 };

src/hotspot/os/windows/memMapPrinter_windows.cpp

@@ -0,0 +1,253 @@
+/*
+ * Copyright (c) 2024, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2024, Red Hat, Inc. and/or its affiliates.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+#include "precompiled.hpp"
+#include "nmt/memMapPrinter.hpp"
+#include "os_windows.hpp"
+#include "runtime/vm_version.hpp"
+
+#include <limits.h>
+#include <winnt.h>
+#include <memoryapi.h>
+#include <psapi.h>
+
+/* maximum number of mapping records returned */
+static const int MAX_REGIONS_RETURNED = 1000000;
+
+class MappingInfo {
+public:
+  stringStream _ap_buffer;
+  stringStream _state_buffer;
+  stringStream _protect_buffer;
+  stringStream _type_buffer;
+  char _file_name[MAX_PATH];
+
+  MappingInfo() {}
+
+  void process(MEMORY_BASIC_INFORMATION& mem_info) {
+    _ap_buffer.reset();
+    _state_buffer.reset();
+    _protect_buffer.reset();
+    _type_buffer.reset();
+    get_protect_string(_ap_buffer, mem_info.AllocationProtect);
+    get_state_string(_state_buffer, mem_info);
+    get_protect_string(_protect_buffer,  mem_info.Protect);
+    get_type_string(_type_buffer, mem_info);
+    _file_name[0] = 0;
+    if (mem_info.Type == MEM_IMAGE) {
+      HMODULE hModule = 0;
+      if (GetModuleHandleEx(GET_MODULE_HANDLE_EX_FLAG_FROM_ADDRESS, static_cast<LPCSTR>(mem_info.AllocationBase), &hModule)) {
+        GetModuleFileName(hModule, _file_name, sizeof(_file_name));
+      }
+    }
+  }
+
+  void get_protect_string(outputStream& out, DWORD prot) {
+    const char read_c = prot & (PAGE_READONLY | PAGE_READWRITE | PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE | PAGE_WRITECOPY | PAGE_EXECUTE_WRITECOPY) ? 'r' : '-';
+    const char write_c = prot & (PAGE_READWRITE | PAGE_WRITECOPY | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY) ? 'w' : '-';
+    const char execute_c = prot & (PAGE_EXECUTE | PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY) ? 'x' : '-';
+    out.print("%c%c%c", read_c, write_c, execute_c);
+    if (prot & (PAGE_WRITECOPY | PAGE_EXECUTE_WRITECOPY)) {
+      out.put('c');
+    }
+    if (prot & PAGE_GUARD) {
+      out.put('g');
+    }
+    if (prot & PAGE_NOCACHE) {
+      out.put('n');
+    }
+    if (prot & PAGE_WRITECOMBINE) {
+      out.put('W');
+    }
+    const DWORD bits = PAGE_NOACCESS | PAGE_READONLY | PAGE_READWRITE | PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE
+                        | PAGE_WRITECOPY | PAGE_EXECUTE_WRITECOPY | PAGE_EXECUTE
+                        | PAGE_GUARD | PAGE_NOCACHE | PAGE_WRITECOMBINE;
+    if ((prot & bits) != prot) {
+      out.print_cr("Unknown Windows memory protection value: 0x%x unknown bits: 0x%x", prot, prot & ~bits);
+      assert(false, "Unknown Windows memory protection value: 0x%x unknown bits: 0x%x", prot, prot & ~bits);
+    }
+  }
+
+  void get_state_string(outputStream& out, MEMORY_BASIC_INFORMATION& mem_info) {
+    if (mem_info.State == MEM_COMMIT) {
+      out.put('c');
+    } else if (mem_info.State == MEM_FREE) {
+      out.put('f');
+    } else if (mem_info.State == MEM_RESERVE) {
+      out.put('r');
+    } else {
+      out.print_cr("Unknown Windows memory state value: 0x%x", mem_info.State);
+      assert(false, "Unknown Windows memory state value: 0x%x", mem_info.State);
+    }
+  }
+
+  void get_type_string(outputStream& out, MEMORY_BASIC_INFORMATION& mem_info) {
+    if (mem_info.Type == MEM_IMAGE) {
+      out.print("img");
+    } else if (mem_info.Type == MEM_MAPPED) {
+      out.print("map");
+    } else if (mem_info.Type == MEM_PRIVATE) {
+      out.print("pvt");
+    } else if (mem_info.Type == 0 && mem_info.State == MEM_FREE) {
+      out.print("---");
+    } else {
+      out.print_cr("Unknown Windows memory type 0x%x", mem_info.Type);
+      assert(false, "Unknown Windows memory type 0x%x", mem_info.Type);
+    }
+  }
+};
+
+class MappingInfoSummary {
+  unsigned _num_mappings;
+  size_t _total_region_size;  // combined resident set size
+  size_t _total_committed;    // combined committed size
+  class WinOsInfo : public os::win32 {
+    public:
+      static void printOsInfo(outputStream* st) {
+        st->print("OS:");
+        os::win32::print_windows_version(st);
+        os::win32::print_uptime_info(st);
+        VM_Version::print_platform_virtualization_info(st);
+        os::print_memory_info(st);
+      }
+  };
+public:
+  MappingInfoSummary() : _num_mappings(0),  _total_region_size(0),
+                      _total_committed(0) {}
+
+  void add_mapping(const MEMORY_BASIC_INFORMATION& mem_info, const MappingInfo& mapping_info) {
+    if (mem_info.State != MEM_FREE) {
+      _num_mappings++;
+      _total_region_size += mem_info.RegionSize;
+      _total_committed += mem_info.State == MEM_COMMIT ? mem_info.RegionSize : 0;
+    }
+  }
+
+  void print_on(const MappingPrintSession& session) const {
+    outputStream* st = session.out();
+    WinOsInfo::printOsInfo(st);
+    st->print_cr("current process reserved memory: " PROPERFMT, PROPERFMTARGS(_total_region_size));
+    st->print_cr("current process committed memory: " PROPERFMT, PROPERFMTARGS(_total_committed));
+    st->print_cr("current process region count: " PROPERFMT, PROPERFMTARGS(_num_mappings));
+  }
+};
+
+class MappingInfoPrinter {
+  const MappingPrintSession& _session;
+public:
+  MappingInfoPrinter(const MappingPrintSession& session) :
+    _session(session)
+  {}
+
+  void print_single_mapping(const MEMORY_BASIC_INFORMATION& mem_info, const MappingInfo& mapping_info) const {
+    outputStream* st = _session.out();
+#define INDENT_BY(n)          \
+  if (st->fill_to(n) == 0) {  \
+    st->print(" ");           \
+  }
+    st->print(PTR_FORMAT "-" PTR_FORMAT, mem_info.BaseAddress, static_cast<const char*>(mem_info.BaseAddress) + mem_info.RegionSize);
+    INDENT_BY(38);
+    st->print("%12zu", mem_info.RegionSize);
+    INDENT_BY(51);
+    st->print("%s", mapping_info._protect_buffer.base());
+    INDENT_BY(57);
+    st->print("%s-%s", mapping_info._state_buffer.base(), mapping_info._type_buffer.base());
+    INDENT_BY(63);
+    st->print("%#11llx", reinterpret_cast<const unsigned long long>(mem_info.BaseAddress) - reinterpret_cast<const unsigned long long>(mem_info.AllocationBase));
+    INDENT_BY(72);
+    if (_session.print_nmt_info_for_region(mem_info.BaseAddress, static_cast<const char*>(mem_info.BaseAddress) + mem_info.RegionSize)) {
+      st->print(" ");
+    }
+    st->print_raw(mapping_info._file_name);
+  #undef INDENT_BY
+    st->cr();
+  }
+
+  void print_legend() const {
+    outputStream* st = _session.out();
+    st->print_cr("from, to, vsize: address range and size");
+    st->print_cr("prot:    protection:");
+    st->print_cr("             rwx: read / write / execute");
+    st->print_cr("             c: copy on write");
+    st->print_cr("             g: guard");
+    st->print_cr("             n: no cache");
+    st->print_cr("             W: write combine");
+    st->print_cr("state:   region state and type:");
+    st->print_cr("             state: committed / reserved");
+    st->print_cr("             type: image / mapped / private");
+    st->print_cr("file:    file mapped, if mapping is not anonymous");
+    st->print_cr("vm info: VM information (requires NMT)");
+    {
+      streamIndentor si(st, 16);
+      _session.print_nmt_flag_legend();
+    }
+  }
+
+  void print_header() const {
+    outputStream* st = _session.out();
+    //            0         1         2         3         4         5         6         7         8         9         0         1         2         3
+    //            01234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789
+    //            0x00007ffb24565000-0x00007ffb24a7e000      5345280 r--   c-img   0x1155000 C:\work\jdk\build\fastdebug\jdk\bin\server\jvm.dll
+    st->print_cr("from               to                        vsize prot  state      offset vminfo/file");
+    st->print_cr("===========================================================================================");
+  }
+};
+
+void MemMapPrinter::pd_print_all_mappings(const MappingPrintSession& session) {
+
+  HANDLE hProcess = GetCurrentProcess();
+
+  MappingInfoPrinter printer(session);
+  MappingInfoSummary summary;
+
+  outputStream* const st = session.out();
+
+  printer.print_legend();
+  st->cr();
+  printer.print_header();
+
+  MEMORY_BASIC_INFORMATION mem_info;
+  MappingInfo mapping_info;
+
+  int region_count = 0;
+  ::memset(&mem_info, 0, sizeof(mem_info));
+  for (char* ptr = 0; VirtualQueryEx(hProcess, ptr, &mem_info, sizeof(mem_info)) == sizeof(mem_info); ) {
+    assert(mem_info.RegionSize > 0, "RegionSize is not greater than zero");
+    if (++region_count > MAX_REGIONS_RETURNED) {
+      st->print_cr("limit of %d regions reached (results inaccurate)", region_count);
+      break;
+    }
+    mapping_info.process(mem_info);
+    if (mem_info.State != MEM_FREE) {
+      printer.print_single_mapping(mem_info, mapping_info);
+      summary.add_mapping(mem_info, mapping_info);
+    }
+    ptr += mem_info.RegionSize;
+    ::memset(&mem_info, 0, sizeof(mem_info));
+  }
+  st->cr();
+  summary.print_on(session);
+  st->cr();
+}

src/hotspot/share/jfr/recorder/service/jfrOptionSet.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2012, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2012, 2024, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -208,7 +208,7 @@ static DCmdArgument<MemorySizeArgument> _dcmd_globalbuffersize(
 static DCmdArgument<jlong> _dcmd_numglobalbuffers(
   "numglobalbuffers",
   "Number of global buffers",
-  "JULONG",
+  "INT",
   false,
   default_num_global_buffers);
 
@@ -222,7 +222,7 @@ static DCmdArgument<MemorySizeArgument> _dcmd_maxchunksize(
 static DCmdArgument<jlong> _dcmd_old_object_queue_size (
   "old-object-queue-size",
   "Maximum number of old objects to track",
-  "JINT",
+  "INT",
   false,
   default_old_object_queue_size);
 
@@ -245,7 +245,7 @@ static DCmdArgument<bool> _dcmd_sample_protection(
 static DCmdArgument<jlong> _dcmd_stackdepth(
   "stackdepth",
   "Stack depth for stacktraces (minimum 1, maximum 2048)",
-  "JULONG",
+  "INT",
   false,
   default_stack_depth);
 

src/hotspot/share/jfr/support/jfrNativeLibraryLoadEvent.cpp

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2023, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2023, 2024, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
@@ -117,6 +117,7 @@ static void commit(const HelperType& helper) {
     JavaThread* jt = JavaThread::cast(thread);
     if (jt->thread_state() == _thread_in_native) {
       // For a JavaThread to take a JFR stacktrace, it must be in _thread_in_vm. Can safepoint here.
+      MACOS_AARCH64_ONLY(ThreadWXEnable __wx(WXWrite, jt));
       ThreadInVMfromNative transition(jt);
       event.commit();
       return;

src/hotspot/share/nmt/memMapPrinter.cpp

@@ -25,7 +25,7 @@
 
 #include "precompiled.hpp"
 
-#ifdef LINUX
+#if defined(LINUX) || defined(_WIN64)
 
 #include "gc/shared/collectedHeap.hpp"
 #include "logging/logAsyncWriter.hpp"

src/hotspot/share/nmt/memMapPrinter.hpp

@@ -30,7 +30,7 @@
 #include "nmt/memTag.hpp"
 #include "utilities/globalDefinitions.hpp"
 
-#ifdef LINUX
+#if defined(LINUX) || defined(_WIN64)
 
 class outputStream;
 class CachedNMTInformation;

src/hotspot/share/opto/compile.cpp

@@ -3347,8 +3347,9 @@ void Compile::final_graph_reshaping_main_switch(Node* n, Final_Reshape_Counts& f
       bool is_oop   = t->isa_oopptr() != nullptr;
       bool is_klass = t->isa_klassptr() != nullptr;
 
-      if ((is_oop   && Matcher::const_oop_prefer_decode()  ) ||
-          (is_klass && Matcher::const_klass_prefer_decode() && t->isa_klassptr()->exact_klass()->is_in_encoding_range())) {
+      if ((is_oop   && UseCompressedOops          && Matcher::const_oop_prefer_decode()  ) ||
+          (is_klass && UseCompressedClassPointers && Matcher::const_klass_prefer_decode() &&
+           t->isa_klassptr()->exact_klass()->is_in_encoding_range())) {
         Node* nn = nullptr;
 
         int op = is_oop ? Op_ConN : Op_ConNKlass;

src/hotspot/share/opto/gcm.cpp

@@ -562,6 +562,103 @@ bool PhaseCFG::unrelated_load_in_store_null_block(Node* store, Node* load) {
   return false;
 }
 
+class DefUseMemStatesQueue : public StackObj {
+private:
+  class DefUsePair : public StackObj {
+  private:
+    Node* _def; // memory state
+    Node* _use; // use of the memory state that also modifies the memory state
+
+  public:
+    DefUsePair(Node* def, Node* use) :
+      _def(def), _use(use) {
+    }
+
+    DefUsePair() :
+      _def(nullptr), _use(nullptr) {
+    }
+
+    Node* def() const {
+      return _def;
+    }
+
+    Node* use() const {
+      return _use;
+    }
+  };
+
+  GrowableArray<DefUsePair> _queue;
+  GrowableArray<MergeMemNode*> _worklist_visited; // visited mergemem nodes
+
+  bool already_enqueued(Node* def_mem, PhiNode* use_phi) const {
+    // def_mem is one of the inputs of use_phi and at least one input of use_phi is
+    // not def_mem. It's however possible that use_phi has def_mem as input multiple
+    // times. If that happens, use_phi is recorded as a use of def_mem multiple
+    // times as well. When PhaseCFG::insert_anti_dependences() goes over
+    // uses of def_mem and enqueues them for processing, use_phi would then be
+    // enqueued for processing multiple times when it only needs to be
+    // processed once. The code below checks if use_phi as a use of def_mem was
+    // already enqueued to avoid redundant processing of use_phi.
+    int j = _queue.length()-1;
+    // If there are any use of def_mem already enqueued, they were enqueued
+    // last (all use of def_mem are processed in one go).
+    for (; j >= 0; j--) {
+      const DefUsePair& def_use_pair = _queue.at(j);
+      if (def_use_pair.def() != def_mem) {
+        // We're done with the uses of def_mem
+        break;
+      }
+      if (def_use_pair.use() == use_phi) {
+        return true;
+      }
+    }
+#ifdef ASSERT
+    for (; j >= 0; j--) {
+      const DefUsePair& def_use_pair = _queue.at(j);
+      assert(def_use_pair.def() != def_mem, "Should be done with the uses of def_mem");
+    }
+#endif
+    return false;
+  }
+
+public:
+  DefUseMemStatesQueue(ResourceArea* area) {
+  }
+
+  void push(Node* def_mem_state, Node* use_mem_state) {
+    if (use_mem_state->is_MergeMem()) {
+      // Be sure we don't get into combinatorial problems.
+      if (!_worklist_visited.append_if_missing(use_mem_state->as_MergeMem())) {
+        return; // already on work list; do not repeat
+      }
+    } else if (use_mem_state->is_Phi()) {
+      // A Phi could have the same mem as input multiple times. If that's the case, we don't need to enqueue it
+      // more than once. We otherwise allow phis to be repeated; they can merge two relevant states.
+      if (already_enqueued(def_mem_state, use_mem_state->as_Phi())) {
+        return;
+      }
+    }
+
+    _queue.push(DefUsePair(def_mem_state, use_mem_state));
+  }
+
+  bool is_nonempty() const {
+    return _queue.is_nonempty();
+  }
+
+  Node* top_def() const {
+    return _queue.top().def();
+  }
+
+  Node* top_use() const {
+    return _queue.top().use();
+  }
+
+  void pop() {
+    _queue.pop();
+  }
+};
+
 //--------------------------insert_anti_dependences---------------------------
 // A load may need to witness memory that nearby stores can overwrite.
 // For each nearby store, either insert an "anti-dependence" edge
@@ -579,6 +676,7 @@ bool PhaseCFG::unrelated_load_in_store_null_block(Node* store, Node* load) {
 // preserve anti-dependences.  The caller may also hoist the load
 // above the LCA, if it is not the early block.
 Block* PhaseCFG::insert_anti_dependences(Block* LCA, Node* load, bool verify) {
+  ResourceMark rm;
   assert(load->needs_anti_dependence_check(), "must be a load of some sort");
   assert(LCA != nullptr, "");
   DEBUG_ONLY(Block* LCA_orig = LCA);
@@ -625,10 +723,8 @@ Block* PhaseCFG::insert_anti_dependences(Block* LCA, Node* load, bool verify) {
     early = memory_early_block(load, early, this);
   }
 
-  ResourceArea *area = Thread::current()->resource_area();
-  Node_List worklist_mem(area);     // prior memory state to store
-  Node_List worklist_store(area);   // possible-def to explore
-  Node_List worklist_visited(area); // visited mergemem nodes
+  ResourceArea* area = Thread::current()->resource_area();
+  DefUseMemStatesQueue worklist_def_use_mem_states(area); // prior memory state to store and possible-def to explore
   Node_List non_early_stores(area); // all relevant stores outside of early
   bool must_raise_LCA = false;
 
@@ -644,60 +740,56 @@ Block* PhaseCFG::insert_anti_dependences(Block* LCA, Node* load, bool verify) {
   // The relevant stores "nearby" the load consist of a tree rooted
   // at initial_mem, with internal nodes of type MergeMem.
   // Therefore, the branches visited by the worklist are of this form:
-  //    initial_mem -> (MergeMem ->)* store
+  //    initial_mem -> (MergeMem ->)* Memory state modifying node
+  // Memory state modifying nodes include Store and Phi nodes and any node for which needs_anti_dependence_check()
+  // returns false.
   // The anti-dependence constraints apply only to the fringe of this tree.
 
   Node* initial_mem = load->in(MemNode::Memory);
-  worklist_store.push(initial_mem);
-  worklist_visited.push(initial_mem);
-  worklist_mem.push(nullptr);
-  while (worklist_store.size() > 0) {
+  worklist_def_use_mem_states.push(nullptr, initial_mem);
+  while (worklist_def_use_mem_states.is_nonempty()) {
     // Examine a nearby store to see if it might interfere with our load.
-    Node* mem   = worklist_mem.pop();
-    Node* store = worklist_store.pop();
-    uint op = store->Opcode();
+    Node* def_mem_state = worklist_def_use_mem_states.top_def();
+    Node* use_mem_state = worklist_def_use_mem_states.top_use();
+    worklist_def_use_mem_states.pop();
+
+    uint op = use_mem_state->Opcode();
+    assert(!use_mem_state->needs_anti_dependence_check(), "no loads");
 
     // MergeMems do not directly have anti-deps.
     // Treat them as internal nodes in a forward tree of memory states,
     // the leaves of which are each a 'possible-def'.
-    if (store == initial_mem    // root (exclusive) of tree we are searching
+    if (use_mem_state == initial_mem    // root (exclusive) of tree we are searching
         || op == Op_MergeMem    // internal node of tree we are searching
         ) {
-      mem = store;   // It's not a possibly interfering store.
-      if (store == initial_mem)
+      def_mem_state = use_mem_state;   // It's not a possibly interfering store.
+      if (use_mem_state == initial_mem)
         initial_mem = nullptr;  // only process initial memory once
 
-      for (DUIterator_Fast imax, i = mem->fast_outs(imax); i < imax; i++) {
-        store = mem->fast_out(i);
-        if (store->is_MergeMem()) {
-          // Be sure we don't get into combinatorial problems.
-          // (Allow phis to be repeated; they can merge two relevant states.)
-          uint j = worklist_visited.size();
-          for (; j > 0; j--) {
-            if (worklist_visited.at(j-1) == store)  break;
-          }
-          if (j > 0)  continue; // already on work list; do not repeat
-          worklist_visited.push(store);
+      for (DUIterator_Fast imax, i = def_mem_state->fast_outs(imax); i < imax; i++) {
+        use_mem_state = def_mem_state->fast_out(i);
+        if (use_mem_state->needs_anti_dependence_check()) {
+          // use_mem_state is also a kind of load (i.e. needs_anti_dependence_check), and it is not a memory state
+          // modifying node (store, Phi or MergeMem). Hence, load can't be anti dependent on this node.
+          continue;
         }
-        worklist_mem.push(mem);
-        worklist_store.push(store);
+        worklist_def_use_mem_states.push(def_mem_state, use_mem_state);
       }
       continue;
     }
 
     if (op == Op_MachProj || op == Op_Catch)   continue;
-    if (store->needs_anti_dependence_check())  continue;  // not really a store
 
     // Compute the alias index.  Loads and stores with different alias
     // indices do not need anti-dependence edges.  Wide MemBar's are
     // anti-dependent on everything (except immutable memories).
-    const TypePtr* adr_type = store->adr_type();
+    const TypePtr* adr_type = use_mem_state->adr_type();
     if (!C->can_alias(adr_type, load_alias_idx))  continue;
 
     // Most slow-path runtime calls do NOT modify Java memory, but
     // they can block and so write Raw memory.
-    if (store->is_Mach()) {
-      MachNode* mstore = store->as_Mach();
+    if (use_mem_state->is_Mach()) {
+      MachNode* mstore = use_mem_state->as_Mach();
       if (load_alias_idx != Compile::AliasIdxRaw) {
         // Check for call into the runtime using the Java calling
         // convention (and from there into a wrapper); it has no
@@ -736,10 +828,10 @@ Block* PhaseCFG::insert_anti_dependences(Block* LCA, Node* load, bool verify) {
     // or else observe that 'store' is all the way up in the
     // earliest legal block for 'load'.  In the latter case,
     // immediately insert an anti-dependence edge.
-    Block* store_block = get_block_for_node(store);
+    Block* store_block = get_block_for_node(use_mem_state);
     assert(store_block != nullptr, "unused killing projections skipped above");
 
-    if (store->is_Phi()) {
+    if (use_mem_state->is_Phi()) {
       // Loop-phis need to raise load before input. (Other phis are treated
       // as store below.)
       //
@@ -754,8 +846,8 @@ Block* PhaseCFG::insert_anti_dependences(Block* LCA, Node* load, bool verify) {
       // Do not assert(store_block != early, "Phi merging memory after access")
       // PhiNode may be at start of block 'early' with backedge to 'early'
       DEBUG_ONLY(bool found_match = false);
-      for (uint j = PhiNode::Input, jmax = store->req(); j < jmax; j++) {
-        if (store->in(j) == mem) {   // Found matching input?
+      for (uint j = PhiNode::Input, jmax = use_mem_state->req(); j < jmax; j++) {
+        if (use_mem_state->in(j) == def_mem_state) {   // Found matching input?
           DEBUG_ONLY(found_match = true);
           Block* pred_block = get_block_for_node(store_block->pred(j));
           if (pred_block != early) {
@@ -781,21 +873,21 @@ Block* PhaseCFG::insert_anti_dependences(Block* LCA, Node* load, bool verify) {
       // will find him on the non_early_stores list and stick him
       // with a precedence edge.
       // (But, don't bother if LCA is already raised all the way.)
-      if (LCA != early && !unrelated_load_in_store_null_block(store, load)) {
+      if (LCA != early && !unrelated_load_in_store_null_block(use_mem_state, load)) {
         store_block->set_raise_LCA_mark(load_index);
         must_raise_LCA = true;
-        non_early_stores.push(store);
+        non_early_stores.push(use_mem_state);
       }
     } else {
       // Found a possibly-interfering store in the load's 'early' block.
       // This means 'load' cannot sink at all in the dominator tree.
       // Add an anti-dep edge, and squeeze 'load' into the highest block.
-      assert(store != load->find_exact_control(load->in(0)), "dependence cycle found");
+      assert(use_mem_state != load->find_exact_control(load->in(0)), "dependence cycle found");
       if (verify) {
-        assert(store->find_edge(load) != -1 || unrelated_load_in_store_null_block(store, load),
+        assert(use_mem_state->find_edge(load) != -1 || unrelated_load_in_store_null_block(use_mem_state, load),
                "missing precedence edge");
       } else {
-        store->add_prec(load);
+        use_mem_state->add_prec(load);
       }
       LCA = early;
       // This turns off the process of gathering non_early_stores.

src/hotspot/share/services/diagnosticCommand.cpp

@@ -138,9 +138,11 @@ void DCmd::register_dcmds(){
   DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<PerfMapDCmd>(full_export, true, false));
   DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<TrimCLibcHeapDCmd>(full_export, true, false));
   DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<MallocInfoDcmd>(full_export, true, false));
+#endif // LINUX
+#if defined(LINUX) || defined(_WIN64)
   DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<SystemMapDCmd>(full_export, true,false));
   DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<SystemDumpMapDCmd>(full_export, true,false));
-#endif // LINUX
+#endif // LINUX or WINDOWS
   DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<CodeHeapAnalyticsDCmd>(full_export, true, false));
 
   DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<CompilerDirectivesPrintDCmd>(full_export, true, false));
@@ -1172,7 +1174,7 @@ void CompilationMemoryStatisticDCmd::execute(DCmdSource source, TRAPS) {
   CompilationMemoryStatistic::print_all_by_size(output(), human_readable, minsize);
 }
 
-#ifdef LINUX
+#if defined(LINUX) || defined(_WIN64)
 
 SystemMapDCmd::SystemMapDCmd(outputStream* output, bool heap) : DCmd(output, heap) {}
 
@@ -1190,16 +1192,22 @@ SystemDumpMapDCmd::SystemDumpMapDCmd(outputStream* output, bool heap) :
 
 void SystemDumpMapDCmd::execute(DCmdSource source, TRAPS) {
   const char* name = _filename.value();
+  if (name == nullptr || name[0] == 0) {
+    output()->print_cr("filename is empty or not specified.  No file written");
+    return;
+  }
   fileStream fs(name);
   if (fs.is_open()) {
     if (!MemTracker::enabled()) {
       output()->print_cr("(NMT is disabled, will not annotate mappings).");
     }
     MemMapPrinter::print_all_mappings(&fs);
+#ifndef _WIN64
     // For the readers convenience, resolve path name.
     char tmp[JVM_MAXPATHLEN];
     const char* absname = os::Posix::realpath(name, tmp, sizeof(tmp));
     name = absname != nullptr ? absname : name;
+#endif
     output()->print_cr("Memory map dumped to \"%s\".", name);
   } else {
     output()->print_cr("Failed to open \"%s\" for writing (%s).", name, os::strerror(errno));

src/hotspot/share/services/diagnosticCommand.hpp

@@ -981,14 +981,14 @@ public:
   virtual void execute(DCmdSource source, TRAPS);
 };
 
-#ifdef LINUX
+#if defined(LINUX) || defined(_WIN64)
 
 class SystemMapDCmd : public DCmd {
 public:
   SystemMapDCmd(outputStream* output, bool heap);
   static const char* name() { return "System.map"; }
   static const char* description() {
-    return "Prints an annotated process memory map of the VM process (linux only).";
+    return "Prints an annotated process memory map of the VM process (linux and Windows only).";
   }
   static const char* impact() { return "Medium; can be high for very large java heaps."; }
   static const JavaPermission permission() {
@@ -1006,7 +1006,7 @@ public:
   SystemDumpMapDCmd(outputStream* output, bool heap);
   static const char* name() { return "System.dump_map"; }
   static const char* description() {
-    return "Dumps an annotated process memory map to an output file (linux only).";
+    return "Dumps an annotated process memory map to an output file (linux and Windows only).";
   }
   static const char* impact() { return "Medium; can be high for very large java heaps."; }
   static const JavaPermission permission() {
@@ -1017,6 +1017,6 @@ public:
   virtual void execute(DCmdSource source, TRAPS);
 };
 
-#endif // LINUX
+#endif // LINUX or WINDOWS
 
 #endif // SHARE_SERVICES_DIAGNOSTICCOMMAND_HPP

src/java.base/share/classes/java/lang/TypeNotPresentException.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003, 2020, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2024, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -28,9 +28,9 @@ package java.lang;
 /**
  * Thrown when an application tries to access a type using a string
  * representing the type's name, but no definition for the type with
- * the specified name can be found.   This exception differs from
- * {@link ClassNotFoundException} in that {@code ClassNotFoundException} is a
- * checked exception, whereas this exception is unchecked.
+ * the specified name can be found. This exception differs from
+ * {@link ClassNotFoundException} in that {@code ClassNotFoundException}
+ * is a checked exception, whereas this exception is unchecked.
  *
  * <p>Note that this exception may be used when undefined type variables
  * are accessed as well as when types (e.g., classes, interfaces or
@@ -48,15 +48,15 @@ public class TypeNotPresentException extends RuntimeException {
     private static final long serialVersionUID = -5101214195716534496L;
 
     /**
-     * The type name.
+     * The type name or the name of a type variable.
      */
     private String typeName;
 
     /**
-     * Constructs a {@code TypeNotPresentException} for the named type
-     * with the specified cause.
+     * Constructs a {@code TypeNotPresentException} for the named type or
+     * type variable with the specified cause.
      *
-     * @param typeName the fully qualified name of the unavailable type
+     * @param typeName the fully qualified name of the unavailable type or type variable
      * @param cause the exception that was thrown when the system attempted to
      *    load the named type, or {@code null} if unavailable or inapplicable
      */
@@ -66,9 +66,9 @@ public class TypeNotPresentException extends RuntimeException {
     }
 
     /**
-     * Returns the fully qualified name of the unavailable type.
+     * Returns the fully qualified name of the unavailable type or type variable name.
      *
-     * @return the fully qualified name of the unavailable type
+     * @return the fully qualified name of the unavailable type or type variable name
      */
     public String typeName() { return typeName;}
 }

src/java.base/share/classes/java/lang/invoke/DelegatingMethodHandle.java

@@ -143,7 +143,7 @@ abstract sealed class DelegatingMethodHandle extends MethodHandle
         final int PRE_ACTION   = hasPreAction ? nameCursor++ : -1;
         final int NEXT_MH     = customized ? -1 : nameCursor++;
         final int REINVOKE    = nameCursor++;
-        LambdaForm.Name[] names = LambdaForm.arguments(nameCursor - ARG_LIMIT, mtype.invokerType());
+        LambdaForm.Name[] names = LambdaForm.invokeArguments(nameCursor - ARG_LIMIT, mtype);
         assert(names.length == nameCursor);
         names[THIS_DMH] = names[THIS_DMH].withConstraint(constraint);
         Object[] targetArgs;

src/java.base/share/classes/java/lang/invoke/DirectMethodHandle.java

@@ -250,11 +250,17 @@ sealed class DirectMethodHandle extends MethodHandle {
         default:  throw new InternalError("which="+which);
         }
 
-        MethodType mtypeWithArg = mtype.appendParameterTypes(MemberName.class);
-        if (doesAlloc)
-            mtypeWithArg = mtypeWithArg
-                    .insertParameterTypes(0, Object.class)  // insert newly allocated obj
-                    .changeReturnType(void.class);          // <init> returns void
+        MethodType mtypeWithArg;
+        if (doesAlloc) {
+            var ptypes = mtype.ptypes();
+            var newPtypes = new Class<?>[ptypes.length + 2];
+            newPtypes[0] = Object.class; // insert newly allocated obj
+            System.arraycopy(ptypes, 0, newPtypes, 1, ptypes.length);
+            newPtypes[newPtypes.length - 1] = MemberName.class;
+            mtypeWithArg = MethodType.methodType(void.class, newPtypes, true);
+        } else {
+            mtypeWithArg = mtype.appendParameterTypes(MemberName.class);
+        }
         MemberName linker = new MemberName(MethodHandle.class, linkerName, mtypeWithArg, REF_invokeStatic);
         try {
             linker = IMPL_NAMES.resolveOrFail(REF_invokeStatic, linker, null, LM_TRUSTED,
@@ -270,7 +276,7 @@ sealed class DirectMethodHandle extends MethodHandle {
         final int GET_MEMBER  = nameCursor++;
         final int CHECK_RECEIVER = (needsReceiverCheck ? nameCursor++ : -1);
         final int LINKER_CALL = nameCursor++;
-        Name[] names = arguments(nameCursor - ARG_LIMIT, mtype.invokerType());
+        Name[] names = invokeArguments(nameCursor - ARG_LIMIT, mtype);
         assert(names.length == nameCursor);
         if (doesAlloc) {
             // names = { argx,y,z,... new C, init method }
@@ -786,7 +792,7 @@ sealed class DirectMethodHandle extends MethodHandle {
         final int LINKER_CALL = nameCursor++;
         final int POST_CAST = (needsCast && isGetter ? nameCursor++ : -1);
         final int RESULT    = nameCursor-1;  // either the call or the cast
-        Name[] names = arguments(nameCursor - ARG_LIMIT, mtype.invokerType());
+        Name[] names = invokeArguments(nameCursor - ARG_LIMIT, mtype);
         if (needsInit)
             names[INIT_BAR] = new Name(getFunction(NF_ensureInitialized), names[DMH_THIS]);
         if (needsCast && !isGetter)

src/java.base/share/classes/java/lang/invoke/Invokers.java

@@ -314,14 +314,14 @@ class Invokers {
         final int CHECK_TYPE   = nameCursor++;
         final int CHECK_CUSTOM = (CUSTOMIZE_THRESHOLD >= 0) ? nameCursor++ : -1;
         final int LINKER_CALL  = nameCursor++;
-        MethodType invokerFormType = mtype.invokerType();
+        MethodType invokerFormType = mtype;
         if (isLinker) {
             if (!customized)
                 invokerFormType = invokerFormType.appendParameterTypes(MemberName.class);
         } else {
             invokerFormType = invokerFormType.invokerType();
         }
-        Name[] names = arguments(nameCursor - INARG_LIMIT, invokerFormType);
+        Name[] names = invokeArguments(nameCursor - INARG_LIMIT, invokerFormType);
         assert(names.length == nameCursor)
                 : Arrays.asList(mtype, customized, which, nameCursor, names.length);
         if (MTYPE_ARG >= INARG_LIMIT) {
@@ -390,11 +390,11 @@ class Invokers {
         final int LINKER_CALL  = nameCursor++;
 
         Name[] names = new Name[LINKER_CALL + 1];
-        names[THIS_VH] = argument(THIS_VH, BasicType.basicType(Object.class));
+        names[THIS_VH] = argument(THIS_VH, BasicType.L_TYPE);
         for (int i = 0; i < mtype.parameterCount(); i++) {
             names[ARG_BASE + i] = argument(ARG_BASE + i, BasicType.basicType(mtype.parameterType(i)));
         }
-        names[VAD_ARG] = new Name(ARG_LIMIT, BasicType.basicType(Object.class));
+        names[VAD_ARG] = new Name(ARG_LIMIT, BasicType.L_TYPE);
 
         names[UNBOUND_VH] = new Name(getFunction(NF_directVarHandleTarget), names[THIS_VH]);
 
@@ -446,8 +446,8 @@ class Invokers {
         final int LINKER_CALL  = nameCursor++;
 
         Name[] names = new Name[LINKER_CALL + 1];
-        names[THIS_MH] = argument(THIS_MH, BasicType.basicType(Object.class));
-        names[CALL_VH] = argument(CALL_VH, BasicType.basicType(Object.class));
+        names[THIS_MH] = argument(THIS_MH, BasicType.L_TYPE);
+        names[CALL_VH] = argument(CALL_VH, BasicType.L_TYPE);
         for (int i = 0; i < mtype.parameterCount(); i++) {
             names[ARG_BASE + i] = argument(ARG_BASE + i, BasicType.basicType(mtype.parameterType(i)));
         }
@@ -589,17 +589,16 @@ class Invokers {
         final int CSITE_ARG    = skipCallSite ? -1 : APPENDIX_ARG;
         final int CALL_MH      = skipCallSite ? APPENDIX_ARG : nameCursor++;  // result of getTarget
         final int LINKER_CALL  = nameCursor++;
-        MethodType invokerFormType = mtype.appendParameterTypes(skipCallSite ? MethodHandle.class : CallSite.class);
-        Name[] names = arguments(nameCursor - INARG_LIMIT, invokerFormType);
-        assert(names.length == nameCursor);
-        assert(names[APPENDIX_ARG] != null);
+        Name[] names = arguments(nameCursor - INARG_LIMIT + 1, mtype);
+        assert(names.length == nameCursor && names[APPENDIX_ARG] == null);
+        names[APPENDIX_ARG] = argument(APPENDIX_ARG, BasicType.L_TYPE);
         if (!skipCallSite)
             names[CALL_MH] = new Name(getFunction(NF_getCallSiteTarget), names[CSITE_ARG]);
         // (site.)invokedynamic(a*):R => mh = site.getTarget(); mh.invokeBasic(a*)
         final int PREPEND_MH = 0, PREPEND_COUNT = 1;
-        Object[] outArgs = Arrays.copyOfRange(names, ARG_BASE, OUTARG_LIMIT + PREPEND_COUNT, Object[].class);
+        Object[] outArgs = new Object[OUTARG_LIMIT + PREPEND_COUNT];
+        System.arraycopy(names, 0, outArgs, PREPEND_COUNT, outArgs.length - PREPEND_COUNT);
         // prepend MH argument:
-        System.arraycopy(outArgs, 0, outArgs, PREPEND_COUNT, outArgs.length - PREPEND_COUNT);
         outArgs[PREPEND_MH] = names[CALL_MH];
         names[LINKER_CALL] = new Name(mtype, outArgs);
         lform = LambdaForm.create(INARG_LIMIT, names,

src/java.base/share/classes/java/lang/invoke/LambdaForm.java

@@ -1636,6 +1636,16 @@ class LambdaForm {
             names[i] = argument(i, basicType(types.parameterType(i)));
         return names;
     }
+
+    static Name[] invokeArguments(int extra, MethodType types) {
+        int length = types.parameterCount();
+        Name[] names = new Name[length + extra + 1];
+        names[0] = argument(0, L_TYPE);
+        for (int i = 0; i < length; i++)
+            names[i + 1] = argument(i + 1, basicType(types.parameterType(i)));
+        return names;
+    }
+
     static final int INTERNED_ARGUMENT_LIMIT = 10;
     private static final Name[][] INTERNED_ARGUMENTS
             = new Name[ARG_TYPE_LIMIT][INTERNED_ARGUMENT_LIMIT];

src/java.base/share/classes/java/lang/invoke/MethodHandleImpl.java

@@ -810,8 +810,7 @@ abstract class MethodHandleImpl {
         final int CALL_TARGET  = nameCursor++;
         assert(CALL_TARGET == SELECT_ALT+1);  // must be true to trigger IBG.emitSelectAlternative
 
-        MethodType lambdaType = basicType.invokerType();
-        Name[] names = arguments(nameCursor - ARG_LIMIT, lambdaType);
+        Name[] names = invokeArguments(nameCursor - ARG_LIMIT, basicType);
 
         BoundMethodHandle.SpeciesData data =
                 (GET_COUNTERS != -1) ? BoundMethodHandle.speciesData_LLLL()
@@ -843,7 +842,7 @@ abstract class MethodHandleImpl {
         invokeArgs[0] = names[SELECT_ALT];
         names[CALL_TARGET] = new Name(basicType, invokeArgs);
 
-        lform = LambdaForm.create(lambdaType.parameterCount(), names, /*forceInline=*/true, Kind.GUARD);
+        lform = LambdaForm.create(basicType.parameterCount() + 1, names, /*forceInline=*/true, Kind.GUARD);
 
         return basicType.form().setCachedLambdaForm(MethodTypeForm.LF_GWT, lform);
     }
@@ -870,8 +869,6 @@ abstract class MethodHandleImpl {
      * among catchException combinators with the same basic type.
      */
     private static LambdaForm makeGuardWithCatchForm(MethodType basicType) {
-        MethodType lambdaType = basicType.invokerType();
-
         LambdaForm lform = basicType.form().cachedLambdaForm(MethodTypeForm.LF_GWC);
         if (lform != null) {
             return lform;
@@ -890,7 +887,7 @@ abstract class MethodHandleImpl {
         final int TRY_CATCH        = nameCursor++;
         final int UNBOX_RESULT     = nameCursor++;
 
-        Name[] names = arguments(nameCursor - ARG_LIMIT, lambdaType);
+        Name[] names = invokeArguments(nameCursor - ARG_LIMIT, basicType);
 
         BoundMethodHandle.SpeciesData data = BoundMethodHandle.speciesData_LLLLL();
         names[THIS_MH]          = names[THIS_MH].withConstraint(data);
@@ -919,7 +916,7 @@ abstract class MethodHandleImpl {
         Object[] unboxArgs  = new Object[] {names[GET_UNBOX_RESULT], names[TRY_CATCH]};
         names[UNBOX_RESULT] = new Name(invokeBasicUnbox, unboxArgs);
 
-        lform = LambdaForm.create(lambdaType.parameterCount(), names, Kind.GUARD_WITH_CATCH);
+        lform = LambdaForm.create(basicType.parameterCount() + 1, names, Kind.GUARD_WITH_CATCH);
 
         return basicType.form().setCachedLambdaForm(MethodTypeForm.LF_GWC, lform);
     }
@@ -1738,8 +1735,6 @@ abstract class MethodHandleImpl {
      * bytecode generation}.
      */
     private static LambdaForm makeLoopForm(MethodType basicType, BasicType[] localVarTypes) {
-        MethodType lambdaType = basicType.invokerType();
-
         final int THIS_MH = 0;  // the BMH_LLL
         final int ARG_BASE = 1; // start of incoming arguments
         final int ARG_LIMIT = ARG_BASE + basicType.parameterCount();
@@ -1754,7 +1749,7 @@ abstract class MethodHandleImpl {
 
         LambdaForm lform = basicType.form().cachedLambdaForm(MethodTypeForm.LF_LOOP);
         if (lform == null) {
-            Name[] names = arguments(nameCursor - ARG_LIMIT, lambdaType);
+            Name[] names = invokeArguments(nameCursor - ARG_LIMIT, basicType);
 
             BoundMethodHandle.SpeciesData data = BoundMethodHandle.speciesData_LLL();
             names[THIS_MH] = names[THIS_MH].withConstraint(data);
@@ -1782,7 +1777,7 @@ abstract class MethodHandleImpl {
             names[UNBOX_RESULT] = new Name(invokeBasicUnbox, unboxArgs);
 
             lform = basicType.form().setCachedLambdaForm(MethodTypeForm.LF_LOOP,
-                    LambdaForm.create(lambdaType.parameterCount(), names, Kind.LOOP));
+                    LambdaForm.create(basicType.parameterCount() + 1, names, Kind.LOOP));
         }
 
         // BOXED_ARGS is the index into the names array where the loop idiom starts
@@ -1971,8 +1966,6 @@ abstract class MethodHandleImpl {
      * forms among tryFinally combinators with the same basic type.
      */
     private static LambdaForm makeTryFinallyForm(MethodType basicType) {
-        MethodType lambdaType = basicType.invokerType();
-
         LambdaForm lform = basicType.form().cachedLambdaForm(MethodTypeForm.LF_TF);
         if (lform != null) {
             return lform;
@@ -1990,7 +1983,7 @@ abstract class MethodHandleImpl {
         final int TRY_FINALLY      = nameCursor++;
         final int UNBOX_RESULT     = nameCursor++;
 
-        Name[] names = arguments(nameCursor - ARG_LIMIT, lambdaType);
+        Name[] names = invokeArguments(nameCursor - ARG_LIMIT, basicType);
 
         BoundMethodHandle.SpeciesData data = BoundMethodHandle.speciesData_LLLL();
         names[THIS_MH]          = names[THIS_MH].withConstraint(data);
@@ -2016,7 +2009,7 @@ abstract class MethodHandleImpl {
         Object[] unboxArgs  = new Object[] {names[GET_UNBOX_RESULT], names[TRY_FINALLY]};
         names[UNBOX_RESULT] = new Name(invokeBasicUnbox, unboxArgs);
 
-        lform = LambdaForm.create(lambdaType.parameterCount(), names, Kind.TRY_FINALLY);
+        lform = LambdaForm.create(basicType.parameterCount() + 1, names, Kind.TRY_FINALLY);
 
         return basicType.form().setCachedLambdaForm(MethodTypeForm.LF_TF, lform);
     }
@@ -2060,7 +2053,6 @@ abstract class MethodHandleImpl {
     }
 
     private static LambdaForm makeCollectorForm(MethodType basicType, Class<?> arrayType) {
-        MethodType lambdaType = basicType.invokerType();
         int parameterCount = basicType.parameterCount();
 
         // Only share the lambda form for empty arrays and reference types.
@@ -2093,7 +2085,7 @@ abstract class MethodHandleImpl {
         final int STORE_ELEMENT_LIMIT = STORE_ELEMENT_BASE + parameterCount;
         nameCursor = STORE_ELEMENT_LIMIT;
 
-        Name[] names = arguments(nameCursor - ARG_LIMIT, lambdaType);
+        Name[] names = invokeArguments(nameCursor - ARG_LIMIT, basicType);
 
         BoundMethodHandle.SpeciesData data = BoundMethodHandle.speciesData_L();
         names[THIS_MH]          = names[THIS_MH].withConstraint(data);
@@ -2111,7 +2103,7 @@ abstract class MethodHandleImpl {
                     names[CALL_NEW_ARRAY], storeIndex, names[argCursor]);
         }
 
-        LambdaForm lform = LambdaForm.create(lambdaType.parameterCount(), names, CALL_NEW_ARRAY, Kind.COLLECTOR);
+        LambdaForm lform = LambdaForm.create(basicType.parameterCount() + 1, names, CALL_NEW_ARRAY, Kind.COLLECTOR);
         if (isSharedLambdaForm) {
             lform = basicType.form().setCachedLambdaForm(MethodTypeForm.LF_COLLECTOR, lform);
         }
@@ -2174,8 +2166,6 @@ abstract class MethodHandleImpl {
 
     private static LambdaForm makeTableSwitchForm(MethodType basicType, BoundMethodHandle.SpeciesData data,
                                                   int numCases) {
-        MethodType lambdaType = basicType.invokerType();
-
         // We need to cache based on the basic type X number of cases,
         // since the number of cases is used when generating bytecode.
         // This also means that we can't use the cache in MethodTypeForm,
@@ -2207,7 +2197,7 @@ abstract class MethodHandleImpl {
         final int FIELD_UNBOX_RESULT  = fieldCursor++;
         final int FIELD_CASES         = fieldCursor++;
 
-        Name[] names = arguments(nameCursor - ARG_LIMIT, lambdaType);
+        Name[] names = invokeArguments(nameCursor - ARG_LIMIT, basicType);
 
         names[THIS_MH] = names[THIS_MH].withConstraint(data);
         names[GET_DEFAULT_CASE] = new Name(data.getterFunction(FIELD_DEFAULT_CASE), names[THIS_MH]);
@@ -2236,7 +2226,7 @@ abstract class MethodHandleImpl {
             names[UNBOXED_RESULT] = new Name(invokeBasic, unboxArgs);
         }
 
-        lform = LambdaForm.create(lambdaType.parameterCount(), names, Kind.TABLE_SWITCH);
+        lform = LambdaForm.create(basicType.parameterCount() + 1, names, Kind.TABLE_SWITCH);
         LambdaForm prev = TableSwitchCacheKey.CACHE.putIfAbsent(key, lform);
         return prev != null ? prev : lform;
     }

src/java.base/share/classes/java/lang/invoke/NativeMethodHandle.java

@@ -108,7 +108,7 @@ import static java.lang.invoke.MethodHandleStatics.newInternalError;
         final int GET_NEP = nameCursor++;
         final int LINKER_CALL = nameCursor++;
 
-        LambdaForm.Name[] names = arguments(nameCursor - ARG_LIMIT, mtype.invokerType());
+        LambdaForm.Name[] names = invokeArguments(nameCursor - ARG_LIMIT, mtype);
         assert (names.length == nameCursor);
 
         names[GET_NEP] = new LambdaForm.Name(Lazy.NF_internalNativeEntryPoint, names[NMH_THIS]);

src/java.base/share/classes/sun/reflect/generics/factory/CoreReflectionFactory.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2024, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -106,7 +106,11 @@ public class CoreReflectionFactory implements GenericsFactory {
     }
 
     public TypeVariable<?> findTypeVariable(String name){
-        return getScope().lookup(name);
+        TypeVariable<?> variable = getScope().lookup(name);
+        if (variable == null) {
+            throw new TypeNotPresentException(name, null);
+        }
+        return variable;
     }
 
     public Type makeNamedType(String name){

src/java.desktop/share/classes/java/awt/color/ICC_ColorSpace.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2024, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -48,7 +48,7 @@ import sun.java2d.cmm.PCMM;
  * {@code ColorSpace} class. This representation of device independent and
  * device dependent color spaces is based on the International Color Consortium
  * Specification ICC.1:2001-12, File Format for Color Profiles (see
- * <a href="http://www.color.org">http://www.color.org</a>).
+ * <a href="https://www.color.org">https://www.color.org</a>).
  * <p>
  * Typically, a {@code Color} or {@code ColorModel} would be associated with an
  * ICC Profile which is either an input, display, or output profile (see the ICC

src/java.desktop/share/classes/java/awt/color/ICC_Profile.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2023, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2024, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -64,7 +64,7 @@ import sun.java2d.cmm.ProfileDeferralInfo;
  * A representation of color profile data for device independent and device
  * dependent color spaces based on the International Color Consortium
  * Specification ICC.1:2001-12, File Format for Color Profiles, (see
- * <a href="http://www.color.org"> http://www.color.org</a>).
+ * <a href="https://www.color.org"> https://www.color.org</a>).
  * <p>
  * An {@code ICC_ColorSpace} object can be constructed from an appropriate
  * {@code ICC_Profile}. Typically, an {@code ICC_ColorSpace} would be associated

src/java.desktop/share/classes/java/awt/image/ColorConvertOp.java

@@ -690,7 +690,7 @@ public class ColorConvertOp implements BufferedImageOp, RasterOp {
          * shall be set to zero. Thus, we are ignoring two most significant
          * bytes here.
          *
-         *  See http://www.color.org/ICC1v42_2006-05.pdf, section 7.2.15.
+         *  See https://www.color.org/ICC1v42_2006-05.pdf, section 7.2.15.
          */
         return ((header[index+2] & 0xff) <<  8) |
                 (header[index+3] & 0xff);

src/java.desktop/share/classes/javax/imageio/package-info.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000, 2017, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2000, 2024, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -101,7 +101,7 @@
  * <!-- WBMP plugin -->
  *   <tr>
  *     <th scope="row">
- *     <a href="http://www.wapforum.org/what/technical/SPEC-WAESpec-19990524.pdf">
+ *     <a href="https://www.wapforum.org/what/technical/SPEC-WAESpec-19990524.pdf">
  *     WBMP</a>
  *     <td>yes
  *     <td>yes

src/java.desktop/share/classes/javax/imageio/plugins/tiff/BaselineTIFFTagSet.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2005, 2018, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2005, 2024, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
@@ -1008,7 +1008,7 @@ public final class BaselineTIFFTagSet extends TIFFTagSet {
     /**
      * Constant specifying the "ICC Profile" tag.
      *
-     * @see <a href="http://www.color.org/ICC1V42.pdf">ICC Specification, section B.4: Embedding ICC profiles in TIFF files</a>
+     * @see <a href="https://www.color.org/ICC1V42.pdf">ICC Specification, section B.4: Embedding ICC profiles in TIFF files</a>
      */
     public static final int TAG_ICC_PROFILE = 34675;
 

src/java.desktop/share/classes/sun/java2d/vulkan/VKSurfaceData.java

@@ -75,9 +75,11 @@ public abstract class VKSurfaceData extends SurfaceData
     private static final String DESC_VK_TEXTURE = "VK Texture";
 
 
+    // We want non-premultiplied alpha to prevent precision loss, so use PixelConverter.Argb
+    // See also VKUtil_DecodeJavaColor.
     static final SurfaceType VKSurface =
             SurfaceType.Any.deriveSubType(DESC_VK_SURFACE,
-                    PixelConverter.ArgbPre.instance);
+                    PixelConverter.Argb.instance);
     static final SurfaceType VKSurfaceRTT =
             VKSurface.deriveSubType(DESC_VK_SURFACE_RTT);
     static final SurfaceType VKTexture =
@@ -110,6 +112,7 @@ public abstract class VKSurfaceData extends SurfaceData
         }
     }
 
+    // TODO Do we really want to have scale there? It is used by getDefaultScaleX/Y...
     protected int scale;
     protected int width;
     protected int height;

src/java.desktop/share/glsl/vulkan/blit.frag

@@ -1,9 +1,9 @@
 #version 450
 
-layout(binding = 0) uniform sampler2D texSampler;
-layout(location = 0) in vec2 fragTexCoord;
-layout(location = 0) out vec4 outColor;
+layout(binding = 0) uniform sampler2D u_TexSampler;
+layout(location = 0) in  vec2 in_TexCoord;
+layout(location = 0) out vec4 out_Color;
 
 void main() {
-    outColor = texture(texSampler, fragTexCoord);
+    out_Color = texture(u_TexSampler, in_TexCoord);
 }

src/java.desktop/share/glsl/vulkan/blit.vert

@@ -1,10 +1,10 @@
 #version 450
 
-layout(location = 0) in vec2 inPosition;
-layout(location = 1) in vec2 texPosition;
-layout(location = 0) out vec2 fragTexCoord;
+layout(location = 0) in  vec2 in_Position;
+layout(location = 1) in  vec2 in_TexCoord;
+layout(location = 0) out vec2 out_TexCoord;
 
 void main() {
-    gl_Position = vec4(inPosition, 0.0, 1.0);
-    fragTexCoord = texPosition;
+    gl_Position = vec4(in_Position, 0.0, 1.0);
+    out_TexCoord = in_TexCoord;
 }

src/java.desktop/share/glsl/vulkan/clip.vert

@@ -0,0 +1,11 @@
+#version 450
+
+layout(push_constant) uniform PushConstants {
+    vec2 viewportNormalizer; // 2.0 / viewport
+} push;
+
+layout(location = 0) in ivec2 in_Position;
+
+void main() {
+    gl_Position = vec4(vec2(in_Position) * push.viewportNormalizer - vec2(1.0), 0.0, 1.0);
+}

src/java.desktop/share/glsl/vulkan/color.frag

@@ -1,8 +1,8 @@
 #version 450
 
-layout(location = 0) in flat vec4 fragColor;
-layout(location = 0) out vec4 outColor;
+layout(location = 0) in flat vec4 in_Color;
+layout(location = 0) out vec4 out_Color;
 
 void main() {
-    outColor = fragColor;
+    out_Color = in_Color;
 }

src/java.desktop/share/glsl/vulkan/color.vert

@@ -1,13 +1,14 @@
 #version 450
 
 layout(push_constant) uniform PushConstants {
-    vec4 fragColor;
-} pushConstants;
+    vec2 viewportNormalizer; // 2.0 / viewport
+} push;
 
-layout(location = 0) in vec2 inPosition;
-layout(location = 0) out flat vec4 fragColor;
+layout(location = 0) in vec2 in_Position;
+layout(location = 1) in vec4 in_Color;
+layout(location = 0) out flat vec4 out_Color;
 
 void main() {
-    gl_Position = vec4(inPosition, 0.0, 1.0);
-    fragColor = pushConstants.fragColor;
+    gl_Position = vec4(in_Position * push.viewportNormalizer - vec2(1.0), 0.0, 1.0);
+    out_Color = in_Color;
 }

src/java.desktop/share/glsl/vulkan/mask_fill_color.frag

@@ -0,0 +1,18 @@
+#version 450
+
+layout(set = 0, binding = 0, r8) uniform readonly restrict imageBuffer u_Mask;
+
+layout(origin_upper_left) in vec4 gl_FragCoord;
+
+layout(location = 0) in flat ivec4 in_OriginOffsetAndScanline;
+layout(location = 1) in flat  vec4 in_Color;
+
+layout(location = 0) out vec4 out_Color;
+
+void main() {
+    ivec2 maskPos = ivec2(gl_FragCoord.xy) - in_OriginOffsetAndScanline.xy;
+    int offset = in_OriginOffsetAndScanline.z;
+    int scanline = in_OriginOffsetAndScanline.w;
+    int maskIndex = offset + scanline * maskPos.y + min(scanline, maskPos.x);
+    out_Color = in_Color * imageLoad(u_Mask, maskIndex).r;
+}

src/java.desktop/share/glsl/vulkan/mask_fill_color.vert

@@ -0,0 +1,20 @@
+#version 450
+
+layout(push_constant) uniform PushConstants {
+    vec2 viewportNormalizer; // 2.0 / viewport
+} push;
+
+layout(location = 0) in ivec4 in_PositionOffsetAndScanline;
+layout(location = 1) in  vec4 in_Color;
+
+// This starts with "Origin" and not "Position" intentionally.
+// When drawing, vertices are ordered in a such way, that provoking vertex is always the top-left one.
+// This gives us an easy way to calculate offset within the rectangle without additional inputs.
+layout(location = 0) out flat ivec4 out_OriginOffsetAndScanline;
+layout(location = 1) out flat  vec4 out_Color;
+
+void main() {
+    gl_Position = vec4(vec2(in_PositionOffsetAndScanline.xy) * push.viewportNormalizer - vec2(1.0), 0.0, 1.0);
+    out_OriginOffsetAndScanline = in_PositionOffsetAndScanline;
+    out_Color = in_Color;
+}

src/java.desktop/share/native/common/java2d/vulkan/CArrayUtil.h

@@ -186,46 +186,59 @@ void* CARR_ring_buffer_realloc(CARR_ring_buffer_t* buf, size_t elem_size, size_t
  */
 #define RING_BUFFER_CAPACITY(P) ((P) == NULL ? (size_t) 0 : RING_BUFFER_T(P)->capacity)
 
+/**
+ * Add element to the beginning of the ring buffer. Implicitly initializes when buffer is NULL.
+ * On allocation failure, C_ARRAY_UTIL_ALLOCATION_FAILED is called.
+ * @param P pointer to the first data element of the buffer
+ */
+#define RING_BUFFER_PUSH_FRONT(P, ...) do {                                                                                    \
+    if ((P) == NULL) (P) = CARR_ring_buffer_realloc(NULL, sizeof((P)[0]), ARRAY_DEFAULT_CAPACITY);                             \
+    else if ((RING_BUFFER_T(P)->head + RING_BUFFER_T(P)->capacity - 1) % RING_BUFFER_T(P)->capacity == RING_BUFFER_T(P)->tail) \
+        (P) = CARR_ring_buffer_realloc(RING_BUFFER_T(P), sizeof((P)[0]), ARRAY_CAPACITY_GROW(RING_BUFFER_T(P)->capacity));     \
+    if ((P) == NULL) C_ARRAY_UTIL_ALLOCATION_FAILED();                                                                         \
+    RING_BUFFER_T(P)->head = (RING_BUFFER_T(P)->head + RING_BUFFER_T(P)->capacity - 1) % RING_BUFFER_T(P)->capacity;           \
+    (P)[RING_BUFFER_T(P)->head] = (__VA_ARGS__);                                                                               \
+} while(0)
+
 /**
  * Add element to the end of the ring buffer. Implicitly initializes when buffer is NULL.
  * On allocation failure, C_ARRAY_UTIL_ALLOCATION_FAILED is called.
  * @param P pointer to the first data element of the buffer
  */
-#define RING_BUFFER_PUSH(P, ...) RING_BUFFER_PUSH_CUSTOM(P, (P)[tail] = (__VA_ARGS__);)
-#define RING_BUFFER_PUSH_CUSTOM(P, ...) do {                                                                                 \
-    size_t head, tail, new_tail;                                                                                             \
-    if ((P) == NULL) {                                                                                                       \
-        (P) = CARR_ring_buffer_realloc(NULL, sizeof((P)[0]), ARRAY_DEFAULT_CAPACITY);                                        \
-        if ((P) == NULL) C_ARRAY_UTIL_ALLOCATION_FAILED();                                                                   \
-        head = tail = 0;                                                                                                     \
-        new_tail = 1;                                                                                                        \
-    } else {                                                                                                                 \
-        head = RING_BUFFER_T(P)->head;                                                                                       \
-        tail = RING_BUFFER_T(P)->tail;                                                                                       \
-        new_tail = (tail + 1) % RING_BUFFER_T(P)->capacity;                                                                  \
-        if (new_tail == head) {                                                                                              \
-            (P) = CARR_ring_buffer_realloc(RING_BUFFER_T(P), sizeof(P[0]), ARRAY_CAPACITY_GROW(RING_BUFFER_T(P)->capacity)); \
-            if ((P) == NULL) C_ARRAY_UTIL_ALLOCATION_FAILED();                                                               \
-            head = 0;                                                                                                        \
-            tail = RING_BUFFER_T(P)->tail;                                                                                   \
-            new_tail = RING_BUFFER_T(P)->tail + 1;                                                                           \
-        }                                                                                                                    \
-    }                                                                                                                        \
-    __VA_ARGS__                                                                                                              \
-    RING_BUFFER_T(P)->tail = new_tail;                                                                                       \
+#define RING_BUFFER_PUSH_BACK(P, ...) do {                                                                                 \
+    if ((P) == NULL) (P) = CARR_ring_buffer_realloc(NULL, sizeof((P)[0]), ARRAY_DEFAULT_CAPACITY);                         \
+    else if ((RING_BUFFER_T(P)->tail + 1) % RING_BUFFER_T(P)->capacity == RING_BUFFER_T(P)->head)                          \
+        (P) = CARR_ring_buffer_realloc(RING_BUFFER_T(P), sizeof((P)[0]), ARRAY_CAPACITY_GROW(RING_BUFFER_T(P)->capacity)); \
+    if ((P) == NULL) C_ARRAY_UTIL_ALLOCATION_FAILED();                                                                     \
+    (P)[RING_BUFFER_T(P)->tail] = (__VA_ARGS__);                                                                           \
+    RING_BUFFER_T(P)->tail = (RING_BUFFER_T(P)->tail + 1) % RING_BUFFER_T(P)->capacity;                                    \
 } while(0)
 
 /**
  * Get pointer to the first element of the ring buffer.
  * @param P pointer to the first data element of the buffer
  */
-#define RING_BUFFER_PEEK(P) ((P) == NULL || RING_BUFFER_T(P)->head == RING_BUFFER_T(P)->tail ? NULL : &(P)[RING_BUFFER_T(P)->head])
+#define RING_BUFFER_FRONT(P) ((P) == NULL || RING_BUFFER_T(P)->head == RING_BUFFER_T(P)->tail ? NULL : &(P)[RING_BUFFER_T(P)->head])
+
+/**
+ * Get pointer to the last element of the ring buffer.
+ * @param P pointer to the first data element of the buffer
+ */
+#define RING_BUFFER_BACK(P) ((P) == NULL || RING_BUFFER_T(P)->head == RING_BUFFER_T(P)->tail ? NULL : \
+    &(P)[(RING_BUFFER_T(P)->tail + RING_BUFFER_T(P)->capacity - 1) % RING_BUFFER_T(P)->capacity])
 
 /**
  * Move beginning of the ring buffer forward (remove first element).
  * @param P pointer to the first data element of the buffer
  */
-#define RING_BUFFER_POP(P) RING_BUFFER_T(P)->head = (RING_BUFFER_T(P)->head + 1) % RING_BUFFER_T(P)->capacity
+#define RING_BUFFER_POP_FRONT(P) RING_BUFFER_T(P)->head = (RING_BUFFER_T(P)->head + 1) % RING_BUFFER_T(P)->capacity
+
+/**
+ * Move end of the ring buffer backward (remove last element).
+ * @param P pointer to the first data element of the buffer
+ */
+#define RING_BUFFER_POP_BACK(P) \
+    RING_BUFFER_T(P)->tail = (RING_BUFFER_T(P)->tail + RING_BUFFER_T(P)->capacity - 1) % RING_BUFFER_T(P)->capacity
 
 /**
  * Deallocate the ring buffer

src/java.desktop/share/native/common/java2d/vulkan/VKAllocator.c

@@ -0,0 +1,609 @@
+// Copyright 2024 JetBrains s.r.o.
+// DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+//
+// This code is free software; you can redistribute it and/or modify it
+// under the terms of the GNU General Public License version 2 only, as
+// published by the Free Software Foundation.  Oracle designates this
+// particular file as subject to the "Classpath" exception as provided
+// by Oracle in the LICENSE file that accompanied this code.
+//
+// This code is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+// version 2 for more details (a copy is included in the LICENSE file that
+// accompanied this code).
+//
+// You should have received a copy of the GNU General Public License version
+// 2 along with this work; if not, write to the Free Software Foundation,
+// Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+// or visit www.oracle.com if you need additional information or have any
+// questions.
+
+#include <assert.h>
+#include "VKUtil.h"
+#include "VKBase.h"
+#include "VKAllocator.h"
+
+/**
+ * Block size is a minimum allocation size.
+ * Using block size of 256 bytes gives us 256*2^21 = 512MiB addressable space per shared page
+ * (read further for explanations). Such block size is less than typical alignment,
+ * so there is no point in decreasing block size further to decrease possible fragmentation.
+ */
+#define BLOCK_POWER 8U
+#define BLOCK_SIZE (1ULL<<BLOCK_POWER)
+
+/**
+ * Starting page level for small allocations.
+ * With block size of 256 bytes and page level of 12, smallest pages will be 1MiB in size.
+ */
+#define MIN_SHARED_PAGE_LEVEL 12
+
+/**
+ * Pair of memory blocks - "buddies".
+ * We want to keep bookkeeping footprint low, so single BlockPair should fit into 64 bits.
+ * This implies the following limits:
+ * - Max number of bottom-level blocks in a page (flat)         = 2^21
+ * - Max number of bottom-level block pairs in a page (flat)    = 2^20
+ * - Max number of all block pair nodes in a page (binary tree) = 2^21-1
+ */
+typedef struct {
+    uint64_t offset     : 20; // Memory offset in block pairs from the beginning of the page.
+    uint64_t parent     : 21; // Parent BlockPair index starting from 1, or 0 if none.
+    uint64_t nextFree   : 21; // Index of the next free BlockPair of the same level starting from 1, or 0 if none.
+    uint64_t firstFree  :  1; // Whether first block is free.
+    uint64_t secondFree :  1; // Whether second block is free.
+} BlockPair;
+
+/**
+ * Memory handle passed outside of allocator, we also need it to fit into 64 bits.
+ * Memory offset and BlockPair indices are both fixed to 21 bits (see BlockPair).
+ * We use 5 bits for block level, as this gives us full range over available offsets [0, 2^21-1].
+ * Special block level value of 31 means that its size covers the entire page, and may not be power of two.
+ * Note, however, that 21 bits for offset is not enough to cover whole range of levels [0, 30],
+ * therefore maximum size of shared pages will be bounded by available offset range (2^21 blocks).
+ * This leaves us with 17 bits, which we use for page index, there is no any special reason for this,
+ * we just use what's left. This naturally limits total possible number of allocated pages to 2^17.
+ */
+typedef union MemoryHandle {
+    uint64_t value;
+    struct {
+        uint64_t page   : 17; // Page index.
+        uint64_t offset : 21; // Memory offset in blocks from the beginning of the page.
+        uint64_t level  :  5; // Block level = log2(size), or 31 if size is not power of two.
+        uint64_t pair   : 21; // BlockPair index starting from 1, or 0 if none.
+    };
+} MemoryHandle;
+
+// Define limits discussed earlier.
+#define MAX_PAGES (1ULL << 17)
+// These are hard constants and not meant to be adjusted:
+#define MAX_BLOCK_LEVEL (21U)
+#define MAX_SHARED_PAGE_SIZE ((1ULL << MAX_BLOCK_LEVEL) * BLOCK_SIZE)
+
+typedef struct {
+    BlockPair* blockPairs;
+    void*      mappedData;
+    uint32_t   freeLevelIndices[MAX_BLOCK_LEVEL+1]; // Indices start from 1
+    uint32_t   freeBlockPairIndex;                  // Indices start from 1
+    uint32_t   nextPageIndex;
+    uint32_t   memoryType;
+} SharedPageData;
+
+typedef struct {
+    VkDeviceMemory memory;
+    union {
+        VkDeviceSize    dedicatedSize;  // If this is a dedicated page.
+        SharedPageData* sharedPageData; // If this is a shared page.
+        uint32_t        nextFreePage;   // If this struct is unused.
+    };
+#ifdef DEBUG
+    VkDeviceSize debugPageSize;
+    uint32_t debugMemoryType;
+#endif
+} Page;
+
+typedef struct {
+    uint32_t sharedPagesIndex;
+    uint32_t allocationLevelTracker; // Used to manage page growth. Each new page size = (allocationLevelTracker++) / 2
+#ifdef DEBUG
+    VkDeviceSize debugTotalPagesSize;
+#endif
+} Pool;
+
+struct VKAllocator {
+    VKDevice* device;
+    VkPhysicalDeviceMemoryProperties memoryProperties;
+
+    Page*    pages;
+    uint32_t freePageIndex;
+    Pool     pools[VK_MAX_MEMORY_TYPES];
+};
+
+#define NO_PAGE_INDEX (~0U)
+
+VKMemoryRequirements VKAllocator_NoRequirements(VKAllocator* allocator) {
+    return (VKMemoryRequirements) {
+        .allocator = allocator,
+        .dedicatedRequirements.sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS,
+        .requirements.sType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,
+        .requirements.memoryRequirements = {
+                .size = 0,
+                .alignment = 1,
+                .memoryTypeBits = VK_NO_MEMORY_TYPE
+        },
+        .memoryType = VK_NO_MEMORY_TYPE
+    };
+}
+VKMemoryRequirements VKAllocator_BufferRequirements(VKAllocator* allocator, VkBuffer buffer) {
+    assert(allocator != NULL);
+    VKMemoryRequirements r = VKAllocator_NoRequirements(allocator);
+    r.requirements.pNext = &r.dedicatedRequirements;
+    const VkBufferMemoryRequirementsInfo2 bufferRequirementsInfo = {
+            .sType = VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2,
+            .buffer = buffer
+    };
+    allocator->device->vkGetBufferMemoryRequirements2(allocator->device->handle, &bufferRequirementsInfo, &r.requirements);
+    return r;
+}
+VKMemoryRequirements VKAllocator_ImageRequirements(VKAllocator* allocator, VkImage image) {
+    assert(allocator != NULL);
+    VKMemoryRequirements r = VKAllocator_NoRequirements(allocator);
+    r.requirements.pNext = &r.dedicatedRequirements;
+    const VkImageMemoryRequirementsInfo2 imageRequirementsInfo = {
+            .sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2,
+            .image = image
+    };
+    allocator->device->vkGetImageMemoryRequirements2(allocator->device->handle, &imageRequirementsInfo, &r.requirements);
+    return r;
+}
+
+void VKAllocator_PadToAlignment(VKMemoryRequirements* requirements) {
+    assert(requirements != NULL);
+    VkMemoryRequirements* t = &requirements->requirements.memoryRequirements;
+    t->size = ((t->size + t->alignment - 1) / t->alignment) * t->alignment;
+    requirements->dedicatedRequirements.requiresDedicatedAllocation = VK_FALSE;
+    requirements->dedicatedRequirements.prefersDedicatedAllocation = VK_FALSE;
+}
+
+void VKAllocator_FindMemoryType(VKMemoryRequirements* requirements,
+                                VkMemoryPropertyFlags requiredProperties, VkMemoryPropertyFlags allowedProperties) {
+    if (requirements->memoryType != VK_NO_MEMORY_TYPE) return;
+    // TODO also skip heaps with insufficient memory?
+    allowedProperties |= requiredProperties;
+    for (uint32_t i = 0; i < requirements->allocator->memoryProperties.memoryTypeCount; i++) {
+        if ((requirements->requirements.memoryRequirements.memoryTypeBits & (1 << i)) == 0) continue;
+        VkMemoryPropertyFlags flags = requirements->allocator->memoryProperties.memoryTypes[i].propertyFlags;
+        if ((flags & requiredProperties) == requiredProperties && (flags & allowedProperties) == flags) {
+            requirements->memoryType = i;
+            return;
+        }
+    }
+}
+
+static uint32_t VKAllocator_AllocatePage(VKAllocator* alloc, uint32_t memoryType, VkDeviceSize size,
+                                         VkImage dedicatedImage, VkBuffer dedicatedBuffer) {
+    assert(alloc != NULL);
+
+    // Allocate memory.
+    VkBool32 dedicated = dedicatedImage != VK_NULL_HANDLE || dedicatedBuffer != VK_NULL_HANDLE;
+    VKDevice* device = alloc->device;
+    VkMemoryDedicatedAllocateInfo dedicatedAllocateInfo = {
+            .sType = VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
+            .image = dedicatedImage,
+            .buffer = dedicatedBuffer
+    };
+    VkMemoryAllocateInfo allocateInfo = {
+            .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
+            .pNext = dedicated ? &dedicatedAllocateInfo : NULL,
+            .allocationSize = size,
+            .memoryTypeIndex = memoryType
+    };
+    VkDeviceMemory memory;
+    VK_IF_ERROR(device->vkAllocateMemory(device->handle, &allocateInfo, NULL, &memory)) {
+        J2dRlsTraceLn3(J2D_TRACE_ERROR, "VKAllocator_AllocatePage: FAILED memoryType=%d, size=%d, dedicated=%d", memoryType, size, dedicated);
+        return NO_PAGE_INDEX;
+    }
+
+    // Allocate page struct.
+    uint32_t index;
+    Page* page;
+    if (alloc->freePageIndex != NO_PAGE_INDEX) {
+        index = alloc->freePageIndex;
+        page = &alloc->pages[index];
+        alloc->freePageIndex = page->nextFreePage;
+    } else {
+        index = ARRAY_SIZE(alloc->pages);
+        VK_RUNTIME_ASSERT(index < MAX_PAGES);
+        ARRAY_PUSH_BACK(alloc->pages, (Page) {});
+        page = &ARRAY_LAST(alloc->pages);
+    }
+    assert(page->memory == VK_NULL_HANDLE);
+    *page = (Page) { .memory = memory };
+
+    J2dRlsTraceLn4(J2D_TRACE_INFO, "VKAllocator_AllocatePage: #%d memoryType=%d, size=%d, dedicated=%d", index, memoryType, size, dedicated);
+#ifdef DEBUG
+    page->debugPageSize = size;
+    page->debugMemoryType = memoryType;
+    alloc->pools[memoryType].debugTotalPagesSize += size;
+    J2dTraceLn2(J2D_TRACE_INFO, "VKAllocator_AllocatePage: memoryType=%d, debugTotalPagesSize=%d", memoryType, alloc->pools[memoryType].debugTotalPagesSize);
+#endif
+    return index;
+}
+
+static void VKAllocator_FreePage(VKAllocator* alloc, Page* page, uint32_t pageIndex) {
+    assert(alloc != NULL);
+    VKDevice* device = alloc->device;
+    device->vkFreeMemory(device->handle, page->memory, NULL);
+    page->memory = VK_NULL_HANDLE;
+    page->nextFreePage = alloc->freePageIndex;
+    alloc->freePageIndex = pageIndex;
+    J2dRlsTraceLn1(J2D_TRACE_INFO, "VKAllocator_FreePage: #%d", pageIndex);
+#ifdef DEBUG
+    alloc->pools[page->debugMemoryType].debugTotalPagesSize -= page->debugPageSize;
+    J2dTraceLn2(J2D_TRACE_INFO, "VKAllocator_FreePage: memoryType=%d, debugTotalPagesSize=%d",
+                page->debugMemoryType, alloc->pools[page->debugMemoryType].debugTotalPagesSize);
+#endif
+}
+
+/**
+ * Pop free block pair of the specified level from the free list.
+ * Subdivides upper level blocks if there are no existing matching blocks.
+ */
+static uint32_t VKAllocator_PopFreeBlockPair(SharedPageData* data, uint32_t level) {
+    assert(data != NULL && level <= MAX_BLOCK_LEVEL);
+    uint32_t pairIndex = data->freeLevelIndices[level];
+    if (pairIndex != 0) {
+        // Pop existing free block pair.
+        BlockPair pair = data->blockPairs[pairIndex-1];
+        assert(pair.firstFree ^ pair.secondFree); // Only one must be free.
+        data->freeLevelIndices[level] = pair.nextFree;
+        return pairIndex;
+    } else if (level < MAX_BLOCK_LEVEL && (pairIndex = VKAllocator_PopFreeBlockPair(data, level+1)) != 0) {
+        // Allocate block pair struct.
+        uint32_t parentIndex = pairIndex;
+        BlockPair* pair;
+        if (data->freeBlockPairIndex != 0) {
+            pairIndex = data->freeBlockPairIndex;
+            pair = &data->blockPairs[pairIndex-1];
+            data->freeBlockPairIndex = pair->nextFree;
+        } else {
+            ARRAY_PUSH_BACK(data->blockPairs, (BlockPair) {});
+            pairIndex = ARRAY_SIZE(data->blockPairs);
+            pair = &data->blockPairs[pairIndex-1];
+        }
+        // Subdivide parent block.
+        BlockPair* parent = &data->blockPairs[parentIndex-1];
+        assert(parent->firstFree || parent->secondFree);
+        *pair = (BlockPair) {
+                .offset     = parent->offset,
+                .parent     = parentIndex,
+                .nextFree   = 0,
+                .firstFree  = 1,
+                .secondFree = 1,
+        };
+        if (!parent->firstFree) {
+            pair->offset |= 1ULL << level;
+            parent->secondFree = 0;
+        } else parent->firstFree = 0;
+        data->freeLevelIndices[level] = pairIndex;
+        return pairIndex;
+    } else return 0;
+}
+
+/**
+ * Push free block pair of the specified level to the free list.
+ * Merges into upper level blocks if there are free buddies.
+ * Returns VK_TRUE, if page was completely freed.
+ */
+static VkBool32 VKAllocator_PushFreeBlockPair(SharedPageData* data, BlockPair* pair, uint32_t pairIndex, uint32_t level) {
+    assert(data != NULL && level <= MAX_BLOCK_LEVEL);
+    assert(pair->firstFree || pair->secondFree);
+    if (pair->firstFree && pair->secondFree) {
+        // Merge.
+        uint32_t parentIndex = pair->parent;
+        assert(parentIndex != 0);
+        BlockPair* parent = &data->blockPairs[parentIndex-1];
+        if (pair->offset == parent->offset) {
+            assert(!parent->firstFree);
+            parent->firstFree = 1;
+        } else {
+            assert(!parent->secondFree);
+            parent->secondFree = 1;
+        }
+        // Remove from free list.
+        if (data->freeLevelIndices[level] == pairIndex) {
+            data->freeLevelIndices[level] = pair->nextFree;
+        } else {
+            assert(data->freeLevelIndices[level] != 0);
+            BlockPair* b = &data->blockPairs[data->freeLevelIndices[level]-1];
+            for (;;) {
+                if (b->nextFree == pairIndex) {
+                    b->nextFree = pair->nextFree;
+                    break;
+                }
+                assert(b->nextFree != 0);
+                b = &data->blockPairs[b->nextFree-1];
+            }
+        }
+        // Return block pair struct to pool.
+        pair->nextFree = data->freeBlockPairIndex;
+        data->freeBlockPairIndex = pairIndex;
+        return VKAllocator_PushFreeBlockPair(data, parent, parentIndex, level+1);
+    } else {
+        pair->nextFree = data->freeLevelIndices[level];
+        data->freeLevelIndices[level] = pairIndex;
+        return pair->parent == 0;
+    }
+}
+
+typedef struct {
+    MemoryHandle handle;
+    VkDeviceMemory memory;
+} AllocationResult;
+
+/**
+ * Provided image or buffer may be used for dedicated allocation.
+ */
+static AllocationResult VKAllocator_AllocateForResource(VKMemoryRequirements* requirements, VkImage image, VkBuffer buffer) {
+    assert(requirements != NULL && requirements->allocator != NULL);
+    VKAllocator* alloc      = requirements->allocator;
+    uint32_t     memoryType = requirements->memoryType;
+    VkDeviceSize size       = requirements->requirements.memoryRequirements.size;
+    VkDeviceSize alignment  = requirements->requirements.memoryRequirements.alignment;
+    VkBool32     dedicated  = requirements->dedicatedRequirements.requiresDedicatedAllocation ||
+                              requirements->dedicatedRequirements.prefersDedicatedAllocation;
+    assert(memoryType != VK_NO_MEMORY_TYPE);
+    assert(size > 0);
+    assert(alignment > 0 && (alignment & (alignment - 1)) == 0); // Alignment must be power of 2.
+
+    uint32_t level = size <= BLOCK_SIZE ? 0 : VKUtil_Log2(size - 1) + 1 - BLOCK_POWER;
+    uint32_t blockSize = BLOCK_SIZE << level;
+    // Adjust level to ensure proper alignment. Not very optimal, but this is a very rare case.
+    while (blockSize % alignment != 0) { level++; blockSize <<= 1; }
+
+    J2dRlsTraceLn6(J2D_TRACE_VERBOSE,
+                   "VKAllocator_Allocate: level=%d, blockSize=%d, size=%d, alignment=%d, memoryType=%d, dedicated=%d",
+                   level, blockSize, size, alignment, memoryType, dedicated);
+
+    if (!dedicated && level <= MAX_BLOCK_LEVEL) {
+        // Try to sub-allocate.
+        AllocationResult result = { .handle.value = 0 };
+        result.handle.level = level;
+        Pool* pool = &alloc->pools[memoryType];
+        uint32_t pageIndex = pool->sharedPagesIndex;
+        // Try to find block in existing pages.
+        Page* page;
+        SharedPageData* data;
+        uint32_t pairIndex;
+        while (pageIndex != NO_PAGE_INDEX) {
+            page = &alloc->pages[pageIndex];
+            data = page->sharedPageData;
+            pairIndex = VKAllocator_PopFreeBlockPair(data, level);
+            if (pairIndex != 0) break;
+            pageIndex = data->nextPageIndex;
+        }
+        // Allocate new page.
+        if (pageIndex == NO_PAGE_INDEX) {
+            uint32_t pageLevel = (pool->allocationLevelTracker++) / 2;
+            if (pageLevel < level) pool->allocationLevelTracker = (pageLevel = level) * 2 + 1;
+            else if (pageLevel > MAX_BLOCK_LEVEL) pool->allocationLevelTracker = (pageLevel = MAX_BLOCK_LEVEL) * 2 + 1;
+            pageIndex = VKAllocator_AllocatePage(alloc, memoryType, BLOCK_SIZE << pageLevel, VK_NULL_HANDLE, VK_NULL_HANDLE);
+            if (pageIndex == NO_PAGE_INDEX) return (AllocationResult) {{0}, VK_NULL_HANDLE};
+            page = &alloc->pages[pageIndex];
+            data = page->sharedPageData = (SharedPageData*) calloc(1, sizeof(SharedPageData));
+            VK_RUNTIME_ASSERT(page->sharedPageData);
+            data->memoryType = memoryType;
+            ARRAY_PUSH_BACK(data->blockPairs, (BlockPair) {
+                    .offset     = 0,
+                    .parent     = 0,
+                    .nextFree   = 0,
+                    .firstFree  = 1,
+                    .secondFree = 0,
+            });
+            data->freeLevelIndices[pageLevel] = 1;
+            data->nextPageIndex = pool->sharedPagesIndex;
+            pool->sharedPagesIndex = pageIndex;
+            pairIndex = VKAllocator_PopFreeBlockPair(data, level);
+            assert(pairIndex != 0);
+        }
+        // Take the block.
+        BlockPair* pair = &data->blockPairs[pairIndex-1];
+        result.handle.page = pageIndex;
+        result.handle.pair = pairIndex;
+        // No need to check alignment, all blocks are aligned on their size.
+        if (pair->firstFree) {
+            result.handle.offset = (pair->offset << 1U);
+            pair->firstFree = 0;
+        } else {
+            result.handle.offset = (pair->offset << 1U) + (1ULL << level);
+            pair->secondFree = 0;
+        }
+        result.memory = page->memory;
+        return result;
+    } else {
+        // Dedicated allocation.
+        uint32_t pageIndex = VKAllocator_AllocatePage(alloc, memoryType, size, image, buffer);
+        if (pageIndex == NO_PAGE_INDEX) return (AllocationResult) {{0}, VK_NULL_HANDLE};
+        Page* page = &alloc->pages[pageIndex];
+        page->dedicatedSize = size;
+        return (AllocationResult) {
+                .handle = {
+                        .page =   pageIndex,
+                        .offset = 0,
+                        .level =  31, // Special value, same meaning as VK_WHOLE_SIZE
+                        .pair =   0
+                },
+                .memory = page->memory
+        };
+    }
+}
+
+VKMemory VKAllocator_Allocate(VKMemoryRequirements* requirements) {
+    return (VKMemory) VKAllocator_AllocateForResource(requirements, VK_NULL_HANDLE, VK_NULL_HANDLE).handle.value;
+}
+VKMemory VKAllocator_AllocateForImage(VKMemoryRequirements* requirements, VkImage image) {
+    AllocationResult result = VKAllocator_AllocateForResource(requirements, image, VK_NULL_HANDLE);
+    if (result.handle.value == 0) return VK_NULL_HANDLE;
+    assert(result.memory != VK_NULL_HANDLE);
+    VKDevice* device = requirements->allocator->device;
+    VK_IF_ERROR(device->vkBindImageMemory(device->handle, image, result.memory, result.handle.offset << BLOCK_POWER)) {
+        VKAllocator_Free(requirements->allocator, (VKMemory) result.handle.value);
+        return VK_NULL_HANDLE;
+    }
+    return (VKMemory) result.handle.value;
+}
+VKMemory VKAllocator_AllocateForBuffer(VKMemoryRequirements* requirements, VkBuffer buffer) {
+    AllocationResult result = VKAllocator_AllocateForResource(requirements, VK_NULL_HANDLE, buffer);
+    if (result.handle.value == 0) return VK_NULL_HANDLE;
+    assert(result.memory != VK_NULL_HANDLE);
+    VKDevice* device = requirements->allocator->device;
+    VK_IF_ERROR(device->vkBindBufferMemory(device->handle, buffer, result.memory, result.handle.offset << BLOCK_POWER)) {
+        VKAllocator_Free(requirements->allocator, (VKMemory) result.handle.value);
+        return VK_NULL_HANDLE;
+    }
+    return (VKMemory) result.handle.value;
+}
+
+void VKAllocator_Free(VKAllocator* allocator, VKMemory memory) {
+    assert(allocator != NULL);
+    if (memory == VK_NULL_HANDLE) return;
+    MemoryHandle handle = { .value = (uint64_t) memory };
+    Page* page = &allocator->pages[handle.page];
+    if (handle.pair != 0) {
+        // Return block into shared page.
+        SharedPageData* data = page->sharedPageData;
+        BlockPair* pair = &data->blockPairs[handle.pair-1];
+        if ((pair->offset << 1U) == handle.offset) pair->firstFree = 1;
+        else pair->secondFree = 1;
+        VkBool32 cleared = VKAllocator_PushFreeBlockPair(data, pair, handle.pair, handle.level);
+        J2dRlsTraceLn3(J2D_TRACE_VERBOSE,
+                       "VKAllocator_Free: shared, level=%d, blockSize=%d, memoryType=%d",
+                       handle.level, BLOCK_SIZE << handle.level, data->memoryType);
+        // If page is empty and not the last created, release it.
+        if (cleared) {
+            Pool* pool = &allocator->pools[data->memoryType];
+            if (pool->sharedPagesIndex != handle.page) {
+                assert(pool->sharedPagesIndex != NO_PAGE_INDEX);
+                Page* p = &allocator->pages[pool->sharedPagesIndex];
+                for (;;) {
+                    if (p->sharedPageData->nextPageIndex == handle.page) {
+                        p->sharedPageData->nextPageIndex = data->nextPageIndex;
+                        break;
+                    }
+                    assert(p->sharedPageData->nextPageIndex != 0);
+                    p = &allocator->pages[p->sharedPageData->nextPageIndex];
+                }
+                VKAllocator_FreePage(allocator, page, handle.page);
+                free(data);
+            }
+        }
+    } else {
+        // Release dedicated allocation.
+        J2dRlsTraceLn2(J2D_TRACE_VERBOSE, "VKAllocator_Free: dedicated, level=%d, blockSize=%d", handle.level, BLOCK_SIZE << handle.level);
+        VKAllocator_FreePage(allocator, page, handle.page);
+    }
+}
+
+VkMappedMemoryRange VKAllocator_GetMemoryRange(VKAllocator* allocator, VKMemory memory) {
+    assert(allocator != NULL && memory != VK_NULL_HANDLE);
+    MemoryHandle handle = { .value = (uint64_t) memory };
+    return (VkMappedMemoryRange) {
+            .sType  = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,
+            .memory = allocator->pages[handle.page].memory,
+            .offset = handle.offset * BLOCK_SIZE,
+            .size   = handle.level == 31 ? VK_WHOLE_SIZE : BLOCK_SIZE << handle.level
+    };
+}
+void* VKAllocator_Map(VKAllocator* allocator, VKMemory memory) {
+    assert(allocator != NULL && memory != VK_NULL_HANDLE);
+    MemoryHandle handle = { .value = (uint64_t) memory };
+    Page* page = &allocator->pages[handle.page];
+    void *p;
+    if (handle.pair != 0) {
+        if (page->sharedPageData->mappedData == NULL) {
+            VK_IF_ERROR(allocator->device->vkMapMemory(allocator->device->handle, page->memory,
+                                                       0, VK_WHOLE_SIZE, 0, &p)) VK_UNHANDLED_ERROR();
+            page->sharedPageData->mappedData = p;
+        }
+        p = (void*) (((uint8_t*) page->sharedPageData->mappedData) + (handle.offset * BLOCK_SIZE));
+    } else {
+        VK_IF_ERROR(allocator->device->vkMapMemory(allocator->device->handle, page->memory,
+                                                   0, VK_WHOLE_SIZE, 0, &p)) VK_UNHANDLED_ERROR();
+    }
+    return p;
+}
+void VKAllocator_Unmap(VKAllocator* allocator, VKMemory memory) {
+    assert(allocator != NULL && memory != VK_NULL_HANDLE);
+    MemoryHandle handle = { .value = (uint64_t) memory };
+    Page* page = &allocator->pages[handle.page];
+    if (handle.pair == 0) allocator->device->vkUnmapMemory(allocator->device->handle, page->memory);
+}
+void VKAllocator_Flush(VKAllocator* allocator, VKMemory memory, VkDeviceSize offset, VkDeviceSize size) {
+    VkMappedMemoryRange range = VKAllocator_GetMemoryRange(allocator, memory);
+    assert((size == VK_WHOLE_SIZE && offset <= range.size) || offset + size <= range.size);
+    range.offset += offset;
+    range.size = size == VK_WHOLE_SIZE ? range.size - offset : size;
+    VK_IF_ERROR(allocator->device->vkFlushMappedMemoryRanges(allocator->device->handle, 1, &range)) VK_UNHANDLED_ERROR();
+}
+void VKAllocator_Invalidate(VKAllocator* allocator, VKMemory memory, VkDeviceSize offset, VkDeviceSize size) {
+    VkMappedMemoryRange range = VKAllocator_GetMemoryRange(allocator, memory);
+    assert((size == VK_WHOLE_SIZE && offset <= range.size) || offset + size <= range.size);
+    range.offset += offset;
+    range.size = size == VK_WHOLE_SIZE ? range.size - offset : size;
+    VK_IF_ERROR(allocator->device->vkInvalidateMappedMemoryRanges(allocator->device->handle, 1, &range)) VK_UNHANDLED_ERROR();
+}
+
+VKAllocator* VKAllocator_Create(VKDevice* device) {
+    VKGraphicsEnvironment* ge = VKGE_graphics_environment();
+    VKAllocator* allocator = (VKAllocator*) calloc(1, sizeof(VKAllocator));
+    allocator->device = device;
+    allocator->freePageIndex = NO_PAGE_INDEX;
+    for (uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; i++) {
+        allocator->pools[i] = (Pool) {
+                .sharedPagesIndex = NO_PAGE_INDEX,
+                .allocationLevelTracker = MIN_SHARED_PAGE_LEVEL * 2
+        };
+    }
+    ge->vkGetPhysicalDeviceMemoryProperties(device->physicalDevice, &allocator->memoryProperties);
+
+    J2dRlsTraceLn1(J2D_TRACE_INFO, "VKAllocator_Create: allocator=%p", allocator);
+    return allocator;
+}
+
+void VKAllocator_Destroy(VKAllocator* allocator) {
+    if (allocator == NULL) return;
+
+    for (uint32_t i = 0; i < VK_MAX_MEMORY_TYPES; i++) {
+        uint32_t pageIndex;
+        while ((pageIndex = allocator->pools[i].sharedPagesIndex) != NO_PAGE_INDEX) {
+            Page* page = &allocator->pages[pageIndex];
+            SharedPageData* data = page->sharedPageData;
+#ifdef DEBUG
+            // Check that all shared allocations were freed.
+            for (uint32_t j = MAX_BLOCK_LEVEL;; j--) {
+                if (data->freeLevelIndices[j] != 0) {
+                    BlockPair* pair = &data->blockPairs[data->freeLevelIndices[j]-1];
+                    if (pair->parent == 0) break;
+                    else VK_FATAL_ERROR("VKAllocator_Destroy: leaked memory in shared page");
+                }
+                assert(j > 0);
+            }
+#endif
+            ARRAY_FREE(data->blockPairs);
+            allocator->pools[i].sharedPagesIndex = data->nextPageIndex;
+            free(data);
+            VKAllocator_FreePage(allocator, page, pageIndex);
+        }
+#ifdef DEBUG
+        // Check that all dedicated allocations were freed.
+        if (allocator->pools[i].debugTotalPagesSize > 0) VK_FATAL_ERROR("VKAllocator_Destroy: leaked memory in dedicated page");
+#endif
+    }
+    ARRAY_FREE(allocator->pages);
+
+    J2dRlsTraceLn1(J2D_TRACE_INFO, "VKAllocator_Destroy(%p)", allocator);
+    free(allocator);
+}

src/java.desktop/share/native/common/java2d/vulkan/VKAllocator.h

@@ -0,0 +1,138 @@
+// Copyright 2024 JetBrains s.r.o.
+// DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+//
+// This code is free software; you can redistribute it and/or modify it
+// under the terms of the GNU General Public License version 2 only, as
+// published by the Free Software Foundation.  Oracle designates this
+// particular file as subject to the "Classpath" exception as provided
+// by Oracle in the LICENSE file that accompanied this code.
+//
+// This code is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+// version 2 for more details (a copy is included in the LICENSE file that
+// accompanied this code).
+//
+// You should have received a copy of the GNU General Public License version
+// 2 along with this work; if not, write to the Free Software Foundation,
+// Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+//
+// Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+// or visit www.oracle.com if you need additional information or have any
+// questions.
+
+#ifndef VKAllocator_h_Included
+#define VKAllocator_h_Included
+
+#include "VKTypes.h"
+
+#define VK_NO_MEMORY_TYPE (~0U)
+#define VK_ALL_MEMORY_PROPERTIES ((VkMemoryPropertyFlags) (~0U))
+
+typedef struct {
+    VKAllocator*                  allocator;
+    VkMemoryRequirements2         requirements;
+    VkMemoryDedicatedRequirements dedicatedRequirements;
+    uint32_t                      memoryType;
+} VKMemoryRequirements;
+
+VKAllocator* VKAllocator_Create(VKDevice* device);
+
+void VKAllocator_Destroy(VKAllocator* allocator);
+
+/**
+ * Get generic, most permissive memory requirements with size=0, alignment=1.
+ */
+VKMemoryRequirements VKAllocator_NoRequirements(VKAllocator* allocator);
+/**
+ * Get buffer memory requirements. Required size may not be multiple of alignment, see VKAllocator_PadToAlignment.
+ */
+VKMemoryRequirements VKAllocator_BufferRequirements(VKAllocator* allocator, VkBuffer buffer);
+/**
+ * Get image memory requirements. Required size may not be multiple of alignment, see VKAllocator_PadToAlignment.
+ */
+VKMemoryRequirements VKAllocator_ImageRequirements(VKAllocator* allocator, VkImage image);
+
+/**
+ * Buffer and image memory requirements doesn't enforce size to be multiple of alignment.
+ * This needs to be enforced manually if resources are going to be sub-allocated in array manner.
+ * This also resets dedicated requirement flags, as for dedicated allocations size must
+ * be strictly equal to the one returned by resource memory requirements.
+ */
+void VKAllocator_PadToAlignment(VKMemoryRequirements* requirements);
+
+/**
+ * Find memory type with properties not less than requiredProperties and not more than allowedProperties,
+ * allowed by given memory requirements.
+ * Found memory type is set in requirements->memoryType, if it is not set already.
+ * If requirements->memoryType is already set, this function does nothing.
+ * @param requiredProperties minimal required set of properties
+ * @param allowedProperties  maximal allowed set of properties, implicitly includes requiredProperties, can be 0
+ */
+void VKAllocator_FindMemoryType(VKMemoryRequirements* requirements,
+                                VkMemoryPropertyFlags requiredProperties, VkMemoryPropertyFlags allowedProperties);
+
+/**
+ * Callback used to find appropriate memory type within given requirements.
+ * Found memory type must be set in requirements->memoryType.
+ * See VKAllocator_FindMemoryType.
+ */
+typedef void (*VKAllocator_FindMemoryTypeCallback)(VKMemoryRequirements* requirements);
+
+/**
+ * Allocate memory within given requirements.
+ * Requirements must have been initialized with VKAllocator_*Requirements
+ * and memory type found with VKAllocator_FindMemoryType.
+ */
+VKMemory VKAllocator_Allocate(VKMemoryRequirements* requirements);
+
+/**
+ * Allocate memory within given requirements and bind it to the image.
+ * Requirements must have been initialized with VKAllocator_*Requirements
+ * and memory type found with VKAllocator_FindMemoryType.
+ */
+VKMemory VKAllocator_AllocateForImage(VKMemoryRequirements* requirements, VkImage image);
+
+/**
+ * Allocate memory within given requirements and bind it to the buffer.
+ * Requirements must have been initialized with VKAllocator_*Requirements
+ * and memory type found with VKAllocator_FindMemoryType.
+ */
+VKMemory VKAllocator_AllocateForBuffer(VKMemoryRequirements* requirements, VkBuffer buffer);
+
+/**
+ * Release allocated memory.
+ */
+void VKAllocator_Free(VKAllocator* allocator, VKMemory memory);
+
+/**
+ * Get underlying memory range for the memory handle.
+ * - VkMappedMemoryRange.memory is a raw VkDeviceMemory given memory was allocated from.
+ * - VkMappedMemoryRange.offset is the starting offset of the given memory within VkMappedMemoryRange.memory.
+ * - VkMappedMemoryRange.size is the size of the given memory block, or VK_WHOLE_SIZE.
+ *   VK_WHOLE_SIZE is returned in cases, when exact memory block size is not known,
+ *   but it is guaranteed, that in such cases memory block covers the entire VkMappedMemoryRange.memory.
+ */
+VkMappedMemoryRange VKAllocator_GetMemoryRange(VKAllocator* allocator, VKMemory memory);
+
+/**
+ * Map allocated memory. Returns pointer to the beginning of mapped memory block.
+ */
+void* VKAllocator_Map(VKAllocator* allocator, VKMemory memory);
+
+/**
+ * Unmap allocated memory.
+ */
+void VKAllocator_Unmap(VKAllocator* allocator, VKMemory memory);
+
+/**
+ * Flush mapped memory range. size may be VK_WHOLE_SIZE. See vkFlushMappedMemoryRanges.
+ */
+void VKAllocator_Flush(VKAllocator* allocator, VKMemory memory, VkDeviceSize offset, VkDeviceSize size);
+
+/**
+ * Invalidate mapped memory range. size may be VK_WHOLE_SIZE. See vkInvalidateMappedMemoryRanges.
+ */
+void VKAllocator_Invalidate(VKAllocator* allocator, VKMemory memory, VkDeviceSize offset, VkDeviceSize size);
+
+#endif //VKAllocator_h_Included

src/java.desktop/share/native/common/java2d/vulkan/VKBase.c

@@ -28,6 +28,7 @@
 #include <string.h>
 #include "VKUtil.h"
 #include "VKBase.h"
+#include "VKAllocator.h"
 #include "VKRenderer.h"
 #include "VKTexturePool.h"
 
@@ -58,26 +59,22 @@ static void vulkanLibClose() {
                     VKDevice* device = &geInstance->devices[i];
                     VKRenderer_Destroy(device->renderer);
                     VKTexturePool_Dispose(device->texturePool);
+                    VKAllocator_Destroy(device->allocator);
                     ARRAY_FREE(device->enabledExtensions);
                     ARRAY_FREE(device->enabledLayers);
                     free(device->name);
-                    if (device->vkDestroyDevice != NULL && device->handle != NULL) {
-                        device->vkDestroyDevice(device->handle, NULL);
-                    }
+                    if (device->vkDestroyDevice != NULL) device->vkDestroyDevice(device->handle, NULL);
                 }
                 ARRAY_FREE(geInstance->devices);
             }
 
 #if defined(DEBUG)
-            if (geInstance->vkDestroyDebugUtilsMessengerEXT != NULL &&
-                geInstance->debugMessenger != NULL && geInstance->vkInstance != NULL) {
+            if (geInstance->vkDestroyDebugUtilsMessengerEXT != NULL && geInstance->vkInstance != VK_NULL_HANDLE) {
                 geInstance->vkDestroyDebugUtilsMessengerEXT(geInstance->vkInstance, geInstance->debugMessenger, NULL);
             }
 #endif
 
-            if (geInstance->vkDestroyInstance != NULL && geInstance->vkInstance != NULL) {
-                geInstance->vkDestroyInstance(geInstance->vkInstance, NULL);
-            }
+            if (geInstance->vkDestroyInstance != NULL) geInstance->vkDestroyInstance(geInstance->vkInstance, NULL);
             free(geInstance);
             geInstance = NULL;
         }
@@ -359,9 +356,19 @@ static jboolean VK_FindDevices() {
     ARRAY_ENSURE_CAPACITY(geInstance->devices, physicalDevicesCount);
 
     for (uint32_t i = 0; i < physicalDevicesCount; i++) {
+        VkPhysicalDeviceExtendedDynamicStateFeaturesEXT extendedDynamicStateFeatures = {
+                .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT,
+                .pNext = NULL
+        };
+
+        VkPhysicalDeviceExtendedDynamicState3FeaturesEXT extendedDynamicState3Features = {
+                .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT,
+                .pNext = &extendedDynamicStateFeatures
+        };
+
         VkPhysicalDeviceVulkan12Features device12Features = {
                 .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES,
-                .pNext = NULL
+                .pNext = &extendedDynamicState3Features
         };
 
         VkPhysicalDeviceFeatures2 deviceFeatures2 = {
@@ -371,7 +378,7 @@ static jboolean VK_FindDevices() {
 
         geInstance->vkGetPhysicalDeviceFeatures2(geInstance->physicalDevices[i], &deviceFeatures2);
 
-        VkPhysicalDeviceProperties2 deviceProperties2 = {.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2};
+        VkPhysicalDeviceProperties2 deviceProperties2 = {.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 };
         geInstance->vkGetPhysicalDeviceProperties2(geInstance->physicalDevices[i], &deviceProperties2);
         J2dRlsTrace5(J2D_TRACE_INFO, "\t- %s (%d.%d.%d, %s) ",
                      (const char *) deviceProperties2.properties.deviceName,
@@ -450,14 +457,24 @@ static jboolean VK_FindDevices() {
         VK_IF_ERROR(geInstance->vkEnumerateDeviceExtensionProperties(geInstance->physicalDevices[i],
                                                                   NULL, &extensionCount, extensions)) continue;
         J2dRlsTraceLn(J2D_TRACE_VERBOSE, "    Supported device extensions:")
-        VkBool32 hasSwapChain = VK_FALSE;
+        VkBool32 hasSwapChain = VK_FALSE, hasDynamicRendering = VK_FALSE,
+                 hasExtendedDynamicState = VK_FALSE, hasExtendedDynamicState3 = VK_FALSE;
         for (uint32_t j = 0; j < extensionCount; j++) {
             J2dRlsTraceLn1(J2D_TRACE_VERBOSE, "        %s", (char *) extensions[j].extensionName)
             hasSwapChain = hasSwapChain ||
-                           strcmp(VK_KHR_SWAPCHAIN_EXTENSION_NAME, extensions[j].extensionName) == 0;
+                    strcmp(VK_KHR_SWAPCHAIN_EXTENSION_NAME, extensions[j].extensionName) == 0;
+            hasDynamicRendering = hasDynamicRendering ||
+                    strcmp(VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME, extensions[j].extensionName) == 0;
+            hasExtendedDynamicState = hasExtendedDynamicState ||
+                    strcmp(VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME, extensions[j].extensionName) == 0;
+            hasExtendedDynamicState3 = hasExtendedDynamicState3 ||
+                    strcmp(VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME, extensions[j].extensionName) == 0;
         }
         J2dRlsTraceLn(J2D_TRACE_VERBOSE, "Vulkan: Found device extensions:")
         J2dRlsTraceLn1(J2D_TRACE_VERBOSE, "    " VK_KHR_SWAPCHAIN_EXTENSION_NAME " = %s", hasSwapChain ? "true" : "false")
+        J2dRlsTraceLn1(J2D_TRACE_VERBOSE, "    " VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME " = %s", hasDynamicRendering ? "true" : "false")
+        J2dRlsTraceLn1(J2D_TRACE_VERBOSE, "    " VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME " = %s", hasExtendedDynamicState ? "true" : "false")
+        J2dRlsTraceLn1(J2D_TRACE_VERBOSE, "    " VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME " = %s", hasExtendedDynamicState3 ? "true" : "false")
 
         if (!hasSwapChain) {
             J2dRlsTraceLn(J2D_TRACE_INFO,
@@ -465,9 +482,17 @@ static jboolean VK_FindDevices() {
             continue;
         }
 
+        // Randomly turn off optional features in debug mode.
+        if (VK_DEBUG_RANDOM(50)) hasDynamicRendering = VK_FALSE;
+        if (VK_DEBUG_RANDOM(50)) hasExtendedDynamicState = VK_FALSE;
+        if (VK_DEBUG_RANDOM(50)) hasExtendedDynamicState3 = VK_FALSE;
+
         pchar* deviceEnabledLayers = NULL;
         pchar* deviceEnabledExtensions = NULL;
         ARRAY_PUSH_BACK(deviceEnabledExtensions, VK_KHR_SWAPCHAIN_EXTENSION_NAME);
+        if (hasDynamicRendering) ARRAY_PUSH_BACK(deviceEnabledExtensions, VK_KHR_DYNAMIC_RENDERING_EXTENSION_NAME);
+        if (hasExtendedDynamicState) ARRAY_PUSH_BACK(deviceEnabledExtensions, VK_EXT_EXTENDED_DYNAMIC_STATE_EXTENSION_NAME);
+        if (hasExtendedDynamicState3) ARRAY_PUSH_BACK(deviceEnabledExtensions, VK_EXT_EXTENDED_DYNAMIC_STATE_3_EXTENSION_NAME);
 
         // Validation layer
 #ifdef DEBUG
@@ -496,7 +521,12 @@ static jboolean VK_FindDevices() {
                 .physicalDevice = geInstance->physicalDevices[i],
                 .queueFamily = queueFamily,
                 .enabledLayers = deviceEnabledLayers,
-                .enabledExtensions = deviceEnabledExtensions
+                .enabledExtensions = deviceEnabledExtensions,
+                .dynamicRendering = hasDynamicRendering,
+                .dynamicBlending = hasExtendedDynamicState3 && extendedDynamicState3Features.extendedDynamicState3ColorBlendEquation,
+                .dynamicLogicOp = hasExtendedDynamicState3 && extendedDynamicState3Features.extendedDynamicState3LogicOpEnable &&
+                                                              extendedDynamicState3Features.extendedDynamicState3ColorBlendEnable,
+                .dynamicStencil = hasExtendedDynamicState && extendedDynamicStateFeatures.extendedDynamicState
         }));
     }
     if (ARRAY_SIZE(geInstance->devices) == 0) {
@@ -537,6 +567,29 @@ static jboolean VK_InitDevice(VKDevice* device) {
     };
     void *pNext = &features12;
 
+    VkPhysicalDeviceDynamicRenderingFeaturesKHR dynamicRenderingFeatures = {
+            .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DYNAMIC_RENDERING_FEATURES_KHR,
+            .pNext = pNext,
+            .dynamicRendering = VK_TRUE
+    };
+    if (device->dynamicRendering) pNext = &dynamicRenderingFeatures;
+
+    VkPhysicalDeviceExtendedDynamicStateFeaturesEXT dynamicStateFeatures = {
+            .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_FEATURES_EXT,
+            .pNext = pNext,
+            .extendedDynamicState = VK_TRUE
+    };
+    if (device->dynamicStencil) pNext = &dynamicStateFeatures;
+
+    VkPhysicalDeviceExtendedDynamicState3FeaturesEXT dynamicState3Features = {
+            .sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTENDED_DYNAMIC_STATE_3_FEATURES_EXT,
+            .pNext = pNext,
+            .extendedDynamicState3ColorBlendEquation = device->dynamicBlending,
+            .extendedDynamicState3ColorBlendEnable = device->dynamicLogicOp,
+            .extendedDynamicState3LogicOpEnable = device->dynamicLogicOp,
+    };
+    if (device->dynamicBlending || device->dynamicLogicOp) pNext = &dynamicState3Features;
+
     VkDeviceCreateInfo createInfo = {
         .sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
         .pNext = pNext,
@@ -554,7 +607,8 @@ static jboolean VK_InitDevice(VKDevice* device) {
         J2dRlsTraceLn1(J2D_TRACE_ERROR, "Vulkan: Cannot create device: %s", device->name)
         return JNI_FALSE;
     }
-    J2dRlsTraceLn1(J2D_TRACE_INFO, "Vulkan: Device created (%s)", device->name)
+    J2dRlsTraceLn5(J2D_TRACE_INFO, "VK_InitDevice(%s): dynamicRendering=%d, dynamicBlending=%d, dynamicLogicOp=%d, dynamicStencil=%d",
+                   device->name, device->dynamicRendering, device->dynamicBlending, device->dynamicLogicOp, device->dynamicStencil);
 
 #define DEVICE_PROC(NAME) GET_VK_PROC_RET_FALSE_IF_ERR(geInstance->vkGetDeviceProcAddr, device, device->handle, NAME)
     DEVICE_PROC(vkDestroyDevice);
@@ -589,11 +643,21 @@ static jboolean VK_InitDevice(VKDevice* device) {
     DEVICE_PROC(vkCmdBlitImage);
     DEVICE_PROC(vkCmdPipelineBarrier);
     DEVICE_PROC(vkCmdBeginRenderPass);
+    if (device->dynamicRendering) {
+        DEVICE_PROC(vkCmdBeginRenderingKHR);
+        DEVICE_PROC(vkCmdEndRenderingKHR);
+    }
     DEVICE_PROC(vkCmdExecuteCommands);
     DEVICE_PROC(vkCmdClearAttachments);
     DEVICE_PROC(vkCmdBindPipeline);
     DEVICE_PROC(vkCmdSetViewport);
     DEVICE_PROC(vkCmdSetScissor);
+    if (device->dynamicStencil) DEVICE_PROC(vkCmdSetStencilTestEnableEXT);
+    if (device->dynamicBlending) DEVICE_PROC(vkCmdSetColorBlendEquationEXT);
+    if (device->dynamicLogicOp) {
+        DEVICE_PROC(vkCmdSetColorBlendEnableEXT);
+        DEVICE_PROC(vkCmdSetLogicOpEnableEXT);
+    }
     DEVICE_PROC(vkCmdDraw);
     DEVICE_PROC(vkCmdEndRenderPass);
     DEVICE_PROC(vkEndCommandBuffer);
@@ -606,25 +670,28 @@ static jboolean VK_InitDevice(VKDevice* device) {
     DEVICE_PROC(vkDestroyDescriptorSetLayout);
     DEVICE_PROC(vkUpdateDescriptorSets);
     DEVICE_PROC(vkCreateDescriptorPool);
+    DEVICE_PROC(vkDestroyDescriptorPool);
     DEVICE_PROC(vkAllocateDescriptorSets);
     DEVICE_PROC(vkCmdBindDescriptorSets);
-    DEVICE_PROC(vkGetImageMemoryRequirements);
+    DEVICE_PROC(vkGetImageMemoryRequirements2);
     DEVICE_PROC(vkCreateBuffer);
-    DEVICE_PROC(vkGetBufferMemoryRequirements);
+    DEVICE_PROC(vkDestroyBuffer);
+    DEVICE_PROC(vkCreateBufferView);
+    DEVICE_PROC(vkDestroyBufferView);
+    DEVICE_PROC(vkGetBufferMemoryRequirements2);
     DEVICE_PROC(vkBindBufferMemory);
     DEVICE_PROC(vkMapMemory);
     DEVICE_PROC(vkUnmapMemory);
     DEVICE_PROC(vkCmdBindVertexBuffers);
     DEVICE_PROC(vkCreateRenderPass);
     DEVICE_PROC(vkDestroyRenderPass);
-    DEVICE_PROC(vkDestroyBuffer);
     DEVICE_PROC(vkFreeMemory);
     DEVICE_PROC(vkDestroyImageView);
     DEVICE_PROC(vkDestroyImage);
     DEVICE_PROC(vkDestroyFramebuffer);
     DEVICE_PROC(vkFlushMappedMemoryRanges);
+    DEVICE_PROC(vkInvalidateMappedMemoryRanges);
     DEVICE_PROC(vkCmdPushConstants);
-    DEVICE_PROC(vkCmdCopyBufferToImage);
 
     device->vkGetDeviceQueue(device->handle, device->queueFamily, 0, &device->queue);
     if (device->queue == NULL) {
@@ -633,6 +700,13 @@ static jboolean VK_InitDevice(VKDevice* device) {
         return JNI_FALSE;
     }
 
+    device->allocator = VKAllocator_Create(device);
+    if (!device->allocator) {
+        J2dRlsTraceLn(J2D_TRACE_ERROR, "Vulkan: Cannot create allocator")
+        VK_UNHANDLED_ERROR();
+        return JNI_FALSE;
+    }
+
     device->renderer = VKRenderer_Create(device);
     if (!device->renderer) {
         J2dRlsTraceLn(J2D_TRACE_ERROR, "Vulkan: Cannot create renderer")
@@ -663,6 +737,10 @@ VKGraphicsEnvironment* VKGE_graphics_environment() {
  */
 JNIEXPORT jboolean JNICALL
 Java_sun_java2d_vulkan_VKInstance_initNative(JNIEnv *env, jclass wlge, jlong nativePtr, jboolean verb, jint requestedDevice) {
+#ifdef DEBUG
+    // Init random for debug-related validation tricks.
+    srand(nativePtr);
+#endif
     verbose = verb;
     PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = vulkanLibOpen();
     if (vkGetInstanceProcAddr == NULL) {

src/java.desktop/share/native/common/java2d/vulkan/VKBase.h

@@ -28,7 +28,6 @@
 #define VKBase_h_Included
 #include "VKTypes.h"
 #include "VKTexturePool.h"
-#include "VKRenderState.h"
 
 struct VKDevice {
     VkDevice         handle;
@@ -38,7 +37,12 @@ struct VKDevice {
     pchar*           enabledLayers;
     pchar*           enabledExtensions;
     VkQueue          queue;
+    VkBool32         dynamicRendering;
+    VkBool32         dynamicBlending;
+    VkBool32         dynamicLogicOp;
+    VkBool32         dynamicStencil;
 
+    VKAllocator*     allocator;
     VKRenderer*      renderer;
     VKTexturePool*   texturePool;
 
@@ -73,12 +77,18 @@ struct VKDevice {
     PFN_vkBeginCommandBuffer vkBeginCommandBuffer;
     PFN_vkCmdBlitImage vkCmdBlitImage;
     PFN_vkCmdPipelineBarrier vkCmdPipelineBarrier;
+    PFN_vkCmdBeginRenderingKHR vkCmdBeginRenderingKHR;
+    PFN_vkCmdEndRenderingKHR vkCmdEndRenderingKHR;
     PFN_vkCmdBeginRenderPass vkCmdBeginRenderPass;
     PFN_vkCmdExecuteCommands vkCmdExecuteCommands;
     PFN_vkCmdClearAttachments vkCmdClearAttachments;
     PFN_vkCmdBindPipeline vkCmdBindPipeline;
     PFN_vkCmdSetViewport vkCmdSetViewport;
     PFN_vkCmdSetScissor vkCmdSetScissor;
+    PFN_vkCmdSetStencilTestEnableEXT vkCmdSetStencilTestEnableEXT;
+    PFN_vkCmdSetColorBlendEquationEXT vkCmdSetColorBlendEquationEXT;
+    PFN_vkCmdSetColorBlendEnableEXT vkCmdSetColorBlendEnableEXT;
+    PFN_vkCmdSetLogicOpEnableEXT vkCmdSetLogicOpEnableEXT;
     PFN_vkCmdDraw vkCmdDraw;
     PFN_vkCmdEndRenderPass vkCmdEndRenderPass;
     PFN_vkEndCommandBuffer vkEndCommandBuffer;
@@ -91,25 +101,28 @@ struct VKDevice {
     PFN_vkDestroyDescriptorSetLayout vkDestroyDescriptorSetLayout;
     PFN_vkUpdateDescriptorSets vkUpdateDescriptorSets;
     PFN_vkCreateDescriptorPool vkCreateDescriptorPool;
+    PFN_vkDestroyDescriptorPool vkDestroyDescriptorPool;
     PFN_vkAllocateDescriptorSets vkAllocateDescriptorSets;
     PFN_vkCmdBindDescriptorSets vkCmdBindDescriptorSets;
-    PFN_vkGetImageMemoryRequirements vkGetImageMemoryRequirements;
+    PFN_vkGetImageMemoryRequirements2 vkGetImageMemoryRequirements2;
     PFN_vkCreateBuffer vkCreateBuffer;
-    PFN_vkGetBufferMemoryRequirements vkGetBufferMemoryRequirements;
+    PFN_vkDestroyBuffer vkDestroyBuffer;
+    PFN_vkCreateBufferView vkCreateBufferView;
+    PFN_vkDestroyBufferView vkDestroyBufferView;
+    PFN_vkGetBufferMemoryRequirements2 vkGetBufferMemoryRequirements2;
     PFN_vkBindBufferMemory vkBindBufferMemory;
     PFN_vkMapMemory vkMapMemory;
     PFN_vkUnmapMemory vkUnmapMemory;
     PFN_vkCmdBindVertexBuffers vkCmdBindVertexBuffers;
     PFN_vkCreateRenderPass vkCreateRenderPass;
     PFN_vkDestroyRenderPass vkDestroyRenderPass;
-    PFN_vkDestroyBuffer vkDestroyBuffer;
     PFN_vkFreeMemory vkFreeMemory;
     PFN_vkDestroyImageView vkDestroyImageView;
     PFN_vkDestroyImage vkDestroyImage;
     PFN_vkDestroyFramebuffer vkDestroyFramebuffer;
     PFN_vkFlushMappedMemoryRanges vkFlushMappedMemoryRanges;
+    PFN_vkInvalidateMappedMemoryRanges vkInvalidateMappedMemoryRanges;
     PFN_vkCmdPushConstants vkCmdPushConstants;
-    PFN_vkCmdCopyBufferToImage vkCmdCopyBufferToImage;
 };
 
 struct VKGraphicsEnvironment {

src/java.desktop/share/native/common/java2d/vulkan/VKBlitLoops.c

@@ -1,216 +0,0 @@
-/*
- * Copyright (c) 2024, Oracle and/or its affiliates. All rights reserved.
- * Copyright (c) 2024, JetBrains s.r.o.. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-#include <malloc.h>
-#include <string.h>
-#include "jlong.h"
-#include "SurfaceData.h"
-#include "VKUtil.h"
-#include "VKBlitLoops.h"
-#include "VKSurfaceData.h"
-#include "VKRenderer.h"
-
-
-#include "Trace.h"
-#include "VKImage.h"
-#include "VKRenderer.h"
-#include "VKImage.h"
-#include "VKBuffer.h"
-#include "CArrayUtil.h"
-
-static void VKBlitSwToTextureViaPooledTexture(VKRenderingContext* context, VKImage* dest, const SurfaceDataRasInfo *srcInfo,
-                     int dx1, int dy1, int dx2, int dy2) {
-    const int sw = srcInfo->bounds.x2 - srcInfo->bounds.x1;
-    const int sh = srcInfo->bounds.y2 - srcInfo->bounds.y1;
-    const int dw = dx2 - dx1;
-    const int dh = dy2 - dy1;
-
-    if (dw < sw || dh < sh) {
-        J2dTraceLn4(J2D_TRACE_ERROR, "replaceTextureRegion: dest size: (%d, %d) less than source size: (%d, %d)", dw, dh, sw, sh);
-        return;
-    }
-    float width = dest->extent.width/2.0;
-    float height = dest->extent.height/2.0;
-    J2dRlsTraceLn2(J2D_TRACE_VERBOSE,
-                   "VKRenderQueue_flushBuffer: FILL_PARALLELOGRAM(W=%f, H=%f)",
-                   width, height);
-    VKTxVertex* vertices = ARRAY_ALLOC(VKTxVertex, 4);
-    /*
-     *    (p1)---------(p2)
-     *     |             |
-     *     |             |
-     *     |             |
-     *    (p4)---------(p3)
-     */
-    float p1x = -1.0f + dx1 / width;
-    float p1y = -1.0f + dy1 / height;
-    float p2x = -1.0f + dx2 / width;
-    float p2y = -1.0f + dy1 / height;
-    float p3x = -1.0f + dx2 / width;
-    float p3y = -1.0f + dy2 / height;
-    float p4x = -1.0f + dx1 / width;
-    float p4y = -1.0f + dy2 / height;
-
-
-    ARRAY_PUSH_BACK(vertices, ((VKTxVertex) {p1x, p1y, 0.0f, 0.0f}));
-    ARRAY_PUSH_BACK(vertices, ((VKTxVertex) {p2x, p2y, 1.0f, 0.0f}));
-    ARRAY_PUSH_BACK(vertices, ((VKTxVertex) {p4x, p4y, 0.0f, 1.0f}));
-    ARRAY_PUSH_BACK(vertices, ((VKTxVertex) {p3x, p3y, 1.0f, 1.0f}));
-
-    VKBuffer* renderVertexBuffer = ARRAY_TO_VERTEX_BUF(context->surface->device, vertices);
-    ARRAY_FREE(vertices);
-    VKSDOps* surface = context->surface;
-    VKRenderer_Render(surface);
-    const char *raster = srcInfo->rasBase;
-    raster += (uint32_t)srcInfo->bounds.y1 * (uint32_t)srcInfo->scanStride + (uint32_t)srcInfo->bounds.x1 * (uint32_t)srcInfo->pixelStride;
-    VKImage *image = VKImage_Create(context->surface->device, sw, sh, VK_FORMAT_R8G8B8A8_UNORM, VK_IMAGE_TILING_LINEAR,
-                                  VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT,
-                                  VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
-        J2dTraceLn4(J2D_TRACE_VERBOSE, "replaceTextureRegion src (dw, dh) : [%d, %d] dest (dx1, dy1) =[%d, %d]",
-                    dw, dh, dx1, dy1);
-    uint32_t dataSize = sw * sh * srcInfo->pixelStride;
-    char* data = malloc(dataSize);
-    // copy src pixels inside src bounds to buff
-    for (int row = 0; row < sh; row++) {
-        memcpy(data + (row * sw * srcInfo->pixelStride), raster, sw * srcInfo->pixelStride);
-        raster += (uint32_t)srcInfo->scanStride;
-    }
-    VKBuffer *buffer = VKBuffer_CreateFromData(context->surface->device, data, dataSize);
-    //free(data);
-    VKImage_LoadBuffer(context, image, buffer, dx1, dy1, sw, sh);
-    VKRenderer_TextureRender(context, dest, image, renderVertexBuffer->buffer, 4);
-    //VKRenderer_EndRendering(logicalDevice, VK_FALSE, VK_FALSE);
-    VKRenderer_FlushRenderPass(context->surface);
-}
-
-
-void VKBlitLoops_IsoBlit(JNIEnv *env,
-                         VKRenderingContext* context, jlong pSrcOps, jlong pDstOps,
-                         jboolean xform, jint hint,
-                         jboolean texture,
-                         jint sx1, jint sy1,
-                         jint sx2, jint sy2,
-                         jdouble dx1, jdouble dy1,
-                         jdouble dx2, jdouble dy2)
-{
-    J2dRlsTraceLn8(J2D_TRACE_VERBOSE, "VKRenderQueue_flushBuffer: BLIT_IsoBlit (%d %d %d %d) -> (%f %f %f %f) ",
-                                   sx1, sy1, sx2, sy2, dx1, dy1, dx2, dy2);
-    J2dRlsTraceLn2(J2D_TRACE_VERBOSE, "VKRenderQueue_flushBuffer: BLIT_IsoBlit texture=%d xform=%d",
-                                   texture, xform)
-}
-
-void VKBlitLoops_Blit(JNIEnv *env,
-                      VKRenderingContext* context, jlong pSrcOps, jlong pDstOps,
-                      jboolean xform, jint hint,
-                      jint srctype, jboolean texture,
-                      jint sx1, jint sy1,
-                      jint sx2, jint sy2,
-                      jdouble dx1, jdouble dy1,
-                      jdouble dx2, jdouble dy2)
-{
-    J2dRlsTraceLn8(J2D_TRACE_VERBOSE, "VKRenderQueue_flushBuffer: BLIT_Blit (%d %d %d %d) -> (%f %f %f %f) ",
-                                   sx1, sy1, sx2, sy2, dx1, dy1, dx2, dy2)
-    J2dRlsTraceLn3(J2D_TRACE_VERBOSE, "VKRenderQueue_flushBuffer: BLIT_Blit texture=%d xform=%d srctype=%d",
-                                   texture, xform, srctype)
-
-    SurfaceDataOps *srcOps = (SurfaceDataOps *)jlong_to_ptr(pSrcOps);
-    VKSDOps *dstOps = (VKSDOps *)jlong_to_ptr(pDstOps);
-
-    RETURN_IF_NULL(context);
-    RETURN_IF_NULL(srcOps);
-    RETURN_IF_NULL(dstOps);
-
-    VKImage *dest = dstOps->image;
-    if (dest == NULL) {
-        J2dTraceLn(J2D_TRACE_ERROR, "MTLBlitLoops_Blit: dest is null");
-        return;
-    }
-//    if (srctype < 0 || srctype >= sizeof(RasterFormatInfos)/ sizeof(MTLRasterFormatInfo)) {
-//        J2dTraceLn1(J2D_TRACE_ERROR, "MTLBlitLoops_Blit: source pixel format %d isn't supported", srctype);
-//        return;
-//    }
-    const jint sw    = sx2 - sx1;
-    const jint sh    = sy2 - sy1;
-    const jint dw = dx2 - dx1;
-    const jint dh = dy2 - dy1;
-
-    if (sw <= 0 || sh <= 0 || dw <= 0 || dh <= 0) {
-        J2dTraceLn(J2D_TRACE_ERROR, "MTLBlitLoops_Blit: invalid dimensions");
-        return;
-    }
-
-//    if (!xform) {
-//        clipDestCoords(
-//                &dx1, &dy1, &dx2, &dy2,
-//                &sx1, &sy1, &sx2, &sy2,
-//                dest.width, dest.height, texture ? NULL : [mtlc.clip getRect]
-//        );
-//    }
-
-    SurfaceDataRasInfo srcInfo;
-    srcInfo.bounds.x1 = sx1;
-    srcInfo.bounds.y1 = sy1;
-    srcInfo.bounds.x2 = sx2;
-    srcInfo.bounds.y2 = sy2;
-
-    // NOTE: This function will modify the contents of the bounds field to represent the maximum available raster data.
-    if (srcOps->Lock(env, srcOps, &srcInfo, SD_LOCK_READ) != SD_SUCCESS) {
-        J2dTraceLn(J2D_TRACE_WARNING, "MTLBlitLoops_Blit: could not acquire lock");
-        return;
-    }
-
-    if (srcInfo.bounds.x2 > srcInfo.bounds.x1 && srcInfo.bounds.y2 > srcInfo.bounds.y1) {
-        srcOps->GetRasInfo(env, srcOps, &srcInfo);
-        if (srcInfo.rasBase) {
-            if (srcInfo.bounds.x1 != sx1) {
-                const int dx = srcInfo.bounds.x1 - sx1;
-                dx1 += dx * (dw / sw);
-            }
-            if (srcInfo.bounds.y1 != sy1) {
-                const int dy = srcInfo.bounds.y1 - sy1;
-                dy1 += dy * (dh / sh);
-            }
-            if (srcInfo.bounds.x2 != sx2) {
-                const int dx = srcInfo.bounds.x2 - sx2;
-                dx2 += dx * (dw / sw);
-            }
-            if (srcInfo.bounds.y2 != sy2) {
-                const int dy = srcInfo.bounds.y2 - sy2;
-                dy2 += dy * (dh / sh);
-            }
-
-//            MTLRasterFormatInfo rfi = RasterFormatInfos[srctype];
-//
-//            if (texture) {
-//                replaceTextureRegion(mtlc, dest, &srcInfo, &rfi, (int) dx1, (int) dy1, (int) dx2, (int) dy2);
-//            } else {
-                VKBlitSwToTextureViaPooledTexture(context, dest, &srcInfo, dx1, dy1, dx2, dy2);
-//            }
-        }
-        SurfaceData_InvokeRelease(env, srcOps, &srcInfo);
-    }
-    SurfaceData_InvokeUnlock(env, srcOps, &srcInfo);
-}

src/java.desktop/share/native/common/java2d/vulkan/VKBlitLoops.h

@@ -1,60 +0,0 @@
-/*
- * Copyright (c) 2024, Oracle and/or its affiliates. All rights reserved.
- * Copyright (c) 2024, JetBrains s.r.o.. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-#ifndef VKBlitLoops_h_Included
-#define VKBlitLoops_h_Included
-
-#include "jni.h"
-#include "sun_java2d_vulkan_VKBlitLoops.h"
-#include "VKBase.h"
-
-#define OFFSET_SRCTYPE sun_java2d_vulkan_VKBlitLoops_OFFSET_SRCTYPE
-#define OFFSET_HINT    sun_java2d_vulkan_VKBlitLoops_OFFSET_HINT
-#define OFFSET_TEXTURE sun_java2d_vulkan_VKBlitLoops_OFFSET_TEXTURE
-#define OFFSET_RTT     sun_java2d_vulkan_VKBlitLoops_OFFSET_RTT
-#define OFFSET_XFORM   sun_java2d_vulkan_VKBlitLoops_OFFSET_XFORM
-#define OFFSET_ISOBLIT sun_java2d_vulkan_VKBlitLoops_OFFSET_ISOBLIT
-
-void VKBlitLoops_IsoBlit(JNIEnv *env,
-                          VKRenderingContext* context, jlong pSrcOps, jlong pDstOps,
-                          jboolean xform, jint hint,
-                          jboolean texture,
-                          jint sx1, jint sy1,
-                          jint sx2, jint sy2,
-                          jdouble dx1, jdouble dy1,
-                          jdouble dx2, jdouble dy2);
-
-void VKBlitLoops_Blit(JNIEnv *env,
-                       VKRenderingContext* context, jlong pSrcOps, jlong pDstOps,
-                       jboolean xform, jint hint,
-                       jint srctype, jboolean texture,
-                       jint sx1, jint sy1,
-                       jint sx2, jint sy2,
-                       jdouble dx1, jdouble dy1,
-                       jdouble dx2, jdouble dy2);
-
-
-#endif /* VKBlitLoops_h_Included */

src/java.desktop/share/native/common/java2d/vulkan/VKBuffer.c

@@ -24,118 +24,155 @@
  * questions.
  */
 
+#include <assert.h>
 #include <string.h>
 #include "VKUtil.h"
+#include "VKAllocator.h"
 #include "VKBase.h"
 #include "VKBuffer.h"
 
-VkResult VKBuffer_FindMemoryType(VkPhysicalDevice physicalDevice, uint32_t typeFilter,
-                                 VkMemoryPropertyFlags properties, uint32_t* pMemoryType) {
-    VKGraphicsEnvironment* ge = VKGE_graphics_environment();
-    VkPhysicalDeviceMemoryProperties memProperties;
-    ge->vkGetPhysicalDeviceMemoryProperties(physicalDevice, &memProperties);
-
-    for (uint32_t i = 0; i < memProperties.memoryTypeCount; i++) {
-        if ((typeFilter & (1 << i)) && (memProperties.memoryTypes[i].propertyFlags & properties) == properties) {
-            *pMemoryType = i;
-            return VK_SUCCESS;
-        }
+static VKMemory VKBuffer_DestroyBuffersOnFailure(VKDevice* device, VKMemory page, uint32_t bufferCount, VKBuffer* buffers) {
+    assert(device != NULL && device->allocator != NULL);
+    for (uint32_t i = 0; i < bufferCount; i++) {
+        device->vkDestroyBuffer(device->handle, buffers[i].handle, NULL);
     }
-
-    return VK_ERROR_UNKNOWN;
+    VKAllocator_Free(device->allocator, page);
+    return VK_NULL_HANDLE;
 }
 
-VKBuffer* VKBuffer_Create(VKDevice* device, VkDeviceSize size,
-                          VkBufferUsageFlags usage, VkMemoryPropertyFlags properties)
-{
-    VKBuffer* buffer = calloc(1, sizeof(VKBuffer));
-    VK_RUNTIME_ASSERT(buffer);
+VKMemory VKBuffer_CreateBuffers(VKDevice* device, VkBufferUsageFlags usageFlags,
+                                VKAllocator_FindMemoryTypeCallback findMemoryTypeCallback,
+                                VkDeviceSize bufferSize, VkDeviceSize pageSize,
+                                uint32_t* bufferCount, VKBuffer* buffers) {
+    assert(device != NULL && device->allocator != NULL);
+    assert(bufferCount != NULL && buffers != NULL);
+    assert(pageSize == 0 || pageSize >= bufferSize);
+    if (*bufferCount == 0 || bufferSize == 0) return VK_NULL_HANDLE;
+    VKAllocator* alloc = device->allocator;
 
+    // Create a single buffer.
     VkBufferCreateInfo bufferInfo = {
             .sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,
-            .size = size,
-            .usage = usage,
+            .size = bufferSize,
+            .usage = usageFlags,
             .sharingMode = VK_SHARING_MODE_EXCLUSIVE
     };
+    VK_IF_ERROR(device->vkCreateBuffer(device->handle, &bufferInfo, NULL, &buffers[0].handle)) return VK_NULL_HANDLE;
 
-    VK_IF_ERROR(device->vkCreateBuffer(device->handle, &bufferInfo, NULL, &buffer->buffer)) {
-        VKBuffer_free(device, buffer);
-        return NULL;
+    // Check memory requirements. We aim to create maxBufferCount buffers,
+    // but due to implementation-specific alignment requirements this number can be lower (unlikely though).
+    VKMemoryRequirements requirements = VKAllocator_BufferRequirements(alloc, buffers[0].handle);
+    VKAllocator_PadToAlignment(&requirements); // Align for array-like allocation.
+    VkDeviceSize realBufferSize = requirements.requirements.memoryRequirements.size;
+    if (pageSize == 0) pageSize = (*bufferCount) * realBufferSize;
+    uint32_t realBufferCount = pageSize / realBufferSize;
+    if (realBufferCount > *bufferCount) realBufferCount = *bufferCount;
+    if (realBufferCount == 0) return VKBuffer_DestroyBuffersOnFailure(device, VK_NULL_HANDLE, 1, buffers);
+    requirements.requirements.memoryRequirements.size = pageSize;
+
+    // Find memory type.
+    findMemoryTypeCallback(&requirements);
+    if (requirements.memoryType == VK_NO_MEMORY_TYPE) {
+        return VKBuffer_DestroyBuffersOnFailure(device, VK_NULL_HANDLE, 1, buffers);
     }
 
-    buffer->size = size;
+    // Allocate new memory page.
+    VKMemory page = VKAllocator_Allocate(&requirements);
+    if (page == VK_NULL_HANDLE) return VKBuffer_DestroyBuffersOnFailure(device, VK_NULL_HANDLE, 1, buffers);
+    void* data = VKAllocator_Map(alloc, page);
+    if (data == NULL) return VKBuffer_DestroyBuffersOnFailure(device, page, 1, buffers);
+    VkMappedMemoryRange range = VKAllocator_GetMemoryRange(alloc, page);
 
-    VkMemoryRequirements memRequirements;
-    device->vkGetBufferMemoryRequirements(device->handle, buffer->buffer, &memRequirements);
-
-    uint32_t memoryType;
-
-    VK_IF_ERROR(VKBuffer_FindMemoryType(device->physicalDevice,
-                                     memRequirements.memoryTypeBits,
-                                     properties, &memoryType)) {
-        VKBuffer_free(device, buffer);
-        return NULL;
+    // Create remaining buffers and bind memory.
+    for (uint32_t i = 0;;) {
+        VKBuffer* b = &buffers[i];
+        b->range = (VkMappedMemoryRange) {
+            .sType  = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,
+            .memory = range.memory,
+            .offset = range.offset + realBufferSize * i,
+            .size   = realBufferSize
+        };
+        b->data = (void*) (((uint8_t*) data) + realBufferSize * i);
+        VK_IF_ERROR(device->vkBindBufferMemory(device->handle, b->handle, range.memory, b->range.offset)) {
+            return VKBuffer_DestroyBuffersOnFailure(device, page, i + 1, buffers);
+        }
+        if ((++i) >= realBufferCount) break;
+        VK_IF_ERROR(device->vkCreateBuffer(device->handle, &bufferInfo, NULL, &buffers[i].handle)) {
+            return VKBuffer_DestroyBuffersOnFailure(device, page, i, buffers);
+        }
     }
 
-    VkMemoryAllocateInfo allocInfo = {
-            .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
-            .allocationSize = memRequirements.size,
-            .memoryTypeIndex = memoryType
-    };
-
-    VK_IF_ERROR(device->vkAllocateMemory(device->handle, &allocInfo, NULL, &buffer->memory)) {
-        VKBuffer_free(device, buffer);
-        return NULL;
-    }
-
-    VK_IF_ERROR(device->vkBindBufferMemory(device->handle, buffer->buffer, buffer->memory, 0)) {
-        VKBuffer_free(device, buffer);
-        return NULL;
-    }
-    return buffer;
+    *bufferCount = realBufferCount;
+    return page;
 }
 
-VKBuffer* VKBuffer_CreateFromData(VKDevice* device, void* vertices, VkDeviceSize bufferSize)
-{
-    VKBuffer* buffer = VKBuffer_Create(device, bufferSize,
-                                       VK_BUFFER_USAGE_TRANSFER_DST_BIT | VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
-                                       VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
-                                       VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
-
-    void* data;
-    VK_IF_ERROR(device->vkMapMemory(device->handle, buffer->memory, 0, VK_WHOLE_SIZE, 0, &data)) {
-        VKBuffer_free(device, buffer);
-        return NULL;
+static VkDescriptorPool VKBuffer_DestroyTexelBuffersOnFailure(VKDevice* device, VkDescriptorPool pool, uint32_t bufferCount, VKTexelBuffer* texelBuffers) {
+    assert(device != NULL);
+    for (uint32_t i = 0; i < bufferCount; i++) {
+        device->vkDestroyBufferView(device->handle, texelBuffers[i].view, NULL);
     }
-    memcpy(data, vertices, bufferSize);
+    device->vkDestroyDescriptorPool(device->handle, pool, NULL);
+    return VK_NULL_HANDLE;
+}
 
-    VkMappedMemoryRange memoryRange = {
-            .sType = VK_STRUCTURE_TYPE_MAPPED_MEMORY_RANGE,
-            .pNext = NULL,
-            .memory = buffer->memory,
+VkDescriptorPool VKBuffer_CreateTexelBuffers(VKDevice* device, VkFormat format,
+                                             VkDescriptorType descriptorType, VkDescriptorSetLayout descriptorSetLayout,
+                                             uint32_t bufferCount, VKBuffer* buffers, VKTexelBuffer* texelBuffers) {
+    assert(device != NULL);
+
+    // Create descriptor pool.
+    VkDescriptorPoolSize poolSize = { .type = descriptorType, .descriptorCount = bufferCount };
+    VkDescriptorPoolCreateInfo descriptorPoolCreateInfo = {
+            .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
+            .flags = 0,
+            .maxSets = bufferCount,
+            .poolSizeCount = 1,
+            .pPoolSizes = &poolSize
+    };
+    VkDescriptorPool pool;
+    VK_IF_ERROR(device->vkCreateDescriptorPool(device->handle, &descriptorPoolCreateInfo, NULL, &pool)) return VK_NULL_HANDLE;
+
+    // Allocate descriptor sets.
+    VkDescriptorSetLayout layouts[bufferCount];
+    for (uint32_t i = 0; i < bufferCount; i++) layouts[i] = descriptorSetLayout;
+    VkDescriptorSetAllocateInfo allocateInfo = {
+            .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
+            .descriptorPool = pool,
+            .descriptorSetCount = bufferCount,
+            .pSetLayouts = layouts
+    };
+    VkDescriptorSet descriptorSets[bufferCount];
+    VK_IF_ERROR(device->vkAllocateDescriptorSets(device->handle, &allocateInfo, descriptorSets)) {
+        return VKBuffer_DestroyTexelBuffersOnFailure(device, pool, 0, texelBuffers);
+    }
+
+    // Create buffer views and record them into descriptors.
+    VkBufferViewCreateInfo bufferViewCreateInfo = {
+            .sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO,
+            .format = format,
             .offset = 0,
-            .size = VK_WHOLE_SIZE
+            .range = VK_WHOLE_SIZE
     };
-
-
-    VK_IF_ERROR(device->vkFlushMappedMemoryRanges(device->handle, 1, &memoryRange)) {
-        VKBuffer_free(device, buffer);
-        return NULL;
+    VkWriteDescriptorSet writeDescriptorSets[bufferCount];
+    for (uint32_t i = 0; i < bufferCount; i++) {
+        texelBuffers[i] = (VKTexelBuffer) {
+            .buffer = buffers[i],
+            .descriptorSet = descriptorSets[i]
+        };
+        bufferViewCreateInfo.buffer = buffers[i].handle;
+        VK_IF_ERROR(device->vkCreateBufferView(device->handle, &bufferViewCreateInfo, NULL, &texelBuffers[i].view)) {
+            return VKBuffer_DestroyTexelBuffersOnFailure(device, pool, i, texelBuffers);
+        }
+        writeDescriptorSets[i] = (VkWriteDescriptorSet) {
+                .sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
+                .dstSet = descriptorSets[i],
+                .dstBinding = 0,
+                .dstArrayElement = 0,
+                .descriptorCount = 1,
+                .descriptorType = descriptorType,
+                .pTexelBufferView = &texelBuffers[i].view
+        };
     }
-    device->vkUnmapMemory(device->handle, buffer->memory);
-    buffer->size = bufferSize;
-
-    return buffer;
+    device->vkUpdateDescriptorSets(device->handle, bufferCount, writeDescriptorSets, 0, NULL);
+    return pool;
 }
-
-void VKBuffer_free(VKDevice* device, VKBuffer* buffer) {
-    if (buffer != NULL) {
-        if (buffer->buffer != VK_NULL_HANDLE) {
-            device->vkDestroyBuffer(device->handle, buffer->buffer, NULL);
-        }
-        if (buffer->memory != VK_NULL_HANDLE) {
-            device->vkFreeMemory(device->handle, buffer->memory, NULL);
-        }
-        free(buffer);
-    }
-}

src/java.desktop/share/native/common/java2d/vulkan/VKBuffer.h

@@ -29,23 +29,42 @@
 
 #include "VKTypes.h"
 
-#define ARRAY_TO_VERTEX_BUF(device, vertices)                                           \
-    VKBuffer_CreateFromData(device, vertices, ARRAY_SIZE(vertices)*sizeof (vertices[0]))
-
 struct VKBuffer {
-    VkBuffer buffer;
-    VkDeviceMemory memory;
-    VkDeviceSize size;
+    VkBuffer handle;
+    // Buffer has no ownership over its memory.
+    // Provided memory, offset and size must only be used to flush memory writes.
+    // Allocation and freeing is done in pages.
+    VkMappedMemoryRange range;
+    // Only sequential writes and no reads from mapped memory!
+    void* data;
 };
 
-VkResult VKBuffer_FindMemoryType(VkPhysicalDevice physicalDevice, uint32_t typeFilter,
-                                 VkMemoryPropertyFlags properties, uint32_t* pMemoryType);
+struct VKTexelBuffer {
+    VKBuffer buffer;
+    VkBufferView view;
+    VkDescriptorSet descriptorSet;
+};
 
-VKBuffer* VKBuffer_Create(VKDevice* device, VkDeviceSize size,
-                          VkBufferUsageFlags usage, VkMemoryPropertyFlags properties);
+/**
+ * Create buffers, allocate a memory page and bind them together.
+ * 'pageSize' can be 0, meaning that page size is calculated based on buffer memory requirements.
+ * It returns allocated memory page, or VK_NULL_HANDLE on failure.
+ * 'bufferCount' is updated with actual number of created buffers.
+ * Created buffers are written in 'buffers'.
+ */
+VKMemory VKBuffer_CreateBuffers(VKDevice* device, VkBufferUsageFlags usageFlags,
+                                VKAllocator_FindMemoryTypeCallback findMemoryTypeCallback,
+                                VkDeviceSize bufferSize, VkDeviceSize pageSize,
+                                uint32_t* bufferCount, VKBuffer* buffers);
 
-VKBuffer* VKBuffer_CreateFromData(VKDevice* device, void* vertices, VkDeviceSize bufferSize);
-
-void VKBuffer_free(VKDevice* device, VKBuffer* buffer);
+/**
+ * Create texel buffers from existing array of buffers.
+ * It returns created descriptor pool, or VK_NULL_HANDLE on failure.
+ * Created texel buffers are written in 'texelBuffers',
+ * original buffers are taken from 'buffers'.
+ */
+VkDescriptorPool VKBuffer_CreateTexelBuffers(VKDevice* device, VkFormat format,
+                                             VkDescriptorType descriptorType, VkDescriptorSetLayout descriptorSetLayout,
+                                             uint32_t bufferCount, VKBuffer* buffers, VKTexelBuffer* texelBuffers);
 
 #endif // VKBuffer_h_Included

src/java.desktop/share/native/common/java2d/vulkan/VKImage.c

@@ -24,46 +24,57 @@
  * questions.
  */
 
+#include <assert.h>
 #include "VKUtil.h"
+#include "VKAllocator.h"
 #include "VKBase.h"
-#include "VKBuffer.h"
 #include "VKImage.h"
-#include "VKRenderer.h"
-#include "VKSurfaceData.h"
 
 
-VkBool32 VKImage_CreateView(VKDevice* device, VKImage* image) {
+static VkBool32 VKImage_CreateViews(VKDevice* device, VKImage* image) {
     VkImageViewCreateInfo viewInfo = {
             .sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
-            .image = image->image,
+            .image = image->handle,
             .viewType = VK_IMAGE_VIEW_TYPE_2D,
-            .format = image->format,
-            .subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
+            .subresourceRange.aspectMask = VKImage_GetAspect(image),
             .subresourceRange.baseMipLevel = 0,
             .subresourceRange.levelCount = 1,
             .subresourceRange.baseArrayLayer = 0,
             .subresourceRange.layerCount = 1,
     };
-
-    VK_IF_ERROR(device->vkCreateImageView(device->handle, &viewInfo, NULL, &image->view)) {
-        return VK_FALSE;
+    FormatGroup formatGroup = VKUtil_GetFormatGroup(image->format);
+    if (formatGroup.bytes == 0) formatGroup.aliases[FORMAT_ALIAS_UNORM] = image->format;
+    SET_FORMAT_ALIASED_HANDLE(image->view, formatGroup.aliases, alias) {
+        viewInfo.format = formatGroup.aliases[alias];
+        VK_IF_ERROR(device->vkCreateImageView(device->handle, &viewInfo, NULL, &image->view[alias])) {
+            return VK_FALSE;
+        }
     }
     return VK_TRUE;
 }
 
+VkImageAspectFlagBits VKImage_GetAspect(VKImage* image) {
+    return VKUtil_GetFormatGroup(image->format).bytes == 0 ? // Unknown format group means stencil.
+           VK_IMAGE_ASPECT_STENCIL_BIT : VK_IMAGE_ASPECT_COLOR_BIT;
+}
+
 VKImage* VKImage_Create(VKDevice* device, uint32_t width, uint32_t height,
-                        VkFormat format, VkImageTiling tiling,
-                        VkImageUsageFlags usage,
-                        VkMemoryPropertyFlags properties)
-{
+                        VkImageCreateFlags flags, VkFormat format,
+                        VkImageTiling tiling, VkImageUsageFlags usage, VkSampleCountFlagBits samples,
+                        VKAllocator_FindMemoryTypeCallback findMemoryTypeCallback) {
+    assert(device != NULL && device->allocator != NULL);
     VKImage* image = calloc(1, sizeof(VKImage));
     VK_RUNTIME_ASSERT(image);
 
     image->format = format;
     image->extent = (VkExtent2D) {width, height};
+    image->layout = VK_IMAGE_LAYOUT_UNDEFINED;
+    image->lastStage = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
+    image->lastAccess = 0;
 
-    VkImageCreateInfo imageInfo = {
+    VkImageCreateInfo createInfo = {
             .sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
+            .flags = flags,
             .imageType = VK_IMAGE_TYPE_2D,
             .extent.width = width,
             .extent.height = height,
@@ -74,94 +85,41 @@ VKImage* VKImage_Create(VKDevice* device, uint32_t width, uint32_t height,
             .tiling = tiling,
             .initialLayout = VK_IMAGE_LAYOUT_UNDEFINED,
             .usage = usage,
-            .samples = VK_SAMPLE_COUNT_1_BIT,
+            .samples = samples,
             .sharingMode = VK_SHARING_MODE_EXCLUSIVE
     };
-
-    VK_IF_ERROR(device->vkCreateImage(device->handle, &imageInfo, NULL, &image->image)) {
-        VKImage_free(device, image);
+    VK_IF_ERROR(device->vkCreateImage(device->handle, &createInfo, NULL, &image->handle)) {
+        VKImage_Destroy(device, image);
         return NULL;
     }
 
-    VkMemoryRequirements memRequirements;
-    device->vkGetImageMemoryRequirements(device->handle, image->image, &memRequirements);
-
-    uint32_t memoryType;
-    VK_IF_ERROR(VKBuffer_FindMemoryType(device->physicalDevice,
-                                memRequirements.memoryTypeBits,
-                                properties, &memoryType))
-    {
-        VKImage_free(device, image);
+    VKMemoryRequirements requirements = VKAllocator_ImageRequirements(device->allocator, image->handle);
+    findMemoryTypeCallback(&requirements);
+    if (requirements.memoryType == VK_NO_MEMORY_TYPE) {
+        VKImage_Destroy(device, image);
         return NULL;
     }
 
-    VkMemoryAllocateInfo allocInfo = {
-            .sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO,
-            .allocationSize = memRequirements.size,
-            .memoryTypeIndex = memoryType
-    };
-
-    VK_IF_ERROR(device->vkAllocateMemory(device->handle, &allocInfo, NULL, &image->memory)) {
-        VKImage_free(device, image);
+    image->memory = VKAllocator_AllocateForImage(&requirements, image->handle);
+    if (image->memory == VK_NULL_HANDLE) {
+        VKImage_Destroy(device, image);
         return NULL;
     }
 
-    VK_IF_ERROR(device->vkBindImageMemory(device->handle, image->image, image->memory, 0)) {
-        VKImage_free(device, image);
-        return NULL;
-    }
-
-    if (!VKImage_CreateView(device, image)) {
-        VKImage_free(device, image);
+    if (!VKImage_CreateViews(device, image)) {
+        VKImage_Destroy(device, image);
         return NULL;
     }
 
     return image;
 }
 
-void VKImage_LoadBuffer(VKRenderingContext* context, VKImage* image, VKBuffer* buffer,
-                        uint32_t x0, uint32_t y0, uint32_t width, uint32_t height) {
-    VkCommandBuffer cb = VKRenderer_Render(context->surface);
-    VKDevice *device = context->surface->device;
-    VkBufferImageCopy region = (VkBufferImageCopy){
-            .bufferOffset = 0,
-            .bufferRowLength = 0,
-            .bufferImageHeight = 0,
-            .imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT,
-            .imageSubresource.mipLevel = 0,
-            .imageSubresource.baseArrayLayer = 0,
-            .imageSubresource.layerCount = 1,
-            .imageOffset = {x0, y0, 0},
-            .imageExtent = {
-                    .width = width,
-                    .height = height,
-                    .depth = 1
-            }
-    };
-    J2dRlsTraceLn4(J2D_TRACE_VERBOSE, "VKImage_LoadBuffer(device=%p, commandBuffer=%p, buffer=%p, image=%p)",
-                   device, cb, buffer->buffer, image->image);
-    device->vkCmdCopyBufferToImage(cb, buffer->buffer, image->image,
-                                          VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
-                                          1, &region);
-}
-
-void VKImage_free(VKDevice* device, VKImage* image) {
-    if (!image) return;
-
-    if (image->view != VK_NULL_HANDLE) {
-        device->vkDestroyImageView(device->handle, image->view, NULL);
-        image->view = VK_NULL_HANDLE;
-    }
-
-    if (image->memory != VK_NULL_HANDLE) {
-        device->vkFreeMemory(device->handle, image->memory, NULL);
-        image->memory = VK_NULL_HANDLE;
-    }
-
-    if (image->image != VK_NULL_HANDLE) {
-        device->vkDestroyImage(device->handle, image->image, NULL);
-        image->image = VK_NULL_HANDLE;
-    }
-
+void VKImage_Destroy(VKDevice* device, VKImage* image) {
+    assert(device != NULL && device->allocator != NULL);
+    if (image == NULL) return;
+    SET_FORMAT_ALIASED_HANDLE(image->view, image->view, alias)
+        device->vkDestroyImageView(device->handle, image->view[alias], NULL);
+    device->vkDestroyImage(device->handle, image->handle, NULL);
+    VKAllocator_Free(device->allocator, image->memory);
     free(image);
 }

src/java.desktop/share/native/common/java2d/vulkan/VKImage.h

@@ -28,22 +28,26 @@
 #define VKImage_h_Included
 
 #include "VKTypes.h"
+#include "VKAllocator.h"
 
 struct VKImage {
-    VkImage                 image;
-    VkDeviceMemory          memory;
-    VkImageView             view;
-    VkFormat                format;
-    VkExtent2D              extent;
+    VkImage     handle;
+    VKMemory    memory;
+    VkImageView view FORMAT_ALIASED;
+    VkFormat    format;
+    VkExtent2D  extent;
+
+    VkImageLayout           layout;
+    VkPipelineStageFlagBits lastStage;
+    VkAccessFlagBits        lastAccess;
 };
 
+VkImageAspectFlagBits VKImage_GetAspect(VKImage* image);
+
 VKImage* VKImage_Create(VKDevice* device, uint32_t width, uint32_t height,
-                        VkFormat format, VkImageTiling tiling,
-                        VkImageUsageFlags usage,
-                        VkMemoryPropertyFlags properties);
+                        VkImageCreateFlags flags, VkFormat format,
+                        VkImageTiling tiling, VkImageUsageFlags usage, VkSampleCountFlagBits samples,
+                        VKAllocator_FindMemoryTypeCallback findMemoryTypeCallback);
 
-void VKImage_LoadBuffer(VKRenderingContext* context, VKImage* image, VKBuffer* buffer,
-                        uint32_t x0, uint32_t y0, uint32_t width, uint32_t height);
-
-void VKImage_free(VKDevice* device, VKImage* image);
+void VKImage_Destroy(VKDevice* device, VKImage* image);
 #endif // VKImage_h_Included

src/java.desktop/share/native/common/java2d/vulkan/VKPipelines.c

@@ -34,15 +34,17 @@
 #undef SHADER_ENTRY
 #undef BYTECODE_END
 
-struct VKPipelineSet {
+typedef struct VKPipelineSet {
     VkPipeline pipelines[PIPELINE_COUNT];
-};
+    VKPipelineSetDescriptor descriptor;
+    struct VKPipelineSet*   next;
+} VKPipelineSet;
 
-struct VKShaders {
+typedef struct VKShaders {
 #   define SHADER_ENTRY(NAME, TYPE) VkPipelineShaderStageCreateInfo NAME ## _ ## TYPE;
 #   include "vulkan/shader_list.h"
 #   undef SHADER_ENTRY
-};
+} VKShaders;
 
 static void VKPipelines_DestroyShaders(VKDevice* device, VKShaders* shaders) {
     assert(device != NULL);
@@ -80,27 +82,37 @@ static VKShaders* VKPipelines_CreateShaders(VKDevice* device) {
     return shaders;
 }
 
-#define MAKE_INPUT_STATE(TYPE, ...)                                             \
-static const VkVertexInputAttributeDescription attributes[] = { __VA_ARGS__ }; \
-static const VkVertexInputBindingDescription binding = {                       \
-        .binding = 0,                                                          \
-        .stride = sizeof(TYPE),                                                \
-        .inputRate = VK_VERTEX_INPUT_RATE_VERTEX                               \
-};                                                                             \
-static const VkPipelineVertexInputStateCreateInfo inputState = {               \
-        .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,    \
-        .vertexBindingDescriptionCount = 1,                                    \
-        .pVertexBindingDescriptions = &binding,                                \
-        .vertexAttributeDescriptionCount = SARRAY_COUNT_OF(attributes),        \
-        .pVertexAttributeDescriptions = attributes                             \
-}
+#define MAKE_INPUT_STATE(NAME, TYPE, ...)                                                  \
+const VkFormat INPUT_STATE_ATTRIBUTE_FORMATS_##NAME[] = { __VA_ARGS__ };                   \
+VkVertexInputAttributeDescription                                                          \
+    INPUT_STATE_ATTRIBUTES_##NAME[SARRAY_COUNT_OF(INPUT_STATE_ATTRIBUTE_FORMATS_##NAME)];  \
+const VkVertexInputBindingDescription INPUT_STATE_BINDING_##NAME = {                       \
+        .binding = 0,                                                                      \
+        .stride = sizeof(TYPE),                                                            \
+        .inputRate = VK_VERTEX_INPUT_RATE_VERTEX                                           \
+};                                                                                         \
+const VkPipelineVertexInputStateCreateInfo INPUT_STATE_##NAME = {                          \
+        .sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,                \
+        .vertexBindingDescriptionCount = 1,                                                \
+        .pVertexBindingDescriptions = &INPUT_STATE_BINDING_##NAME,                         \
+        .vertexAttributeDescriptionCount = SARRAY_COUNT_OF(INPUT_STATE_ATTRIBUTES_##NAME), \
+        .pVertexAttributeDescriptions = INPUT_STATE_ATTRIBUTES_##NAME                      \
+};                                                                                         \
+uint32_t INPUT_STATE_BINDING_SIZE_##NAME = 0;                                              \
+for (uint32_t i = 0; i < SARRAY_COUNT_OF(INPUT_STATE_ATTRIBUTES_##NAME); i++) {            \
+    INPUT_STATE_ATTRIBUTES_##NAME[i] = (VkVertexInputAttributeDescription) {               \
+        i, 0, INPUT_STATE_ATTRIBUTE_FORMATS_##NAME[i], INPUT_STATE_BINDING_SIZE_##NAME};   \
+    INPUT_STATE_BINDING_SIZE_##NAME +=                                                     \
+        VKUtil_GetFormatGroup(INPUT_STATE_ATTRIBUTE_FORMATS_##NAME[i]).bytes;              \
+} if (sizeof(TYPE) != INPUT_STATE_BINDING_SIZE_##NAME) VK_FATAL_ERROR("Vertex size mismatch for input state " #NAME)
 
 typedef struct {
     VkGraphicsPipelineCreateInfo createInfo;
     VkPipelineMultisampleStateCreateInfo multisampleState;
+    VkPipelineDepthStencilStateCreateInfo depthStencilState;;
     VkPipelineColorBlendStateCreateInfo colorBlendState;
     VkPipelineDynamicStateCreateInfo dynamicState;
-    VkDynamicState dynamicStates[2];
+    VkDynamicState dynamicStates[6];
 } PipelineCreateState;
 
 typedef struct {
@@ -137,6 +149,20 @@ static void VKPipelines_InitPipelineCreateState(PipelineCreateState* state) {
             .sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
             .rasterizationSamples = VK_SAMPLE_COUNT_1_BIT
     };
+    const VkStencilOpState stencilOpState = {
+            .failOp = VK_STENCIL_OP_KEEP,
+            .passOp = VK_STENCIL_OP_KEEP,
+            .compareOp = VK_COMPARE_OP_NOT_EQUAL,
+            .compareMask = 0xFFFFFFFFU,
+            .writeMask = 0U,
+            .reference = CLIP_STENCIL_EXCLUDE_VALUE
+    };
+    state->depthStencilState = (VkPipelineDepthStencilStateCreateInfo) {
+            .sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
+            .stencilTestEnable = VK_FALSE,
+            .front = stencilOpState,
+            .back = stencilOpState
+    };
     state->colorBlendState = (VkPipelineColorBlendStateCreateInfo) {
             .sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
             .logicOpEnable = VK_FALSE,
@@ -157,6 +183,7 @@ static void VKPipelines_InitPipelineCreateState(PipelineCreateState* state) {
             .pViewportState = &viewportState,
             .pRasterizationState = &rasterizationState,
             .pMultisampleState = &state->multisampleState,
+            .pDepthStencilState = &state->depthStencilState,
             .pColorBlendState = &state->colorBlendState,
             .pDynamicState = &state->dynamicState,
             .subpass = 0,
@@ -178,13 +205,40 @@ static const VkPipelineInputAssemblyStateCreateInfo INPUT_ASSEMBLY_STATE_LINE_LI
         .topology = VK_PRIMITIVE_TOPOLOGY_LINE_LIST
 };
 
-const VkPipelineColorBlendAttachmentState BLEND_STATE = {
-        .blendEnable = VK_FALSE,
-        .colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |
-                          VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT
+// Blend states are hard-coded, but can also be loaded dynamically to implement custom composites.
+#define DEF_BLEND(NAME, SRC_COLOR, DST_COLOR, SRC_ALPHA, DST_ALPHA)       \
+{ .blendEnable = VK_TRUE,                                                 \
+  .srcColorBlendFactor = VK_BLEND_FACTOR_ ## SRC_COLOR,                   \
+  .dstColorBlendFactor = VK_BLEND_FACTOR_ ## DST_COLOR,                   \
+  .colorBlendOp = VK_BLEND_OP_ADD,                                        \
+  .srcAlphaBlendFactor = VK_BLEND_FACTOR_ ## SRC_ALPHA,                   \
+  .dstAlphaBlendFactor = VK_BLEND_FACTOR_ ## DST_ALPHA,                   \
+  .alphaBlendOp = VK_BLEND_OP_ADD,                                        \
+  .colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | \
+                    VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT }
+
+
+const VkPipelineColorBlendAttachmentState COMPOSITE_BLEND_STATES[COMPOSITE_COUNT] = {
+        { .blendEnable = VK_FALSE, // LOGIC_XOR
+          .colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |
+                            VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT },
+//               NAME ||      SRC_COLOR       |       DST_COLOR      |      SRC_ALPHA       |       DST_ALPHA      ||
+DEF_BLEND(|     CLEAR |, ZERO                 , ZERO                 , ZERO                 , ZERO                 ),
+DEF_BLEND(|       SRC |, ONE                  , ZERO                 , ONE                  , ZERO                 ),
+DEF_BLEND(|  SRC_OVER |, ONE                  , ONE_MINUS_SRC_ALPHA  , ONE                  , ONE_MINUS_SRC_ALPHA  ),
+DEF_BLEND(|  DST_OVER |, ONE_MINUS_DST_ALPHA  , ONE                  , ONE_MINUS_DST_ALPHA  , ONE                  ),
+DEF_BLEND(|    SRC_IN |, DST_ALPHA            , ZERO                 , DST_ALPHA            , ZERO                 ),
+DEF_BLEND(|    DST_IN |, ZERO                 , SRC_ALPHA            , ZERO                 , SRC_ALPHA            ),
+DEF_BLEND(|   SRC_OUT |, ONE_MINUS_DST_ALPHA  , ZERO                 , ONE_MINUS_DST_ALPHA  , ZERO                 ),
+DEF_BLEND(|   DST_OUT |, ZERO                 , ONE_MINUS_SRC_ALPHA  , ZERO                 , ONE_MINUS_SRC_ALPHA  ),
+DEF_BLEND(|       DST |, ZERO                 , ONE                  , ZERO                 , ONE                  ),
+DEF_BLEND(|  SRC_ATOP |, DST_ALPHA            , ONE_MINUS_SRC_ALPHA  , ZERO                 , ONE                  ),
+DEF_BLEND(|  DST_ATOP |, ONE_MINUS_DST_ALPHA  , SRC_ALPHA            , ONE                  , ZERO                 ),
+DEF_BLEND(|       XOR |, ONE_MINUS_DST_ALPHA  , ONE_MINUS_SRC_ALPHA  , ONE_MINUS_DST_ALPHA  , ONE_MINUS_SRC_ALPHA  ),
 };
 
 static void VKPipelines_DestroyPipelineSet(VKDevice* device, VKPipelineSet* set) {
+    assert(device != NULL);
     if (set == NULL) return;
     for (uint32_t i = 0; i < PIPELINE_COUNT; i++) {
         device->vkDestroyPipeline(device->handle, set->pipelines[i], NULL);
@@ -192,21 +246,48 @@ static void VKPipelines_DestroyPipelineSet(VKDevice* device, VKPipelineSet* set)
     free(set);
 }
 
-static VKPipelineSet* VKPipelines_CreatePipelineSet(VKRenderPassContext* renderPassContext) {
+static VKPipelineSet* VKPipelines_CreatePipelineSet(VKRenderPassContext* renderPassContext, VKPipelineSetDescriptor descriptor) {
     assert(renderPassContext != NULL && renderPassContext->pipelineContext != NULL);
+    assert(descriptor.composite < COMPOSITE_COUNT);
     VKPipelineContext* pipelineContext = renderPassContext->pipelineContext;
 
     VKPipelineSet* set = calloc(1, sizeof(VKPipelineSet));
     VK_RUNTIME_ASSERT(set);
+    set->descriptor = descriptor;
     VKDevice* device = pipelineContext->device;
     VKShaders* shaders = pipelineContext->shaders;
 
     // Setup default pipeline parameters.
     PipelineCreateState base;
     VKPipelines_InitPipelineCreateState(&base);
+    FormatAlias formatAlias = FORMAT_ALIAS_ORIGINAL;
+    FormatGroup formatGroup = VKUtil_GetFormatGroup(renderPassContext->format);
+    if (COMPOSITE_GROUP(descriptor.composite) == LOGIC_COMPOSITE_GROUP) {
+        // Tweak parameters for logic composite. Make sure to draw into UNORM attachment.
+        formatAlias = FORMAT_ALIAS_UNORM;
+        base.colorBlendState.logicOpEnable = VK_TRUE;
+    }
     base.createInfo.layout = pipelineContext->pipelineLayout;
-    base.createInfo.renderPass = renderPassContext->renderPass;
-    base.colorBlendState.pAttachments = &BLEND_STATE;
+    base.createInfo.renderPass = renderPassContext->renderPass[descriptor.stencilMode != STENCIL_MODE_NONE][formatAlias];
+    base.colorBlendState.pAttachments = &COMPOSITE_BLEND_STATES[descriptor.composite];
+    if (device->dynamicBlending)
+        base.dynamicStates[base.dynamicState.dynamicStateCount++] = VK_DYNAMIC_STATE_COLOR_BLEND_EQUATION_EXT;
+    if (device->dynamicLogicOp) {
+        base.dynamicStates[base.dynamicState.dynamicStateCount++] = VK_DYNAMIC_STATE_COLOR_BLEND_ENABLE_EXT;
+        base.dynamicStates[base.dynamicState.dynamicStateCount++] = VK_DYNAMIC_STATE_LOGIC_OP_ENABLE_EXT;
+    }
+    if (descriptor.stencilMode != STENCIL_MODE_NONE && device->dynamicStencil)
+        base.dynamicStates[base.dynamicState.dynamicStateCount++] = VK_DYNAMIC_STATE_STENCIL_TEST_ENABLE_EXT;
+    if (descriptor.stencilMode == STENCIL_MODE_ON) base.depthStencilState.stencilTestEnable = VK_TRUE;
+    VkPipelineRenderingCreateInfoKHR renderingCreateInfo = {
+            .sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR,
+            .viewMask = 0,
+            .colorAttachmentCount = 1,
+            .pColorAttachmentFormats = &formatGroup.aliases[formatAlias],
+            .stencilAttachmentFormat = descriptor.stencilMode == STENCIL_MODE_NONE ?
+                    VK_FORMAT_UNDEFINED : VK_FORMAT_S8_UINT
+    };
+    if (device->dynamicRendering) base.createInfo.pNext = &renderingCreateInfo;
     assert(base.dynamicState.dynamicStateCount <= SARRAY_COUNT_OF(base.dynamicStates));
 
     ShaderStages stages[PIPELINE_COUNT];
@@ -216,46 +297,40 @@ static VKPipelineSet* VKPipelines_CreatePipelineSet(VKRenderPassContext* renderP
         createInfos[i].pStages = stages[i].createInfos;
     }
 
-    static const VkVertexInputAttributeDescription positionAttribute = {
-            .location = 0,
-            .binding = 0,
-            .format = VK_FORMAT_R32G32_SFLOAT,
-            .offset = 0
-    };
-    static const VkVertexInputAttributeDescription texcoordAttribute = {
-            .location = 1,
-            .binding = 0,
-            .format = VK_FORMAT_R32G32_SFLOAT,
-            .offset = sizeof(float) * 2
-    };
+    // Setup plain color pipelines.
+    MAKE_INPUT_STATE(COLOR, VKColorVertex, VK_FORMAT_R32G32_SFLOAT, VK_FORMAT_R32G32B32A32_SFLOAT);
+    createInfos[PIPELINE_DRAW_COLOR].pVertexInputState = createInfos[PIPELINE_FILL_COLOR].pVertexInputState = &INPUT_STATE_COLOR;
+    createInfos[PIPELINE_FILL_COLOR].pInputAssemblyState = &INPUT_ASSEMBLY_STATE_TRIANGLE_LIST;
+    createInfos[PIPELINE_DRAW_COLOR].pInputAssemblyState = &INPUT_ASSEMBLY_STATE_LINE_LIST;
+    stages[PIPELINE_DRAW_COLOR] = stages[PIPELINE_FILL_COLOR] = (ShaderStages) {{ shaders->color_vert, shaders->color_frag }};
 
-    { // Setup plain color pipelines.
-        MAKE_INPUT_STATE(VKVertex, positionAttribute);
-        createInfos[PIPELINE_DRAW_COLOR].pVertexInputState = createInfos[PIPELINE_FILL_COLOR].pVertexInputState = &inputState;
-        createInfos[PIPELINE_FILL_COLOR].pInputAssemblyState = &INPUT_ASSEMBLY_STATE_TRIANGLE_LIST;
-        createInfos[PIPELINE_DRAW_COLOR].pInputAssemblyState = &INPUT_ASSEMBLY_STATE_LINE_LIST;
-        stages[PIPELINE_DRAW_COLOR] = stages[PIPELINE_FILL_COLOR] = (ShaderStages) {{ shaders->color_vert, shaders->color_frag }};
-    }
+    // Setup blit pipeline.
+    MAKE_INPUT_STATE(BLIT, VKTxVertex, VK_FORMAT_R32G32_SFLOAT, VK_FORMAT_R32G32_SFLOAT);
+    createInfos[PIPELINE_BLIT].pVertexInputState = &INPUT_STATE_BLIT;
+    createInfos[PIPELINE_BLIT].pInputAssemblyState = &INPUT_ASSEMBLY_STATE_TRIANGLE_STRIP;
+    createInfos[PIPELINE_BLIT].layout = pipelineContext->texturePipelineLayout;
+    stages[PIPELINE_BLIT] = (ShaderStages) {{ shaders->blit_vert, shaders->blit_frag }};
 
-    { // Setup texture pipeline.
-        MAKE_INPUT_STATE(VKTxVertex, positionAttribute, texcoordAttribute);
-        createInfos[PIPELINE_BLIT].pVertexInputState = &inputState;
-        createInfos[PIPELINE_BLIT].pInputAssemblyState = &INPUT_ASSEMBLY_STATE_TRIANGLE_STRIP;
-        createInfos[PIPELINE_BLIT].layout = pipelineContext->texturePipelineLayout;
-        stages[PIPELINE_BLIT] = (ShaderStages) {{ shaders->blit_vert, shaders->blit_frag }};
-    }
+    // Setup plain color mask fill pipeline.
+    MAKE_INPUT_STATE(MASK_FILL_COLOR, VKMaskFillColorVertex, VK_FORMAT_R32G32B32A32_SINT, VK_FORMAT_R32G32B32A32_SFLOAT);
+    createInfos[PIPELINE_MASK_FILL_COLOR].pVertexInputState = &INPUT_STATE_MASK_FILL_COLOR;
+    createInfos[PIPELINE_MASK_FILL_COLOR].pInputAssemblyState = &INPUT_ASSEMBLY_STATE_TRIANGLE_LIST;
+    createInfos[PIPELINE_MASK_FILL_COLOR].layout = pipelineContext->maskFillPipelineLayout;
+    stages[PIPELINE_MASK_FILL_COLOR] = (ShaderStages) {{ shaders->mask_fill_color_vert, shaders->mask_fill_color_frag }};
 
     // Create pipelines.
     // TODO pipeline cache
     VK_IF_ERROR(device->vkCreateGraphicsPipelines(device->handle, VK_NULL_HANDLE, PIPELINE_COUNT,
                                                   createInfos, NULL, set->pipelines)) VK_UNHANDLED_ERROR();
-    J2dRlsTraceLn(J2D_TRACE_INFO, "VKPipelines_CreatePipelineSet");
+    J2dRlsTraceLn2(J2D_TRACE_INFO, "VKPipelines_CreatePipelineSet: composite=%d, stencilMode=%d",
+                   descriptor.composite, descriptor.stencilMode);
     return set;
 }
 
-static VkResult VKPipelines_InitRenderPass(VKDevice* device, VKRenderPassContext* renderPassContext) {
-    VkAttachmentDescription colorAttachment = {
-            .format = renderPassContext->format,
+static VkResult VKPipelines_InitRenderPasses(VKDevice* device, VKRenderPassContext* renderPassContext) {
+    assert(device != NULL && renderPassContext != NULL);
+    if (device->dynamicRendering) return VK_SUCCESS;
+    VkAttachmentDescription attachments[] = {{
             .samples = VK_SAMPLE_COUNT_1_BIT,
             .loadOp = VK_ATTACHMENT_LOAD_OP_LOAD,
             .storeOp = VK_ATTACHMENT_STORE_OP_STORE,
@@ -263,44 +338,74 @@ static VkResult VKPipelines_InitRenderPass(VKDevice* device, VKRenderPassContext
             .stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
             .initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
             .finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
-    };
+    }, {
+            .format = VK_FORMAT_S8_UINT,
+            .samples = VK_SAMPLE_COUNT_1_BIT,
+            .loadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE,
+            .storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE,
+            .stencilLoadOp = VK_ATTACHMENT_LOAD_OP_LOAD,
+            .stencilStoreOp = VK_ATTACHMENT_STORE_OP_STORE,
+            .initialLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
+            .finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL
+    }};
     VkAttachmentReference colorReference = {
             .attachment = 0,
             .layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
     };
+    VkAttachmentReference stencilReference = {
+            .attachment = 1,
+            .layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL
+    };
     VkSubpassDescription subpassDescription = {
             .pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS,
             .colorAttachmentCount = 1,
             .pColorAttachments = &colorReference
     };
-    // TODO this is probably not needed?
-//    // Subpass dependencies for layout transitions
-//    VkSubpassDependency dependency = {
-//            .srcSubpass = VK_SUBPASS_EXTERNAL,
-//            .dstSubpass = 0,
-//            .srcStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
-//            .dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
-//            .srcAccessMask = 0,
-//            .dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT
-//    };
     VkRenderPassCreateInfo createInfo = {
             .sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO,
             .attachmentCount = 1,
-            .pAttachments = &colorAttachment,
+            .pAttachments = attachments,
             .subpassCount = 1,
             .pSubpasses = &subpassDescription,
             .dependencyCount = 0,
             .pDependencies = NULL
     };
-    return device->vkCreateRenderPass(device->handle, &createInfo, NULL, &renderPassContext->renderPass);
+    FormatGroup formatGroup = VKUtil_GetFormatGroup(renderPassContext->format);
+    for (uint32_t i = 0; i < 2; i++) {
+        if (i == 1) {
+            createInfo.attachmentCount = 2;
+            subpassDescription.pDepthStencilAttachment = &stencilReference;
+        }
+        SET_FORMAT_ALIASED_HANDLE(renderPassContext->renderPass[i], formatGroup.aliases, alias) {
+            attachments[0].format = formatGroup.aliases[alias];
+            VkResult result = device->vkCreateRenderPass(device->handle, &createInfo, NULL, &renderPassContext->renderPass[i][alias]);
+            VK_IF_ERROR(result) return result;
+        }
+    }
+    return VK_SUCCESS;
 }
 
 static void VKPipelines_DestroyRenderPassContext(VKRenderPassContext* renderPassContext) {
     if (renderPassContext == NULL) return;
     VKDevice* device = renderPassContext->pipelineContext->device;
     assert(device != NULL);
-    VKPipelines_DestroyPipelineSet(device, renderPassContext->pipelineSet);
-    device->vkDestroyRenderPass(device->handle, renderPassContext->renderPass, NULL);
+    for (uint32_t i = 0; i < ARRAY_SIZE(renderPassContext->pipelineSets); i++) {
+        VKPipelineSet* set = renderPassContext->pipelineSets[i];
+        while (set != NULL) {
+            VKPipelineSet* s = set;
+            set = set->next;
+            VKPipelines_DestroyPipelineSet(device, s);
+        }
+    }
+    ARRAY_FREE(renderPassContext->pipelineSets);
+    SET_FORMAT_ALIASED_HANDLE(renderPassContext->clipPipeline, renderPassContext->clipPipeline, alias)
+        device->vkDestroyPipeline(device->handle, renderPassContext->clipPipeline[alias], NULL);
+    for (uint32_t i = 0; i < 2; i++) {
+        SET_FORMAT_ALIASED_HANDLE(renderPassContext->renderPass[i], renderPassContext->renderPass[i], alias)
+            device->vkDestroyRenderPass(device->handle, renderPassContext->renderPass[i][alias], NULL);
+    }
+    J2dRlsTraceLn2(J2D_TRACE_INFO, "VKPipelines_DestroyRenderPassContext(%p): format=%d",
+                   renderPassContext, renderPassContext->format);
     free(renderPassContext);
 }
 
@@ -311,11 +416,67 @@ static VKRenderPassContext* VKPipelines_CreateRenderPassContext(VKPipelineContex
     renderPassContext->pipelineContext = pipelineContext;
     renderPassContext->format = format;
 
-    VK_IF_ERROR(VKPipelines_InitRenderPass(pipelineContext->device, renderPassContext)) {
+    VK_IF_ERROR(VKPipelines_InitRenderPasses(pipelineContext->device, renderPassContext)) {
         VKPipelines_DestroyRenderPassContext(renderPassContext);
         return NULL;
     }
 
+    // Setup default pipeline parameters.
+    const VkPipelineColorBlendAttachmentState NO_COLOR_ATTACHMENT = {
+            .blendEnable = VK_FALSE,
+            .colorWriteMask = 0
+    };
+    PipelineCreateState base;
+    VKPipelines_InitPipelineCreateState(&base);
+    base.createInfo.layout = pipelineContext->pipelineLayout;
+    base.colorBlendState.pAttachments = &NO_COLOR_ATTACHMENT;
+    base.depthStencilState.stencilTestEnable = VK_TRUE;
+    VkPipelineRenderingCreateInfoKHR renderingCreateInfo = {
+            .sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO_KHR,
+            .viewMask = 0,
+            .colorAttachmentCount = 1,
+            .pColorAttachmentFormats = &renderPassContext->format,
+            .stencilAttachmentFormat = VK_FORMAT_S8_UINT
+    };
+    if (pipelineContext->device->dynamicRendering) base.createInfo.pNext = &renderingCreateInfo;
+    assert(base.dynamicState.dynamicStateCount <= SARRAY_COUNT_OF(base.dynamicStates));
+
+    // Setup clip pipeline.
+    MAKE_INPUT_STATE(CLIP, VKIntVertex, VK_FORMAT_R32G32_SINT);
+    base.createInfo.pVertexInputState = &INPUT_STATE_CLIP;
+    base.createInfo.pInputAssemblyState = &INPUT_ASSEMBLY_STATE_TRIANGLE_LIST;
+    const VkStencilOpState CLIP_STENCIL_OP = {
+            .failOp = VK_STENCIL_OP_REPLACE,
+            .passOp = VK_STENCIL_OP_REPLACE,
+            .compareOp = VK_COMPARE_OP_NEVER,
+            .compareMask = 0U,
+            .writeMask = 0xFFFFFFFFU,
+            .reference = CLIP_STENCIL_INCLUDE_VALUE
+    };
+    const VkPipelineDepthStencilStateCreateInfo CLIP_STENCIL_STATE = {
+            .sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
+            .stencilTestEnable = VK_TRUE,
+            .front = CLIP_STENCIL_OP,
+            .back = CLIP_STENCIL_OP
+    };
+    base.createInfo.pDepthStencilState = &CLIP_STENCIL_STATE;
+    base.createInfo.stageCount = 1;
+    base.createInfo.pStages = &pipelineContext->shaders->clip_vert;
+
+    VkGraphicsPipelineCreateInfo createInfos FORMAT_ALIASED;
+    for (FormatAlias alias = FORMAT_ALIAS_ORIGINAL; alias <= FORMAT_ALIAS_UNORM; alias++) {
+        createInfos[alias] = base.createInfo;
+        createInfos[alias].renderPass = renderPassContext->renderPass[1][alias];
+    }
+    VkBool32 hasFormatAliasing = renderPassContext->renderPass[1][FORMAT_ALIAS_ORIGINAL] != renderPassContext->renderPass[1][FORMAT_ALIAS_UNORM];
+
+    // Create pipelines.
+    // TODO pipeline cache
+    VK_IF_ERROR(pipelineContext->device->vkCreateGraphicsPipelines(
+            pipelineContext->device->handle, VK_NULL_HANDLE, hasFormatAliasing ? 2 : 1,
+            createInfos, NULL, renderPassContext->clipPipeline)) VK_UNHANDLED_ERROR();
+    if (!hasFormatAliasing) renderPassContext->clipPipeline[FORMAT_ALIAS_UNORM] = renderPassContext->clipPipeline[FORMAT_ALIAS_ORIGINAL];
+    J2dRlsTraceLn2(J2D_TRACE_INFO, "VKPipelines_CreateRenderPassContext(%p): format=%d", renderPassContext, format);
     return renderPassContext;
 }
 
@@ -327,7 +488,7 @@ static VkResult VKPipelines_InitPipelineLayouts(VKDevice* device, VKPipelineCont
     VkPushConstantRange pushConstantRange = {
             .stageFlags = VK_SHADER_STAGE_VERTEX_BIT,
             .offset = 0,
-            .size = sizeof(float) * 4
+            .size = sizeof(float) * 2
     };
     VkPipelineLayoutCreateInfo createInfo = {
             .sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
@@ -358,6 +519,26 @@ static VkResult VKPipelines_InitPipelineLayouts(VKDevice* device, VKPipelineCont
     result = device->vkCreatePipelineLayout(device->handle, &createInfo, NULL, &pipelines->texturePipelineLayout);
     VK_IF_ERROR(result) return result;
 
+    VkDescriptorSetLayoutBinding maskBufferLayoutBinding = {
+            .binding = 0,
+            .descriptorType = VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER,
+            .descriptorCount = 1,
+            .stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT,
+            .pImmutableSamplers = NULL
+    };
+    VkDescriptorSetLayoutCreateInfo descriptorSetLayoutCreateInfo = {
+            .sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
+            .bindingCount = 1,
+            .pBindings = &maskBufferLayoutBinding
+    };
+    result = device->vkCreateDescriptorSetLayout(device->handle, &descriptorSetLayoutCreateInfo, NULL, &pipelines->maskFillDescriptorSetLayout);
+    VK_IF_ERROR(result) return result;
+
+    createInfo.setLayoutCount = 1;
+    createInfo.pSetLayouts = &pipelines->maskFillDescriptorSetLayout;
+    result = device->vkCreatePipelineLayout(device->handle, &createInfo, NULL, &pipelines->maskFillPipelineLayout);
+    VK_IF_ERROR(result) return result;
+
     return VK_SUCCESS;
 }
 
@@ -392,6 +573,7 @@ VKPipelineContext* VKPipelines_CreateContext(VKDevice* device) {
         return NULL;
     }
 
+    J2dRlsTraceLn1(J2D_TRACE_INFO, "VKPipelines_CreateContext(%p)", pipelineContext);
     return pipelineContext;
 }
 
@@ -412,13 +594,16 @@ void VKPipelines_DestroyContext(VKPipelineContext* pipelineContext) {
     device->vkDestroyPipelineLayout(device->handle, pipelineContext->texturePipelineLayout, NULL);
     device->vkDestroyDescriptorSetLayout(device->handle, pipelineContext->textureDescriptorSetLayout, NULL);
 
+    J2dRlsTraceLn1(J2D_TRACE_INFO, "VKPipelines_DestroyContext(%p)", pipelineContext);
     free(pipelineContext);
 }
 
 VKRenderPassContext* VKPipelines_GetRenderPassContext(VKPipelineContext* pipelineContext, VkFormat format) {
     assert(pipelineContext != NULL && pipelineContext->device != NULL);
     for (uint32_t i = 0; i < ARRAY_SIZE(pipelineContext->renderPassContexts); i++) {
-        if (pipelineContext->renderPassContexts[i]->format == format) return pipelineContext->renderPassContexts[i];
+        if (pipelineContext->renderPassContexts[i]->format == format) {
+            return pipelineContext->renderPassContexts[i];
+        }
     }
     // Not found, create.
     VKRenderPassContext* renderPassContext = VKPipelines_CreateRenderPassContext(pipelineContext, format);
@@ -426,9 +611,118 @@ VKRenderPassContext* VKPipelines_GetRenderPassContext(VKPipelineContext* pipelin
     return renderPassContext;
 }
 
-VkPipeline VKPipelines_GetPipeline(VKRenderPassContext* renderPassContext, VKPipeline pipeline) {
-    if (renderPassContext->pipelineSet == NULL) {
-        renderPassContext->pipelineSet = VKPipelines_CreatePipelineSet(renderPassContext);
-    }
-    return renderPassContext->pipelineSet->pipelines[pipeline];
+inline void hash(uint32_t* result, int i) { // Good for hashing enums.
+    uint32_t x = (uint32_t) i;
+    x = ((x >> 16U) ^ x) * 0x45d9f3bU;
+    x = ((x >> 16U) ^ x) * 0x45d9f3bU;
+    x =  (x >> 16U) ^ x;
+    *result ^= x + 0x9e3779b9U + (*result << 6U) + (*result >> 2U);
+}
+inline uint32_t pipelineSetDescriptorHash(VKPipelineSetDescriptor* d) {
+    uint32_t h = 0U;
+    hash(&h, d->stencilMode);
+    hash(&h, d->composite);
+    return h;
+}
+inline VkBool32 pipelineSetDescriptorEquals(VKPipelineSetDescriptor* a, VKPipelineSetDescriptor* b) {
+    return a->stencilMode == b->stencilMode &&
+           a->composite == b->composite;
+}
+
+VkPipeline VKPipelines_GetPipeline(VKRenderPassContext* renderPassContext, VKPipelineSetDescriptor descriptor, VKPipeline pipeline) {
+    assert(renderPassContext != NULL && renderPassContext->pipelineContext != NULL);
+    assert(pipeline < PIPELINE_COUNT); // We could append custom pipelines after that index.
+
+    // Depending on availability of certain dynamic states, we can reduce number of pipeline permutations.
+    // We do this by amending the pipeline set descriptor here.
+    VKDevice* device = renderPassContext->pipelineContext->device;
+    assert(device != NULL);
+    VKCompositeMode compositeGroup = COMPOSITE_GROUP(descriptor.composite);
+    if (device->dynamicBlending && compositeGroup == ALPHA_COMPOSITE_GROUP)
+        descriptor.composite = ALPHA_COMPOSITE_SRC_OVER; // Dynamic blending: all alpha composites are combined.
+    if (device->dynamicLogicOp && compositeGroup == LOGIC_COMPOSITE_GROUP &&
+        renderPassContext->renderPass[0][FORMAT_ALIAS_ORIGINAL] == renderPassContext->renderPass[0][FORMAT_ALIAS_UNORM])
+        descriptor.composite = ALPHA_COMPOSITE_SRC_OVER; // Dynamic logicOp: all composites are combined.
+    if (device->dynamicStencil && descriptor.stencilMode != STENCIL_MODE_NONE)
+        descriptor.stencilMode = STENCIL_MODE_ON; // Dynamic stencil: stencil test on/off combined.
+
+    // Find pipeline set in hash table.
+    VKPipelineSet* set = NULL;
+    uint32_t lookupDepth = 0xFFFFFFFFU;
+    uint32_t hash = pipelineSetDescriptorHash(&descriptor);
+    if (renderPassContext->pipelineSets != NULL) {
+        VKPipelineSet* bucket = renderPassContext->pipelineSets[hash % ARRAY_SIZE(renderPassContext->pipelineSets)];
+        lookupDepth = 0;
+        while (bucket != NULL) {
+            if (pipelineSetDescriptorEquals(&descriptor, &bucket->descriptor)) {
+                set = bucket;
+                break;
+            } else {
+                bucket = bucket->next;
+                lookupDepth++;
+            }
+        }
+    }
+
+    // If lookup was too deep, rehash.
+    const uint32_t REHASH_THRESHOLD = 5;
+    if (lookupDepth >= REHASH_THRESHOLD) {
+        static const uint32_t TABLE_SIZE_PRIMES[] = { 53U, 97U, 193U, 389U, 769U, 1543U, 3079U, 6151U, 12289U, 24593U,
+                                                      49157U, 98317U, 196613U, 393241U, 786433U, 1572869U, 3145739U,
+                                                      6291469U, 12582917U, 25165843U, 50331653U, 100663319U,
+                                                      201326611U, 402653189U, 805306457U, 1610612741U };
+        size_t size = ARRAY_SIZE(renderPassContext->pipelineSets);
+        for (uint32_t i = 0;; i++) {
+            assert(i < SARRAY_COUNT_OF(TABLE_SIZE_PRIMES));
+            if (TABLE_SIZE_PRIMES[i] > size) {
+                size = TABLE_SIZE_PRIMES[i];
+                break;
+            }
+        }
+        VKPipelineSet** t = NULL;
+        ARRAY_RESIZE(t, size);
+        for (uint32_t i = 0; i < size; i++) t[i] = NULL;
+        for (uint32_t i = 0; i < ARRAY_SIZE(renderPassContext->pipelineSets); i++) {
+            VKPipelineSet* s = renderPassContext->pipelineSets[i];
+            while (s != NULL) {
+                VKPipelineSet* next = s->next;
+                VKPipelineSet** bucket = &t[pipelineSetDescriptorHash(&s->descriptor) % size];
+                s->next = *bucket;
+                *bucket = s;
+                s = next;
+            }
+        }
+        ARRAY_FREE(renderPassContext->pipelineSets);
+        renderPassContext->pipelineSets = t;
+    }
+
+    // If pipeline set was not found, create and insert.
+    if (set == NULL) {
+        set = VKPipelines_CreatePipelineSet(renderPassContext, descriptor);
+        VKPipelineSet** bucket = &renderPassContext->pipelineSets[hash % ARRAY_SIZE(renderPassContext->pipelineSets)];
+        set->next = *bucket;
+        *bucket = set;
+#ifdef DEBUG
+        lookupDepth = REHASH_THRESHOLD;
+#endif
+    }
+
+#ifdef DEBUG
+    if (lookupDepth >= REHASH_THRESHOLD) {
+        J2dTraceLn1(J2D_TRACE_VERBOSE, "VKPipelines_GetPipeline: hash table updated, buckets=%d",
+                    ARRAY_SIZE(renderPassContext->pipelineSets));
+        uint32_t minDepth = 0xFFFFFFFFU, maxDepth = 0, totalSets = 0;
+        J2dTrace(J2D_TRACE_VERBOSE, "   ");
+        for (uint32_t i = 0; i < ARRAY_SIZE(renderPassContext->pipelineSets); i++) {
+            uint32_t depth = 0;
+            for (VKPipelineSet* s = renderPassContext->pipelineSets[i]; s != NULL; s = s ->next) depth++;
+            J2dTrace1(J2D_TRACE_VERBOSE2, " %d", depth);
+            if (minDepth > depth) minDepth = depth;
+            if (maxDepth < depth) maxDepth = depth;
+            totalSets += depth;
+        }
+        J2dTrace3(J2D_TRACE_VERBOSE, " | minDepth=%d, maxDepth=%d, totalSets=%d\n", minDepth, maxDepth, totalSets);
+    }
+#endif
+    return set->pipelines[pipeline];
 }

src/java.desktop/share/native/common/java2d/vulkan/VKPipelines.h

@@ -24,33 +24,75 @@
 #ifndef VKPipelines_h_Included
 #define VKPipelines_h_Included
 
+#include "java_awt_AlphaComposite.h"
 #include "VKTypes.h"
 
-typedef struct VKShaders VKShaders;
-typedef struct VKPipelineSet VKPipelineSet;
+#define CLIP_STENCIL_INCLUDE_VALUE 0x80U
+#define CLIP_STENCIL_EXCLUDE_VALUE 0U
 
 /**
- * All pipeline types, use these to index into VKPipelineSet.pipelines.
+ * All pipeline types.
  */
 typedef enum {
-    PIPELINE_FILL_COLOR = 0,
-    PIPELINE_DRAW_COLOR = 1,
-    PIPELINE_BLIT = 2,
-    PIPELINE_COUNT = 3
+    PIPELINE_FILL_COLOR      = 0,
+    PIPELINE_DRAW_COLOR      = 1,
+    PIPELINE_BLIT            = 2,
+    PIPELINE_MASK_FILL_COLOR = 3,
+    PIPELINE_COUNT           = 4,
+    NO_PIPELINE              = 0x7FFFFFFF
 } VKPipeline;
 
+typedef enum {
+    STENCIL_MODE_NONE = 0, // No stencil attachment.
+    STENCIL_MODE_OFF  = 1, // Has stencil attachment, stencil test disabled.
+    STENCIL_MODE_ON   = 2  // Has stencil attachment, stencil test enabled.
+} VKStencilMode;
+
+/**
+ * There are two groups of composite modes:
+ * - Logic composite - using logicOp.
+ * - Alpha compisite - using blending.
+ */
+typedef enum {
+    LOGIC_COMPOSITE_XOR      = 0,
+    LOGIC_COMPOSITE_GROUP    = LOGIC_COMPOSITE_XOR,
+    ALPHA_COMPOSITE_CLEAR    = java_awt_AlphaComposite_CLEAR,
+    ALPHA_COMPOSITE_SRC      = java_awt_AlphaComposite_SRC,
+    ALPHA_COMPOSITE_DST      = java_awt_AlphaComposite_DST,
+    ALPHA_COMPOSITE_SRC_OVER = java_awt_AlphaComposite_SRC_OVER,
+    ALPHA_COMPOSITE_DST_OVER = java_awt_AlphaComposite_DST_OVER,
+    ALPHA_COMPOSITE_SRC_IN   = java_awt_AlphaComposite_SRC_IN,
+    ALPHA_COMPOSITE_DST_IN   = java_awt_AlphaComposite_DST_IN,
+    ALPHA_COMPOSITE_SRC_OUT  = java_awt_AlphaComposite_SRC_OUT,
+    ALPHA_COMPOSITE_DST_OUT  = java_awt_AlphaComposite_DST_OUT,
+    ALPHA_COMPOSITE_SRC_ATOP = java_awt_AlphaComposite_SRC_ATOP,
+    ALPHA_COMPOSITE_DST_ATOP = java_awt_AlphaComposite_DST_ATOP,
+    ALPHA_COMPOSITE_XOR      = java_awt_AlphaComposite_XOR,
+    ALPHA_COMPOSITE_GROUP    = ALPHA_COMPOSITE_XOR,
+    COMPOSITE_COUNT          = ALPHA_COMPOSITE_GROUP + 1,
+    NO_COMPOSITE             = 0x7FFFFFFF
+} VKCompositeMode;
+#define COMPOSITE_GROUP(COMPOSITE) (                               \
+    (COMPOSITE) <= LOGIC_COMPOSITE_GROUP ? LOGIC_COMPOSITE_GROUP : \
+    (COMPOSITE) <= ALPHA_COMPOSITE_GROUP ? ALPHA_COMPOSITE_GROUP : \
+    NO_COMPOSITE )
+
+extern const VkPipelineColorBlendAttachmentState COMPOSITE_BLEND_STATES[COMPOSITE_COUNT];
+
 /**
  * Global pipeline context.
  */
 struct VKPipelineContext {
     VKDevice*             device;
     VkPipelineLayout      pipelineLayout;
-    VkPipelineLayout      texturePipelineLayout;
     VkDescriptorSetLayout textureDescriptorSetLayout;
+    VkPipelineLayout      texturePipelineLayout;
+    VkDescriptorSetLayout maskFillDescriptorSetLayout;
+    VkPipelineLayout      maskFillPipelineLayout;
 
     VkSampler             linearRepeatSampler;
 
-    VKShaders*            shaders;
+    struct VKShaders*     shaders;
     VKRenderPassContext** renderPassContexts;
 };
 
@@ -58,25 +100,45 @@ struct VKPipelineContext {
  * Per-format context.
  */
 struct VKRenderPassContext {
-    VKPipelineContext* pipelineContext;
-    VkFormat           format;
-    VkRenderPass       renderPass;
-    VKPipelineSet*     pipelineSet; // TODO we will need a real hash map for this in the future.
+    VKPipelineContext*     pipelineContext;
+    VkFormat               format;
+    VkRenderPass           renderPass[2] FORMAT_ALIASED; // Color-only and color+stencil. Only when dynamicRendering=OFF.
+    VkPipeline             clipPipeline FORMAT_ALIASED;
+    struct VKPipelineSet** pipelineSets;
 };
 
+/**
+ * All features describing a pipeline set.
+ * When adding new fields, update hash and comparison in VKPipelines_GetPipeline.
+ */
+typedef struct {
+    VKStencilMode   stencilMode;
+    VKCompositeMode composite;
+} VKPipelineSetDescriptor;
+
+typedef struct {
+    int x, y;
+} VKIntVertex;
+
 typedef struct {
     float x, y;
-} VKVertex;
+    Color color;
+} VKColorVertex;
 
 typedef struct {
     float px, py;
     float u, v;
 } VKTxVertex;
 
+typedef struct {
+    int x, y, maskOffset, maskScanline;
+    Color color;
+} VKMaskFillColorVertex;
+
 VKPipelineContext* VKPipelines_CreateContext(VKDevice* device);
 void VKPipelines_DestroyContext(VKPipelineContext* pipelines);
 
 VKRenderPassContext* VKPipelines_GetRenderPassContext(VKPipelineContext* pipelineContext, VkFormat format);
-VkPipeline VKPipelines_GetPipeline(VKRenderPassContext* renderPassContext, VKPipeline pipeline);
+VkPipeline VKPipelines_GetPipeline(VKRenderPassContext* renderPassContext, VKPipelineSetDescriptor descriptor, VKPipeline pipeline);
 
 #endif //VKPipelines_h_Included

src/java.desktop/share/native/common/java2d/vulkan/VKRenderQueue.c

@@ -26,13 +26,15 @@
 
 #ifndef HEADLESS
 
+#include "sun_font_StrikeCache.h"
 #include "sun_java2d_pipe_BufferedOpCodes.h"
 #include "sun_java2d_pipe_BufferedRenderPipe.h"
 #include "sun_java2d_pipe_BufferedTextPipe.h"
+#include "sun_java2d_vulkan_VKBlitLoops.h"
+#include "fontscalerdefs.h"
 #include "Trace.h"
 #include "jlong.h"
 #include "VKBase.h"
-#include "VKBlitLoops.h"
 #include "VKSurfaceData.h"
 #include "VKRenderer.h"
 #include "VKUtil.h"
@@ -91,9 +93,24 @@
 #define OFFSET_XFORM   sun_java2d_vulkan_VKBlitLoops_OFFSET_XFORM
 #define OFFSET_ISOBLIT sun_java2d_vulkan_VKBlitLoops_OFFSET_ISOBLIT
 
+#define NO_CLIP ((VkRect2D) {{0, 0}, {0x7FFFFFFFU, 0x7FFFFFFFU}})
+
 // Rendering context is only accessed from VKRenderQueue_flushBuffer,
 // which is only called from queue flusher thread, no need for synchronization.
-static VKRenderingContext context = {};
+static VKRenderingContext context = {
+        .surface = NULL,
+        .color = {},
+        .composite = ALPHA_COMPOSITE_SRC_OVER,
+        .extraAlpha = 1.0f,
+        .clipModCount = 1,
+        .clipRect = NO_CLIP,
+        .clipSpanVertices = NULL
+};
+// We keep this color separately from context.color,
+// because we need consistent state when switching between XOR and alpha composite modes.
+// This variable holds last value set by SET_COLOR, while context.color holds color,
+// currently used for drawing, which may have also been provided by SET_XOR_COMPOSITE.
+CorrectedColor color;
 
 JNIEXPORT void JNICALL Java_sun_java2d_vulkan_VKRenderQueue_flushBuffer
     (JNIEnv *env, jobject oglrq, jlong buf, jint limit)
@@ -144,6 +161,7 @@ JNIEXPORT void JNICALL Java_sun_java2d_vulkan_VKRenderQueue_flushBuffer
                 J2dRlsTraceLn4(J2D_TRACE_VERBOSE,
                             "VKRenderQueue_flushBuffer: DRAW_RECT(%d, %d, %d, %d)",
                             x, y, w, h);
+                VKRenderer_RenderRect(&context, PIPELINE_DRAW_COLOR, x, y, w, h);
             }
             break;
         case sun_java2d_pipe_BufferedOpCodes_DRAW_POLY:
@@ -213,7 +231,7 @@ JNIEXPORT void JNICALL Java_sun_java2d_vulkan_VKRenderQueue_flushBuffer
                 jint h = NEXT_INT(b);
                 J2dRlsTraceLn4(J2D_TRACE_VERBOSE,
                     "VKRenderQueue_flushBuffer: FILL_RECT(%d, %d, %d, %d)", x, y, w, h);
-                VKRenderer_FillRect(&context, x, y, w, h);
+                VKRenderer_RenderRect(&context, PIPELINE_FILL_COLOR, x, y, w, h);
             }
             break;
         case sun_java2d_pipe_BufferedOpCodes_FILL_SPANS:
@@ -250,6 +268,8 @@ JNIEXPORT void JNICALL Java_sun_java2d_vulkan_VKRenderQueue_flushBuffer
                 J2dRlsTraceLn6(J2D_TRACE_VERBOSE,
                     "VKRenderQueue_flushBuffer: FILL_AAPARALLELOGRAM(%f, %f, %f, %f, %f, %f)",
                     x11, y11, dx21, dy21, dx12, dy12);
+                // TODO this is not AA!
+                VKRenderer_RenderParallelogram(&context, PIPELINE_FILL_COLOR, x11, y11, dx21, dy21, dx12, dy12);
             }
             break;
 
@@ -279,6 +299,25 @@ JNIEXPORT void JNICALL Java_sun_java2d_vulkan_VKRenderQueue_flushBuffer
                     bytesPerGlyph = BYTES_PER_GLYPH_IMAGE;
                 }
                 J2dRlsTraceLn(J2D_TRACE_VERBOSE, "VKRenderQueue_flushBuffer: DRAW_GLYPH_LIST");
+                // TODO this is a quick and dirty implementation of greyscale-AA text rendering over MASK_FILL. Need to do better.
+                jfloat glyphx, glyphy;
+                for (int i = 0; i < numGlyphs; i++) {
+                    GlyphInfo *ginfo = (GlyphInfo *)jlong_to_ptr(NEXT_LONG(images));
+                    if (usePositions) {
+                        jfloat posx = NEXT_FLOAT(positions);
+                        jfloat posy = NEXT_FLOAT(positions);
+                        glyphx = glyphListOrigX + posx + ginfo->topLeftX;
+                        glyphy = glyphListOrigY + posy + ginfo->topLeftY;
+                    } else {
+                        glyphx = glyphListOrigX + ginfo->topLeftX;
+                        glyphy = glyphListOrigY + ginfo->topLeftY;
+                        glyphListOrigX += ginfo->advanceX;
+                        glyphListOrigY += ginfo->advanceY;
+                    }
+                    if (ginfo->format != sun_font_StrikeCache_PIXEL_FORMAT_GREYSCALE) continue;
+                    if (ginfo->height*ginfo->rowBytes == 0) continue;
+                    VKRenderer_MaskFill(&context, (int) glyphx, (int) glyphy, ginfo->width, ginfo->height, 0, ginfo->rowBytes, ginfo->height*ginfo->rowBytes, ginfo->image);
+                }
                 SKIP_BYTES(b, numGlyphs * bytesPerGlyph);
             }
             break;
@@ -319,25 +358,7 @@ JNIEXPORT void JNICALL Java_sun_java2d_vulkan_VKRenderQueue_flushBuffer
                                                     OFFSET_XFORM);
                 jboolean isoblit  = EXTRACT_BOOLEAN(packedParams,
                                                     OFFSET_ISOBLIT);
-                if (isoblit) {
-                    VKBlitLoops_IsoBlit(env, &context, pSrc, pDst,
-                                         xform, hint, texture,
-                                         sx1, sy1, sx2, sy2,
-                                         dx1, dy1, dx2, dy2);
-                } else {
-                    jint srctype = EXTRACT_BYTE(packedParams, OFFSET_SRCTYPE);
-                    VKBlitLoops_Blit(env, &context, pSrc, pDst,
-                                      xform, hint, srctype, texture,
-                                      sx1, sy1, sx2, sy2,
-                                      dx1, dy1, dx2, dy2);
-                }
-
-                break;
-                J2dRlsTraceLn8(J2D_TRACE_VERBOSE, "VKRenderQueue_flushBuffer: BLIT (%d %d %d %d) -> (%f %f %f %f) ",
-                               sx1, sy1, sx2, sy2, dx1, dy1, dx2, dy2)
-                J2dRlsTraceLn4(J2D_TRACE_VERBOSE, "VKRenderQueue_flushBuffer: BLIT texture=%d rtt=%d xform=%d isoblit=%d",
-                               texture, rtt, xform, isoblit)
-
+                J2dRlsTraceLn(J2D_TRACE_VERBOSE, "VKRenderQueue_flushBuffer: BLIT");
             }
             break;
         case sun_java2d_pipe_BufferedOpCodes_SURFACE_TO_SW_BLIT:
@@ -364,7 +385,10 @@ JNIEXPORT void JNICALL Java_sun_java2d_vulkan_VKRenderQueue_flushBuffer
                 jint maskscan = NEXT_INT(b);
                 jint masklen  = NEXT_INT(b);
                 unsigned char *pMask = (masklen > 0) ? b : NULL;
-                J2dRlsTraceLn(J2D_TRACE_VERBOSE, "VKRenderQueue_flushBuffer: MASK_FILL");
+                J2dRlsTraceLn7(J2D_TRACE_VERBOSE,
+                               "VKRenderQueue_flushBuffer: MASK_FILL(%d, %d, %dx%d, maskoff=%d, maskscan=%d, masklen=%d)",
+                               x, y, w, h, maskoff, maskscan, masklen);
+                VKRenderer_MaskFill(&context, x, y, w, h, maskoff, maskscan, masklen, pMask);
                 SKIP_BYTES(b, masklen);
             }
             break;
@@ -390,12 +414,17 @@ JNIEXPORT void JNICALL Java_sun_java2d_vulkan_VKRenderQueue_flushBuffer
                 J2dRlsTraceLn4(J2D_TRACE_VERBOSE,
                     "VKRenderQueue_flushBuffer: SET_RECT_CLIP(%d, %d, %d, %d)",
                     x1, y1, x2, y2);
+                ARRAY_RESIZE(context.clipSpanVertices, 0);
+                context.clipRect = (VkRect2D) {{x1, y1}, {x2 - x1, y2 - y1}};
+                context.clipModCount++;
             }
             break;
         case sun_java2d_pipe_BufferedOpCodes_BEGIN_SHAPE_CLIP:
             {
                 J2dRlsTraceLn(J2D_TRACE_VERBOSE,
                     "VKRenderQueue_flushBuffer: BEGIN_SHAPE_CLIP");
+                ARRAY_RESIZE(context.clipSpanVertices, 0);
+                context.clipModCount++;
             }
             break;
         case sun_java2d_pipe_BufferedOpCodes_SET_SHAPE_CLIP_SPANS:
@@ -403,28 +432,50 @@ JNIEXPORT void JNICALL Java_sun_java2d_vulkan_VKRenderQueue_flushBuffer
                 jint count = NEXT_INT(b);
                 J2dRlsTraceLn(J2D_TRACE_VERBOSE,
                     "VKRenderQueue_flushBuffer: SET_SHAPE_CLIP_SPANS");
-                SKIP_BYTES(b, count * BYTES_PER_SPAN);
+                size_t offset = ARRAY_SIZE(context.clipSpanVertices);
+                ARRAY_RESIZE(context.clipSpanVertices, offset + count * 6);
+                for (jint i = 0; i < count; i++) {
+                    jint x1 = NEXT_INT(b);
+                    jint y1 = NEXT_INT(b);
+                    jint x2 = NEXT_INT(b);
+                    jint y2 = NEXT_INT(b);
+                    context.clipSpanVertices[offset + i * 6 + 0] = (VKIntVertex) {x1, y1};
+                    context.clipSpanVertices[offset + i * 6 + 1] = (VKIntVertex) {x2, y1};
+                    context.clipSpanVertices[offset + i * 6 + 2] = (VKIntVertex) {x2, y2};
+                    context.clipSpanVertices[offset + i * 6 + 3] = (VKIntVertex) {x2, y2};
+                    context.clipSpanVertices[offset + i * 6 + 4] = (VKIntVertex) {x1, y2};
+                    context.clipSpanVertices[offset + i * 6 + 5] = (VKIntVertex) {x1, y1};
+                }
+                context.clipModCount++;
             }
             break;
         case sun_java2d_pipe_BufferedOpCodes_END_SHAPE_CLIP:
             {
                 J2dRlsTraceLn(J2D_TRACE_VERBOSE,
                     "VKRenderQueue_flushBuffer: END_SHAPE_CLIP");
+                context.clipRect = NO_CLIP;
+                context.clipModCount++;
             }
             break;
         case sun_java2d_pipe_BufferedOpCodes_RESET_CLIP:
             {
                 J2dRlsTraceLn(J2D_TRACE_VERBOSE,
                     "VKRenderQueue_flushBuffer: RESET_CLIP");
+                ARRAY_RESIZE(context.clipSpanVertices, 0);
+                context.clipRect = NO_CLIP;
+                context.clipModCount++;
             }
             break;
         case sun_java2d_pipe_BufferedOpCodes_SET_ALPHA_COMPOSITE:
             {
-                jint rule         = NEXT_INT(b);
+                jint   rule       = NEXT_INT(b);
                 jfloat extraAlpha = NEXT_FLOAT(b);
-                jint flags        = NEXT_INT(b);
-                J2dRlsTraceLn(J2D_TRACE_VERBOSE,
-                    "VKRenderQueue_flushBuffer: SET_ALPHA_COMPOSITE");
+                jint   flags      = NEXT_INT(b);
+                J2dRlsTraceLn3(J2D_TRACE_VERBOSE,
+                    "VKRenderQueue_flushBuffer: SET_ALPHA_COMPOSITE(%d, %f, %d)", rule, extraAlpha, flags);
+                context.color      = color;
+                context.composite  = (VKCompositeMode) rule;
+                context.extraAlpha = extraAlpha;
             }
             break;
         case sun_java2d_pipe_BufferedOpCodes_SET_XOR_COMPOSITE:
@@ -432,12 +483,21 @@ JNIEXPORT void JNICALL Java_sun_java2d_vulkan_VKRenderQueue_flushBuffer
                 jint xorPixel = NEXT_INT(b);
                 J2dRlsTraceLn(J2D_TRACE_VERBOSE,
                     "VKRenderQueue_flushBuffer: SET_XOR_COMPOSITE");
+                context.color      = VKUtil_DecodeJavaColor(xorPixel);
+                context.composite  = LOGIC_COMPOSITE_XOR;
+                context.extraAlpha = 1.0f;
+                // Alpha is left unchanged in XOR mode.
+                context.color.linear.a = 0.0f;
+                context.color.nonlinearSrgb.a = 0.0f;
             }
             break;
         case sun_java2d_pipe_BufferedOpCodes_RESET_COMPOSITE:
             {
                 J2dRlsTraceLn(J2D_TRACE_VERBOSE,
                     "VKRenderQueue_flushBuffer: RESET_COMPOSITE");
+                context.color      = color;
+                context.composite  = ALPHA_COMPOSITE_SRC;
+                context.extraAlpha = 1.0f;
             }
             break;
         case sun_java2d_pipe_BufferedOpCodes_SET_TRANSFORM:
@@ -448,18 +508,8 @@ JNIEXPORT void JNICALL Java_sun_java2d_vulkan_VKRenderQueue_flushBuffer
                 jdouble m11 = NEXT_DOUBLE(b);
                 jdouble m02 = NEXT_DOUBLE(b);
                 jdouble m12 = NEXT_DOUBLE(b);
-                J2dRlsTraceLn3(J2D_TRACE_VERBOSE,
-                    "VKRenderQueue_flushBuffer: SET_TRANSFORM | %.2f %.2f %.2f |", m00, m01, m02);
-                J2dRlsTraceLn3(J2D_TRACE_VERBOSE,
-                    "                                         | %.2f %.2f %.2f |", m10, m11, m12);
                 J2dRlsTraceLn(J2D_TRACE_VERBOSE,
-                    "                                         | 0.00 0.00 1.00 |");
-                //currentDevice->renderState.m00 = m00;
-                //currentDevice->renderState.m01 = m01;
-                //currentDevice->renderState.m10 = m10;
-                //currentDevice->renderState.m11 = m11;
-                //currentDevice->renderState.m02 = m02;
-                //currentDevice->renderState.m12 = m12;
+                    "VKRenderQueue_flushBuffer: SET_TRANSFORM");
             }
             break;
         case sun_java2d_pipe_BufferedOpCodes_RESET_TRANSFORM:
@@ -572,10 +622,13 @@ JNIEXPORT void JNICALL Java_sun_java2d_vulkan_VKRenderQueue_flushBuffer
         case sun_java2d_pipe_BufferedOpCodes_SET_COLOR:
             {
                 jint javaColor = NEXT_INT(b);
-                context.color = VKUtil_DecodeJavaColor(javaColor);
-                J2dRlsTraceLn5(J2D_TRACE_VERBOSE,
-                    "VKRenderQueue_flushBuffer: SET_COLOR 0x%08x, linear_rgba={%.3f, %.3f, %.3f, %.3f}",
-                    javaColor, context.color.r, context.color.g, context.color.b, context.color.a);
+                color = VKUtil_DecodeJavaColor(javaColor);
+                if (COMPOSITE_GROUP(context.composite) == ALPHA_COMPOSITE_GROUP) context.color = color;
+                J2dRlsTraceLn1(J2D_TRACE_VERBOSE, "VKRenderQueue_flushBuffer: SET_COLOR(0x%08x)", javaColor);
+                J2dTraceLn8(J2D_TRACE_VERBOSE, // Print color values with straight alpha for convenience.
+                    "    srgb={%.3f, %.3f, %.3f, %.3f}, linear={%.3f, %.3f, %.3f, %.3f}",
+                    color.nonlinearSrgb.r/color.linear.a, color.nonlinearSrgb.g/color.linear.a, color.nonlinearSrgb.b/color.linear.a, color.linear.a,
+                    color.linear.r/color.linear.a, color.linear.g/color.linear.a, color.linear.b/color.linear.a, color.linear.a);
             }
             break;
         case sun_java2d_pipe_BufferedOpCodes_SET_GRADIENT_PAINT:

src/java.desktop/share/native/common/java2d/vulkan/VKRenderState.h

@@ -1,43 +0,0 @@
-/*
- * Copyright (c) 2024, Oracle and/or its affiliates. All rights reserved.
- * Copyright (c) 2024, JetBrains s.r.o.. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.  Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-#ifndef VKRenderState_h_Included
-#define VKRenderState_h_Included
-
-#include <stdint.h>
-
-
-struct VKRenderState {
-    uint32_t color;
-    double m00;
-    double m10;
-    double m01;
-    double m11;
-    double m02;
-    double m12;
-};
-
-#endif /* VKRenderState_h_Included */

src/java.desktop/share/native/common/java2d/vulkan/VKRenderer.h

@@ -31,75 +31,19 @@
 #include "VKPipelines.h"
 
 struct VKRenderingContext {
-    VKSDOps* surface;
-    Color color;
-};
-
-#define TRACKED_RESOURCE(NAME) \
-typedef struct {               \
-    uint64_t timestamp;        \
-    NAME value;                \
-} Tracked ## NAME
-
-TRACKED_RESOURCE(VkCommandBuffer);
-TRACKED_RESOURCE(VkSemaphore);
-/**
- * Renderer attached to device.
- */
-struct VKRenderer {
-    VKDevice*          device;
-    VKPipelineContext* pipelineContext;
-
-    TrackedVkCommandBuffer* pendingCommandBuffers;
-    TrackedVkCommandBuffer* pendingSecondaryCommandBuffers;
-    TrackedVkSemaphore* pendingSemaphores;
-
-    /**
-     * Last known timestamp hit by GPU execution. Resources with equal or less timestamp may be safely reused.
-     */
-    uint64_t readTimestamp;
-    /**
-     * Next timestamp to be recorded. This is the last checkpoint to be hit by GPU execution.
-     */
-    uint64_t writeTimestamp;
-
-    VkSemaphore     timelineSemaphore;
-    VkCommandPool   commandPool;
-    VkCommandBuffer commandBuffer;
-
-    struct Wait {
-        VkSemaphore*          semaphores;
-        VkPipelineStageFlags* stages;
-    } wait;
-
-    struct PendingPresentation {
-        VkSwapchainKHR* swapchains;
-        uint32_t*       indices;
-        VkResult*       results;
-    } pendingPresentation;
-};
-
-/**
- * Rendering-related info attached to surface.
- */
-struct VKRenderPass {
-    VKRenderPassContext* context;
-    VkFramebuffer        framebuffer;
-    VkCommandBuffer      commandBuffer;
-    VkBool32             pendingFlush;
-    VkBool32             pendingCommands;
-    VkBool32             pendingClear;
-
-    VkImageLayout           layout;
-    VkPipelineStageFlagBits lastStage;
-    VkAccessFlagBits        lastAccess;
-    uint64_t                lastTimestamp; // When was this surface last used?
+    VKSDOps*        surface;
+    CorrectedColor  color;
+    VKCompositeMode composite;
+    // Extra alpha is not used when painting with plain color,
+    // in this case color.a already includes it.
+    float extraAlpha;
+    uint64_t     clipModCount; // Used to track changes to the clip.
+    VkRect2D     clipRect;
+    VKIntVertex* clipSpanVertices;
 };
 
 VKRenderer* VKRenderer_Create(VKDevice* device);
 
-VkCommandBuffer VKRenderer_Render(VKSDOps* surface);
-
 void VKRenderer_Destroy(VKRenderer* renderer);
 
 /**
@@ -115,7 +59,7 @@ void VKRenderer_Flush(VKRenderer* renderer);
 /**
  * Cancel render pass of the surface, release all associated resources and deallocate render pass.
  */
-void VKRenderer_ReleaseRenderPass(VKSDOps* surface);
+void VKRenderer_DestroyRenderPass(VKSDOps* surface);
 
 /**
  * Flush pending render pass and queue surface for presentation (if applicable).
@@ -127,15 +71,16 @@ void VKRenderer_FlushSurface(VKSDOps* surface);
  * Actual resize will be performed later, before starting a new frame.
  */
 void VKRenderer_ConfigureSurface(VKSDOps* surface, VkExtent2D extent);
-void VKRenderer_FlushRenderPass(VKSDOps* surface);
-// Blit ops.
+
+// Blit operations.
 
 void VKRenderer_TextureRender(VKRenderingContext* context,
                               VKImage *destImage, VKImage *srcImage,
                               VkBuffer vertexBuffer, uint32_t vertexNum);
 
-// fill ops
-void VKRenderer_FillRect(VKRenderingContext* context, jint x, jint y, jint w, jint h);
+// Drawing operations.
+
+void VKRenderer_RenderRect(VKRenderingContext* context, VKPipeline pipeline, jint x, jint y, jint w, jint h);
 
 void VKRenderer_RenderParallelogram(VKRenderingContext* context, VKPipeline pipeline,
                                     jfloat x11, jfloat y11,
@@ -144,4 +89,6 @@ void VKRenderer_RenderParallelogram(VKRenderingContext* context, VKPipeline pipe
 
 void VKRenderer_FillSpans(VKRenderingContext* context, jint spanCount, jint *spans);
 
+void VKRenderer_MaskFill(VKRenderingContext* context, jint x, jint y, jint w, jint h, jint maskoff, jint maskscan, jint masklen, uint8_t* mask);
+
 #endif //VKRenderer_h_Included

src/java.desktop/share/native/common/java2d/vulkan/VKSurfaceData.c

@@ -38,11 +38,12 @@ static void VKSD_ResetImageSurface(VKSDOps* vksdo) {
     if (vksdo == NULL) return;
 
     // ReleaseRenderPass also waits while the surface resources are being used by device.
-    VKRenderer_ReleaseRenderPass(vksdo);
+    VKRenderer_DestroyRenderPass(vksdo);
 
-    if (vksdo->device != NULL && vksdo->image != NULL) {
-        VKImage_free(vksdo->device, vksdo->image);
-        vksdo->image = NULL;
+    if (vksdo->device != NULL) {
+        VKImage_Destroy(vksdo->device, vksdo->stencil);
+        VKImage_Destroy(vksdo->device, vksdo->image);
+        vksdo->image = vksdo->stencil = NULL;
     }
 }
 
@@ -67,6 +68,10 @@ void VKSD_ResetSurface(VKSDOps* vksdo) {
     }
 }
 
+static void VKSD_FindImageSurfaceMemoryType(VKMemoryRequirements* requirements) {
+    VKAllocator_FindMemoryType(requirements, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT, VK_ALL_MEMORY_PROPERTIES);
+}
+
 VkBool32 VKSD_ConfigureImageSurface(VKSDOps* vksdo) {
     // Initialize the device. currentDevice can be changed on the fly, and we must reconfigure surfaces accordingly.
     VKDevice* device = VKGE_graphics_environment()->currentDevice;
@@ -79,15 +84,26 @@ VkBool32 VKSD_ConfigureImageSurface(VKSDOps* vksdo) {
     if (vksdo->requestedExtent.width > 0 && vksdo->requestedExtent.height > 0 && (vksdo->image == NULL ||
             vksdo->requestedExtent.width != vksdo->image->extent.width ||
             vksdo->requestedExtent.height != vksdo->image->extent.height)) {
-        // VK_FORMAT_B8G8R8A8_UNORM is the most widely-supported format for our use.
+        // Use proper blending by default. See VKRenderer_GetFormatAliasForRenderPass for details.
+        vksdo->gammaCorrect = VK_TRUE;
+        // VK_FORMAT_B8G8R8A8_SRGB is the most widely-supported format for our use.
+        // We can also use normalized high-bit-count formats, like R10G10B10A2_UNORM, or R16G16B16A16_UNORM.
+        // The only thing to keep in mind is that we must not use 8-bits per component normalized formats, like
+        // B8G8R8A8_UNORM, because they would result in precision loss when blitting to the swapchain (explained further).
+        // Currently, we only support *_SRGB and *_UNORM formats,
+        // as other types may not be trivial to alias for logicOp rendering.
+        VkFormat format = VK_FORMAT_B8G8R8A8_SRGB;
+        if (VK_DEBUG_RANDOM(50)) format = VK_FORMAT_R16G16B16A16_UNORM;
+        VkFormat unormAlias = VKUtil_GetFormatGroup(format).aliases[FORMAT_ALIAS_UNORM];
+        // If we are using legacy blending, force UNORM format for surface image and swapchain.
+        if (!vksdo->gammaCorrect) format = unormAlias;
+
         VKImage* image = VKImage_Create(device, vksdo->requestedExtent.width, vksdo->requestedExtent.height,
-                                        VK_FORMAT_B8G8R8A8_UNORM, VK_IMAGE_TILING_OPTIMAL,
+                                        format != unormAlias ? VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT : 0,
+                                        format, VK_IMAGE_TILING_OPTIMAL,
                                         VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT,
-                                        VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
-        if (image == NULL) {
-            J2dRlsTraceLn1(J2D_TRACE_ERROR, "VKSD_ConfigureImageSurface(%p): cannot create image", vksdo);
-            VK_UNHANDLED_ERROR();
-        }
+                                        VK_SAMPLE_COUNT_1_BIT, VKSD_FindImageSurfaceMemoryType);
+        VK_RUNTIME_ASSERT(image);
         VKSD_ResetImageSurface(vksdo);
         vksdo->image = image;
         J2dRlsTraceLn3(J2D_TRACE_INFO, "VKSD_ConfigureImageSurface(%p): image updated %dx%d", vksdo, image->extent.width, image->extent.height);
@@ -95,6 +111,25 @@ VkBool32 VKSD_ConfigureImageSurface(VKSDOps* vksdo) {
     return vksdo->image != NULL;
 }
 
+VkBool32 VKSD_ConfigureImageSurfaceStencil(VKSDOps* vksdo) {
+    // Check that image is ready.
+    if (vksdo->image == NULL) {
+        J2dRlsTraceLn1(J2D_TRACE_WARNING, "VKSD_ConfigureImageSurfaceStencil(%p): image is not ready", vksdo);
+        return VK_FALSE;
+    }
+    // Initialize stencil image.
+    if (vksdo->stencil == NULL) {
+        vksdo->stencil = VKImage_Create(vksdo->device, vksdo->image->extent.width, vksdo->image->extent.height,
+                                        0, VK_FORMAT_S8_UINT, VK_IMAGE_TILING_OPTIMAL,
+                                        VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT,
+                                        VK_SAMPLE_COUNT_1_BIT, VKSD_FindImageSurfaceMemoryType);
+        VK_RUNTIME_ASSERT(vksdo->stencil);
+        J2dRlsTraceLn3(J2D_TRACE_INFO, "VKSD_ConfigureImageSurfaceStencil(%p): stencil image updated %dx%d",
+                       vksdo, vksdo->stencil->extent.width, vksdo->stencil->extent.height);
+    }
+    return vksdo->stencil != NULL;
+}
+
 VkBool32 VKSD_ConfigureWindowSurface(VKWinSDOps* vkwinsdo) {
     // Check that image is ready.
     if (vkwinsdo->vksdOps.image == NULL) {
@@ -120,6 +155,47 @@ VkBool32 VKSD_ConfigureWindowSurface(VKWinSDOps* vkwinsdo) {
         return VK_FALSE;
     }
 
+    // currentExtent is the current width and height of the surface, or the special value (0xFFFFFFFF, 0xFFFFFFFF)
+    // indicating that the surface size will be determined by the extent of a swapchain targeting the surface.
+    // https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VkSurfaceCapabilitiesKHR.html
+    // The behavior is platform-dependent if the image extent does not match the surface’s currentExtent
+    // as returned by vkGetPhysicalDeviceSurfaceCapabilitiesKHR.
+    // https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VkSwapchainCreateInfoKHR.html
+    if ((vkwinsdo->vksdOps.image->extent.width != capabilities.currentExtent.width ||
+         vkwinsdo->vksdOps.image->extent.height != capabilities.currentExtent.height) &&
+         (capabilities.currentExtent.width != 0xFFFFFFFF || capabilities.currentExtent.height != 0xFFFFFFFF)) {
+        J2dRlsTraceLn5(J2D_TRACE_WARNING,
+                       "VKSD_ConfigureWindowSurface(%p): surface size doesn't match, expected=%dx%d, capabilities.currentExtent=%dx%d",
+                       vkwinsdo, vkwinsdo->vksdOps.image->extent.width, vkwinsdo->vksdOps.image->extent.height,
+                       capabilities.currentExtent.width, capabilities.currentExtent.height);
+        return VK_FALSE;
+    }
+
+    if (vkwinsdo->vksdOps.image->extent.width  < capabilities.minImageExtent.width  ||
+        vkwinsdo->vksdOps.image->extent.height < capabilities.minImageExtent.height ||
+        vkwinsdo->vksdOps.image->extent.width  > capabilities.maxImageExtent.width  ||
+        vkwinsdo->vksdOps.image->extent.height > capabilities.maxImageExtent.height) {
+        J2dRlsTraceLn7(J2D_TRACE_WARNING,
+                       "VKSD_ConfigureWindowSurface(%p): surface size doesn't fit, expected=%dx%d, "
+                       "capabilities.minImageExtent=%dx%d, capabilities.minImageExtent=%dx%d",
+                       vkwinsdo, vkwinsdo->vksdOps.image->extent.width, vkwinsdo->vksdOps.image->extent.height,
+                       capabilities.minImageExtent.width, capabilities.minImageExtent.height,
+                       capabilities.maxImageExtent.width, capabilities.maxImageExtent.height);
+        return VK_FALSE;
+    }
+
+    // Our surfaces use pre-multiplied alpha, try to match.
+    // This allows us to have semi-transparent windows.
+    VkCompositeAlphaFlagBitsKHR compositeAlpha;
+    if (capabilities.supportedCompositeAlpha & VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR) {
+        compositeAlpha = VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR;
+    } else if (capabilities.supportedCompositeAlpha & VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR) {
+        // This is wrong, but at least some transparency is better than none, right?
+        compositeAlpha = VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR;
+    } else if (capabilities.supportedCompositeAlpha & VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR) {
+        compositeAlpha = VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR;
+    } else compositeAlpha = (VkCompositeAlphaFlagBitsKHR) capabilities.supportedCompositeAlpha;
+
     uint32_t formatCount;
     VK_IF_ERROR(ge->vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, vkwinsdo->surface, &formatCount, NULL)) {
         return VK_FALSE;
@@ -133,17 +209,29 @@ VkBool32 VKSD_ConfigureWindowSurface(VKWinSDOps* vkwinsdo) {
     J2dRlsTraceLn1(J2D_TRACE_INFO, "VKSD_ConfigureWindowSurface(%p): available swapchain formats:", vkwinsdo);
     for (uint32_t i = 0; i < formatCount; i++) {
         J2dRlsTraceLn2(J2D_TRACE_INFO, "    format=%d, colorSpace=%d", formats[i].format, formats[i].colorSpace);
-        // We draw with sRGB colors (see VKUtil_DecodeJavaColor()), so we don't want Vulkan to do color space
-        // conversions when drawing to surface. We use *_UNORM formats, so that colors are written "as is".
-        // With VK_COLOR_SPACE_SRGB_NONLINEAR_KHR these colors will be interpreted by presentation engine as sRGB.
-        if (formats[i].colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR && (
-                formats[i].format == VK_FORMAT_A8B8G8R8_UNORM_PACK32 ||
-                formats[i].format == VK_FORMAT_B8G8R8A8_UNORM ||
-                formats[i].format == VK_FORMAT_R8G8B8A8_UNORM ||
-                formats[i].format == VK_FORMAT_B8G8R8_UNORM ||
-                formats[i].format == VK_FORMAT_R8G8B8_UNORM
-            )) {
-            format = &formats[i];
+        // Currently, we only support default VK_COLOR_SPACE_SRGB_NONLINEAR_KHR color space, which means
+        // that we must use SRGB image formats, if we want proper gamma-correct colors.
+        // This only applies to the swapchain image, and we can use any format for the intermediate rendering
+        // target (VKSDOps.image). But in practice this means that for VKSDOps.image we would want to either
+        // use *_SRGB, or high-bit-count images, as even R8G8B8A8_UNORM will result in precision loss.
+
+        // We must strictly use SRGB formats for gamma-correct colors and UNORM for legacy mode.
+        if (vkwinsdo->vksdOps.gammaCorrect) {
+            if (formats[i].colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR && (
+                    formats[i].format == VK_FORMAT_A8B8G8R8_SRGB_PACK32 ||
+                    formats[i].format == VK_FORMAT_B8G8R8A8_SRGB ||
+                    formats[i].format == VK_FORMAT_R8G8B8A8_SRGB ||
+                    formats[i].format == VK_FORMAT_B8G8R8_SRGB ||
+                    formats[i].format == VK_FORMAT_R8G8B8_SRGB
+            )) format = &formats[i];
+        } else {
+            if (formats[i].colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR && (
+                    formats[i].format == VK_FORMAT_A8B8G8R8_UNORM_PACK32 ||
+                    formats[i].format == VK_FORMAT_B8G8R8A8_UNORM ||
+                    formats[i].format == VK_FORMAT_R8G8B8A8_UNORM ||
+                    formats[i].format == VK_FORMAT_B8G8R8_UNORM ||
+                    formats[i].format == VK_FORMAT_R8G8B8_UNORM
+            )) format = &formats[i];
         }
     }
     if (format == NULL) {
@@ -151,20 +239,32 @@ VkBool32 VKSD_ConfigureWindowSurface(VKWinSDOps* vkwinsdo) {
         return VK_FALSE;
     }
 
-    // TODO inspect and choose present mode
     uint32_t presentModeCount;
     VK_IF_ERROR(ge->vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, vkwinsdo->surface, &presentModeCount, NULL)) {
         return VK_FALSE;
     }
     VkPresentModeKHR presentModes[presentModeCount];
     VK_IF_ERROR(ge->vkGetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, vkwinsdo->surface, &presentModeCount, presentModes)) {
-        VK_UNHANDLED_ERROR();
+        return VK_FALSE;
     }
-
-    uint32_t imageCount = capabilities.minImageCount + 1;
-    if (capabilities.maxImageCount > 0 && imageCount > capabilities.maxImageCount) {
-        imageCount = capabilities.maxImageCount;
+    // FIFO mode is guaranteed to be supported.
+    // https://registry.khronos.org/vulkan/specs/1.3-extensions/man/html/VkPresentModeKHR.html
+    uint32_t imageCount = 2;
+    VkPresentModeKHR presentMode = VK_PRESENT_MODE_FIFO_KHR;
+    // MAILBOX makes no sense without at least 3 images and using less memory
+    // for swapchain images may be more beneficial than having unlimited FPS.
+    // However, if minImageCount is too big anyway, why not use MAILBOX.
+    if (capabilities.minImageCount >= 3) {
+        for (uint32_t i = 0; i < presentModeCount; i++) {
+            if (presentModes[i] == VK_PRESENT_MODE_MAILBOX_KHR) {
+                presentMode = VK_PRESENT_MODE_MAILBOX_KHR;
+                imageCount = 3;
+                break;
+            }
+        }
     }
+    if (imageCount > capabilities.maxImageCount && capabilities.maxImageCount != 0) imageCount = capabilities.maxImageCount;
+    else if (imageCount < capabilities.minImageCount) imageCount = capabilities.minImageCount;
 
     VkSwapchainKHR swapchain;
     VkSwapchainCreateInfoKHR createInfoKhr = {
@@ -173,15 +273,15 @@ VkBool32 VKSD_ConfigureWindowSurface(VKWinSDOps* vkwinsdo) {
             .minImageCount = imageCount,
             .imageFormat = format->format,
             .imageColorSpace = format->colorSpace,
-            .imageExtent = vkwinsdo->vksdOps.image->extent, // TODO consider capabilities.currentExtent, capabilities.minImageExtent and capabilities.maxImageExtent
+            .imageExtent = vkwinsdo->vksdOps.image->extent,
             .imageArrayLayers = 1,
             .imageUsage = VK_IMAGE_USAGE_TRANSFER_DST_BIT,
             .imageSharingMode = VK_SHARING_MODE_EXCLUSIVE,
             .queueFamilyIndexCount = 0,
             .pQueueFamilyIndices = NULL,
             .preTransform = capabilities.currentTransform,
-            .compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR,
-            .presentMode = VK_PRESENT_MODE_FIFO_KHR, // TODO need more flexibility
+            .compositeAlpha = compositeAlpha,
+            .presentMode = presentMode,
             .clipped = VK_TRUE,
             .oldSwapchain = vkwinsdo->swapchain
     };
@@ -189,7 +289,9 @@ VkBool32 VKSD_ConfigureWindowSurface(VKWinSDOps* vkwinsdo) {
     VK_IF_ERROR(device->vkCreateSwapchainKHR(device->handle, &createInfoKhr, NULL, &swapchain)) {
         return VK_FALSE;
     }
-    J2dRlsTraceLn1(J2D_TRACE_INFO, "VKSD_ConfigureWindowSurface(%p): swapchain created", vkwinsdo);
+    J2dRlsTraceLn5(J2D_TRACE_INFO, "VKSD_ConfigureWindowSurface(%p): swapchain created, format=%d, presentMode=%d, imageCount=%d, compositeAlpha=%d",
+                   vkwinsdo, format->format, presentMode, imageCount, compositeAlpha);
+    vkwinsdo->resizeCallback(vkwinsdo, vkwinsdo->vksdOps.image->extent);
 
     if (vkwinsdo->swapchain != VK_NULL_HANDLE) {
         // Destroy old swapchain.

src/java.desktop/share/native/common/java2d/vulkan/VKSurfaceData.h

@@ -40,6 +40,7 @@
 #define VKSD_UNDEFINED       sun_java2d_pipe_hw_AccelSurface_UNDEFINED
 #define VKSD_WINDOW          sun_java2d_pipe_hw_AccelSurface_WINDOW
 #define VKSD_RT_TEXTURE      sun_java2d_pipe_hw_AccelSurface_RT_TEXTURE
+
 /**
  * The VKSDOps structure describes a native Vulkan surface and contains all
  * information pertaining to the native surface.
@@ -47,15 +48,25 @@
 struct VKSDOps {
     SurfaceDataOps sdOps;
     jint           drawableType;
+    /**
+     * Whether we use proper gamma-corrected colors, or not.
+     * When TRUE, linear colors are used for drawing, which results in correct blending.
+     * When FALSE, sRGB colors are used for drawing, which results in legacy blending.
+     * See VKRenderer_GetFormatAliasForRenderPass for details.
+     */
+    VkBool32       gammaCorrect;
     VKDevice*      device;
     VKImage*       image;
+    VKImage*       stencil;
 
-    Color          background;
+    CorrectedColor background;
     VkExtent2D     requestedExtent;
 
     VKRenderPass*  renderPass;
 };
 
+typedef void (*VKWinSD_SurfaceResizeCallback)(VKWinSDOps* surface, VkExtent2D extent);
+
 /**
  * The VKWinSDOps structure describes a native Vulkan surface connected with a window.
  */
@@ -66,6 +77,7 @@ struct VKWinSDOps {
     VkImage*       swapchainImages;
     VKDevice*      swapchainDevice;
     VkExtent2D     swapchainExtent;
+    VKWinSD_SurfaceResizeCallback resizeCallback;
 };
 
 /**
@@ -80,6 +92,12 @@ void VKSD_ResetSurface(VKSDOps* vksdo);
  */
 VkBool32 VKSD_ConfigureImageSurface(VKSDOps* vksdo);
 
+/**
+ * [Re]configure stencil attachment of the image surface.
+ * VKSD_ConfigureImageSurface must have been called before.
+ */
+VkBool32 VKSD_ConfigureImageSurfaceStencil(VKSDOps* vksdo);
+
 /**
  * Configure window surface. This [re]initializes the swapchain.
  * VKSD_ConfigureImageSurface must have been called before.

src/java.desktop/share/native/common/java2d/vulkan/VKTexturePool.c

@@ -24,13 +24,12 @@
  * questions.
  */
 
-#include <stdlib.h>
 #include <pthread.h>
 
 #include "VKImage.h"
+#include "VKUtil.h"
 #include "VKTexturePool.h"
 #include "jni.h"
-#include "jni_util.h"
 #include "Trace.h"
 
 
@@ -72,6 +71,10 @@ void VKTexturePoolLock_unlockImpl(ATexturePoolLockPrivPtr *lock) {
     if (TRACE_LOCK) J2dRlsTraceLn1(J2D_TRACE_VERBOSE, "VKTexturePoolLock_unlockImpl: lock=%p - unlocked", l);
 }
 
+static void VKTexturePool_FindImageMemoryType(VKMemoryRequirements* requirements) {
+    // TODO both DEVICE_LOCAL and HOST_VISIBLE memory is very precious, we may need to use just DEVICE_LOCAL instead.
+    VKAllocator_FindMemoryType(requirements, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, VK_ALL_MEMORY_PROPERTIES);
+}
 
 /* Texture allocate/free API */
 static ATexturePrivPtr* VKTexturePool_createTexture(ADevicePrivPtr *device,
@@ -81,10 +84,10 @@ static ATexturePrivPtr* VKTexturePool_createTexture(ADevicePrivPtr *device,
 {
     CHECK_NULL_RETURN(device, NULL);
     VKImage* texture = VKImage_Create((VKDevice*)device, width, height,
-                                      (VkFormat)format,
-                                      VK_IMAGE_TILING_LINEAR,
+                                      0, (VkFormat)format,
+                                      VK_IMAGE_TILING_OPTIMAL,
                                       VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT,
-                                      VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
+                                      VK_SAMPLE_COUNT_1_BIT, VKTexturePool_FindImageMemoryType);
     if IS_NULL(texture) {
         J2dRlsTrace(J2D_TRACE_ERROR, "VKTexturePool_createTexture: Cannot create VKImage");
         return NULL;
@@ -98,15 +101,11 @@ static ATexturePrivPtr* VKTexturePool_createTexture(ADevicePrivPtr *device,
 }
 
 static int VKTexturePool_bytesPerPixel(long format) {
-    switch ((VkFormat)format) {
-        case VK_FORMAT_R8G8B8A8_UNORM:
-            return 4;
-        case VK_FORMAT_R8_UNORM:
-            return 1;
-        default:
-            J2dRlsTraceLn1(J2D_TRACE_ERROR, "VKTexturePool_bytesPerPixel: format=%d not supported (4 bytes by default)", format);
-            return 4;
-    }
+    FormatGroup group = VKUtil_GetFormatGroup((VkFormat)format);
+    if (group.bytes == 0) {
+        J2dRlsTraceLn1(J2D_TRACE_ERROR, "VKTexturePool_bytesPerPixel: format=%d not supported (4 bytes by default)", format);
+        return 4;
+    } else return (int) group.bytes;
 }
 
 static void VKTexturePool_freeTexture(ADevicePrivPtr *device, ATexturePrivPtr *texture) {
@@ -116,7 +115,7 @@ static void VKTexturePool_freeTexture(ADevicePrivPtr *device, ATexturePrivPtr *t
     if (TRACE_TEX) J2dRlsTraceLn4(J2D_TRACE_VERBOSE, "VKTexturePool_freeTexture: free texture: tex=%p, w=%d h=%d, pf=%d",
                                   tex, tex->extent.width, tex->extent.height, tex->format);
 
-    VKImage_free((VKDevice*)device, tex);
+    VKImage_Destroy((VKDevice*)device, tex);
 }
 
 /* VKTexturePoolHandle API */

src/java.desktop/share/native/common/java2d/vulkan/VKTypes.h

@@ -26,7 +26,23 @@
 #include <vulkan/vulkan.h>
 
 /**
- * Floating-point RGBA color with sRGB encoding.
+ * Sometimes we need to reinterpret an image as UNORM instead of its original format.
+ * Therefore for any resource related to image/attachment format we need two copies:
+ * - FORMAT_ALIAS_ORIGINAL
+ * - FORMAT_ALIAS_UNORM
+ * Such resources are:
+ * - Image view.
+ * - Surface framebuffer (Only when dynamicRendering=OFF).
+ * - Render pass instance (Only when dynamicRendering=OFF).
+ *
+ * See SET_FORMAT_ALIASED_HANDLE and VKRenderer_GetFormatAliasForRenderPass for more details.
+ */
+#define FORMAT_ALIASED [2]
+
+/**
+ * Floating-point RGBA color components with pre-multiplied alpha.
+ * May be encoded as either linear, or sRGB depending on the context.
+ * See CorrectedColor.linear, CorrectedColor.nonlinearSrgb.
  */
 typedef union {
     struct {
@@ -35,14 +51,29 @@ typedef union {
     VkClearValue vkClearValue;
 } Color;
 
+/**
+ * Floating-point RGBA color with pre-multiplied alpha in both linear and sRGB encoding.
+ * You never need to use linear or sRGB variants directly, use VKRenderer_GetColorForRenderPass instead.
+ *
+ * Read more about presenting sRGB content in VKSD_ConfigureWindowSurface.
+ * Read more about conversion from Java colors in VKUtil_DecodeJavaColor.
+ */
+typedef struct {
+    Color linear;
+    Color nonlinearSrgb;
+} CorrectedColor;
+
+VK_DEFINE_NON_DISPATCHABLE_HANDLE(VKMemory);
+
 typedef struct VKGraphicsEnvironment VKGraphicsEnvironment;
 typedef struct VKDevice VKDevice;
+typedef struct VKAllocator VKAllocator;
 typedef struct VKRenderer VKRenderer;
 typedef struct VKRenderPass VKRenderPass;
 typedef struct VKRenderingContext VKRenderingContext;
 typedef struct VKPipelineContext VKPipelineContext;
 typedef struct VKRenderPassContext VKRenderPassContext;
-typedef struct VKShaders VKShaders;
+typedef struct VKTexelBuffer VKTexelBuffer;
 typedef struct VKBuffer VKBuffer;
 typedef struct VKImage VKImage;
 typedef struct VKSDOps VKSDOps;

src/java.desktop/share/native/common/java2d/vulkan/VKUtil.c

@@ -21,9 +21,12 @@
 // or visit www.oracle.com if you need additional information or have any
 // questions.
 
+#include <assert.h>
+#include <math.h>
 #include "VKUtil.h"
 
-Color VKUtil_DecodeJavaColor(uint32_t srgb) {
+CorrectedColor VKUtil_DecodeJavaColor(uint32_t color) {
+    assert(sizeof(Color) == sizeof(float) * 4);
     // Just map [0, 255] integer colors onto [0, 1] floating-point range, it remains in sRGB color space.
     // sRGB gamma correction remains unsupported.
     static const float NormTable256[256] = {
@@ -32,13 +35,253 @@ Color VKUtil_DecodeJavaColor(uint32_t srgb) {
 #define NORM64(N) NORM8(N),NORM8(N+8),NORM8(N+16),NORM8(N+24),NORM8(N+32),NORM8(N+40),NORM8(N+48),NORM8(N+56)
             NORM64(0),NORM64(64),NORM64(128),NORM64(192)
     };
-    Color c = {
-            .r = NormTable256[(srgb >> 16) & 0xFF],
-            .g = NormTable256[(srgb >>  8) & 0xFF],
-            .b = NormTable256[ srgb        & 0xFF],
-            .a = NormTable256[(srgb >> 24) & 0xFF]
+    Color srgb = {
+            .r = NormTable256[(color >> 16) & 0xFF],
+            .g = NormTable256[(color >>  8) & 0xFF],
+            .b = NormTable256[ color        & 0xFF],
+            .a = NormTable256[(color >> 24) & 0xFF]
     };
-    return c;
+    // This SRGB -> LINEAR conversion implementation is taken from Khronos Data Format Specification:
+    // https://registry.khronos.org/DataFormat/specs/1.3/dataformat.1.3.html#TRANSFER_SRGB_EOTF
+    Color linear = {
+            .r = (float) (srgb.r <= 0.04045 ? srgb.r / 12.92 : pow((srgb.r + 0.055) / 1.055, 2.4)),
+            .g = (float) (srgb.g <= 0.04045 ? srgb.g / 12.92 : pow((srgb.g + 0.055) / 1.055, 2.4)),
+            .b = (float) (srgb.b <= 0.04045 ? srgb.b / 12.92 : pow((srgb.b + 0.055) / 1.055, 2.4)),
+            .a = srgb.a
+    };
+    // Convert to pre-multiplied alpha.
+    srgb.r *= srgb.a;
+    srgb.g *= srgb.a;
+    srgb.b *= srgb.a;
+    linear.r *= linear.a;
+    linear.g *= linear.a;
+    linear.b *= linear.a;
+    return (CorrectedColor) { .linear = linear, .nonlinearSrgb = srgb };
+}
+
+uint32_t VKUtil_Log2(uint64_t i) {
+    // https://graphics.stanford.edu/~seander/bithacks.html#IntegerLogLookup
+    static const char LogTable256[256] = {
+#define LT(n) n, n, n, n, n, n, n, n, n, n, n, n, n, n, n, n
+            -1, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
+            LT(4), LT(5), LT(5), LT(6), LT(6), LT(6), LT(6),
+            LT(7), LT(7), LT(7), LT(7), LT(7), LT(7), LT(7), LT(7) };
+    register uint32_t t;
+    if      (t = i >> 56) return 56 + LogTable256[t];
+    else if (t = i >> 48) return 48 + LogTable256[t];
+    else if (t = i >> 40) return 40 + LogTable256[t];
+    else if (t = i >> 32) return 32 + LogTable256[t];
+    else if (t = i >> 24) return 24 + LogTable256[t];
+    else if (t = i >> 16) return 16 + LogTable256[t];
+    else if (t = i >>  8) return  8 + LogTable256[t];
+    else return LogTable256[i & 0xFF];
+}
+
+FormatGroup VKUtil_GetFormatGroup(VkFormat format) {
+#define GROUP(SIZE, ...) return ((FormatGroup) { .bytes = SIZE, .aliases[FORMAT_ALIAS_ORIGINAL] = format, __VA_ARGS__ })
+    switch (format) {
+        case VK_FORMAT_R4G4_UNORM_PACK8:      GROUP(1, .aliases[FORMAT_ALIAS_UNORM] = VK_FORMAT_R4G4_UNORM_PACK8);
+        case VK_FORMAT_R4G4B4A4_UNORM_PACK16: GROUP(2, .aliases[FORMAT_ALIAS_UNORM] = VK_FORMAT_R4G4B4A4_UNORM_PACK16);
+        case VK_FORMAT_B4G4R4A4_UNORM_PACK16: GROUP(2, .aliases[FORMAT_ALIAS_UNORM] = VK_FORMAT_B4G4R4A4_UNORM_PACK16);
+        case VK_FORMAT_R5G6B5_UNORM_PACK16:   GROUP(2, .aliases[FORMAT_ALIAS_UNORM] = VK_FORMAT_R5G6B5_UNORM_PACK16);
+        case VK_FORMAT_B5G6R5_UNORM_PACK16:   GROUP(2, .aliases[FORMAT_ALIAS_UNORM] = VK_FORMAT_B5G6R5_UNORM_PACK16);
+        case VK_FORMAT_R5G5B5A1_UNORM_PACK16: GROUP(2, .aliases[FORMAT_ALIAS_UNORM] = VK_FORMAT_R5G5B5A1_UNORM_PACK16);
+        case VK_FORMAT_B5G5R5A1_UNORM_PACK16: GROUP(2, .aliases[FORMAT_ALIAS_UNORM] = VK_FORMAT_B5G5R5A1_UNORM_PACK16);
+        case VK_FORMAT_A1R5G5B5_UNORM_PACK16: GROUP(2, .aliases[FORMAT_ALIAS_UNORM] = VK_FORMAT_A1R5G5B5_UNORM_PACK16);
+        case VK_FORMAT_R8_UNORM:
+        case VK_FORMAT_R8_SNORM:
+        case VK_FORMAT_R8_USCALED:
+        case VK_FORMAT_R8_SSCALED:
+        case VK_FORMAT_R8_UINT:
+        case VK_FORMAT_R8_SINT:
+        case VK_FORMAT_R8_SRGB:
+            GROUP(1, .aliases[FORMAT_ALIAS_SRGB] = VK_FORMAT_R8_SRGB,
+                  .aliases[FORMAT_ALIAS_UNORM] = VK_FORMAT_R8_UNORM, .aliases[FORMAT_ALIAS_SNORM] = VK_FORMAT_R8_SNORM,
+                  .aliases[FORMAT_ALIAS_USCALED] = VK_FORMAT_R8_USCALED, .aliases[FORMAT_ALIAS_SSCALED] = VK_FORMAT_R8_SSCALED,
+                  .aliases[FORMAT_ALIAS_UINT] = VK_FORMAT_R8_UINT, .aliases[FORMAT_ALIAS_SINT] = VK_FORMAT_R8_SINT);
+        case VK_FORMAT_R8G8_UNORM:
+        case VK_FORMAT_R8G8_SNORM:
+        case VK_FORMAT_R8G8_USCALED:
+        case VK_FORMAT_R8G8_SSCALED:
+        case VK_FORMAT_R8G8_UINT:
+        case VK_FORMAT_R8G8_SINT:
+        case VK_FORMAT_R8G8_SRGB:
+            GROUP(2, .aliases[FORMAT_ALIAS_SRGB] = VK_FORMAT_R8G8_SRGB,
+                  .aliases[FORMAT_ALIAS_UNORM] = VK_FORMAT_R8G8_UNORM, .aliases[FORMAT_ALIAS_SNORM] = VK_FORMAT_R8G8_SNORM,
+                  .aliases[FORMAT_ALIAS_USCALED] = VK_FORMAT_R8G8_USCALED, .aliases[FORMAT_ALIAS_SSCALED] = VK_FORMAT_R8G8_SSCALED,
+                  .aliases[FORMAT_ALIAS_UINT] = VK_FORMAT_R8G8_UINT, .aliases[FORMAT_ALIAS_SINT] = VK_FORMAT_R8G8_SINT);
+        case VK_FORMAT_R8G8B8_UNORM:
+        case VK_FORMAT_R8G8B8_SNORM:
+        case VK_FORMAT_R8G8B8_USCALED:
+        case VK_FORMAT_R8G8B8_SSCALED:
+        case VK_FORMAT_R8G8B8_UINT:
+        case VK_FORMAT_R8G8B8_SINT:
+        case VK_FORMAT_R8G8B8_SRGB:
+            GROUP(3, .aliases[FORMAT_ALIAS_SRGB] = VK_FORMAT_R8G8B8_SRGB,
+                  .aliases[FORMAT_ALIAS_UNORM] = VK_FORMAT_R8G8B8_UNORM, .aliases[FORMAT_ALIAS_SNORM] = VK_FORMAT_R8G8B8_SNORM,
+                  .aliases[FORMAT_ALIAS_USCALED] = VK_FORMAT_R8G8B8_USCALED, .aliases[FORMAT_ALIAS_SSCALED] = VK_FORMAT_R8G8B8_SSCALED,
+                  .aliases[FORMAT_ALIAS_UINT] = VK_FORMAT_R8G8B8_UINT, .aliases[FORMAT_ALIAS_SINT] = VK_FORMAT_R8G8B8_SINT);
+        case VK_FORMAT_B8G8R8_UNORM:
+        case VK_FORMAT_B8G8R8_SNORM:
+        case VK_FORMAT_B8G8R8_USCALED:
+        case VK_FORMAT_B8G8R8_SSCALED:
+        case VK_FORMAT_B8G8R8_UINT:
+        case VK_FORMAT_B8G8R8_SINT:
+        case VK_FORMAT_B8G8R8_SRGB:
+            GROUP(3, .aliases[FORMAT_ALIAS_SRGB] = VK_FORMAT_B8G8R8_SRGB,
+                  .aliases[FORMAT_ALIAS_UNORM] = VK_FORMAT_B8G8R8_UNORM, .aliases[FORMAT_ALIAS_SNORM] = VK_FORMAT_B8G8R8_SNORM,
+                  .aliases[FORMAT_ALIAS_USCALED] = VK_FORMAT_B8G8R8_USCALED, .aliases[FORMAT_ALIAS_SSCALED] = VK_FORMAT_B8G8R8_SSCALED,
+                  .aliases[FORMAT_ALIAS_UINT] = VK_FORMAT_B8G8R8_UINT, .aliases[FORMAT_ALIAS_SINT] = VK_FORMAT_B8G8R8_SINT);
+        case VK_FORMAT_R8G8B8A8_UNORM:
+        case VK_FORMAT_R8G8B8A8_SNORM:
+        case VK_FORMAT_R8G8B8A8_USCALED:
+        case VK_FORMAT_R8G8B8A8_SSCALED:
+        case VK_FORMAT_R8G8B8A8_UINT:
+        case VK_FORMAT_R8G8B8A8_SINT:
+        case VK_FORMAT_R8G8B8A8_SRGB:
+            GROUP(4, .aliases[FORMAT_ALIAS_SRGB] = VK_FORMAT_R8G8B8A8_SRGB,
+                  .aliases[FORMAT_ALIAS_UNORM] = VK_FORMAT_R8G8B8A8_UNORM, .aliases[FORMAT_ALIAS_SNORM] = VK_FORMAT_R8G8B8A8_SNORM,
+                  .aliases[FORMAT_ALIAS_USCALED] = VK_FORMAT_R8G8B8A8_USCALED, .aliases[FORMAT_ALIAS_SSCALED] = VK_FORMAT_R8G8B8A8_SSCALED,
+                  .aliases[FORMAT_ALIAS_UINT] = VK_FORMAT_R8G8B8A8_UINT, .aliases[FORMAT_ALIAS_SINT] = VK_FORMAT_R8G8B8A8_SINT);
+        case VK_FORMAT_B8G8R8A8_UNORM:
+        case VK_FORMAT_B8G8R8A8_SNORM:
+        case VK_FORMAT_B8G8R8A8_USCALED:
+        case VK_FORMAT_B8G8R8A8_SSCALED:
+        case VK_FORMAT_B8G8R8A8_UINT:
+        case VK_FORMAT_B8G8R8A8_SINT:
+        case VK_FORMAT_B8G8R8A8_SRGB:
+            GROUP(4, .aliases[FORMAT_ALIAS_SRGB] = VK_FORMAT_B8G8R8A8_SRGB,
+                  .aliases[FORMAT_ALIAS_UNORM] = VK_FORMAT_B8G8R8A8_UNORM, .aliases[FORMAT_ALIAS_SNORM] = VK_FORMAT_B8G8R8A8_SNORM,
+                  .aliases[FORMAT_ALIAS_USCALED] = VK_FORMAT_B8G8R8A8_USCALED, .aliases[FORMAT_ALIAS_SSCALED] = VK_FORMAT_B8G8R8A8_SSCALED,
+                  .aliases[FORMAT_ALIAS_UINT] = VK_FORMAT_B8G8R8A8_UINT, .aliases[FORMAT_ALIAS_SINT] = VK_FORMAT_B8G8R8A8_SINT);
+        case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
+        case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
+        case VK_FORMAT_A8B8G8R8_USCALED_PACK32:
+        case VK_FORMAT_A8B8G8R8_SSCALED_PACK32:
+        case VK_FORMAT_A8B8G8R8_UINT_PACK32:
+        case VK_FORMAT_A8B8G8R8_SINT_PACK32:
+        case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
+            GROUP(4, .aliases[FORMAT_ALIAS_SRGB] = VK_FORMAT_A8B8G8R8_SRGB_PACK32,
+                  .aliases[FORMAT_ALIAS_UNORM] = VK_FORMAT_A8B8G8R8_UNORM_PACK32, .aliases[FORMAT_ALIAS_SNORM] = VK_FORMAT_A8B8G8R8_SNORM_PACK32,
+                  .aliases[FORMAT_ALIAS_USCALED] = VK_FORMAT_A8B8G8R8_USCALED_PACK32, .aliases[FORMAT_ALIAS_SSCALED] = VK_FORMAT_A8B8G8R8_SSCALED_PACK32,
+                  .aliases[FORMAT_ALIAS_UINT] = VK_FORMAT_A8B8G8R8_UINT_PACK32, .aliases[FORMAT_ALIAS_SINT] = VK_FORMAT_A8B8G8R8_SINT_PACK32);
+        case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
+        case VK_FORMAT_A2R10G10B10_SNORM_PACK32:
+        case VK_FORMAT_A2R10G10B10_USCALED_PACK32:
+        case VK_FORMAT_A2R10G10B10_SSCALED_PACK32:
+        case VK_FORMAT_A2R10G10B10_UINT_PACK32:
+        case VK_FORMAT_A2R10G10B10_SINT_PACK32:
+            GROUP(4,
+                  .aliases[FORMAT_ALIAS_UNORM] = VK_FORMAT_A2R10G10B10_UNORM_PACK32, .aliases[FORMAT_ALIAS_SNORM] = VK_FORMAT_A2R10G10B10_SNORM_PACK32,
+                  .aliases[FORMAT_ALIAS_USCALED] = VK_FORMAT_A2R10G10B10_USCALED_PACK32, .aliases[FORMAT_ALIAS_SSCALED] = VK_FORMAT_A2R10G10B10_SSCALED_PACK32,
+                  .aliases[FORMAT_ALIAS_UINT] = VK_FORMAT_A2R10G10B10_UINT_PACK32, .aliases[FORMAT_ALIAS_SINT] = VK_FORMAT_A2R10G10B10_SINT_PACK32);
+        case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
+        case VK_FORMAT_A2B10G10R10_SNORM_PACK32:
+        case VK_FORMAT_A2B10G10R10_USCALED_PACK32:
+        case VK_FORMAT_A2B10G10R10_SSCALED_PACK32:
+        case VK_FORMAT_A2B10G10R10_UINT_PACK32:
+        case VK_FORMAT_A2B10G10R10_SINT_PACK32:
+            GROUP(4,
+                  .aliases[FORMAT_ALIAS_UNORM] = VK_FORMAT_A2B10G10R10_UNORM_PACK32, .aliases[FORMAT_ALIAS_SNORM] = VK_FORMAT_A2B10G10R10_SNORM_PACK32,
+                  .aliases[FORMAT_ALIAS_USCALED] = VK_FORMAT_A2B10G10R10_USCALED_PACK32, .aliases[FORMAT_ALIAS_SSCALED] = VK_FORMAT_A2B10G10R10_SSCALED_PACK32,
+                  .aliases[FORMAT_ALIAS_UINT] = VK_FORMAT_A2B10G10R10_UINT_PACK32, .aliases[FORMAT_ALIAS_SINT] = VK_FORMAT_A2B10G10R10_SINT_PACK32);
+        case VK_FORMAT_R16_UNORM:
+        case VK_FORMAT_R16_SNORM:
+        case VK_FORMAT_R16_USCALED:
+        case VK_FORMAT_R16_SSCALED:
+        case VK_FORMAT_R16_UINT:
+        case VK_FORMAT_R16_SINT:
+        case VK_FORMAT_R16_SFLOAT:
+            GROUP(2, .aliases[FORMAT_ALIAS_SFLOAT] = VK_FORMAT_R16_SFLOAT,
+                  .aliases[FORMAT_ALIAS_UNORM] = VK_FORMAT_R16_UNORM, .aliases[FORMAT_ALIAS_SNORM] = VK_FORMAT_R16_SNORM,
+                  .aliases[FORMAT_ALIAS_USCALED] = VK_FORMAT_R16_USCALED, .aliases[FORMAT_ALIAS_SSCALED] = VK_FORMAT_R16_SSCALED,
+                  .aliases[FORMAT_ALIAS_UINT] = VK_FORMAT_R16_UINT, .aliases[FORMAT_ALIAS_SINT] = VK_FORMAT_R16_SINT);
+        case VK_FORMAT_R16G16_UNORM:
+        case VK_FORMAT_R16G16_SNORM:
+        case VK_FORMAT_R16G16_USCALED:
+        case VK_FORMAT_R16G16_SSCALED:
+        case VK_FORMAT_R16G16_UINT:
+        case VK_FORMAT_R16G16_SINT:
+        case VK_FORMAT_R16G16_SFLOAT:
+            GROUP(4, .aliases[FORMAT_ALIAS_SFLOAT] = VK_FORMAT_R16G16_SFLOAT,
+                  .aliases[FORMAT_ALIAS_UNORM] = VK_FORMAT_R16G16_UNORM, .aliases[FORMAT_ALIAS_SNORM] = VK_FORMAT_R16G16_SNORM,
+                  .aliases[FORMAT_ALIAS_USCALED] = VK_FORMAT_R16G16_USCALED, .aliases[FORMAT_ALIAS_SSCALED] = VK_FORMAT_R16G16_SSCALED,
+                  .aliases[FORMAT_ALIAS_UINT] = VK_FORMAT_R16G16_UINT, .aliases[FORMAT_ALIAS_SINT] = VK_FORMAT_R16G16_SINT);
+        case VK_FORMAT_R16G16B16_UNORM:
+        case VK_FORMAT_R16G16B16_SNORM:
+        case VK_FORMAT_R16G16B16_USCALED:
+        case VK_FORMAT_R16G16B16_SSCALED:
+        case VK_FORMAT_R16G16B16_UINT:
+        case VK_FORMAT_R16G16B16_SINT:
+        case VK_FORMAT_R16G16B16_SFLOAT:
+            GROUP(6, .aliases[FORMAT_ALIAS_SFLOAT] = VK_FORMAT_R16G16B16_SFLOAT,
+                  .aliases[FORMAT_ALIAS_UNORM] = VK_FORMAT_R16G16B16_UNORM, .aliases[FORMAT_ALIAS_SNORM] = VK_FORMAT_R16G16B16_SNORM,
+                  .aliases[FORMAT_ALIAS_USCALED] = VK_FORMAT_R16G16B16_USCALED, .aliases[FORMAT_ALIAS_SSCALED] = VK_FORMAT_R16G16B16_SSCALED,
+                  .aliases[FORMAT_ALIAS_UINT] = VK_FORMAT_R16G16B16_UINT, .aliases[FORMAT_ALIAS_SINT] = VK_FORMAT_R16G16B16_SINT);
+        case VK_FORMAT_R16G16B16A16_UNORM:
+        case VK_FORMAT_R16G16B16A16_SNORM:
+        case VK_FORMAT_R16G16B16A16_USCALED:
+        case VK_FORMAT_R16G16B16A16_SSCALED:
+        case VK_FORMAT_R16G16B16A16_UINT:
+        case VK_FORMAT_R16G16B16A16_SINT:
+        case VK_FORMAT_R16G16B16A16_SFLOAT:
+            GROUP(8, .aliases[FORMAT_ALIAS_SFLOAT] = VK_FORMAT_R16G16B16A16_SFLOAT,
+                  .aliases[FORMAT_ALIAS_UNORM] = VK_FORMAT_R16G16B16A16_UNORM, .aliases[FORMAT_ALIAS_SNORM] = VK_FORMAT_R16G16B16A16_SNORM,
+                  .aliases[FORMAT_ALIAS_USCALED] = VK_FORMAT_R16G16B16A16_USCALED, .aliases[FORMAT_ALIAS_SSCALED] = VK_FORMAT_R16G16B16A16_SSCALED,
+                  .aliases[FORMAT_ALIAS_UINT] = VK_FORMAT_R16G16B16A16_UINT, .aliases[FORMAT_ALIAS_SINT] = VK_FORMAT_R16G16B16A16_SINT);
+        case VK_FORMAT_R32_UINT:
+        case VK_FORMAT_R32_SINT:
+        case VK_FORMAT_R32_SFLOAT:
+            GROUP(4, .aliases[FORMAT_ALIAS_SFLOAT] = VK_FORMAT_R32_SFLOAT,
+                  .aliases[FORMAT_ALIAS_UINT] = VK_FORMAT_R32_UINT, .aliases[FORMAT_ALIAS_SINT] = VK_FORMAT_R32_SINT);
+        case VK_FORMAT_R32G32_UINT:
+        case VK_FORMAT_R32G32_SINT:
+        case VK_FORMAT_R32G32_SFLOAT:
+            GROUP(8, .aliases[FORMAT_ALIAS_SFLOAT] = VK_FORMAT_R32G32_SFLOAT,
+                  .aliases[FORMAT_ALIAS_UINT] = VK_FORMAT_R32G32_UINT, .aliases[FORMAT_ALIAS_SINT] = VK_FORMAT_R32G32_SINT);
+        case VK_FORMAT_R32G32B32_UINT:
+        case VK_FORMAT_R32G32B32_SINT:
+        case VK_FORMAT_R32G32B32_SFLOAT:
+            GROUP(12, .aliases[FORMAT_ALIAS_SFLOAT] = VK_FORMAT_R32G32B32_SFLOAT,
+                  .aliases[FORMAT_ALIAS_UINT] = VK_FORMAT_R32G32B32_UINT, .aliases[FORMAT_ALIAS_SINT] = VK_FORMAT_R32G32B32_SINT);
+        case VK_FORMAT_R32G32B32A32_UINT:
+        case VK_FORMAT_R32G32B32A32_SINT:
+        case VK_FORMAT_R32G32B32A32_SFLOAT:
+            GROUP(16, .aliases[FORMAT_ALIAS_SFLOAT] = VK_FORMAT_R32G32B32A32_SFLOAT,
+                  .aliases[FORMAT_ALIAS_UINT] = VK_FORMAT_R32G32B32A32_UINT, .aliases[FORMAT_ALIAS_SINT] = VK_FORMAT_R32G32B32A32_SINT);
+        case VK_FORMAT_R64_UINT:
+        case VK_FORMAT_R64_SINT:
+        case VK_FORMAT_R64_SFLOAT:
+            GROUP(8, .aliases[FORMAT_ALIAS_SFLOAT] = VK_FORMAT_R64_SFLOAT,
+                  .aliases[FORMAT_ALIAS_UINT] = VK_FORMAT_R64_UINT, .aliases[FORMAT_ALIAS_SINT] = VK_FORMAT_R64_SINT);
+        case VK_FORMAT_R64G64_UINT:
+        case VK_FORMAT_R64G64_SINT:
+        case VK_FORMAT_R64G64_SFLOAT:
+            GROUP(16, .aliases[FORMAT_ALIAS_SFLOAT] = VK_FORMAT_R64G64_SFLOAT,
+                  .aliases[FORMAT_ALIAS_UINT] = VK_FORMAT_R64G64_UINT, .aliases[FORMAT_ALIAS_SINT] = VK_FORMAT_R64G64_SINT);
+        case VK_FORMAT_R64G64B64_UINT:
+        case VK_FORMAT_R64G64B64_SINT:
+        case VK_FORMAT_R64G64B64_SFLOAT:
+            GROUP(24, .aliases[FORMAT_ALIAS_SFLOAT] = VK_FORMAT_R64G64B64_SFLOAT,
+                  .aliases[FORMAT_ALIAS_UINT] = VK_FORMAT_R64G64B64_UINT, .aliases[FORMAT_ALIAS_SINT] = VK_FORMAT_R64G64B64_SINT);
+        case VK_FORMAT_R64G64B64A64_UINT:
+        case VK_FORMAT_R64G64B64A64_SINT:
+        case VK_FORMAT_R64G64B64A64_SFLOAT:
+            GROUP(32, .aliases[FORMAT_ALIAS_SFLOAT] = VK_FORMAT_R64G64B64A64_SFLOAT,
+                  .aliases[FORMAT_ALIAS_UINT] = VK_FORMAT_R64G64B64A64_UINT, .aliases[FORMAT_ALIAS_SINT] = VK_FORMAT_R64G64B64A64_SINT);
+        case VK_FORMAT_R10X6_UNORM_PACK16:                 GROUP(2, .aliases[FORMAT_ALIAS_UNORM] = VK_FORMAT_R10X6_UNORM_PACK16);
+        case VK_FORMAT_R10X6G10X6_UNORM_2PACK16:           GROUP(4, .aliases[FORMAT_ALIAS_UNORM] = VK_FORMAT_R10X6G10X6_UNORM_2PACK16);
+        case VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16: GROUP(8, .aliases[FORMAT_ALIAS_UNORM] = VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16);
+        case VK_FORMAT_R12X4_UNORM_PACK16:                 GROUP(2, .aliases[FORMAT_ALIAS_UNORM] = VK_FORMAT_R12X4_UNORM_PACK16);
+        case VK_FORMAT_R12X4G12X4_UNORM_2PACK16:           GROUP(4, .aliases[FORMAT_ALIAS_UNORM] = VK_FORMAT_R12X4G12X4_UNORM_2PACK16);
+        case VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16: GROUP(8, .aliases[FORMAT_ALIAS_UNORM] = VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16);
+        case VK_FORMAT_A4R4G4B4_UNORM_PACK16:              GROUP(2, .aliases[FORMAT_ALIAS_UNORM] = VK_FORMAT_A4R4G4B4_UNORM_PACK16);
+        case VK_FORMAT_A4B4G4R4_UNORM_PACK16:              GROUP(2, .aliases[FORMAT_ALIAS_UNORM] = VK_FORMAT_A4B4G4R4_UNORM_PACK16);
+        case VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR:          GROUP(2, .aliases[FORMAT_ALIAS_UNORM] = VK_FORMAT_A1B5G5R5_UNORM_PACK16_KHR);
+        case VK_FORMAT_A8_UNORM_KHR:                       GROUP(1, .aliases[FORMAT_ALIAS_UNORM] = VK_FORMAT_A8_UNORM_KHR);
+        default: GROUP(0);
+    }
+#undef GROUP
 }
 
 void VKUtil_LogResultError(const char* string, VkResult result) {

src/java.desktop/share/native/common/java2d/vulkan/VKUtil.h

@@ -33,6 +33,16 @@
 #define C_ARRAY_UTIL_ALLOCATION_FAILED() VK_FATAL_ERROR("CArrayUtil allocation failed")
 #include "CArrayUtil.h"
 
+// VK_DEBUG_RANDOM may be used to randomly tune some parameters and turn off some features,
+// which would allow to cover wider range of scenarios and catch configuration-specific errors early.
+// In debug builds it returns 1 with approximately CHANCE_PERCENT chance, on release builds it is always 0.
+// When using this macro, make sure to leave sufficient info in the log to track failing configurations.
+#ifdef DEBUG
+#define VK_DEBUG_RANDOM(CHANCE_PERCENT) ((rand() % 100) < CHANCE_PERCENT)
+#else
+#define VK_DEBUG_RANDOM(CHANCE_PERCENT) 0
+#endif
+
 // Useful logging & result checking macros
 void VKUtil_LogResultError(const char* string, VkResult result);
 inline VkBool32 VKUtil_CheckError(VkResult result, const char* errorMessage) {
@@ -58,27 +68,62 @@ inline VkBool32 VKUtil_CheckError(VkResult result, const char* errorMessage) {
 #define VK_RUNTIME_ASSERT(...) if (!(__VA_ARGS__)) VK_FATAL_ERROR("Vulkan assertion failed: " #__VA_ARGS__)
 
 /**
- * Vulkan expects linear colors.
- * However Java2D expects legacy behavior, as if colors were blended in sRGB color space.
- * Therefore this function just remaps color components from [0, 255] to [0, 1] range,
- * they still represent sRGB color.
- * This is also accounted for in VKSD_ConfigureWindowSurface, so that Vulkan doesn't do any
- * color space conversions on its own, as the colors we are drawing are already in sRGB.
+ * Set format-aliased handle.
+ * CHECK is anything which can be used for matching handle check, usually format aliases.
+ * It executes a loop for each of two unique format aliases (FORMAT_ALIAS_ORIGINAL and FORMAT_ALIAS_UNORM).
+ * If CHECK is the same for both format aliases, only one iteration for FORMAT_ALIAS_ORIGINAL is executed,
+ * and FORMAT_ALIAS_UNORM handle alias is copied from FORMAT_ALIAS_ORIGINAL.
+ *
+ * See FORMAT_ALIASED and VKRenderer_GetFormatAliasForRenderPass for more details.
  */
-Color VKUtil_DecodeJavaColor(uint32_t color);
+#define SET_FORMAT_ALIASED_HANDLE(HANDLE, CHECK, ALIAS) for (FormatAlias (ALIAS) = FORMAT_ALIAS_ORIGINAL; \
+    (ALIAS) == FORMAT_ALIAS_ORIGINAL || ((ALIAS) == FORMAT_ALIAS_UNORM &&                                 \
+    ((CHECK)[FORMAT_ALIAS_UNORM] != (CHECK)[FORMAT_ALIAS_ORIGINAL] ||                                     \
+    (((HANDLE)[FORMAT_ALIAS_UNORM] = (HANDLE)[FORMAT_ALIAS_ORIGINAL]) && 0))); (ALIAS)++)
 
-/*
- * The following macros allow the caller to return (or continue) if the
- * provided value is NULL.  (The strange else clause is included below to
- * allow for a trailing ';' after RETURN/CONTINUE_IF_NULL() invocations.)
+typedef enum {
+    FORMAT_ALIAS_ORIGINAL = 0,
+    FORMAT_ALIAS_UNORM    = 1,
+    FORMAT_ALIAS_SNORM    = 2,
+    FORMAT_ALIAS_USCALED  = 3,
+    FORMAT_ALIAS_SSCALED  = 4,
+    FORMAT_ALIAS_UINT     = 5,
+    FORMAT_ALIAS_SINT     = 6,
+    FORMAT_ALIAS_SFLOAT   = 7,
+    FORMAT_ALIAS_SRGB     = 8,
+    FORMAT_ALIAS_COUNT    = 9
+} FormatAlias;
+
+/**
+ * Group of format aliases. Use FormatAlias enum values to index into FormatGroup.aliases.
  */
-#define ACT_IF_NULL(ACTION, value)         \
-    if ((value) == NULL) {                 \
-        J2dTraceLn1(J2D_TRACE_ERROR,       \
-                    "%s is null", #value); \
-        ACTION;                            \
-    } else do { } while (0)
-#define RETURN_IF_NULL(value)   ACT_IF_NULL(return, value)
-#define CONTINUE_IF_NULL(value) ACT_IF_NULL(continue, value)
+typedef struct {
+    VkFormat aliases[FORMAT_ALIAS_COUNT];
+    uint     bytes;
+} FormatGroup;
+
+/**
+ * Convert 32-bit sRGB encoded straight-alpha Java color to [0, 1] normalized
+ * floating-point representation with pre-multiplied alpha in both linear and sRGB color space.
+ * You never need to use linear or sRGB variants directly, use VKRenderer_GetColorForRenderPass instead.
+ *
+ * Read more about presenting sRGB content in VKSD_ConfigureWindowSurface.
+ *
+ * Note: we receive colors from Java with straight (non-premultiplied) alpha, which is unusual.
+ * This is controlled by PixelConverter parameter of SurfaceType, see VKSurfaceData.java.
+ * This is done to prevent precision loss and redundant conversions,
+ * as we need straight alpha to convert from sRGB to linear color space anyway.
+ */
+CorrectedColor VKUtil_DecodeJavaColor(uint32_t color);
+
+/**
+ * Integer log2, the same as index of highest set bit.
+ */
+uint32_t VKUtil_Log2(uint64_t i);
+
+/**
+ * Get group of formats with the same component layout.
+ */
+FormatGroup VKUtil_GetFormatGroup(VkFormat format);
 
 #endif //VKUtil_h_Included

src/java.desktop/unix/classes/sun/java2d/vulkan/WLVKSurfaceData.java

@@ -46,7 +46,6 @@ public abstract class WLVKSurfaceData extends VKSurfaceData implements WLSurface
     private static final PlatformLogger log = PlatformLogger.getLogger("sun.java2d.vulkan.WLVKSurfaceData");
 
     protected WLComponentPeer peer;
-    protected WLVKGraphicsConfig graphicsConfig;
 
     private native void initOps(int backgroundRGB);
 
@@ -57,13 +56,18 @@ public abstract class WLVKSurfaceData extends VKSurfaceData implements WLSurface
     {
         super(gc, cm, type, 0, 0);
         this.peer = peer;
-        this.graphicsConfig = gc;
         final int backgroundRGB = peer.getBackground() != null
                 ? peer.getBackground().getRGB()
                 : 0;
         initOps(backgroundRGB);
     }
 
+    private void bufferAttached() {
+        // Called from the native code when a buffer has just been attached to this surface
+        // but the surface has not been committed yet.
+        peer.updateSurfaceSize();
+    }
+
     @Override
     public void assignSurface(long surfacePtr) {
         assignWlSurface(surfacePtr);
@@ -85,8 +89,8 @@ public abstract class WLVKSurfaceData extends VKSurfaceData implements WLSurface
             rq.ensureCapacityAndAlignment(20, 4);
             buf.putInt(CONFIGURE_SURFACE);
             buf.putLong(getNativeOps());
-            buf.putInt(width / scale); // TODO This is incorrect, but we'll deal with this later, we probably need to do something on Wayland side for app-controlled scaling
-            buf.putInt(height / scale); // TODO This is incorrect, but we'll deal with this later, we probably need to do something on Wayland side for app-controlled scaling
+            buf.putInt(width);
+            buf.putInt(height);
 
             rq.flushNow();
         } finally {
@@ -115,8 +119,9 @@ public abstract class WLVKSurfaceData extends VKSurfaceData implements WLSurface
         return false;
     }
 
+    @Override
     public GraphicsConfiguration getDeviceConfiguration() {
-        return graphicsConfig;
+        return peer.getGraphicsConfiguration();
     }
 
     /**
@@ -180,7 +185,7 @@ public abstract class WLVKSurfaceData extends VKSurfaceData implements WLSurface
 
         @Override
         public BufferedContext getContext() {
-            return graphicsConfig.getContext();
+            return ((WLVKGraphicsConfig) getDeviceConfiguration()).getContext();
         }
 
         @Override

src/java.desktop/unix/native/common/java2d/vulkan/WLVKSurfaceData.c

@@ -30,6 +30,11 @@
 #include "VKUtil.h"
 #include "VKSurfaceData.h"
 
+static void WLVKSurfaceData_OnResize(VKWinSDOps* surface, VkExtent2D extent) {
+    JNIEnv* env = (JNIEnv*)JNU_GetEnv(jvm, JNI_VERSION_1_2);
+    JNU_CallMethodByName(env, NULL, surface->vksdOps.sdOps.sdObject, "bufferAttached", "()V");
+}
+
 JNIEXPORT void JNICALL Java_sun_java2d_vulkan_WLVKSurfaceData_initOps(JNIEnv *env, jobject vksd, jint backgroundRGB) {
     J2dTraceLn1(J2D_TRACE_VERBOSE, "WLVKSurfaceData_initOps(%p)", vksd);
     VKWinSDOps* sd = (VKWinSDOps*)SurfaceData_InitOps(env, vksd, sizeof(VKWinSDOps));
@@ -39,6 +44,7 @@ JNIEXPORT void JNICALL Java_sun_java2d_vulkan_WLVKSurfaceData_initOps(JNIEnv *en
     }
     sd->vksdOps.drawableType = VKSD_WINDOW;
     sd->vksdOps.background = VKUtil_DecodeJavaColor(backgroundRGB);
+    sd->resizeCallback = WLVKSurfaceData_OnResize;
     VKSD_ResetSurface(&sd->vksdOps);
 }
 

src/jdk.jfr/share/classes/jdk/jfr/internal/dcmd/ArgumentParser.java

@@ -221,7 +221,7 @@ final class ArgumentParser {
 
     private Object value(String name, String type, String text) {
         return switch (type) {
-            case "JULONG" -> parseLong(name, text);
+            case "INT" -> parseLong(name, text);
             case "STRING", "STRING SET" -> text == null ? "" : text;
             case "BOOLEAN" -> parseBoolean(name, text);
             case "NANOTIME" -> parseNanotime(name, text);
@@ -361,4 +361,4 @@ final class ArgumentParser {
             }
         }
     }
-}
+}

src/jdk.jfr/share/classes/jdk/jfr/internal/dcmd/DCmdDump.java

@@ -237,7 +237,7 @@ final class DCmdDump extends AbstractDCmd {
                                   'yyyy_MM_dd_HH_mm_ss' format.
 
                  maxage           (Optional) Length of time for dumping the flight recording data to a
-                                  file. (INTEGER followed by 's' for seconds 'm' for minutes or 'h' for
+                                  file. (INT followed by 's' for seconds 'm' for minutes or 'h' for
                                   hours, no default value)
 
                  maxsize          (Optional) Maximum size for the amount of data to dump from a flight

src/jdk.jfr/share/classes/jdk/jfr/internal/dcmd/DCmdQuery.java

@@ -141,7 +141,7 @@ public final class DCmdQuery extends AbstractDCmd {
 
                 Options:
 
-                  maxage     (Optional) Length of time for the query to span. (INTEGER followed by
+                  maxage     (Optional) Length of time for the query to span. (INT followed by
                              's' for seconds 'm' for minutes or 'h' for hours, no default value)
 
                   maxsize    (Optional) Maximum size for the query to span in bytes if one of
@@ -154,7 +154,7 @@ public final class DCmdQuery extends AbstractDCmd {
                   verbose    (Optional) Display additional information about the query execution.
                              (BOOLEAN, false)
 
-                  width      (Optional) Maximum number of horizontal characters. (BOOLEAN, false)""";
+                  width      (Optional) Maximum number of horizontal characters. (INT, default value is 100)""";
     }
 
     @Override
@@ -170,7 +170,7 @@ public final class DCmdQuery extends AbstractDCmd {
                     null, false),
             new Argument("verbose", "Display additional information about the query execution", "BOOLEAN", false,
                     true, "false", false),
-            new Argument("width", "Maximum number of horizontal characters", "JULONG", false, true, "100",
+            new Argument("width", "Maximum number of horizontal characters", "INT", false, true, "100",
                     false), };
     }
 }

src/jdk.jfr/share/classes/jdk/jfr/internal/dcmd/DCmdStart.java

@@ -353,7 +353,7 @@ final class DCmdStart extends AbstractDCmd {
                Options:
 
                  delay            (Optional) Length of time to wait before starting to record
-                                  (INTEGER followed by 's' for seconds 'm' for minutes or h' for
+                                  (INT followed by 's' for seconds 'm' for minutes or h' for
                                   hours, 0s)
 
                  disk             (Optional) Flag for also writing the data to disk while recording
@@ -368,7 +368,7 @@ final class DCmdStart extends AbstractDCmd {
                                   id-1-2021_09_14_09_00.jfr) (BOOLEAN, false)
 
                  duration         (Optional) Length of time to record. Note that 0s means forever
-                                  (INTEGER followed by 's' for seconds 'm' for minutes or 'h' for
+                                  (INT followed by 's' for seconds 'm' for minutes or 'h' for
                                   hours, 0s)
 
                  filename         (Optional) Name of the file to which the flight recording data is
@@ -385,7 +385,7 @@ final class DCmdStart extends AbstractDCmd {
 
                  maxage           (Optional) Maximum time to keep the recorded data on disk. This
                                   parameter is valid only when the disk parameter is set to true.
-                                  Note 0s means forever. (INTEGER followed by 's' for seconds 'm'
+                                  Note 0s means forever. (INT followed by 's' for seconds 'm'
                                   for minutes or 'h' for hours, 0s)
 
                  maxsize          (Optional) Maximum size of the data to keep on disk in bytes if

src/jdk.jfr/share/classes/jdk/jfr/internal/dcmd/DCmdView.java

@@ -108,9 +108,9 @@ public class DCmdView extends AbstractDCmd {
         return """
                 Options:
 
-                 cell-height   (Optional) Maximum number of rows in a table cell. (INTEGER, no default value)
+                 cell-height   (Optional) Maximum number of rows in a table cell. (INT, no default value)
 
-                 maxage        (Optional) Length of time for the view to span. (INTEGER followed by
+                 maxage        (Optional) Length of time for the view to span. (INT followed by
                                's' for seconds 'm' for minutes or 'h' for hours, default value is 10m)
 
                  maxsize       (Optional) Maximum size for the view to span in bytes if one of
@@ -127,7 +127,7 @@ public class DCmdView extends AbstractDCmd {
                                See list below for available views. (STRING, no default value)
 
                  width         (Optional) The width of the view in characters
-                               (INTEGER, no default value)""";
+                               (INT, default value is 100)""";
     }
 
     public String getExamples() {
@@ -136,7 +136,7 @@ public class DCmdView extends AbstractDCmd {
 
                  $ jcmd <pid> JFR.view gc
 
-                 $ jcmd <pid< JFR.view width=160 hot-methods
+                 $ jcmd <pid> JFR.view width=160 hot-methods
 
                  $ jcmd <pid> JFR.view verbose=true allocation-by-class
 
@@ -154,7 +154,7 @@ public class DCmdView extends AbstractDCmd {
         return new Argument[] {
             new Argument("cell-height",
                 "Maximum heigth of a table cell",
-                "JULONG", false, true, "1", false),
+                "INT", false, true, "1", false),
             new Argument("maxage",
                 "Maximum duration of data to view, in (s)econds, (m)inutes, (h)ours, or (d)ays, e.g. 60m, or 0 for no limit",
                 "NANOTIME", false, true, "10m", false),
@@ -172,7 +172,7 @@ public class DCmdView extends AbstractDCmd {
                 "STRING", true, false, null, false),
             new Argument("width",
                 "Maximum number of horizontal characters",
-                "JULONG", false, true, "100", false)
+                "INT", false, true, "100", false)
         };
    }
 }

test/hotspot/jtreg/serviceability/dcmd/vm/SystemDumpMapTest.java

@@ -35,7 +35,7 @@ import java.util.regex.Pattern;
  * @test
  * @summary Test of diagnostic command System.map
  * @library /test/lib
- * @requires (os.family=="linux")
+ * @requires (os.family == "linux" | os.family == "windows")
  * @modules java.base/jdk.internal.misc
  *          java.compiler
  *          java.management
@@ -63,11 +63,11 @@ public class SystemDumpMapTest extends SystemMapTestBase {
             boolean NMTOff = output.contains("NMT is disabled");
             String regexBase = ".*0x\\p{XDigit}+ - 0x\\p{XDigit}+ +\\d+";
             HashSet<Pattern> patterns = new HashSet<>();
-            for (String s: shouldMatchUnconditionally) {
+            for (String s: shouldMatchUnconditionally()) {
                 patterns.add(Pattern.compile(s));
             }
             if (!NMTOff) { // expect VM annotations if NMT is on
-                for (String s: shouldMatchIfNMTIsEnabled) {
+                for (String s: shouldMatchIfNMTIsEnabled()) {
                     patterns.add(Pattern.compile(s));
                 }
             }

test/hotspot/jtreg/serviceability/dcmd/vm/SystemMapTest.java

@@ -31,7 +31,7 @@ import jdk.test.lib.process.OutputAnalyzer;
  * @test
  * @summary Test of diagnostic command System.map
  * @library /test/lib
- * @requires (os.family=="linux")
+ * @requires (os.family == "linux" | os.family == "windows")
  * @modules java.base/jdk.internal.misc
  *          java.compiler
  *          java.management
@@ -42,11 +42,11 @@ public class SystemMapTest extends SystemMapTestBase {
     public void run(CommandExecutor executor) {
         OutputAnalyzer output = executor.execute("System.map");
         boolean NMTOff = output.contains("NMT is disabled");
-        for (String s: shouldMatchUnconditionally) {
+        for (String s: shouldMatchUnconditionally()) {
             output.shouldMatch(s);
         }
         if (!NMTOff) { // expect VM annotations if NMT is on
-            for (String s: shouldMatchIfNMTIsEnabled) {
+            for (String s: shouldMatchIfNMTIsEnabled()) {
                 output.shouldMatch(s);
             }
         }

test/hotspot/jtreg/serviceability/dcmd/vm/SystemMapTestBase.java

@@ -22,6 +22,8 @@
  * questions.
  */
 
+import jdk.test.lib.Platform;
+
 public class SystemMapTestBase {
 
     // e.g.
@@ -29,6 +31,7 @@ public class SystemMapTestBase {
     private static final String range = "0x\\p{XDigit}+-0x\\p{XDigit}+";
     private static final String space = " +";
     private static final String someSize = "\\d+";
+    private static final String someNumber = "(0x\\p{XDigit}+|\\d+)";
     private static final String pagesize = "(4K|8K|16K|64K|2M|16M|64M)";
     private static final String prot = "[rwsxp-]+";
 
@@ -44,7 +47,8 @@ public class SystemMapTestBase {
 
     // java heap is either committed, non-shared, or - in case of ZGC - committed and shared.
     private static final String regexBase_java_heap = regexBase + "(shrd,)?com.*";
-    protected static final String shouldMatchUnconditionally[] = {
+
+    private static final String shouldMatchUnconditionally_linux[] = {
         // java launcher
         regexBase_committed + "/bin/java",
         // libjvm
@@ -55,7 +59,7 @@ public class SystemMapTestBase {
         regexBase_shared_and_committed + "hsperfdata_.*"
     };
 
-    protected static final String shouldMatchIfNMTIsEnabled[] = {
+    private static final String shouldMatchIfNMTIsEnabled_linux[] = {
         regexBase_java_heap + "JAVAHEAP.*",
         // metaspace
         regexBase_committed + "META.*",
@@ -66,4 +70,43 @@ public class SystemMapTestBase {
         // Main thread stack
         regexBase_committed + "STACK.*main.*"
     };
+
+    // windows:
+    private static final String winprot = "[\\-rwxcin]*";
+    private static final String wintype = "[rc]-(img|map|pvt)";
+
+    private static final String winbase = range + space + someSize + space + winprot + space;
+
+    private static final String winimage     = winbase + "c-img" + space + someNumber + space;
+    private static final String wincommitted = winbase + "(c-pvt|c-map)" + space + someNumber + space;
+    private static final String winreserved  = winbase + "r-pvt" + space + someNumber + space;
+
+    private static final String shouldMatchUnconditionally_windows[] = {
+        // java launcher
+        winimage + ".*[\\/\\\\]bin[\\/\\\\]java[.]exe",
+        // libjvm
+        winimage + ".*[\\/\\\\]bin[\\/\\\\].*[\\/\\\\]jvm.dll"
+    };
+
+    private static final String shouldMatchIfNMTIsEnabled_windows[] = {
+        wincommitted + "JAVAHEAP.*",
+        // metaspace
+        wincommitted + "META.*",
+        // parts of metaspace should be uncommitted
+        winreserved + "META.*",
+        // code cache
+        wincommitted + "CODE.*",
+        // Main thread stack
+        wincommitted + "STACK-\\d+-main.*"
+    };
+
+    private static final boolean isWindows = Platform.isWindows();
+
+    protected static String[] shouldMatchUnconditionally() {
+        return isWindows ? shouldMatchUnconditionally_windows : shouldMatchUnconditionally_linux;
+    }
+    protected static String[] shouldMatchIfNMTIsEnabled() {
+        return isWindows ? shouldMatchIfNMTIsEnabled_windows : shouldMatchIfNMTIsEnabled_linux;
+    }
+
 }

test/jdk/ProblemList.txt

@@ -788,3 +788,4 @@ java/awt/FullScreen/TranslucentWindow/TranslucentWindow.java 8258103 linux-all
 java/awt/Focus/FrameMinimizeTest/FrameMinimizeTest.java 8016266 linux-x64
 java/awt/Frame/SizeMinimizedTest.java 8305915 linux-x64
 java/awt/PopupMenu/PopupHangTest.java 8340022 windows-all
+java/awt/Focus/MinimizeNonfocusableWindowTest.java 8024487 windows-all

test/jdk/java/awt/Focus/MinimizeNonfocusableWindowTest.java

@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2011, 2024, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 6399659
+ * @summary   When minimizing non-focusable window focus shouldn't jump out of the focused window.
+ * @library /java/awt/regtesthelpers
+ * @build PassFailJFrame
+ * @run main/manual MinimizeNonfocusableWindowTest
+*/
+
+import java.awt.Frame;
+import java.awt.Window;
+import java.util.List;
+
+public class MinimizeNonfocusableWindowTest {
+
+    private static final String INSTRUCTIONS = """
+
+             You should see three frames: Frame-1, Frame-2 and Unfocusable.
+
+             1. Click Frame-1 to make it focused window, then click Frame-2.
+                Minimize Unfocusable frame with the mouse. If Frame-2 is still
+                the focused window continue testing, otherwise press FAIL.
+
+             2. Restore Unfocusable frame to normal state. Try to resize by dragging
+                its edge with left mouse button. It should be resizable. If not press
+                FAIL. Try the same with right mouse button. It shouldn't resize.
+                If it does, press FAIL, otherwise press PASS.""";
+
+    public static void main(String[] args) throws Exception {
+        PassFailJFrame.builder()
+                .title("MinimizeNonfocusableWindowTest Instructions")
+                .instructions(INSTRUCTIONS)
+                .rows((int) INSTRUCTIONS.lines().count() + 1)
+                .columns(40)
+                .testUI(MinimizeNonfocusableWindowTest::createTestUI)
+                .build()
+                .awaitAndCheck();
+    }
+
+    private static List<Window> createTestUI() {
+        Frame frame1 = new Frame("Frame-1");
+        Frame frame2 = new Frame("Frame-2");
+        Frame frame3 = new Frame("Unfocusable");
+        frame1.setBounds(100, 0, 200, 100);
+        frame2.setBounds(100, 150, 200, 100);
+        frame3.setBounds(100, 300, 200, 100);
+
+        frame3.setFocusableWindowState(false);
+
+        return List.of(frame1, frame2, frame3);
+    }
+}
+

test/jdk/java/awt/Focus/WindowDisposeFocusTest.java

@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 1999, 2024, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 4257071 4228379
+ * @summary Ensures that focus lost is delivered to a lightweight component
+            in a disposed window
+ * @library /java/awt/regtesthelpers
+ * @build PassFailJFrame
+ * @run main/manual WindowDisposeFocusTest
+*/
+
+import java.awt.Window;
+import java.awt.event.WindowAdapter;
+import java.awt.event.WindowEvent;
+import javax.swing.JButton;
+import javax.swing.JDialog;
+import javax.swing.JFrame;
+import javax.swing.JPanel;
+
+public class WindowDisposeFocusTest {
+
+    private static final String INSTRUCTIONS = """
+         Click on "Second"
+         Click on close box
+         When dialog pops up, "Second" should no longer have focus.""";
+
+    public static void main(String[] args) throws Exception {
+        PassFailJFrame.builder()
+                .title("WindowDisposeFocusTest Instructions")
+                .instructions(INSTRUCTIONS)
+                .rows((int) INSTRUCTIONS.lines().count() + 2)
+                .columns(35)
+                .testUI(WindowDisposeFocusTest::createTestUI)
+                .build()
+                .awaitAndCheck();
+    }
+
+    private static Window createTestUI() {
+        return JFCFocusBug2.test(new String[]{});
+    }
+}
+
+class JFCFocusBug2 extends JPanel {
+
+    static public Window test(String[] args) {
+        final JFrame frame = new JFrame("WindowDisposeFrame");
+        frame.setSize(100, 100);
+        frame.setVisible(true);
+
+        final JFCFocusBug2 bug = new JFCFocusBug2();
+        final JDialog dialog = new JDialog(frame, false);
+        dialog.addWindowListener(new WindowAdapter() {
+            public void windowClosing(WindowEvent e) {
+                dialog.dispose();
+                JDialog dialog2 = new JDialog(frame, false);
+                dialog2.setContentPane(bug);
+                dialog2.pack();
+                dialog2.setVisible(true);
+            }
+        });
+        dialog.setContentPane(bug);
+        dialog.pack();
+        dialog.setVisible(true);
+        return frame;
+    }
+
+    public JFCFocusBug2() {
+        _first = new JButton("First");
+        _second = new JButton("Second");
+        add(_first);
+        add(_second);
+    }
+
+    private JButton _first;
+    private JButton _second;
+}

test/jdk/java/awt/Focus/bug6435715.java

@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2006, 2024, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 6435715
+ * @summary JButton stops receiving the focusGained event and eventually focus is lost altogether
+ * @modules java.desktop/sun.awt
+ * @library /java/awt/regtesthelpers
+ * @build PassFailJFrame
+ * @run main/manual bug6435715
+ */
+
+import java.awt.event.FocusAdapter;
+import java.awt.event.FocusEvent;
+import javax.swing.JButton;
+import javax.swing.JFrame;
+import javax.swing.JPanel;
+
+public class bug6435715 {
+
+    private static final String INSTRUCTIONS = """
+            1. after test started you will see frame with three buttons. Notice that focus is on Button2.
+            2. Click on Button 3. Focus goes to Button3.
+            3. Click on Button1 and quickly switch to another window. Via either alt/tab or
+            clicking another window with the mouse.
+            4. After a few seconds, come back to the frame. Notice that focus is around Button2
+            5. Click at Button3. If focus remains at Button2 test failed, if focus is on Button3 - test passed.""";
+
+    public static void main(String[] args) throws Exception {
+        PassFailJFrame.builder()
+                .title("bug6435715 Instructions")
+                .instructions(INSTRUCTIONS)
+                .rows((int) INSTRUCTIONS.lines().count() + 5)
+                .columns(35)
+                .testUI(bug6435715::createTestUI)
+                .build()
+                .awaitAndCheck();
+    }
+
+    private static JFrame createTestUI() {
+        JFrame fr = new JFrame("FocusIssue");
+        sun.awt.SunToolkit.setLWRequestStatus(fr, true);
+
+        JPanel panel = new JPanel();
+        final JButton b1 = new JButton("Button 1");
+        final JButton b2 = new JButton("Button 2");
+        final JButton b3 = new JButton("Button 3");
+
+        panel.add(b1);
+        panel.add(b2);
+        panel.add(b3);
+
+        b1.addFocusListener(new FocusAdapter() {
+            public void focusGained(FocusEvent event) {
+                synchronized (this) {
+                    try {
+                        wait(1000);
+                    } catch (Exception ex) {
+                        ex.printStackTrace();
+                    }
+                    b2.requestFocus();
+                }
+            }
+        });
+        fr.getContentPane().add(panel);
+        fr.pack();
+        return fr;
+    }
+
+}

test/jdk/java/awt/Label/ContainerValidateTest.java

@@ -0,0 +1,169 @@
+/*
+ * Copyright (c) 1999, 2024, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+import java.awt.BorderLayout;
+import java.awt.Button;
+import java.awt.EventQueue;
+import java.awt.Frame;
+import java.awt.Label;
+import java.awt.Panel;
+import java.awt.Rectangle;
+import java.awt.Robot;
+import java.awt.TextField;
+import java.awt.event.InputEvent;
+import java.awt.event.MouseEvent;
+import java.awt.event.MouseListener;
+
+/*
+ * @test
+ * @key headful
+ * @bug 4247913
+ * @summary Tests that Label repaints after call Container.validate()
+ * @run main ContainerValidateTest
+ */
+
+public class ContainerValidateTest extends Frame implements MouseListener {
+    private static Robot robot;
+    private static Panel currentPanel;
+    private static Button currentBtn;
+    private static Panel updatedPanel;
+    private static Label updatedLabel;
+    private static TextField updatedTxtField;
+    private static Button updatedBtn;
+
+    private static volatile Rectangle btnBounds;
+
+    Panel pnl1 = new Panel();
+    Panel pnl2 = new Panel();
+    Label lbl1 = new Label("Label 1");
+    Label lbl2 = new Label("Label 2");
+    TextField txt1 = new TextField("field1", 20);
+    TextField txt2 = new TextField("field2", 20);
+    Button btn1 = new Button("Swap 1");
+    Button btn2 = new Button("Swap 2");
+
+    public static void main(String[] args) throws Exception {
+        robot = new Robot();
+
+        ContainerValidateTest containerValidate = new ContainerValidateTest();
+        EventQueue.invokeAndWait(containerValidate::createAndShowUI);
+        robot.waitForIdle();
+        robot.delay(1000);
+
+        containerValidate.testUI();
+    }
+
+    private void createAndShowUI() {
+        this.setTitle("ContainerValidateTest Test");
+        pnl1.add(lbl1);
+        pnl1.add(txt1);
+        pnl1.add(btn1);
+
+        pnl2.add(lbl2);
+        pnl2.add(txt2);
+        pnl2.add(btn2);
+
+        btn1.addMouseListener(this);
+        btn2.addMouseListener(this);
+
+        this.add(pnl1, BorderLayout.CENTER);
+        pack();
+        setLocationRelativeTo(null);
+        setVisible(true);
+    }
+
+    private void testUI() throws Exception {
+        EventQueue.invokeAndWait(() -> btnBounds
+                = new Rectangle(btn1.getLocationOnScreen().x,
+                                btn1.getLocationOnScreen().y,
+                                btn1.getWidth(),
+                                btn1.getHeight()));
+        for (int i= 1; i < 4 ; i++) {
+            EventQueue.invokeAndWait(() -> {
+                currentPanel = (Panel) this.getComponent(0);
+                currentBtn = (Button) currentPanel.getComponent(2);
+            });
+
+            robot.mouseMove(btnBounds.x + (int) btnBounds.getWidth() / 2,
+                            btnBounds.y + (int) btnBounds.getHeight() / 2);
+            robot.mousePress(InputEvent.BUTTON1_DOWN_MASK);
+            robot.mouseRelease(InputEvent.BUTTON1_DOWN_MASK);
+            robot.waitForIdle();
+            //large delay set for completion of UI validate()
+            robot.delay(500);
+
+            EventQueue.invokeAndWait(() -> {
+                updatedPanel = (Panel) this.getComponent(0);
+                updatedLabel = (Label) updatedPanel.getComponent(0);
+                updatedTxtField = (TextField) updatedPanel.getComponent(1);
+                updatedBtn = (Button) updatedPanel.getComponent(2);
+            });
+            testPanelComponents(currentBtn.getLabel());
+        }
+    }
+
+    private void testPanelComponents(String btnLabel) {
+        if (btnLabel.equals("Swap 1")) {
+            if (!(updatedLabel.getText().equals(lbl2.getText())
+                  && updatedTxtField.getText().equals(txt2.getText())
+                  && updatedBtn.getLabel().equals(btn2.getLabel()))) {
+                throw new RuntimeException("Test Failed!! Labels not repainted"
+                                           + " after Container.validate()");
+            }
+        } else {
+            if (!(updatedLabel.getText().equals(lbl1.getText())
+                  && updatedTxtField.getText().equals(txt1.getText())
+                  && updatedBtn.getLabel().equals(btn1.getLabel()))) {
+                throw new RuntimeException("Test Failed!! Labels not repainted"
+                                           + " after Container.validate()");
+            }
+        }
+    }
+
+    @Override
+    public void mousePressed(MouseEvent evt) {
+        if (evt.getComponent() instanceof Button btn) {
+            if (btn.equals(btn1)) {
+                remove(pnl1);
+                add(pnl2, BorderLayout.CENTER);
+            } else {
+                remove(pnl2);
+                add(pnl1, BorderLayout.CENTER);
+            }
+            invalidate();
+            validate();
+        }
+    }
+
+    @Override
+    public void mouseReleased(MouseEvent e) {}
+
+    @Override
+    public void mouseEntered(MouseEvent e) {}
+
+    @Override
+    public void mouseExited(MouseEvent e) {}
+
+    @Override
+    public void mouseClicked(MouseEvent e) {}
+}

test/jdk/java/awt/TextField/SetEchoCharTest.java

@@ -0,0 +1,178 @@
+/*
+ * Copyright (c) 1999, 2024, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+import java.awt.Button;
+import java.awt.EventQueue;
+import java.awt.FlowLayout;
+import java.awt.Frame;
+import java.awt.Label;
+import java.awt.Point;
+import java.awt.Robot;
+import java.awt.TextField;
+import java.awt.Toolkit;
+import java.awt.datatransfer.Clipboard;
+import java.awt.datatransfer.StringSelection;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.InputEvent;
+import java.awt.event.KeyEvent;
+
+import jdk.test.lib.Platform;
+
+/*
+ * @test
+ * @bug 4124697
+ * @key headful
+ * @summary Make sure that after setting and then changing the echo
+ *         character again, the TextField continues to function as expected.
+ * @library /test/lib
+ * @build jdk.test.lib.Platform
+ * @run main SetEchoCharTest
+ */
+
+public class SetEchoCharTest {
+    private static Frame frame;
+    private static Robot robot;
+    private static TextField tfPassword;
+    private static Button btn1;
+    private static Button btn2;
+    private static volatile Point btn1Loc;
+    private static volatile Point btn2Loc;
+
+    private static final String CHANGE = "Change echo char";
+    private static final String PRINT = "Print text";
+    private static final String INITIAL_TEXT = "DefaultPwd";
+    private static final String CHANGED_TEXT = "NewPwd";
+    private static final char NEW_ECHO_CHAR = '*';
+
+    public static void main(String[] args) throws Exception {
+        try {
+            robot = new Robot();
+            robot.setAutoWaitForIdle(true);
+            robot.setAutoDelay(50);
+
+            EventQueue.invokeAndWait(() -> createAndShowUI());
+            robot.waitForIdle();
+            robot.delay(1000);
+
+            testEchoChar();
+            robot.waitForIdle();
+            robot.delay(200);
+
+            testNewEchoChar();
+            robot.waitForIdle();
+            robot.delay(200);
+        } finally {
+            EventQueue.invokeAndWait(() -> {
+                if (frame != null) {
+                    frame.dispose();
+                }
+            });
+        }
+    }
+
+    private static void createAndShowUI() {
+        frame = new Frame("SetEchoCharTest");
+        frame.setLayout(new FlowLayout());
+
+        Label label = new Label("Pwd:");
+        tfPassword = new TextField(INITIAL_TEXT, 10);
+        tfPassword.setEchoChar('X');
+        tfPassword.addActionListener((ActionListener) e -> {
+            if (e.getActionCommand().equals(CHANGED_TEXT)) {
+                //check the 2nd condition only if ActionEvent
+                //is triggered by changed text
+                if (!(tfPassword.getText().equals(CHANGED_TEXT)
+                    && tfPassword.getEchoChar() == NEW_ECHO_CHAR)) {
+                    throw new RuntimeException("Test Failed!!! TextField not working"
+                                               + " as expected after echo char change");
+                }
+            }
+        });
+        frame.add(label);
+        frame.add(tfPassword);
+
+        btn1 = new Button(PRINT);
+        btn1.addActionListener(new BtnActionListener());
+        frame.add(btn1);
+
+        btn2 = new Button(CHANGE);
+        btn2.addActionListener(new BtnActionListener());
+        frame.add(btn2);
+        frame.setSize(200,200);
+        frame.setLocationRelativeTo(null);
+        frame.setVisible(true);
+    }
+
+    private static void testEchoChar() throws Exception {
+        EventQueue.invokeAndWait(() -> {
+            btn1Loc = btn1.getLocationOnScreen();
+            btn2Loc = btn2.getLocationOnScreen();
+        });
+
+        robot.mouseMove(btn1Loc.x + btn1.getWidth() / 2,
+                        btn1Loc.y + btn1.getHeight() / 2);
+        robot.mousePress(InputEvent.BUTTON1_DOWN_MASK);
+        robot.mouseRelease(InputEvent.BUTTON1_DOWN_MASK);
+        robot.delay(1000);
+
+        robot.mouseMove(btn2Loc.x + btn2.getWidth() / 2,
+                        btn2Loc.y + btn2.getHeight() / 2);
+        robot.mousePress(InputEvent.BUTTON1_DOWN_MASK);
+        robot.mouseRelease(InputEvent.BUTTON1_DOWN_MASK);
+        robot.delay(1000);
+    }
+
+    private static void testNewEchoChar() {
+        StringSelection stringSelection = new StringSelection(CHANGED_TEXT);
+        Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
+        clipboard.setContents(stringSelection, stringSelection);
+
+        int ctrlKey = Platform.isOSX() ? KeyEvent.VK_META : KeyEvent.VK_CONTROL;
+        robot.keyPress(ctrlKey);
+        robot.keyPress(KeyEvent.VK_V);
+        robot.keyRelease(KeyEvent.VK_V);
+        robot.keyRelease(ctrlKey);
+
+        robot.keyPress(KeyEvent.VK_ENTER);
+        robot.keyRelease(KeyEvent.VK_ENTER);
+    }
+
+    private static class BtnActionListener implements ActionListener {
+        public void actionPerformed(ActionEvent evt) {
+            String ac = evt.getActionCommand();
+            if (CHANGE.equals(ac)) {
+                tfPassword.setText("");
+                tfPassword.setEchoChar(NEW_ECHO_CHAR);
+                tfPassword.requestFocus();
+            }
+            if (PRINT.equals(ac)) {
+                if (!tfPassword.getText().equals(INITIAL_TEXT)) {
+                    throw new RuntimeException("Test Failed!!!"
+                                               + " Initial text not as expected");
+                }
+            }
+        }
+    }
+}
+

test/jdk/java/awt/TextField/SetEchoCharWordOpsTest.java

@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2005, 2024, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+import java.awt.FlowLayout;
+import java.awt.Label;
+import java.awt.TextField;
+import javax.swing.JPanel;
+
+import jdk.test.lib.Platform;
+
+/*
+ * @test
+ * @bug 6191897
+ * @summary Verifies that ctrl+left/right does not move word-by-word in a TextField
+ *          with echo character set
+ * @library /java/awt/regtesthelpers  /test/lib
+ * @build PassFailJFrame jdk.test.lib.Platform
+ * @run main/manual SetEchoCharWordOpsTest
+ */
+
+public class SetEchoCharWordOpsTest {
+
+    public static void main(String[] args) throws Exception {
+        String selectAllKey;
+        String moveKeys;
+        String selectKeys;
+
+        if (Platform.isOSX()) {
+            selectAllKey = "Cmd + A";
+            moveKeys = "Alt + Right/Left";
+            selectKeys = "Shift + Alt + Right/Left";
+        } else {
+            selectAllKey = "Ctrl + A";
+            moveKeys = "Ctrl + Right/Left";
+            selectKeys = "Shift + Ctrl + Right/Left";
+        }
+
+        String instructions =
+                "The password field (in the bottom panel) in this test contains"
+                 + " a few words (3 words).\n"
+                 + "Move the focus to the text field and press " + selectAllKey + ".\n"
+                 + "Try moving the caret word-by-word with " + moveKeys + " or"
+                 + " extending selection with " + selectKeys + "."
+                 + " You should NOT be able to do that.\n\n"
+                 + "If you are able to move the caret word-by-word press FAIL,"
+                 + " else press PASS.";
+
+        PassFailJFrame.builder()
+                      .title("SetEchoCharClipboard Instructions")
+                      .instructions(instructions)
+                      .rows((int) instructions.lines().count() + 3)
+                      .columns(45)
+                      .splitUIBottom(SetEchoCharWordOpsTest::createAndShowUI)
+                      .build()
+                      .awaitAndCheck();
+    }
+
+
+    private static JPanel createAndShowUI() {
+        JPanel jPanel = new JPanel();
+        TextField tf = new TextField("one two three", 15);
+        Label tfLabel = new Label("Password Field:");
+
+        jPanel.setLayout(new FlowLayout());
+        tf.setEchoChar('*');
+        jPanel.add(tfLabel);
+        jPanel.add(tf);
+        return jPanel;
+    }
+}

test/jdk/java/lang/reflect/Generics/TestMissingTypeVariable.java

@@ -0,0 +1,70 @@
+/*
+ * Copyright (c) 2024, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @library /test/lib
+ * @bug 8337302
+ * @enablePreview
+ * @summary Tests that an exception is thrown if a type variable is not declared
+ */
+
+import jdk.test.lib.ByteCodeLoader;
+
+import java.lang.classfile.ClassFile;
+import java.lang.classfile.Signature;
+import java.lang.classfile.attribute.SignatureAttribute;
+import java.lang.constant.ClassDesc;
+import java.lang.reflect.AccessFlag;
+import java.lang.reflect.Type;
+
+public class TestMissingTypeVariable {
+
+    public static void main(String[] args) throws Exception {
+        ClassFile cf = ClassFile.of();
+        byte[] bytes = cf.build(
+                ClassDesc.of("sample.MissingVariable"),
+                classBuilder -> {
+                    classBuilder.withSuperclass(ClassDesc.of("java.lang.Object"));
+                    classBuilder.withFlags(AccessFlag.PUBLIC);
+                    classBuilder.withField("f",
+                            ClassDesc.of("java.lang.Object"),
+                            fieldBuilder -> fieldBuilder.withFlags(AccessFlag.PUBLIC).with(SignatureAttribute.of(Signature.parseFrom("TA;"))));
+                });
+        /*
+          package sample;
+          public class MissingVariable {
+            public A f; // undeclared type variable
+          }
+         */
+        Class<?> missing = ByteCodeLoader.load("sample.MissingVariable", bytes);
+        try {
+            Type type = missing.getField("f").getGenericType();
+            throw new IllegalStateException("Expected TypeNotPresentException but got: " + type);
+        } catch (TypeNotPresentException e) {
+            if (!"A".equals(e.typeName())) {
+                throw new IllegalStateException("Unexpected name: " + e.typeName());
+            }
+        }
+    }
+}

test/jdk/sun/java2d/GdiRendering/GdiBlitOffscreenTest.java

@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) 2002, 2024, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 4725045
+ * @key headful
+ * @summary verifies that there are no artifacts due to using
+ * GDI for copies to the back buffer (GDI should only be used
+ * for copies to the screen)
+ * @run main GdiBlitOffscreenTest
+*/
+
+import java.awt.Color;
+import java.awt.Graphics;
+import java.awt.Image;
+import java.awt.Point;
+import java.awt.Robot;
+import java.awt.image.BufferedImage;
+import javax.swing.JComponent;
+import javax.swing.JFrame;
+import javax.swing.SwingUtilities;
+
+public class GdiBlitOffscreenTest {
+
+    static volatile JFrame f;
+    static final int imageW = 100, imageH = 100, FW = 500, FH = 500;
+    static volatile BufferedImage greenImage;
+
+    public static void main(String[] args) throws Exception {
+
+        // First, create an image.
+        greenImage = new BufferedImage(imageW, imageH,
+                                       BufferedImage.TYPE_INT_RGB);
+        Graphics redG = greenImage.getGraphics();
+        redG.setColor(Color.green);
+        redG.fillRect(0, 0, imageW, imageH);
+        redG.setColor(Color.white);
+        redG.drawString("Passed!", 30, 80);
+
+        Robot robot = new Robot();
+        try {
+            SwingUtilities.invokeAndWait(GdiBlitOffscreenTest::createUI);
+            robot.delay(1000);
+            robot.waitForIdle();
+            Point p = f.getLocationOnScreen();
+            Color c = robot.getPixelColor(p.x+FW/2, p.y+FH/2);
+            if (!c.equals(Color.green)) {
+                throw new RuntimeException("Color is " + c);
+            }
+        } finally {
+            if (f != null) {
+                SwingUtilities.invokeAndWait(f::dispose);
+            }
+        }
+    }
+
+    private static void createUI() {
+        f = new JFrame("GdiBlitOffscreenTest");
+        f.setSize(FW, FH);
+        f.setVisible(true);
+
+        // copy the image to the window.
+        Graphics g = f.getGraphics();
+        g.drawImage(greenImage, 0, 0, null);
+
+        // Now, get on with the rest of the test
+        JComponent app = new GdiBlitOffscreenTestComponent(imageW, imageH, greenImage);
+        app.setSize(500, 500);
+        f.getContentPane().add(app);
+        f.validate();
+        f.repaint();
+    }
+}
+
+class GdiBlitOffscreenTestComponent extends JComponent {
+
+    int imageW, imageH;
+    Image theImage;
+
+    public GdiBlitOffscreenTestComponent(int imageW, int imageH,
+                                         Image theImage)
+    {
+        this.theImage = theImage;
+        this.imageW = imageW;
+        this.imageH = imageH;
+    }
+
+    public void paintComponent(Graphics g) {
+        int imageX = (getWidth() - imageW) / 2;
+        int imageY = (getHeight() - imageH) / 2;
+        g.setColor(Color.blue);
+        g.fillRect(0, 0, getWidth(), getHeight());
+        g.setColor(Color.red);
+        g.fillRect(imageX, imageY, imageW, imageH);
+        g.setColor(Color.white);
+        g.drawString("Failed!", imageX + 30, imageY + 80);
+        g.drawImage(theImage, imageX, imageY, null);
+    }
+
+}

test/jdk/sun/java2d/GdiRendering/GdiLockTest.java

@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2002, 2024, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 4693644
+ * @summary verifies that there are no artifacts due to copying with GDI
+ * @library /java/awt/regtesthelpers
+ * @build PassFailJFrame
+ * @run main/manual GdiLockTest
+*/
+
+import java.awt.Color;
+import java.awt.Component;
+import java.awt.Frame;
+import java.awt.Graphics;
+
+public class GdiLockTest {
+
+        static final String INSTRUCTIONS = """
+            A window will open up next to these instructions.
+            The text you see in that window should blink on and off.
+            If it never disappears, then the test has failed.
+        """;
+
+    public static void main(String[] argv) throws Exception {
+        PassFailJFrame.builder()
+                .title("GdiLockTest")
+                .instructions(INSTRUCTIONS)
+                .testTimeOut(5)
+                .rows(5)
+                .columns(45)
+                .testUI(GdiLockTest::createUI)
+                .build()
+                .awaitAndCheck();
+    }
+
+    private static Frame createUI() {
+        Frame f = new Frame("GdiLockTest");
+        f.setSize(300, 300);
+        GdiLockTestComponent test = new GdiLockTestComponent();
+        Thread t = new Thread(test);
+        f.add(test);
+        t.start();
+        return f;
+    }
+}
+
+class GdiLockTestComponent extends Component implements Runnable {
+
+    boolean textVisible = true;
+
+    public void paint(Graphics g) {
+        g.setColor(Color.white);
+        g.fillRect(0, 0, getWidth(), getHeight());
+        g.setColor(Color.black);
+        if (!textVisible) {
+            g.setClip(200, 200, 300, 300);
+        }
+        g.drawString("This text should be blinking", 10, 30);
+        if (!textVisible) {
+            g.setClip(0, 0, getWidth(), getHeight());
+        }
+    }
+
+    public void run() {
+        while (true) {
+            repaint();
+            textVisible = !textVisible;
+            try {
+                Thread.sleep(500);
+            } catch (Exception e) {}
+        }
+    }
+}

test/jdk/sun/java2d/SunGraphics2D/DrawRoundRect0Bug.java

@@ -0,0 +1,69 @@
+/*
+ * Copyright (c) 2001, 2024, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 4515761
+ * @summary verify that drawRoundRect produces correct output for 0 w/h
+ */
+
+import java.awt.Color;
+import static java.awt.Color.*;
+import java.awt.Graphics2D;
+import java.awt.image.BufferedImage;
+
+public class DrawRoundRect0Bug {
+
+    public static void main(String argv[]) {
+        BufferedImage img = new BufferedImage(250, 250, BufferedImage.TYPE_INT_RGB);
+        Graphics2D g = img.createGraphics();
+
+        g.setColor(white);
+        g.fillRect(0, 0, img.getWidth(), img.getHeight());
+
+        g.setColor(green);
+        g.drawLine(150, 90, 150, 110);
+        if (img.getRGB(150, 100) != green.getRGB()) {
+            throw new RuntimeException("Vertical line not green");
+        }
+
+        g.setColor(blue);
+        g.drawRoundRect(160, 90, 0, 20, 4, 4);
+        if (img.getRGB(160, 100) != blue.getRGB()) {
+            throw new RuntimeException("Vertical (ie zero width) round rect not blue");
+        }
+
+        g.setColor(green);
+        g.drawLine(150, 140, 170, 140);
+        if (img.getRGB(160, 140) != green.getRGB()) {
+            throw new RuntimeException("Horizontal line not green");
+        }
+
+        g.setColor(blue);
+        g.drawRoundRect(150, 150, 20, 0, 4, 4);
+        if (img.getRGB(160, 150) != blue.getRGB()) {
+            throw new RuntimeException("Horizontal (ie zero height) round rect not blue");
+        }
+    }
+
+}

test/jdk/sun/java2d/SunGraphics2D/RevalidateBug.java

@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2002, 2024, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 4652373
+ * @summary verify that SunGraphics2D survives surface revalidation
+ * @library /java/awt/regtesthelpers
+ * @build PassFailJFrame
+ * @run main/manual RevalidateBug
+ * @requires (os.family == "windows")
+ */
+
+import java.awt.Color;
+import java.awt.Dimension;
+import java.awt.GradientPaint;
+import java.awt.Graphics;
+import java.awt.Graphics2D;
+import java.awt.Insets;
+import java.awt.Rectangle;
+import javax.swing.JComponent;
+import javax.swing.JFrame;
+
+public class RevalidateBug {
+
+    private static final String INSTRUCTIONS = """
+        This bug only reproduces on Windows systems with a task manager that can lock the computer.
+
+        This test draws a grayscale gradient in a window.
+
+        After the gradient becomes visible above, use ctrl-alt-del to bring up
+        the task manager and lock the computer.
+        Then unlock the computer and the gradient should be repainted to pass.
+
+        If the gradient does not appear after unlocking (or if the test gets
+        an error on its own after unlocking the computer) then it fails.
+        """;
+
+    public static void main(String[] argv) throws Exception {
+        PassFailJFrame.builder()
+                .title("RevalidateBug")
+                .instructions(INSTRUCTIONS)
+                .testTimeOut(5)
+                .rows(12)
+                .columns(50)
+                .testUI(RevalidateBug::createUI)
+                .build()
+                .awaitAndCheck();
+    }
+
+    private static JFrame createUI() {
+
+        JComponent comp = new JComponent() {
+
+            protected void paintComponent(Graphics g) {
+                super.paintComponent(g);
+                System.out.println("paintComponent");
+                Graphics2D g2d = (Graphics2D) g;
+
+                Insets insets = getInsets();
+                Rectangle rect =
+                    new Rectangle(insets.left, insets.top,
+                                  getWidth() - insets.right - insets.left,
+                                  getHeight() - insets.top - insets.bottom);
+                g2d.setPaint(new GradientPaint(rect.x, rect.y, Color.white,
+                                               rect.x + rect.width, rect.y, Color.black));
+
+                System.out.println(rect + " w:" + getWidth() + " h:"+getHeight());
+
+                g2d.fillRect(0, 0, getWidth(), getHeight());
+            }
+
+            public Dimension getPreferredSize() {
+                return new Dimension(500, 500);
+            }
+        };
+
+        JFrame f = new JFrame("RevalidateTest");
+        f.add(comp);
+        f.pack();
+        return f;
+    }
+
+}

test/jdk/sun/java2d/SunGraphics2D/ScaledPolyTest.java

@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2001, 2024, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/*
+ * @test
+ * @bug 4516037
+ * @summary verify that scaled Polygons honor the transform
+ */
+
+import java.awt.Color;
+import static java.awt.Color.*;
+import java.awt.Graphics2D;
+import java.awt.Polygon;
+import java.awt.image.BufferedImage;
+
+public class ScaledPolyTest {
+
+    public static void main(String[] args) {
+
+        Polygon poly = new Polygon();
+        poly.addPoint(20, 10);
+        poly.addPoint(30, 30);
+        poly.addPoint(10, 30);
+        poly.addPoint(20, 10);
+
+        int height = 300;
+        int width = 300;
+        BufferedImage bi = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
+        Graphics2D g2d = bi.createGraphics();
+        g2d.setColor(Color.white);
+        g2d.fillRect(0, 0, bi.getWidth(), bi.getHeight());
+
+        g2d.translate(10, 10);
+        g2d.scale(2, 2);
+        g2d.setColor(Color.yellow);
+        g2d.fill(poly);
+        g2d.setColor(Color.blue);
+        g2d.draw(poly);
+
+        /*
+         * Examine each row of the image.
+         * If the stroked polygon is correctly aligned on the filled polygon,
+         * if there is anything except white on the line,
+         * the transition will always be white+->blue+->yellow*->blue*->white+
+         */
+        int bluePix = blue.getRGB();
+        int yellowPix = yellow.getRGB();
+        int whitePix = white.getRGB();
+        for (int y = 0; y < height; y++ ) {
+            int x = 0;
+            int pix = whitePix;
+
+            while (pix == whitePix && x < width) pix = bi.getRGB(x++, y);
+            if (pix == whitePix && x == width) continue; // all white row.
+
+            if (pix != bluePix) throw new RuntimeException("Expected blue");
+
+            while (pix == bluePix) pix = bi.getRGB(x++, y);
+
+            if (pix == yellowPix) {
+               while (pix == yellowPix) pix = bi.getRGB(x++, y);
+               if (pix != bluePix) throw new RuntimeException("Expected blue");
+               while (pix == bluePix) pix = bi.getRGB(x++, y);
+               if (pix != whitePix) throw new RuntimeException("Expected white");
+            }
+
+            while (pix == whitePix && x < width) pix = bi.getRGB(x++, y);
+            if (pix == whitePix && x == width) {
+                continue;
+            } else {
+                throw new RuntimeException("Expected white to finish the row");
+            }
+        }
+    }
+}

test/jdk/sun/tools/jcmd/TestJcmdPIDSubstitution.java

@@ -51,6 +51,8 @@ public class TestJcmdPIDSubstitution {
         verifyOutputFilenames("GC.heap_dump", FILENAME);
         if (Platform.isLinux()) {
             verifyOutputFilenames("Compiler.perfmap", FILENAME);
+        }
+        if (Platform.isLinux() || Platform.isWindows()) {
             verifyOutputFilenames("System.dump_map", "-F=%s".formatted(FILENAME));
         }
     }