# Copyright (C) 2011-2020 Apple Inc. All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
# 1. Redistributions of source code must retain the above copyright
#    notice, this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
#    notice, this list of conditions and the following disclaimer in the
#    documentation and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
# BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
# THE POSSIBILITY OF SUCH DAMAGE.

require 'config'
require 'ast'
require 'opt'

# This file contains utilities that are useful for implementing a backend
# for RISC-like processors (ARM, MIPS, etc).

#
# Lowering of simple branch ops. For example:
#
# baddiz foo, bar, baz
#
# will become:
#
# addi foo, bar
# bz baz
#

def riscLowerSimpleBranchOps(list)
    newList = []
    list.each {
        | node |
        if node.is_a? Instruction
            annotation = node.annotation
            case node.opcode
            when /^b(addi|subi|ori|addp)/
                op = $1
                branch = "b" + $~.post_match
                
                case op
                when "addi"
                    op = "addis"
                when "addp"
                    op = "addps"
                when "subi"
                    op = "subis"
                when "ori"
                    op = "oris"
                end
                
                newList << Instruction.new(node.codeOrigin, op, node.operands[0..-2], annotation)
                newList << Instruction.new(node.codeOrigin, branch, [node.operands[-1]])
            when 'bmulis', 'bmulz', 'bmulnz'
                condition = $~.post_match
                newList << Instruction.new(node.codeOrigin, "muli", node.operands[0..-2], annotation)
                newList << Instruction.new(node.codeOrigin, "bti" + condition, [node.operands[-2], node.operands[-1]])
            else
                newList << node
            end
        else
            newList << node
        end
    }
    newList
end

#
# Lowing of complex branch ops. For example:
#
# bmulio foo, bar, baz
#
# becomes:
#
# smulli foo, bar, bar, tmp1
# rshifti bar, 31, tmp2
# bineq tmp1, tmp2, baz
#

def riscLowerHardBranchOps(list)
    newList = []
    list.each {
        | node |
        if node.is_a? Instruction and node.opcode == "bmulio"
            tmp1 = Tmp.new(node.codeOrigin, :gpr)
            tmp2 = Tmp.new(node.codeOrigin, :gpr)
            newList << Instruction.new(node.codeOrigin, "smulli", [node.operands[0], node.operands[1], node.operands[1], tmp1], node.annotation)
            newList << Instruction.new(node.codeOrigin, "rshifti", [node.operands[-2], Immediate.new(node.codeOrigin, 31), tmp2])
            newList << Instruction.new(node.codeOrigin, "bineq", [tmp1, tmp2, node.operands[-1]])
        else
            newList << node
        end
    }
    newList
end

#
# Lowering of shift ops. For example:
#
# lshifti foo, bar
#
# will become:
#
# andi foo, 31, tmp
# lshifti tmp, bar
#

def riscSanitizeShift(operand, list)
    return operand if operand.immediate?
    
    tmp = Tmp.new(operand.codeOrigin, :gpr)
    list << Instruction.new(operand.codeOrigin, "andi", [operand, Immediate.new(operand.codeOrigin, 31), tmp])
    tmp
end

def riscLowerShiftOps(list)
    newList = []
    list.each {
        | node |
        if node.is_a? Instruction
            case node.opcode
            when "lshifti", "rshifti", "urshifti", "lshiftp", "rshiftp", "urshiftp"
                if node.operands.size == 2
                    newList << Instruction.new(node.codeOrigin, node.opcode, [riscSanitizeShift(node.operands[0], newList), node.operands[1]], node.annotation)
                else
                    newList << Instruction.new(node.codeOrigin, node.opcode, [node.operands[0], riscSanitizeShift(node.operands[1], newList), node.operands[2]], node.annotation)
                    raise "Wrong number of operands for shift at #{node.codeOriginString}" unless node.operands.size == 3
                end
            else
                newList << node
            end
        else
            newList << node
        end
    }
    newList
end

#
# Lowering of malformed addresses. For example:
#
# loadp 10000[foo], bar
#
# will become:
#
# move 10000, tmp
# addp foo, tmp
# loadp 0[tmp], bar
#
# Note that you use this lowering phase by passing it a block that returns true
# if you don't want to lower the address, or false if you do. For example to get
# the effect of the example above, the block would have to say something like:
#
# riscLowerMalformedAddresses(thingy) {
#     | node, address |
#     if address.is_a? Address
#         address.offset.value > 1000
#     else
#         true # don't lower anything else, in this example
#     end
# }
#
# See arm.rb for a different example, in which we lower all BaseIndex addresses
# that have non-zero offset, all Address addresses that have large offsets, and
# all other addresses (like AbsoluteAddress).
#

class Node
    def riscLowerMalformedAddressesRecurse(list, topLevelNode, &block)
        mapChildren {
            | subNode |
            subNode.riscLowerMalformedAddressesRecurse(list, topLevelNode, &block)
        }
    end
end

class Address
    def riscLowerMalformedAddressesRecurse(list, node, &block)
        return self if yield node, self

        tmp = Tmp.new(codeOrigin, :gpr)
        list << Instruction.new(codeOrigin, "move", [offset, tmp])
        list << Instruction.new(codeOrigin, "addp", [base, tmp])
        Address.new(codeOrigin, tmp, Immediate.new(codeOrigin, 0))
    end
end

class BaseIndex
    def riscLowerMalformedAddressesRecurse(list, node, &block)
        return self if yield node, self
        
        tmp = Tmp.new(codeOrigin, :gpr)
        list << Instruction.new(codeOrigin, "leap", [BaseIndex.new(codeOrigin, base, index, scale, Immediate.new(codeOrigin, 0)), tmp])
        Address.new(codeOrigin, tmp, offset).riscLowerMalformedAddressesRecurse(list, node, &block)
    end
end

class AbsoluteAddress
    def riscLowerMalformedAddressesRecurse(list, node, &block)
        return self if yield node, self
        
        tmp = Tmp.new(codeOrigin, :gpr)
        list << Instruction.new(codeOrigin, "move", [address, tmp])
        Address.new(codeOrigin, tmp, Immediate.new(codeOrigin, 0))
    end
end

def riscLowerMalformedAddresses(list, &block)
    newList = []
    list.each {
        | node |
        newList << node.riscLowerMalformedAddressesRecurse(newList, node, &block)
    }
    newList
end

#
# Lowering of malformed addresses in double loads and stores. For example:
#
# loadd [foo, bar, 8], baz
#
# becomes:
#
# leap [foo, bar, 8], tmp
# loadd [tmp], baz
#

class Node
    def riscDoubleAddress(list)
        self
    end
end

class BaseIndex
    def riscDoubleAddress(list)
        tmp = Tmp.new(codeOrigin, :gpr)
        list << Instruction.new(codeOrigin, "leap", [self, tmp])
        Address.new(codeOrigin, tmp, Immediate.new(codeOrigin, 0))
    end
end

def riscLowerMalformedAddressesDouble(list)
    newList = []
    list.each {
        | node |
        if node.is_a? Instruction
            case node.opcode
            when "loadd"
                newList << Instruction.new(node.codeOrigin, "loadd", [node.operands[0].riscDoubleAddress(newList), node.operands[1]], node.annotation)
            when "loadv"
                newList << Instruction.new(node.codeOrigin, "loadv", [node.operands[0].riscDoubleAddress(newList), node.operands[1]], node.annotation)
            when "loadf"
                newList << Instruction.new(node.codeOrigin, "loadf", [node.operands[0].riscDoubleAddress(newList), node.operands[1]], node.annotation)
            when "stored"
                newList << Instruction.new(node.codeOrigin, "stored", [node.operands[0], node.operands[1].riscDoubleAddress(newList)], node.annotation)
            when "storef"
                newList << Instruction.new(node.codeOrigin, "storef", [node.operands[0], node.operands[1].riscDoubleAddress(newList)], node.annotation)
            when "storev"
                newList << Instruction.new(node.codeOrigin, "storev", [node.operands[0], node.operands[1].riscDoubleAddress(newList)], node.annotation)
            else
                newList << node
            end
        else
            newList << node
        end
    }
    newList
end

#
# Lowering of misplaced immediates for opcodes in opcodeList. For example, if storei is in opcodeList:
#
# storei 0, [foo]
#
# will become:
#
# move 0, tmp
# storei tmp, [foo]
#

def riscLowerMisplacedImmediates(list, opcodeList)
    newList = []
    list.each {
        | node |
        if node.is_a? Instruction
            if opcodeList.include? node.opcode
                operands = node.operands
                newOperands = []
                operands.each {
                    | operand |
                    if operand.is_a? Immediate
                        tmp = Tmp.new(operand.codeOrigin, :gpr)
                        newList << Instruction.new(operand.codeOrigin, "move", [operand, tmp])
                        newOperands << tmp
                    else
                        newOperands << operand
                    end
                }
                newList << Instruction.new(node.codeOrigin, node.opcode, newOperands, node.annotation)
            else
                newList << node
            end
        else
            newList << node
        end
    }
    newList
end

#
# Lowering of malformed immediates except when used in a "move" instruction.
# For example:
#
# addp 642641, foo
#
# will become:
#
# move 642641, tmp
# addp tmp, foo
#

class Node
    def riscLowerMalformedImmediatesRecurse(list, validImmediates)
        mapChildren {
            | node |
            node.riscLowerMalformedImmediatesRecurse(list, validImmediates)
        }
    end
end

class Address
    def riscLowerMalformedImmediatesRecurse(list, validImmediates)
        self
    end
end

class BaseIndex
    def riscLowerMalformedImmediatesRecurse(list, validImmediates)
        self
    end
end

class AbsoluteAddress
    def riscLowerMalformedImmediatesRecurse(list, validImmediates)
        self
    end
end

class Immediate
    def riscLowerMalformedImmediatesRecurse(list, validImmediates)
        unless validImmediates.include? value
            tmp = Tmp.new(codeOrigin, :gpr)
            list << Instruction.new(codeOrigin, "move", [self, tmp])
            tmp
        else
            self
        end
    end
end

def riscLowerMalformedImmediates(list, validImmediates, validLogicalImmediates)
    newList = []
    list.each {
        | node |
        if node.is_a? Instruction
            annotation = node.annotation
            case node.opcode
            when "move", "moveii"
                newList << node
            when "addi", "addp", "addq", "addis", "subi", "subp", "subq", "subis"
                if node.operands[0].is_a? Immediate and
                        (not validImmediates.include? node.operands[0].value) and
                        validImmediates.include? -node.operands[0].value and
                        node.operands.size == 2
                    if node.opcode =~ /add/
                        newOpcode = "sub" + $~.post_match
                    else
                        newOpcode = "add" + $~.post_match
                    end
                    newList << Instruction.new(node.codeOrigin, newOpcode,
                                               [Immediate.new(node.codeOrigin, -node.operands[0].value)] + node.operands[1..-1],
                                               annotation)
                else
                    newList << node.riscLowerMalformedImmediatesRecurse(newList, validImmediates)
                end
            when "muli", "mulp", "mulq"
                if node.operands[0].is_a? Immediate
                    tmp = Tmp.new(codeOrigin, :gpr)
                    newList << Instruction.new(node.codeOrigin, "move", [node.operands[0], tmp], annotation)
                    newList << Instruction.new(node.codeOrigin, node.opcode, [tmp] + node.operands[1..-1])
                else
                    newList << node.riscLowerMalformedImmediatesRecurse(newList, validImmediates)
                end
            when "ori", "orh", "orp", "oris", "xori", "xorp", "andi", "andp"
                newList << node.riscLowerMalformedImmediatesRecurse(newList, validLogicalImmediates)
            else
                newList << node.riscLowerMalformedImmediatesRecurse(newList, validImmediates)
            end
        else
            newList << node
        end
    }
    newList
end

#
# Lowering of misplaced addresses. For example:
#
# addi foo, [bar]
#
# will become:
#
# loadi [bar], tmp
# addi foo, tmp
# storei tmp, [bar]
#
# Another example:
#
# addi [foo], bar
#
# will become:
#
# loadi [foo], tmp
# addi tmp, bar
#

def riscLowerOperandToRegister(insn, preList, postList, operandIndex, suffix, needStore)
    operand = insn.operands[operandIndex]
    return operand unless operand.address?

    tmp = Tmp.new(insn.codeOrigin, if suffix == "d" then :fpr else :gpr end)
    preList << Instruction.new(insn.codeOrigin, "load" + suffix, [operand, tmp])
    if needStore
        postList << Instruction.new(insn.codeOrigin, "store" + suffix, [tmp, operand])
    end
    tmp
end

def riscLowerOperandsToRegisters(insn, preList, postList, suffix)
    newOperands = []
    insn.operands.each_with_index {
        | operand, index |
        newOperands << riscLowerOperandToRegister(insn, preList, postList, index, suffix, index == insn.operands.size - 1)
    }
    newOperands
end

class Instruction
    def riscCloneWithOperandLowered(preList, postList, operandIndex, suffix, needStore)
        operand = riscLowerOperandToRegister(self, preList, postList, operandIndex, suffix, needStore)
        cloneWithNewOperands([operand])
    end
    def riscCloneWithOperandsLowered(preList, postList, suffix)
        operands = riscLowerOperandsToRegisters(self, preList, postList, suffix)
        cloneWithNewOperands(operands)
    end
end

def riscLowerMisplacedAddresses(list)
    newList = []
    hasBackendSpecificLowering = Instruction.respond_to? "lowerMisplacedAddresses#{$activeBackend}"
    list.each {
        | node |
        if node.is_a? Instruction
            if hasBackendSpecificLowering
                wasHandled, newList = Instruction.send("lowerMisplacedAddresses#{$activeBackend}", node, newList)
                next if wasHandled
            end

            postInstructions = []
            annotation = node.annotation
            case node.opcode
            when "addi", "addis", "andi", "lshifti", "muli", "negi", "noti", "ori", "oris",
                "rshifti", "urshifti", "subi", "subis", "xori", /^bi/, /^bti/, /^ci/, /^ti/
                newList << node.riscCloneWithOperandsLowered(newList, postInstructions, "i")
            when "orh"
                newList << node.riscCloneWithOperandsLowered(newList, postInstructions, "h")
            when "addp", "andp", "lshiftp", "mulp", "negp", "orp", "rshiftp", "urshiftp",
                "subp", "xorp", /^bp/, /^btp/, /^cp/
                newList << node.riscCloneWithOperandsLowered(newList, postInstructions, "p")
            when "addq", "andq", "lshiftq", "mulq", "negq", "orq", "rshiftq", "urshiftq",
                "subq", "xorq", /^bq/, /^btq/, /^cq/
                newList << node.riscCloneWithOperandsLowered(newList, postInstructions, "q")
            when "bbeq", "bbneq", "bba", "bbaeq", "bbb", "bbbeq", "btbz", "btbnz", "tbz", "tbnz",
                "cbeq", "cbneq", "cba", "cbaeq", "cbb", "cbbeq"
                newList << node.riscCloneWithOperandsLowered(newList, postInstructions, "b")
            when "bbgt", "bbgteq", "bblt", "bblteq", "btbs", "tbs", "cbgt", "cbgteq", "cblt", "cblteq"
                newList << node.riscCloneWithOperandsLowered(newList, postInstructions, "bs")
            when "addd", "divd", "subd", "muld", "sqrtd", /^bd/
                newList << node.riscCloneWithOperandsLowered(newList, postInstructions, "d")
            when "jmp", "call"
                newList << node.riscCloneWithOperandLowered(newList, postInstructions, 0, "p", false)
            else
                newList << node
            end
            newList += postInstructions
        else
            newList << node
        end
    }
    newList
end

#
# Lowering of register reuse in compare instructions. For example:
#
# cieq t0, t1, t0
#
# will become:
#
# mov tmp, t0
# cieq tmp, t1, t0
#

def riscLowerRegisterReuse(list)
    newList = []
    list.each {
        | node |
        if node.is_a? Instruction
            annotation = node.annotation
            case node.opcode
            when "cieq", "cineq", "cia", "ciaeq", "cib", "cibeq", "cigt", "cigteq", "cilt", "cilteq",
                "cpeq", "cpneq", "cpa", "cpaeq", "cpb", "cpbeq", "cpgt", "cpgteq", "cplt", "cplteq",
                "tis", "tiz", "tinz", "tbs", "tbz", "tbnz", "tps", "tpz", "tpnz", "cbeq", "cbneq",
                "cba", "cbaeq", "cbb", "cbbeq", "cbgt", "cbgteq", "cblt", "cblteq"
                if node.operands.size == 2
                    if node.operands[0] == node.operands[1]
                        tmp = Tmp.new(node.codeOrigin, :gpr)
                        newList << Instruction.new(node.codeOrigin, "move", [node.operands[0], tmp], annotation)
                        newList << Instruction.new(node.codeOrigin, node.opcode, [tmp, node.operands[1]])
                    else
                        newList << node
                    end
                else
                    raise "Wrong number of arguments at #{node.codeOriginString}" unless node.operands.size == 3
                    if node.operands[0] == node.operands[2]
                        tmp = Tmp.new(node.codeOrigin, :gpr)
                        newList << Instruction.new(node.codeOrigin, "move", [node.operands[0], tmp], annotation)
                        newList << Instruction.new(node.codeOrigin, node.opcode, [tmp, node.operands[1], node.operands[2]])
                    elsif node.operands[1] == node.operands[2]
                        tmp = Tmp.new(node.codeOrigin, :gpr)
                        newList << Instruction.new(node.codeOrigin, "move", [node.operands[1], tmp], annotation)
                        newList << Instruction.new(node.codeOrigin, node.opcode, [node.operands[0], tmp, node.operands[2]])
                    else
                        newList << node
                    end
                end
            else
                newList << node
            end
        else
            newList << node
        end
    }
    newList
end

#
# Lowering of the not instruction. The following:
#
# noti t0
#
# becomes:
#
# xori -1, t0
#

def riscLowerNot(list)
    newList = []
    list.each {
        | node |
        if node.is_a? Instruction
            case node.opcode
            when "noti", "notp"
                raise "Wrong number of operands at #{node.codeOriginString}" unless node.operands.size == 1
                suffix = node.opcode[-1..-1]
                newList << Instruction.new(node.codeOrigin, "xor" + suffix,
                                           [Immediate.new(node.codeOrigin, -1), node.operands[0]])
            else
                newList << node
            end
        else
            newList << node
        end
    }
    return newList
end

#
# Lowing of complex branch ops on 64-bit. For example:
#
# bmulio foo, bar, baz
#
# becomes:
#
# smulli foo, bar, bar
# rshiftp bar, 32, tmp1
# rshifti bar, 31, tmp2
# zxi2p bar, bar 
# bineq tmp1, tmp2, baz
#

def riscLowerHardBranchOps64(list)
    newList = []
    list.each {
        | node |
        if node.is_a? Instruction and node.opcode == "bmulio"
            tmp1 = Tmp.new(node.codeOrigin, :gpr)
            tmp2 = Tmp.new(node.codeOrigin, :gpr)
            newList << Instruction.new(node.codeOrigin, "smulli", [node.operands[0], node.operands[1], node.operands[1]])
            newList << Instruction.new(node.codeOrigin, "rshiftp", [node.operands[1], Immediate.new(node.codeOrigin, 32), tmp1])
            newList << Instruction.new(node.codeOrigin, "rshifti", [node.operands[1], Immediate.new(node.codeOrigin, 31), tmp2])
            newList << Instruction.new(node.codeOrigin, "zxi2p", [node.operands[1], node.operands[1]])
            newList << Instruction.new(node.codeOrigin, "bineq", [tmp1, tmp2, node.operands[2]])
        else
            newList << node
        end
    }
    newList
end

#
# Lowering of test instructions. For example:
#
# btiz t0, t1, .foo
#
# becomes:
#
# andi t0, t1, tmp
# bieq tmp, 0, .foo
#
# and another example:
#
# tiz t0, t1, t2
#
# becomes:
#
# andi t0, t1, tmp
# cieq tmp, 0, t2
#

def riscLowerTest(list)
    def emit(newList, andOpcode, branchOpcode, node)
        if node.operands.size == 2
            newList << Instruction.new(node.codeOrigin, branchOpcode, [node.operands[0], Immediate.new(node.codeOrigin, 0), node.operands[1]])
            return
        end

        raise "Incorrect number of operands at #{codeOriginString}" unless node.operands.size == 3

        if node.operands[0].immediate? and node.operands[0].value == -1
            newList << Instruction.new(node.codeOrigin, branchOpcode, [node.operands[1], Immediate.new(node.codeOrigin, 0), node.operands[2]])
            return
        end

        if node.operands[1].immediate? and node.operands[1].value == -1
            newList << Instruction.new(node.codeOrigin, branchOpcode, [node.operands[0], Immediate.new(node.codeOrigin, 0), node.operands[2]])
            return
        end
        
        tmp = Tmp.new(node.codeOrigin, :gpr)
        newList << Instruction.new(node.codeOrigin, andOpcode, [node.operands[0], node.operands[1], tmp])
        newList << Instruction.new(node.codeOrigin, branchOpcode, [tmp, Immediate.new(node.codeOrigin, 0), node.operands[2]])
    end

    newList = []
    list.each {
        | node |
        if node.is_a? Instruction
            case node.opcode
            when "btis"
                emit(newList, "andi", "bilt", node)
            when "btiz"
                emit(newList, "andi", "bieq", node)
            when "btinz"
                emit(newList, "andi", "bineq", node)
            when "btps"
                emit(newList, "andp", "bplt", node)
            when "btpz"
                emit(newList, "andp", "bpeq", node)
            when "btpnz"
                emit(newList, "andp", "bpneq", node)
            when "btqs"
                emit(newList, "andq", "bqlt", node)
            when "btqz"
                emit(newList, "andq", "bqeq", node)
            when "btqnz"
                emit(newList, "andq", "bqneq", node)
            when "btbs"
                emit(newList, "andi", "bblt", node)
            when "btbz"
                emit(newList, "andi", "bbeq", node)
            when "btbnz"
                emit(newList, "andi", "bbneq", node)
            when "tis"
                emit(newList, "andi", "cilt", node)
            when "tiz"
                emit(newList, "andi", "cieq", node)
            when "tinz"
                emit(newList, "andi", "cineq", node)
            when "tps"
                emit(newList, "andp", "cplt", node)
            when "tpz"
                emit(newList, "andp", "cpeq", node)
            when "tpnz"
                emit(newList, "andp", "cpneq", node)
            when "tqs"
                emit(newList, "andq", "cqlt", node)
            when "tqz"
                emit(newList, "andq", "cqeq", node)
            when "tqnz"
                emit(newList, "andq", "cqneq", node)
            when "tbs"
                emit(newList, "andi", "cblt", node)
            when "tbz"
                emit(newList, "andi", "cbeq", node)
            when "tbnz"
                emit(newList, "andi", "cbneq", node)
            else
                newList << node
            end
        else
            newList << node
        end
    }
    return newList
end

def riscDropTags(list)
    list.collect {
        |node|
        ret = node
        if node.is_a?(Instruction)
            case node.opcode
            when "jmp", "call"
                if node.operands.size > 1
                    # Delete the extra pointer tagging arguments, otherwise
                    # riscLowerMalformedImmediatesRecurse will pointlessly load
                    # them in a register.
                    ret = Instruction.new(node.codeOrigin, node.opcode, [node.operands[0]])
                end
            end
        end
        ret
    }
end