mirror of
https://github.com/openjdk/jdk.git
synced 2026-04-01 10:43:02 +00:00
310 lines
12 KiB
Java
310 lines
12 KiB
Java
/*
|
|
* 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.
|
|
*/
|
|
|
|
package compiler.lib.verify;
|
|
|
|
import java.util.Optional;
|
|
import java.lang.foreign.*;
|
|
|
|
/**
|
|
* The {@link Verify} class provides a single {@link Verify#checkEQ} static method, which recursively
|
|
* compares the two {@link Object}s by value. It deconstructs {@link Object[]}, compares boxed primitive
|
|
* types, and compares the content of arrays and {@link MemorySegment}s.
|
|
*
|
|
* When a comparison fail, then methods print helpful messages, before throwing a {@link VerifyException}.
|
|
*/
|
|
public final class Verify {
|
|
|
|
private Verify() {}
|
|
|
|
/**
|
|
* Verify the content of two Objects, possibly recursively. Only limited types are implemented.
|
|
*
|
|
* @param a First object to be recursively compared with the second.
|
|
* @param b Second object to be recursively compared with the first.
|
|
* @throws VerifyException If the comparison fails.
|
|
*/
|
|
public static void checkEQ(Object a, Object b) {
|
|
checkEQ(a, b, "");
|
|
}
|
|
|
|
/**
|
|
* Verify the content of two Objects, possibly recursively. Only limited types are implemented.
|
|
*/
|
|
private static void checkEQ(Object a, Object b, String context) {
|
|
// Both null
|
|
if (a == null && b == null) {
|
|
return;
|
|
}
|
|
|
|
// Null mismatch
|
|
if (a == null || b == null) {
|
|
System.err.println("ERROR: Verify.checkEQ failed: null mismatch");
|
|
print(a, "a " + context);
|
|
print(b, "b " + context);
|
|
throw new VerifyException("Object array null mismatch.");
|
|
}
|
|
|
|
// Class mismatch
|
|
Class ca = a.getClass();
|
|
Class cb = b.getClass();
|
|
if (ca != cb) {
|
|
System.err.println("ERROR: Verify.checkEQ failed: class mismatch.");
|
|
System.err.println(" " + ca.getName() + " vs " + cb.getName());
|
|
print(a, "a " + context);
|
|
print(b, "b " + context);
|
|
throw new VerifyException("Object class mismatch.");
|
|
}
|
|
|
|
switch (a) {
|
|
case Object[] x -> checkEQimpl(x, (Object[])b, context);
|
|
case Byte x -> checkEQimpl(x, ((Byte)b).byteValue(), context);
|
|
case Character x -> checkEQimpl(x, ((Character)b).charValue(), context);
|
|
case Short x -> checkEQimpl(x, ((Short)b).shortValue(), context);
|
|
case Integer x -> checkEQimpl(x, ((Integer)b).intValue(), context);
|
|
case Long x -> checkEQimpl(x, ((Long)b).longValue(), context);
|
|
case Float x -> checkEQimpl(x, ((Float)b).floatValue(), context);
|
|
case Double x -> checkEQimpl(x, ((Double)b).doubleValue(), context);
|
|
case byte[] x -> checkEQimpl(x, (byte[])b, context);
|
|
case char[] x -> checkEQimpl(x, (char[])b, context);
|
|
case short[] x -> checkEQimpl(x, (short[])b, context);
|
|
case int[] x -> checkEQimpl(x, (int[])b, context);
|
|
case long[] x -> checkEQimpl(x, (long[])b, context);
|
|
case float[] x -> checkEQimpl(x, (float[])b, context);
|
|
case double[] x -> checkEQimpl(x, (double[])b, context);
|
|
case MemorySegment x -> checkEQimpl(x, (MemorySegment) b, context);
|
|
default -> {
|
|
System.err.println("ERROR: Verify.checkEQ failed: type not supported: " + ca.getName());
|
|
print(a, "a " + context);
|
|
print(b, "b " + context);
|
|
throw new VerifyException("Object array type not supported: " + ca.getName());
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Verify that two bytes are identical.
|
|
*/
|
|
private static void checkEQimpl(byte a, byte b, String context) {
|
|
if (a != b) {
|
|
System.err.println("ERROR: Verify.checkEQ failed: value mismatch: " + a + " vs " + b + " for " + context);
|
|
throw new VerifyException("Value mismatch: " + a + " vs " + b);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Verify that two chars are identical.
|
|
*/
|
|
private static void checkEQimpl(char a, char b, String context) {
|
|
if (a != b) {
|
|
System.err.println("ERROR: Verify.checkEQ failed: value mismatch: " + (int)a + " vs " + (int)b + " for " + context);
|
|
throw new VerifyException("Value mismatch: " + (int)a + " vs " + (int)b);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Verify that two shorts are identical.
|
|
*/
|
|
private static void checkEQimpl(short a, short b, String context) {
|
|
if (a != b) {
|
|
System.err.println("ERROR: Verify.checkEQ failed: value mismatch: " + (int)a + " vs " + (int)b + " for " + context);
|
|
throw new VerifyException("Value mismatch: " + (int)a + " vs " + (int)b);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Verify that two ints are identical.
|
|
*/
|
|
private static void checkEQimpl(int a, int b, String context) {
|
|
if (a != b) {
|
|
System.err.println("ERROR: Verify.checkEQ failed: value mismatch: " + a + " vs " + b + " for " + context);
|
|
throw new VerifyException("Value mismatch: " + a + " vs " + b);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Verify that two longs are identical.
|
|
*/
|
|
private static void checkEQimpl(long a, long b, String context) {
|
|
if (a != b) {
|
|
System.err.println("ERROR: Verify.checkEQ failed: value mismatch: " + a + " vs " + b + " for " + context);
|
|
throw new VerifyException("Value mismatch: " + a + " vs " + b);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Verify that two floats have identical bits.
|
|
*/
|
|
private static void checkEQimpl(float a, float b, String context) {
|
|
if (Float.floatToRawIntBits(a) != Float.floatToRawIntBits(b)) {
|
|
System.err.println("ERROR: Verify.checkEQ failed: value mismatch for " + context);
|
|
System.err.println(" Values: " + a + " vs " + b);
|
|
System.err.println(" Values: " + Float.floatToRawIntBits(a) + " vs " + Float.floatToRawIntBits(b));
|
|
throw new VerifyException("Value mismatch: " + a + " vs " + b);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Verify that two doubles have identical bits.
|
|
*/
|
|
private static void checkEQimpl(double a, double b, String context) {
|
|
if (Double.doubleToRawLongBits(a) != Double.doubleToRawLongBits(b)) {
|
|
System.err.println("ERROR: Verify.checkEQ failed: value mismatch for " + context);
|
|
System.err.println(" Values: " + a + " vs " + b);
|
|
System.err.println(" Values: " + Double.doubleToRawLongBits(a) + " vs " + Double.doubleToRawLongBits(b));
|
|
throw new VerifyException("Value mismatch: " + a + " vs " + b);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Verify that the content of two MemorySegments is identical. Note: we do not check the
|
|
* backing type, only the size and content.
|
|
*/
|
|
private static void checkEQimpl(MemorySegment a, MemorySegment b, String context) {
|
|
long offset = a.mismatch(b);
|
|
if (offset == -1) { return; }
|
|
|
|
// Print some general info
|
|
System.err.println("ERROR: Verify.checkEQ failed for: " + context);
|
|
|
|
printMemorySegment(a, "a " + context);
|
|
printMemorySegment(b, "b " + context);
|
|
|
|
// (1) Mismatch on size
|
|
if (a.byteSize() != b.byteSize()) {
|
|
throw new VerifyException("MemorySegment byteSize mismatch.");
|
|
}
|
|
|
|
// (2) Value mismatch
|
|
System.err.println(" Value mismatch at byte offset: " + offset);
|
|
printMemorySegmentValue(a, offset, 16);
|
|
printMemorySegmentValue(b, offset, 16);
|
|
throw new VerifyException("MemorySegment value mismatch.");
|
|
}
|
|
|
|
/**
|
|
* Verify that the content of two byte arrays is identical.
|
|
*/
|
|
private static void checkEQimpl(byte[] a, byte[] b, String context) {
|
|
checkEQimpl(MemorySegment.ofArray(a), MemorySegment.ofArray(b), context);
|
|
}
|
|
|
|
/**
|
|
* Verify that the content of two char arrays is identical.
|
|
*/
|
|
private static void checkEQimpl(char[] a, char[] b, String context) {
|
|
checkEQimpl(MemorySegment.ofArray(a), MemorySegment.ofArray(b), context);
|
|
}
|
|
|
|
/**
|
|
* Verify that the content of two short arrays is identical.
|
|
*/
|
|
private static void checkEQimpl(short[] a, short[] b, String context) {
|
|
checkEQimpl(MemorySegment.ofArray(a), MemorySegment.ofArray(b), context);
|
|
}
|
|
|
|
/**
|
|
* Verify that the content of two int arrays is identical.
|
|
*/
|
|
private static void checkEQimpl(int[] a, int[] b, String context) {
|
|
checkEQimpl(MemorySegment.ofArray(a), MemorySegment.ofArray(b), context);
|
|
}
|
|
|
|
/**
|
|
* Verify that the content of two long arrays is identical.
|
|
*/
|
|
private static void checkEQimpl(long[] a, long[] b, String context) {
|
|
checkEQimpl(MemorySegment.ofArray(a), MemorySegment.ofArray(b), context);
|
|
}
|
|
|
|
/**
|
|
* Verify that the content of two float arrays is identical.
|
|
*/
|
|
private static void checkEQimpl(float[] a, float[] b, String context) {
|
|
checkEQimpl(MemorySegment.ofArray(a), MemorySegment.ofArray(b), context);
|
|
}
|
|
|
|
/**
|
|
* Verify that the content of two double arrays is identical.
|
|
*/
|
|
private static void checkEQimpl(double[] a, double[] b, String context) {
|
|
checkEQimpl(MemorySegment.ofArray(a), MemorySegment.ofArray(b), context);
|
|
}
|
|
|
|
/**
|
|
* Verify that the content of two Object arrays is identical, recursively:
|
|
* every element is compared with checkEQimpl for the corresponding type.
|
|
*/
|
|
private static void checkEQimpl(Object[] a, Object[] b, String context) {
|
|
// (1) Length mismatch
|
|
if (a.length != b.length) {
|
|
System.err.println("ERROR: Verify.checkEQ failed: length mismatch: " + a.length + " vs " + b.length);
|
|
throw new VerifyException("Object array length mismatch.");
|
|
}
|
|
|
|
for (int i = 0; i < a.length; i++) {
|
|
// Recursive checkEQ call.
|
|
checkEQ(a[i], b[i], "[" + i + "]" + context);
|
|
}
|
|
}
|
|
|
|
private static void print(Object a, String context) {
|
|
if (a == null) {
|
|
System.err.println(" " + context + ": null");
|
|
} else {
|
|
System.err.println(" " + context + ": " + a);
|
|
}
|
|
}
|
|
|
|
private static void printMemorySegment(MemorySegment a, String context) {
|
|
Optional<Object> maybeBase = a.heapBase();
|
|
System.err.println(" " + context + " via MemorySegment:");
|
|
if (maybeBase.isEmpty()) {
|
|
System.err.println(" no heap base (native).");
|
|
} else {
|
|
Object base = maybeBase.get();
|
|
System.err.println(" heap base: " + base);
|
|
}
|
|
System.err.println(" address: " + a.address());
|
|
System.err.println(" byteSize: " + a.byteSize());
|
|
}
|
|
|
|
private static void printMemorySegmentValue(MemorySegment a, long offset, int range) {
|
|
long start = Long.max(offset - range, 0);
|
|
long end = Long.min(offset + range, a.byteSize());
|
|
for (long i = start; i < end; i++) {
|
|
byte b = a.get(ValueLayout.JAVA_BYTE, i);
|
|
System.err.print(String.format("%02x ", b));
|
|
}
|
|
System.err.println("");
|
|
for (long i = start; i < end; i++) {
|
|
if (i == offset) {
|
|
System.err.print("^^ ");
|
|
} else {
|
|
System.err.print(" ");
|
|
}
|
|
}
|
|
System.err.println("");
|
|
}
|
|
}
|