Auto merge of #68404 - Amanieu:llvm-asm, r=estebank

Rename asm! to llvm_asm!

As per rust-lang/rfcs#2843, this PR renames `asm!` to `llvm_asm!`. It also renames the compiler's internal `InlineAsm` data structures to `LlvmInlineAsm` in preparation for the new `asm!` functionality specified in rust-lang/rfcs#2850.

This PR doesn't actually deprecate `asm!` yet, it just makes it redirect to `llvm_asm!`. This is necessary because we first need to update the submodules (in particular stdarch) to use `llvm_asm!`.

Author: bors

src/doc/unstable-book/src/library-features/asm.md renamed to src/doc/unstable-book/src/library-features/llvm-asm.md

@@ -1,25 +1,25 @@
-# `asm`
+# `llvm_asm`
 
-The tracking issue for this feature is: [#29722]
+The tracking issue for this feature is: [#70173]
 
-[#29722]: https://github.com/rust-lang/rust/issues/29722
+[#70173]: https://github.com/rust-lang/rust/issues/70173
 
 ------------------------
 
 For extremely low-level manipulations and performance reasons, one
 might wish to control the CPU directly. Rust supports using inline
-assembly to do this via the `asm!` macro.
+assembly to do this via the `llvm_asm!` macro.
 
 ```rust,ignore
-asm!(assembly template
+llvm_asm!(assembly template
    : output operands
    : input operands
    : clobbers
    : options
    );
 ```
 
-Any use of `asm` is feature gated (requires `#![feature(asm)]` on the
+Any use of `llvm_asm` is feature gated (requires `#![feature(llvm_asm)]` on the
 crate to allow) and of course requires an `unsafe` block.
 
 > **Note**: the examples here are given in x86/x86-64 assembly, but
@@ -31,12 +31,12 @@ The `assembly template` is the only required parameter and must be a
 literal string (i.e. `""`)
 
 ```rust
-#![feature(asm)]
+#![feature(llvm_asm)]
 
 #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
 fn foo() {
     unsafe {
-        asm!("NOP");
+        llvm_asm!("NOP");
     }
 }
 
@@ -51,16 +51,16 @@ fn main() {
 }
 ```
 
-(The `feature(asm)` and `#[cfg]`s are omitted from now on.)
+(The `feature(llvm_asm)` and `#[cfg]`s are omitted from now on.)
 
 Output operands, input operands, clobbers and options are all optional
 but you must add the right number of `:` if you skip them:
 
 ```rust
-# #![feature(asm)]
+# #![feature(llvm_asm)]
 # #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
 # fn main() { unsafe {
-asm!("xor %eax, %eax"
+llvm_asm!("xor %eax, %eax"
     :
     :
     : "eax"
@@ -73,10 +73,10 @@ asm!("xor %eax, %eax"
 Whitespace also doesn't matter:
 
 ```rust
-# #![feature(asm)]
+# #![feature(llvm_asm)]
 # #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
 # fn main() { unsafe {
-asm!("xor %eax, %eax" ::: "eax");
+llvm_asm!("xor %eax, %eax" ::: "eax");
 # } }
 # #[cfg(not(any(target_arch = "x86", target_arch = "x86_64")))]
 # fn main() {}
@@ -89,12 +89,12 @@ Input and output operands follow the same format: `:
 expressions must be mutable lvalues, or not yet assigned:
 
 ```rust
-# #![feature(asm)]
+# #![feature(llvm_asm)]
 # #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
 fn add(a: i32, b: i32) -> i32 {
     let c: i32;
     unsafe {
-        asm!("add $2, $0"
+        llvm_asm!("add $2, $0"
              : "=r"(c)
              : "0"(a), "r"(b)
              );
@@ -116,11 +116,11 @@ operand. This is useful for very low level programming, where
 which register you use is important:
 
 ```rust
-# #![feature(asm)]
+# #![feature(llvm_asm)]
 # #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
 # unsafe fn read_byte_in(port: u16) -> u8 {
 let result: u8;
-asm!("in %dx, %al" : "={al}"(result) : "{dx}"(port));
+llvm_asm!("in %dx, %al" : "={al}"(result) : "{dx}"(port));
 result
 # }
 ```
@@ -133,11 +133,11 @@ compiler not to assume any values loaded into those registers will
 stay valid.
 
 ```rust
-# #![feature(asm)]
+# #![feature(llvm_asm)]
 # #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
 # fn main() { unsafe {
 // Put the value 0x200 in eax:
-asm!("mov $$0x200, %eax" : /* no outputs */ : /* no inputs */ : "eax");
+llvm_asm!("mov $$0x200, %eax" : /* no outputs */ : /* no inputs */ : "eax");
 # } }
 # #[cfg(not(any(target_arch = "x86", target_arch = "x86_64")))]
 # fn main() {}
@@ -167,12 +167,12 @@ Current valid options are:
 3. *intel* - use intel syntax instead of the default AT&T.
 
 ```rust
-# #![feature(asm)]
+# #![feature(llvm_asm)]
 # #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
 # fn main() {
 let result: i32;
 unsafe {
-   asm!("mov eax, 2" : "={eax}"(result) : : : "intel")
+   llvm_asm!("mov eax, 2" : "={eax}"(result) : : : "intel")
 }
 println!("eax is currently {}", result);
 # }
@@ -182,12 +182,12 @@ println!("eax is currently {}", result);
 
 ## More Information
 
-The current implementation of the `asm!` macro is a direct binding to [LLVM's
+The current implementation of the `llvm_asm!` macro is a direct binding to [LLVM's
 inline assembler expressions][llvm-docs], so be sure to check out [their
 documentation as well][llvm-docs] for more information about clobbers,
 constraints, etc.
 
 [llvm-docs]: http://llvm.org/docs/LangRef.html#inline-assembler-expressions
 
 If you need more power and don't mind losing some of the niceties of
-`asm!`, check out [global_asm](global-asm.md).
+`llvm_asm!`, check out [global_asm](global-asm.md).

src/libcore/hint.rs

@@ -113,7 +113,7 @@ pub fn black_box<T>(dummy: T) -> T {
     // box. This isn't the greatest implementation since it probably deoptimizes
     // more than we want, but it's so far good enough.
     unsafe {
-        asm!("" : : "r"(&dummy));
+        llvm_asm!("" : : "r"(&dummy));
         dummy
     }
 }