Local APIC ID is different on x2apic, so we need a virtual function.

Used to initialize the APIC on non-boot processors.

Not 100% it is right wrt SNaN, but it will fault if incorrect.

Still with minimal stack, no interrupt support, etc.

Exceptions are challenging on x64 because the ABI reserves 128 bytes below
%rsp for local variables; this will be overwritten by an exception or
interrupt.  We can't use -mno-red-zone because the payload may not have been
compiled for it.  Instead, use the interrupt stack stack table mechanism
and a separate stack for exceptions.  May fix random corruptions when timers
are used.

Make some room for the command line and other future additions.

Needed for pthread_attr_*() (and in general to make sure the stack is
a regular vma as expected by the payload).

Keep the first 2MB unmapped for null pointer refernences.

This allows us to clear the area around the null pointer, and so trap errors.

The switch is tricky wrt setting up memory, since we need the memory to
be mapped in order to free it, but we need free memory to map (for the page
tables).  What we do is set up a temporart 1:1 map at ffff800000000000
that mirrors the first 1G map we already have from bootstreap, use that
to free all of memory under 1G, then map and free everything else.

Initial memory is physical; the mmu converts it to virtual addresses, and
then it can be added to the memory pool.  Right now there is not much
difference, but the 1:1 mapping is moving soon.

Way too noisy

Allow the clockevents driver to use it during startup.

This makes the apic immediately usable.

On a release build, the compiler hoists the computation of current() until
after the wrmsr() which changes the TLS base, corrupting it.

Insert a barrier to fix.

Harmless.

The ABI requires that the stack be aligned to 16 bytes, so sse can be used.
Make it so.  Fixes the jvm assembler faulting.

This ensures that initialized thread local variables are loaded into the
memory image and are usable.

Needed for exception support.

Currently the free memory pool consists of a statically allocated buffer.
Replace it with a dynamic query of the amount of memory we actually booted with.

(currently limited to 1GB since we haven't mapped anything else yet).

Terminate the stack so gdb doesn't get confused trying to unwind it.

The multiboot stack is not guaranteed to be anywhere in particular, don't use
it.