Automatically zero-pads %p

I tend to use this as a "print a 0x, zero pad out to sizeof void* bits,
and print in hex".  This change will get rid of the need for me to %08,
and will adjust to %016 for 64 bit pointers.
Replaces %08p with %p

I also changed %ps to %x when dealing with ints (flag vars).  In
general, I still use %p on things that techincally aren't pointers (like
uintptr_t).
x86: use a flat segmentation model

This no longer uses the -KERNBASE segmentation model to fake the mapping
of KERNBASE -> 0.  Instead, we construct a single page directory with
jumbo entries to use as the KERNBASE mapping (and one for the identity
mapping of 0 -> 0).  Previously, we were using this segmentation through
the early stages of kern/src/init.c.

We also link the bootstrap code for its original location in unpaged
memory, getting rid of the confusing RELOC business.

Finally, this assumes the ability to support jumbo pages.  Previously,
the kernel would just panic during start up.  Now, those ancient x86
machines will probably just reboot.  (page fault on the second level
page table with no idt).
Fixes XCC texinfo dependency

Gcc stage 1 also needed the change.  This was hard to see since the
build keeps going if stage 1 errors out.  You'd only notice it on a
fresh install.
Reverts -lm error (XCC)

This fixes the change from 6f3a1535f7, where all applications linked
with -lm.  In lieu of libm, parlib won't use any math, and whatever
utilities I come up with will just get dumped in benchutil.

The problem was that the cross-compiler can't bootstrap itself if there
was not an existing installation with -lm.  It would work only after
everything was installed, and it took a reinstall with no existing
toolchain to detect it.

The make process for benchutil was just a copy of parlib's.  We probably
ought to take a better look at all of userspace's makes, including where
we drop files in the toolchain directories.

If you have compilation issues, make clean and rm your toolchain
installation.
Fixes gcc stage 1 build (XCC)

We were ignoring stage1 errors, since it had made it far enough to
build glibc.  This hid other issues, like with commit ee027b (texinfo).

The temporary solution to fake libgcc_eh.a isn't much better, but at
least it doesn't hide errors.  AFAIK, stage 1 doesn't build libgcc_eh:
	http://gcc.gnu.org/ml/gcc-help/2011-07/msg00309.html

Other cross-compile setups will install glibc headers first; it appears
that we're doing the cheap 'shortcut' method:
	http://www.gentoo.org/proj/en/base/embedded/handbook/?part=1&chap=2

Rebuild your cross compiler.  Remove the installation directories first,
just to be sure.
x86: linker script uses sections, not names

It's a bit cleaner, and I'll need this for the upcoming Kbuild patches.

As a side note, the boot section is three pages.  One for the code, and
one for the page table, but also one for the GDT data.  I'd like to
include that in the same page as the code, but I guess the linker
doesn't like that.  I guess we could ultimately free up those three
pages once we've fully booted, if we're hurting for 12KB.
Initial Kbuild / Kconfig commit

This is just the contents of git://github.com/lacombar/kconfig.git,
which was made back in Aug 2011.  It should be a slimmed down version of
the Kbuild essentials.

The one modification I made was to move Makefile -> Makefil-KB for now.

In case we ever update it, I'll keep my changes in a separate commit.
Build system overhauled to use Kbuild (XCC)

The kernel uses Kbuild, and the old userspace targets were reworked to
fit with the new system.  They are still fairly similar to their old
selves.

Users will need to set up an ARCH and config before doing anything,
including building the cross compiler.  Do something like this:

$ make ARCH=i686 config

I cleaned out a bit of old cruft (and some bugs) in the userspace
targets, though a lot of it can do with a rewrite.

Being a fairly substantial change, you're encouraged to rebuild
everything, including the cross-compiler, to make sure there aren't any
issues.
Fixes CPIO creation for non-i386 machines

Need to use the cross-compiler's utils, not the local machine.
Replaces all __CONFIG_*__ with CONFIG_*

For those curious:

$ git grep --color=never --name-only '__CONFIG.*__' | \
  xargs sed -i 's/__\(CONFIG.*\)__/\1/g'

Also, SEQLOCK debugging was never on in the first place (had one _
instead of two __).
Updates Kconfig

The older version was missing a few things, like silentoldconfig.
Probably due to starting with that version from Aug 2011.
Modified the build system to use Kconfig

Once we have entries in the Kconfig, the build system will pass any
CONFIG_FOO=y into the C files as #define CONFIG_FOO 1.  Whenever any
config variable changes, any file using that #define will be rebuilt.

Also, we support the silentoldconfig recursive target, which detects
changed .config files and regenerates the kconfig outputs, so that
kbuild will detect the changes.

The downside to the silent rebuild of auto.conf is that it exposed some
bug in objdump where we can't use a -S when we also updated and included
auto.conf.  That was a pain to figure out.  If you really want -S, you
can do it, so long as you don't rely on the silentoldconfig recursive
call.  You can do something like:

$ touch .config
$ make silentoldconfig
$ make (with -S in your objdump args)
Kernel configuration uses Kconfig

To get started, $ make ARCH=<your_arch> defconfig.
To change things, $ make [config | menuconfig].

Rebuild the kernel and test applications.
Patches objdump (XCC)

Backports an objdump patch, allowing it to be called with -S from a
Makefile that reincludes one of its parts (such as auto.conf).

Rebuild binutils (rm the builddir, config file, and binutils-2.21.1/
directory, then remake).