[GR-35831] Intrinsify recursive ObjectMonitor locking.

PullRequest: graal/11147

Author: mur47x111

compiler/src/org.graalvm.compiler.core.amd64/src/org/graalvm/compiler/core/amd64/AMD64ArithmeticLIRGenerator.java

@@ -262,7 +262,7 @@ private Variable emitBinaryConst(LIRKind resultKind, AMD64BinaryArithmetic op, O
         }
     }
 
-    private static AMD64MOp getMOp(AMD64BinaryArithmetic op, int constant) {
+    public static AMD64MOp getMOp(AMD64BinaryArithmetic op, int constant) {
         if (constant == 1) {
             if (op.equals(AMD64BinaryArithmetic.ADD)) {
                 return AMD64MOp.INC;

compiler/src/org.graalvm.compiler.core.amd64/src/org/graalvm/compiler/core/amd64/AMD64NodeMatchRules.java

@@ -62,8 +62,10 @@
 import org.graalvm.compiler.lir.LIRValueUtil;
 import org.graalvm.compiler.lir.LabelRef;
 import org.graalvm.compiler.lir.amd64.AMD64AddressValue;
+import org.graalvm.compiler.lir.amd64.AMD64BinaryConsumer;
 import org.graalvm.compiler.lir.amd64.AMD64ControlFlow.TestBranchOp;
 import org.graalvm.compiler.lir.amd64.AMD64ControlFlow.TestConstBranchOp;
+import org.graalvm.compiler.lir.amd64.AMD64UnaryConsumer;
 import org.graalvm.compiler.lir.gen.LIRGeneratorTool;
 import org.graalvm.compiler.nodes.ConstantNode;
 import org.graalvm.compiler.nodes.DeoptimizingNode;
@@ -83,6 +85,7 @@
 import org.graalvm.compiler.nodes.memory.AddressableMemoryAccess;
 import org.graalvm.compiler.nodes.memory.LIRLowerableAccess;
 import org.graalvm.compiler.nodes.memory.MemoryAccess;
+import org.graalvm.compiler.nodes.memory.ReadNode;
 import org.graalvm.compiler.nodes.memory.WriteNode;
 import org.graalvm.compiler.nodes.util.GraphUtil;
 
@@ -577,6 +580,59 @@ public ComplexMatchResult xorMemory(ValueNode value, LIRLowerableAccess access)
         }
     }
 
+    private ComplexMatchResult emitMemoryConsumer(WriteNode write, AMD64Assembler.AMD64BinaryArithmetic arithmeticOp, ReadNode read, ValueNode value) {
+        if (getMemoryKind(write).isInteger() && !write.canDeoptimize() && !read.canDeoptimize()) {
+            OperandSize size = getMemorySize(write);
+            if (write.getAddress() == read.getAddress()) {
+                if (value.isJavaConstant()) {
+                    long valueCst = value.asJavaConstant().asLong();
+                    if (NumUtil.isInt(valueCst)) {
+                        AMD64Assembler.AMD64MOp mop = AMD64ArithmeticLIRGenerator.getMOp(arithmeticOp, (int) valueCst);
+                        if (mop != null) {
+                            return builder -> {
+                                AMD64AddressValue addressValue = (AMD64AddressValue) operand(write.getAddress());
+                                builder.append(new AMD64UnaryConsumer.MemoryOp(mop, size, addressValue));
+                                return null;
+                            };
+                        } else {
+                            return builder -> {
+                                AMD64AddressValue addressValue = (AMD64AddressValue) operand(write.getAddress());
+                                builder.append(new AMD64BinaryConsumer.MemoryConstOp(arithmeticOp.getMIOpcode(size, NumUtil.isByte(valueCst)), size, addressValue, (int) valueCst, state(write)));
+                                return null;
+                            };
+                        }
+                    }
+                }
+                return builder -> {
+                    AMD64AddressValue addressValue = (AMD64AddressValue) operand(write.getAddress());
+                    builder.append(new AMD64BinaryConsumer.MemoryMROp(arithmeticOp.getMROpcode(size), size, addressValue, builder.getLIRGeneratorTool().asAllocatable(operand(value)), state(write)));
+                    return null;
+                };
+            }
+        }
+        return null;
+    }
+
+    @MatchRule("(Write=write object (Add Read=read value))")
+    public ComplexMatchResult addToMemory(WriteNode write, ReadNode read, ValueNode value) {
+        return emitMemoryConsumer(write, ADD, read, value);
+    }
+
+    @MatchRule("(Write=write object (Sub Read=read value))")
+    public ComplexMatchResult subToMemory(WriteNode write, ReadNode read, ValueNode value) {
+        return emitMemoryConsumer(write, SUB, read, value);
+    }
+
+    @MatchRule("(Write=write object (Or Read=read value))")
+    public ComplexMatchResult orToMemory(WriteNode write, ReadNode read, ValueNode value) {
+        return emitMemoryConsumer(write, OR, read, value);
+    }
+
+    @MatchRule("(Write=write object (Xor Read=read value))")
+    public ComplexMatchResult xorToMemory(WriteNode write, ReadNode read, ValueNode value) {
+        return emitMemoryConsumer(write, XOR, read, value);
+    }
+
     @MatchRule("(Write object Narrow=narrow)")
     public ComplexMatchResult writeNarrow(WriteNode root, NarrowNode narrow) {
         return builder -> {