Skip to content

Commit 3be16bd

Browse files
nikicnikic
committed
[IRBuilder] Remove various typed pointer handling (NFC)
1 parent 23c2175 commit 3be16bd

File tree

2 files changed

+8
-86
lines changed

2 files changed

+8
-86
lines changed

‎llvm/include/llvm/IR/IRBuilder.h

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1021,8 +1021,6 @@ class IRBuilderBase {
10211021
ArrayRef<Type *> OverloadedTypes,
10221022
const Twine &Name = "");
10231023

1024-
Value *getCastedInt8PtrValue(Value *Ptr);
1025-
10261024
//===--------------------------------------------------------------------===//
10271025
// Instruction creation methods: Terminators
10281026
//===--------------------------------------------------------------------===//

‎llvm/lib/IR/IRBuilder.cpp

Lines changed: 8 additions & 84 deletions
Original file line numberDiff line numberDiff line change
@@ -60,15 +60,6 @@ Type *IRBuilderBase::getCurrentFunctionReturnType() const {
6060
return BB->getParent()->getReturnType();
6161
}
6262

63-
Value *IRBuilderBase::getCastedInt8PtrValue(Value *Ptr) {
64-
auto *PT = cast<PointerType>(Ptr->getType());
65-
if (PT->isOpaqueOrPointeeTypeMatches(getInt8Ty()))
66-
return Ptr;
67-
68-
// Otherwise, we need to insert a bitcast.
69-
return CreateBitCast(Ptr, getInt8PtrTy(PT->getAddressSpace()));
70-
}
71-
7263
DebugLoc IRBuilderBase::getCurrentDebugLocation() const {
7364
for (auto &KV : MetadataToCopy)
7465
if (KV.first == LLVMContext::MD_dbg)
@@ -147,7 +138,6 @@ CallInst *IRBuilderBase::CreateMemSet(Value *Ptr, Value *Val, Value *Size,
147138
MaybeAlign Align, bool isVolatile,
148139
MDNode *TBAATag, MDNode *ScopeTag,
149140
MDNode *NoAliasTag) {
150-
Ptr = getCastedInt8PtrValue(Ptr);
151141
Value *Ops[] = {Ptr, Val, Size, getInt1(isVolatile)};
152142
Type *Tys[] = { Ptr->getType(), Size->getType() };
153143
Module *M = BB->getParent()->getParent();
@@ -176,7 +166,6 @@ CallInst *IRBuilderBase::CreateMemSetInline(Value *Dst, MaybeAlign DstAlign,
176166
bool IsVolatile, MDNode *TBAATag,
177167
MDNode *ScopeTag,
178168
MDNode *NoAliasTag) {
179-
Dst = getCastedInt8PtrValue(Dst);
180169
Value *Ops[] = {Dst, Val, Size, getInt1(IsVolatile)};
181170
Type *Tys[] = {Dst->getType(), Size->getType()};
182171
Module *M = BB->getParent()->getParent();
@@ -204,7 +193,6 @@ CallInst *IRBuilderBase::CreateElementUnorderedAtomicMemSet(
204193
Value *Ptr, Value *Val, Value *Size, Align Alignment, uint32_t ElementSize,
205194
MDNode *TBAATag, MDNode *ScopeTag, MDNode *NoAliasTag) {
206195

207-
Ptr = getCastedInt8PtrValue(Ptr);
208196
Value *Ops[] = {Ptr, Val, Size, getInt32(ElementSize)};
209197
Type *Tys[] = {Ptr->getType(), Size->getType()};
210198
Module *M = BB->getParent()->getParent();
@@ -232,9 +220,6 @@ CallInst *IRBuilderBase::CreateMemTransferInst(
232220
Intrinsic::ID IntrID, Value *Dst, MaybeAlign DstAlign, Value *Src,
233221
MaybeAlign SrcAlign, Value *Size, bool isVolatile, MDNode *TBAATag,
234222
MDNode *TBAAStructTag, MDNode *ScopeTag, MDNode *NoAliasTag) {
235-
Dst = getCastedInt8PtrValue(Dst);
236-
Src = getCastedInt8PtrValue(Src);
237-
238223
Value *Ops[] = {Dst, Src, Size, getInt1(isVolatile)};
239224
Type *Tys[] = { Dst->getType(), Src->getType(), Size->getType() };
240225
Module *M = BB->getParent()->getParent();
@@ -269,9 +254,6 @@ CallInst *IRBuilderBase::CreateMemCpyInline(
269254
Value *Dst, MaybeAlign DstAlign, Value *Src, MaybeAlign SrcAlign,
270255
Value *Size, bool IsVolatile, MDNode *TBAATag, MDNode *TBAAStructTag,
271256
MDNode *ScopeTag, MDNode *NoAliasTag) {
272-
Dst = getCastedInt8PtrValue(Dst);
273-
Src = getCastedInt8PtrValue(Src);
274-
275257
Value *Ops[] = {Dst, Src, Size, getInt1(IsVolatile)};
276258
Type *Tys[] = {Dst->getType(), Src->getType(), Size->getType()};
277259
Function *F = BB->getParent();
@@ -311,9 +293,6 @@ CallInst *IRBuilderBase::CreateElementUnorderedAtomicMemCpy(
311293
"Pointer alignment must be at least element size");
312294
assert(SrcAlign >= ElementSize &&
313295
"Pointer alignment must be at least element size");
314-
Dst = getCastedInt8PtrValue(Dst);
315-
Src = getCastedInt8PtrValue(Src);
316-
317296
Value *Ops[] = {Dst, Src, Size, getInt32(ElementSize)};
318297
Type *Tys[] = {Dst->getType(), Src->getType(), Size->getType()};
319298
Module *M = BB->getParent()->getParent();
@@ -349,9 +328,6 @@ CallInst *IRBuilderBase::CreateMemMove(Value *Dst, MaybeAlign DstAlign,
349328
Value *Size, bool isVolatile,
350329
MDNode *TBAATag, MDNode *ScopeTag,
351330
MDNode *NoAliasTag) {
352-
Dst = getCastedInt8PtrValue(Dst);
353-
Src = getCastedInt8PtrValue(Src);
354-
355331
Value *Ops[] = {Dst, Src, Size, getInt1(isVolatile)};
356332
Type *Tys[] = { Dst->getType(), Src->getType(), Size->getType() };
357333
Module *M = BB->getParent()->getParent();
@@ -386,9 +362,6 @@ CallInst *IRBuilderBase::CreateElementUnorderedAtomicMemMove(
386362
"Pointer alignment must be at least element size");
387363
assert(SrcAlign >= ElementSize &&
388364
"Pointer alignment must be at least element size");
389-
Dst = getCastedInt8PtrValue(Dst);
390-
Src = getCastedInt8PtrValue(Src);
391-
392365
Value *Ops[] = {Dst, Src, Size, getInt32(ElementSize)};
393366
Type *Tys[] = {Dst->getType(), Src->getType(), Size->getType()};
394367
Module *M = BB->getParent()->getParent();
@@ -493,7 +466,6 @@ CallInst *IRBuilderBase::CreateFPMinimumReduce(Value *Src) {
493466
CallInst *IRBuilderBase::CreateLifetimeStart(Value *Ptr, ConstantInt *Size) {
494467
assert(isa<PointerType>(Ptr->getType()) &&
495468
"lifetime.start only applies to pointers.");
496-
Ptr = getCastedInt8PtrValue(Ptr);
497469
if (!Size)
498470
Size = getInt64(-1);
499471
else
@@ -509,7 +481,6 @@ CallInst *IRBuilderBase::CreateLifetimeStart(Value *Ptr, ConstantInt *Size) {
509481
CallInst *IRBuilderBase::CreateLifetimeEnd(Value *Ptr, ConstantInt *Size) {
510482
assert(isa<PointerType>(Ptr->getType()) &&
511483
"lifetime.end only applies to pointers.");
512-
Ptr = getCastedInt8PtrValue(Ptr);
513484
if (!Size)
514485
Size = getInt64(-1);
515486
else
@@ -526,7 +497,6 @@ CallInst *IRBuilderBase::CreateInvariantStart(Value *Ptr, ConstantInt *Size) {
526497

527498
assert(isa<PointerType>(Ptr->getType()) &&
528499
"invariant.start only applies to pointers.");
529-
Ptr = getCastedInt8PtrValue(Ptr);
530500
if (!Size)
531501
Size = getInt64(-1);
532502
else
@@ -606,7 +576,6 @@ CallInst *IRBuilderBase::CreateMaskedLoad(Type *Ty, Value *Ptr, Align Alignment,
606576
const Twine &Name) {
607577
auto *PtrTy = cast<PointerType>(Ptr->getType());
608578
assert(Ty->isVectorTy() && "Type should be vector");
609-
assert(PtrTy->isOpaqueOrPointeeTypeMatches(Ty) && "Wrong element type");
610579
assert(Mask && "Mask should not be all-ones (null)");
611580
if (!PassThru)
612581
PassThru = PoisonValue::get(Ty);
@@ -627,7 +596,6 @@ CallInst *IRBuilderBase::CreateMaskedStore(Value *Val, Value *Ptr,
627596
auto *PtrTy = cast<PointerType>(Ptr->getType());
628597
Type *DataTy = Val->getType();
629598
assert(DataTy->isVectorTy() && "Val should be a vector");
630-
assert(PtrTy->isOpaqueOrPointeeTypeMatches(DataTy) && "Wrong element type");
631599
assert(Mask && "Mask should not be all-ones (null)");
632600
Type *OverloadedTypes[] = { DataTy, PtrTy };
633601
Value *Ops[] = {Val, Ptr, getInt32(Alignment.value()), Mask};
@@ -662,10 +630,6 @@ CallInst *IRBuilderBase::CreateMaskedGather(Type *Ty, Value *Ptrs,
662630
auto *VecTy = cast<VectorType>(Ty);
663631
ElementCount NumElts = VecTy->getElementCount();
664632
auto *PtrsTy = cast<VectorType>(Ptrs->getType());
665-
assert(cast<PointerType>(PtrsTy->getElementType())
666-
->isOpaqueOrPointeeTypeMatches(
667-
cast<VectorType>(Ty)->getElementType()) &&
668-
"Element type mismatch");
669633
assert(NumElts == PtrsTy->getElementCount() && "Element count mismatch");
670634

671635
if (!Mask)
@@ -696,13 +660,6 @@ CallInst *IRBuilderBase::CreateMaskedScatter(Value *Data, Value *Ptrs,
696660
auto *DataTy = cast<VectorType>(Data->getType());
697661
ElementCount NumElts = PtrsTy->getElementCount();
698662

699-
#ifndef NDEBUG
700-
auto *PtrTy = cast<PointerType>(PtrsTy->getElementType());
701-
assert(NumElts == DataTy->getElementCount() &&
702-
PtrTy->isOpaqueOrPointeeTypeMatches(DataTy->getElementType()) &&
703-
"Incompatible pointer and data types");
704-
#endif
705-
706663
if (!Mask)
707664
Mask = getAllOnesMask(NumElts);
708665

@@ -725,12 +682,7 @@ CallInst *IRBuilderBase::CreateMaskedScatter(Value *Data, Value *Ptrs,
725682
CallInst *IRBuilderBase::CreateMaskedExpandLoad(Type *Ty, Value *Ptr,
726683
Value *Mask, Value *PassThru,
727684
const Twine &Name) {
728-
auto *PtrTy = cast<PointerType>(Ptr->getType());
729685
assert(Ty->isVectorTy() && "Type should be vector");
730-
assert(PtrTy->isOpaqueOrPointeeTypeMatches(
731-
cast<FixedVectorType>(Ty)->getElementType()) &&
732-
"Wrong element type");
733-
(void)PtrTy;
734686
assert(Mask && "Mask should not be all-ones (null)");
735687
if (!PassThru)
736688
PassThru = PoisonValue::get(Ty);
@@ -747,13 +699,8 @@ CallInst *IRBuilderBase::CreateMaskedExpandLoad(Type *Ty, Value *Ptr,
747699
/// be accessed in memory
748700
CallInst *IRBuilderBase::CreateMaskedCompressStore(Value *Val, Value *Ptr,
749701
Value *Mask) {
750-
auto *PtrTy = cast<PointerType>(Ptr->getType());
751702
Type *DataTy = Val->getType();
752703
assert(DataTy->isVectorTy() && "Val should be a vector");
753-
assert(PtrTy->isOpaqueOrPointeeTypeMatches(
754-
cast<FixedVectorType>(DataTy)->getElementType()) &&
755-
"Wrong element type");
756-
(void)PtrTy;
757704
assert(Mask && "Mask should not be all-ones (null)");
758705
Type *OverloadedTypes[] = {DataTy};
759706
Value *Ops[] = {Val, Ptr, Mask};
@@ -1174,9 +1121,6 @@ Value *IRBuilderBase::CreatePtrDiff(Type *ElemTy, Value *LHS, Value *RHS,
11741121
const Twine &Name) {
11751122
assert(LHS->getType() == RHS->getType() &&
11761123
"Pointer subtraction operand types must match!");
1177-
assert(cast<PointerType>(LHS->getType())
1178-
->isOpaqueOrPointeeTypeMatches(ElemTy) &&
1179-
"Pointer type must match element type");
11801124
Value *LHS_int = CreatePtrToInt(LHS, Type::getInt64Ty(Context));
11811125
Value *RHS_int = CreatePtrToInt(RHS, Type::getInt64Ty(Context));
11821126
Value *Difference = CreateSub(LHS_int, RHS_int);
@@ -1187,50 +1131,34 @@ Value *IRBuilderBase::CreatePtrDiff(Type *ElemTy, Value *LHS, Value *RHS,
11871131
Value *IRBuilderBase::CreateLaunderInvariantGroup(Value *Ptr) {
11881132
assert(isa<PointerType>(Ptr->getType()) &&
11891133
"launder.invariant.group only applies to pointers.");
1190-
// FIXME: we could potentially avoid casts to/from i8*.
11911134
auto *PtrType = Ptr->getType();
1192-
auto *Int8PtrTy = getInt8PtrTy(PtrType->getPointerAddressSpace());
1193-
if (PtrType != Int8PtrTy)
1194-
Ptr = CreateBitCast(Ptr, Int8PtrTy);
11951135
Module *M = BB->getParent()->getParent();
11961136
Function *FnLaunderInvariantGroup = Intrinsic::getDeclaration(
1197-
M, Intrinsic::launder_invariant_group, {Int8PtrTy});
1137+
M, Intrinsic::launder_invariant_group, {PtrType});
11981138

1199-
assert(FnLaunderInvariantGroup->getReturnType() == Int8PtrTy &&
1139+
assert(FnLaunderInvariantGroup->getReturnType() == PtrType &&
12001140
FnLaunderInvariantGroup->getFunctionType()->getParamType(0) ==
1201-
Int8PtrTy &&
1141+
PtrType &&
12021142
"LaunderInvariantGroup should take and return the same type");
12031143

1204-
CallInst *Fn = CreateCall(FnLaunderInvariantGroup, {Ptr});
1205-
1206-
if (PtrType != Int8PtrTy)
1207-
return CreateBitCast(Fn, PtrType);
1208-
return Fn;
1144+
return CreateCall(FnLaunderInvariantGroup, {Ptr});
12091145
}
12101146

12111147
Value *IRBuilderBase::CreateStripInvariantGroup(Value *Ptr) {
12121148
assert(isa<PointerType>(Ptr->getType()) &&
12131149
"strip.invariant.group only applies to pointers.");
12141150

1215-
// FIXME: we could potentially avoid casts to/from i8*.
12161151
auto *PtrType = Ptr->getType();
1217-
auto *Int8PtrTy = getInt8PtrTy(PtrType->getPointerAddressSpace());
1218-
if (PtrType != Int8PtrTy)
1219-
Ptr = CreateBitCast(Ptr, Int8PtrTy);
12201152
Module *M = BB->getParent()->getParent();
12211153
Function *FnStripInvariantGroup = Intrinsic::getDeclaration(
1222-
M, Intrinsic::strip_invariant_group, {Int8PtrTy});
1154+
M, Intrinsic::strip_invariant_group, {PtrType});
12231155

1224-
assert(FnStripInvariantGroup->getReturnType() == Int8PtrTy &&
1156+
assert(FnStripInvariantGroup->getReturnType() == PtrType &&
12251157
FnStripInvariantGroup->getFunctionType()->getParamType(0) ==
1226-
Int8PtrTy &&
1158+
PtrType &&
12271159
"StripInvariantGroup should take and return the same type");
12281160

1229-
CallInst *Fn = CreateCall(FnStripInvariantGroup, {Ptr});
1230-
1231-
if (PtrType != Int8PtrTy)
1232-
return CreateBitCast(Fn, PtrType);
1233-
return Fn;
1161+
return CreateCall(FnStripInvariantGroup, {Ptr});
12341162
}
12351163

12361164
Value *IRBuilderBase::CreateVectorReverse(Value *V, const Twine &Name) {
@@ -1326,8 +1254,6 @@ Value *IRBuilderBase::CreatePreserveArrayAccessIndex(
13261254
auto *BaseType = Base->getType();
13271255
assert(isa<PointerType>(BaseType) &&
13281256
"Invalid Base ptr type for preserve.array.access.index.");
1329-
assert(cast<PointerType>(BaseType)->isOpaqueOrPointeeTypeMatches(ElTy) &&
1330-
"Pointer element type mismatch");
13311257

13321258
Value *LastIndexV = getInt32(LastIndex);
13331259
Constant *Zero = ConstantInt::get(Type::getInt32Ty(Context), 0);
@@ -1377,8 +1303,6 @@ Value *IRBuilderBase::CreatePreserveStructAccessIndex(
13771303
auto *BaseType = Base->getType();
13781304
assert(isa<PointerType>(BaseType) &&
13791305
"Invalid Base ptr type for preserve.struct.access.index.");
1380-
assert(cast<PointerType>(BaseType)->isOpaqueOrPointeeTypeMatches(ElTy) &&
1381-
"Pointer element type mismatch");
13821306

13831307
Value *GEPIndex = getInt32(Index);
13841308
Constant *Zero = ConstantInt::get(Type::getInt32Ty(Context), 0);

0 commit comments

Comments
 (0)