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

codegen: workaround for a emitBB bug

codegen: print every jvm instruction as label in disasm output

codegen: some more tests

codegen: eliminate code duplication

refactor: better names for TrapInfo^WTrapCause

Makefile: let testfiles be a dependency for the tests target

- just compile java files needed for executing mate (e.g. java/* stuff)
- also satisify a dependency with a wrong classfile as we test something
  different here (see ClassPath3.*). yes, it's a hack, as our "test framework"
  isn't really mature :-)

hlint: more fixes

not everything fixed though. some ugly things in the codegen hopefully disappears
sometimes (e.g. due to an awesome reg allocator ;))

ffi: don't use C for obtaining an address of a haskell function

i.e. get rid of dirty FFI hacks.

thanks to simonmar:
http://stackoverflow.com/questions/10967598/get-the-address-of-a-function-without-ffi#comment14326263_10967598

tools: cabal: update to new harpy version

codegen: add instanceof stub

gnuclasspath is going crazy now o_O

tools: install libs with profile information

trapmap: delete entry after information is consumed

debug.h: define DBG_ALL

codegen: extra handling if calldisplacement doesn't fit in 8bit

harpy generates different code for
- call (Disp  (0x33 :: Word32) (eax)
- call (Disp (0x444 :: Word32) (eax))
although if both immediates are declared as Word32, harpy checks
at emmitting if it's able to reduce code size.

hopefully we find a easier way to fix this issue, because this way
just introduces more complexity.

codegen/div: clear edx before use div insn

codegen: a few more hacks to get more of classpath running

methodlookup: unique identifier for methods are name+signature

in our case always the "first" method with the name was taken
(the signature was ignored)

classpool: staticfields calculation: bugfix

span doesn't do what I believed it does (it aborts on first predicate match)

tests: generics

traps: debugging

tests: static classes

classpool: cache class file access

it was designed for that, so do it... *sigh*
sometimes I'm so dumb

most things are intend stuff

string: allocate a real java object for strings

incl. fieldtable, array, ...

also see:
http://www.javamex.com/tutorials/memory/string_memory_usage.shtml

debug: malloc stuff

array: char array support

Makefile: optional call file for testcases

in order to easier pass arguments to the JVM for certain testcases,
e.g. classpath stuff

main: some kind of argument parsing

o -cp, -classpath and -jar support now from commandline.
  args parsing is a mess, I know. Unfortunately I can't use
  getopt here, because the weird argument syntax of openjdk
  java.
o finally, calls like `./mate tests.Static5' are also possible now
  (before it was `./mate tests/Static5' only)
o new dependency: package split

ClassPool: JAR and ClassPath support

thanks hs-java awesomeness, although the implemented Java.ClassPath
Modell doesn't really fit nicely in our current implementation :/
so it's a bit hackish...

hs-java: upgrade to 0.3.1

0.3 has JAR support, so stay tuned \o/

fixed bug in mate.cabal '.' should be in include dir not included itself

Makefile: delete *_stub.* files

those are generated exporting things with FFI