Clarify docs around what libcore users must declare

[JustAPerson]

I find the documentation about what libcore depends on a bit confusing right now. I'm trying to make my #[no_std] crate compile after a year on inactivity for context.

Now firstly, this section describes several symbols, but is the actual symbol name relevant (ignoring memcpy/memset/etc)? Or do we only care about the existence of some function labeled with the appropriate attribute? The distinction between symbol name and the associated lang attribute is confusing here.

rust_begin_panic - This function takes four arguments, a fmt::Arguments, a &'static str, and two u32's. These four arguments dictate the panic message, the file at which panic was invoked, and the line and column inside the file. It is up to consumers of this core library to define this panic function; it is only required to never return. This requires a lang attribute named panic_impl.

It appears that the #[lang="panic_impl"] mentioned is already declared in libcore/panicking.rs. It appears that this should refer to #[lang = "panic_fmt"] instead, which is what libcore users formerly had to declare but is now implicitly declared by by the new #[panic_handler]. Rustc will complain about missing a #[panic_handler] currently. So this section should probably be updated to refer to #[panic_handler] instead.

rust_eh_personality - is used by the failure mechanisms of the compiler. This is often mapped to GCC's personality function, but crates which do not trigger a panic can be assured that this function is never called. The lang attribute is called eh_personality.

It should probably be mentioned that #[lang="eh_personality"] seems only necessary if panic=unwind. Additionally should perhaps mention _Unwind_Resume as well (which theoretically is only necessary for panic=unwind builds but can erroneously be required for panic=abort opt-level=0 builds see #53301). There's actually more of these eh functions that should be perhaps mentioned depending on your target. The subtleties are explained in libpanic_unwind and libpanic_abort.

Along the same lines, the docs of liballoc should probably also mention #[alloc_error_handler] (see #51540).

I can try writing up a draft or PR but wanted to get feedback first.

[steveklabnik]

Yes, this doc is out of date; we've now stabilized panic handling stuff, so this is what you need today https://github.com/intermezzOS/kernel/blob/master/src/panic.rs

[hkBst]

I find the documentation about what libcore depends on a bit confusing right now. I'm trying to make my #[no_std] crate compile after a year on inactivity for context.

This now lives here:

rust/library/core/src/lib.rs

Lines 21 to 44 in aa95b96

	//! This library is built on the assumption of a few existing symbols:
	//!
	//! * `memcpy`, `memmove`, `memset`, `memcmp`, `bcmp`, `strlen` - These are core memory routines
	//! which are generated by Rust codegen backends. Additionally, this library can make explicit
	//! calls to `strlen`. Their signatures are the same as found in C, but there are extra
	//! assumptions about their semantics: For `memcpy`, `memmove`, `memset`, `memcmp`, and `bcmp`, if
	//! the `n` parameter is 0, the function is assumed to not be UB, even if the pointers are NULL or
	//! dangling. (Note that making extra assumptions about these functions is common among compilers:
	//! [clang](https://reviews.llvm.org/D86993) and [GCC](https://gcc.gnu.org/onlinedocs/gcc/Standards.html#C-Language) do the same.)
	//! These functions are often provided by the system libc, but can also be provided by the
	//! [compiler-builtins crate](https://crates.io/crates/compiler_builtins).
	//! Note that the library does not guarantee that it will always make these assumptions, so Rust
	//! user code directly calling the C functions should follow the C specification! The advice for
	//! Rust user code is to call the functions provided by this library instead (such as
	//! `ptr::copy`).
	//!
	//! * Panic handler - This function takes one argument, a `&panic::PanicInfo`. It is up to consumers of this core
	//! library to define this panic function; it is only required to never
	//! return. You should mark your implementation using `#[panic_handler]`.
	//!
	//! * `rust_eh_personality` - is used by the failure mechanisms of the
	//! compiler. This is often mapped to GCC's personality function, but crates
	//! which do not trigger a panic can be assured that this function is never
	//! called. The `lang` attribute is called `eh_personality`.

[hkBst]

rust_begin_panic - This function takes four arguments, a fmt::Arguments, a &'static str, and two u32's. These four arguments dictate the panic message, the file at which panic was invoked, and the line and column inside the file. It is up to consumers of this core library to define this panic function; it is only required to never return. This requires a lang attribute named panic_impl.

It appears that the #[lang="panic_impl"] mentioned is already declared in libcore/panicking.rs. It appears that this should refer to #[lang = "panic_fmt"] instead, which is what libcore users formerly had to declare but is now implicitly declared by by the new #[panic_handler]. Rustc will complain about missing a #[panic_handler] currently. So this section should probably be updated to refer to #[panic_handler] instead.

This part seems to have been fixed