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

Implemented the CURBE allocation with the register file allocator

Started to implement proper allocation of curbe entries

Fixed the comment for block coalescing

Started to implement the generic memory allocator used to register allocate the programs

Removed this selection tile crap. It was just a bad idea. Instead use a selection block that basically keeps track of the way basic blocks are encoding while performing the instruction selection

Fixed scalar register encoding for untyped reads and writes

Played around for the new back end boilerplate

Fixed various bug in the new boilerplate (selection / allocation / encoding)

Simplify the new emission code

Finished first implementation of the boiler plate code to separate instruction selection from the rest (final encoding and register allocation). Neither debugged nor activated.

Added most of the boiler plate for the instruction selection and vector allocation (i.e. the registers that need to be contiguous are allocated together in vectors)

Prepare the work for proper register allocation (i.e. after instruction selection)

Move the register allocation in a dedicated class

Implemented first methods of the gen selection engine

Fixed compilation

Started to segment the final code generation into: - instruction selection phase - register allocation - mov insertion - instruction scheduling - instrucition encoding

Started with the instruction selection engine

Now booleans are encoded with 1 short instead of a vector of shorts.

Fixed typo in the curbe load for SimContext

Fixed compilation with gcc 4.7

Added support for bool to int conversion (that uses a select)

Fixed a type in a range-based for loop

Made a systematic of range-based for loops when it is possible

Replace some C cast by C++ const_cast to make things a bit more pure and clearer...

s/getInput/getArg/g (just to make things consistent with the previous related renaming)

Removed unused file

Added first support for structure kernel arguments (anything bigger than 4 bytes). They work on c++ simulator and regular Gen backend