Infinite loop when translating llvm global variable to SPRIV

Encountered an infinite loop when coverting the following OpenCL kernel to SPIRV binary. The source code is:

`typedef struct {`
` int first;`
` constant int* firstPtr;`
`} ConstantPool;`

`constant ConstantPool constants = { 1, &constants.first };`

`kernel void constant_struct_with_pointer_to_own_field(void)`
`{ ... }`

This struct is a little bit weird, but llvm creates the following globalvariable:

`%struct.ConstantPool = type { i32, i32 addrspace(2)* }`

`@constants = dso_local addrspace(2) constant %struct.ConstantPool { i32 1, i32 addrspace(2)* getelementptr inbounds (%struct.ConstantPool, %struct.ConstantPool addrspace(2)* @constants, i32 0, i32 0) }, align 4
`

The problem is that `transConstant` have the following code:

As a struct, the transCosntant pushes all operands and call tranValue again. In my case, one operand finally reaches the value itself, which causes an infinite loop.

How to avoid this infinit loop? IMO, even we don't implement the global variable containing a llvm::ConstantExpr of itself (which seems hard to represent in spirv?), we should assert a scenario like this?

Start by tracing transConstant and transValue using the self-referential LLVM global shown in the issue, reproducing the OpenCL kernel translation to confirm the recursion. Determine how this case should terminate, then verify that translation no longer loops and that the resulting diagnostic or handling matches the chosen behavior.

Written by the indexing model from the issue text.