Merge branch 'upstream-master'

Author: Datadog Syncup Service

src/hotspot/share/gc/parallel/psParallelCompact.cpp

@@ -116,51 +116,45 @@ class SplitInfo
   // Return true if this split info is valid (i.e., if a split has been
   // recorded).  The very first region cannot have a partial object and thus is
   // never split, so 0 is the 'invalid' value.
-  bool is_valid() const { return _src_region_idx > 0; }
+  bool is_valid() const { return _split_region_idx > 0; }
 
   // Return true if this split holds data for the specified source region.
-  inline bool is_split(size_t source_region) const;
+  inline bool is_split(size_t region_idx) const;
 
-  // The index of the split region, the size of the partial object on that
-  // region and the destination of the partial object.
-  size_t    partial_obj_size() const { return _partial_obj_size; }
-  HeapWord* destination() const      { return _destination; }
+  // Obj at the split point doesn't fit the previous space and will be relocated to the next space.
+  HeapWord* split_point() const { return _split_point; }
 
-  // The destination count of the partial object referenced by this split
-  // (either 1 or 2).  This must be added to the destination count of the
-  // remainder of the source region.
-  unsigned int destination_count() const { return _destination_count; }
+  // Number of live words before the split point on this region.
+  size_t preceding_live_words() const { return _preceding_live_words; }
 
-  // If a word within the partial object will be written to the first word of a
-  // destination region, this is the address of the destination region;
-  // otherwise this is null.
-  HeapWord* dest_region_addr() const     { return _dest_region_addr; }
+  // A split region has two "destinations", living in two spaces. This method
+  // returns the first one -- destination for the first live word on
+  // this split region.
+  HeapWord* preceding_destination() const {
+    assert(_preceding_destination != nullptr, "inv");
+    return _preceding_destination;
+  }
 
-  // If a word within the partial object will be written to the first word of a
-  // destination region, this is the address of that word within the partial
-  // object; otherwise this is null.
-  HeapWord* first_src_addr() const       { return _first_src_addr; }
+  // Number of regions the preceding live words are relocated into.
+  uint preceding_destination_count() const { return _preceding_destination_count; }
 
-  // Record the data necessary to split the region src_region_idx.
-  void record(size_t src_region_idx, size_t partial_obj_size,
-              HeapWord* destination);
+  void record(size_t split_region_idx, HeapWord* split_point, size_t preceding_live_words);
 
   void clear();
 
   DEBUG_ONLY(void verify_clear();)
 
 private:
-  size_t       _src_region_idx;
-  size_t       _partial_obj_size;
-  HeapWord*    _destination;
-  unsigned int _destination_count;
-  HeapWord*    _dest_region_addr;
-  HeapWord*    _first_src_addr;
+  size_t       _split_region_idx;
+  HeapWord*    _split_point;
+  size_t       _preceding_live_words;
+  HeapWord*    _preceding_destination;
+  uint         _preceding_destination_count;
 };
 
 inline bool SplitInfo::is_split(size_t region_idx) const
 {
-  return _src_region_idx == region_idx && is_valid();
+  return _split_region_idx == region_idx && is_valid();
 }
 
 class SpaceInfo
@@ -215,10 +209,18 @@ class ParallelCompactData
   class RegionData
   {
   public:
-    // Destination address of the region.
+    // Destination for the first live word in this region.
+    // Therefore, the new addr for every live obj on this region can be calculated as:
+    //
+    // new_addr := _destination + live_words_offset(old_addr);
+    //
+    // where, live_words_offset is the number of live words accumulated from
+    // region-start to old_addr.
     HeapWord* destination() const { return _destination; }
 
-    // The first region containing data destined for this region.
+    // A destination region can have multiple source regions; only the first
+    // one is recorded. Since all live objs are slided down, subsequent source
+    // regions can be found via plain heap-region iteration.
     size_t source_region() const { return _source_region; }
 
     // Reuse _source_region to store the corresponding shadow region index
@@ -313,9 +315,12 @@ class ParallelCompactData
     // Return to the normal path here
     inline void shadow_to_normal();
 
-
     int shadow_state() { return _shadow_state; }
 
+    bool is_clear();
+
+    void verify_clear() NOT_DEBUG_RETURN;
+
   private:
     // The type used to represent object sizes within a region.
     typedef uint region_sz_t;
@@ -873,7 +878,10 @@ class MoveAndUpdateClosure: public StackObj {
   size_t    words_remaining()    const { return _words_remaining; }
   bool      is_full()            const { return _words_remaining == 0; }
   HeapWord* source()             const { return _source; }
-  void      set_source(HeapWord* addr) { _source = addr; }
+  void      set_source(HeapWord* addr) {
+    assert(addr != nullptr, "precondition");
+    _source = addr;
+  }
 
   // If the object will fit (size <= words_remaining()), copy it to the current
   // destination, update the interior oops and the start array.
@@ -902,9 +910,8 @@ inline size_t MoveAndUpdateClosure::calculate_words_remaining(size_t region) {
   HeapWord* dest_addr = PSParallelCompact::summary_data().region_to_addr(region);
   PSParallelCompact::SpaceId dest_space_id = PSParallelCompact::space_id(dest_addr);
   HeapWord* new_top = PSParallelCompact::new_top(dest_space_id);
-  assert(dest_addr < new_top, "sanity");
-
-  return MIN2(pointer_delta(new_top, dest_addr), ParallelCompactData::RegionSize);
+  return MIN2(pointer_delta(new_top, dest_addr),
+              ParallelCompactData::RegionSize);
 }
 
 inline

src/hotspot/share/gc/parallel/psParallelCompact.hpp

@@ -57,7 +57,7 @@ public static void main(String args[]) throws Exception {
                         System.getProperty("test.provider.name", "SunJCE"));
         System.out.println("Testing provider " + cp.getName() + "...");
         Provider kfp = Security.getProvider(
-                        System.getProperty("test.providername", "SunRsaSign"));
+                        System.getProperty("test.provider.name", "SunRsaSign"));
         String kpgAlgorithm = "RSA";
         KeyPairGenerator kpg = KeyPairGenerator.getInstance(kpgAlgorithm, kfp);
         kpg.initialize(SecurityUtils.getTestKeySize(kpgAlgorithm));

test/jdk/com/sun/crypto/provider/Cipher/RSA/TestOAEPPadding.java

@@ -0,0 +1,162 @@
+/*
+ * 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.
+ */
+import jdk.test.lib.json.JSONValue;
+import jtreg.SkippedException;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.security.Provider;
+import java.security.Security;
+
+/*
+ * @test
+ * @bug 8342442
+ * @library /test/lib
+ */
+
+/// This test runs on `internalProjection.json`-style files generated
+/// by NIST's ACVP Server. See [https://github.com/usnistgov/ACVP-Server].
+///
+/// The files are either put into the `data` directory or another
+/// directory specified by the `test.acvp.data` test property.
+/// The test walks through the directory recursively and looks for
+/// file names equal to or ending with `internalProjection.json` and
+/// runs tests on them.
+///
+/// Set the `test.acvp.alg` test property to only test the specified algorithm.
+///
+/// Sample files can be downloaded from
+/// [https://github.com/usnistgov/ACVP-Server/tree/master/gen-val/json-files].
+///
+/// By default, the test uses system-preferred implementations.
+/// If you want to test a specific provider, set the
+/// `test.acvp.provider` test property. The provider must be
+/// registered.
+///
+/// Tests for each algorithm must be compliant to its specification linked from
+/// [https://github.com/usnistgov/ACVP?tab=readme-ov-file#supported-algorithms].
+///
+/// Example:
+/// ```
+/// jtreg -Dtest.acvp.provider=SunJCE \
+///       -Dtest.acvp.alg=ML-KEM \
+///       -Dtest.acvp.data=/path/to/json-files/ \
+///       -jdk:/path/to/jdk Launcher.java
+/// ```
+public class Launcher {
+
+    private static final String ONLY_ALG
+            = System.getProperty("test.acvp.alg");
+
+    private static final Provider PROVIDER;
+
+    private static int count = 0;
+    private static int invalidTest = 0;
+    private static int unsupportedTest = 0;
+
+    static {
+        var provProp = System.getProperty("test.acvp.provider");
+        if (provProp != null) {
+            var p = Security.getProvider(provProp);
+            if (p == null) {
+                System.err.println(provProp + " is not a registered provider name");
+                throw new RuntimeException(provProp + " is not a registered provider name");
+            }
+            PROVIDER = p;
+        } else {
+            PROVIDER = null;
+        }
+    }
+
+    public static void main(String[] args) throws Exception {
+
+        var testDataProp = System.getProperty("test.acvp.data");
+        Path dataPath = testDataProp != null
+                ? Path.of(testDataProp)
+                : Path.of(System.getProperty("test.src"), "data");
+        System.out.println("Data path: " + dataPath);
+
+        if (PROVIDER != null) {
+            System.out.println("Provider: " + PROVIDER.getName());
+        }
+        if (ONLY_ALG != null) {
+            System.out.println("Algorithm: " + ONLY_ALG);
+        }
+
+        try (var stream = Files.walk(dataPath)) {
+            stream.filter(Files::isRegularFile)
+                    .filter(p -> p.getFileName().toString()
+                            .endsWith("internalProjection.json"))
+                    .forEach(Launcher::run);
+        }
+
+        if (count > 0) {
+            System.out.println();
+            System.out.println("Test completed: " + count);
+            System.out.println("Invalid tests: " + invalidTest);
+            System.out.println("Unsupported tests: " + unsupportedTest);
+        } else {
+            throw new SkippedException("No supported test found");
+        }
+    }
+
+    static void run(Path test) {
+        try {
+            JSONValue kat;
+            try {
+                kat = JSONValue.parse(Files.readString(test));
+            } catch (Exception e) {
+                System.out.println("Warning: cannot parse " + test + ". Skipped");
+                invalidTest++;
+                return;
+            }
+            var alg = kat.get("algorithm").asString();
+            if (ONLY_ALG != null && !alg.equals(ONLY_ALG)) {
+                return;
+            }
+            System.out.println(">>> Testing " + test + "...");
+            switch (alg) {
+                case "ML-DSA" -> {
+                    ML_DSA_Test.run(kat, PROVIDER);
+                    count++;
+                }
+                case "ML-KEM" -> {
+                    ML_KEM_Test.run(kat, PROVIDER);
+                    count++;
+                }
+                case "SHA2-256", "SHA2-224", "SHA3-256", "SHA3-224" -> {
+                    SHA_Test.run(kat, PROVIDER);
+                    count++;
+                }
+                default -> {
+                    System.out.println("Skipped unsupported algorithm: " + alg);
+                    unsupportedTest++;
+                }
+            }
+        } catch (RuntimeException re) {
+            throw re;
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+}