This is an archive of the discontinued LLVM Phabricator instance.

Differential D89205

[VE] Support fneg and frem
ClosedPublic

Authored by kaz7 on Oct 11 2020, 7:47 AM.

Details

Reviewers
simoll
k-ishizaka
Commits
rG9d6d4b07a216: [VE] Support fneg and frem
Summary

VE doesn't have fneg or frem instruction, so change them to expand. Add
regression tests also.

Diff Detail

Event Timeline

kaz7 created this revision.Oct 11 2020, 7:47 AM
Herald added subscribers: llvm-commits, hiraditya. · View Herald TranscriptOct 11 2020, 7:47 AM
kaz7 requested review of this revision.Oct 11 2020, 7:47 AM
Harbormaster completed remote builds in B74729: Diff 297461.Oct 11 2020, 8:28 AM
simoll accepted this revision.Oct 12 2020, 2:50 AM
This revision is now accepted and ready to land.Oct 12 2020, 2:50 AM
This revision was landed with ongoing or failed builds.Oct 12 2020, 3:19 AM
Closed by commit rG9d6d4b07a216: [VE] Support fneg and frem (authored by kaz7). · Explain Why
This revision was automatically updated to reflect the committed changes.
kaz7 added a commit: rG9d6d4b07a216: [VE] Support fneg and frem.

Revision Contents

PathSize
llvm/
lib/
Target/
VE/
8 lines
test/
CodeGen/
VE/
67 lines
171 lines

Diff 297534

llvm/lib/Target/VE/VEISelLowering.cpp

Show First 20 Lines • Show All 734 Lines • ▼ Show 20 LinesVETargetLowering::VETargetLowering(const TargetMachine &TM,
// fp16 not supported // fp16 not supported
for (MVT FPVT : MVT::fp_valuetypes()) { for (MVT FPVT : MVT::fp_valuetypes()) {
setOperationAction(ISD::FP16_TO_FP, FPVT, Expand); setOperationAction(ISD::FP16_TO_FP, FPVT, Expand);
setOperationAction(ISD::FP_TO_FP16, FPVT, Expand); setOperationAction(ISD::FP_TO_FP16, FPVT, Expand);
} }
/// } Conversion /// } Conversion
/// Floating-point Ops { /// Floating-point Ops {
/// Note: Floating-point operations are fneg, fadd, fsub, fmul, fdiv, frem,
/// and fcmp.
// VE doesn't have following floating point operations.
for (MVT VT : MVT::fp_valuetypes()) {
setOperationAction(ISD::FNEG, VT, Expand);
setOperationAction(ISD::FREM, VT, Expand);
}
// VE doesn't have fdiv of f128. // VE doesn't have fdiv of f128.
setOperationAction(ISD::FDIV, MVT::f128, Expand); setOperationAction(ISD::FDIV, MVT::f128, Expand);
for (MVT FPVT : {MVT::f32, MVT::f64}) { for (MVT FPVT : {MVT::f32, MVT::f64}) {
// f32 and f64 uses ConstantFP. f128 uses ConstantPool. // f32 and f64 uses ConstantFP. f128 uses ConstantPool.
setOperationAction(ISD::ConstantFP, FPVT, Legal); setOperationAction(ISD::ConstantFP, FPVT, Legal);
} }
▲ Show 20 Lines • Show All 596 Lines • Show Last 20 Lines

llvm/test/CodeGen/VE/fp_fneg.ll

  • This file was added.
; RUN: llc < %s -mtriple=ve | FileCheck %s
;;; Test ‘fneg’ Instruction
;;;
;;; Syntax:
;;; <result> = fneg [fast-math flags]* <ty> <op1> ; yields ty:result
;;;
;;; Overview:
;;; The ‘fneg’ instruction returns the negation of its operand.
;;;
;;; Arguments:
;;; The argument to the ‘fneg’ instruction must be a floating-point or
;;; vector of floating-point values.
;;;
;;; Semantics:
;;;
;;; The value produced is a copy of the operand with its sign bit flipped.
;;; This instruction can also take any number of fast-math flags, which are
;;; optimization hints to enable otherwise unsafe floating-point
;;; optimizations.
;;;
;;; Example:
;;; <result> = fneg float %val ; yields float:result = -%var
;;;
;;; Note:
;;; We test only float/double/fp128.
; Function Attrs: norecurse nounwind readnone
define float @fneg_float(float %0) {
; CHECK-LABEL: fneg_float:
; CHECK: .LBB{{[0-9]+}}_2:
; CHECK-NEXT: sra.l %s0, %s0, 32
; CHECK-NEXT: lea %s1, -2147483648
; CHECK-NEXT: and %s1, %s1, (32)0
; CHECK-NEXT: xor %s0, %s0, %s1
; CHECK-NEXT: sll %s0, %s0, 32
; CHECK-NEXT: or %s11, 0, %s9
%2 = fneg float %0
ret float %2
}
; Function Attrs: norecurse nounwind readnone
define double @fneg_double(double %0) {
; CHECK-LABEL: fneg_double:
; CHECK: .LBB{{[0-9]+}}_2:
; CHECK-NEXT: xor %s0, %s0, (1)1
; CHECK-NEXT: or %s11, 0, %s9
%2 = fneg double %0
ret double %2
}
; Function Attrs: norecurse nounwind readnone
define fp128 @fneg_quad(fp128 %0) {
; CHECK-LABEL: fneg_quad:
; CHECK: .LBB{{[0-9]+}}_2:
; CHECK-NEXT: st %s1, 176(, %s11)
; CHECK-NEXT: st %s0, 184(, %s11)
; CHECK-NEXT: ld1b.zx %s0, 191(, %s11)
; CHECK-NEXT: lea %s1, 128
; CHECK-NEXT: xor %s0, %s0, %s1
; CHECK-NEXT: st1b %s0, 191(, %s11)
; CHECK-NEXT: ld %s1, 176(, %s11)
; CHECK-NEXT: ld %s0, 184(, %s11)
; CHECK-NEXT: or %s11, 0, %s9
%2 = fneg fp128 %0
ret fp128 %2
}

llvm/test/CodeGen/VE/fp_frem.ll

  • This file was added.
; RUN: llc < %s -mtriple=ve | FileCheck %s
;;; Test ‘frem’ Instruction
;;;
;;; Syntax:
;;; <result> = frem [fast-math flags]* <ty> <op1>, <op2> ; yields ty:result
;;;
;;; Overview:
;;; The ‘frem’ instruction returns the remainder from the division of its two
;;; operands.
;;;
;;; Arguments:
;;; The two arguments to the ‘frem’ instruction must be floating-point or
;;; vector of floating-point values. Both arguments must have identical types.
;;;
;;; Semantics:
;;; The value produced is the floating-point remainder of the two operands.
;;; This is the same output as a libm ‘fmod’ function, but without any
;;; possibility of setting errno. The remainder has the same sign as the
;;; dividend. This instruction is assumed to execute in the default
;;; floating-point environment. This instruction can also take any number
;;; of fast-math flags, which are optimization hints to enable otherwise
;;; unsafe floating-point optimizations:
;;;
;;; Example:
;;;
;;; <result> = frem float 4.0, %var ; yields float:result = 4.0 % %var
;;;
;;; Note:
;;; We test only float/double/fp128.
;;; We have no way to generated frem from C source code, so convert fdiv
;;; to frem by using sed program.
; Function Attrs: norecurse nounwind readnone
define float @frem_float_var(float %0, float %1) {
; CHECK-LABEL: frem_float_var:
; CHECK: .LBB{{[0-9]+}}_2:
; CHECK-NEXT: lea %s2, fmodf@lo
; CHECK-NEXT: and %s2, %s2, (32)0
; CHECK-NEXT: lea.sl %s12, fmodf@hi(, %s2)
; CHECK-NEXT: bsic %s10, (, %s12)
; CHECK-NEXT: or %s11, 0, %s9
%3 = frem float %0, %1
ret float %3
}
; Function Attrs: norecurse nounwind readnone
define double @frem_double_var(double %0, double %1) {
; CHECK-LABEL: frem_double_var:
; CHECK: .LBB{{[0-9]+}}_2:
; CHECK-NEXT: lea %s2, fmod@lo
; CHECK-NEXT: and %s2, %s2, (32)0
; CHECK-NEXT: lea.sl %s12, fmod@hi(, %s2)
; CHECK-NEXT: bsic %s10, (, %s12)
; CHECK-NEXT: or %s11, 0, %s9
%3 = frem double %0, %1
ret double %3
}
; Function Attrs: norecurse nounwind readnone
define fp128 @frem_quad_var(fp128 %0, fp128 %1) {
; CHECK-LABEL: frem_quad_var:
; CHECK: .LBB{{[0-9]+}}_2:
; CHECK-NEXT: lea %s4, fmodl@lo
; CHECK-NEXT: and %s4, %s4, (32)0
; CHECK-NEXT: lea.sl %s12, fmodl@hi(, %s4)
; CHECK-NEXT: bsic %s10, (, %s12)
; CHECK-NEXT: or %s11, 0, %s9
%3 = frem fp128 %0, %1
ret fp128 %3
}
; Function Attrs: norecurse nounwind readnone
define float @frem_float_zero(float %0) {
; CHECK-LABEL: frem_float_zero:
; CHECK: .LBB{{[0-9]+}}_2:
; CHECK-NEXT: or %s1, 0, %s0
; CHECK-NEXT: lea.sl %s0, 0
; CHECK-NEXT: lea %s2, fmodf@lo
; CHECK-NEXT: and %s2, %s2, (32)0
; CHECK-NEXT: lea.sl %s12, fmodf@hi(, %s2)
; CHECK-NEXT: bsic %s10, (, %s12)
; CHECK-NEXT: or %s11, 0, %s9
%2 = frem float 0.000000e+00, %0
ret float %2
}
; Function Attrs: norecurse nounwind readnone
define double @frem_double_zero(double %0) {
; CHECK-LABEL: frem_double_zero:
; CHECK: .LBB{{[0-9]+}}_2:
; CHECK-NEXT: or %s1, 0, %s0
; CHECK-NEXT: lea %s0, fmod@lo
; CHECK-NEXT: and %s0, %s0, (32)0
; CHECK-NEXT: lea.sl %s12, fmod@hi(, %s0)
; CHECK-NEXT: lea.sl %s0, 0
; CHECK-NEXT: bsic %s10, (, %s12)
; CHECK-NEXT: or %s11, 0, %s9
%2 = frem double 0.000000e+00, %0
ret double %2
}
; Function Attrs: norecurse nounwind readnone
define fp128 @frem_quad_zero(fp128 %0) {
; CHECK-LABEL: frem_quad_zero:
; CHECK: .LBB{{[0-9]+}}_2:
; CHECK-NEXT: or %s2, 0, %s0
; CHECK-NEXT: or %s3, 0, %s1
; CHECK-NEXT: lea %s0, .LCPI{{[0-9]+}}_0@lo
; CHECK-NEXT: and %s0, %s0, (32)0
; CHECK-NEXT: lea.sl %s4, .LCPI{{[0-9]+}}_0@hi(, %s0)
; CHECK-NEXT: ld %s0, 8(, %s4)
; CHECK-NEXT: ld %s1, (, %s4)
; CHECK-NEXT: lea %s4, fmodl@lo
; CHECK-NEXT: and %s4, %s4, (32)0
; CHECK-NEXT: lea.sl %s12, fmodl@hi(, %s4)
; CHECK-NEXT: bsic %s10, (, %s12)
; CHECK-NEXT: or %s11, 0, %s9
%2 = frem fp128 0xL00000000000000000000000000000000, %0
ret fp128 %2
}
; Function Attrs: norecurse nounwind readnone
define float @frem_float_cont(float %0) {
; CHECK-LABEL: frem_float_cont:
; CHECK: .LBB{{[0-9]+}}_2:
; CHECK-NEXT: or %s1, 0, %s0
; CHECK-NEXT: lea.sl %s0, -1073741824
; CHECK-NEXT: lea %s2, fmodf@lo
; CHECK-NEXT: and %s2, %s2, (32)0
; CHECK-NEXT: lea.sl %s12, fmodf@hi(, %s2)
; CHECK-NEXT: bsic %s10, (, %s12)
; CHECK-NEXT: or %s11, 0, %s9
%2 = frem float -2.000000e+00, %0
ret float %2
}
; Function Attrs: norecurse nounwind readnone
define double @frem_double_cont(double %0) {
; CHECK-LABEL: frem_double_cont:
; CHECK: .LBB{{[0-9]+}}_2:
; CHECK-NEXT: or %s1, 0, %s0
; CHECK-NEXT: lea %s0, fmod@lo
; CHECK-NEXT: and %s0, %s0, (32)0
; CHECK-NEXT: lea.sl %s12, fmod@hi(, %s0)
; CHECK-NEXT: lea.sl %s0, -1073741824
; CHECK-NEXT: bsic %s10, (, %s12)
; CHECK-NEXT: or %s11, 0, %s9
%2 = frem double -2.000000e+00, %0
ret double %2
}
; Function Attrs: norecurse nounwind readnone
define fp128 @frem_quad_cont(fp128 %0) {
; CHECK-LABEL: frem_quad_cont:
; CHECK: .LBB{{[0-9]+}}_2:
; CHECK-NEXT: or %s2, 0, %s0
; CHECK-NEXT: or %s3, 0, %s1
; CHECK-NEXT: lea %s0, .LCPI{{[0-9]+}}_0@lo
; CHECK-NEXT: and %s0, %s0, (32)0
; CHECK-NEXT: lea.sl %s4, .LCPI{{[0-9]+}}_0@hi(, %s0)
; CHECK-NEXT: ld %s0, 8(, %s4)
; CHECK-NEXT: ld %s1, (, %s4)
; CHECK-NEXT: lea %s4, fmodl@lo
; CHECK-NEXT: and %s4, %s4, (32)0
; CHECK-NEXT: lea.sl %s12, fmodl@hi(, %s4)
; CHECK-NEXT: bsic %s10, (, %s12)
; CHECK-NEXT: or %s11, 0, %s9
%2 = frem fp128 0xL0000000000000000C000000000000000, %0
ret fp128 %2
}