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

Added more bits of byte scatter / gather and started to implement the conversion routines

Added first bits of byte scattered reads and writes in GenContext Started to clean up code to prepare a full-fledge register allocator

Removed mandelbrot from the tests

Fixed a bug in the IR context that created empty blocks

Start to implement UB GenReg

Removed more unused encoding stuff related to swizzles

Removed unused part of the encoding

Started to implement support for byte and shorts

Started to implement mandelbrot

Fixed wrong assertion

Debugged unstructured branch code

Added more tests for structured and unstructured branches Debugged the unstructured branch code

Fixed jumpi encoding problem

Fixed bug in fwd branch encoding

Fixed bug in the way to handle masked branches

Added several tests for unstructured branches

Cleaned up kernel directory

Added flat_address_space tests

Kept on

Finished the small test framework

Revamped tests to make them smaller and simpler (and more automatic to use)

tests -> utests

Sorted used / unused files in the test directory Made everything c++

fix gcc 4.7 compilation issues

Added some functionalities for the test framework

Made performance simulator work when using fulsim drm

Started to revmap the tests to make something easier and faster to use

Moved tests in a separate directory

Started to implement unstructured branches in the compiler

Added first support for branches

Added support for BlockIPs

Added first support for BlockIPs

Added support for shorts in the simulator

Played with SIMD8

Align driver code with new way to handle curbe

Simplify the way we handle curbe

Implemented a first quick and dirty mul32x32