11:50 <bitts[m]> How can I call a function defined in an assembly file that is included with global_asm!? I tried declaring it with extern "C" {}, but linker throws undefined symbol?

11:52 <dirbaio[m]> That's how you do it yep. Here's one example:

11:52 <dirbaio[m]> https://github.com/embassy-rs/cortex25519/blob/1fecf397b0209ef5858ee8f9c7df9bcc24f7eb11/src/cortex_m_curve25519.s#L38

11:52 <dirbaio[m]> https://github.com/embassy-rs/cortex25519/blob/1fecf397b0209ef5858ee8f9c7df9bcc24f7eb11/src/backend.rs#L10

11:52 <dirbaio[m]> Maybe .type or .global is required, not sure

11:53 <bitts[m]> I have both .type and .global, but what does options(raw) do? I dont have that..

11:55 <dirbaio[m]> It's so rust doesn't do anything with {} characters in the asm. Handy if you want to include_str a normal .s file without escaping the {}s. That's not what's causing your error..

11:55 <bitts[m]> Adding it did not help.. Hmm..

11:55 <dirbaio[m]> Can you post your code?

11:57 <bitts[m]> Assembly:... (full message at <https://catircservices.org/_irc/v1/media/download/AcuWMRtL26JD9xt0yZzy2eijBtd_H4o_71tJ7n3khpTZecVDXw40mWleQbvt02TTzzI6egrSPioR8SKtLUgolGa_8AAAAAAAAGNhdGlyY3NlcnZpY2VzLm9yZy9ja1padlRZUFVnVmxqdk5QTkV6SUxzWUQ>)

11:59 <dirbaio[m]> Seems OK yeah 🤔🤔

11:59 <dirbaio[m]> Try moving .global after the label?

11:59 <bitts[m]> Tried, did not help, also adding .size did not help

12:00 <dirbaio[m]> Wtf! Can you paste the linker error?

12:00 <bitts[m]> It is in a separate crate from where I am calling the arm_get_core_id, could that cause this?

12:07 <diondokter[m]> Doesn't the asm macro want each instruction in a separate string?

12:08 <diondokter[m]> (Also, if you're on nightly, you could try out the new and improved naked fns)

12:09 <dirbaio[m]> Rust skips linking a crate if you never use it. Do you have the global_asm in the same crate as the extern?

12:10 <dirbaio[m]> If you do then it should be OK because you're useing that crate for sure. If not then you have to make sure to add a dummy use

12:11 <bitts[m]> Yes, the rust code above is all in one file in one crate, then I use arm_get_core_id() from a different crate

12:14 <bitts[m]> diondokter: I'm using global_asm! which can read a standard assembly file. asm! takes separate strings yes

12:14 <diondokter[m]> Ah ok

12:14 <bitts[m]> Tried moving it all to the same crate, no dice.. Weird...

12:21 <adamgreig[m]> fwiw asm can take one string or multiple strings or whatever too

12:21 <adamgreig[m]> iirc?

12:24 <adamgreig[m]> yea, it's fine, it's just you'd have to put newlines in so it makes for a potentially ugly multi-line string or loads or \r\n

12:24 <adamgreig[m]> the macro just offers the option of doing lots of string literals which it will glue together with newlines in-between

12:24 <diondokter[m]> adamgreig[m]: Ah that's probably it then

12:25 <adamgreig[m]> so like asm!("mov {0}, {1} \r\n add {0}, 5", out(reg) o, in(reg) i); works, and asm!("mov {0}, {1}", "add {0}, 5", out(reg) o, in(reg) i); is the same, or you could put an actual newline and split the literal over multiple lines, but you can't just have mov {0}, {1} add {0}, 5

12:27 <bitts[m]> If it was just that one function I would move it over to hand-coded asm!, but unfortunately there are a bunch of them in multiple files that I would prefer to just use as is

12:28 <diondokter[m]> Maybe you need to mark it as executable?

12:28 <bitts[m]> I already use global_asm! for some boot code, and that works fine, so it is not completely broken.

12:28 <diondokter[m]> Something something ax

12:29 <diondokter[m]> You function declaration is a lot less than this: https://github.com/rust-embedded/cortex-m/blob/master/cortex-m-rt/src/lib.rs#L520-L526

12:29 <diondokter[m]> * Your asm function declaration is a lot less than this: https://github.com/rust-embedded/cortex-m/blob/master/cortex-m-rt/src/lib.rs#L520-L526

12:31 <bitts[m]> Not going to object to that, but it is awfully similar to what dirbaio linked to above. But I can try to throw in some of that for sure!

12:31 <diondokter[m]> Oh didn't see that from Dario

12:31 <adamgreig[m]> it's worth a try, I worry the issue is some sort of linker related nuisance where your symbols just aren't ending up where you want them, but I don't see why not

12:32 <bitts[m]> Not sure if being on a mac could have something to do with it?

12:36 <adamgreig[m]> wouldn't expect so

15:12 <bitts[m]> Huh, for the curious, I had based my project off the raspberry-pi os tutorial (https://github.com/rust-embedded/rust-raspberrypi-OS-tutorials) which is makefile based and calls cargo rustc. After setting up a new project using standard .cargo/config.toml etc, the global_asm! works as expected..

16:29 <mameluc[m]> I have something like this in my lorawan code... (full message at <https://catircservices.org/_irc/v1/media/download/AQeCx7F_fWZ6Jl0rPR9WpapBx14npQg-SawHmbkpH9YxZORvUooNttb6IwHgHRkpEYLjxT-2OtMGDb9d0PiZUyi_8AAAAAAAAGNhdGlyY3NlcnZpY2VzLm9yZy9zcFlVeW5uRERMTWpxVllZRFZkVE1RcFY>)

16:31 <dirbaio[m]> traits support async fn natively now

16:31 <mameluc[m]> idk if overkill but I wanted to return a Result with a future in it

16:31 <mameluc[m]> should probably skip that and just simplify

16:32 <mameluc[m]> my thinking was that all values for the timer might not be possible

16:32 <dirbaio[m]> honestly i'd just make it infallible

16:32 <mameluc[m]> sounds better, thanks

16:33 <dirbaio[m]> but if not, returning a uture that returns a result, and returning a result with a future inside should work equally well

16:33 <dirbaio[m]> s/uture/future/

16:33 <dirbaio[m]> and you can only do the former on stable

16:34 <dirbaio[m]> (unless you force impls to hand-implement futures to avoid TAIT)

16:37 <mameluc[m]> I was trying to figure out the language when I wrote that, there is a lot of "why did I do it like that" now when I go trough it all :D

16:37 <mameluc[m]> Lorawan requires a handful of hardware stuff, some "callbacks" and a bunch of constants so the traits are not so simple

16:37 <mameluc[m]> With the timer stuff it is all moot anyway bc I know what kind of ranges the timers should work on, something like 1s - 10s