Test case for OpenCL 1.1 supported data types

Add test case, OpenCL 1.1 Math Built-in Functions

test creating program objects, build program executable, build options, query program objects

Fix up README.md

miss a line "cd build" in section "How to build"

new test case from Nanhai.

Signed-off-by: Zhigang Gong <zhigang.gong@linux.intel.com>

First implementation for extension cl_khr_gl_sharing.

Signed-off-by: Zhigang Gong <zhigang.gong@linux.intel.com>

Remove glext.h.

It's part of ogl not ocl.

Signed-off-by: Zhigang Gong <zhigang.gong@linux.intel.com>

Only llvm3.0 and 3.1 have TargetData.h.

Signed-off-by: Zhigang Gong <zhigang.gong@linux.intel.com>

Fixed a potential Null pointer reference in emitMovForPHI.

Signed-off-by: Zhigang Gong <zhigang.gong@linux.intel.com>

Updated comment on lost copy since it is supported now

Implemented a work around for LLVM / clang 3.2. They handle swizzle of constant
vectors in a weird way such that the final LLVM code uses ConstantExpr which are
not supported yet. So, I modified the kernels to make them work.
Still two kernels are not working. They basically use undefined values which are
actually used. I am not supporting such case right now. It would be the
opportunity to simplify all this.

LLVM 3.2 works now. I needed to deactivate fmulall though. The code does not
seem to be correct. Well, I am not sure. May be related to the llvm+clang
version I have.

Improved llvm 3.2 support (remove some warnings using nasty macros)

Fixed lost copy issue when deSSAing the code. Yeah for even more MOV!!
global copy propagation is overdue!

Added complete support for barrier (and use of SLM)
Added some tests to assert this functionnality

Started to implement OpenCL barrier() function

Started the boiler plate for barrier (and fences) instructions
Improved the comment on the instruction selection

Removed MAD instruction in the IR

Added support for __local pointer in kernel arguments. This require to add more
features in the run-time and proper support in the rest of the compiler

Updated README since LLVM 3.1 is supported and LLVM 3.2 is almost supported

Improved the comment on the LLVM pass

Fixed more warning with LLVM 3.2
Redisabled LLVM 3.2. There are still problems. Some kernels output wrong code.
It is certainly the lost copy issue.

Fixed inverted assertion

Added a lengthy comment on the LLVM to Gen IR translation

Forbid use of LLVM 3.2 since there are still issues with the code generated by
clang 3.2

Fixed a warning when compiling with LLVM 3.1
Replaced invocatiopn of clang with dirty "system()" by a cleaner "popen()". The
cleanest solution should to use the clang API

Finished proper support for LLVM 3.1
All tests pass

Fixed a bug in llvm Gen backend

Fixed preprocessor defines for LLVM 3.0

Cleaned some old bitrot code in llvm_gen_backend
Started to implement support for llvm 3.2. There are problems for complex
kernels with this version. Maybe the lost copy issue.

Enabled assertions and internal errors for the compiler. The compiler missed too
many things to turn that off

Added support for llvm 3.1
Cleaned up some warnings
Forced pedantic option removal in the Makefile

Fixed a leak in the code using libdrm_intel

Made a quick pass to clean up a bit the headers (there is way too many "INLINE"
methods in this code)

Removed one useless rforeach for the basic blocks

Removed old bits of ir::Instruction

Started to revamp ir::Instruction class to make it use intrusive_list instead

Added supports for loads and stores of float8/float16

Implemented merge of identical immediates per basic block

Added a new menger sponge with no shadow (just to have an extra kernel a bit
simpler than menger sponge itself)

Added support for select instructions with embedded compares
Added missing Julia missing tests

Changed style of the comment for insn scheduling

Made the zero cycle strategy work. This stronly limits the register pressure.
Added a simpler version of Julia.
Added a lengthy comment on the instruction scheduling strategy

Added a additional rule for MADs. When we try to avoid spilling, we do not
generate MADs

Added more features to the instruction scheduler to support both pre-register
allocation and post-register allocation scheduling
Well, we really need to implement something really good for the pre-reg
allocation scheduling to avoid spilling (which is not supported anyway today)

Fixed a potential bug with cvar
Fixed MAD related cvar initialization in c++ pre-main

Added julia set
Improved a bit the MOV removal pass

Added three kernels from Inigo website. Be aware that glsl mod functions is not
the same as ocl one... Damn :-)

Farctorized the code for the kernels I picked up from Inigo websites

Removed the remaining bits of the Gen specific extensions. Much cleaner code
now.

Started to remove support for gen extensions. This was basically a quick fire
and forget code to play a bit with ideas similar to what NV proposed. The goal
is to make the code we have as much clear as we can. So, I just removed
everything.

Removed the remaining bits of the c++ simulator. We only need the support for
real hardware here. Nothing more.

Updated the utest Makefile

- Added reference images for all the remaining tests that need them
- Added a lengthy comment on instruction selection
- Added some new patters to improve immediate matching

- 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