Kernel properly handles floating point (XCC)

The kernel saves and restores floating point rather aggressively.  There
are a couple corner cases where we can avoid saving state, such as when
a uthread makes a syscall and gets preempted before the call returns.

The use of the TS flag is actually quite problematic.  We'd need to
reflect it to userspace via VCPD, and it would end up acting as a taint
if uthreads migrate between vcores.  Keep in mind that userspace can't
reset TS on its own, and any attempt to save callee-saved FP state (like
on a user-level context switch) will result in a trap, forcing the FPU
to be turned on.

Rebuild parlib and all applications.
Removes env_push/pop of FPU state

RISC and SPARC: please check out your fp_state functions (like save,
restore, init).
Uthreads need to be aligned when allocated

All threading libraries need to force alignment with posix_memalign,
since the ancillary state requires greater than 8 byte alignment.
Uthreads handle FP save and restore

RISCV / SPARC, please take a look at your code (TODO).  I didn't just
inline it, in case you want to put the code in C files in your subdirs.
Fixes bug with pop_ros_ctx (x86)

Again, much like 2612bab3, removing the memset in 0a19848d0 caused
another bug, where we were no longer sending in EV_NONE and a null
message.  Having a gibberish message led to sending very high event
numbers, which was basically a quasi-random function pointer.

Good times!
fill-kfs strips only debug info from libc.so/ld.so
Support new risc-v calling convention
Don't write/obtain errno unless sysc.err is set

This is mostly a performance optimization, but it also allows syscalls
to be executed before TLS is set up.  This helps when debugging ld.so.
Reimplement writev to not access errno on success

Like the previous commit, this helps when debugging ld.so, since TLS may
not yet be initialized.
Bypass GOT/PLT for __ros_syscall within libc

Bypassing the global offset table removes one level of indirection in the
syscall path.  On RISC-V, a call via the GOT is three instructions, including
a load, whereas a direct call is a single instruction with no data memory
access.  The situation in x86 is analogous, though it's the PLT and
instruction cache that are bypassed, rather than the GOT and data cache.
(FWIW, the difference is due to self-modifying code being cheap on x86.)

In general, libc_hidden_proto/libc_hidden_def have this effect, but they
should only be used when interposition isn't necessary (e.g. you can't use
LD_PRELOAD to override function definitions if the PLT is bypassed).
Suppress warning and fix assert in proc_pop_ctx
Implement save/restore_fp_state for RISC-V
Update save_kernel_tf_asm to use new calling conv.
Always keep floating point enabled on RISC-V
Formatting/renaming some RISC-V stuff
Move read/write_fsr so they're visible to userland
Implement backtrace for RISC-V

We now have a working frame pointer when -fno-omit-frame-pointer is given.
Improve RISC-V cpu_relax

Before, it executed a tight loop, which isn't energy efficient.  Now,
it divides 0 by 0 and "uses" the result, which, on our in-order
microarchitectures, results in a long-latency stall that doesn't burn too
much energy.
Fixes assert typo
x86: initialize XMM registers along with x87

In the future (or in RISCV), someone might have an init_fp_state() that
is super-efficient.  If it turns out that manually zeroing the XMM
registers is faster, then we can change the code.  I haven't
microbenchmarked the new way or compared it to 0'ing the 15 XMM
registers + loading the MXCSR yet.