private void prepareLeftOperand(
BooleanOperator operation,
Class<?> type,
Class<?> leftType,
Class<?> rightType,
Label shortcutEvaluation) {
if (leftType.isPrimitive()) {
if (type != null) {
castOrCoercePrimitive(LEFT_OPERAND, leftType, type);
}
return;
}
Label notNullLabel =
jitLeftIsNull(
type == null || leftType == type
? jitNullSafeOperationStart()
: jitNullSafeCoercion(leftType, type));
if (operation.isEquality() && !rightType.isPrimitive()) {
// if (left == null) return right == null
checkNullEquality();
} else {
// if (left == null) return false
mv.visitInsn(ICONST_0);
}
mv.visitJumpInsn(GOTO, shortcutEvaluation);
mv.visitLabel(notNullLabel);
}
private void jitMapAccessInvocation(MapAccessInvocation invocation, boolean firstInvocation) {
if (firstInvocation) {
mv.visitVarInsn(ALOAD, 1);
cast(Map.class);
}
Class<?> keyClass = jitExpression(invocation.getKey(), invocation.getKeyType());
if (keyClass.isPrimitive()) {
convertPrimitiveToObject(keyClass);
}
invokeInterface(Map.class, "get", Object.class, Object.class);
if (invocation.getReturnType() != Object.class) {
cast(invocation.getReturnType());
}
}
private void castOrCoercePrimitive(int regNr, Class<?> fromType, Class<?> toType) {
if (fromType == toType) {
return;
}
load(regNr);
if (toType.isPrimitive()) {
castPrimitiveToPrimitive(fromType, toType);
} else {
Class<?> toTypeAsPrimitive = convertToPrimitiveType(toType);
castPrimitiveToPrimitive(fromType, toTypeAsPrimitive);
invokeStatic(toType, "valueOf", toType, toTypeAsPrimitive);
}
store(regNr, toType);
}
private void jitBinary(SingleCondition singleCondition) {
Expression left = singleCondition.getLeft();
Expression right = singleCondition.getRight();
Class<?> commonType =
singleCondition.getOperation().needsSameType()
? findCommonClass(
left.getType(), !left.canBeNull(), right.getType(), !right.canBeNull())
: null;
if (commonType == Object.class && singleCondition.getOperation().isComparison()) {
commonType = Comparable.class;
}
if (commonType != null && commonType.isPrimitive()) {
jitPrimitiveBinary(singleCondition, left, right, commonType);
} else {
jitObjectBinary(singleCondition, left, right, commonType);
}
}
private void prepareRightOperand(
Expression right, Class<?> type, Class<?> rightType, Label shortcutEvaluation) {
if (rightType.isPrimitive()) {
if (type != null) {
castOrCoercePrimitive(RIGHT_OPERAND, rightType, type);
}
return;
}
Label nullLabel = new Label();
Label notNullLabel = new Label();
load(RIGHT_OPERAND);
mv.visitJumpInsn(IFNULL, nullLabel);
if (type != null && !isFixed(right) && rightType != type) {
castOrCoerceTo(RIGHT_OPERAND, rightType, type, nullLabel);
}
mv.visitJumpInsn(GOTO, notNullLabel);
mv.visitLabel(nullLabel);
mv.visitInsn(ICONST_0);
mv.visitJumpInsn(GOTO, shortcutEvaluation);
mv.visitLabel(notNullLabel);
}
private Class<?> findCommonClass(Class<?> class1, Class<?> class2, boolean canBePrimitive) {
if (class1.isAssignableFrom(class2)) {
return class1;
}
if (class1 == boolean.class && class2 == Boolean.class) {
return canBePrimitive ? boolean.class : Boolean.class;
}
if (class1 == char.class && class2 == Character.class) {
return canBePrimitive ? char.class : Character.class;
}
if (class1 == byte.class && class2 == Byte.class) {
return canBePrimitive ? byte.class : Byte.class;
}
if (class1 == short.class && class2 == Short.class) {
return canBePrimitive ? short.class : Short.class;
}
if (class1 == Number.class && class2.isPrimitive()) {
return Double.class;
}
if (class1 == int.class || class1 == short.class || class1 == byte.class) {
if (class2 == Integer.class) {
return canBePrimitive ? int.class : Integer.class;
}
if (class2 == long.class) {
return long.class;
}
if (class2 == Long.class) {
return canBePrimitive ? long.class : Long.class;
}
if (class2 == float.class) {
return float.class;
}
if (class2 == Float.class) {
return canBePrimitive ? float.class : Float.class;
}
if (class2 == double.class) {
return double.class;
}
if (class2 == Double.class) {
return canBePrimitive ? double.class : Double.class;
}
if (class2 == BigInteger.class) {
return BigInteger.class;
}
if (class2 == BigDecimal.class) {
return BigDecimal.class;
}
}
if (class1 == long.class) {
if (class2 == int.class) {
return long.class;
}
if (class2 == Integer.class) {
return canBePrimitive ? long.class : Long.class;
}
if (class2 == Long.class) {
return canBePrimitive ? long.class : Long.class;
}
if (class2 == float.class) {
return double.class;
}
if (class2 == Float.class) {
return canBePrimitive ? double.class : Double.class;
}
if (class2 == double.class) {
return double.class;
}
if (class2 == Double.class) {
return canBePrimitive ? double.class : Double.class;
}
if (class2 == BigInteger.class) {
return BigInteger.class;
}
if (class2 == BigDecimal.class) {
return BigDecimal.class;
}
}
if (class1 == float.class) {
if (class2 == int.class) {
return float.class;
}
if (class2 == Integer.class) {
return canBePrimitive ? float.class : Float.class;
}
if (class2 == long.class) {
return double.class;
}
if (class2 == Long.class) {
return canBePrimitive ? double.class : Double.class;
}
if (class2 == Float.class) {
return canBePrimitive ? float.class : Float.class;
}
if (class2 == double.class) {
return double.class;
}
if (class2 == Double.class) {
return canBePrimitive ? double.class : Double.class;
}
if (class2 == BigInteger.class) {
return BigDecimal.class;
}
if (class2 == BigDecimal.class) {
return BigDecimal.class;
}
}
if (class1 == double.class) {
if (class2 == int.class) {
return float.class;
}
if (class2 == Integer.class) {
return canBePrimitive ? double.class : Double.class;
}
if (class2 == long.class) {
return double.class;
}
if (class2 == Long.class) {
return canBePrimitive ? double.class : Double.class;
}
if (class2 == float.class) {
return double.class;
}
if (class2 == Float.class) {
return canBePrimitive ? double.class : Double.class;
}
if (class2 == Double.class) {
return canBePrimitive ? double.class : Double.class;
}
if (class2 == BigInteger.class) {
return BigDecimal.class;
}
if (class2 == BigDecimal.class) {
return BigDecimal.class;
}
}
if (class1 == Integer.class) {
if (class2 == Long.class) {
return Long.class;
}
if (class2 == Float.class) {
return Float.class;
}
if (class2 == Double.class) {
return Double.class;
}
if (class2 == BigInteger.class) {
return BigInteger.class;
}
if (class2 == BigDecimal.class) {
return BigDecimal.class;
}
}
if (class1 == Long.class) {
if (class2 == Float.class) {
return Double.class;
}
if (class2 == Double.class) {
return Double.class;
}
if (class2 == BigInteger.class) {
return BigInteger.class;
}
if (class2 == BigDecimal.class) {
return BigDecimal.class;
}
}
if (class1 == Float.class) {
if (class2 == Double.class) {
return Double.class;
}
if (class2 == BigInteger.class) {
return BigDecimal.class;
}
if (class2 == BigDecimal.class) {
return BigDecimal.class;
}
}
if (class1 == Double.class) {
if (class2 == BigInteger.class) {
return BigDecimal.class;
}
if (class2 == BigDecimal.class) {
return BigDecimal.class;
}
}
if (class1 == BigInteger.class) {
if (class2 == BigDecimal.class) {
return BigDecimal.class;
}
}
return null;
}
private void jitObjectBinary(
SingleCondition singleCondition, Expression left, Expression right, Class<?> type) {
Class<?> leftType =
isDeclarationExpression(left) ? convertFromPrimitiveType(left.getType()) : left.getType();
Class<?> rightType =
isDeclarationExpression(right)
? convertFromPrimitiveType(right.getType())
: right.getType();
jitExpression(left, type != null ? type : leftType);
if (isDeclarationExpression(left) && left.getType().isPrimitive()) {
castFromPrimitive(left.getType());
}
store(LEFT_OPERAND, leftType);
jitExpression(right, type != null ? type : rightType);
if (isDeclarationExpression(right) && right.getType().isPrimitive()) {
castFromPrimitive(right.getType());
}
store(RIGHT_OPERAND, rightType);
Label shortcutEvaluation = new Label();
BooleanOperator operation = singleCondition.getOperation();
prepareLeftOperand(operation, type, leftType, rightType, shortcutEvaluation);
prepareRightOperand(right, type, rightType, shortcutEvaluation);
load(LEFT_OPERAND);
load(RIGHT_OPERAND);
switch (operation) {
case CONTAINS:
invokeStatic(
EvaluatorHelper.class,
"contains",
boolean.class,
Object.class,
rightType.isPrimitive() ? rightType : Object.class);
break;
case MATCHES:
invokeVirtual(type, "matches", boolean.class, String.class);
break;
case SOUNDSLIKE:
invokeStatic(
EvaluatorHelper.class, "soundslike", boolean.class, String.class, String.class);
break;
default:
if (operation.isEquality()) {
if (type.isInterface()) {
invokeInterface(type, "equals", boolean.class, Object.class);
} else {
invokeVirtual(type, "equals", boolean.class, Object.class);
}
if (operation == BooleanOperator.NE) {
singleCondition.toggleNegation();
}
} else {
if (type.isInterface()) {
invokeInterface(
type, "compareTo", int.class, type == Comparable.class ? Object.class : type);
} else {
invokeVirtual(type, "compareTo", int.class, type);
}
mv.visitInsn(ICONST_0);
jitPrimitiveOperation(operation, int.class);
}
}
mv.visitLabel(shortcutEvaluation);
}