Blender Git Loki

Refactor of the node graph compiler class, to have a backend-agnostic base.

The main compiler class is now itself independent of LLVM and can be used for
future backends. The implementation of specific behavior (values, statements, etc.)
happens through a CodeGenerator implementation. This also uses aggregation rather
than inheritance on the compiler class part (which is not a virtual class itself).

Merge branch 'master' into object_nodes

Use a Scope concept for avoiding codegen for existing nodes.

Rather than a single socket value map, use a "scope" to keep track of which
nodes are already generated. This reintroduces the "block" idea from earlier
versions, but at the later codegen stage rather than the node graph.

Describing scope on the level of nodes becomes quite clumsy and ambiguous,
and moves nodes further away from the UI representation. The compiler can
handle this more elegantly without requiring persistent data.

Scopes can be nested. This is not used yet, but will allow scoped variables
later on, where the variables being used for a node path depend on its scope.

Removed/Disabled some deprecated code.

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.