Prospective Mac build fix

Define ahead of time which "feature" set we want, i.e. no LLINT/DFG/JIT
code but only ENABLE(ASSEMBLER). Otherwise Platform.h will make a choice
for us depending on the platform.

Change-Id: I372dc690ecbc624e9d589f6f10078a7647fcb570
Reviewed-by: Erik Verbruggen <erik.verbruggen@digia.com>

Fix LLVM build

Change-Id: I7ae00a5e90087182d9f7d939db0a036c120e3b9b
Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>

Prospective Mac OS X build fix

open_memstream is not supported beyond Linux it seems, so do the
symbol replacing disassembly printing only on Linux.

Change-Id: I1eff6db9e10bd0ebbc06e967a61f998ee42438a8
Reviewed-by: Erik Verbruggen <erik.verbruggen@digia.com>

Add missing license headers

Change-Id: I59d602a0f2c1fefb03994ed32a3d697b176791ff
Reviewed-by: Lars Knoll <lars.knoll@digia.com>

Clean up arithmetic operation calls

Don't repeat calls to generateFunctionCall but use a helper macro to
get the name.

Change-Id: I394b1980cbd67f3ca94fc41402de2d5b99c45016
Reviewed-by: Lars Knoll <lars.knoll@digia.com>

Store booleans as 32 bit integers

The old code was giving valgrind warnings, because
we loaded the boolean (1 byte) as a 32 bit integer.
Instead simply store all booleans as 32 bit ints
to avoid the warnings.

Change-Id: I46c7f9fc9d8dfe52afd9bab2dbab8923aaa630f8
Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>

Send all debug output to stderr

qDebug() was used for part of the logging, which
uses stderr. Send everything else there as well.

Change-Id: I363dff3d2e4dd6f95bf0347f1df589ae2528fd32
Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>

Handle Integer_Type in a switch statement

Change-Id: I8e00636f0896cec7d18d645dd70db8a100bf5560
Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>

Remove almost all uses of __qmljs_init_string

Change-Id: I88130ec39958c75b70d898a352423908ac2ef1d4
Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>

Remove __qmljs_init_(number|boolean)

Change-Id: Iae59dfea39e44931bb2f7a6436bd2f1491bbf843
Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>

Introduce an integer type for Value

The type is not being used yet, but all runtime
methods should be updated and able to deal with
integer Values correctly.

In addition started to clean up the use of some of
__qmljs_* Value constructors.

Change-Id: I1cb2169a5731f6adcc990dcbc92bc96aa008079f
Reviewed-by: Simon Hausmann <simon.hausmann@digia.com>

Fix: make it possible to change the used LLVM installation.

If either the LLVM_INSTALL_DIR environment variable or the qmake
variable are set, use that to find the llvm-config utility. Changing
those is easier than modifying your path. Can be used if you have more
than one LLVM installation installed.

Change-Id: I24265b397e21f468ece61392a112de9a50c67c5a
Reviewed-by: Lars Knoll <lars.knoll@digia.com>

Fix stack corruption on ia32

On ia32 sizeof(void*) < sizeof(Value), so we need to subtract
sizeof(Value) instead of sizeof(void*) before reaching the first
temp.

Added comments to explain the offsets.

Change-Id: Iefbb1dc762fdf36d73002c52dc9c471ec15ff403
Reviewed-by: Lars Knoll <lars.knoll@digia.com>

Initial build fixes for arm

Fix a crash when generating optimised code

The base operation for OpInplaceAnd is OpBitAnd,
not OpAnd.

Implement copyValue using a single load/store pair in the common case of copying temps

Simplify boolean conditional jumps

* Expect the boolean value to be in Gpr0, which means after the __qmljs_to_boolean
  call the move(ReturnValueRegister, Gpr0) becomes a noop
* Instead of loading the true/1 into a register, use it as immediate value in the cmp

Make conditional jumps more readable

Fix ia32 build: make loadArgument available on all archs for copyValue

Fix stack corruption

The position of temporaries on the stack was
off by 1, leading to us overwriting other r14, that gets
pushed to the stack after we have allocated space for temps.

Simplify function header and footer on x86-64

Generate a few instructions less per function call.

Emit code for copying values

Remove __qmljs_copy in the process.

Work around gcc bug on amd64 with function pointer assignment

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