/*

 * Copyright (c) 2009, 2016, 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

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

package org.graalvm.compiler.core.amd64;

import static jdk.vm.ci.code.ValueUtil.asRegister;

import static jdk.vm.ci.code.ValueUtil.isAllocatableValue;

import static jdk.vm.ci.code.ValueUtil.isRegister;

import static org.graalvm.compiler.asm.amd64.AMD64Assembler.AMD64BinaryArithmetic.CMP;

import static org.graalvm.compiler.asm.amd64.AMD64BaseAssembler.OperandSize.DWORD;

import static org.graalvm.compiler.asm.amd64.AMD64BaseAssembler.OperandSize.PD;

import static org.graalvm.compiler.asm.amd64.AMD64BaseAssembler.OperandSize.PS;

import static org.graalvm.compiler.asm.amd64.AMD64BaseAssembler.OperandSize.QWORD;

import static org.graalvm.compiler.core.common.GraalOptions.GeneratePIC;

import static org.graalvm.compiler.lir.LIRValueUtil.asConstant;

import static org.graalvm.compiler.lir.LIRValueUtil.asConstantValue;

import static org.graalvm.compiler.lir.LIRValueUtil.asJavaConstant;

import static org.graalvm.compiler.lir.LIRValueUtil.isConstantValue;

import static org.graalvm.compiler.lir.LIRValueUtil.isIntConstant;

import static org.graalvm.compiler.lir.LIRValueUtil.isJavaConstant;

import org.graalvm.compiler.asm.amd64.AMD64Assembler.AMD64BinaryArithmetic;

import org.graalvm.compiler.asm.amd64.AMD64Assembler.AMD64MIOp;

import org.graalvm.compiler.asm.amd64.AMD64Assembler.AMD64RMOp;

import org.graalvm.compiler.asm.amd64.AMD64Assembler.ConditionFlag;

import org.graalvm.compiler.asm.amd64.AMD64BaseAssembler.OperandSize;

import org.graalvm.compiler.asm.amd64.AMD64Assembler.SSEOp;

import org.graalvm.compiler.core.common.LIRKind;

import org.graalvm.compiler.core.common.NumUtil;

import org.graalvm.compiler.core.common.calc.Condition;

import org.graalvm.compiler.core.common.spi.ForeignCallLinkage;

import org.graalvm.compiler.core.common.spi.LIRKindTool;

import org.graalvm.compiler.debug.GraalError;

import org.graalvm.compiler.lir.ConstantValue;

import org.graalvm.compiler.lir.LIRFrameState;

import org.graalvm.compiler.lir.LIRInstruction;

import org.graalvm.compiler.lir.LIRValueUtil;

import org.graalvm.compiler.lir.LabelRef;

import org.graalvm.compiler.lir.StandardOp.JumpOp;

import org.graalvm.compiler.lir.StandardOp.SaveRegistersOp;

import org.graalvm.compiler.lir.SwitchStrategy;

import org.graalvm.compiler.lir.Variable;

import org.graalvm.compiler.lir.amd64.AMD64AddressValue;

import org.graalvm.compiler.lir.amd64.AMD64ArithmeticLIRGeneratorTool;

import org.graalvm.compiler.lir.amd64.AMD64ArrayCompareToOp;

import org.graalvm.compiler.lir.amd64.AMD64ArrayEqualsOp;

import org.graalvm.compiler.lir.amd64.AMD64ArrayIndexOfOp;

import org.graalvm.compiler.lir.amd64.AMD64Binary;

import org.graalvm.compiler.lir.amd64.AMD64BinaryConsumer;

import org.graalvm.compiler.lir.amd64.AMD64ByteSwapOp;

import org.graalvm.compiler.lir.amd64.AMD64Call;

import org.graalvm.compiler.lir.amd64.AMD64ControlFlow;

import org.graalvm.compiler.lir.amd64.AMD64ControlFlow.BranchOp;

import org.graalvm.compiler.lir.amd64.AMD64ControlFlow.CondMoveOp;

import org.graalvm.compiler.lir.amd64.AMD64ControlFlow.CondSetOp;

import org.graalvm.compiler.lir.amd64.AMD64ControlFlow.FloatBranchOp;

import org.graalvm.compiler.lir.amd64.AMD64ControlFlow.FloatCondMoveOp;

import org.graalvm.compiler.lir.amd64.AMD64ControlFlow.FloatCondSetOp;

import org.graalvm.compiler.lir.amd64.AMD64ControlFlow.ReturnOp;

import org.graalvm.compiler.lir.amd64.AMD64ControlFlow.StrategySwitchOp;

import org.graalvm.compiler.lir.amd64.AMD64ControlFlow.TableSwitchOp;

import org.graalvm.compiler.lir.amd64.AMD64LFenceOp;

import org.graalvm.compiler.lir.amd64.AMD64Move;

import org.graalvm.compiler.lir.amd64.AMD64Move.CompareAndSwapOp;

import org.graalvm.compiler.lir.amd64.AMD64Move.MembarOp;

import org.graalvm.compiler.lir.amd64.AMD64Move.StackLeaOp;

import org.graalvm.compiler.lir.amd64.AMD64PauseOp;

import org.graalvm.compiler.lir.amd64.AMD64ZapRegistersOp;

import org.graalvm.compiler.lir.amd64.AMD64ZapStackOp;

import org.graalvm.compiler.lir.gen.LIRGenerationResult;

import org.graalvm.compiler.lir.gen.LIRGenerator;

import org.graalvm.compiler.phases.util.Providers;

import jdk.vm.ci.amd64.AMD64;

import jdk.vm.ci.amd64.AMD64Kind;

import jdk.vm.ci.code.CallingConvention;

import jdk.vm.ci.code.Register;

import jdk.vm.ci.code.RegisterValue;

import jdk.vm.ci.code.StackSlot;

import jdk.vm.ci.meta.AllocatableValue;

import jdk.vm.ci.meta.JavaConstant;

import jdk.vm.ci.meta.JavaKind;

import jdk.vm.ci.meta.PlatformKind;

import jdk.vm.ci.meta.VMConstant;

import jdk.vm.ci.meta.Value;

import jdk.vm.ci.meta.ValueKind;

/**

 * This class implements the AMD64 specific portion of the LIR generator.

 */

public abstract class AMD64LIRGenerator extends LIRGenerator {

    public AMD64LIRGenerator(LIRKindTool lirKindTool, AMD64ArithmeticLIRGenerator arithmeticLIRGen, MoveFactory moveFactory, Providers providers, LIRGenerationResult lirGenRes) {

        super(lirKindTool, arithmeticLIRGen, moveFactory, providers, lirGenRes);

    }

    /**

     * Checks whether the supplied constant can be used without loading it into a register for store

     * operations, i.e., on the right hand side of a memory access.

     *

     * @param c The constant to check.

     * @return True if the constant can be used directly, false if the constant needs to be in a

     *         register.

     */

    protected static final boolean canStoreConstant(JavaConstant c) {

        // there is no immediate move of 64-bit constants on Intel

        switch (c.getJavaKind()) {

            case Long:

                return NumUtil.isInt(c.asLong());

            case Double:

                return false;

            case Object:

                return c.isNull();

            default:

                return true;

        }

    }

    @Override

    protected JavaConstant zapValueForKind(PlatformKind kind) {

        long dead = 0xDEADDEADDEADDEADL;

        switch ((AMD64Kind) kind) {

            case BYTE:

                return JavaConstant.forByte((byte) dead);

            case WORD:

                return JavaConstant.forShort((short) dead);

            case DWORD:

                return JavaConstant.forInt((int) dead);

            case QWORD:

                return JavaConstant.forLong(dead);

            case SINGLE:

                return JavaConstant.forFloat(Float.intBitsToFloat((int) dead));

            default:

                // we don't support vector types, so just zap with double for all of them

                return JavaConstant.forDouble(Double.longBitsToDouble(dead));

        }

    }

    public AMD64AddressValue asAddressValue(Value address) {

        if (address instanceof AMD64AddressValue) {

            return (AMD64AddressValue) address;

        } else {

            if (address instanceof JavaConstant) {

                long displacement = ((JavaConstant) address).asLong();

                if (NumUtil.isInt(displacement)) {

                    return new AMD64AddressValue(address.getValueKind(), Value.ILLEGAL, (int) displacement);

                }

            }

            return new AMD64AddressValue(address.getValueKind(), asAllocatable(address), 0);

        }

    }

    @Override

    public Variable emitAddress(AllocatableValue stackslot) {

        Variable result = newVariable(LIRKind.value(target().arch.getWordKind()));

        append(new StackLeaOp(result, stackslot));

        return result;

    }

    /**

     * The AMD64 backend only uses DWORD and QWORD values in registers because of a performance

     * penalty when accessing WORD or BYTE registers. This function converts small integer kinds to

     * DWORD.

     */

    @Override

    public <K extends ValueKind<K>> K toRegisterKind(K kind) {

        switch ((AMD64Kind) kind.getPlatformKind()) {

            case BYTE:

            case WORD:

                return kind.changeType(AMD64Kind.DWORD);

            default:

                return kind;

        }

    }

    private AllocatableValue asAllocatable(Value value, ValueKind<?> kind) {

        if (value.getValueKind().equals(kind)) {

            return asAllocatable(value);

        } else if (isRegister(value)) {

            return asRegister(value).asValue(kind);

        } else if (isConstantValue(value)) {

            return emitLoadConstant(kind, asConstant(value));

        } else {

            Variable variable = newVariable(kind);

            emitMove(variable, value);

            return variable;

        }

    }

    private Value emitCompareAndSwap(boolean isLogic, LIRKind accessKind, Value address, Value expectedValue, Value newValue, Value trueValue, Value falseValue) {

        ValueKind<?> kind = newValue.getValueKind();

        assert kind.equals(expectedValue.getValueKind());

        AMD64AddressValue addressValue = asAddressValue(address);

        LIRKind integralAccessKind = accessKind;

        Value reinterpretedExpectedValue = expectedValue;

        Value reinterpretedNewValue = newValue;

        boolean isXmm = ((AMD64Kind) accessKind.getPlatformKind()).isXMM();

        if (isXmm) {

            if (accessKind.getPlatformKind().equals(AMD64Kind.SINGLE)) {

                integralAccessKind = LIRKind.fromJavaKind(target().arch, JavaKind.Int);

            } else {

                integralAccessKind = LIRKind.fromJavaKind(target().arch, JavaKind.Long);

            }

            reinterpretedExpectedValue = arithmeticLIRGen.emitReinterpret(integralAccessKind, expectedValue);

            reinterpretedNewValue = arithmeticLIRGen.emitReinterpret(integralAccessKind, newValue);

        }

        AMD64Kind memKind = (AMD64Kind) integralAccessKind.getPlatformKind();

        RegisterValue aRes = AMD64.rax.asValue(integralAccessKind);

        AllocatableValue allocatableNewValue = asAllocatable(reinterpretedNewValue, integralAccessKind);

        emitMove(aRes, reinterpretedExpectedValue);

        append(new CompareAndSwapOp(memKind, aRes, addressValue, aRes, allocatableNewValue));

        if (isLogic) {

            assert trueValue.getValueKind().equals(falseValue.getValueKind());

            Variable result = newVariable(trueValue.getValueKind());

            append(new CondMoveOp(result, Condition.EQ, asAllocatable(trueValue), falseValue));

            return result;

        } else {

            if (isXmm) {

                return arithmeticLIRGen.emitReinterpret(accessKind, aRes);

            } else {

                Variable result = newVariable(kind);

                emitMove(result, aRes);

                return result;

            }

        }

    }

    @Override

    public Variable emitLogicCompareAndSwap(LIRKind accessKind, Value address, Value expectedValue, Value newValue, Value trueValue, Value falseValue) {

        return (Variable) emitCompareAndSwap(true, accessKind, address, expectedValue, newValue, trueValue, falseValue);

    }

    @Override

    public Value emitValueCompareAndSwap(LIRKind accessKind, Value address, Value expectedValue, Value newValue) {

        return emitCompareAndSwap(false, accessKind, address, expectedValue, newValue, null, null);

    }

    public void emitCompareAndSwapBranch(ValueKind<?> kind, AMD64AddressValue address, Value expectedValue, Value newValue, Condition condition, LabelRef trueLabel, LabelRef falseLabel,

                    double trueLabelProbability) {

        assert condition == Condition.EQ || condition == Condition.NE;

        AMD64Kind memKind = (AMD64Kind) kind.getPlatformKind();

        RegisterValue raxValue = AMD64.rax.asValue(kind);

        emitMove(raxValue, expectedValue);

        append(new CompareAndSwapOp(memKind, raxValue, address, raxValue, asAllocatable(newValue)));

        append(new BranchOp(condition, trueLabel, falseLabel, trueLabelProbability));

    }

    @Override

    public Value emitAtomicReadAndAdd(Value address, ValueKind<?> kind, Value delta) {

        Variable result = newVariable(kind);

        AMD64AddressValue addressValue = asAddressValue(address);

        append(new AMD64Move.AtomicReadAndAddOp((AMD64Kind) kind.getPlatformKind(), result, addressValue, asAllocatable(delta)));

        return result;

    }

    @Override

    public Value emitAtomicReadAndWrite(Value address, ValueKind<?> kind, Value newValue) {

        Variable result = newVariable(kind);

        AMD64AddressValue addressValue = asAddressValue(address);

        append(new AMD64Move.AtomicReadAndWriteOp((AMD64Kind) kind.getPlatformKind(), result, addressValue, asAllocatable(newValue)));

        return result;

    }

    @Override

    public void emitNullCheck(Value address, LIRFrameState state) {

        append(new AMD64Move.NullCheckOp(asAddressValue(address), state));

    }

    @Override

    public void emitJump(LabelRef label) {

        assert label != null;

        append(new JumpOp(label));

    }

    @Override

    public void emitCompareBranch(PlatformKind cmpKind, Value left, Value right, Condition cond, boolean unorderedIsTrue, LabelRef trueLabel, LabelRef falseLabel, double trueLabelProbability) {

        Condition finalCondition = emitCompare(cmpKind, left, right, cond);

        if (cmpKind == AMD64Kind.SINGLE || cmpKind == AMD64Kind.DOUBLE) {

            append(new FloatBranchOp(finalCondition, unorderedIsTrue, trueLabel, falseLabel, trueLabelProbability));

        } else {

            append(new BranchOp(finalCondition, trueLabel, falseLabel, trueLabelProbability));

        }

    }

    public void emitCompareBranchMemory(AMD64Kind cmpKind, Value left, AMD64AddressValue right, LIRFrameState state, Condition cond, boolean unorderedIsTrue, LabelRef trueLabel, LabelRef falseLabel,

                    double trueLabelProbability) {

        boolean mirrored = emitCompareMemory(cmpKind, left, right, state);

        Condition finalCondition = mirrored ? cond.mirror() : cond;

        if (cmpKind.isXMM()) {

            append(new FloatBranchOp(finalCondition, unorderedIsTrue, trueLabel, falseLabel, trueLabelProbability));

        } else {

            append(new BranchOp(finalCondition, trueLabel, falseLabel, trueLabelProbability));

        }

    }

    @Override

    public void emitOverflowCheckBranch(LabelRef overflow, LabelRef noOverflow, LIRKind cmpLIRKind, double overflowProbability) {

        append(new BranchOp(ConditionFlag.Overflow, overflow, noOverflow, overflowProbability));

    }

    @Override

    public void emitIntegerTestBranch(Value left, Value right, LabelRef trueDestination, LabelRef falseDestination, double trueDestinationProbability) {

        emitIntegerTest(left, right);

        append(new BranchOp(Condition.EQ, trueDestination, falseDestination, trueDestinationProbability));

    }

    @Override

    public Variable emitConditionalMove(PlatformKind cmpKind, Value left, Value right, Condition cond, boolean unorderedIsTrue, Value trueValue, Value falseValue) {

        boolean isFloatComparison = cmpKind == AMD64Kind.SINGLE || cmpKind == AMD64Kind.DOUBLE;

        Condition finalCondition = cond;

        Value finalTrueValue = trueValue;

        Value finalFalseValue = falseValue;

        if (isFloatComparison) {

            // eliminate the parity check in case of a float comparison

            Value finalLeft = left;

            Value finalRight = right;

            if (unorderedIsTrue != AMD64ControlFlow.trueOnUnordered(finalCondition)) {

                if (unorderedIsTrue == AMD64ControlFlow.trueOnUnordered(finalCondition.mirror())) {

                    finalCondition = finalCondition.mirror();

                    finalLeft = right;

                    finalRight = left;

                } else if (finalCondition != Condition.EQ && finalCondition != Condition.NE) {

                    // negating EQ and NE does not make any sense as we would need to negate

                    // unorderedIsTrue as well (otherwise, we would no longer fulfill the Java

                    // NaN semantics)

                    assert unorderedIsTrue == AMD64ControlFlow.trueOnUnordered(finalCondition.negate());

                    finalCondition = finalCondition.negate();

                    finalTrueValue = falseValue;

                    finalFalseValue = trueValue;

                }

            }

            emitRawCompare(cmpKind, finalLeft, finalRight);

        } else {

            finalCondition = emitCompare(cmpKind, left, right, cond);

        }

        boolean isParityCheckNecessary = isFloatComparison && unorderedIsTrue != AMD64ControlFlow.trueOnUnordered(finalCondition);

        Variable result = newVariable(finalTrueValue.getValueKind());

        if (!isParityCheckNecessary && isIntConstant(finalTrueValue, 1) && isIntConstant(finalFalseValue, 0)) {

            if (isFloatComparison) {

                append(new FloatCondSetOp(result, finalCondition));

            } else {

                append(new CondSetOp(result, finalCondition));

            }

        } else if (!isParityCheckNecessary && isIntConstant(finalTrueValue, 0) && isIntConstant(finalFalseValue, 1)) {

            if (isFloatComparison) {

                if (unorderedIsTrue == AMD64ControlFlow.trueOnUnordered(finalCondition.negate())) {

                    append(new FloatCondSetOp(result, finalCondition.negate()));

                } else {

                    append(new FloatCondSetOp(result, finalCondition));

                    Variable negatedResult = newVariable(result.getValueKind());

                    append(new AMD64Binary.ConstOp(AMD64BinaryArithmetic.XOR, OperandSize.get(result.getPlatformKind()), negatedResult, result, 1));

                    result = negatedResult;

                }

            } else {

                append(new CondSetOp(result, finalCondition.negate()));

            }

        } else if (isFloatComparison) {

            append(new FloatCondMoveOp(result, finalCondition, unorderedIsTrue, load(finalTrueValue), load(finalFalseValue)));

        } else {

            append(new CondMoveOp(result, finalCondition, load(finalTrueValue), loadNonConst(finalFalseValue)));

        }

        return result;

    }

    @Override

    public Variable emitIntegerTestMove(Value left, Value right, Value trueValue, Value falseValue) {

        emitIntegerTest(left, right);

        Variable result = newVariable(trueValue.getValueKind());

        append(new CondMoveOp(result, Condition.EQ, load(trueValue), loadNonConst(falseValue)));

        return result;

    }

    private void emitIntegerTest(Value a, Value b) {

        assert ((AMD64Kind) a.getPlatformKind()).isInteger();

        OperandSize size = a.getPlatformKind() == AMD64Kind.QWORD ? QWORD : DWORD;

        if (isJavaConstant(b) && NumUtil.is32bit(asJavaConstant(b).asLong())) {

            append(new AMD64BinaryConsumer.ConstOp(AMD64MIOp.TEST, size, asAllocatable(a), (int) asJavaConstant(b).asLong()));

        } else if (isJavaConstant(a) && NumUtil.is32bit(asJavaConstant(a).asLong())) {

            append(new AMD64BinaryConsumer.ConstOp(AMD64MIOp.TEST, size, asAllocatable(b), (int) asJavaConstant(a).asLong()));

        } else if (isAllocatableValue(b)) {

            append(new AMD64BinaryConsumer.Op(AMD64RMOp.TEST, size, asAllocatable(b), asAllocatable(a)));

        } else {

            append(new AMD64BinaryConsumer.Op(AMD64RMOp.TEST, size, asAllocatable(a), asAllocatable(b)));

        }

    }

    /**

     * This method emits the compare against memory instruction, and may reorder the operands. It

     * returns true if it did so.

     *

     * @param b the right operand of the comparison

     * @return true if the left and right operands were switched, false otherwise

     */

    private boolean emitCompareMemory(AMD64Kind cmpKind, Value a, AMD64AddressValue b, LIRFrameState state) {

        OperandSize size;

        switch (cmpKind) {

            case BYTE:

                size = OperandSize.BYTE;

                break;

            case WORD:

                size = OperandSize.WORD;

                break;

            case DWORD:

                size = OperandSize.DWORD;

                break;

            case QWORD:

                size = OperandSize.QWORD;

                break;

            case SINGLE:

                append(new AMD64BinaryConsumer.MemoryRMOp(SSEOp.UCOMIS, PS, asAllocatable(a), b, state));

                return false;

            case DOUBLE:

                append(new AMD64BinaryConsumer.MemoryRMOp(SSEOp.UCOMIS, PD, asAllocatable(a), b, state));

                return false;

            default:

                throw GraalError.shouldNotReachHere("unexpected kind: " + cmpKind);

        }

        if (isConstantValue(a)) {

            return emitCompareMemoryConOp(size, asConstantValue(a), b, state);

        } else {

            return emitCompareRegMemoryOp(size, asAllocatable(a), b, state);

        }

    }

    protected boolean emitCompareMemoryConOp(OperandSize size, ConstantValue a, AMD64AddressValue b, LIRFrameState state) {

        if (JavaConstant.isNull(a.getConstant())) {

            append(new AMD64BinaryConsumer.MemoryConstOp(CMP, size, b, 0, state));

            return true;

        } else if (a.getConstant() instanceof VMConstant && size == DWORD) {

            VMConstant vc = (VMConstant) a.getConstant();

            append(new AMD64BinaryConsumer.MemoryVMConstOp(CMP.getMIOpcode(size, false), b, vc, state));

            return true;

        } else {

            long value = a.getJavaConstant().asLong();

            if (NumUtil.is32bit(value)) {

                append(new AMD64BinaryConsumer.MemoryConstOp(CMP, size, b, (int) value, state));

                return true;

            } else {

                return emitCompareRegMemoryOp(size, asAllocatable(a), b, state);

            }

        }

    }

    private boolean emitCompareRegMemoryOp(OperandSize size, AllocatableValue a, AMD64AddressValue b, LIRFrameState state) {

        AMD64RMOp op = CMP.getRMOpcode(size);

        append(new AMD64BinaryConsumer.MemoryRMOp(op, size, a, b, state));

        return false;

    }

    /**

     * This method emits the compare instruction, and may reorder the operands. It returns true if

     * it did so.

     *

     * @param a the left operand of the comparison

     * @param b the right operand of the comparison

     * @param cond the condition of the comparison

     * @return true if the left and right operands were switched, false otherwise

     */

    private Condition emitCompare(PlatformKind cmpKind, Value a, Value b, Condition cond) {

        if (LIRValueUtil.isVariable(b)) {

            emitRawCompare(cmpKind, b, a);

            return cond.mirror();

        } else {

            emitRawCompare(cmpKind, a, b);

            return cond;

        }

    }

    private void emitRawCompare(PlatformKind cmpKind, Value left, Value right) {

        ((AMD64ArithmeticLIRGeneratorTool) arithmeticLIRGen).emitCompareOp((AMD64Kind) cmpKind, load(left), loadNonConst(right));

    }

    @Override

    public void emitMembar(int barriers) {

        int necessaryBarriers = target().arch.requiredBarriers(barriers);

        if (target().isMP && necessaryBarriers != 0) {

            append(new MembarOp(necessaryBarriers));

        }

    }

    public abstract void emitCCall(long address, CallingConvention nativeCallingConvention, Value[] args, int numberOfFloatingPointArguments);