Add -march=pentium to boot {CC,C++}FLAGS on x86_64, prevents GCC from generating SSE code.
Made the bootloader search for both kernel_x86 and kernel_x86_64 when built for x86 or x86_64.
Don't store a KMessage in kernel_args for the boot volume, only the buffer address/size.

Pointers in kernel_args are going to be changed to unconditionally use 64-bit
storage (to make kernel_args compatible with both the x86 and x86_64 kernels).
KMessage stores a pointer to its buffer, however since KMessage is used
outside of the boot code it is undesirable to change it to use 64-bit storage
for the pointer as it may add additional overhead on 32-bit builds. Therefore,
only store the buffer address and size and then construct a KMessage from
those in the kernel.
Changed addr_range to use uint64.

I've tested this change on x86, causing no issues. I've checked over the code
for all other platforms and made the necessary changes and to the best of my
knowledge they should also still work, but I haven't actually built and
tested them. Once I've completed the kernel_args changes the other platforms
will need testing.
Changes to kernel_args to make it identical for x86 and x86_64.

* Added a FixedWidthPointer template class which uses 64-bit storage to hold
  a pointer. This is used in place of raw pointers in kernel_args.
* Added __attribute__((packed)) to kernel_args and all structures contained
  within it. This is necessary due to different alignment behaviour for
  32-bit and 64-bit compilation with GCC.
* With these changes, kernel_args will now come out the same size for both
  the x86_64 kernel and the loader, excluding the preloaded_image structure
  which has not yet been changed.
* Tested both an x86 GCC2 and GCC4 build, no problems caused by these changes.
Some improvements to the previous changes made to vfs_boot.cpp suggested by Ingo.
Remove phys_addr_range, just use addr_range for both virtual and physical address ranges (as requested by Ingo).
Merge branch 'master' into x86_64
Proper implementation of arch_kernel.h for x86_64.
Code style fixes.
Added ELF64 headers, common ELF32 and ELF64 definitions moved to elf_common.h.
Removed the addr_t conversion operators from FixedWidthPointer which makes comparison against NULL work properly.
Added an ELF64 version of preloaded_image.

* There is now 2 structures, preloaded_elf32_image and preloaded_elf64_image,
  which both inherit from preloaded_image.
* For now I've just hardcoded in use of preloaded_elf32_image, but the
  bootloader ELF code will shortly be converted to use templates which use
  the appropriate structure. The kernel will be changed later when I add
  ELF64 support to it.
* All kernel_args data is now compatible between 32-bit and 64-bit kernels.
Support static_cast on FixedWidthPointer.
Changed the boot ELF code to use templates and added ELF64 support.

The actual implementation of the ELF loading methods have been put into
an ELFLoader template class that takes a single template parameter, which
is a structure containing all the necessary ELF typedefs. It's a bit
verbose, but I thought it was a neater solution than using a bunch of
standalone functions with a huge number of template parameters. There is
no change to code outside of elf.cpp, the ELF32/ELF64 differences are
handled internally.
FixedWidthPointer: Fix ==/!= operators, remove OtherType casts

* FixedWidthPointer:
  - operators ==/!=: Change second operand type from void* to const
    Type*. Also add non-const version to resolve ambiguity warning when
    comparing with non-const pointer.
  - Add Pointer() getter.
  - Remove templatized cast operators. They are nice for casting the
    pointer directly to another pointer type, but result in ambiguity.
* Make preloaded_image::debug_string_table non-const. Avoids clashes of
  the const and non-coast FixedWidthPointer comparison operators. A
  cleaner (but more verbose) solution would be to spezialize
  FixedWidthPointer for const types.
Fixes for other platforms.
Align the start of the kernel .data to a 2MB boundary, prevents ld from merging the text and data PHDRs.
Improved elf_load_image() a bit.

After enabling BOOT_SUPPORT_ELF64 on x86 the x86 kernel could no longer be
booted because too many kernel_args allocations were taking place and filling
kernel_args_ranges. This was because for each image load it would check if
the image is ELF64, fail and fall back to ELF32 (each ELF64 check allocated
a preloaded_image). Changed elf_load_image() so that it only tries both when
loading the kernel image, and then for modules it will only try the same ELF
class as the kernel image.
Added x86_64 ELF64 relocation functions for the bootloader. All that's left to do now is handle the 64-bit load address properly.