1 /* 2 * Copyright (c) 2013, 2018, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 */ 23 24 25 package org.graalvm.compiler.lir.aarch64; 26 27 import static jdk.vm.ci.code.ValueUtil.asRegister; 28 import static jdk.vm.ci.code.ValueUtil.isRegister; 29 import static org.graalvm.compiler.lir.LIRInstruction.OperandFlag.CONST; 30 import static org.graalvm.compiler.lir.LIRInstruction.OperandFlag.REG; 31 import static org.graalvm.compiler.lir.LIRValueUtil.asJavaConstant; 32 import static org.graalvm.compiler.lir.LIRValueUtil.isJavaConstant; 33 34 import org.graalvm.compiler.asm.aarch64.AArch64Assembler; 35 import org.graalvm.compiler.asm.aarch64.AArch64MacroAssembler; 36 import org.graalvm.compiler.core.common.NumUtil; 37 import org.graalvm.compiler.core.common.calc.Condition; 38 import org.graalvm.compiler.debug.GraalError; 39 import org.graalvm.compiler.lir.LIRInstructionClass; 40 import org.graalvm.compiler.lir.asm.CompilationResultBuilder; 41 42 import jdk.vm.ci.meta.JavaConstant; 43 import jdk.vm.ci.meta.Value; 44 45 public class AArch64Compare { 46 47 public static class CompareOp extends AArch64LIRInstruction { 48 public static final LIRInstructionClass<CompareOp> TYPE = LIRInstructionClass.create(CompareOp.class); 49 50 @Use protected Value x; 51 @Use({REG, CONST}) protected Value y; 52 CompareOp(Value x, Value y)53 public CompareOp(Value x, Value y) { 54 super(TYPE); 55 assert x.getPlatformKind() == y.getPlatformKind() : x.getPlatformKind() + " " + y.getPlatformKind(); 56 this.x = x; 57 this.y = y; 58 } 59 60 @Override emitCode(CompilationResultBuilder crb, AArch64MacroAssembler masm)61 public void emitCode(CompilationResultBuilder crb, AArch64MacroAssembler masm) { 62 gpCompare(masm, x, y); 63 } 64 } 65 66 /** 67 * Compares integer values x and y. 68 * 69 * @param x integer value to compare. May not be null. 70 * @param y integer value to compare. May not be null. 71 */ gpCompare(AArch64MacroAssembler masm, Value x, Value y)72 public static void gpCompare(AArch64MacroAssembler masm, Value x, Value y) { 73 final int size = x.getPlatformKind().getSizeInBytes() * Byte.SIZE; 74 if (isRegister(y)) { 75 masm.cmp(size, asRegister(x), asRegister(y)); 76 } else { 77 JavaConstant constant = asJavaConstant(y); 78 if (constant.isDefaultForKind()) { 79 masm.cmp(size, asRegister(x), 0); 80 } else { 81 final long longValue = constant.asLong(); 82 assert NumUtil.isInt(longValue); 83 int maskedValue; 84 switch (constant.getJavaKind()) { 85 case Boolean: 86 case Byte: 87 maskedValue = (int) (longValue & 0xFF); 88 break; 89 case Char: 90 case Short: 91 maskedValue = (int) (longValue & 0xFFFF); 92 break; 93 case Int: 94 case Long: 95 maskedValue = (int) longValue; 96 break; 97 default: 98 throw GraalError.shouldNotReachHere(); 99 } 100 masm.cmp(size, asRegister(x), maskedValue); 101 } 102 } 103 } 104 105 public static class FloatCompareOp extends AArch64LIRInstruction { 106 public static final LIRInstructionClass<FloatCompareOp> TYPE = LIRInstructionClass.create(FloatCompareOp.class); 107 108 @Use protected Value x; 109 @Use({REG, CONST}) protected Value y; 110 private final Condition condition; 111 private final boolean unorderedIsTrue; 112 FloatCompareOp(Value x, Value y, Condition condition, boolean unorderedIsTrue)113 public FloatCompareOp(Value x, Value y, Condition condition, boolean unorderedIsTrue) { 114 super(TYPE); 115 assert !isJavaConstant(y) || isFloatCmpConstant(y, condition, unorderedIsTrue); 116 this.x = x; 117 this.y = y; 118 this.condition = condition; 119 this.unorderedIsTrue = unorderedIsTrue; 120 } 121 122 /** 123 * Checks if val can be used as a constant for the gpCompare operation or not. 124 */ isFloatCmpConstant(Value val, Condition condition, boolean unorderedIsTrue)125 public static boolean isFloatCmpConstant(Value val, Condition condition, boolean unorderedIsTrue) { 126 // If the condition is "EQ || unordered" or "NE && unordered" we have to use 2 registers 127 // in any case. 128 if (!(condition == Condition.EQ && unorderedIsTrue || condition == Condition.NE && !unorderedIsTrue)) { 129 return false; 130 } 131 return isJavaConstant(val) && asJavaConstant(val).isDefaultForKind(); 132 } 133 134 @Override emitCode(CompilationResultBuilder crb, AArch64MacroAssembler masm)135 public void emitCode(CompilationResultBuilder crb, AArch64MacroAssembler masm) { 136 assert isRegister(x); 137 int size = x.getPlatformKind().getSizeInBytes() * Byte.SIZE; 138 if (isRegister(y)) { 139 masm.fcmp(size, asRegister(x), asRegister(y)); 140 // There is no condition code for "EQ || unordered" nor one for "NE && unordered", 141 // so we have to fix them up ourselves. 142 // In both cases we combine the asked for condition into the EQ, respectively NE 143 // condition, i.e. 144 // if EQ && unoreredIsTrue, then the EQ flag will be set if the two values gpCompare 145 // unequal but are 146 // unordered. 147 if (condition == Condition.EQ && unorderedIsTrue) { 148 // if f1 ordered f2: 149 // result = f1 == f2 150 // else: 151 // result = EQUAL 152 int nzcv = 0b0100; // EQUAL -> Z = 1 153 masm.fccmp(size, asRegister(x), asRegister(y), nzcv, AArch64Assembler.ConditionFlag.VC); 154 } else if (condition == Condition.NE && !unorderedIsTrue) { 155 // if f1 ordered f2: 156 // result = f1 != f2 157 // else: 158 // result = !NE == EQUAL 159 int nzcv = 0b0100; // EQUAL -> Z = 1 160 masm.fccmp(size, asRegister(x), asRegister(y), nzcv, AArch64Assembler.ConditionFlag.VC); 161 } 162 } else { 163 // cmp against +0.0 164 masm.fcmpZero(size, asRegister(x)); 165 } 166 } 167 168 @Override verify()169 public void verify() { 170 assert x.getPlatformKind().equals(y.getPlatformKind()) : "a: " + x + " b: " + y; 171 } 172 } 173 174 } 175