• Feature Name: naked_fns
• Start Date: 2015-07-10
• RFC PR: rust-lang/rfcs#1201
• Rust Issue: rust-lang/rust#32408

Summary

Add support for generating

Motivation

Some systems programming tasks require that the programmer have complete

When writing interrupt handlers for example, most systems require additional

#![allow(unused)]
fn main() {
unsafe fn isr_nop() {
    asm!("push %rax"
         /* Additional pushes elided */ :::: "volatile");
    let n = 0u64;
    asm!("pop %rax"
         /* Additional pops elided */ :::: "volatile");
}
}

The generated

isr_nop:
    sub $8, %rsp
    push %rax
    movq $0, 0(%rsp)
    pop %rax
    add $8, %rsp
    retq

Here the programmer's need to save machine state conflicts with the compiler's assumption that it has complete

When interacting with FFIs that are not natively supported by the compiler, a similar

Support for naked functions also allows

    mov 4(%ebp), %eax
    ret

Because the compiler depends on a function prologue and epilogue to maintain storage

Detailed design

設計（する）

Add a new function attribute to the language,

Because the calling

Defining

#![allow(unused)]
fn main() {
#[naked]
unsafe fn foo() { }
}

The following variant is not an error because the C calling

#![allow(unused)]
fn main() {
#[naked]
extern "C" fn foo() { }
}

Because the compiler cannot verify the correctness of code written in a naked function (since it may have an unknown calling

#[naked]
extern "C" fn error(x: &mut u8) {
    *x += 1;
}

#[naked]
unsafe extern "C" fn correct1(x: &mut u8) {
    *x += 1;
}

#[naked]
extern "C" fn correct2(x: &mut u8) {
    unsafe {
        *x += 1;
    }
}

Example

The following example illustrates

use std::intrinsics;
use std::sync::atomic::{self, AtomicUsize, Ordering};

#[naked]
#[cfg(target_arch="x86")]
unsafe extern "C" fn isr_3() {
    asm!("pushad
          call increment_breakpoint_count
          popad
          iretd" :::: "volatile");
    intrinsics::unreachable();
}

static bp_count: AtomicUsize = ATOMIC_USIZE_INIT;

#[no_mangle]
pub fn increment_breakpoint_count() {
    bp_count.fetch_add(1, Ordering::Relaxed);
}

fn register_isr(vector: u8, handler: unsafe extern "C" fn() -> ()) { /* ... */ }

fn main() {
    register_isr(3, isr_3);
    // ...
}

Implementation

実装

Considerations

考慮

The current support for extern functions in rustc generates a minimum

For naked functions, it is impossible for the compiler to generate a Rust ABI version of the function because the implementation

Drawbacks

The utility of this feature is extremely limited to most users, and it might be misused if the implications of writing a naked function are not carefully considered.

Alternatives

代わりのもの、選択肢

Do nothing. The required functionality for the use case outlined can be implemented

Unresolved questions

It is easy to quietly generate wrong code in naked functions, such as by causing the compiler to allocate stack space for temporaries

The unsafe requirement on naked functions may not be desirable in all cases. However, relaxing that requirement in the future would not be a breaking change.

Because a naked function may use a calling