llvm/test/CodeGen/RISCV/double-bitmanip-dagcombines.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
   2 ; RUN: llc -mtriple=riscv32 -target-abi=ilp32 -verify-machineinstrs < %s \
   3 ; RUN:   | FileCheck -check-prefix=RV32I %s
   4 ; RUN: llc -mtriple=riscv32 -target-abi=ilp32 -mattr=+d -verify-machineinstrs < %s \
   5 ; RUN:   | FileCheck -check-prefix=RV32IFD %s
   6 ; RUN: llc -mtriple=riscv64 -target-abi=lp64 -verify-machineinstrs < %s \
   7 ; RUN:   | FileCheck -check-prefix=RV64I %s
   8 ; RUN: llc -mtriple=riscv64 -target-abi=lp64 -mattr=+d -verify-machineinstrs < %s \
   9 ; RUN:   | FileCheck -check-prefix=RV64IFD %s
  10 ;
  11 ; This file tests cases where simple floating point operations can be
  12 ; profitably handled though bit manipulation if a soft-float ABI is being used
  13 ; (e.g. fneg implemented by XORing the sign bit). This is typically handled in
  14 ; DAGCombiner::visitBITCAST, but this target-independent code may not trigger
  15 ; in cases where we perform custom legalisation (e.g. RV32IFD).
  16
  17 ; TODO: Add an appropriate target-specific DAG combine that can handle
  18 ; RISCVISD::SplitF64/BuildPairF64 used for RV32IFD.
  19
  20 define double @fneg(double %a) nounwind {
  21 ; RV32I-LABEL: fneg:
  22 ; RV32I:       # %bb.0:
  23 ; RV32I-NEXT:    lui a2, 524288
  24 ; RV32I-NEXT:    xor a1, a1, a2
  25 ; RV32I-NEXT:    ret
  26 ;
  27 ; RV32IFD-LABEL: fneg:
  28 ; RV32IFD:       # %bb.0:
  29 ; RV32IFD-NEXT:    lui a2, 524288
  30 ; RV32IFD-NEXT:    xor a1, a1, a2
  31 ; RV32IFD-NEXT:    ret
  32 ;
  33 ; RV64I-LABEL: fneg:
  34 ; RV64I:       # %bb.0:
  35 ; RV64I-NEXT:    li a1, -1
  36 ; RV64I-NEXT:    slli a1, a1, 63
  37 ; RV64I-NEXT:    xor a0, a0, a1
  38 ; RV64I-NEXT:    ret
  39 ;
  40 ; RV64IFD-LABEL: fneg:
  41 ; RV64IFD:       # %bb.0:
  42 ; RV64IFD-NEXT:    li a1, -1
  43 ; RV64IFD-NEXT:    slli a1, a1, 63
  44 ; RV64IFD-NEXT:    xor a0, a0, a1
  45 ; RV64IFD-NEXT:    ret
  46   %1 = fneg double %a
  47   ret double %1
  48 }
  49
  50 declare double @llvm.fabs.f64(double)
  51
  52 define double @fabs(double %a) nounwind {
  53 ; RV32I-LABEL: fabs:
  54 ; RV32I:       # %bb.0:
  55 ; RV32I-NEXT:    slli a1, a1, 1
  56 ; RV32I-NEXT:    srli a1, a1, 1
  57 ; RV32I-NEXT:    ret
  58 ;
  59 ; RV32IFD-LABEL: fabs:
  60 ; RV32IFD:       # %bb.0:
  61 ; RV32IFD-NEXT:    slli a1, a1, 1
  62 ; RV32IFD-NEXT:    srli a1, a1, 1
  63 ; RV32IFD-NEXT:    ret
  64 ;
  65 ; RV64I-LABEL: fabs:
  66 ; RV64I:       # %bb.0:
  67 ; RV64I-NEXT:    slli a0, a0, 1
  68 ; RV64I-NEXT:    srli a0, a0, 1
  69 ; RV64I-NEXT:    ret
  70 ;
  71 ; RV64IFD-LABEL: fabs:
  72 ; RV64IFD:       # %bb.0:
  73 ; RV64IFD-NEXT:    slli a0, a0, 1
  74 ; RV64IFD-NEXT:    srli a0, a0, 1
  75 ; RV64IFD-NEXT:    ret
  76   %1 = call double @llvm.fabs.f64(double %a)
  77   ret double %1
  78 }
  79
  80 declare double @llvm.copysign.f64(double, double)
  81
  82 ; DAGTypeLegalizer::SoftenFloatRes_FCOPYSIGN will convert to bitwise
  83 ; operations if floating point isn't supported. A combine could be written to
  84 ; do the same even when f64 is legal.
  85
  86 define double @fcopysign_fneg(double %a, double %b) nounwind {
  87 ; RV32I-LABEL: fcopysign_fneg:
  88 ; RV32I:       # %bb.0:
  89 ; RV32I-NEXT:    not a2, a3
  90 ; RV32I-NEXT:    lui a3, 524288
  91 ; RV32I-NEXT:    and a2, a2, a3
  92 ; RV32I-NEXT:    slli a1, a1, 1
  93 ; RV32I-NEXT:    srli a1, a1, 1
  94 ; RV32I-NEXT:    or a1, a1, a2
  95 ; RV32I-NEXT:    ret
  96 ;
  97 ; RV32IFD-LABEL: fcopysign_fneg:
  98 ; RV32IFD:       # %bb.0:
  99 ; RV32IFD-NEXT:    addi sp, sp, -16
 100 ; RV32IFD-NEXT:    sw a2, 8(sp)
 101 ; RV32IFD-NEXT:    sw a3, 12(sp)
 102 ; RV32IFD-NEXT:    fld ft0, 8(sp)
 103 ; RV32IFD-NEXT:    sw a0, 8(sp)
 104 ; RV32IFD-NEXT:    sw a1, 12(sp)
 105 ; RV32IFD-NEXT:    fld ft1, 8(sp)
 106 ; RV32IFD-NEXT:    fsgnjn.d ft0, ft1, ft0
 107 ; RV32IFD-NEXT:    fsd ft0, 8(sp)
 108 ; RV32IFD-NEXT:    lw a0, 8(sp)
 109 ; RV32IFD-NEXT:    lw a1, 12(sp)
 110 ; RV32IFD-NEXT:    addi sp, sp, 16
 111 ; RV32IFD-NEXT:    ret
 112 ;
 113 ; RV64I-LABEL: fcopysign_fneg:
 114 ; RV64I:       # %bb.0:
 115 ; RV64I-NEXT:    not a1, a1
 116 ; RV64I-NEXT:    slli a0, a0, 1
 117 ; RV64I-NEXT:    srli a0, a0, 1
 118 ; RV64I-NEXT:    srli a1, a1, 63
 119 ; RV64I-NEXT:    slli a1, a1, 63
 120 ; RV64I-NEXT:    or a0, a0, a1
 121 ; RV64I-NEXT:    ret
 122 ;
 123 ; RV64IFD-LABEL: fcopysign_fneg:
 124 ; RV64IFD:       # %bb.0:
 125 ; RV64IFD-NEXT:    li a2, -1
 126 ; RV64IFD-NEXT:    slli a2, a2, 63
 127 ; RV64IFD-NEXT:    xor a1, a1, a2
 128 ; RV64IFD-NEXT:    fmv.d.x ft0, a1
 129 ; RV64IFD-NEXT:    fmv.d.x ft1, a0
 130 ; RV64IFD-NEXT:    fsgnj.d ft0, ft1, ft0
 131 ; RV64IFD-NEXT:    fmv.x.d a0, ft0
 132 ; RV64IFD-NEXT:    ret
 133   %1 = fneg double %b
 134   %2 = call double @llvm.copysign.f64(double %a, double %1)
 135   ret double %2
 136 }