Instead of looking up the actual symbols, adjust the existing entry to point
back at the PLT.  This will later case the stub at the first three entries
of the PLT to get called with the symbol index on the stack, for run-time
resolution.

much more efficient.

This implementation stores small objects in pools of similar-sized objects,
while large objects are allocated using a first-fit algorithm.  There is also
a specialized interface for allocating aligned pages.

Doesn't really affect anything, but it is cleaner.

This lets use _attribute__((init_priority)) to control static constructor
order, useful for configuring interdependent global services.

More elf/debug work.

Conflicts:
	Makefile

Add serial console

* 'master' of github.com:/avikivity/osv:
  boot: initialize .bss
  loader: create a JVM
  loader: run an initialization function in libjvm.so
  elf: perform relocations on looked-up symbols
  elf: rename dynamic tag lookkup to dynamic_tag()
  elf: add lookup function to get a fully typed function
  elf: load program as an object, not via a function
  runtime: define environ
  pthread: add pthread_{getspecific,setspecific,key_create}
  mutex: stub implementation
  elf: dump name of symbol which we failed to look up
  runtime: define 'timezone'
  elf: core provides libdl.so functions

Conflicts:
	Makefile

Previously, the boot code assumed (by omission) that memory is initialized
to zero.  Apparently that is not the case, and this caused memory to become
corrupted.

Initialize .bss to zero to fix.

At the moment it can only print to the console.

order to reach includes files for within the hirarchy.

Not working yet.

Otherwise, we use the unrelocated virtual address, which points nowhere.

lookup() is too similar to symbol lookup

The 'program' object allows us to later resolve symbols (aka dlopen()/dlsym()).

No threading yet, so no real locking

Don't load it from the glibc library.

Weak symbols are allowed to fail name resolution, in which case they bind to
zero.

Some libraries come without DT_HASH.

We need to parse the core's dynamic segment, which is linked to from the
program header.  Since the core is not an elf_file, but an elf_object, we
need to move the parsing code there.