src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.core.aarch64/src/org/graalvm/compiler/core/aarch64/AArch64NodeMatchRules.java

rev 52509 : [mq]: graal2

*** 23,37 ****
--- 23,48 ----
  
  
  
  package org.graalvm.compiler.core.aarch64;
  
+ import org.graalvm.compiler.asm.aarch64.AArch64MacroAssembler;
  import org.graalvm.compiler.core.gen.NodeMatchRules;
+ import org.graalvm.compiler.core.match.ComplexMatchResult;
+ import org.graalvm.compiler.core.match.MatchRule;
  import org.graalvm.compiler.lir.LIRFrameState;
+ import org.graalvm.compiler.lir.aarch64.AArch64ArithmeticOp;
  import org.graalvm.compiler.lir.gen.LIRGeneratorTool;
+ import org.graalvm.compiler.nodes.ConstantNode;
  import org.graalvm.compiler.nodes.DeoptimizingNode;
  import org.graalvm.compiler.nodes.NodeView;
+ import org.graalvm.compiler.nodes.ValueNode;
+ import org.graalvm.compiler.nodes.calc.AddNode;
+ import org.graalvm.compiler.nodes.calc.BinaryNode;
+ import org.graalvm.compiler.nodes.calc.LeftShiftNode;
+ import org.graalvm.compiler.nodes.calc.RightShiftNode;
+ import org.graalvm.compiler.nodes.calc.UnsignedRightShiftNode;
  import org.graalvm.compiler.nodes.memory.Access;
  
  import jdk.vm.ci.aarch64.AArch64Kind;
  
  public class AArch64NodeMatchRules extends NodeMatchRules {
*** 49,58 ****
--- 60,99 ----
  
      protected AArch64Kind getMemoryKind(Access access) {
          return (AArch64Kind) gen.getLIRKind(access.asNode().stamp(NodeView.DEFAULT)).getPlatformKind();
      }
  
+     private ComplexMatchResult emitAddSubShift(AArch64ArithmeticOp op, ValueNode value, BinaryNode shift) {
+         assert shift.getY() instanceof ConstantNode;
+         int shiftAmount = shift.getY().asJavaConstant().asInt();
+ 
+         if (shift instanceof LeftShiftNode) {
+             return builder -> getArithmeticLIRGenerator().emitAddSubShift(op, operand(value), operand(shift.getX()),
+                             AArch64MacroAssembler.ShiftType.LSL, shiftAmount);
+         } else if (shift instanceof RightShiftNode) {
+             return builder -> getArithmeticLIRGenerator().emitAddSubShift(op, operand(value), operand(shift.getX()),
+                             AArch64MacroAssembler.ShiftType.ASR, shiftAmount);
+         } else {
+             assert shift instanceof UnsignedRightShiftNode;
+             return builder -> getArithmeticLIRGenerator().emitAddSubShift(op, operand(value), operand(shift.getX()),
+                             AArch64MacroAssembler.ShiftType.LSR, shiftAmount);
+         }
+     }
+ 
+     @MatchRule("(Add=binary a (LeftShift=shift b Constant))")
+     @MatchRule("(Add=binary a (RightShift=shift b Constant))")
+     @MatchRule("(Add=binary a (UnsignedRightShift=shift b Constant))")
+     @MatchRule("(Sub=binary a (LeftShift=shift b Constant))")
+     @MatchRule("(Sub=binary a (RightShift=shift b Constant))")
+     @MatchRule("(Sub=binary a (UnsignedRightShift=shift b Constant))")
+     public ComplexMatchResult addSubShift(BinaryNode binary, ValueNode a, BinaryNode shift) {
+         if (binary instanceof AddNode) {
+             return emitAddSubShift(AArch64ArithmeticOp.ADD, a, shift);
+         }
+         return emitAddSubShift(AArch64ArithmeticOp.SUB, a, shift);
+     }
+ 
      @Override
      public AArch64LIRGenerator getLIRGeneratorTool() {
          return (AArch64LIRGenerator) gen;
      }