Private memory indexing OpenCL - opencl

Question

I am struggling with OpenCL specification, as I find it sometimes ambiguous, can someone try to answer the following questions ?
Consider the following code :
__kernel void myKernel(...)
{
// Buffer 1
__local float *buffer1[64];
// Buffer 2
__local float *buffer2;
// Buffer 3
__private float *buffer3[64];
// Buffer 4
float *buffer4[64];
int var1 = 1, var2 = 2;
nonKernelFunction(&var1, &var2);
// ...
}
void nonKernelFunction(int *pvar1, int *pvar2)
{
int *pvar;
if (someRunTimeCondition)
pvar = pvar1;
else
pvar = pvar2;
*pvar += 1;
}
1) Is there a difference (static or dynamic) between buffer1 and buffer2 ?
2) Are declarations of buffer3 and buffer4 equivalent (they are for variables, but I'm not sure for pointers) ?
3) On GPUs (where private memory is only registers I think), where will the compiler allocate the ressources ? If it is in global memory, is it possible to know how much memory will be used at run time, from the host ?
4) Assuming buffer3 and buffer4 are stored into registers, how can instructions like buffer3[i] = buffer4[i] (where i is known at run time) be allowed ?
5) If buffer3 and buffer4 are not stored into registers, then, how can nonKernelFunction code be allowed (var1 and var2 are definitely not in memory) ?
Thanks

Answer 1

AFAIK :
1) there is no technical difference between static specifications in the kernel code and "dynamic" specification by the host via a buffer;
2) by default variables are __private so this should not make any difference;
3) private memory MAY be allocated in registers if small but otherwise global memory will be used;
you can query minimum memory requirements for a kernel using clGetKernelWorkGroupInfo;
4) why should they not be allowed, because it might result in out-of-bound errors ?
5) var1 and var2 are in the address-space of the GPU, even if not in the private memory; access might be slower that's all.
EDIT1 :
The fact that var1 and var2 are in registers, say reg1 and reg2, should not be an issue as the code could result in pseudo-assembly like :
myKernel:
...
push reg1
push reg2
call nonKernelFunction
...
nonKernelFunction:
test someRunTimeCondition
jz ko
mov [SP+2] reg1
jmp end:
ko:
mov [SP+1] reg1
end:
mov [reg1] reg2
inc reg2
mov reg2 [reg1]
I don't know if GPUs assemblies/core-architectures are much different but on a standard CPU there is no issue because you use the stack to make abstraction of the effective locations.
Note that there is a more recent version of the spec here :) http://www.khronos.org/registry/cl/specs/opencl-1.2.pdf