Blender Git Loki

Disabled compiling and eval of broken BVM functions, to simplify debugging until they can be reimplemented.

Use persistent pass managers for optimization, rather than creating them every time.

Set a target triple and data layout for modules.

According to the site below, this is necessary for proper optimization.

http://llvm.org/docs/Frontend/PerformanceTips.html

Generalized code generation for nodes to support more complex control flow in the future.

The basic idea is that a node represents a function F, without assuming anything about
how the input expressions are evaluated:

F = F()

In most common case this function can be decomposed and defined in terms of concrete values,
which are given by the input expressions:

F = F'(G1(), G2(), ...), where Gn are the respective inputs of the node

This is a first *very* naive implementation. It would rely heavily on common-subexpression-
elimination (CSE) to avoid generating the same code paths over and over again. There should
probably be some initial optimization on the BVM node level instead of relying just on LLVM passes.

The purpose of this generalization is to allow more complicated control flow inside node functions.
Nodes would then also be able to take additional variable arguments (e.g. an index), which can
be modified before being used as internal arguments for input expressions.

Merge branch 'master' into object_nodes

Basic Gabor noise implementation for BLI_noise and blenvm.

This is just the very basic version of the sparse convolution noise
with a Gabor kernel. It does not yet have derivatives or anisotropic
filtering. The only frequency spectrum implemented atm is isotropic
band-limited noise.

Removed cmake macro entry for deleted bf_blenvm_llvm_modules.

Support for image sampling in the LLVM backend.

This reintroduces the "globals" concept for mapping ID datablocks with
a consistent permanent identifier key.

Fix invalid function signature when passing derivatives for types that don't support them.

Unify code generation through the llvm API.

Also standard functions for copying and zeroing values are now
implemented per type rather than relying on a simple load/store.
This will become more important with larger aggregate types such as matrix44.

Removed the unused "simple" (without derivatives) compiler implementation.

As long as the compiler class is WIP the two implementations go out of sync too
easily. Better to make a copy of the dual version and then reduce it when the
compiler class is reasonably stable.

Removed the WITH_IRMODULES option, used previously for loading IR code from text files.

This approach suffers from difficulty of generating machine-independent IR code
and is better generated using the C++ API directly. The llc tool can be used to suggest
implementations with C++ API usage, see for example
http://fdiv.net/2012/11/16/llvm-generates-code-that-generates-code

Merge branch 'master' into object_nodes

Generate names for formal function parameters to make LLVM output more readable.

Note that these names are not identifiers and don't have to be unique, their only
purpose is to aid in understanding the generated LLVM code.

Replace function signature for dual values with a flattened sequence of basic types.

This avoids the allocation of aggregate struct space for duals and allows better
optimizations.

Move the node-output-to-value map into compiler subclasses.

This is in preparation for specializing the value types of compiler implementations,
so that we can replace dual struct types with independent llvm values.

Rename NodeValue to NodeConstant, to make it more consistent with LLVM naming.

Cleanup: use argument pointers for aggregate base types.

Merge branch 'master' into object_nodes

Derivatives for all the basic math node functions.