Ignore generated files

Remove old assembler

Make it really work for 64 bit.

crypto.js passes now :)

More 64-bit fixes

Rudimentary amd64 port

Fix rethrow

Remove generated code

Fix compilation on amd64 (not working yet, just building)

Centralize value copying

Save and restore context register before calls

More debug info

First shot at more readable call instructions in output

Remember linked function names in prep for future debug help

Fix array subscript write: add missing context pointer argument to qmljs_set_element call

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.