test/CodeGen/WebAssembly/conv.ll

   1 ; RUN: llc < %s -asm-verbose=false | FileCheck %s
   2
   3 ; Test that basic conversion operations assemble as expected.
   4
   5 target datalayout = "e-p:32:32-i64:64-n32:64-S128"
   6 target triple = "wasm32-unknown-unknown"
   7
   8 ; CHECK-LABEL: i32_wrap_i64:
   9 ; CHECK-NEXT: .param i64{{$}}
  10 ; CHECK-NEXT: .result i32{{$}}
  11 ; CHECK-NEXT: i32.wrap/i64 $push[[NUM:[0-9]+]], $0{{$}}
  12 ; CHECK-NEXT: return $pop[[NUM]]{{$}}
  13 define i32 @i32_wrap_i64(i64 %x) {
  14   %a = trunc i64 %x to i32
  15   ret i32 %a
  16 }
  17
  18 ; CHECK-LABEL: i64_extend_s_i32:
  19 ; CHECK-NEXT: .param i32
  20 ; CHECK-NEXT: .result i64
  21 ; CHECK-NEXT: i64.extend_s/i32 $push[[NUM:[0-9]+]], $0{{$}}
  22 ; CHECK-NEXT: return $pop[[NUM]]{{$}}
  23 define i64 @i64_extend_s_i32(i32 %x) {
  24   %a = sext i32 %x to i64
  25   ret i64 %a
  26 }
  27
  28 ; CHECK-LABEL: i64_extend_u_i32:
  29 ; CHECK-NEXT: .param i32
  30 ; CHECK-NEXT: .result i64
  31 ; CHECK-NEXT: i64.extend_u/i32 $push[[NUM:[0-9]+]], $0{{$}}
  32 ; CHECK-NEXT: return $pop[[NUM]]{{$}}
  33 define i64 @i64_extend_u_i32(i32 %x) {
  34   %a = zext i32 %x to i64
  35   ret i64 %a
  36 }
  37
  38 ; CHECK-LABEL: i32_trunc_s_f32:
  39 ; CHECK-NEXT: .param f32
  40 ; CHECK-NEXT: .result i32
  41 ; CHECK-NEXT: i32.trunc_s/f32 $push[[NUM:[0-9]+]], $0{{$}}
  42 ; CHECK-NEXT: return $pop[[NUM]]{{$}}
  43 define i32 @i32_trunc_s_f32(float %x) {
  44   %a = fptosi float %x to i32
  45   ret i32 %a
  46 }
  47
  48 ; CHECK-LABEL: i32_trunc_u_f32:
  49 ; CHECK-NEXT: .param f32
  50 ; CHECK-NEXT: .result i32
  51 ; CHECK-NEXT: i32.trunc_u/f32 $push[[NUM:[0-9]+]], $0{{$}}
  52 ; CHECK-NEXT: return $pop[[NUM]]{{$}}
  53 define i32 @i32_trunc_u_f32(float %x) {
  54   %a = fptoui float %x to i32
  55   ret i32 %a
  56 }
  57
  58 ; CHECK-LABEL: i32_trunc_s_f64:
  59 ; CHECK-NEXT: .param f64
  60 ; CHECK-NEXT: .result i32
  61 ; CHECK-NEXT: i32.trunc_s/f64 $push[[NUM:[0-9]+]], $0{{$}}
  62 ; CHECK-NEXT: return $pop[[NUM]]{{$}}
  63 define i32 @i32_trunc_s_f64(double %x) {
  64   %a = fptosi double %x to i32
  65   ret i32 %a
  66 }
  67
  68 ; CHECK-LABEL: i32_trunc_u_f64:
  69 ; CHECK-NEXT: .param f64
  70 ; CHECK-NEXT: .result i32
  71 ; CHECK-NEXT: i32.trunc_u/f64 $push[[NUM:[0-9]+]], $0{{$}}
  72 ; CHECK-NEXT: return $pop[[NUM]]{{$}}
  73 define i32 @i32_trunc_u_f64(double %x) {
  74   %a = fptoui double %x to i32
  75   ret i32 %a
  76 }
  77
  78 ; CHECK-LABEL: i64_trunc_s_f32:
  79 ; CHECK-NEXT: .param f32
  80 ; CHECK-NEXT: .result i64
  81 ; CHECK-NEXT: i64.trunc_s/f32 $push[[NUM:[0-9]+]], $0{{$}}
  82 ; CHECK-NEXT: return $pop[[NUM]]{{$}}
  83 define i64 @i64_trunc_s_f32(float %x) {
  84   %a = fptosi float %x to i64
  85   ret i64 %a
  86 }
  87
  88 ; CHECK-LABEL: i64_trunc_u_f32:
  89 ; CHECK-NEXT: .param f32
  90 ; CHECK-NEXT: .result i64
  91 ; CHECK-NEXT: i64.trunc_u/f32 $push[[NUM:[0-9]+]], $0{{$}}
  92 ; CHECK-NEXT: return $pop[[NUM]]{{$}}
  93 define i64 @i64_trunc_u_f32(float %x) {
  94   %a = fptoui float %x to i64
  95   ret i64 %a
  96 }
  97
  98 ; CHECK-LABEL: i64_trunc_s_f64:
  99 ; CHECK-NEXT: .param f64
 100 ; CHECK-NEXT: .result i64
 101 ; CHECK-NEXT: i64.trunc_s/f64 $push[[NUM:[0-9]+]], $0{{$}}
 102 ; CHECK-NEXT: return $pop[[NUM]]{{$}}
 103 define i64 @i64_trunc_s_f64(double %x) {
 104   %a = fptosi double %x to i64
 105   ret i64 %a
 106 }
 107
 108 ; CHECK-LABEL: i64_trunc_u_f64:
 109 ; CHECK-NEXT: .param f64
 110 ; CHECK-NEXT: .result i64
 111 ; CHECK-NEXT: i64.trunc_u/f64 $push[[NUM:[0-9]+]], $0{{$}}
 112 ; CHECK-NEXT: return $pop[[NUM]]{{$}}
 113 define i64 @i64_trunc_u_f64(double %x) {
 114   %a = fptoui double %x to i64
 115   ret i64 %a
 116 }
 117
 118 ; CHECK-LABEL: f32_convert_s_i32:
 119 ; CHECK-NEXT: .param i32
 120 ; CHECK-NEXT: .result f32
 121 ; CHECK-NEXT: f32.convert_s/i32 $push[[NUM:[0-9]+]], $0{{$}}
 122 ; CHECK-NEXT: return $pop[[NUM]]{{$}}
 123 define float @f32_convert_s_i32(i32 %x) {
 124   %a = sitofp i32 %x to float
 125   ret float %a
 126 }
 127
 128 ; CHECK-LABEL: f32_convert_u_i32:
 129 ; CHECK-NEXT: .param i32
 130 ; CHECK-NEXT: .result f32
 131 ; CHECK-NEXT: f32.convert_u/i32 $push[[NUM:[0-9]+]], $0{{$}}
 132 ; CHECK-NEXT: return $pop[[NUM]]{{$}}
 133 define float @f32_convert_u_i32(i32 %x) {
 134   %a = uitofp i32 %x to float
 135   ret float %a
 136 }
 137
 138 ; CHECK-LABEL: f64_convert_s_i32:
 139 ; CHECK-NEXT: .param i32
 140 ; CHECK-NEXT: .result f64
 141 ; CHECK-NEXT: f64.convert_s/i32 $push[[NUM:[0-9]+]], $0{{$}}
 142 ; CHECK-NEXT: return $pop[[NUM]]{{$}}
 143 define double @f64_convert_s_i32(i32 %x) {
 144   %a = sitofp i32 %x to double
 145   ret double %a
 146 }
 147
 148 ; CHECK-LABEL: f64_convert_u_i32:
 149 ; CHECK-NEXT: .param i32
 150 ; CHECK-NEXT: .result f64
 151 ; CHECK-NEXT: f64.convert_u/i32 $push[[NUM:[0-9]+]], $0{{$}}
 152 ; CHECK-NEXT: return $pop[[NUM]]{{$}}
 153 define double @f64_convert_u_i32(i32 %x) {
 154   %a = uitofp i32 %x to double
 155   ret double %a
 156 }
 157
 158 ; CHECK-LABEL: f32_convert_s_i64:
 159 ; CHECK-NEXT: .param i64
 160 ; CHECK-NEXT: .result f32
 161 ; CHECK-NEXT: f32.convert_s/i64 $push[[NUM:[0-9]+]], $0{{$}}
 162 ; CHECK-NEXT: return $pop[[NUM]]{{$}}
 163 define float @f32_convert_s_i64(i64 %x) {
 164   %a = sitofp i64 %x to float
 165   ret float %a
 166 }
 167
 168 ; CHECK-LABEL: f32_convert_u_i64:
 169 ; CHECK-NEXT: .param i64
 170 ; CHECK-NEXT: .result f32
 171 ; CHECK-NEXT: f32.convert_u/i64 $push[[NUM:[0-9]+]], $0{{$}}
 172 ; CHECK-NEXT: return $pop[[NUM]]{{$}}
 173 define float @f32_convert_u_i64(i64 %x) {
 174   %a = uitofp i64 %x to float
 175   ret float %a
 176 }
 177
 178 ; CHECK-LABEL: f64_convert_s_i64:
 179 ; CHECK-NEXT: .param i64
 180 ; CHECK-NEXT: .result f64
 181 ; CHECK-NEXT: f64.convert_s/i64 $push[[NUM:[0-9]+]], $0{{$}}
 182 ; CHECK-NEXT: return $pop[[NUM]]{{$}}
 183 define double @f64_convert_s_i64(i64 %x) {
 184   %a = sitofp i64 %x to double
 185   ret double %a
 186 }
 187
 188 ; CHECK-LABEL: f64_convert_u_i64:
 189 ; CHECK-NEXT: .param i64
 190 ; CHECK-NEXT: .result f64
 191 ; CHECK-NEXT: f64.convert_u/i64 $push[[NUM:[0-9]+]], $0{{$}}
 192 ; CHECK-NEXT: return $pop[[NUM]]{{$}}
 193 define double @f64_convert_u_i64(i64 %x) {
 194   %a = uitofp i64 %x to double
 195   ret double %a
 196 }
 197
 198 ; CHECK-LABEL: f64_promote_f32:
 199 ; CHECK-NEXT: .param f32
 200 ; CHECK-NEXT: .result f64
 201 ; CHECK-NEXT: f64.promote/f32 $push[[NUM:[0-9]+]], $0{{$}}
 202 ; CHECK-NEXT: return $pop[[NUM]]{{$}}
 203 define double @f64_promote_f32(float %x) {
 204   %a = fpext float %x to double
 205   ret double %a
 206 }
 207
 208 ; CHECK-LABEL: f32_demote_f64:
 209 ; CHECK-NEXT: .param f64
 210 ; CHECK-NEXT: .result f32
 211 ; CHECK-NEXT: f32.demote/f64 $push[[NUM:[0-9]+]], $0{{$}}
 212 ; CHECK-NEXT: return $pop[[NUM]]{{$}}
 213 define float @f32_demote_f64(double %x) {
 214   %a = fptrunc double %x to float
 215   ret float %a
 216 }