/src/test/assembly/asm/bpf-types.rs

https://gitlab.com/rust-lang/rust · Rust · 154 lines · 67 code · 23 blank · 64 comment · 5 complexity · 52abb0f690098105635c9c440234b863 MD5 · raw file 

    

  1. // min-llvm-version: 13.0
    2. 

  2. // assembly-output: emit-asm
    3. 

  3. // compile-flags: --target bpfel-unknown-none -C target_feature=+alu32
    4. 

  4. // needs-llvm-components: bpf
    5. 

  5. 

  6. #![feature(no_core, lang_items, rustc_attrs, repr_simd, asm_sym, asm_experimental_arch)]
    7. 

  7. #![crate_type = "rlib"]
    8. 

  8. #![no_core]
    9. 

  9. #![allow(asm_sub_register, non_camel_case_types)]
    10. 

  10. 

  11. #[rustc_builtin_macro]
    12. 

  12. macro_rules! asm {
    13. 

  13.     () => {};
    14. 

  14. }
    15. 

  15. #[rustc_builtin_macro]
    16. 

  16. macro_rules! concat {
    17. 

  17.     () => {};
    18. 

  18. }
    19. 

  19. #[rustc_builtin_macro]
    20. 

  20. macro_rules! stringify {
    21. 

  21.     () => {};
    22. 

  22. }
    23. 

  23. 

  24. #[lang = "sized"]
    25. 

  25. trait Sized {}
    26. 

  26. #[lang = "copy"]
    27. 

  27. trait Copy {}
    28. 

  28. 

  29. type ptr = *const u64;
    30. 

  30. 

  31. impl Copy for i8 {}
    32. 

  32. impl Copy for i16 {}
    33. 

  33. impl Copy for i32 {}
    34. 

  34. impl Copy for i64 {}
    35. 

  35. impl Copy for ptr {}
    36. 

  36. 

  37. macro_rules! check {
    38. 

  38.     ($func:ident $ty:ident $class:ident) => {
    39. 

  39.         #[no_mangle]
    40. 

  40.         pub unsafe fn $func(x: $ty) -> $ty {
    41. 

  41.             let y;
    42. 

  42.             asm!("{} = {}", out($class) y, in($class) x);
    43. 

  43.             y
    44. 

  44.         }
    45. 

  45.     };
    46. 

  46. }
    47. 

  47. 

  48. macro_rules! check_reg {
    49. 

  49.     ($func:ident $ty:ident $reg:tt) => {
    50. 

  50.         #[no_mangle]
    51. 

  51.         pub unsafe fn $func(x: $ty) -> $ty {
    52. 

  52.             let y;
    53. 

  53.             asm!(concat!($reg, " = ", $reg), lateout($reg) y, in($reg) x);
    54. 

  54.             y
    55. 

  55.         }
    56. 

  56.     };
    57. 

  57. }
    58. 

  58. 

  59. extern "C" {
    60. 

  60.     fn extern_func();
    61. 

  61. }
    62. 

  62. 

  63. // CHECK-LABEL: sym_fn
    64. 

  64. // CHECK: #APP
    65. 

  65. // CHECK: call extern_func
    66. 

  66. // CHECK: #NO_APP
    67. 

  67. #[no_mangle]
    68. 

  68. pub unsafe fn sym_fn() {
    69. 

  69.     asm!("call {}", sym extern_func);
    70. 

  70. }
    71. 

  71. 

  72. // CHECK-LABEL: reg_i8:
    73. 

  73. // CHECK: #APP
    74. 

  74. // CHECK: r{{[0-9]+}} = r{{[0-9]+}}
    75. 

  75. // CHECK: #NO_APP
    76. 

  76. check!(reg_i8 i8 reg);
    77. 

  77. 

  78. // CHECK-LABEL: reg_i16:
    79. 

  79. // CHECK: #APP
    80. 

  80. // CHECK: r{{[0-9]+}} = r{{[0-9]+}}
    81. 

  81. // CHECK: #NO_APP
    82. 

  82. check!(reg_i16 i16 reg);
    83. 

  83. 

  84. // CHECK-LABEL: reg_i32:
    85. 

  85. // CHECK: #APP
    86. 

  86. // CHECK: r{{[0-9]+}} = r{{[0-9]+}}
    87. 

  87. // CHECK: #NO_APP
    88. 

  88. check!(reg_i32 i32 reg);
    89. 

  89. 

  90. // CHECK-LABEL: reg_i64:
    91. 

  91. // CHECK: #APP
    92. 

  92. // CHECK: r{{[0-9]+}} = r{{[0-9]+}}
    93. 

  93. // CHECK: #NO_APP
    94. 

  94. check!(reg_i64 i64 reg);
    95. 

  95. 

  96. // CHECK-LABEL: wreg_i8:
    97. 

  97. // CHECK: #APP
    98. 

  98. // CHECK: w{{[0-9]+}} = w{{[0-9]+}}
    99. 

  99. // CHECK: #NO_APP
    100. 

  100. check!(wreg_i8 i8 wreg);
    101. 

  101. 

  102. // CHECK-LABEL: wreg_i16:
    103. 

  103. // CHECK: #APP
    104. 

  104. // CHECK: w{{[0-9]+}} = w{{[0-9]+}}
    105. 

  105. // CHECK: #NO_APP
    106. 

  106. check!(wreg_i16 i16 wreg);
    107. 

  107. 

  108. // CHECK-LABEL: wreg_i32:
    109. 

  109. // CHECK: #APP
    110. 

  110. // CHECK: w{{[0-9]+}} = w{{[0-9]+}}
    111. 

  111. // CHECK: #NO_APP
    112. 

  112. check!(wreg_i32 i32 wreg);
    113. 

  113. 

  114. // CHECK-LABEL: r0_i8:
    115. 

  115. // CHECK: #APP
    116. 

  116. // CHECK: r0 = r0
    117. 

  117. // CHECK: #NO_APP
    118. 

  118. check_reg!(r0_i8 i8 "r0");
    119. 

  119. 

  120. // CHECK-LABEL: r0_i16:
    121. 

  121. // CHECK: #APP
    122. 

  122. // CHECK: r0 = r0
    123. 

  123. // CHECK: #NO_APP
    124. 

  124. check_reg!(r0_i16 i16 "r0");
    125. 

  125. 

  126. // CHECK-LABEL: r0_i32:
    127. 

  127. // CHECK: #APP
    128. 

  128. // CHECK: r0 = r0
    129. 

  129. // CHECK: #NO_APP
    130. 

  130. check_reg!(r0_i32 i32 "r0");
    131. 

  131. 

  132. // CHECK-LABEL: r0_i64:
    133. 

  133. // CHECK: #APP
    134. 

  134. // CHECK: r0 = r0
    135. 

  135. // CHECK: #NO_APP
    136. 

  136. check_reg!(r0_i64 i64 "r0");
    137. 

  137. 

  138. // CHECK-LABEL: w0_i8:
    139. 

  139. // CHECK: #APP
    140. 

  140. // CHECK: w0 = w0
    141. 

  141. // CHECK: #NO_APP
    142. 

  142. check_reg!(w0_i8 i8 "w0");
    143. 

  143. 

  144. // CHECK-LABEL: w0_i16:
    145. 

  145. // CHECK: #APP
    146. 

  146. // CHECK: w0 = w0
    147. 

  147. // CHECK: #NO_APP
    148. 

  148. check_reg!(w0_i16 i16 "w0");
    149. 

  149. 

  150. // CHECK-LABEL: w0_i32:
    151. 

  151. // CHECK: #APP
    152. 

  152. // CHECK: w0 = w0
    153. 

  153. // CHECK: #NO_APP
    154. 

  154. check_reg!(w0_i32 i32 "w0");
    155.