/src/test/codegen/simd-intrinsic/simd-intrinsic-float-exp2.rs

https://gitlab.com/rust-lang/rust · Rust · 92 lines · 60 code · 17 blank · 15 comment · 0 complexity · 99b74cdf784dc0e7d1d7464a11ce546d MD5 · raw file 

    

  1. // compile-flags: -C no-prepopulate-passes
    2. 

  2. 

  3. #![crate_type = "lib"]
    4. 

  4. 

  5. #![feature(repr_simd, platform_intrinsics)]
    6. 

  6. #![allow(non_camel_case_types)]
    7. 

  7. 

  8. #[repr(simd)]
    9. 

  9. #[derive(Copy, Clone, PartialEq, Debug)]
    10. 

  10. pub struct f32x2(pub f32, pub f32);
    11. 

  11. 

  12. #[repr(simd)]
    13. 

  13. #[derive(Copy, Clone, PartialEq, Debug)]
    14. 

  14. pub struct f32x4(pub f32, pub f32, pub f32, pub f32);
    15. 

  15. 

  16. #[repr(simd)]
    17. 

  17. #[derive(Copy, Clone, PartialEq, Debug)]
    18. 

  18. pub struct f32x8(pub f32, pub f32, pub f32, pub f32,
    19. 

  19.                  pub f32, pub f32, pub f32, pub f32);
    20. 

  20. 

  21. #[repr(simd)]
    22. 

  22. #[derive(Copy, Clone, PartialEq, Debug)]
    23. 

  23. pub struct f32x16(pub f32, pub f32, pub f32, pub f32,
    24. 

  24.                   pub f32, pub f32, pub f32, pub f32,
    25. 

  25.                   pub f32, pub f32, pub f32, pub f32,
    26. 

  26.                   pub f32, pub f32, pub f32, pub f32);
    27. 

  27. 

  28. extern "platform-intrinsic" {
    29. 

  29.     fn simd_fexp2<T>(x: T) -> T;
    30. 

  30. }
    31. 

  31. 

  32. // CHECK-LABEL: @exp2_32x2
    33. 

  33. #[no_mangle]
    34. 

  34. pub unsafe fn exp2_32x2(a: f32x2) -> f32x2 {
    35. 

  35.     // CHECK: call <2 x float> @llvm.exp2.v2f32
    36. 

  36.     simd_fexp2(a)
    37. 

  37. }
    38. 

  38. 

  39. // CHECK-LABEL: @exp2_32x4
    40. 

  40. #[no_mangle]
    41. 

  41. pub unsafe fn exp2_32x4(a: f32x4) -> f32x4 {
    42. 

  42.     // CHECK: call <4 x float> @llvm.exp2.v4f32
    43. 

  43.     simd_fexp2(a)
    44. 

  44. }
    45. 

  45. 

  46. // CHECK-LABEL: @exp2_32x8
    47. 

  47. #[no_mangle]
    48. 

  48. pub unsafe fn exp2_32x8(a: f32x8) -> f32x8 {
    49. 

  49.     // CHECK: call <8 x float> @llvm.exp2.v8f32
    50. 

  50.     simd_fexp2(a)
    51. 

  51. }
    52. 

  52. 

  53. // CHECK-LABEL: @exp2_32x16
    54. 

  54. #[no_mangle]
    55. 

  55. pub unsafe fn exp2_32x16(a: f32x16) -> f32x16 {
    56. 

  56.     // CHECK: call <16 x float> @llvm.exp2.v16f32
    57. 

  57.     simd_fexp2(a)
    58. 

  58. }
    59. 

  59. 

  60. #[repr(simd)]
    61. 

  61. #[derive(Copy, Clone, PartialEq, Debug)]
    62. 

  62. pub struct f64x2(pub f64, pub f64);
    63. 

  63. 

  64. #[repr(simd)]
    65. 

  65. #[derive(Copy, Clone, PartialEq, Debug)]
    66. 

  66. pub struct f64x4(pub f64, pub f64, pub f64, pub f64);
    67. 

  67. 

  68. #[repr(simd)]
    69. 

  69. #[derive(Copy, Clone, PartialEq, Debug)]
    70. 

  70. pub struct f64x8(pub f64, pub f64, pub f64, pub f64,
    71. 

  71.                  pub f64, pub f64, pub f64, pub f64);
    72. 

  72. 

  73. // CHECK-LABEL: @exp2_64x4
    74. 

  74. #[no_mangle]
    75. 

  75. pub unsafe fn exp2_64x4(a: f64x4) -> f64x4 {
    76. 

  76.     // CHECK: call <4 x double> @llvm.exp2.v4f64
    77. 

  77.     simd_fexp2(a)
    78. 

  78. }
    79. 

  79. 

  80. // CHECK-LABEL: @exp2_64x2
    81. 

  81. #[no_mangle]
    82. 

  82. pub unsafe fn exp2_64x2(a: f64x2) -> f64x2 {
    83. 

  83.     // CHECK: call <2 x double> @llvm.exp2.v2f64
    84. 

  84.     simd_fexp2(a)
    85. 

  85. }
    86. 

  86. 

  87. // CHECK-LABEL: @exp2_64x8
    88. 

  88. #[no_mangle]
    89. 

  89. pub unsafe fn exp2_64x8(a: f64x8) -> f64x8 {
    90. 

  90.     // CHECK: call <8 x double> @llvm.exp2.v8f64
    91. 

  91.     simd_fexp2(a)
    92. 

  92. }
    93.