[LLVM->SPIRV] Cast the GEP base pointer to source type upon mismatch

The source element type used in a GEP may differ
from the actual type of the pointer operand (e.g., `ptr i8` vs.
`ptr [N x T]`). This mismatch can lead to incorrect address computations
during translation to SPIR-V, which requires that pointer types match the
type of the object being accessed.

This patch inserts an explicit bitcast to convert the GEP pointer operand
to the expected type, derived from the GEP’s source element type, before
emitting an `PtrAccessChain`. This ensures the resulting SPIR-V
instruction has a correctly typed base pointer and produces valid
indexing behavior.

For example:
Before this change, the following GEP was translated incorrectly:
  `getelementptr(i8, ptr addrspace(1) @a_var, i64 2)`
Whereas this nearly equivalent GEP was handled correctly:
  `getelementptr inbounds ([2 x i8], ptr @a_var, i64 0, i64 1)`

Previously, the first form was incorrectly interpreted as:
  `getelementptr inbounds ([2 x i8], ptr @a_var, i64 0, i64 2)`

Author: karolzwolak

lib/SPIRV/SPIRVWriter.cpp

@@ -1474,6 +1474,15 @@ SPIRVValue *LLVMToSPIRVBase::transConstant(Value *V) {
   if (auto *ConstUE = dyn_cast<ConstantExpr>(V)) {
     if (auto *GEP = dyn_cast<GEPOperator>(ConstUE)) {
       auto *TransPointerOperand = transValue(GEP->getPointerOperand(), nullptr);
+      // Determine the expected pointer type from the GEP source element type.
+      Type *GepSourceElemTy = GEP->getSourceElementType();
+      SPIRVType *ExpectedPtrTy = transPointerType(GepSourceElemTy, GEP->getPointerAddressSpace());
+
+      // Ensure the base pointer's type matches the GEP's effective source element type.
+      if (TransPointerOperand->getType() != ExpectedPtrTy) {
+        TransPointerOperand = BM->addUnaryInst(OpBitcast, ExpectedPtrTy, TransPointerOperand, nullptr);
+      }
+
       std::vector<SPIRVWord> Ops = {TransPointerOperand->getId()};
       for (unsigned I = 0, E = GEP->getNumIndices(); I != E; ++I)
         Ops.push_back(transValue(GEP->getOperand(I + 1), nullptr)->getId());

test/gep-byte-operand.ll

@@ -0,0 +1,24 @@
+; RUN: llvm-as %s -o %t.bc
+; RUN: llvm-spirv %t.bc -spirv-text -o - | FileCheck %s
+; RUN: llvm-spirv %t.bc -o %t.spv
+
+; Make sure that when the GEP operand type doesn't match the source element type (here operand a_var is [2 x i16], but the source element is i8),
+; we cast the operand to the source element pointer type (a_var to i8*).
+
+target datalayout = "e-p:32:32-i64:64-v16:16-v24:32-v32:32-v48:64-v96:128-v192:256-v256:256-v512:512-v1024:1024"
+target triple = "spir-unknown-unknown"
+
+; CHECK-DAG: Name [[A_VAR:[0-9]+]] "a_var"
+; CHECK-DAG: Name [[GLOBAL_PTR:[0-9]+]] "global_ptr"
+
+; CHECK-DAG: TypeArray [[ARRAY_TYPE:[0-9]+]] [[USHORT_TYPE:[0-9]+]] [[CONST_2:[0-9]+]]
+; CHECK-DAG: TypePointer [[ARRAY_PTR_TYPE:[0-9]+]] 5 [[ARRAY_TYPE]]
+
+; CHECK-DAG: Variable [[ARRAY_PTR_TYPE]] [[A_VAR]] 5 [[INIT_ID:[0-9]+]]
+; CHECK-DAG: SpecConstantOp [[I8PTR:[0-9]+]] [[BITCAST:[0-9]+]] 124 [[A_VAR]]
+; CHECK-DAG: SpecConstantOp [[I8PTR]] [[PTRCHAIN:[0-9]+]] 67 [[BITCAST]] [[INDEX_ID:[0-9]+]]
+; CHECK-DAG: TypePointer [[PTR_PTR_TYPE:[0-9]+]] 5 [[I8PTR]]
+; CHECK-DAG: Variable [[PTR_PTR_TYPE]] [[GLOBAL_PTR]] 5 [[PTRCHAIN]]
+
+@a_var = dso_local addrspace(1) global [2 x i16] [i16 4, i16 5], align 2
+@global_ptr = dso_local addrspace(1) global ptr addrspace(1) getelementptr (i8, ptr addrspace(1) @a_var, i64 2), align 8