[GR-63328] Emit additional reinterpret when generating float CAS from node matching rules

PullRequest: graal/20351

Author: mur47x111

compiler/src/jdk.graal.compiler.test/src/jdk/graal/compiler/replacements/test/UnsafeReplacementsTest.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2018, 2021, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2018, 2025, 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
@@ -24,9 +24,10 @@
  */
 package jdk.graal.compiler.replacements.test;
 
-import jdk.graal.compiler.test.AddExports;
 import org.junit.Test;
 
+import jdk.graal.compiler.test.AddExports;
+
 @AddExports("java.base/jdk.internal.misc")
 public class UnsafeReplacementsTest extends MethodSubstitutionTest {
 
@@ -155,6 +156,15 @@ public void testCompareAndSet() {
         test("unsafeCompareAndSetDouble");
     }
 
+    public static Boolean unsafeCompareAndSetFloatVar(Container c) {
+        return unsafe.compareAndSetFloat(c, floatOffset, 1.0f, 2.0f);
+    }
+
+    @Test
+    public void testUnsafeCompareAndSetFloatVar() {
+        test("unsafeCompareAndSetFloatVar", new Container());
+    }
+
     public static boolean unsafeWeakCompareAndSetBoolean() {
         Container container = new Container();
         boolean success = false;

compiler/src/jdk.graal.compiler/src/jdk/graal/compiler/core/amd64/AMD64LIRGenerator.java

@@ -247,9 +247,9 @@ private AllocatableValue asAllocatable(Value value, ValueKind<?> kind) {
         }
     }
 
-    private Value emitCompareAndSwap(boolean isLogic, LIRKind accessKind, Value address, Value expectedValue, Value newValue, Value trueValue, Value falseValue, BarrierType barrierType) {
+    private Value emitCompareAndSwapHelper(boolean isLogic, LIRKind accessKind, Value address, Value expectedValue, Value newValue, BarrierType barrierType) {
         ValueKind<?> kind = newValue.getValueKind();
-        assert kind.equals(expectedValue.getValueKind());
+        GraalError.guarantee(kind.equals(expectedValue.getValueKind()), "%s != %s", kind, expectedValue.getValueKind());
 
         AMD64AddressValue addressValue = asAddressValue(address);
         LIRKind integerAccessKind = accessKind;
@@ -270,15 +270,20 @@ private Value emitCompareAndSwap(boolean isLogic, LIRKind accessKind, Value addr
         AllocatableValue allocatableNewValue = asAllocatable(reinterpretedNewValue, integerAccessKind);
         emitMove(aRes, reinterpretedExpectedValue);
         emitCompareAndSwapOp(isLogic, integerAccessKind, memKind, aRes, addressValue, allocatableNewValue, barrierType);
+        return aRes;
+    }
+
+    private Value emitCompareAndSwap(boolean isLogic, LIRKind accessKind, Value address, Value expectedValue, Value newValue, Value trueValue, Value falseValue, BarrierType barrierType) {
+        Value aRes = emitCompareAndSwapHelper(isLogic, accessKind, address, expectedValue, newValue, barrierType);
 
         if (isLogic) {
             assert trueValue.getValueKind().equals(falseValue.getValueKind());
             return emitCondMoveOp(Condition.EQ, trueValue, falseValue, false, false);
         } else {
-            if (isXmm) {
+            if (((AMD64Kind) accessKind.getPlatformKind()).isXMM()) {
                 return arithmeticLIRGen.emitReinterpret(accessKind, aRes);
             } else {
-                Variable result = newVariable(kind);
+                Variable result = newVariable(newValue.getValueKind());
                 emitMove(result, aRes);
                 return result;
             }
@@ -298,13 +303,11 @@ public Value emitValueCompareAndSwap(LIRKind accessKind, Value address, Value ex
 
     public void emitCompareAndSwapBranch(boolean isLogic, LIRKind kind, AMD64AddressValue address, Value expectedValue, Value newValue, Condition condition, LabelRef trueLabel, LabelRef falseLabel,
                     double trueLabelProbability, BarrierType barrierType) {
-        assert kind.getPlatformKind().getSizeInBytes() <= expectedValue.getValueKind().getPlatformKind().getSizeInBytes() : kind + " " + expectedValue;
-        assert kind.getPlatformKind().getSizeInBytes() <= newValue.getValueKind().getPlatformKind().getSizeInBytes() : kind + " " + newValue;
-        assert condition == Condition.EQ || condition == Condition.NE : Assertions.errorMessage(condition, address, expectedValue, newValue);
-        AMD64Kind memKind = (AMD64Kind) kind.getPlatformKind();
-        RegisterValue raxValue = AMD64.rax.asValue(kind);
-        emitMove(raxValue, expectedValue);
-        emitCompareAndSwapOp(isLogic, kind, memKind, raxValue, address, asAllocatable(newValue), barrierType);
+        GraalError.guarantee(kind.getPlatformKind().getSizeInBytes() <= expectedValue.getValueKind().getPlatformKind().getSizeInBytes(), "kind=%s, expectedValue=%s", kind, expectedValue);
+        GraalError.guarantee(kind.getPlatformKind().getSizeInBytes() <= newValue.getValueKind().getPlatformKind().getSizeInBytes(), "kind=%s, newValue=%s", kind, newValue);
+        GraalError.guarantee(condition == Condition.EQ || condition == Condition.NE, Assertions.errorMessage(condition, address, expectedValue, newValue));
+
+        emitCompareAndSwapHelper(isLogic, kind, address, expectedValue, newValue, barrierType);
         append(new BranchOp(condition, trueLabel, falseLabel, trueLabelProbability));
     }