trying to read process memory to get symbols, relocs broken
so, turns out it works.  needs PIC!

without PIC, the relocations are crazy... but with PIC they are
exactly as I expect.  le sigh.
drop a lot of dead code from symbol lookup/reloc stuff.

now that we know it actually works...
add/reorganize test C code.

Go will try to build any C code in the local directory for Cgo,
with of course terrible results when all of those files have their
own 'main'.  So relegate that code to its own directory.
add bfd gitignores
add new function because to get around procread problem.

C callbacks in Go are a nightmare, just ignore them.
reading symbols in Go, but still broken.

need to fix test to actually ptrace the child, because we need to
read it's link map list for symbol relocation.
rework to use ptrace processes and its ReadWord.

.. but not quite done / at the stage of my C, yet.
reliable debugger/inferior synchronization.

absolutely repulsive, but still technically reliable.  essentially
we synchronize with files, and we need the client program to be
modified to synchronize with us.  getting it to work is just
details/painful, for the moment.
add && start using debug channels.

instead of just littering everything with printfs...
get relocation and symbol setup working in Go.

getting similar results to C, though confusingly/interestingly
missing 'pause' in the symbol list of the test.  Hrm.
ignore refs/tags.
correct address lookup, add test for malloc breakpoint.

the issue was not relocating/fixing for every library in our
load_map.  it's apparently important to get all of them in there.

breakpoints now mostly work.  need to correct %rip and test
still, but at least the interruption is sound.
implement the rest of the breakpoint test.

finally. seems to work. periodic strange bug where the breakpoint is
never hit, yet the program's output clearly indicates it got
through the break location.  we must be calculating the address
incorrectly... but only sometimes?
fix bug setting breakpoint.

we want to make sure we only overwrite the start of the
instruction, otherwise we can cause Bad Things(tm).  Also, the
length of the instruction is always one byte, by definition.
add an option to note/find every malloc in the program.
properly account for erroneous programs.

i.e. if they terminate before they hit our 'malloc' breakpoint,
that's not an error.. just a buggy program.
update hacky sync methodology.

to remove a race.  now the parent waits for the child to say "i
started up okay", THEN it freezes the child and does its magic.
finally, when its read all it needs, it completes the sync
procedure by writing a value into the file that says the child can
continue.

this removes a race between the child finishing 'badsync' and then
getting past our breakpoint before we can SIGSTOP the child and
*set* the breakpoint.
finally got the malloc detection stuff working!
Get identifying all the mallocs working.

Tons of stuff in here.

* Don't explicitly filter out symbols not used in the main
  executable.
* Grab symbols from a special list, shared object or not.  This
  lets us pull out malloc and friends, even if the executable
  doesn't use those directly.
* Add a C++ test program that uses new, thereby testing a shared
  library calling malloc, but not us.
* get rid of all the awful synchronization and just break at main.
  This lets us do bfd.SymbolsProcess then, which means the dynamic
  loader has already done its thing.
* handle programs that don't have 'malloc' without panic'ing.

My test programs work, as well as a custom compiler I have
installed.  But we seem to fail on fortran programs and
simulations, e.g. enzo.