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

Added missing tests and kernels for structure arguments

Added first support for structure arguments (bigger than 4 bytes for 32 bit Gen) They work for both c++ simulator and Gen back-ends

Started constant_push handling Started to revamp the custom allocators

s/input/arg/g

s/FunctionInput/FunctionArgument/g

Properly identified the three cases for the function argument

Fixed a bug in masked gathe for the simulator

Started to handle structure arguments

Added some first support for function arguments that are just values (int, short, char and of course pointers)

Added more tests for function arguments

Added one more test for the arrays

Added proper support for stack in Gen backend

Added missing lowering files

Added first support for stack Only c++ simulator can handle it right now

Added first test for stack handling

Added support for lowering of return instruction

Added tests for return instruction lowering

Made mandelbrot pass in the C++ simulator Made (actually) all tests pass in the C++ simulator

Added support for byte registers in the simulator Added byte scatters / gathers in the simulator Added conversion instructions in the simulator

Added support for loads and stores of uint2/3/4

Added tests for uint2/3/4 loads / stores and unaligned versions of them

Made Mandelbrot work on Fulsim (SIMD8 only right now)

Fixed FP division

Added load immediates of bytes and shorts

Added tests for load immediates of bytes and shorts

Added tests for shorts and bytes operations

Simplified a lot the encoding and the back end. Added support for bytes

Activated all the tests. Byte conversion now works fine

Fixed this damn fucking relocation bug!

Fixed a bug while providing local IDs in the CURBE

Added first test for byte scatter reads / writes

Reencode a new surface state to make fulsim happy while using byte scattered reads and writes with flat address space

Played around with byte scatters / gathers