mlir/test/Conversion/MathToROCDL/math-to-rocdl.mlir

   1 // RUN: mlir-opt %s -convert-math-to-rocdl -allow-unregistered-dialect -split-input-file | FileCheck %s
   2
   3 module @test_module {
   4   // CHECK: llvm.func @__ocml_fmod_f16(f16, f16) -> f16
   5   // CHECK: llvm.func @__ocml_fmod_f32(f32, f32) -> f32
   6   // CHECK: llvm.func @__ocml_fmod_f64(f64, f64) -> f64
   7   // CHECK-LABEL: func @arith_remf
   8   func.func @arith_remf(%arg_f16 : f16, %arg_f32 : f32, %arg_f64 : f64) -> (f16, f32, f64) {
   9     %result16 = arith.remf %arg_f16, %arg_f16 : f16
  10     // CHECK: llvm.call @__ocml_fmod_f16(%{{.*}}, %{{.*}}) : (f16, f16) -> f16
  11     %result32 = arith.remf %arg_f32, %arg_f32 : f32
  12     // CHECK: llvm.call @__ocml_fmod_f32(%{{.*}}, %{{.*}}) : (f32, f32) -> f32
  13     %result64 = arith.remf %arg_f64, %arg_f64 : f64
  14     // CHECK: llvm.call @__ocml_fmod_f64(%{{.*}}, %{{.*}}) : (f64, f64) -> f64
  15     func.return %result16, %result32, %result64 : f16, f32, f64
  16   }
  17 }
  18
  19 // -----
  20
  21 module @test_module {
  22   // CHECK: llvm.func @__ocml_acos_f16(f16) -> f16
  23   // CHECK: llvm.func @__ocml_acos_f32(f32) -> f32
  24   // CHECK: llvm.func @__ocml_acos_f64(f64) -> f64
  25   // CHECK-LABEL: func @math_acos
  26   func.func @math_acos(%arg_f16 : f16, %arg_f32 : f32, %arg_f64 : f64) -> (f16, f32, f64) {
  27     %result16 = math.acos %arg_f16 : f16
  28     // CHECK: llvm.call @__ocml_acos_f16(%{{.*}}) : (f16) -> f16
  29     %result32 = math.acos %arg_f32 : f32
  30     // CHECK: llvm.call @__ocml_acos_f32(%{{.*}}) : (f32) -> f32
  31     %result64 = math.acos %arg_f64 : f64
  32     // CHECK: llvm.call @__ocml_acos_f64(%{{.*}}) : (f64) -> f64
  33     func.return %result16, %result32, %result64 : f16, f32, f64
  34   }
  35 }
  36
  37 // -----
  38
  39 module @test_module {
  40   // CHECK: llvm.func @__ocml_acosh_f16(f16) -> f16
  41   // CHECK: llvm.func @__ocml_acosh_f32(f32) -> f32
  42   // CHECK: llvm.func @__ocml_acosh_f64(f64) -> f64
  43   // CHECK-LABEL: func @math_acosh
  44   func.func @math_acosh(%arg_f16 : f16, %arg_f32 : f32, %arg_f64 : f64) -> (f16, f32, f64) {
  45     %result16 = math.acosh %arg_f16 : f16
  46     // CHECK: llvm.call @__ocml_acosh_f16(%{{.*}}) : (f16) -> f16
  47     %result32 = math.acosh %arg_f32 : f32
  48     // CHECK: llvm.call @__ocml_acosh_f32(%{{.*}}) : (f32) -> f32
  49     %result64 = math.acosh %arg_f64 : f64
  50     // CHECK: llvm.call @__ocml_acosh_f64(%{{.*}}) : (f64) -> f64
  51     func.return %result16, %result32, %result64 : f16, f32, f64
  52   }
  53 }
  54
  55 // -----
  56
  57 module @test_module {
  58   // CHECK: llvm.func @__ocml_asin_f16(f16) -> f16
  59   // CHECK: llvm.func @__ocml_asin_f32(f32) -> f32
  60   // CHECK: llvm.func @__ocml_asin_f64(f64) -> f64
  61   // CHECK-LABEL: func @math_asin
  62   func.func @math_asin(%arg_f16 : f16, %arg_f32 : f32, %arg_f64 : f64) -> (f16, f32, f64) {
  63     %result16 = math.asin %arg_f16 : f16
  64     // CHECK: llvm.call @__ocml_asin_f16(%{{.*}}) : (f16) -> f16
  65     %result32 = math.asin %arg_f32 : f32
  66     // CHECK: llvm.call @__ocml_asin_f32(%{{.*}}) : (f32) -> f32
  67     %result64 = math.asin %arg_f64 : f64
  68     // CHECK: llvm.call @__ocml_asin_f64(%{{.*}}) : (f64) -> f64
  69     func.return %result16, %result32, %result64 : f16, f32, f64
  70   }
  71 }
  72
  73 // -----
  74
  75 module @test_module {
  76   // CHECK: llvm.func @__ocml_asinh_f16(f16) -> f16
  77   // CHECK: llvm.func @__ocml_asinh_f32(f32) -> f32
  78   // CHECK: llvm.func @__ocml_asinh_f64(f64) -> f64
  79   // CHECK-LABEL: func @math_asinh
  80   func.func @math_asinh(%arg_f16 : f16, %arg_f32 : f32, %arg_f64 : f64) -> (f16, f32, f64) {
  81     %result16 = math.asinh %arg_f16 : f16
  82     // CHECK: llvm.call @__ocml_asinh_f16(%{{.*}}) : (f16) -> f16
  83     %result32 = math.asinh %arg_f32 : f32
  84     // CHECK: llvm.call @__ocml_asinh_f32(%{{.*}}) : (f32) -> f32
  85     %result64 = math.asinh %arg_f64 : f64
  86     // CHECK: llvm.call @__ocml_asinh_f64(%{{.*}}) : (f64) -> f64
  87     func.return %result16, %result32, %result64 : f16, f32, f64
  88   }
  89 }
  90
  91 // -----
  92
  93 module @test_module {
  94   // CHECK: llvm.func @__ocml_atan_f16(f16) -> f16
  95   // CHECK: llvm.func @__ocml_atan_f32(f32) -> f32
  96   // CHECK: llvm.func @__ocml_atan_f64(f64) -> f64
  97   // CHECK-LABEL: func @math_atan
  98   func.func @math_atan(%arg_f16 : f16, %arg_f32 : f32, %arg_f64 : f64) -> (f16, f32, f64) {
  99     %result16 = math.atan %arg_f16 : f16
 100     // CHECK: llvm.call @__ocml_atan_f16(%{{.*}}) : (f16) -> f16
 101     %result32 = math.atan %arg_f32 : f32
 102     // CHECK: llvm.call @__ocml_atan_f32(%{{.*}}) : (f32) -> f32
 103     %result64 = math.atan %arg_f64 : f64
 104     // CHECK: llvm.call @__ocml_atan_f64(%{{.*}}) : (f64) -> f64
 105     func.return %result16, %result32, %result64 : f16, f32, f64
 106   }
 107 }
 108
 109 // -----
 110
 111 module @test_module {
 112   // CHECK: llvm.func @__ocml_atanh_f16(f16) -> f16
 113   // CHECK: llvm.func @__ocml_atanh_f32(f32) -> f32
 114   // CHECK: llvm.func @__ocml_atanh_f64(f64) -> f64
 115   // CHECK-LABEL: func @math_atanh
 116   func.func @math_atanh(%arg_f16 : f16, %arg_f32 : f32, %arg_f64 : f64) -> (f16, f32, f64) {
 117     %result16 = math.atanh %arg_f16 : f16
 118     // CHECK: llvm.call @__ocml_atanh_f16(%{{.*}}) : (f16) -> f16
 119     %result32 = math.atanh %arg_f32 : f32
 120     // CHECK: llvm.call @__ocml_atanh_f32(%{{.*}}) : (f32) -> f32
 121     %result64 = math.atanh %arg_f64 : f64
 122     // CHECK: llvm.call @__ocml_atanh_f64(%{{.*}}) : (f64) -> f64
 123     func.return %result16, %result32, %result64 : f16, f32, f64
 124   }
 125 }
 126
 127 // -----
 128
 129 module @test_module {
 130   // CHECK: llvm.func @__ocml_atan2_f16(f16, f16) -> f16
 131   // CHECK: llvm.func @__ocml_atan2_f32(f32, f32) -> f32
 132   // CHECK: llvm.func @__ocml_atan2_f64(f64, f64) -> f64
 133   // CHECK-LABEL: func @math_atan2
 134   func.func @math_atan2(%arg_f16 : f16, %arg_f32 : f32, %arg_f64 : f64) -> (f16, f32, f64) {
 135     %result16 = math.atan2 %arg_f16, %arg_f16 : f16
 136     // CHECK: llvm.call @__ocml_atan2_f16(%{{.*}}, %{{.*}}) : (f16, f16) -> f16
 137     %result32 = math.atan2 %arg_f32, %arg_f32 : f32
 138     // CHECK: llvm.call @__ocml_atan2_f32(%{{.*}}, %{{.*}}) : (f32, f32) -> f32
 139     %result64 = math.atan2 %arg_f64, %arg_f64 : f64
 140     // CHECK: llvm.call @__ocml_atan2_f64(%{{.*}}, %{{.*}}) : (f64, f64) -> f64
 141     func.return %result16, %result32, %result64 : f16, f32, f64
 142   }
 143 }
 144
 145 // -----
 146
 147 module @test_module {
 148   // CHECK: llvm.func @__ocml_cbrt_f16(f16) -> f16
 149   // CHECK: llvm.func @__ocml_cbrt_f32(f32) -> f32
 150   // CHECK: llvm.func @__ocml_cbrt_f64(f64) -> f64
 151   // CHECK-LABEL: func @math_cbrt
 152   func.func @math_cbrt(%arg_f16 : f16, %arg_f32 : f32, %arg_f64 : f64) -> (f16, f32, f64) {
 153     %result16 = math.cbrt %arg_f16 : f16
 154     // CHECK: llvm.call @__ocml_cbrt_f16(%{{.*}}) : (f16) -> f16
 155     %result32 = math.cbrt %arg_f32 : f32
 156     // CHECK: llvm.call @__ocml_cbrt_f32(%{{.*}}) : (f32) -> f32
 157     %result64 = math.cbrt %arg_f64 : f64
 158     // CHECK: llvm.call @__ocml_cbrt_f64(%{{.*}}) : (f64) -> f64
 159     func.return %result16, %result32, %result64 : f16, f32, f64
 160   }
 161 }
 162
 163 // -----
 164
 165 module @test_module {
 166   // CHECK: llvm.func @__ocml_ceil_f16(f16) -> f16
 167   // CHECK: llvm.func @__ocml_ceil_f32(f32) -> f32
 168   // CHECK: llvm.func @__ocml_ceil_f64(f64) -> f64
 169   // CHECK-LABEL: func @math_ceil
 170   func.func @math_ceil(%arg_f16 : f16, %arg_f32 : f32, %arg_f64 : f64) -> (f16, f32, f64) {
 171     %result16 = math.ceil %arg_f16 : f16
 172     // CHECK: llvm.call @__ocml_ceil_f16(%{{.*}}) : (f16) -> f16
 173     %result32 = math.ceil %arg_f32 : f32
 174     // CHECK: llvm.call @__ocml_ceil_f32(%{{.*}}) : (f32) -> f32
 175     %result64 = math.ceil %arg_f64 : f64
 176     // CHECK: llvm.call @__ocml_ceil_f64(%{{.*}}) : (f64) -> f64
 177     func.return %result16, %result32, %result64 : f16, f32, f64
 178   }
 179 }
 180
 181 // -----
 182
 183 module @test_module {
 184   // CHECK: llvm.func @__ocml_cos_f16(f16) -> f16
 185   // CHECK: llvm.func @__ocml_cos_f32(f32) -> f32
 186   // CHECK: llvm.func @__ocml_cos_f64(f64) -> f64
 187   // CHECK-LABEL: func @math_cos
 188   func.func @math_cos(%arg_f16 : f16, %arg_f32 : f32, %arg_f64 : f64) -> (f16, f32, f64) {
 189     %result16 = math.cos %arg_f16 : f16
 190     // CHECK: llvm.call @__ocml_cos_f16(%{{.*}}) : (f16) -> f16
 191     %result32 = math.cos %arg_f32 : f32
 192     // CHECK: llvm.call @__ocml_cos_f32(%{{.*}}) : (f32) -> f32
 193     %result64 = math.cos %arg_f64 : f64
 194     // CHECK: llvm.call @__ocml_cos_f64(%{{.*}}) : (f64) -> f64
 195     func.return %result16, %result32, %result64 : f16, f32, f64
 196   }
 197 }
 198
 199 // -----
 200
 201 module @test_module {
 202   // CHECK: llvm.func @__ocml_cosh_f16(f16) -> f16
 203   // CHECK: llvm.func @__ocml_cosh_f32(f32) -> f32
 204   // CHECK: llvm.func @__ocml_cosh_f64(f64) -> f64
 205   // CHECK-LABEL: func @math_cosh
 206   func.func @math_cosh(%arg_f16 : f16, %arg_f32 : f32, %arg_f64 : f64) -> (f16, f32, f64) {
 207     %result16 = math.cosh %arg_f16 : f16
 208     // CHECK: llvm.call @__ocml_cosh_f16(%{{.*}}) : (f16) -> f16
 209     %result32 = math.cosh %arg_f32 : f32
 210     // CHECK: llvm.call @__ocml_cosh_f32(%{{.*}}) : (f32) -> f32
 211     %result64 = math.cosh %arg_f64 : f64
 212     // CHECK: llvm.call @__ocml_cosh_f64(%{{.*}}) : (f64) -> f64
 213     func.return %result16, %result32, %result64 : f16, f32, f64
 214   }
 215 }
 216
 217 // -----
 218
 219 module @test_module {
 220   // CHECK: llvm.func @__ocml_sinh_f16(f16) -> f16
 221   // CHECK: llvm.func @__ocml_sinh_f32(f32) -> f32
 222   // CHECK: llvm.func @__ocml_sinh_f64(f64) -> f64
 223   // CHECK-LABEL: func @math_sinh
 224   func.func @math_sinh(%arg_f16 : f16, %arg_f32 : f32, %arg_f64 : f64) -> (f16, f32, f64) {
 225     %result16 = math.sinh %arg_f16 : f16
 226     // CHECK: llvm.call @__ocml_sinh_f16(%{{.*}}) : (f16) -> f16
 227     %result32 = math.sinh %arg_f32 : f32
 228     // CHECK: llvm.call @__ocml_sinh_f32(%{{.*}}) : (f32) -> f32
 229     %result64 = math.sinh %arg_f64 : f64
 230     // CHECK: llvm.call @__ocml_sinh_f64(%{{.*}}) : (f64) -> f64
 231     func.return %result16, %result32, %result64 : f16, f32, f64
 232   }
 233 }
 234
 235 // -----
 236
 237 module @test_module {
 238   // CHECK: llvm.func @__ocml_exp_f16(f16) -> f16
 239   // CHECK: llvm.func @__ocml_exp_f64(f64) -> f64
 240   // CHECK-LABEL: func @math_exp
 241   func.func @math_exp(%arg_f16 : f16, %arg_f64 : f64) -> (f16, f64) {
 242     %result16 = math.exp %arg_f16 : f16
 243     // CHECK: llvm.call @__ocml_exp_f16(%{{.*}}) : (f16) -> f16
 244     %result64 = math.exp %arg_f64 : f64
 245     // CHECK: llvm.call @__ocml_exp_f64(%{{.*}}) : (f64) -> f64
 246     func.return %result16, %result64 : f16, f64
 247   }
 248 }
 249
 250 // -----
 251
 252 module @test_module {
 253   // CHECK: llvm.func @__ocml_exp2_f16(f16) -> f16
 254   // CHECK: llvm.func @__ocml_exp2_f32(f32) -> f32
 255   // CHECK: llvm.func @__ocml_exp2_f64(f64) -> f64
 256   // CHECK-LABEL: func @math_exp2
 257   func.func @math_exp2(%arg_f16 : f16, %arg_f32 : f32, %arg_f64 : f64) -> (f16, f32, f64) {
 258     %result16 = math.exp2 %arg_f16 : f16
 259     // CHECK: llvm.call @__ocml_exp2_f16(%{{.*}}) : (f16) -> f16
 260     %result32 = math.exp2 %arg_f32 : f32
 261     // CHECK: llvm.call @__ocml_exp2_f32(%{{.*}}) : (f32) -> f32
 262     %result64 = math.exp2 %arg_f64 : f64
 263     // CHECK: llvm.call @__ocml_exp2_f64(%{{.*}}) : (f64) -> f64
 264     func.return %result16, %result32, %result64 : f16, f32, f64
 265   }
 266 }
 267
 268 // -----
 269
 270 module @test_module {
 271   // CHECK: llvm.func @__ocml_expm1_f16(f16) -> f16
 272   // CHECK: llvm.func @__ocml_expm1_f32(f32) -> f32
 273   // CHECK: llvm.func @__ocml_expm1_f64(f64) -> f64
 274   // CHECK-LABEL: func @math_expm1
 275   func.func @math_expm1(%arg_f16 : f16, %arg_f32 : f32, %arg_f64 : f64) -> (f16, f32, f64) {
 276     %result16 = math.expm1 %arg_f16 : f16
 277     // CHECK: llvm.call @__ocml_expm1_f16(%{{.*}}) : (f16) -> f16
 278     %result32 = math.expm1 %arg_f32 : f32
 279     // CHECK: llvm.call @__ocml_expm1_f32(%{{.*}}) : (f32) -> f32
 280     %result64 = math.expm1 %arg_f64 : f64
 281     // CHECK: llvm.call @__ocml_expm1_f64(%{{.*}}) : (f64) -> f64
 282     func.return %result16, %result32, %result64 : f16, f32, f64
 283   }
 284 }
 285
 286 // -----
 287
 288 module @test_module {
 289   // CHECK: llvm.func @__ocml_floor_f16(f16) -> f16
 290   // CHECK: llvm.func @__ocml_floor_f32(f32) -> f32
 291   // CHECK: llvm.func @__ocml_floor_f64(f64) -> f64
 292   // CHECK-LABEL: func @math_floor
 293   func.func @math_floor(%arg_f16 : f16, %arg_f32 : f32, %arg_f64 : f64) -> (f16, f32, f64) {
 294     %result16 = math.floor %arg_f16 : f16
 295     // CHECK: llvm.call @__ocml_floor_f16(%{{.*}}) : (f16) -> f16
 296     %result32 = math.floor %arg_f32 : f32
 297     // CHECK: llvm.call @__ocml_floor_f32(%{{.*}}) : (f32) -> f32
 298     %result64 = math.floor %arg_f64 : f64
 299     // CHECK: llvm.call @__ocml_floor_f64(%{{.*}}) : (f64) -> f64
 300     func.return %result16, %result32, %result64 : f16, f32, f64
 301   }
 302 }
 303
 304 // -----
 305
 306 module @test_module {
 307   // CHECK: llvm.func @__ocml_log_f16(f16) -> f16
 308   // CHECK: llvm.func @__ocml_log_f64(f64) -> f64
 309   // CHECK-LABEL: func @math_log
 310   func.func @math_log(%arg_f16 : f16, %arg_f64 : f64) -> (f16, f64) {
 311     %result16 = math.log %arg_f16 : f16
 312     // CHECK: llvm.call @__ocml_log_f16(%{{.*}}) : (f16) -> f16
 313     %result64 = math.log %arg_f64 : f64
 314     // CHECK: llvm.call @__ocml_log_f64(%{{.*}}) : (f64) -> f64
 315     func.return %result16, %result64 : f16, f64
 316   }
 317 }
 318
 319 // -----
 320
 321 module @test_module {
 322   // CHECK: llvm.func @__ocml_log10_f16(f16) -> f16
 323   // CHECK: llvm.func @__ocml_log10_f32(f32) -> f32
 324   // CHECK: llvm.func @__ocml_log10_f64(f64) -> f64
 325   // CHECK-LABEL: func @math_log10
 326   func.func @math_log10(%arg_f16 : f16, %arg_f32 : f32, %arg_f64 : f64) -> (f16, f32, f64) {
 327     %result16 = math.log10 %arg_f16 : f16
 328     // CHECK: llvm.call @__ocml_log10_f16(%{{.*}}) : (f16) -> f16
 329     %result32 = math.log10 %arg_f32 : f32
 330     // CHECK: llvm.call @__ocml_log10_f32(%{{.*}}) : (f32) -> f32
 331     %result64 = math.log10 %arg_f64 : f64
 332     // CHECK: llvm.call @__ocml_log10_f64(%{{.*}}) : (f64) -> f64
 333     func.return %result16, %result32, %result64 : f16, f32, f64
 334   }
 335 }
 336
 337 // -----
 338
 339 module @test_module {
 340   // CHECK: llvm.func @__ocml_log1p_f16(f16) -> f16
 341   // CHECK: llvm.func @__ocml_log1p_f32(f32) -> f32
 342   // CHECK: llvm.func @__ocml_log1p_f64(f64) -> f64
 343   // CHECK-LABEL: func @math_log1p
 344   func.func @math_log1p(%arg_f16 : f16, %arg_f32 : f32, %arg_f64 : f64) -> (f16, f32, f64) {
 345     %result16 = math.log1p %arg_f16 : f16
 346     // CHECK: llvm.call @__ocml_log1p_f16(%{{.*}}) : (f16) -> f16
 347     %result32 = math.log1p %arg_f32 : f32
 348     // CHECK: llvm.call @__ocml_log1p_f32(%{{.*}}) : (f32) -> f32
 349     %result64 = math.log1p %arg_f64 : f64
 350     // CHECK: llvm.call @__ocml_log1p_f64(%{{.*}}) : (f64) -> f64
 351     func.return %result16, %result32, %result64 : f16, f32, f64
 352   }
 353 }
 354
 355 // -----
 356
 357 module @test_module {
 358   // CHECK: llvm.func @__ocml_pow_f16(f16, f16) -> f16
 359   // CHECK: llvm.func @__ocml_pow_f32(f32, f32) -> f32
 360   // CHECK: llvm.func @__ocml_pow_f64(f64, f64) -> f64
 361   // CHECK-LABEL: func @math_powf
 362   func.func @math_powf(%arg_f16 : f16, %arg_f32 : f32, %arg_f64 : f64) -> (f16, f32, f64) {
 363     %result16 = math.powf %arg_f16, %arg_f16 : f16
 364     // CHECK: llvm.call @__ocml_pow_f16(%{{.*}}, %{{.*}}) : (f16, f16) -> f16
 365     %result32 = math.powf %arg_f32, %arg_f32 : f32
 366     // CHECK: llvm.call @__ocml_pow_f32(%{{.*}}, %{{.*}}) : (f32, f32) -> f32
 367     %result64 = math.powf %arg_f64, %arg_f64 : f64
 368     // CHECK: llvm.call @__ocml_pow_f64(%{{.*}}, %{{.*}}) : (f64, f64) -> f64
 369     func.return %result16, %result32, %result64 : f16, f32, f64
 370   }
 371 }
 372
 373 // -----
 374
 375 module @test_module {
 376   // CHECK: llvm.func @__ocml_rsqrt_f16(f16) -> f16
 377   // CHECK: llvm.func @__ocml_rsqrt_f32(f32) -> f32
 378   // CHECK: llvm.func @__ocml_rsqrt_f64(f64) -> f64
 379   // CHECK-LABEL: func @math_rsqrt
 380   func.func @math_rsqrt(%arg_f16 : f16, %arg_f32 : f32, %arg_f64 : f64) -> (f16, f32, f64) {
 381     %result16 = math.rsqrt %arg_f16 : f16
 382     // CHECK: llvm.call @__ocml_rsqrt_f16(%{{.*}}) : (f16) -> f16
 383     %result32 = math.rsqrt %arg_f32 : f32
 384     // CHECK: llvm.call @__ocml_rsqrt_f32(%{{.*}}) : (f32) -> f32
 385     %result64 = math.rsqrt %arg_f64 : f64
 386     // CHECK: llvm.call @__ocml_rsqrt_f64(%{{.*}}) : (f64) -> f64
 387     func.return %result16, %result32, %result64 : f16, f32, f64
 388   }
 389 }
 390
 391 // -----
 392
 393 module @test_module {
 394   // CHECK: llvm.func @__ocml_sin_f16(f16) -> f16
 395   // CHECK: llvm.func @__ocml_sin_f32(f32) -> f32
 396   // CHECK: llvm.func @__ocml_sin_f64(f64) -> f64
 397   // CHECK-LABEL: func @math_sin
 398   func.func @math_sin(%arg_f16 : f16, %arg_f32 : f32, %arg_f64 : f64) -> (f16, f32, f64) {
 399     %result16 = math.sin %arg_f16 : f16
 400     // CHECK: llvm.call @__ocml_sin_f16(%{{.*}}) : (f16) -> f16
 401     %result32 = math.sin %arg_f32 : f32
 402     // CHECK: llvm.call @__ocml_sin_f32(%{{.*}}) : (f32) -> f32
 403     %result64 = math.sin %arg_f64 : f64
 404     // CHECK: llvm.call @__ocml_sin_f64(%{{.*}}) : (f64) -> f64
 405     func.return %result16, %result32, %result64 : f16, f32, f64
 406   }
 407 }
 408
 409 // -----
 410
 411 module @test_module {
 412   // CHECK: llvm.func @__ocml_tanh_f16(f16) -> f16
 413   // CHECK: llvm.func @__ocml_tanh_f32(f32) -> f32
 414   // CHECK: llvm.func @__ocml_tanh_f64(f64) -> f64
 415   // CHECK-LABEL: func @math_tanh
 416   func.func @math_tanh(%arg_f16 : f16, %arg_f32 : f32, %arg_f64 : f64) -> (f16, f32, f64) {
 417     %result16 = math.tanh %arg_f16 : f16
 418     // CHECK: llvm.call @__ocml_tanh_f16(%{{.*}}) : (f16) -> f16
 419     %result32 = math.tanh %arg_f32 : f32
 420     // CHECK: llvm.call @__ocml_tanh_f32(%{{.*}}) : (f32) -> f32
 421     %result64 = math.tanh %arg_f64 : f64
 422     // CHECK: llvm.call @__ocml_tanh_f64(%{{.*}}) : (f64) -> f64
 423     func.return %result16, %result32, %result64 : f16, f32, f64
 424   }
 425 }
 426
 427 // -----
 428
 429 module @test_module {
 430   // CHECK: llvm.func @__ocml_tan_f16(f16) -> f16
 431   // CHECK: llvm.func @__ocml_tan_f32(f32) -> f32
 432   // CHECK: llvm.func @__ocml_tan_f64(f64) -> f64
 433   // CHECK-LABEL: func @math_tan
 434   func.func @math_tan(%arg_f16 : f16, %arg_f32 : f32, %arg_f64 : f64) -> (f16, f32, f64) {
 435     %result16 = math.tan %arg_f16 : f16
 436     // CHECK: llvm.call @__ocml_tan_f16(%{{.*}}) : (f16) -> f16
 437     %result32 = math.tan %arg_f32 : f32
 438     // CHECK: llvm.call @__ocml_tan_f32(%{{.*}}) : (f32) -> f32
 439     %result64 = math.tan %arg_f64 : f64
 440     // CHECK: llvm.call @__ocml_tan_f64(%{{.*}}) : (f64) -> f64
 441     func.return %result16, %result32, %result64 : f16, f32, f64
 442   }
 443 }
 444
 445 // -----
 446
 447 module @test_module {
 448   // CHECK: llvm.func @__ocml_erf_f16(f16) -> f16
 449   // CHECK: llvm.func @__ocml_erf_f32(f32) -> f32
 450   // CHECK: llvm.func @__ocml_erf_f64(f64) -> f64
 451   // CHECK-LABEL: func @math_erf
 452   func.func @math_erf(%arg_f16 : f16, %arg_f32 : f32, %arg_f64 : f64) -> (f16, f32, f64) {
 453     %result16 = math.erf %arg_f16 : f16
 454     // CHECK: llvm.call @__ocml_erf_f16(%{{.*}}) : (f16) -> f16
 455     %result32 = math.erf %arg_f32 : f32
 456     // CHECK: llvm.call @__ocml_erf_f32(%{{.*}}) : (f32) -> f32
 457     %result64 = math.erf %arg_f64 : f64
 458     // CHECK: llvm.call @__ocml_erf_f64(%{{.*}}) : (f64) -> f64
 459     func.return %result16, %result32, %result64 : f16, f32, f64
 460   }
 461 }
 462
 463 // -----
 464
 465 module @test_module {
 466   // CHECK: llvm.func @__ocml_sin_f16(f16) -> f16
 467   // CHECK: llvm.func @__ocml_sin_f32(f32) -> f32
 468   // CHECK: llvm.func @__ocml_sin_f64(f64) -> f64
 469   // CHECK-LABEL: func @math_casting
 470   func.func @math_casting(%arg_f16 : f16, %arg_f32 : f32, %arg_f64 : f64, %arg_bf16 : bf16) -> (f16, f32, f64, bf16) {
 471     %resultf16 = math.sin %arg_f16 : f16
 472     // CHECK: llvm.call @__ocml_sin_f16(%{{.*}}) : (f16) -> f16
 473     %resultf32 = math.sin %arg_f32 : f32
 474     // CHECK: llvm.call @__ocml_sin_f32(%{{.*}}) : (f32) -> f32
 475     %resultf64 = math.sin %arg_f64 : f64
 476     // CHECK: llvm.call @__ocml_sin_f64(%{{.*}}) : (f64) -> f64
 477     %resultbf16 = math.sin %arg_bf16 : bf16
 478     // CHECK: llvm.fpext %{{.*}} : bf16 to f32
 479     // CHECK-NEXT: llvm.call @__ocml_sin_f32(%{{.*}}) : (f32) -> f32
 480     // CHECK-NEXT: llvm.fptrunc %{{.*}} : f32 to bf16
 481     func.return %resultf16, %resultf32, %resultf64, %resultbf16 : f16, f32, f64, bf16
 482   }
 483 }
 484
 485 // -----
 486
 487 // Math operation not inside function
 488 // Ensure it not crash
 489
 490 module {
 491   "test.some_op_with_region"() ({
 492   ^bb0(%arg0: f64):
 493     // CHECK: math.atan
 494     %0 = math.atan %arg0 : f64
 495     "test.possible_terminator"() : () -> ()
 496   }) : () -> ()
 497 }