mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-10-22 12:33:33 +02:00
4d43f941c8
This changes locals from being declared by the emitLocal hook in WebAssemblyTargetStreamer, rather than with an instruction. After exploring the infastructure in LLVM more, this seems to make more sense since declaring locals doesn't use an encoded opcode. This also adds more 0xd opcodes, type encodings, and miscellaneous binary encoding bits. llvm-svn: 285040
102 lines
4.3 KiB
TableGen
102 lines
4.3 KiB
TableGen
// WebAssemblyInstrFloat.td-WebAssembly Float codegen support ---*- tablegen -*-
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
///
|
|
/// \file
|
|
/// \brief WebAssembly Floating-point operand code-gen constructs.
|
|
///
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
let Defs = [ARGUMENTS] in {
|
|
|
|
let isCommutable = 1 in
|
|
defm ADD : BinaryFP<fadd, "add ", 0x92, 0xa0>;
|
|
defm SUB : BinaryFP<fsub, "sub ", 0x93, 0xa1>;
|
|
let isCommutable = 1 in
|
|
defm MUL : BinaryFP<fmul, "mul ", 0x94, 0xa2>;
|
|
defm DIV : BinaryFP<fdiv, "div ", 0x95, 0xa3>;
|
|
defm SQRT : UnaryFP<fsqrt, "sqrt", 0x91, 0x9f>;
|
|
|
|
defm ABS : UnaryFP<fabs, "abs ", 0x8b, 0x99>;
|
|
defm NEG : UnaryFP<fneg, "neg ", 0x8c, 0x9a>;
|
|
defm COPYSIGN : BinaryFP<fcopysign, "copysign", 0x98, 0xa6>;
|
|
|
|
let isCommutable = 1 in {
|
|
defm MIN : BinaryFP<fminnan, "min ", 0x96, 0xa4>;
|
|
defm MAX : BinaryFP<fmaxnan, "max ", 0x97, 0xa5>;
|
|
} // isCommutable = 1
|
|
|
|
defm CEIL : UnaryFP<fceil, "ceil", 0x8d, 0x9b>;
|
|
defm FLOOR : UnaryFP<ffloor, "floor", 0x8e, 0x9c>;
|
|
defm TRUNC : UnaryFP<ftrunc, "trunc", 0x8f, 0x9d>;
|
|
defm NEAREST : UnaryFP<fnearbyint, "nearest", 0x90, 0x9e>;
|
|
|
|
} // Defs = [ARGUMENTS]
|
|
|
|
// DAGCombine oddly folds casts into the rhs of copysign. Unfold them.
|
|
def : Pat<(fcopysign F64:$lhs, F32:$rhs),
|
|
(COPYSIGN_F64 F64:$lhs, (F64_PROMOTE_F32 F32:$rhs))>;
|
|
def : Pat<(fcopysign F32:$lhs, F64:$rhs),
|
|
(COPYSIGN_F32 F32:$lhs, (F32_DEMOTE_F64 F64:$rhs))>;
|
|
|
|
// WebAssembly doesn't expose inexact exceptions, so map frint to fnearbyint.
|
|
def : Pat<(frint f32:$src), (NEAREST_F32 f32:$src)>;
|
|
def : Pat<(frint f64:$src), (NEAREST_F64 f64:$src)>;
|
|
|
|
let Defs = [ARGUMENTS] in {
|
|
|
|
let isCommutable = 1 in {
|
|
defm EQ : ComparisonFP<SETOEQ, "eq ", 0x5b, 0x61>;
|
|
defm NE : ComparisonFP<SETUNE, "ne ", 0x5c, 0x62>;
|
|
} // isCommutable = 1
|
|
defm LT : ComparisonFP<SETOLT, "lt ", 0x5d, 0x63>;
|
|
defm LE : ComparisonFP<SETOLE, "le ", 0x5e, 0x64>;
|
|
defm GT : ComparisonFP<SETOGT, "gt ", 0x5f, 0x65>;
|
|
defm GE : ComparisonFP<SETOGE, "ge ", 0x60, 0x66>;
|
|
|
|
} // Defs = [ARGUMENTS]
|
|
|
|
// Don't care floating-point comparisons, supported via other comparisons.
|
|
def : Pat<(seteq f32:$lhs, f32:$rhs), (EQ_F32 f32:$lhs, f32:$rhs)>;
|
|
def : Pat<(setne f32:$lhs, f32:$rhs), (NE_F32 f32:$lhs, f32:$rhs)>;
|
|
def : Pat<(setlt f32:$lhs, f32:$rhs), (LT_F32 f32:$lhs, f32:$rhs)>;
|
|
def : Pat<(setle f32:$lhs, f32:$rhs), (LE_F32 f32:$lhs, f32:$rhs)>;
|
|
def : Pat<(setgt f32:$lhs, f32:$rhs), (GT_F32 f32:$lhs, f32:$rhs)>;
|
|
def : Pat<(setge f32:$lhs, f32:$rhs), (GE_F32 f32:$lhs, f32:$rhs)>;
|
|
def : Pat<(seteq f64:$lhs, f64:$rhs), (EQ_F64 f64:$lhs, f64:$rhs)>;
|
|
def : Pat<(setne f64:$lhs, f64:$rhs), (NE_F64 f64:$lhs, f64:$rhs)>;
|
|
def : Pat<(setlt f64:$lhs, f64:$rhs), (LT_F64 f64:$lhs, f64:$rhs)>;
|
|
def : Pat<(setle f64:$lhs, f64:$rhs), (LE_F64 f64:$lhs, f64:$rhs)>;
|
|
def : Pat<(setgt f64:$lhs, f64:$rhs), (GT_F64 f64:$lhs, f64:$rhs)>;
|
|
def : Pat<(setge f64:$lhs, f64:$rhs), (GE_F64 f64:$lhs, f64:$rhs)>;
|
|
|
|
let Defs = [ARGUMENTS] in {
|
|
|
|
def SELECT_F32 : I<(outs F32:$dst), (ins F32:$lhs, F32:$rhs, I32:$cond),
|
|
[(set F32:$dst, (select I32:$cond, F32:$lhs, F32:$rhs))],
|
|
"f32.select\t$dst, $lhs, $rhs, $cond", 0x1b>;
|
|
def SELECT_F64 : I<(outs F64:$dst), (ins F64:$lhs, F64:$rhs, I32:$cond),
|
|
[(set F64:$dst, (select I32:$cond, F64:$lhs, F64:$rhs))],
|
|
"f64.select\t$dst, $lhs, $rhs, $cond", 0x1b>;
|
|
|
|
} // Defs = [ARGUMENTS]
|
|
|
|
// ISD::SELECT requires its operand to conform to getBooleanContents, but
|
|
// WebAssembly's select interprets any non-zero value as true, so we can fold
|
|
// a setne with 0 into a select.
|
|
def : Pat<(select (i32 (setne I32:$cond, 0)), F32:$lhs, F32:$rhs),
|
|
(SELECT_F32 F32:$lhs, F32:$rhs, I32:$cond)>;
|
|
def : Pat<(select (i32 (setne I32:$cond, 0)), F64:$lhs, F64:$rhs),
|
|
(SELECT_F64 F64:$lhs, F64:$rhs, I32:$cond)>;
|
|
|
|
// And again, this time with seteq instead of setne and the arms reversed.
|
|
def : Pat<(select (i32 (seteq I32:$cond, 0)), F32:$lhs, F32:$rhs),
|
|
(SELECT_F32 F32:$rhs, F32:$lhs, I32:$cond)>;
|
|
def : Pat<(select (i32 (seteq I32:$cond, 0)), F64:$lhs, F64:$rhs),
|
|
(SELECT_F64 F64:$rhs, F64:$lhs, I32:$cond)>;
|