llvm dev - Nov 2008 - [LLVMdev] Do I need to add new intrinsic functions for the OpenGL shading language swizzle?

OpenGL shading language (GLSL) is like a C subset language, but it contains
some special features, ex: native vector type & swizzle.
In GLSL, you can declare vector types:

void main()
{
  vec4 a;
  vec3 b;
  vec2 c;
}

You can access the element of vector by using .xyzw, it means the 1st, 2nd,
3rd, 4th element of the vector are x, y, z, w.
Ex:

void main()
{
  float f;
  vec4 a = vec4(1.0, 2.0, 3.0, 4.0);
  vec4 b = vec4(3.0, 4.0, 5.0, 6.0);

  v4.xyw = vec2(2.5, 3.3. 7.7);
  f = v4.y;

  b.xy += a.xy;
}

Because my chip supports this facility in instruction & register level, I
think I have to preserve the semantic of this 'vector' and
'swizzle'. I
don't think this GLSL::vector can be represented directly by the
llvm::vector type, because I can just operate on some elements on a
GLSL::vector rather than 4 elements all the time. (Am I right about this
thought?)

Hence, I think I would need to add some new 'intrinsic' function in
LLVM,
and use llvm::vector to represent GLSL::vector.

Ex:

vec4 a;
vec3 b
a.xyz = b;

will be translate to

llvm::vector<4> a;
llvm::vector<3> b;
intrinsic_vector3_to_vector4_assign(a, 0, 1, 2, b);

Then in the backend, I can see this intrinsic function, and do instruction
selections based on this intrinsic. Ex: intrinsic_vector3_to_vector4_assign
will be translated to single machine instruction: mov a.xyz, b.xyz.

Am I right on this thought? Does it really needs to add LLVM intrinsic
functions to support OpenGL shading language?
Or am I missing some really usful mechanism in LLVM to natively support
this?

Comments are welcome.

---
Wei Hu
http://www.csie.ntu.edu.tw/~r88052/
http://wei-hu-tw.blogspot.com/
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20081118/32443b11/attachment.html>

On Nov 17, 2008, at 6:51 PM, Wei wrote:
> Am I right on this thought? Does it really needs to add LLVM  
> intrinsic functions to support OpenGL shading language?
> Or am I missing some really usful mechanism in LLVM to natively  
> support this?
No, you don't need to extend LLVM for this.  We fully support vector  
operations (like shuffles, insertions, extractions) at the IR level.   
You should decompose these operations in your parser and then  
reassemble them in the code generator.

-Chris