Mercurial > hg > graal-compiler

changeset 22930:33c69b58ff65

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Move emitCompareOp to AMD64ArithmeticLIRGeneratorTool.
author Roland Schatz <roland.schatz@oracle.com>
date Tue, 03 Nov 2015 11:01:20 +0100
parents 098c285cc3b8
children d7df89bcc764
files graal/com.oracle.graal.compiler.amd64/src/com/oracle/graal/compiler/amd64/AMD64ArithmeticLIRGenerator.java graal/com.oracle.graal.compiler.amd64/src/com/oracle/graal/compiler/amd64/AMD64LIRGenerator.java graal/com.oracle.graal.lir.amd64/src/com/oracle/graal/lir/amd64/AMD64ArithmeticLIRGeneratorTool.java
diffstat 3 files changed, 73 insertions(+), 68 deletions(-) [+]
line wrap: on
line diff
--- a/graal/com.oracle.graal.compiler.amd64/src/com/oracle/graal/compiler/amd64/AMD64ArithmeticLIRGenerator.java	Mon Nov 02 18:25:48 2015 +0100
+++ b/graal/com.oracle.graal.compiler.amd64/src/com/oracle/graal/compiler/amd64/AMD64ArithmeticLIRGenerator.java	Tue Nov 03 11:01:20 2015 +0100
@@ -25,6 +25,7 @@
 
 import static com.oracle.graal.asm.amd64.AMD64Assembler.AMD64BinaryArithmetic.ADD;
 import static com.oracle.graal.asm.amd64.AMD64Assembler.AMD64BinaryArithmetic.AND;
+import static com.oracle.graal.asm.amd64.AMD64Assembler.AMD64BinaryArithmetic.CMP;
 import static com.oracle.graal.asm.amd64.AMD64Assembler.AMD64BinaryArithmetic.OR;
 import static com.oracle.graal.asm.amd64.AMD64Assembler.AMD64BinaryArithmetic.SUB;
 import static com.oracle.graal.asm.amd64.AMD64Assembler.AMD64BinaryArithmetic.XOR;
@@ -42,6 +43,8 @@
 import static com.oracle.graal.asm.amd64.AMD64Assembler.AMD64RMOp.MOVZX;
 import static com.oracle.graal.asm.amd64.AMD64Assembler.AMD64RMOp.MOVZXB;
 import static com.oracle.graal.asm.amd64.AMD64Assembler.AMD64RMOp.POPCNT;
+import static com.oracle.graal.asm.amd64.AMD64Assembler.AMD64RMOp.TEST;
+import static com.oracle.graal.asm.amd64.AMD64Assembler.AMD64RMOp.TESTB;
 import static com.oracle.graal.asm.amd64.AMD64Assembler.AMD64RMOp.TZCNT;
 import static com.oracle.graal.asm.amd64.AMD64Assembler.AMD64Shift.ROL;
 import static com.oracle.graal.asm.amd64.AMD64Assembler.AMD64Shift.ROR;
@@ -92,9 +95,11 @@
 import com.oracle.graal.asm.amd64.AMD64Assembler.AMD64Shift;
 import com.oracle.graal.asm.amd64.AMD64Assembler.OperandSize;
 import com.oracle.graal.asm.amd64.AMD64Assembler.SSEOp;
+import com.oracle.graal.compiler.common.GraalOptions;
 import com.oracle.graal.compiler.common.calc.FloatConvert;
 import com.oracle.graal.lir.ConstantValue;
 import com.oracle.graal.lir.LIRFrameState;
+import com.oracle.graal.lir.LIRValueUtil;
 import com.oracle.graal.lir.Variable;
 import com.oracle.graal.lir.amd64.AMD64AddressValue;
 import com.oracle.graal.lir.amd64.AMD64Arithmetic.FPDivRemOp;
@@ -1037,4 +1042,63 @@
             emitStore(kind, storeAddress, getLIRGen().asAllocatable(input), state);
         }
     }
+
+    @Override
+    public void emitCompareOp(AMD64Kind cmpKind, Variable left, Value right) {
+        OperandSize size;
+        switch (cmpKind) {
+            case BYTE:
+                size = BYTE;
+                break;
+            case WORD:
+                size = WORD;
+                break;
+            case DWORD:
+                size = DWORD;
+                break;
+            case QWORD:
+                size = QWORD;
+                break;
+            case SINGLE:
+                getLIRGen().append(new AMD64BinaryConsumer.Op(SSEOp.UCOMIS, PS, left, getLIRGen().asAllocatable(right)));
+                return;
+            case DOUBLE:
+                getLIRGen().append(new AMD64BinaryConsumer.Op(SSEOp.UCOMIS, PD, left, getLIRGen().asAllocatable(right)));
+                return;
+            default:
+                throw JVMCIError.shouldNotReachHere("unexpected kind: " + cmpKind);
+        }
+
+        if (isConstantValue(right)) {
+            Constant c = LIRValueUtil.asConstant(right);
+            if (JavaConstant.isNull(c)) {
+                getLIRGen().append(new AMD64BinaryConsumer.Op(TEST, DWORD, left, left));
+                return;
+            } else if (c instanceof VMConstant) {
+                VMConstant vc = (VMConstant) c;
+                boolean isImmutable = GraalOptions.ImmutableCode.getValue();
+                boolean generatePIC = GraalOptions.GeneratePIC.getValue();
+                if (size == DWORD && !(isImmutable && generatePIC)) {
+                    getLIRGen().append(new AMD64BinaryConsumer.VMConstOp(CMP.getMIOpcode(DWORD, false), left, vc));
+                } else {
+                    getLIRGen().append(new AMD64BinaryConsumer.DataOp(CMP.getRMOpcode(size), size, left, vc));
+                }
+                return;
+            } else if (c instanceof JavaConstant) {
+                JavaConstant jc = (JavaConstant) c;
+                if (jc.isDefaultForKind()) {
+                    AMD64RMOp op = size == BYTE ? TESTB : TEST;
+                    getLIRGen().append(new AMD64BinaryConsumer.Op(op, size, left, left));
+                    return;
+                } else if (NumUtil.is32bit(jc.asLong())) {
+                    getLIRGen().append(new AMD64BinaryConsumer.ConstOp(CMP, size, left, (int) jc.asLong()));
+                    return;
+                }
+            }
+        }
+
+        // fallback: load, then compare
+        getLIRGen().append(new AMD64BinaryConsumer.Op(CMP.getRMOpcode(size), size, left, getLIRGen().asAllocatable(right)));
+    }
+
 }
--- a/graal/com.oracle.graal.compiler.amd64/src/com/oracle/graal/compiler/amd64/AMD64LIRGenerator.java	Mon Nov 02 18:25:48 2015 +0100
+++ b/graal/com.oracle.graal.compiler.amd64/src/com/oracle/graal/compiler/amd64/AMD64LIRGenerator.java	Tue Nov 03 11:01:20 2015 +0100
@@ -24,17 +24,12 @@
 package com.oracle.graal.compiler.amd64;
 
 import static com.oracle.graal.asm.amd64.AMD64Assembler.AMD64BinaryArithmetic.CMP;
-import static com.oracle.graal.asm.amd64.AMD64Assembler.AMD64RMOp.TEST;
-import static com.oracle.graal.asm.amd64.AMD64Assembler.AMD64RMOp.TESTB;
-import static com.oracle.graal.asm.amd64.AMD64Assembler.OperandSize.BYTE;
 import static com.oracle.graal.asm.amd64.AMD64Assembler.OperandSize.DWORD;
 import static com.oracle.graal.asm.amd64.AMD64Assembler.OperandSize.PD;
 import static com.oracle.graal.asm.amd64.AMD64Assembler.OperandSize.PS;
 import static com.oracle.graal.asm.amd64.AMD64Assembler.OperandSize.QWORD;
-import static com.oracle.graal.asm.amd64.AMD64Assembler.OperandSize.WORD;
 import static com.oracle.graal.lir.LIRValueUtil.asConstantValue;
 import static com.oracle.graal.lir.LIRValueUtil.asJavaConstant;
-import static com.oracle.graal.lir.LIRValueUtil.isConstantValue;
 import static com.oracle.graal.lir.LIRValueUtil.isJavaConstant;
 import static jdk.vm.ci.code.ValueUtil.isAllocatableValue;
 import jdk.vm.ci.amd64.AMD64;
@@ -43,7 +38,6 @@
 import jdk.vm.ci.code.RegisterValue;
 import jdk.vm.ci.common.JVMCIError;
 import jdk.vm.ci.meta.AllocatableValue;
-import jdk.vm.ci.meta.Constant;
 import jdk.vm.ci.meta.JavaConstant;
 import jdk.vm.ci.meta.JavaKind;
 import jdk.vm.ci.meta.LIRKind;
@@ -57,7 +51,6 @@
 import com.oracle.graal.asm.amd64.AMD64Assembler.ConditionFlag;
 import com.oracle.graal.asm.amd64.AMD64Assembler.OperandSize;
 import com.oracle.graal.asm.amd64.AMD64Assembler.SSEOp;
-import com.oracle.graal.compiler.common.GraalOptions;
 import com.oracle.graal.compiler.common.calc.Condition;
 import com.oracle.graal.compiler.common.spi.ForeignCallLinkage;
 import com.oracle.graal.compiler.common.spi.LIRKindTool;
@@ -70,6 +63,7 @@
 import com.oracle.graal.lir.SwitchStrategy;
 import com.oracle.graal.lir.Variable;
 import com.oracle.graal.lir.amd64.AMD64AddressValue;
+import com.oracle.graal.lir.amd64.AMD64ArithmeticLIRGeneratorTool;
 import com.oracle.graal.lir.amd64.AMD64ArrayEqualsOp;
 import com.oracle.graal.lir.amd64.AMD64BinaryConsumer;
 import com.oracle.graal.lir.amd64.AMD64ByteSwapOp;
@@ -297,63 +291,6 @@
         }
     }
 
-    protected void emitCompareOp(PlatformKind cmpKind, Variable left, Value right) {
-        OperandSize size;
-        switch ((AMD64Kind) cmpKind) {
-            case BYTE:
-                size = BYTE;
-                break;
-            case WORD:
-                size = WORD;
-                break;
-            case DWORD:
-                size = DWORD;
-                break;
-            case QWORD:
-                size = QWORD;
-                break;
-            case SINGLE:
-                append(new AMD64BinaryConsumer.Op(SSEOp.UCOMIS, PS, left, asAllocatable(right)));
-                return;
-            case DOUBLE:
-                append(new AMD64BinaryConsumer.Op(SSEOp.UCOMIS, PD, left, asAllocatable(right)));
-                return;
-            default:
-                throw JVMCIError.shouldNotReachHere("unexpected kind: " + cmpKind);
-        }
-
-        if (isConstantValue(right)) {
-            Constant c = LIRValueUtil.asConstant(right);
-            if (JavaConstant.isNull(c)) {
-                append(new AMD64BinaryConsumer.Op(TEST, DWORD, left, left));
-                return;
-            } else if (c instanceof VMConstant) {
-                VMConstant vc = (VMConstant) c;
-                boolean isImmutable = GraalOptions.ImmutableCode.getValue();
-                boolean generatePIC = GraalOptions.GeneratePIC.getValue();
-                if (size == DWORD && !(isImmutable && generatePIC)) {
-                    append(new AMD64BinaryConsumer.VMConstOp(CMP.getMIOpcode(DWORD, false), left, vc));
-                } else {
-                    append(new AMD64BinaryConsumer.DataOp(CMP.getRMOpcode(size), size, left, vc));
-                }
-                return;
-            } else if (c instanceof JavaConstant) {
-                JavaConstant jc = (JavaConstant) c;
-                if (jc.isDefaultForKind()) {
-                    AMD64RMOp op = size == BYTE ? TESTB : TEST;
-                    append(new AMD64BinaryConsumer.Op(op, size, left, left));
-                    return;
-                } else if (NumUtil.is32bit(jc.asLong())) {
-                    append(new AMD64BinaryConsumer.ConstOp(CMP, size, left, (int) jc.asLong()));
-                    return;
-                }
-            }
-        }
-
-        // fallback: load, then compare
-        append(new AMD64BinaryConsumer.Op(CMP.getRMOpcode(size), size, left, asAllocatable(right)));
-    }
-
     /**
      * This method emits the compare against memory instruction, and may reorder the operands. It
      * returns true if it did so.
@@ -439,7 +376,7 @@
             right = loadNonConst(b);
             mirrored = false;
         }
-        emitCompareOp(cmpKind, left, right);
+        ((AMD64ArithmeticLIRGeneratorTool) arithmeticLIRGen).emitCompareOp((AMD64Kind) cmpKind, left, right);
         return mirrored;
     }
 
--- a/graal/com.oracle.graal.lir.amd64/src/com/oracle/graal/lir/amd64/AMD64ArithmeticLIRGeneratorTool.java	Mon Nov 02 18:25:48 2015 +0100
+++ b/graal/com.oracle.graal.lir.amd64/src/com/oracle/graal/lir/amd64/AMD64ArithmeticLIRGeneratorTool.java	Tue Nov 03 11:01:20 2015 +0100
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2013, 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2013, 2015, 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
@@ -22,9 +22,11 @@
  */
 package com.oracle.graal.lir.amd64;
 
-import com.oracle.graal.lir.gen.ArithmeticLIRGeneratorTool;
+import jdk.vm.ci.amd64.AMD64Kind;
+import jdk.vm.ci.meta.Value;
 
-import jdk.vm.ci.meta.Value;
+import com.oracle.graal.lir.Variable;
+import com.oracle.graal.lir.gen.ArithmeticLIRGeneratorTool;
 
 /**
  * This interface can be used to generate AMD64 LIR for arithmetic operations.
@@ -42,4 +44,6 @@
     Value emitCountLeadingZeros(Value value);
 
     Value emitCountTrailingZeros(Value value);
+
+    void emitCompareOp(AMD64Kind cmpKind, Variable left, Value right);
 }