codegen: handle exceptions of a method

also, use bimap for mapping jpc and npc values

TODO: if no handler is found, throw it to caller method

codegen: get full jnmap in patcher

at compile-time, the java PC to native PC map is not complete yet.

codegen: map each real PC to java bytecode PC

and store that information also in the global table (needed for handling a
exception at runtime)

basicblock: store length of basiblock (i.e. bytes of instructionstream)

basicblock: build exceptionmap

java/lang: env for exceptions

codegen: simplify glue code and emit code for all basicblocks

hence, also blocks which are not reachable in a non-exceptional case (aka.
exception handlers)

basicblock: handle athrow as return

codegen: make use of Functor instance

basicblock: build up CFG differently

we already get all those entry points in the previous pass

basicblock: rewrite buildCFG with states

basicblock: annotate BBs with exceptions

basiblock: remove `markBackwardTargets'

... and fold it into `calculateInstructionOffsets', using state monad power.
I added an older testcase, as it forces this situation. However, it won't fail
when removing this feature, but it would lead to code duplication on basicblock
level.

basicblock: using arrows

I feel so awesome now, woooot :D

basicblock: use state monad to save all targets from previous pass

speedup at BigInstance1: 6s -> 2s

basicblock: use simpler type

basicblock: small optimization of algo

athrow: add trapskeleton for it

debug: show disasm in intel syntax

as the codeGen syntax is more like intel syntax ;/

instanceOf: test anonymous interface

GC: implemented QuickCheck magic to test GC of huge object trees

GC: implemented basic GC memory swapping; some refactoring

GC: TwoSpace copy evacuation basically works

GC/MemoryManager: implemented evacuate

GC: refactored Ptr specific test implementation into Mate/Tests/MockRefs;

GC: added newRef field

scratch: stack->register mapping experiments. preparation for hoopl tests

scratch/GC: playground for datastructures to be used in GC - probably...

hlint: style cleanup

instanceOf: also consider interfaces

instanceOf: class hierarchy are considered properly now

TODO: interfaces

instanceOf: make decision at runtime

preperation for a serious instanceOf implementation

MemoryManager: twoSpace memorymanager initialization code; here its time for monad transformers...

moved GC/MemoryManager into Mate (more comfortable with packages etc - integration approaches ;-))

scratch/GC: progress with data structures and traversals

scratch/GC: progress with data structures and traversals

scratch/GC: sketched datastructures etc for obj graph traversal

objectformat: one word after mtable in object layout

also use ptrSize in ClassPool

trapmap: delete some entries

patching: define patcher in X86CodeGen itself where possible

lazy classloading: yet another bug

by computing the field access offset, the class has to loaded. but this should
happen at runtime, on the first field access, not at compile time. see
tests/Instance7.java

traps: delete traps... TODO

README: remove old information

debug: remove #ifdef's and use dumb logger

advantage:
- Haskell code, i.e. tools like hlint or ghc-mod don't have problems with
  processing the source files with CPP
- no (ugly?) old school CPP stuff

disadvantage:
- it's not really a printf thingy (maybe we'll be able to use it soon)

Wall: remove some warnings

globalmaphack: be more general (fmap, factoring, ...)

Revert "globalmaphack: use old school CPP"

fall back to "standard" cpp by ghc, since cpphs doesn't work with ghc-mod.

This reverts commit 94985402292306da1db46b1750927ef46bdb87d3.

Conflicts:

Makefile

GarbageAlloc: little refactoring - all GC allocate methods should have GC suffix; all non GC methods on the other hand should suffix Unmanaged;

MethodPool: removed demo call stuff - added printGCStats instead;
added Makefile to build simple GC tests in scratch (tests which cannot be run with openjdk currently because  native interface stuff);

hs-boehmgc/buildsystem: rm of tempdir after cabal install caused problems with foreign libs (libgc not found during linking); this occurs due to linking with mate - altough  cabal Setup.hs patches correct extra-library-dirs these dirs dont exist after build;

there are two possible fixes:
- ship hs-boehmgc with libgc
- patch cabal install dirs into cabal file in Setup.hs

experiments with JNI;

GC: first working version of boehm gc. working with: 8af66bf9d36f75558ec49e0461099d5f41024574 of hs-boehmgc

gc: delegated mallocs in GarbageAlloc to hs-boehmgc (Mate.GC.Boehm.mallocBytes);
tests: implemented little memory leaking example
jmate: added sketch implementation of Runtime class (which should be used to query heap memory and force GCs)

native: demo for a call to haskell functions at runtime

still a hack though

style suggestion for data decl.

debug: more readable debuginfo

traps: use harpy for patching

pro:
o more readable

contra:
o probably slower than plain patching
o no saftey checks any more (but we could add that if we want)

invokevirtual: implement lazy class loading right

also use a different trap strategy, namely SIGILL instead of SIGSEGV, which
makes handling a lot easier and simplifies code imho.

codegen: approx. initial codebuffer size according to codesize @ bytecode

tests: big object fail

debug: ifdef this, because ghc doesn't eliminate this :/

nativeMaschine: use NativeWord instead of Word32

new insn: fix wrong behaviour on lazy class init

TODO:
- invokevirtual
- invokeinterface

codegen: register dump at runtime

just a debugging aid

java runtime: add simple version of instanceof

just works if we check for the same type, like:
>  A a = new A();
>   if (a instanceof A) {
>   [...]

refactor: trivial stuff and add -fwarn-tabs to $(GHC_OPT)

TODO: update;  Debug: note about `printfFake'

Makefile: add boot class dependency for debug build

basicblock: stupid index bug @ debug output

installenv: use custom harpy repo

and provide a simple shell function for installing from a git
repository

staticcall trap: use different magic sequence

place invalid opcode *before* both NOPs, otherwise two NOP instrunctions are
executed before every actual traphandling stuff (although, CPUs nowadays will
optimize those NOP-sequences away anyways I guess...)

btw, fuuuu @ byte order *sigh*  I'll never get it...

debugmode: no maybe anymore

hlint: stuff

nativeMachine: use constants

- rename NativeMaSchine to NativeMachine
- new module for constants in order to avoid module cycles

nativeMaschine: s/unsigned int/ptrdiff_t/g

more portable

nativeMaschine: add module for binding target machine

TODO: use wordSize where appropriate

refactor: store amount of arguments of a method in RawMethod

also kick `Maybe' at parseMethod in BasicBlock. It's just annoying to unpack
it from Maybe everywhere. Just fail @ parseMethod if we don't find the codeseg

code style: just different indent

maxlocals: store it in new data type RawMethod, with MapBB & Co

we need that information, in order to reserve enough memory on the stack (was
hardcoded so far)

Makefile: don't delete tags file

codegen: factor i{load,store} shortcuts

TODO: replace traps?

refactor: style, fun, hlint, ...

warmup for serious stuff (hopefully)

Makefile: cleanup/describe options, update .PHONY, ...

globalmaphack: use old school CPP

I tried (1) typeclasses and (2) TH, but failed:
(1) typeclasses are not designed to emulate object managment
(2) TH needs GHCi (or at least something at compile-time?), and this doesn't
    work well with MateVM build stuff :/

Makefile: adapt *.compile for new javac behaivour too

gdb: disable ghc's rts timer and disable signal handlers

debugging jitted code is nice again (as it was with 6.12.*)

Makefile: fix for new javac version

seems like it doesn't search the userdir as before

refactor stuff

cabal: removed mate-common

it feels still a bit hackish...

Makefile: `ghci' and `tags' targets

woot

add package jmate

avoid name clashes when using GNU classpath. should be useful for debugging
classpath code.
at the end of the day, we should remove `java/' and maybe `jmate/'

codegen: throw: force runtime error on execution

native: cleaner arraycopy

types: remove dirty Ord instance of MethodSignature

we moved that finally to hs-java-0.3.3

traps: don't delete entry after consuming it

see the source code comment. would be nice to enable deletion again

codegen: typestuff for compiling classpath files

codegen: again, a bug regarding BB ordering

codegen: shift insn

native: add VMSystem.arraycopy