/src/test/codegen/wasm_casts_trapping.rs

https://gitlab.com/rust-lang/rust · Rust · 157 lines · 73 code · 18 blank · 66 comment · 0 complexity · 358a33b2624b230beae7bde49e109b38 MD5 · raw file 

    

  1. // only-wasm32
    2. 

  2. // compile-flags: -C target-feature=-nontrapping-fptoint
    3. 

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

  4. 

  5. // CHECK-LABEL: @cast_f64_i64
    6. 

  6. #[no_mangle]
    7. 

  7. pub fn cast_f64_i64(a: f64) -> i64 {
    8. 

  8.     // CHECK-NOT: fptosi double {{.*}} to i64
    9. 

  9.     // CHECK-NOT: select i1 {{.*}}, i64 {{.*}}, i64 {{.*}}
    10. 

  10.     // CHECK: {{.*}} call {{.*}} @llvm.fptosi.sat.i64.f64{{.*}}
    11. 

  11.     a as _
    12. 

  12. }
    13. 

  13. 

  14. // CHECK-LABEL: @cast_f64_i32
    15. 

  15. #[no_mangle]
    16. 

  16. pub fn cast_f64_i32(a: f64) -> i32 {
    17. 

  17.     // CHECK-NOT: fptosi double {{.*}} to i32
    18. 

  18.     // CHECK-NOT: select i1 {{.*}}, i32 {{.*}}, i32 {{.*}}
    19. 

  19.     // CHECK: {{.*}} call {{.*}} @llvm.fptosi.sat.i32.f64{{.*}}
    20. 

  20.     a as _
    21. 

  21. }
    22. 

  22. 

  23. // CHECK-LABEL: @cast_f32_i64
    24. 

  24. #[no_mangle]
    25. 

  25. pub fn cast_f32_i64(a: f32) -> i64 {
    26. 

  26.     // CHECK-NOT: fptosi float {{.*}} to i64
    27. 

  27.     // CHECK-NOT: select i1 {{.*}}, i64 {{.*}}, i64 {{.*}}
    28. 

  28.     // CHECK: {{.*}} call {{.*}} @llvm.fptosi.sat.i64.f32{{.*}}
    29. 

  29.     a as _
    30. 

  30. }
    31. 

  31. 

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

  33. #[no_mangle]
    34. 

  34. pub fn cast_f32_i32(a: f32) -> i32 {
    35. 

  35.     // CHECK-NOT: fptosi float {{.*}} to i32
    36. 

  36.     // CHECK-NOT: select i1 {{.*}}, i32 {{.*}}, i32 {{.*}}
    37. 

  37.     // CHECK: {{.*}} call {{.*}} @llvm.fptosi.sat.i32.f32{{.*}}
    38. 

  38.     a as _
    39. 

  39. }
    40. 

  40. 

  41. // CHECK-LABEL: @cast_f64_u64
    42. 

  42. #[no_mangle]
    43. 

  43. pub fn cast_f64_u64(a: f64) -> u64 {
    44. 

  44.     // CHECK-NOT: fptoui double {{.*}} to i64
    45. 

  45.     // CHECK-NOT: select i1 {{.*}}, i64 {{.*}}, i64 {{.*}}
    46. 

  46.     // CHECK: {{.*}} call {{.*}} @llvm.fptoui.sat.i64.f64{{.*}}
    47. 

  47.     a as _
    48. 

  48. }
    49. 

  49. 

  50. // CHECK-LABEL: @cast_f64_u32
    51. 

  51. #[no_mangle]
    52. 

  52. pub fn cast_f64_u32(a: f64) -> u32 {
    53. 

  53.     // CHECK-NOT: fptoui double {{.*}} to i32
    54. 

  54.     // CHECK-NOT: select i1 {{.*}}, i32 {{.*}}, i32 {{.*}}
    55. 

  55.     // CHECK: {{.*}} call {{.*}} @llvm.fptoui.sat.i32.f64{{.*}}
    56. 

  56.     a as _
    57. 

  57. }
    58. 

  58. 

  59. // CHECK-LABEL: @cast_f32_u64
    60. 

  60. #[no_mangle]
    61. 

  61. pub fn cast_f32_u64(a: f32) -> u64 {
    62. 

  62.     // CHECK-NOT: fptoui float {{.*}} to i64
    63. 

  63.     // CHECK-NOT: select i1 {{.*}}, i64 {{.*}}, i64 {{.*}}
    64. 

  64.     // CHECK: {{.*}} call {{.*}} @llvm.fptoui.sat.i64.f32{{.*}}
    65. 

  65.     a as _
    66. 

  66. }
    67. 

  67. 

  68. // CHECK-LABEL: @cast_f32_u32
    69. 

  69. #[no_mangle]
    70. 

  70. pub fn cast_f32_u32(a: f32) -> u32 {
    71. 

  71.     // CHECK-NOT: fptoui float {{.*}} to i32
    72. 

  72.     // CHECK-NOT: select i1 {{.*}}, i32 {{.*}}, i32 {{.*}}
    73. 

  73.     // CHECK: {{.*}} call {{.*}} @llvm.fptoui.sat.i32.f32{{.*}}
    74. 

  74.     a as _
    75. 

  75. }
    76. 

  76. 

  77. // CHECK-LABEL: @cast_f32_u8
    78. 

  78. #[no_mangle]
    79. 

  79. pub fn cast_f32_u8(a: f32) -> u8 {
    80. 

  80.     // CHECK-NOT: fptoui float {{.*}} to i8
    81. 

  81.     // CHECK-NOT: select i1 {{.*}}, i8 {{.*}}, i8 {{.*}}
    82. 

  82.     // CHECK: {{.*}} call {{.*}} @llvm.fptoui.sat.i8.f32{{.*}}
    83. 

  83.     a as _
    84. 

  84. }
    85. 

  85. 

  86. // CHECK-LABEL: @cast_unchecked_f64_i64
    87. 

  87. #[no_mangle]
    88. 

  88. pub unsafe fn cast_unchecked_f64_i64(a: f64) -> i64 {
    89. 

  89.     // CHECK: {{.*}} call {{.*}} @llvm.wasm.trunc.signed.{{.*}}
    90. 

  90.     // CHECK-NEXT: ret i64 {{.*}}
    91. 

  91.     a.to_int_unchecked()
    92. 

  92. }
    93. 

  93. 

  94. // CHECK-LABEL: @cast_unchecked_f64_i32
    95. 

  95. #[no_mangle]
    96. 

  96. pub unsafe fn cast_unchecked_f64_i32(a: f64) -> i32 {
    97. 

  97.     // CHECK: {{.*}} call {{.*}} @llvm.wasm.trunc.signed.{{.*}}
    98. 

  98.     // CHECK-NEXT: ret i32 {{.*}}
    99. 

  99.     a.to_int_unchecked()
    100. 

  100. }
    101. 

  101. 

  102. // CHECK-LABEL: @cast_unchecked_f32_i64
    103. 

  103. #[no_mangle]
    104. 

  104. pub unsafe fn cast_unchecked_f32_i64(a: f32) -> i64 {
    105. 

  105.     // CHECK: {{.*}} call {{.*}} @llvm.wasm.trunc.signed.{{.*}}
    106. 

  106.     // CHECK-NEXT: ret i64 {{.*}}
    107. 

  107.     a.to_int_unchecked()
    108. 

  108. }
    109. 

  109. 

  110. // CHECK-LABEL: @cast_unchecked_f32_i32
    111. 

  111. #[no_mangle]
    112. 

  112. pub unsafe fn cast_unchecked_f32_i32(a: f32) -> i32 {
    113. 

  113.     // CHECK: {{.*}} call {{.*}} @llvm.wasm.trunc.signed.{{.*}}
    114. 

  114.     // CHECK-NEXT: ret i32 {{.*}}
    115. 

  115.     a.to_int_unchecked()
    116. 

  116. }
    117. 

  117. 

  118. // CHECK-LABEL: @cast_unchecked_f64_u64
    119. 

  119. #[no_mangle]
    120. 

  120. pub unsafe fn cast_unchecked_f64_u64(a: f64) -> u64 {
    121. 

  121.     // CHECK: {{.*}} call {{.*}} @llvm.wasm.trunc.unsigned.{{.*}}
    122. 

  122.     // CHECK-NEXT: ret i64 {{.*}}
    123. 

  123.     a.to_int_unchecked()
    124. 

  124. }
    125. 

  125. 

  126. // CHECK-LABEL: @cast_unchecked_f64_u32
    127. 

  127. #[no_mangle]
    128. 

  128. pub unsafe fn cast_unchecked_f64_u32(a: f64) -> u32 {
    129. 

  129.     // CHECK: {{.*}} call {{.*}} @llvm.wasm.trunc.unsigned.{{.*}}
    130. 

  130.     // CHECK-NEXT: ret i32 {{.*}}
    131. 

  131.     a.to_int_unchecked()
    132. 

  132. }
    133. 

  133. 

  134. // CHECK-LABEL: @cast_unchecked_f32_u64
    135. 

  135. #[no_mangle]
    136. 

  136. pub unsafe fn cast_unchecked_f32_u64(a: f32) -> u64 {
    137. 

  137.     // CHECK: {{.*}} call {{.*}} @llvm.wasm.trunc.unsigned.{{.*}}
    138. 

  138.     // CHECK-NEXT: ret i64 {{.*}}
    139. 

  139.     a.to_int_unchecked()
    140. 

  140. }
    141. 

  141. 

  142. // CHECK-LABEL: @cast_unchecked_f32_u32
    143. 

  143. #[no_mangle]
    144. 

  144. pub unsafe fn cast_unchecked_f32_u32(a: f32) -> u32 {
    145. 

  145.     // CHECK: {{.*}} call {{.*}} @llvm.wasm.trunc.unsigned.{{.*}}
    146. 

  146.     // CHECK-NEXT: ret i32 {{.*}}
    147. 

  147.     a.to_int_unchecked()
    148. 

  148. }
    149. 

  149. 

  150. // CHECK-LABEL: @cast_unchecked_f32_u8
    151. 

  151. #[no_mangle]
    152. 

  152. pub unsafe fn cast_unchecked_f32_u8(a: f32) -> u8 {
    153. 

  153.     // CHECK-NOT: {{.*}} call {{.*}} @llvm.wasm.trunc.{{.*}}
    154. 

  154.     // CHECK: fptoui float {{.*}} to i8
    155. 

  155.     // CHECK-NEXT: ret i8 {{.*}}
    156. 

  156.     a.to_int_unchecked()
    157. 

  157. }
    158.