blob: 933e809bf6bd99e34284d5bf6971b2b8244cf843 [file] [log] [blame]
# Copyright (C) 2012-2019 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"
# The CLoop llint backend is initially based on the ARMv7 backend, and
# then further enhanced with a few instructions from the x86 backend to
# support building for X64 targets. Hence, the shape of the generated
# code and the usage convention of registers will look a lot like the
# ARMv7 backend's.
def cloopMapType(type)
case type
when :intptr; ".i()"
when :uintptr; ".u()"
when :int32; ".i32()"
when :uint32; ".u32()"
when :int64; ".i64()"
when :uint64; ".u64()"
when :int8; ".i8()"
when :uint8; ".u8()"
when :int8Ptr; ".i8p()"
when :voidPtr; ".vp()"
when :nativeFunc; ".nativeFunc()"
when :double; ".d()"
when :bitsAsDouble; ".bitsAsDouble()"
when :bitsAsInt64; ".bitsAsInt64()"
when :opcode; ".opcode()"
else;
raise "Unsupported type"
end
end
class SpecialRegister < NoChildren
def clLValue(type=:intptr)
clDump
end
def clDump
@name
end
def clValue(type=:intptr)
@name + cloopMapType(type)
end
end
C_LOOP_SCRATCH_FPR = SpecialRegister.new("d6")
class RegisterID
def clDump
case name
# The cloop is modelled on the ARM implementation. Hence, the a0-a3
# registers are aliases for r0-r3 i.e. t0-t3 in our case.
when "t0", "a0", "r0"
"t0"
when "t1", "a1", "r1"
"t1"
when "t2", "a2"
"t2"
when "t3", "a3"
"t3"
when "t4"
"pc"
when "t5"
"t5"
when "csr0"
"pcBase"
when "csr1"
"tagTypeNumber"
when "csr2"
"tagMask"
when "csr3"
"metadataTable"
when "cfr"
"cfr"
when "lr"
"lr"
when "sp"
"sp"
else
raise "Bad register #{name} for C_LOOP at #{codeOriginString}"
end
end
def clLValue(type=:intptr)
clDump
end
def clValue(type=:intptr)
clDump + cloopMapType(type)
end
end
class FPRegisterID
def clDump
case name
when "ft0", "fr"
"d0"
when "ft1"
"d1"
when "ft2"
"d2"
when "ft3"
"d3"
when "ft4"
"d4"
when "ft5"
"d5"
else
raise "Bad register #{name} for C_LOOP at #{codeOriginString}"
end
end
def clLValue(type=:intptr)
clDump
end
def clValue(type=:intptr)
clDump + cloopMapType(type)
end
end
class Immediate
def clDump
"#{value}"
end
def clLValue(type=:intptr)
raise "Immediate cannot be used as an LValue"
end
def clValue(type=:intptr)
# There is a case of a very large unsigned number (0x8000000000000000)
# which we wish to encode. Unfortunately, the C/C++ compiler
# complains if we express that number as a positive decimal integer.
# Hence, for positive values, we just convert the number into hex form
# to keep the compiler happy.
#
# However, for negative values, the to_s(16) hex conversion method does
# not strip the "-" sign resulting in a meaningless "0x-..." valueStr.
# To workaround this, we simply don't encode negative numbers as hex.
valueStr = (value < 0) ? "#{value}" : "0x#{value.to_s(16)}"
case type
when :int8; "int8_t(#{valueStr})"
when :int32; "int32_t(#{valueStr})"
when :int64; "int64_t(#{valueStr})"
when :intptr; "intptr_t(#{valueStr})"
when :uint8; "uint8_t(#{valueStr})"
when :uint32; "uint32_t(#{valueStr})"
when :uint64; "uint64_t(#{valueStr})"
when :uintptr; "uintptr_t(#{valueStr})"
else
raise "Not implemented immediate of type: #{type}"
end
end
end
class Address
def clDump
"[#{base.clDump}, #{offset.value}]"
end
def clLValue(type=:intptr)
clValue(type)
end
def clValue(type=:intptr)
case type
when :int8; int8MemRef
when :int32; int32MemRef
when :int64; int64MemRef
when :intptr; intptrMemRef
when :uint8; uint8MemRef
when :uint32; uint32MemRef
when :uint64; uint64MemRef
when :uintptr; uintptrMemRef
when :opcode; opcodeMemRef
when :nativeFunc; nativeFuncMemRef
else
raise "Unexpected Address type: #{type}"
end
end
def pointerExpr
if offset.value == 0
"#{base.clValue(:int8Ptr)}"
elsif offset.value > 0
"#{base.clValue(:int8Ptr)} + #{offset.value}"
else
"#{base.clValue(:int8Ptr)} - #{-offset.value}"
end
end
def int8MemRef
"*CAST<int8_t*>(#{pointerExpr})"
end
def int16MemRef
"*CAST<int16_t*>(#{pointerExpr})"
end
def int32MemRef
"*CAST<int32_t*>(#{pointerExpr})"
end
def int64MemRef
"*CAST<int64_t*>(#{pointerExpr})"
end
def intptrMemRef
"*CAST<intptr_t*>(#{pointerExpr})"
end
def uint8MemRef
"*CAST<uint8_t*>(#{pointerExpr})"
end
def uint16MemRef
"*CAST<uint16_t*>(#{pointerExpr})"
end
def uint32MemRef
"*CAST<uint32_t*>(#{pointerExpr})"
end
def uint64MemRef
"*CAST<uint64_t*>(#{pointerExpr})"
end
def uintptrMemRef
"*CAST<uintptr_t*>(#{pointerExpr})"
end
def nativeFuncMemRef
"*CAST<NativeFunction*>(#{pointerExpr})"
end
def opcodeMemRef
"*CAST<Opcode*>(#{pointerExpr})"
end
def dblMemRef
"*CAST<double*>(#{pointerExpr})"
end
end
class BaseIndex
def clDump
"[#{base.clDump}, #{offset.clDump}, #{index.clDump} << #{scaleShift}]"
end
def clLValue(type=:intptr)
clValue(type)
end
def clValue(type=:intptr)
case type
when :int8; int8MemRef
when :int32; int32MemRef
when :int64; int64MemRef
when :intptr; intptrMemRef
when :uint8; uint8MemRef
when :uint32; uint32MemRef
when :uint64; uint64MemRef
when :uintptr; uintptrMemRef
when :opcode; opcodeMemRef
else
raise "Unexpected BaseIndex type: #{type}"
end
end
def pointerExpr
if offset.value == 0
"#{base.clValue(:int8Ptr)} + (#{index.clValue} << #{scaleShift})"
else
"#{base.clValue(:int8Ptr)} + (#{index.clValue} << #{scaleShift}) + #{offset.clValue}"
end
end
def int8MemRef
"*CAST<int8_t*>(#{pointerExpr})"
end
def int16MemRef
"*CAST<int16_t*>(#{pointerExpr})"
end
def int32MemRef
"*CAST<int32_t*>(#{pointerExpr})"
end
def int64MemRef
"*CAST<int64_t*>(#{pointerExpr})"
end
def intptrMemRef
"*CAST<intptr_t*>(#{pointerExpr})"
end
def uint8MemRef
"*CAST<uint8_t*>(#{pointerExpr})"
end
def uint16MemRef
"*CAST<uint16_t*>(#{pointerExpr})"
end
def uint32MemRef
"*CAST<uint32_t*>(#{pointerExpr})"
end
def uint64MemRef
"*CAST<uint64_t*>(#{pointerExpr})"
end
def uintptrMemRef
"*CAST<uintptr_t*>(#{pointerExpr})"
end
def opcodeMemRef
"*CAST<Opcode*>(#{pointerExpr})"
end
def dblMemRef
"*CAST<double*>(#{pointerExpr})"
end
end
class AbsoluteAddress
def clDump
"#{codeOriginString}"
end
def clLValue(type=:intptr)
clValue(type)
end
def clValue
clDump
end
end
class LabelReference
def intptrMemRef
"*CAST<intptr_t*>(&#{cLabel})"
end
def cloopEmitLea(destination, type)
$asm.putc "#{destination.clLValue(:voidPtr)} = CAST<void*>(&#{cLabel});"
end
end
#
# Lea support.
#
class Address
def cloopEmitLea(destination, type)
if destination == base
$asm.putc "#{destination.clLValue(:int8Ptr)} += #{offset.clValue(type)};"
else
$asm.putc "#{destination.clLValue(:int8Ptr)} = #{base.clValue(:int8Ptr)} + #{offset.clValue(type)};"
end
end
end
class BaseIndex
def cloopEmitLea(destination, type)
raise "Malformed BaseIndex, offset should be zero at #{codeOriginString}" unless offset.value == 0
$asm.putc "#{destination.clLValue(:int8Ptr)} = #{base.clValue(:int8Ptr)} + (#{index.clValue} << #{scaleShift});"
end
end
#
# Actual lowering code follows.
#
class Sequence
def getModifiedListC_LOOP
myList = @list
# Verify that we will only see instructions and labels.
myList.each {
| node |
unless node.is_a? Instruction or
node.is_a? Label or
node.is_a? LocalLabel or
node.is_a? Skip
raise "Unexpected #{node.inspect} at #{node.codeOrigin}"
end
}
return myList
end
end
def clOperands(operands)
operands.map{|v| v.clDump}.join(", ")
end
def cloopEmitOperation(operands, type, operator)
raise unless type == :intptr || type == :uintptr || type == :int32 || type == :uint32 || \
type == :int64 || type == :uint64 || type == :double
if operands.size == 3
op1 = operands[0]
op2 = operands[1]
dst = operands[2]
else
raise unless operands.size == 2
op1 = operands[1]
op2 = operands[0]
dst = operands[1]
end
raise unless not dst.is_a? Immediate
if dst.is_a? RegisterID and (type == :int32 or type == :uint32)
truncationHeader = "(uint32_t)("
truncationFooter = ")"
else
truncationHeader = ""
truncationFooter = ""
end
$asm.putc "#{dst.clLValue(type)} = #{truncationHeader}#{op1.clValue(type)} #{operator} #{op2.clValue(type)}#{truncationFooter};"
end
def cloopEmitShiftOperation(operands, type, operator)
raise unless type == :intptr || type == :uintptr || type == :int32 || type == :uint32 || type == :int64 || type == :uint64
if operands.size == 3
op1 = operands[0]
op2 = operands[1]
dst = operands[2]
else
op1 = operands[1]
op2 = operands[0]
dst = operands[1]
end
if dst.is_a? RegisterID and (type == :int32 or type == :uint32)
truncationHeader = "(uint32_t)("
truncationFooter = ")"
else
truncationHeader = ""
truncationFooter = ""
end
shiftMask = "((sizeof(uintptr_t) == 8) ? 0x3f : 0x1f)" if type == :intptr || type == :uintptr
shiftMask = "0x3f" if type == :int64 || type == :uint64
shiftMask = "0x1f" if type == :int32 || type == :uint32
$asm.putc "#{dst.clLValue(type)} = #{truncationHeader}#{operands[1].clValue(type)} #{operator} (#{operands[0].clValue(:intptr)} & #{shiftMask})#{truncationFooter};"
end
def cloopEmitUnaryOperation(operands, type, operator)
raise unless type == :intptr || type == :uintptr || type == :int32 || type == :uint32 || type == :int64 || type == :uint64
raise unless operands.size == 1
raise unless not operands[0].is_a? Immediate
op = operands[0]
dst = operands[0]
if dst.is_a? RegisterID and (type == :int32 or type == :uint32)
truncationHeader = "(uint32_t)("
truncationFooter = ")"
else
truncationHeader = ""
truncationFooter = ""
end
$asm.putc "#{dst.clLValue(type)} = #{truncationHeader}#{operator}#{op.clValue(type)}#{truncationFooter};"
end
def cloopEmitCompareDoubleWithNaNCheckAndBranch(operands, condition)
$asm.putc "if (std::isnan(#{operands[0].clValue(:double)}) || std::isnan(#{operands[1].clValue(:double)})"
$asm.putc " || (#{operands[0].clValue(:double)} #{condition} #{operands[1].clValue(:double)}))"
$asm.putc " goto #{operands[2].cLabel};"
end
def cloopEmitCompareAndSet(operands, type, comparator)
# The result is a boolean. Hence, it doesn't need to be based on the type
# of the arguments being compared.
$asm.putc "#{operands[2].clLValue(type)} = (#{operands[0].clValue(type)} #{comparator} #{operands[1].clValue(type)});"
end
def cloopEmitCompareAndBranch(operands, type, comparator)
$asm.putc "if (#{operands[0].clValue(type)} #{comparator} #{operands[1].clValue(type)})"
$asm.putc " goto #{operands[2].cLabel};"
end
# conditionTest should contain a string that provides a comparator and a RHS
# value e.g. "< 0".
def cloopGenerateConditionExpression(operands, type, conditionTest)
op1 = operands[0].clValue(type)
# The operands must consist of 2 or 3 values.
case operands.size
when 2 # Just test op1 against the conditionTest.
lhs = op1
when 3 # Mask op1 with op2 before testing against the conditionTest.
lhs = "(#{op1} & #{operands[1].clValue(type)})"
else
raise "Expected 2 or 3 operands but got #{operands.size} at #{codeOriginString}"
end
"#{lhs} #{conditionTest}"
end
# conditionTest should contain a string that provides a comparator and a RHS
# value e.g. "< 0".
def cloopEmitTestAndBranchIf(operands, type, conditionTest, branchTarget)
conditionExpr = cloopGenerateConditionExpression(operands, type, conditionTest)
$asm.putc "if (#{conditionExpr})"
$asm.putc " goto #{branchTarget};"
end
def cloopEmitTestSet(operands, type, conditionTest)
# The result is a boolean condition. Hence, the result type is always an
# int. The passed in type is only used for the values being tested in
# the condition test.
conditionExpr = cloopGenerateConditionExpression(operands, type, conditionTest)
$asm.putc "#{operands[-1].clLValue} = (#{conditionExpr});"
end
def cloopEmitOpAndBranch(operands, operator, type, conditionTest)
case type
when :intptr; tempType = "intptr_t"
when :int32; tempType = "int32_t"
when :int64; tempType = "int64_t"
else
raise "Unimplemented type"
end
$asm.putc "{"
$asm.putc " #{tempType} temp = #{operands[1].clValue(type)} #{operator} #{operands[0].clValue(type)};"
$asm.putc " #{operands[1].clLValue(type)} = temp;"
$asm.putc " if (temp #{conditionTest})"
$asm.putc " goto #{operands[2].cLabel};"
$asm.putc "}"
end
def cloopEmitOpAndBranchIfOverflow(operands, operator, type)
case type
when :int32
tempType = "int32_t"
truncationHeader = "(uint32_t)("
truncationFooter = ")"
else
raise "Unimplemented type"
end
$asm.putc "{"
# Emit the overflow test based on the operands and the type:
case operator
when "+"; operation = "add"
when "-"; operation = "sub"
when "*"; operation = "multiply"
else
raise "Unimplemented opeartor"
end
$asm.putc " #{tempType} result;"
$asm.putc " bool success = WTF::ArithmeticOperations<#{tempType}, #{tempType}, #{tempType}>::#{operation}(#{operands[1].clValue(type)}, #{operands[0].clValue(type)}, result);"
$asm.putc " #{operands[1].clLValue(type)} = #{truncationHeader}result#{truncationFooter};"
$asm.putc " if (!success)"
$asm.putc " goto #{operands[2].cLabel};"
$asm.putc "}"
end
# operands: callTarget, currentFrame, currentPC
def cloopEmitCallSlowPath(operands)
$asm.putc "{"
$asm.putc " cloopStack.setCurrentStackPointer(sp.vp());"
$asm.putc " SlowPathReturnType result = #{operands[0].cLabel}(#{operands[1].clDump}, #{operands[2].clDump});"
$asm.putc " decodeResult(result, t0, t1);"
$asm.putc "}"
end
def cloopEmitCallSlowPathVoid(operands)
$asm.putc "cloopStack.setCurrentStackPointer(sp.vp());"
$asm.putc "#{operands[0].cLabel}(#{operands[1].clDump}, #{operands[2].clDump});"
end
class Instruction
def lowerC_LOOP
case opcode
when "addi"
cloopEmitOperation(operands, :int32, "+")
when "addq"
cloopEmitOperation(operands, :int64, "+")
when "addp"
cloopEmitOperation(operands, :intptr, "+")
when "andi"
cloopEmitOperation(operands, :int32, "&")
when "andq"
cloopEmitOperation(operands, :int64, "&")
when "andp"
cloopEmitOperation(operands, :intptr, "&")
when "ori"
cloopEmitOperation(operands, :int32, "|")
when "orq"
cloopEmitOperation(operands, :int64, "|")
when "orp"
cloopEmitOperation(operands, :intptr, "|")
when "xori"
cloopEmitOperation(operands, :int32, "^")
when "xorq"
cloopEmitOperation(operands, :int64, "^")
when "xorp"
cloopEmitOperation(operands, :intptr, "^")
when "lshifti"
cloopEmitShiftOperation(operands, :int32, "<<")
when "lshiftq"
cloopEmitShiftOperation(operands, :int64, "<<")
when "lshiftp"
cloopEmitShiftOperation(operands, :intptr, "<<")
when "rshifti"
cloopEmitShiftOperation(operands, :int32, ">>")
when "rshiftq"
cloopEmitShiftOperation(operands, :int64, ">>")
when "rshiftp"
cloopEmitShiftOperation(operands, :intptr, ">>")
when "urshifti"
cloopEmitShiftOperation(operands, :uint32, ">>")
when "urshiftq"
cloopEmitShiftOperation(operands, :uint64, ">>")
when "urshiftp"
cloopEmitShiftOperation(operands, :uintptr, ">>")
when "muli"
cloopEmitOperation(operands, :int32, "*")
when "mulq"
cloopEmitOperation(operands, :int64, "*")
when "mulp"
cloopEmitOperation(operands, :intptr, "*")
when "subi"
cloopEmitOperation(operands, :int32, "-")
when "subq"
cloopEmitOperation(operands, :int64, "-")
when "subp"
cloopEmitOperation(operands, :intptr, "-")
when "negi"
cloopEmitUnaryOperation(operands, :int32, "-")
when "negq"
cloopEmitUnaryOperation(operands, :int64, "-")
when "negp"
cloopEmitUnaryOperation(operands, :intptr, "-")
when "noti"
cloopEmitUnaryOperation(operands, :int32, "~")
when "loadi"
$asm.putc "#{operands[1].clLValue(:uint32)} = #{operands[0].uint32MemRef};"
# There's no need to call clearHighWord() here because the above will
# automatically take care of 0 extension.
when "loadis"
$asm.putc "#{operands[1].clLValue(:int32)} = #{operands[0].int32MemRef};"
when "loadq"
$asm.putc "#{operands[1].clLValue(:int64)} = #{operands[0].int64MemRef};"
when "loadp"
$asm.putc "#{operands[1].clLValue} = #{operands[0].intptrMemRef};"
when "storei"
$asm.putc "#{operands[1].int32MemRef} = #{operands[0].clValue(:int32)};"
when "storeq"
$asm.putc "#{operands[1].int64MemRef} = #{operands[0].clValue(:int64)};"
when "storep"
$asm.putc "#{operands[1].intptrMemRef} = #{operands[0].clValue(:intptr)};"
when "loadb"
$asm.putc "#{operands[1].clLValue(:intptr)} = #{operands[0].uint8MemRef};"
when "loadbs"
$asm.putc "#{operands[1].clLValue(:intptr)} = (uint32_t)(#{operands[0].int8MemRef});"
when "loadbsp"
$asm.putc "#{operands[1].clLValue(:intptr)} = #{operands[0].int8MemRef};"
when "storeb"
$asm.putc "#{operands[1].uint8MemRef} = #{operands[0].clValue(:int8)};"
when "loadh"
$asm.putc "#{operands[1].clLValue(:intptr)} = #{operands[0].uint16MemRef};"
when "loadhs"
$asm.putc "#{operands[1].clLValue(:intptr)} = (uint32_t)(#{operands[0].int16MemRef});"
when "storeh"
$asm.putc "*#{operands[1].uint16MemRef} = #{operands[0].clValue(:int16)};"
when "loadd"
$asm.putc "#{operands[1].clLValue(:double)} = #{operands[0].dblMemRef};"
when "stored"
$asm.putc "#{operands[1].dblMemRef} = #{operands[0].clValue(:double)};"
when "addd"
cloopEmitOperation(operands, :double, "+")
when "divd"
cloopEmitOperation(operands, :double, "/")
when "subd"
cloopEmitOperation(operands, :double, "-")
when "muld"
cloopEmitOperation(operands, :double, "*")
# Convert an int value to its double equivalent, and store it in a double register.
when "ci2d"
$asm.putc "#{operands[1].clLValue(:double)} = (double)#{operands[0].clValue(:int32)}; // ci2d"
when "bdeq"
cloopEmitCompareAndBranch(operands, :double, "==")
when "bdneq"
cloopEmitCompareAndBranch(operands, :double, "!=")
when "bdgt"
cloopEmitCompareAndBranch(operands, :double, ">");
when "bdgteq"
cloopEmitCompareAndBranch(operands, :double, ">=");
when "bdlt"
cloopEmitCompareAndBranch(operands, :double, "<");
when "bdlteq"
cloopEmitCompareAndBranch(operands, :double, "<=");
when "bdequn"
cloopEmitCompareDoubleWithNaNCheckAndBranch(operands, "==")
when "bdnequn"
cloopEmitCompareDoubleWithNaNCheckAndBranch(operands, "!=")
when "bdgtun"
cloopEmitCompareDoubleWithNaNCheckAndBranch(operands, ">")
when "bdgtequn"
cloopEmitCompareDoubleWithNaNCheckAndBranch(operands, ">=")
when "bdltun"
cloopEmitCompareDoubleWithNaNCheckAndBranch(operands, "<")
when "bdltequn"
cloopEmitCompareDoubleWithNaNCheckAndBranch(operands, "<=")
when "td2i"
$asm.putc "#{operands[1].clLValue(:intptr)} = (uint32_t)(intptr_t)#{operands[0].clValue(:double)}; // td2i"
when "bcd2i" # operands: srcDbl dstInt slowPath
$asm.putc "{ // bcd2i"
$asm.putc " double d = #{operands[0].clValue(:double)};"
$asm.putc " const int32_t asInt32 = int32_t(d);"
$asm.putc " if (asInt32 != d || (!asInt32 && std::signbit(d))) // true for -0.0"
$asm.putc " goto #{operands[2].cLabel};"
$asm.putc " #{operands[1].clLValue} = (uint32_t)asInt32;"
$asm.putc "}"
when "move"
$asm.putc "#{operands[1].clLValue(:intptr)} = #{operands[0].clValue(:intptr)};"
when "sxi2q"
$asm.putc "#{operands[1].clLValue(:int64)} = #{operands[0].clValue(:int32)};"
when "zxi2q"
$asm.putc "#{operands[1].clLValue(:uint64)} = #{operands[0].clValue(:uint32)};"
when "nop"
$asm.putc "// nop"
when "bbeq"
cloopEmitCompareAndBranch(operands, :int8, "==")
when "bieq"
cloopEmitCompareAndBranch(operands, :int32, "==")
when "bqeq"
cloopEmitCompareAndBranch(operands, :int64, "==")
when "bpeq"
cloopEmitCompareAndBranch(operands, :intptr, "==")
when "bbneq"
cloopEmitCompareAndBranch(operands, :int8, "!=")
when "bineq"
cloopEmitCompareAndBranch(operands, :int32, "!=")
when "bqneq"
cloopEmitCompareAndBranch(operands, :int64, "!=")
when "bpneq"
cloopEmitCompareAndBranch(operands, :intptr, "!=")
when "bba"
cloopEmitCompareAndBranch(operands, :uint8, ">")
when "bia"
cloopEmitCompareAndBranch(operands, :uint32, ">")
when "bqa"
cloopEmitCompareAndBranch(operands, :uint64, ">")
when "bpa"
cloopEmitCompareAndBranch(operands, :uintptr, ">")
when "bbaeq"
cloopEmitCompareAndBranch(operands, :uint8, ">=")
when "biaeq"
cloopEmitCompareAndBranch(operands, :uint32, ">=")
when "bqaeq"
cloopEmitCompareAndBranch(operands, :uint64, ">=")
when "bpaeq"
cloopEmitCompareAndBranch(operands, :uintptr, ">=")
when "bbb"
cloopEmitCompareAndBranch(operands, :uint8, "<")
when "bib"
cloopEmitCompareAndBranch(operands, :uint32, "<")
when "bqb"
cloopEmitCompareAndBranch(operands, :uint64, "<")
when "bpb"
cloopEmitCompareAndBranch(operands, :uintptr, "<")
when "bbbeq"
cloopEmitCompareAndBranch(operands, :uint8, "<=")
when "bibeq"
cloopEmitCompareAndBranch(operands, :uint32, "<=")
when "bqbeq"
cloopEmitCompareAndBranch(operands, :uint64, "<=")
when "bpbeq"
cloopEmitCompareAndBranch(operands, :uintptr, "<=")
when "bbgt"
cloopEmitCompareAndBranch(operands, :int8, ">")
when "bigt"
cloopEmitCompareAndBranch(operands, :int32, ">")
when "bqgt"
cloopEmitCompareAndBranch(operands, :int64, ">")
when "bpgt"
cloopEmitCompareAndBranch(operands, :intptr, ">")
when "bbgteq"
cloopEmitCompareAndBranch(operands, :int8, ">=")
when "bigteq"
cloopEmitCompareAndBranch(operands, :int32, ">=")
when "bqgteq"
cloopEmitCompareAndBranch(operands, :int64, ">=")
when "bpgteq"
cloopEmitCompareAndBranch(operands, :intptr, ">=")
when "bblt"
cloopEmitCompareAndBranch(operands, :int8, "<")
when "bilt"
cloopEmitCompareAndBranch(operands, :int32, "<")
when "bqlt"
cloopEmitCompareAndBranch(operands, :int64, "<")
when "bplt"
cloopEmitCompareAndBranch(operands, :intptr, "<")
when "bblteq"
cloopEmitCompareAndBranch(operands, :int8, "<=")
when "bilteq"
cloopEmitCompareAndBranch(operands, :int32, "<=")
when "bqlteq"
cloopEmitCompareAndBranch(operands, :int64, "<=")
when "bplteq"
cloopEmitCompareAndBranch(operands, :intptr, "<=")
when "btbz"
cloopEmitTestAndBranchIf(operands, :int8, "== 0", operands[-1].cLabel)
when "btiz"
cloopEmitTestAndBranchIf(operands, :int32, "== 0", operands[-1].cLabel)
when "btqz"
cloopEmitTestAndBranchIf(operands, :int64, "== 0", operands[-1].cLabel)
when "btpz"
cloopEmitTestAndBranchIf(operands, :intptr, "== 0", operands[-1].cLabel)
when "btbnz"
cloopEmitTestAndBranchIf(operands, :int8, "!= 0", operands[-1].cLabel)
when "btinz"
cloopEmitTestAndBranchIf(operands, :int32, "!= 0", operands[-1].cLabel)
when "btqnz"
cloopEmitTestAndBranchIf(operands, :int64, "!= 0", operands[-1].cLabel)
when "btpnz"
cloopEmitTestAndBranchIf(operands, :intptr, "!= 0", operands[-1].cLabel)
when "btbs"
cloopEmitTestAndBranchIf(operands, :int8, "< 0", operands[-1].cLabel)
when "btis"
cloopEmitTestAndBranchIf(operands, :int32, "< 0", operands[-1].cLabel)
when "btqs"
cloopEmitTestAndBranchIf(operands, :int64, "< 0", operands[-1].cLabel)
when "btps"
cloopEmitTestAndBranchIf(operands, :intptr, "< 0", operands[-1].cLabel)
# For jmp, we do not want to assume that we have COMPUTED_GOTO support.
# Fortunately, the only times we should ever encounter indirect jmps is
# when the jmp target is a CLoop opcode (by design).
#
# Hence, we check if the jmp target is a known label reference. If so,
# we can emit a goto directly. If it is not a known target, then we set
# the target in the opcode, and dispatch to it via whatever dispatch
# mechanism is in used.
when "jmp"
if operands[0].is_a? LocalLabelReference or operands[0].is_a? LabelReference
# Handles jumps local or global labels.
$asm.putc "goto #{operands[0].cLabel};"
else
# Handles jumps to some computed target.
# NOTE: must be an opcode handler or a llint glue helper.
$asm.putc "opcode = #{operands[0].clValue(:opcode)};"
$asm.putc "DISPATCH_OPCODE();"
end
when "call"
$asm.putc "CRASH(); // generic call instruction not supported by design!"
when "break"
$asm.putc "CRASH(); // break instruction not implemented."
when "ret"
$asm.putc "opcode = lr.opcode();"
$asm.putc "DISPATCH_OPCODE();"
when "cbeq"
cloopEmitCompareAndSet(operands, :uint8, "==")
when "cieq"
cloopEmitCompareAndSet(operands, :uint32, "==")
when "cqeq"
cloopEmitCompareAndSet(operands, :uint64, "==")
when "cpeq"
cloopEmitCompareAndSet(operands, :uintptr, "==")
when "cbneq"
cloopEmitCompareAndSet(operands, :uint8, "!=")
when "cineq"
cloopEmitCompareAndSet(operands, :uint32, "!=")
when "cqneq"
cloopEmitCompareAndSet(operands, :uint64, "!=")
when "cpneq"
cloopEmitCompareAndSet(operands, :uintptr, "!=")
when "cba"
cloopEmitCompareAndSet(operands, :uint8, ">")
when "cia"
cloopEmitCompareAndSet(operands, :uint32, ">")
when "cqa"
cloopEmitCompareAndSet(operands, :uint64, ">")
when "cpa"
cloopEmitCompareAndSet(operands, :uintptr, ">")
when "cbaeq"
cloopEmitCompareAndSet(operands, :uint8, ">=")
when "ciaeq"
cloopEmitCompareAndSet(operands, :uint32, ">=")
when "cqaeq"
cloopEmitCompareAndSet(operands, :uint64, ">=")
when "cpaeq"
cloopEmitCompareAndSet(operands, :uintptr, ">=")
when "cbb"
cloopEmitCompareAndSet(operands, :uint8, "<")
when "cib"
cloopEmitCompareAndSet(operands, :uint32, "<")
when "cqb"
cloopEmitCompareAndSet(operands, :uint64, "<")
when "cpb"
cloopEmitCompareAndSet(operands, :uintptr, "<")
when "cbbeq"
cloopEmitCompareAndSet(operands, :uint8, "<=")
when "cibeq"
cloopEmitCompareAndSet(operands, :uint32, "<=")
when "cqbeq"
cloopEmitCompareAndSet(operands, :uint64, "<=")
when "cpbeq"
cloopEmitCompareAndSet(operands, :uintptr, "<=")
when "cbgt"
cloopEmitCompareAndSet(operands, :int8, ">")
when "cigt"
cloopEmitCompareAndSet(operands, :int32, ">")
when "cqgt"
cloopEmitCompareAndSet(operands, :int64, ">")
when "cpgt"
cloopEmitCompareAndSet(operands, :intptr, ">")
when "cbgteq"
cloopEmitCompareAndSet(operands, :int8, ">=")
when "cigteq"
cloopEmitCompareAndSet(operands, :int32, ">=")
when "cqgteq"
cloopEmitCompareAndSet(operands, :int64, ">=")
when "cpgteq"
cloopEmitCompareAndSet(operands, :intptr, ">=")
when "cblt"
cloopEmitCompareAndSet(operands, :int8, "<")
when "cilt"
cloopEmitCompareAndSet(operands, :int32, "<")
when "cqlt"
cloopEmitCompareAndSet(operands, :int64, "<")
when "cplt"
cloopEmitCompareAndSet(operands, :intptr, "<")
when "cblteq"
cloopEmitCompareAndSet(operands, :int8, "<=")
when "cilteq"
cloopEmitCompareAndSet(operands, :int32, "<=")
when "cqlteq"
cloopEmitCompareAndSet(operands, :int64, "<=")
when "cplteq"
cloopEmitCompareAndSet(operands, :intptr, "<=")
when "tbs"
cloopEmitTestSet(operands, :int8, "< 0")
when "tis"
cloopEmitTestSet(operands, :int32, "< 0")
when "tqs"
cloopEmitTestSet(operands, :int64, "< 0")
when "tps"
cloopEmitTestSet(operands, :intptr, "< 0")
when "tbz"
cloopEmitTestSet(operands, :int8, "== 0")
when "tiz"
cloopEmitTestSet(operands, :int32, "== 0")
when "tqz"
cloopEmitTestSet(operands, :int64, "== 0")
when "tpz"
cloopEmitTestSet(operands, :intptr, "== 0")
when "tbnz"
cloopEmitTestSet(operands, :int8, "!= 0")
when "tinz"
cloopEmitTestSet(operands, :int32, "!= 0")
when "tqnz"
cloopEmitTestSet(operands, :int64, "!= 0")
when "tpnz"
cloopEmitTestSet(operands, :intptr, "!= 0")
# 64-bit instruction: cdqi (based on X64)
# Sign extends the lower 32 bits of t0, but put the sign extension into
# the lower 32 bits of t1. Leave the upper 32 bits of t0 and t1 unchanged.
when "cdqi"
$asm.putc "{ // cdqi"
$asm.putc " int64_t temp = t0.i32(); // sign extend the low 32bit"
$asm.putc " t0 = (uint32_t)temp; // low word"
$asm.putc " t1 = (uint32_t)(temp >> 32); // high word"
$asm.putc "}"
# 64-bit instruction: idivi op1 (based on X64)
# Divide a 64-bit integer numerator by the specified denominator.
# The numerator is specified in t0 and t1 as follows:
# 1. low 32 bits of the numerator is in the low 32 bits of t0.
# 2. high 32 bits of the numerator is in the low 32 bits of t1.
#
# The resultant quotient is a signed 32-bit int, and is to be stored
# in the lower 32 bits of t0.
# The resultant remainder is a signed 32-bit int, and is to be stored
# in the lower 32 bits of t1.
when "idivi"
# Divide t1,t0 (EDX,EAX) by the specified arg, and store the remainder in t1,
# and quotient in t0:
$asm.putc "{ // idivi"
$asm.putc " int64_t dividend = (int64_t(t1.u32()) << 32) | t0.u32();"
$asm.putc " int64_t divisor = #{operands[0].clValue(:intptr)};"
$asm.putc " t1 = (uint32_t)(dividend % divisor); // remainder"
$asm.putc " t0 = (uint32_t)(dividend / divisor); // quotient"
$asm.putc "}"
# 32-bit instruction: fii2d int32LoOp int32HiOp dblOp (based on ARMv7)
# Decode 2 32-bit ints (low and high) into a 64-bit double.
when "fii2d"
$asm.putc "#{operands[2].clLValue(:double)} = ints2Double(#{operands[0].clValue(:uint32)}, #{operands[1].clValue(:uint32)}); // fii2d"
# 32-bit instruction: f2dii dblOp int32LoOp int32HiOp (based on ARMv7)
# Encode a 64-bit double into 2 32-bit ints (low and high).
when "fd2ii"
$asm.putc "double2Ints(#{operands[0].clValue(:double)}, #{operands[1].clDump}, #{operands[2].clDump}); // fd2ii"
# 64-bit instruction: fq2d int64Op dblOp (based on X64)
# Copy a bit-encoded double in a 64-bit int register to a double register.
when "fq2d"
$asm.putc "#{operands[1].clLValue(:double)} = #{operands[0].clValue(:bitsAsDouble)}; // fq2d"
# 64-bit instruction: fd2q dblOp int64Op (based on X64 instruction set)
# Copy a double as a bit-encoded double into a 64-bit int register.
when "fd2q"
$asm.putc "#{operands[1].clLValue(:int64)} = #{operands[0].clValue(:bitsAsInt64)}; // fd2q"
when "leai"
operands[0].cloopEmitLea(operands[1], :int32)
when "leap"
operands[0].cloopEmitLea(operands[1], :intptr)
when "baddio"
cloopEmitOpAndBranchIfOverflow(operands, "+", :int32)
when "bsubio"
cloopEmitOpAndBranchIfOverflow(operands, "-", :int32)
when "bmulio"
cloopEmitOpAndBranchIfOverflow(operands, "*", :int32)
when "baddis"
cloopEmitOpAndBranch(operands, "+", :int32, "< 0")
when "baddiz"
cloopEmitOpAndBranch(operands, "+", :int32, "== 0")
when "baddinz"
cloopEmitOpAndBranch(operands, "+", :int32, "!= 0")
when "baddqs"
cloopEmitOpAndBranch(operands, "+", :int64, "< 0")
when "baddqz"
cloopEmitOpAndBranch(operands, "+", :int64, "== 0")
when "baddqnz"
cloopEmitOpAndBranch(operands, "+", :int64, "!= 0")
when "baddps"
cloopEmitOpAndBranch(operands, "+", :intptr, "< 0")
when "baddpz"
cloopEmitOpAndBranch(operands, "+", :intptr, "== 0")
when "baddpnz"
cloopEmitOpAndBranch(operands, "+", :intptr, "!= 0")
when "bsubis"
cloopEmitOpAndBranch(operands, "-", :int32, "< 0")
when "bsubiz"
cloopEmitOpAndBranch(operands, "-", :int32, "== 0")
when "bsubinz"
cloopEmitOpAndBranch(operands, "-", :int32, "!= 0")
when "borris"
cloopEmitOpAndBranch(operands, "|", :int32, "< 0")
when "borriz"
cloopEmitOpAndBranch(operands, "|", :int32, "== 0")
when "borrinz"
cloopEmitOpAndBranch(operands, "|", :int32, "!= 0")
when "memfence"
when "push"
operands.each {
| op |
$asm.putc "PUSH(#{op.clDump});"
}
when "pop"
operands.each {
| op |
$asm.putc "POP(#{op.clDump});"
}
# A convenience and compact call to crash because we don't want to use
# the generic llint crash mechanism which relies on the availability
# of the call instruction (which cannot be implemented in a generic
# way, and can be abused if we made it just work for this special case).
# Using a special cloopCrash instruction is cleaner.
when "cloopCrash"
$asm.putc "CRASH();"
# We can't rely on the llint JS call mechanism which actually makes
# use of the call instruction. Instead, we just implement JS calls
# as an opcode dispatch.
when "cloopCallJSFunction"
uid = $asm.newUID
$asm.putc "lr = getOpcode(llint_cloop_did_return_from_js_#{uid});"
$asm.putc "opcode = #{operands[0].clValue(:opcode)};"
$asm.putc "DISPATCH_OPCODE();"
$asm.putsLabel("llint_cloop_did_return_from_js_#{uid}", false)
# We can't do generic function calls with an arbitrary set of args, but
# fortunately we don't have to here. All native function calls always
# have a fixed prototype of 1 args: the passed ExecState.
when "cloopCallNative"
$asm.putc "cloopStack.setCurrentStackPointer(sp.vp());"
$asm.putc "nativeFunc = #{operands[0].clValue(:nativeFunc)};"
$asm.putc "functionReturnValue = JSValue::decode(nativeFunc(t0.execState()));"
$asm.putc "#if USE(JSVALUE32_64)"
$asm.putc " t1 = functionReturnValue.tag();"
$asm.putc " t0 = functionReturnValue.payload();"
$asm.putc "#else // USE_JSVALUE64)"
$asm.putc " t0 = JSValue::encode(functionReturnValue);"
$asm.putc "#endif // USE_JSVALUE64)"
# We can't do generic function calls with an arbitrary set of args, but
# fortunately we don't have to here. All slow path function calls always
# have a fixed prototype too. See cloopEmitCallSlowPath() for details.
when "cloopCallSlowPath"
cloopEmitCallSlowPath(operands)
when "cloopCallSlowPathVoid"
cloopEmitCallSlowPathVoid(operands)
# For debugging only. This is used to insert instrumentation into the
# generated LLIntAssembly.h during llint development only. Do not use
# for production code.
when "cloopDo"
$asm.putc "#{annotation}"
else
lowerDefault
end
end
def recordMetaDataC_LOOP
$asm.codeOrigin codeOriginString if $enableCodeOriginComments
$asm.annotation annotation if $enableInstrAnnotations && (opcode != "cloopDo")
$asm.debugAnnotation codeOrigin.debugDirective if $enableDebugAnnotations
end
end