refactor: rename types (more consistent style)

test: testcase stolen from JorthVM

tools: openjdktest.sh: check for arguments

also, one "--enable-shared" was missing installhaskellenv.sh

tools: some safety checks in openjdktest.sh

tools: script for installing the required haskell environment

tools: test against openjdk

see `make test' after a change, to check if you broke something
hint: use `make -j8 test' or similar (depending on your machine...)

but note, it's only a high level test

tests: don't use `pop' hack anymore, but System.out.printf \o/

varargs: make printf working

although it's still a hack: WOOOT

strings: other solution

strings got free'd by the GHC runtime, ooops

java.lang: add Integer wrapper

fields: don't multiple the offset with 4

it's already correct in the table, noob...

codegen: implement `iastore' and `iaload'

codegen: implement `newarray' and `arraylength'

the length is stored at offset 0.

codegen: kill unsafePerformIO

thanks to MonadIO \o/

codegen: implement IF_ACMP

it's just IF_ICMP actually

strings: put every String from the constantpool in a Map

because the spec requires that every constant string
has the same address.

w0000t @ "Hello World" :-)

trap: sigception: allow signal in signal handler context

this can hapen in combination with the static initializer:
(1) some code in class B wants to access a static field in class A
(2) SEGSEGV is issued.  we are in a signal context now
(3) this is the first usage of class A, so we have to load it
    and execute the static initializer
(4) in the static initializer of class A, there is also a static
    field access, which again causes a SIGSEGV

without `SA_NODEFER', the second SIGSEGV would be ignored.

java.io: PrintStream

invokevirtual: native methods

invokevirtual: get the actual class at run-time

we don't know the actual class in the CodeGen Monad, so we have to
deduce it at run-time. we use the method-table-ptr for that, since
it has an unique address which we can use to map the actual class.

invokevirtual: implemented. not very well tested though

TODO: cleaner code ;-(

callconv: once again, fail...

the arguments were in the wrong order, which wasn't covered by the test cases,
because I use addition everywhere... *d'oh*

fields: use offsets from ClassInfo in codegen

BUT:
    Couldn't match expected type `IO CUInt'
           against inferred type `CodeGen e s CUInt'

any idea how to solve this problem *without* `unsafePerformIO'?

classpool: also calculate offsets for non-static fields

classpool: refactor, refactor, ...

we also need to load classes *without* executing the static
initializer (to access field-offset data at compile-time
for non-static fields)

field access: first primitive attempt

constantpool index is used as offset to access
fields of an object (which isn't correct)

TODO:
- proper table index setup
- allocate bytes according table size
- consider inheritance

trap: move assertion to the top

better for debugging.

methodpool: bug fix

doesn't make sense otherwise.
why no testcase covers this? well, when we lose information
about already compiled methods, we just compile them again...

static initializer: execute it when loading the class file

unfortunately, we have a circle dependency now, hence the file
`Mate/MethodPool.hs-boot'.

java.lang: use Object.class from GNU Classpath

it doesn't have a static initializer.

java/lang/Object from OpenJDK does something weird
in the static initializer:
invokestatic    #17; //Method registerNatives:()V

we don't want that.

static methods: add inheritance capability

if the method isn't found when compiling, check the superclasses for
this certain method. if one is found eventually, add an map entry
for each class to the same method entry.

see tests/Static5.java

static fields: testcase: overwriting of fields

codegen: fix bug in calling conv

the callee used elements of the callers stack as storage for local vars.
don't do that.

java.lang: add Object.class from rt.jar (OpenJDK)

building java/lang/Object.class with javac isn't that easy, so... let's steal it :-/

TODO:
- replace binary blob with some actual code. actually, we can
  use hs-java for that ;-)

make test: less verbose plzkkthx

... and, there is something broken @ Fac.java :-(
stay tuned... *sigh*

classpool: copy field members refs from superclass

codegen: factor offset calculation

codegen: {put,get}static for static field access

TODO:
- execute static initializer upon first loading
- inheritance

refactor: s/C(aller)Map/T(rap)Map/g

we want to store more information for traps, hence an more appropriate name

global map hack: refactor

TODO: do some haskell magic for conversion functions.
  type class? template haskell?

classpool: do classloading at central point. omit '.class' when calling `mate'

methodpool: also call native methods

some comments:
(1) we need shared libs now, otherwise the binary too big (~24MB).
    please recompile from cabal (see README)
(2) as C doesn't allow '/', '(' and ')' as identifier names (unlike
    forth <3), we replace them with '_', in order to identify a
(unique) native function. the pattern is as follows:
class__methodname__methodsignature
(3) `loadNativeFunction' is quite hackisch now. I don't know if we
    get troubles with it at some point. we should consider:
(3a) ask on stackoverflow
(3b) patch this wtf stuff in ghc
(3c) just determine addresses at compile-time.

(3c) sucks, because you have to write much glue-code for every
native method. but maybe we could solve it with some magic TH
stuff (as suggested by hs_)

types: oops, we don't want the index at this point (MethodInfo)

it would be valid just for one certain class anyway... and we don't need it really

modules: move (public) datatypes into a new module

classloading: load classfile on demand

first step, not really done cleanly at the moment.

TODO: introduce a classpool, where the
(1) static initializer is executed upon first loading
(2) reference to `Class Resolved' is saved somewhere

trap: give disasm some nop's, so it shows the label

the disasm doesn't show labels on invalid opcode, but
that's convenient when debugging.

one can argue it's not really efficient here, because two cycles are wastet.
imho that's not true, since modern x86 cpu's eliminate such instructions
sequences.

we could benchmark/test that, but well, it's just on the first hit, so suck it.

codegen: correct argument handling

after a call, we have to decrement the stack pointer again, according how many
arguments that method has. also, we have to push the result in %eax only when
there's a result (i.e. /= void)

README: some notes about a ghc 7.4.1 install (shipped with Ubuntu LTS 12.04)

Mate: exposed internal functions of BasicBlocks for external benchmarks
scratch: implemented kind of benchmark (non trustworthy currently)

scratch: refactored ScratchHS into separate files.

scratch: more refactoring. cyclic cfg finally works

scratch: implemented [node][edge] -> circular structure.

scratch: checked out some abstractions, sandboxing, mostly broken ;-)

tests: added for version of fac to Fac

scratch: Makefile dependencies, LaTeX fun, .gitignore

pdflatex ftw!

trap: use SIGILL instead of SIGSEGV

therefore we can use SIGSEGV for other things (e.g. exception handling)

doc: more related stuff

thx @ hs_

scratch: sketched monadic foldTree stuff. Maybe quite senseless but given this a CFG could be formulated in a functional way.

basicblocks: also consider back references

as we just iterate the instruction stream when generating basicblocks, we need
extra handling for back references.
the solution adds a further pass, which marks targets of jumps (actually it
marks the instruction right *before* the target)

kudos @ tests/Fac.java for being a useful testcase :-)

tests: calculate factorial (non-recursive)

Merge branch 'master' of wien.tomnetworks.com:mate

scratch: Translation scheme latex/literal haskell setup. Translation.lhs should contain documentation for intermediate representation and its compilation schemes

.gitignore: *.swp and object files

ffi: added strange hack in order to build master on my machine:
Linux version 3.0.0-12-generic (buildd@aro 4.6.1-9ubuntu3)
#20-Ubuntu SMP Fri Oct 7 14:50:42 UTC 2011,
gcc (Ubuntu/Linaro 4.6.1-9ubuntu3) 4.6.1;

added scratch - for design experimentation and sandboxing

gdb: small howto debug generated code

not very convenient yet, but hey, better than nothing!

methodpool: save information in codegen context

use that for on-demand compiling

tests: add package definition

Makefile: forgot slash at clean target

README: more notes on dependencies

methodPool: compile methods on-demand

just works with `fib' atm. we need a second "tracker-map" when emitting an
`invoke*' instruction. there we have to lookup and save related method
information.

Makefile: GHCi still broken

although
http://stackoverflow.com/questions/10123040/ghci-doesnt-work-with-ffi-export-declarations-shared-libaries
fixed an issue, there is now a different one:
> $ make ghci
> [...]
> Ok, modules loaded: Main, Mate.X86CodeGen, Mate.MethodPool, Mate.BasicBlocks, Mate.Utilities.
> Prelude Main> main
>
>
> GHCi runtime linker: fatal error: I found a duplicate definition for symbol
>    MateziUtilities_lookupMethod_srt
> whilst processing object file
>    ./Mate/Utilities.o
> This could be caused by:
>    * Loading two different object files which export the same symbol
>    * Specifying the same object file twice on the GHCi command line
>    * An incorrect `package.conf' entry, causing some object to be
>      loaded twice.
> GHCi cannot safely continue in this situation.  Exiting now.  Sorry.
>
> make: *** [ghci] Error 1

so, `make ghci' and `make tags' still doesn't work due to FFI stuff.
we have to use `make test' until we fix it :-(

Makefile: update rules

build: fix -Wall warnings

methodpool: small demo how to access a Data.Map instance from C

yes. it's ugly, unsafe, etc.
but it works :-)

main: remove PoC code

codegen: patch method calls on-demand via traps

we can determine the source of an invalid memory access via unix signal
handling. to do so, we write
 > mov (Addr 0) eax    ; 0x8905 0000 0000
which tries to access memory at address 0. upon first execution of this
instruction the signalhandler is called. there, we replace it with
 > nop                 ; 0x90
 > call <target>       ; 0xe8 YYYY YYYY  ; Y = target

at the moment, this just works with Fib.fib() (or other recursive methods)
as the <target> address is more or less hardcoded.

several TODOs:
- determine address of target method in a different way
- after a call, we have to throw away arguments of the call.
  this is hardcoded now.

codegen: execute generated code

woot! :-)  looks good

codegen: use label mechanism of harpy

more convenient than manual patching

basicblock: change order of `TwoTarget'

basicblock: also generate BB #0 when it's labeld with `Nothing' (BBEnd)

codegen: simple code generation stuff

generated code isn't tested yet

basicblock: remove warning

it can happen now ;-)

basicblock: refactor function interface

basicblock: build BBs from instructionstream

basicblock: get jump offsets from instructions

basicblock: calculate offset in instructionstream

src: move files into a Mate package

hence, ghc(i) is able to figuring out the correct path

Makefile: generate tags (for vim)

README: more install instructions

tests: add class with {do-,}while keyword

... which unfortunately fails to parse due to a bug in hs-java.

the bogus instructions are goto and if<cond>, which hs-java
misses to parse their immediate values from the instructionstream.

fix:
$ git clone git@wien.tomnetworks.com:hs-java.git || git clone git://wien.tomnetworks.com/hs-java.git
$ cd hs-java; cabal configure; cabal build; cabal install

basicblock: put \n between instructions

Makefile: build all class files in tests/

compile: use relative call

we have to calculate the offset, but it's cheaper than a register call

doc: some related papers

fixed broken Makefile (sry - forgot to check Makefile), added RegisterAllocation playground

Utilities, BasicBlock into src folder, BasicBlock sketching

Mate.hs now uses lately introduced Utilities lookupMethod

moved lookupMethod into separate Utilities file. added BasicBlocks playground

Merge branch 'master' of wien.tomnetworks.com:mate

doc: fixed english grammar mistakes (an on demand manner, analyses is plural of analysis)

doc: fixed englisch grammar mistakes (an on demand manner, analyses is plural of analysis)