- Made ribbon test pass (still need to generate the golden image)
- Fixed a corner case with the register allocator. Actually, the insn selection is
able to remove dead code automatically. So, I handle this case now.
- Added a first support for undef values in vectors in the llvm to gen IR
compiler

Add support for insertion into vector of constants

Made compiler_clod pass. The image is now properly computed.
I basically added a bunch of new intrinsics and cleaned a bit the ocl std
library. Well, it is not going to be compliant for a while with the spec (mostly
due to precision issues and the way denormals and nan are handled). But,
it should do the job for now.
Started to add a more complex test called "ribbon"

Removed outdated html documentation files. Markdown files are OK.

Changed name of CMake utest program to make it match with the "Makefile version"

Removed c++ simulator documentation since it is going to be deprecated
Changed the name to "Beignet" for the complete project

Removed use of exceptions since LLVM may not support them (depending on how it
is compiled)

Fixed 32 bit compilation issue. Unfortunately dropped an alignment requirement
for the instructions

Started to add geometric functions (see OpenCL spec)

Added support for various math functions

Pushed back original headers we partially lost during the code base merge. Now
everything is properly tracked

Reset mandelbrot dimensions

Fixed select OCL builtin
Added a new mandelbrot (more efficient) still to improve regression and
funtionality coverage

Fixed a bug in the flag register allocator
Started to add more brutal test to improve functional regressions. Kind of
needed for big modifications that are going to come
Check switch case lowering functionality

Separate instruction data from the rest to prepare intrusive_list use for
ir::Instruction

Used intrusive_list for SelectionVector

Used intrusive_list for SelectionBlock
Removed some of the verbose and useless foreach

Used intrusive_list for SelectionInstruction

Added some more public functionality for intrusive_list

Used intrusive_list for forward list instruction scheduling

Added intrusive list implementation from Maciej Sinilo (MIT licensed)

Removed utest kernels used for the (removed) internal tests

Cleaned up disassembly code to make it used the new files (and not the mesa
files I quickly and dirtily included)

Removed compiler internal utests. We now have the OCL unit tests. We do not need
anymore to test each internal component as we did when the OCL parsing was not
here

Fixed issue with flag register encoding in instruction scheduling

Activated instruction scheduling
Implemented fall back to SIMD8 when register allocation fails
Cleaned up some memory leaks when exception is triggered

Fixed compilation issue with gcc 4.6

Handled null register when scheduling
Changed the way accumulator is written in the pre-ISA

Almost finished instruction scheduling. Just need to handle accumulator write
update when AccWrEn is set

Fixed bug in growing pool allocator

Fixed read/write dependencies for the insn scheduler

Started to make instruction scheduling work

First implementation (untested) of instruction scheduling. Now it is pretty
clear that a clean and generic implementation of intrusive_list is *overdue*

Removed unused files
Added extra functionalities to debug special allocator with valgrind

Cleaned up instruction selection interface. Push everything back to the cpp
using opaque implementation.
The selection implementation is a big blob now to split up

Cleaned up register allocator interface to limit dependencies
It uses now a pimpl interface

Made SelectionInstruction variable sized
Also used a linear allocator for them (for fast variable size allocation)

Implemented linear allocator to have both fast instruction allocation and
variable size for them
Started to revamp SelectionInstruction to make them variable sized

Started to implemented instruction scheduling

Improved MOVs generation while resolving PHIs

Fixed a warning with gcc 4.7 related to the use of zero sized arrays...

Implemented greedy instruction on DAG. The idea is mostly to merge instructions
bottom to top marking instructions to be generated on the fly
Several patterns are implemented like using immediates as the second source or
merging mul and add into mads

Actually implemented the MAD encoding at the same time.

Added proper flag register allocation. Flag are spilled into GRFs. The spilling
code is not reaaly efficient i.e. sometimes the spilling can be avoided in a
basic block but it is still done. The idea is to improve that when the general
GRF spilling will be implemented. Right now, it works, so it is good enough

Pushed back modified files for Gen extension support
Added tests in CMake files

Added support for some Gen extensions. The idea is mostly to play with Gen
specific hardware and propose simple way to use them. We have three extensions
here:
- Gen register regions. This allows us to perform strided loads in the register
file. To implement that on top of OCL, the idea is to encapsulate them in a
function with a side effect. Not really clean but it works.
- Gen gather from register file. Same idea but here we simply gather data from
a bunch of registers
- Vote any/all. This is basically the same idea as ptx i.e. uniform predicates
for branches.
- block read/write. Just to play with uniform load/store messages

I added a bunch of tests for all that and fix thing here and there to make them
work

Fixed a bug in register allocator

Fixed a bug with LLVM alloca
Fixed CFG linearization
Fixed a bug with function stack

Reenabled the CMake build path. It is really imperfect and the build CMake
scripts should be cleanly unified later

Fixed constness warning for gcc 4.7

Fixed build by adding LLVM library directory
Removed unnecessary dependencies to LLVM for libcl.so

Build tests

Signed-off-by: Keith Packard <keithp@keithp.com>

Fix build order between backend and cl library

Signed-off-by: Keith Packard <keithp@keithp.com>

Build .so and .so.0 versions of libgbe

Signed-off-by: Keith Packard <keithp@keithp.com>

Build backend before main library

Signed-off-by: Keith Packard <keithp@keithp.com>

Create make-based build infrastructure

It's simple, but it works on linux at least.

Signed-off-by: Keith Packard <keithp@keithp.com>

Create make-based build infrastructure

Fairly simplistic, but does the job for Linux at least.

Signed-off-by: Keith Packard <keithp@keithp.com>

Removed unused file

Removed a test that does not pass yet

Cleaned up SLM code

Conflicts:
utests/CMakeLists.txt

Added missing file

Used a hash map to handle OCL instrinsic functions

Started to support __local and __constant

Started to play with __local and __constant declarations

Removed unused file

Updated and compiled README

Recompiled the documentation

Updated compiled README

Made errors explicit while loading kernels

Fixed a typo in Release

Fix unitialized value in instruction selection

Fixed uninitialized values reported by valgrind

Properly added use of the custom allocators everywhere

Added more information in the README Checked memory leaks

Added missing file while using the blob (TM)

Spell-checked the documentation Added a TODO entry for uniform analysis and uniform loads and samples

Added more info on general plumbering to do

Added support for disassembling Gen ISA (instead of just using Fulsim...). It is quick and dirty since I copied files directly from Mesa (and therefore, I duplicated Gen structures and defines)

Added more stuff in the documentation.

Added more documentation

Started to clean up the headers

Added missing files in the documentation

Added more stuff in the documentation (mostly on how the branching code is handled in the compiler)

Implemented the description of the flat address space implementation

Added first documentation on flat address space Compiled markdown files

Fixed README

Added the markdown extension to the README file

Added the markdown extension to the README file

Fixed a exception safety issue in the LLVM to GenIR translation Added a markdown readme file

Improved markdown syntax for README

Cleaned up the code to enable the blob compilation path

Cleaned up the code from previous unused dependencies Upate the README

s/gen_eu.*/gen_encoder.*/g

s/GenEmitter/GenEncoder/g

Removed unused crap for the final encoding step

Removed even more kludge from previous register allocation

Removed kludge from pre instruction selection era

Removed kludge from previous register allocator

First working implementation of linear scan register allocator Spilling is still TODO

Implemented the first phase of the linear scan allocator

Played around for register allocation

Used first bits the register file memory allocator in the Gen register allocator