Proc macro implementation of #[naked]

Amanieu d'Antras

Last update: Aug 13, 2022

Related tags

Learning Resources naked-function

Overview

`#[naked]`

Documentation

This crate provide a proc macro version of the #[naked] attribute which can be used on stable Rust.

Example

// The SYSV64 calling convention used on x86_64 Linux passes the first
// 2 integer arguments in EDI/ESI.
#[naked_function::naked]
pub unsafe extern "C" fn add(a: i32, b: i32) -> i32 {
    asm!(
        "lea eax, [edi + esi]",
        "ret",
    );
}

#[test]
fn main() {
    let ret = unsafe { add(1, 2) };
    assert_eq!(ret, 3);
}

License

Licensed under either of:

Apache License, Version 2.0, (LICENSE-APACHE or https://www.apache.org/licenses/LICENSE-2.0)
MIT license (LICENSE-MIT or https://opensource.org/licenses/MIT)

at your option.

Contribution

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

hashmap macro for creating hashmap from provided key/value pairs

HashMap Macro Creates a HashMap from provided key/value pairs. Usage use std::collections::HashMap; use hashmap_macro::hashmap; let m: HashMap&str,

6 Oct 2, 2022

Procedural macro to derive Serde serializer-deserializer for Prost

prost-serde-derive prost-serde-derive is a procedural macro to generate Serde serializers and deserializers for Prost-generated structs. Rationale Cur

4 Dec 15, 2022

Simple Rust derive-macro that simplifies integral enum creation

Integral enum A simple way to define integer-like enums. This macro implements bunch of traits that are usually implemented via looooong derive(..) at

3 Jan 6, 2023

todo2(a.k.a. todo or die) - A better todo! macro inspired from searls/todo_or_die

todo2 todo2(a.k.a. todo or die) - A better todo! macro inspired from searls/todo_or_die This crate provides a better todo! macro, which allows you to

8 Sep 26, 2023

Experimental Quantum Computer Simulator + Quantum Chess Implementation

Quantum Chess A somewhat hacky implementation of this paper (made in a week over a holiday). It's not heavily tested and probably has some bugs still

19 Jan 21, 2022

Ray Tracing: The Next Week implementation in Rust

rttnw Ray Tracing: The Next Week implementation in Rust How to run Install Rust: Link here. Run project git clone https://github.com/luliic2/rttnw cd

20 Apr 26, 2022

Rust implementation of µKanren, a featherweight relational programming language.

µKanren-rs This is a Rust implementation of µKanren, a featherweight relational programming language. See the original Scheme implementation here for

99 Dec 8, 2022

ESP32 implementation of RustZX Spectrum emulator for ESP32-USB-OTG

RustZX for ESP32 - experimental version Goal of the project: Run ZX Spectrum on ESP32 HW: ESP32 OTG USB with ST7789 display References Rust code for E

22 Nov 9, 2022

An implementation of Olm and Megolm in pure Rust.

A Rust implementation of Olm and Megolm vodozemac is a Rust implementation of libolm, a cryptographic library used for end-to-end encryption in Matrix

66 Dec 26, 2022

Comments

request: allow functions to be declared as safe

I do understand that this makes a global_asm along with an extern fn declaration, and that extern fn declarations cannot normally be marked safe (which is itself silly), but if there's a function, such as the example function in the docs that just adds two ints, then of course that should be able to be defined as safe.

One possible way to get around the extern fn declarations always being unsafe is to declare the fn under one name with an extra underscore or some other mild mangling with a link_name attribute to the "real" name, and then also declaring a safe function with the real name that's marked as #[inline] and just calls to the global asm function.

opened by Lokathor 0
request: support `instruction_set` attribute

It might be "too early" to ask for this since that attribute isn't stable yet, but would it be possible to support the instruction_set attribute?

Related, I've had some issues with interworking code where using the rustc::naked attribute (that is, the nightly one in the compiler) fixed the fact that rust code was making non-interworking calls to t32 (written in rust) from a32 (written in a global asm file), causing crashes. Since this proc-macro lowers to a normal global_asm usage, I'm concerned that I could end up hitting those interworking issues again even if you do add instruction_set support

opened by Lokathor 0