Skip to content

Commit 80301a6

Browse files
whitneywhtsangwhitneywhtsang
committed
[SYCL-MLIR] Fix merge
Signed-off-by: Tsang, Whitney <whitney.tsang@intel.com>
1 parent 2fee8ea commit 80301a6

32 files changed

+223
-154
lines changed

‎clang/lib/CodeGen/CGBuiltin.cpp‎

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -225,8 +225,7 @@ static Value *MakeBinaryAtomicValue(
225225

226226
llvm::IntegerType *IntType = llvm::IntegerType::get(
227227
CGF.getLLVMContext(), CGF.getContext().getTypeSize(T));
228-
llvm::Type *IntPtrType =
229-
llvm::PointerType::get(CGF.getLLVMContext(), AddrSpace);
228+
llvm::Type *IntPtrType = IntType->getPointerTo(AddrSpace);
230229
#endif // INTEL_SYCL_OPAQUEPOINTER_READY
231230

232231
llvm::Value *Args[2];

‎clang/lib/CodeGen/CGVTables.cpp‎

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -739,7 +739,11 @@ void CodeGenVTables::addVTableComponent(ConstantArrayBuilder &builder,
739739
vtableHasLocalLinkage,
740740
/*isCompleteDtor=*/false);
741741
else
742+
#ifdef INTEL_SYCL_OPAQUEPOINTER_READY
742743
return builder.add(rtti);
744+
#else // INTEL_SYCL_OPAQUEPOINTER_READY
745+
return builder.add(llvm::ConstantExpr::getBitCast(rtti, CGM.Int8PtrTy));
746+
#endif // INTEL_SYCL_OPAQUEPOINTER_READY
743747

744748
case VTableComponent::CK_FunctionPointer:
745749
case VTableComponent::CK_CompleteDtorPointer:
@@ -785,7 +789,11 @@ void CodeGenVTables::addVTableComponent(ConstantArrayBuilder &builder,
785789
CGM.CreateRuntimeFunction(fnTy, name).getCallee());
786790
if (auto f = dyn_cast<llvm::Function>(fn))
787791
f->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
792+
#ifdef INTEL_SYCL_OPAQUEPOINTER_READY
788793
return fn;
794+
#else // INTEL_SYCL_OPAQUEPOINTER_READY
795+
return llvm::ConstantExpr::getBitCast(fn, CGM.Int8PtrTy);
796+
#endif // INTEL_SYCL_OPAQUEPOINTER_READY
789797
};
790798

791799
llvm::Constant *fnPtr;
@@ -824,6 +832,7 @@ void CodeGenVTables::addVTableComponent(ConstantArrayBuilder &builder,
824832
builder, fnPtr, vtableAddressPoint, vtableHasLocalLinkage,
825833
component.getKind() == VTableComponent::CK_CompleteDtorPointer);
826834
} else {
835+
#ifdef INTEL_SYCL_OPAQUEPOINTER_READY
827836
// TODO: this icky and only exists due to functions being in the generic
828837
// address space, rather than the global one, even though they are
829838
// globals; fixing said issue might be intrusive, and will be done
@@ -835,6 +844,9 @@ void CodeGenVTables::addVTableComponent(ConstantArrayBuilder &builder,
835844
fnPtr =
836845
llvm::ConstantExpr::getAddrSpaceCast(fnPtr, CGM.GlobalsInt8PtrTy);
837846
return builder.add(fnPtr);
847+
#else // INTEL_SYCL_OPAQUEPOINTER_READY
848+
return builder.add(llvm::ConstantExpr::getBitCast(fnPtr, CGM.Int8PtrTy));
849+
#endif // INTEL_SYCL_OPAQUEPOINTER_READY
838850
}
839851
}
840852

‎clang/lib/CodeGen/ItaniumCXXABI.cpp‎

Lines changed: 16 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -3466,7 +3466,11 @@ ItaniumRTTIBuilder::GetAddrOfExternalRTTIDescriptor(QualType Ty) {
34663466
}
34673467
}
34683468

3469+
#ifdef INTEL_SYCL_OPAQUEPOINTER_READY
34693470
return GV;
3471+
#else // INTEL_SYCL_OPAQUEPOINTER_READY
3472+
return llvm::ConstantExpr::getBitCast(GV, CGM.Int8PtrTy);
3473+
#endif // INTEL_SYCL_OPAQUEPOINTER_READY
34703474
}
34713475

34723476
/// TypeInfoIsInStandardLibrary - Given a builtin type, returns whether the type
@@ -3946,7 +3950,11 @@ llvm::Constant *ItaniumRTTIBuilder::BuildTypeInfo(QualType Ty) {
39463950
assert(!OldGV->hasAvailableExternallyLinkage() &&
39473951
"available_externally typeinfos not yet implemented");
39483952

3953+
#ifdef INTEL_SYCL_OPAQUEPOINTER_READY
39493954
return OldGV;
3955+
#else // INTEL_SYCL_OPAQUEPOINTER_READY
3956+
return llvm::ConstantExpr::getBitCast(OldGV, CGM.Int8PtrTy);
3957+
#endif // INTEL_SYCL_OPAQUEPOINTER_READY
39503958
}
39513959

39523960
// Check if there is already an external RTTI descriptor for this type.
@@ -4008,7 +4016,11 @@ llvm::Constant *ItaniumRTTIBuilder::BuildTypeInfo(
40084016
TypeNameField =
40094017
llvm::ConstantExpr::getIntToPtr(TypeNameField, CGM.GlobalsInt8PtrTy);
40104018
} else {
4019+
#ifdef INTEL_SYCL_OPAQUEPOINTER_READY
40114020
TypeNameField = TypeName;
4021+
#else // INTEL_SYCL_OPAQUEPOINTER_READY
4022+
TypeNameField = llvm::ConstantExpr::getBitCast(TypeName, CGM.Int8PtrTy);
4023+
#endif // INTEL_SYCL_OPAQUEPOINTER_READY
40124024
}
40134025
Fields.push_back(TypeNameField);
40144026

@@ -4170,7 +4182,11 @@ llvm::Constant *ItaniumRTTIBuilder::BuildTypeInfo(
41704182
TypeName->setPartition(CGM.getCodeGenOpts().SymbolPartition);
41714183
GV->setPartition(CGM.getCodeGenOpts().SymbolPartition);
41724184

4185+
#ifdef INTEL_SYCL_OPAQUEPOINTER_READY
41734186
return GV;
4187+
#else // INTEL_SYCL_OPAQUEPOINTER_READY
4188+
return llvm::ConstantExpr::getBitCast(GV, CGM.Int8PtrTy);
4189+
#endif // INTEL_SYCL_OPAQUEPOINTER_READY
41744190
}
41754191

41764192
/// BuildObjCObjectTypeInfo - Build the appropriate kind of type_info

‎llvm/lib/Transforms/Instrumentation/ThreadSanitizer.cpp‎

Lines changed: 42 additions & 34 deletions
Original file line numberDiff line numberDiff line change
@@ -205,7 +205,7 @@ void ThreadSanitizer::initialize(Module &M, const TargetLibraryInfo &TLI) {
205205
Attr = Attr.addFnAttribute(Ctx, Attribute::NoUnwind);
206206
// Initialize the callbacks.
207207
TsanFuncEntry = M.getOrInsertFunction("__tsan_func_entry", Attr,
208-
IRB.getVoidTy(), IRB.getPtrTy());
208+
IRB.getVoidTy(), IRB.getInt8PtrTy());
209209
TsanFuncExit =
210210
M.getOrInsertFunction("__tsan_func_exit", Attr, IRB.getVoidTy());
211211
TsanIgnoreBegin = M.getOrInsertFunction("__tsan_ignore_thread_begin", Attr,
@@ -220,49 +220,49 @@ void ThreadSanitizer::initialize(Module &M, const TargetLibraryInfo &TLI) {
220220
std::string BitSizeStr = utostr(BitSize);
221221
SmallString<32> ReadName("__tsan_read" + ByteSizeStr);
222222
TsanRead[i] = M.getOrInsertFunction(ReadName, Attr, IRB.getVoidTy(),
223-
IRB.getPtrTy());
223+
IRB.getInt8PtrTy());
224224

225225
SmallString<32> WriteName("__tsan_write" + ByteSizeStr);
226226
TsanWrite[i] = M.getOrInsertFunction(WriteName, Attr, IRB.getVoidTy(),
227-
IRB.getPtrTy());
227+
IRB.getInt8PtrTy());
228228

229229
SmallString<64> UnalignedReadName("__tsan_unaligned_read" + ByteSizeStr);
230230
TsanUnalignedRead[i] = M.getOrInsertFunction(
231-
UnalignedReadName, Attr, IRB.getVoidTy(), IRB.getPtrTy());
231+
UnalignedReadName, Attr, IRB.getVoidTy(), IRB.getInt8PtrTy());
232232

233233
SmallString<64> UnalignedWriteName("__tsan_unaligned_write" + ByteSizeStr);
234234
TsanUnalignedWrite[i] = M.getOrInsertFunction(
235-
UnalignedWriteName, Attr, IRB.getVoidTy(), IRB.getPtrTy());
235+
UnalignedWriteName, Attr, IRB.getVoidTy(), IRB.getInt8PtrTy());
236236

237237
SmallString<64> VolatileReadName("__tsan_volatile_read" + ByteSizeStr);
238238
TsanVolatileRead[i] = M.getOrInsertFunction(
239-
VolatileReadName, Attr, IRB.getVoidTy(), IRB.getPtrTy());
239+
VolatileReadName, Attr, IRB.getVoidTy(), IRB.getInt8PtrTy());
240240

241241
SmallString<64> VolatileWriteName("__tsan_volatile_write" + ByteSizeStr);
242242
TsanVolatileWrite[i] = M.getOrInsertFunction(
243-
VolatileWriteName, Attr, IRB.getVoidTy(), IRB.getPtrTy());
243+
VolatileWriteName, Attr, IRB.getVoidTy(), IRB.getInt8PtrTy());
244244

245245
SmallString<64> UnalignedVolatileReadName("__tsan_unaligned_volatile_read" +
246246
ByteSizeStr);
247247
TsanUnalignedVolatileRead[i] = M.getOrInsertFunction(
248-
UnalignedVolatileReadName, Attr, IRB.getVoidTy(), IRB.getPtrTy());
248+
UnalignedVolatileReadName, Attr, IRB.getVoidTy(), IRB.getInt8PtrTy());
249249

250250
SmallString<64> UnalignedVolatileWriteName(
251251
"__tsan_unaligned_volatile_write" + ByteSizeStr);
252252
TsanUnalignedVolatileWrite[i] = M.getOrInsertFunction(
253-
UnalignedVolatileWriteName, Attr, IRB.getVoidTy(), IRB.getPtrTy());
253+
UnalignedVolatileWriteName, Attr, IRB.getVoidTy(), IRB.getInt8PtrTy());
254254

255255
SmallString<64> CompoundRWName("__tsan_read_write" + ByteSizeStr);
256256
TsanCompoundRW[i] = M.getOrInsertFunction(
257-
CompoundRWName, Attr, IRB.getVoidTy(), IRB.getPtrTy());
257+
CompoundRWName, Attr, IRB.getVoidTy(), IRB.getInt8PtrTy());
258258

259259
SmallString<64> UnalignedCompoundRWName("__tsan_unaligned_read_write" +
260260
ByteSizeStr);
261261
TsanUnalignedCompoundRW[i] = M.getOrInsertFunction(
262-
UnalignedCompoundRWName, Attr, IRB.getVoidTy(), IRB.getPtrTy());
262+
UnalignedCompoundRWName, Attr, IRB.getVoidTy(), IRB.getInt8PtrTy());
263263

264264
Type *Ty = Type::getIntNTy(Ctx, BitSize);
265-
Type *PtrTy = PointerType::get(Ctx, 0);
265+
Type *PtrTy = Ty->getPointerTo();
266266
SmallString<32> AtomicLoadName("__tsan_atomic" + BitSizeStr + "_load");
267267
TsanAtomicLoad[i] =
268268
M.getOrInsertFunction(AtomicLoadName,
@@ -318,9 +318,9 @@ void ThreadSanitizer::initialize(Module &M, const TargetLibraryInfo &TLI) {
318318
}
319319
TsanVptrUpdate =
320320
M.getOrInsertFunction("__tsan_vptr_update", Attr, IRB.getVoidTy(),
321-
IRB.getPtrTy(), IRB.getPtrTy());
321+
IRB.getInt8PtrTy(), IRB.getInt8PtrTy());
322322
TsanVptrLoad = M.getOrInsertFunction("__tsan_vptr_read", Attr,
323-
IRB.getVoidTy(), IRB.getPtrTy());
323+
IRB.getVoidTy(), IRB.getInt8PtrTy());
324324
TsanAtomicThreadFence = M.getOrInsertFunction(
325325
"__tsan_atomic_thread_fence",
326326
TLI.getAttrList(&Ctx, {0}, /*Signed=*/true, /*Ret=*/false, Attr),
@@ -332,15 +332,15 @@ void ThreadSanitizer::initialize(Module &M, const TargetLibraryInfo &TLI) {
332332
IRB.getVoidTy(), OrdTy);
333333

334334
MemmoveFn =
335-
M.getOrInsertFunction("__tsan_memmove", Attr, IRB.getPtrTy(),
336-
IRB.getPtrTy(), IRB.getPtrTy(), IntptrTy);
335+
M.getOrInsertFunction("__tsan_memmove", Attr, IRB.getInt8PtrTy(),
336+
IRB.getInt8PtrTy(), IRB.getInt8PtrTy(), IntptrTy);
337337
MemcpyFn =
338-
M.getOrInsertFunction("__tsan_memcpy", Attr, IRB.getPtrTy(),
339-
IRB.getPtrTy(), IRB.getPtrTy(), IntptrTy);
338+
M.getOrInsertFunction("__tsan_memcpy", Attr, IRB.getInt8PtrTy(),
339+
IRB.getInt8PtrTy(), IRB.getInt8PtrTy(), IntptrTy);
340340
MemsetFn = M.getOrInsertFunction(
341341
"__tsan_memset",
342342
TLI.getAttrList(&Ctx, {1}, /*Signed=*/true, /*Ret=*/false, Attr),
343-
IRB.getPtrTy(), IRB.getPtrTy(), IRB.getInt32Ty(), IntptrTy);
343+
IRB.getInt8PtrTy(), IRB.getInt8PtrTy(), IRB.getInt32Ty(), IntptrTy);
344344
}
345345

346346
static bool isVtableAccess(Instruction *I) {
@@ -613,14 +613,17 @@ bool ThreadSanitizer::instrumentLoadOrStore(const InstructionInfo &II,
613613
StoredValue = IRB.CreateExtractElement(
614614
StoredValue, ConstantInt::get(IRB.getInt32Ty(), 0));
615615
if (StoredValue->getType()->isIntegerTy())
616-
StoredValue = IRB.CreateIntToPtr(StoredValue, IRB.getPtrTy());
616+
StoredValue = IRB.CreateIntToPtr(StoredValue, IRB.getInt8PtrTy());
617617
// Call TsanVptrUpdate.
618-
IRB.CreateCall(TsanVptrUpdate, {Addr, StoredValue});
618+
IRB.CreateCall(TsanVptrUpdate,
619+
{IRB.CreatePointerCast(Addr, IRB.getInt8PtrTy()),
620+
IRB.CreatePointerCast(StoredValue, IRB.getInt8PtrTy())});
619621
NumInstrumentedVtableWrites++;
620622
return true;
621623
}
622624
if (!IsWrite && isVtableAccess(II.Inst)) {
623-
IRB.CreateCall(TsanVptrLoad, Addr);
625+
IRB.CreateCall(TsanVptrLoad,
626+
IRB.CreatePointerCast(Addr, IRB.getInt8PtrTy()));
624627
NumInstrumentedVtableReads++;
625628
return true;
626629
}
@@ -652,7 +655,7 @@ bool ThreadSanitizer::instrumentLoadOrStore(const InstructionInfo &II,
652655
else
653656
OnAccessFunc = IsWrite ? TsanUnalignedWrite[Idx] : TsanUnalignedRead[Idx];
654657
}
655-
IRB.CreateCall(OnAccessFunc, Addr);
658+
IRB.CreateCall(OnAccessFunc, IRB.CreatePointerCast(Addr, IRB.getInt8PtrTy()));
656659
if (IsCompoundRW || IsWrite)
657660
NumInstrumentedWrites++;
658661
if (IsCompoundRW || !IsWrite)
@@ -688,19 +691,17 @@ static ConstantInt *createOrdering(IRBuilder<> *IRB, AtomicOrdering ord) {
688691
bool ThreadSanitizer::instrumentMemIntrinsic(Instruction *I) {
689692
InstrumentationIRBuilder IRB(I);
690693
if (MemSetInst *M = dyn_cast<MemSetInst>(I)) {
691-
Value *Cast1 = IRB.CreateIntCast(M->getArgOperand(1), IRB.getInt32Ty(), false);
692-
Value *Cast2 = IRB.CreateIntCast(M->getArgOperand(2), IntptrTy, false);
693694
IRB.CreateCall(
694695
MemsetFn,
695-
{M->getArgOperand(0),
696-
Cast1,
697-
Cast2});
696+
{IRB.CreatePointerCast(M->getArgOperand(0), IRB.getInt8PtrTy()),
697+
IRB.CreateIntCast(M->getArgOperand(1), IRB.getInt32Ty(), false),
698+
IRB.CreateIntCast(M->getArgOperand(2), IntptrTy, false)});
698699
I->eraseFromParent();
699700
} else if (MemTransferInst *M = dyn_cast<MemTransferInst>(I)) {
700701
IRB.CreateCall(
701702
isa<MemCpyInst>(M) ? MemcpyFn : MemmoveFn,
702-
{M->getArgOperand(0),
703-
M->getArgOperand(1),
703+
{IRB.CreatePointerCast(M->getArgOperand(0), IRB.getInt8PtrTy()),
704+
IRB.CreatePointerCast(M->getArgOperand(1), IRB.getInt8PtrTy()),
704705
IRB.CreateIntCast(M->getArgOperand(2), IntptrTy, false)});
705706
I->eraseFromParent();
706707
}
@@ -723,7 +724,11 @@ bool ThreadSanitizer::instrumentAtomic(Instruction *I, const DataLayout &DL) {
723724
int Idx = getMemoryAccessFuncIndex(OrigTy, Addr, DL);
724725
if (Idx < 0)
725726
return false;
726-
Value *Args[] = {Addr,
727+
const unsigned ByteSize = 1U << Idx;
728+
const unsigned BitSize = ByteSize * 8;
729+
Type *Ty = Type::getIntNTy(IRB.getContext(), BitSize);
730+
Type *PtrTy = Ty->getPointerTo();
731+
Value *Args[] = {IRB.CreatePointerCast(Addr, PtrTy),
727732
createOrdering(&IRB, LI->getOrdering())};
728733
Value *C = IRB.CreateCall(TsanAtomicLoad[Idx], Args);
729734
Value *Cast = IRB.CreateBitOrPointerCast(C, OrigTy);
@@ -737,7 +742,8 @@ bool ThreadSanitizer::instrumentAtomic(Instruction *I, const DataLayout &DL) {
737742
const unsigned ByteSize = 1U << Idx;
738743
const unsigned BitSize = ByteSize * 8;
739744
Type *Ty = Type::getIntNTy(IRB.getContext(), BitSize);
740-
Value *Args[] = {Addr,
745+
Type *PtrTy = Ty->getPointerTo();
746+
Value *Args[] = {IRB.CreatePointerCast(Addr, PtrTy),
741747
IRB.CreateBitOrPointerCast(SI->getValueOperand(), Ty),
742748
createOrdering(&IRB, SI->getOrdering())};
743749
CallInst *C = CallInst::Create(TsanAtomicStore[Idx], Args);
@@ -754,7 +760,8 @@ bool ThreadSanitizer::instrumentAtomic(Instruction *I, const DataLayout &DL) {
754760
const unsigned ByteSize = 1U << Idx;
755761
const unsigned BitSize = ByteSize * 8;
756762
Type *Ty = Type::getIntNTy(IRB.getContext(), BitSize);
757-
Value *Args[] = {Addr,
763+
Type *PtrTy = Ty->getPointerTo();
764+
Value *Args[] = {IRB.CreatePointerCast(Addr, PtrTy),
758765
IRB.CreateIntCast(RMWI->getValOperand(), Ty, false),
759766
createOrdering(&IRB, RMWI->getOrdering())};
760767
CallInst *C = CallInst::Create(F, Args);
@@ -768,11 +775,12 @@ bool ThreadSanitizer::instrumentAtomic(Instruction *I, const DataLayout &DL) {
768775
const unsigned ByteSize = 1U << Idx;
769776
const unsigned BitSize = ByteSize * 8;
770777
Type *Ty = Type::getIntNTy(IRB.getContext(), BitSize);
778+
Type *PtrTy = Ty->getPointerTo();
771779
Value *CmpOperand =
772780
IRB.CreateBitOrPointerCast(CASI->getCompareOperand(), Ty);
773781
Value *NewOperand =
774782
IRB.CreateBitOrPointerCast(CASI->getNewValOperand(), Ty);
775-
Value *Args[] = {Addr,
783+
Value *Args[] = {IRB.CreatePointerCast(Addr, PtrTy),
776784
CmpOperand,
777785
NewOperand,
778786
createOrdering(&IRB, CASI->getSuccessOrdering()),

‎mlir-sycl/include/mlir/Dialect/SYCL/IR/SYCLOps.td‎

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -402,6 +402,12 @@ def SYCLCallOp : SYCL_Op<"call", [CallOpInterface]> {
402402
operand_range getArgOperands() {
403403
return {arg_operand_begin(), arg_operand_end()};
404404
}
405+
406+
/// Get the argument operands to the called function as a mutable range, this is
407+
/// required by the call interface.
408+
MutableOperandRange getArgOperandsMutable() {
409+
return getArgsMutable();
410+
}
405411
}];
406412

407413
let assemblyFormat = [{

‎mlir-sycl/test/Conversion/SYCLToLLVM/sycl-methods-flat-to-llvm-typed-pointer.mlir‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -90,7 +90,7 @@ func.func @test(%acc: memref<?x!sycl_accessor_1_i32_rw_gb>, %idx: i64) -> memref
9090
// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr<i64>
9191
// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 0] : (!llvm.ptr<[[ID1]]>) -> !llvm.ptr<i64>
9292
// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr<i64>
93-
// CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64
93+
// CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_4]], %[[VAL_2]] : i64
9494
// CHECK-NEXT: %[[VAL_8:.*]] = llvm.add %[[VAL_7]], %[[VAL_6]] : i64
9595
// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 1, 0] : (!llvm.ptr<[[ACCESSOR1]]>) -> !llvm.ptr<ptr<i32, 1>>
9696
// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr<ptr<i32, 1>>
@@ -111,7 +111,7 @@ func.func @test_1(%acc: memref<?x!sycl_accessor_1_i32_rw_gb>, %idx: memref<?x!sy
111111
// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr<i64>
112112
// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 0] : (!llvm.ptr<[[ID2]]>) -> !llvm.ptr<i64>
113113
// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr<i64>
114-
// CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64
114+
// CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_4]], %[[VAL_2]] : i64
115115
// CHECK-NEXT: %[[VAL_8:.*]] = llvm.add %[[VAL_7]], %[[VAL_6]] : i64
116116
// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 1] : (!llvm.ptr<[[ACCESSOR2]]>) -> !llvm.ptr<i64>
117117
// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr<i64>
@@ -138,7 +138,7 @@ func.func @test_2(%acc: memref<?x!sycl_accessor_2_i32_rw_gb>, %idx: memref<?x!sy
138138
// CHECK-NEXT: %[[VAL_4:.*]] = llvm.load %[[VAL_3]] : !llvm.ptr<i64>
139139
// CHECK-NEXT: %[[VAL_5:.*]] = llvm.getelementptr inbounds %[[VAL_1]][0, 0, 0, 0] : (!llvm.ptr<[[ID3]]>) -> !llvm.ptr<i64>
140140
// CHECK-NEXT: %[[VAL_6:.*]] = llvm.load %[[VAL_5]] : !llvm.ptr<i64>
141-
// CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_2]], %[[VAL_4]] : i64
141+
// CHECK-NEXT: %[[VAL_7:.*]] = llvm.mul %[[VAL_4]], %[[VAL_2]] : i64
142142
// CHECK-NEXT: %[[VAL_8:.*]] = llvm.add %[[VAL_7]], %[[VAL_6]] : i64
143143
// CHECK-NEXT: %[[VAL_9:.*]] = llvm.getelementptr inbounds %[[VAL_0]][0, 0, 2, 0, 0, 1] : (!llvm.ptr<[[ACCESSOR3]]>) -> !llvm.ptr<i64>
144144
// CHECK-NEXT: %[[VAL_10:.*]] = llvm.load %[[VAL_9]] : !llvm.ptr<i64>

0 commit comments

Comments
 (0)