Implement MakeClosure
Implement MakeSlice
Various cleanups

Started working on interface ("invoke")
calls, not quite working yet though.
Merge branch 'ssa' of https://github.com/axw/llgo into ssa
Remove dead code
Implement append, work towards interfaces, panic/defer/recover

Lots of changes afoot to make interfaces work properly.
Unsure of how panic/defer/recover will work just yet;
may take this opportunity to move to using sjlj.
Numerous fixes

- Get rid of pointer, stack, method from LLVMValue;
  we always load when ssa tells us to deref, and we
  (should) never need to take the address of a var
  outside of ssa. There's a problem with *ssa.Index
  operating on array, instead of *array, though.
- Temporary (a sign I may be doing something wrong)
  hack to load arrays to stack when indexing.
- Move makeslice to runtime.
- Create globals with the right type.
- Always create blocks before use (ordering problem
  in defineFunction).
- "Backpatch" (to borrow a term used by adonovan)
  values not yet introduced to fr.env: create a
  placeholder (non-const!), and replace all uses
  when visiting the instruction that would define it.
- Temporarily make "panic()" a no-op.
Add interface receiver to type string
More fixes

- Create placeholder value (for backpatch) into its own
  basic block, so we can dispose of the instruction after
  replacing it.
- Remove receiver from interface method when invoking
  (it is implicit in the context pointer).
- Another fix for the Panic standin so we don't have missing
  terminators: call llvm.trap, emit unreachable.
Even more fixes!

- Build closures correctly (input is raw
  function pointer, not pair of pointers).
- Reimplement interface comparisons.

llgo-build runtime *almost* completes now.
I think it's just missing attribute processing,
to set global/function LLVM attributes.
Reenable source annotations

runtime is still not quite there.
Check if function exists before adding

Now I remember...
Moar fixes

- Check if function exists before adding in RuntimeFunction
- Don't use Create*Malloc builder functions; call the runtime.
Store runtime types and intrinsics

Don't use runtime lookup/cache for intrinsics,
it's wasteful. We just lookup at the beginning,
always. If it's unnecessary, we can always do
a load on the first use, but keep the static
allocation.

Also some general cleanup: renamed LLVMTypeMap
to llvmTypeMap, removed FunctionCache.
pkg/runtime: fix runtime.makeslice
Various fixes

- call program.CreatePackages, so we get declarations for imported packages
- implement I2E vs. E2E comparisons, and convertI2E. non-empty interfaces
  not yet represented with itab.
- convert raw function pointers to pair-of-pointers on evaluation

I'll work on proper interface representation now. They won't cache (yet).
Fix and simplify ChangeType

There's nothing to do other than associate
the new type; otherwise the value will have
identical representation.
Various fixes

- Fix handling of method calls
- Reenable global constructors for init functions
  and package-level vars.
Generate program initialization code at compile time

Previously we were creating an "appending" linkage
array in runtime, containing a list of init functions.
This was causing difficult to debug issues when the
declared array is greater than size one (I think that's
the issue, anyway).

Instead, now, we just generate a function that calls
each of the (transitively) imported packages' init
functions. go.tools/ssa gurantees an init function for
each package, and we know the order up front, so this
is safe to do (and simplifies things somewhat).
Implement MakeMap, MapUpdate, Lookup (for maps only)