Replace before-main logic with a syntax extension, use standard args for 'start' (main)

[brson]

Right now the compiler writes main as a wrapper that magically obtains the pointer to the Rust main function and to the crate map, then calls the runtime start function. Imagine something like:

fn _rust_main(argc: int, argv: **i8) {
    // note neither `get_main` or `get_crate_map` actually exist
    rt::start(get_main(), argc, argv, get_crate_map());
}

There are several reasons why this is not the best arrangement. One impact of this is that our most basic entry point, start, takes a third crate_map argument that must be supplied before main.

We could turn this logic into a syntax extension, making the only real entry point start, taking argc and argv (types tbd).

• Make a way to retrieve the crate map at runtime, either an intrinsic (for now) or by some other mechanism once logging becomes a syntax extension.
• Add a syntax extension that looks for either main or #[main] and, if it finds it, add a wrapper function, #[start] __start.
• Later passes look only for #[start].
• Trans generates the minimal code to call #[start].

Related #3309

[emberian]

Triage bump

[pcwalton]

Triage bump

[brson]

The crate map could possibly also be a weak symbol that std needs to link against.

[alexcrichton]

This issue has progress, the crate map is no longer a required argument. Additionally, the #[start] function can be prototyped as:

#[start] fn start(argc: int, argv: **u8) -> int { ... }

Which is kind of what one would expect. @brson, I'm not entirely certain what the motivations of this issue were beyond achieving these two goals, so I'm hesitant to close this. From my understanding of this, it sounds pretty done to me though.

[alexcrichton]

Closing, starting up in rust is pretty standard now (see my previous comment).

Starting a runtime is also as simple as green::start and native::start.