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.

More work on the AOT.

Fix code generation for IR::Call nodes.

Start generating LLVM code for IR::Call nodes.

LLVM code for unary expressions

Generate LLVM code for the binary expressions

Generate LLVM code for the conditional jumps.

Some more work on the LLVM-based AOT compiler.

Move the defnition of the QML/JS Context to qmljs_runtime.h

Initial work on Object.prototype.getOwnPropertyNames.

At the moment getOwnPropertyNames is not compliant, e.g.
we need to add support for property accessors.

Implemented Object.prototype.isPrototypeOf

Naive implementation of the Arguments object.

Implemented Object.prototype.hasOwnProperty.

Note that the current implementation of Object::hasOwnProperty()
in the object model is not ECMA compliant (yet).

Implemented Object.getPrototypeOf and Object.prototype.valueOf

Add special property length of the Object constructor.

Initial work on the RegExp object

Initial work on the Object prototype

Initial work on [[HasProperty]]

Reimplemented Array using std::deque as container.

Fix default size for the bucket tables

Inline comparisons

Fix the pro file

Initial work on the LLVM-based AOT compiler.

Generalized instruction selection.

This will simplify the instruction selection pass for
different architectures.

Use `assert' instead of Q_ASSERT.

Generate cx-instructions for releational expressionsa.

Tests

Fix Array.prototype.concat