Use posix_memalign to ensure assert(!(code & 15))

Implement executalble memory using mmap

Fix non-release builds

Add missing return

Implement missing movs

implement visitExp

Implement construct property/value

Implement call value and property

Port remaining code to better function call mechanism

Fix closure init

Simplify more function calls

further call simplification

Simpler approach to function calls

Simplify passing temps as method arguments

A bit more inplace assignment implemented

Generate the code for copying the argments earlier, to avoid register clobbering between __qmljs_copy calls

Implement constructActivationProperty

Implement mov unop

Implement binop mov

Implement mov as string

Sprinkle a few more notImplemented()

Implement more of cjump

Add missing returns

Fix argument addressing to be in the right order

Fix move temp -> temp

Implemented part of visitCJump

Cleanup

Implement callActivationProperty, mov with target as name and closure init

Fix generation of multiple functions

Sine we can't reset the MacroAssembler properly right now, reconstruct
the isel for every function.

Fix stupid off-by-one in address calculation of temporaries on the stack

Simplified function call helpers

Prospective jump support

Implement basic name lookup

Implement simple value storage

Fix ret argumet passing

cleanup, squash

Call helper

correct temp handling

Cleanups, some rudimentary stubs so that "return 42" can be compiled :)

Fix code ownership

Add udis86 support

Initial import of MASM

Fix division operation

Proper NaN boxing for Value

All JS types are now encoded in a 8 byte data
structure. We use the 52 bits that are unused
when a double is a NaN to encode all other types
that can be stored inside a double.

This is being done by using a few bits to determine
the type, and up to 48 bits for data. This works
even on x64, as addresses (ie. pointers) are limited
to 48 bits on these platforms.

For most other types (except doubles), we store the
data in the lower 32 bits of the double.

Initial work on `eval'.

Do not try to optimize the `global object'.

This should simplify the implementation of `eval' and `with'.

Remove dead code.

Reduce the number of register-to-register copies.

Remember the value of the last executed expression only in EvalMode

Add support for global, eval and function code.

Remove specialized version of __qmljs_set

Remove dead code

Fix bug in jump logic

Make the jump relative to the offset value in the instruction stream.

Begin to implement moth vm

Implemented Function.prototype.apply

Fix possible crash when executing invalid code.

Add skeleton moth vme

Keep alive the exception handler block.

Remove dead code.

Fix make llvm_runtime

Add moth skeleton

Make IR types stricter

We can always loosen these again if we need to.

Import crypto.js from the V8 benchmark tests

Check addresses associated with basic blocks

Improve support for the assignment operators.

Also, use indirect calls in the amd64 code generator.

Fix the code generator

This change fixes a few typos in the code generator (e.g. usages of
_loop instead of loop), also it ensures that all function
declarations are processed before the statements.

Increase the size of the code cache.

This is just a temporary hack, we can't continue to use
a contiguous region of memory to store the code.

Shortcut more constant conditionals

Trim unreachable blocks

Fast track true and false conditionals.

Improve ex to nx conversion.

Only IR::Call has an nx conversion.

Incrementally update the control flow graph.

Remove useless calls to BasicBlock::isTerminated()

Ensure the block created by the labelled statement is terminated

Add support for labelled statements.

Remove dead code

Ensure that basic blocks are terminated.

Also make sure that the special BasicBlock `exitBlock' is always
the last block of the function.

Remove dead code

Add dummy functions for the assignment operators.

Import the ARM macro assembler from the mono project.

Fix LLVM code generation for unary expressions

Generate LLVM code for constructor calls

Delete properties

Resolve the library name

Generate LLVM code for the `this-expression'.

Don't use increments for now.

Initial work on exceptions for the AOT compiler.

Generate code for closures.

Warn about unimplement assignments.

Lower IR::Name nodes.

Generate LLVM code for MoveMember

Lower subscripts

Lower IR::Call and IR::New

Generate LLVM code for member expressions

Use O2-level inlining

Split __qmljs_add

Fix the targets

Compile simple IR::New nodes

Move the Alloca instructions at the beginning of the function.

Fix the return value of calls.