Skip to content

Commit 801cba2

Browse files
Mel-ChenMel-Chen
committed
Revert "Utils support"
This reverts commit 701a4d5.
1 parent 810fa77 commit 801cba2

File tree

4 files changed

+0
-203
lines changed

4 files changed

+0
-203
lines changed

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

Lines changed: 0 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -746,68 +746,49 @@ class IRBuilderBase {
746746
private:
747747
CallInst *getReductionIntrinsic(Intrinsic::ID ID, Value *Src);
748748

749-
// Helper function for creating VP reduce intrinsic call.
750-
CallInst *getReductionIntrinsic(Intrinsic::ID ID, Value *Acc, Value *Src,
751-
Value *Mask, Value *EVL);
752-
753749
public:
754750
/// Create a sequential vector fadd reduction intrinsic of the source vector.
755751
/// The first parameter is a scalar accumulator value. An unordered reduction
756752
/// can be created by adding the reassoc fast-math flag to the resulting
757753
/// sequential reduction.
758754
CallInst *CreateFAddReduce(Value *Acc, Value *Src);
759-
CallInst *CreateFAddReduce(Value *Acc, Value *Src, Value *EVL,
760-
Value *Mask = nullptr);
761755

762756
/// Create a sequential vector fmul reduction intrinsic of the source vector.
763757
/// The first parameter is a scalar accumulator value. An unordered reduction
764758
/// can be created by adding the reassoc fast-math flag to the resulting
765759
/// sequential reduction.
766760
CallInst *CreateFMulReduce(Value *Acc, Value *Src);
767-
CallInst *CreateFMulReduce(Value *Acc, Value *Src, Value *EVL,
768-
Value *Mask = nullptr);
769761

770762
/// Create a vector int add reduction intrinsic of the source vector.
771763
CallInst *CreateAddReduce(Value *Src);
772-
CallInst *CreateAddReduce(Value *Src, Value *EVL, Value *Mask = nullptr);
773764

774765
/// Create a vector int mul reduction intrinsic of the source vector.
775766
CallInst *CreateMulReduce(Value *Src);
776-
CallInst *CreateMulReduce(Value *Src, Value *EVL, Value *Mask = nullptr);
777767

778768
/// Create a vector int AND reduction intrinsic of the source vector.
779769
CallInst *CreateAndReduce(Value *Src);
780-
CallInst *CreateAndReduce(Value *Src, Value *EVL, Value *Mask = nullptr);
781770

782771
/// Create a vector int OR reduction intrinsic of the source vector.
783772
CallInst *CreateOrReduce(Value *Src);
784-
CallInst *CreateOrReduce(Value *Src, Value *EVL, Value *Mask = nullptr);
785773

786774
/// Create a vector int XOR reduction intrinsic of the source vector.
787775
CallInst *CreateXorReduce(Value *Src);
788-
CallInst *CreateXorReduce(Value *Src, Value *EVL, Value *Mask = nullptr);
789776

790777
/// Create a vector integer max reduction intrinsic of the source
791778
/// vector.
792779
CallInst *CreateIntMaxReduce(Value *Src, bool IsSigned = false);
793-
CallInst *CreateIntMaxReduce(Value *Src, Value *EVL, bool IsSigned = false,
794-
Value *Mask = nullptr);
795780

796781
/// Create a vector integer min reduction intrinsic of the source
797782
/// vector.
798783
CallInst *CreateIntMinReduce(Value *Src, bool IsSigned = false);
799-
CallInst *CreateIntMinReduce(Value *Src, Value *EVL, bool IsSigned = false,
800-
Value *Mask = nullptr);
801784

802785
/// Create a vector float max reduction intrinsic of the source
803786
/// vector.
804787
CallInst *CreateFPMaxReduce(Value *Src);
805-
CallInst *CreateFPMaxReduce(Value *Src, Value *EVL, Value *Mask = nullptr);
806788

807789
/// Create a vector float min reduction intrinsic of the source
808790
/// vector.
809791
CallInst *CreateFPMinReduce(Value *Src);
810-
CallInst *CreateFPMinReduce(Value *Src, Value *EVL, Value *Mask = nullptr);
811792

812793
/// Create a vector float maximum reduction intrinsic of the source
813794
/// vector. This variant follows the NaN and signed zero semantic of

‎llvm/include/llvm/Transforms/Utils/LoopUtils.h

Lines changed: 0 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -395,9 +395,6 @@ Value *getShuffleReduction(IRBuilderBase &Builder, Value *Src, unsigned Op,
395395
/// Fast-math-flags are propagated using the IRBuilder's setting.
396396
Value *createSimpleTargetReduction(IRBuilderBase &B, Value *Src,
397397
RecurKind RdxKind);
398-
Value *createSimpleTargetReduction(IRBuilderBase &B, Value *Src,
399-
RecurKind RdxKind, Value *EVL,
400-
Value *Mask = nullptr);
401398
Value *createSimpleTargetReduction(VectorBuilder &VB, Value *Src,
402399
const RecurrenceDescriptor &Desc);
403400

@@ -420,9 +417,6 @@ Value *createTargetReduction(IRBuilderBase &B, const RecurrenceDescriptor &Desc,
420417
Value *createOrderedReduction(IRBuilderBase &B,
421418
const RecurrenceDescriptor &Desc, Value *Src,
422419
Value *Start);
423-
Value *createOrderedReduction(IRBuilderBase &B,
424-
const RecurrenceDescriptor &Desc, Value *Src,
425-
Value *Start, Value *EVL, Value *Mask = nullptr);
426420
Value *createOrderedReduction(VectorBuilder &VB,
427421
const RecurrenceDescriptor &Desc, Value *Src,
428422
Value *Start);

‎llvm/lib/IR/IRBuilder.cpp

Lines changed: 0 additions & 122 deletions
Original file line numberDiff line numberDiff line change
@@ -414,20 +414,6 @@ CallInst *IRBuilderBase::getReductionIntrinsic(Intrinsic::ID ID, Value *Src) {
414414
return CreateCall(Decl, Ops);
415415
}
416416

417-
CallInst *IRBuilderBase::getReductionIntrinsic(Intrinsic::ID ID, Value *Acc,
418-
Value *Src, Value *Mask,
419-
Value *EVL) {
420-
Module *M = GetInsertBlock()->getParent()->getParent();
421-
auto *SrcTy = cast<VectorType>(Src->getType());
422-
EVL = CreateIntCast(EVL, getInt32Ty(), /*isSigned=*/false);
423-
if (!Mask)
424-
Mask = CreateVectorSplat(SrcTy->getElementCount(), getTrue());
425-
Value *Ops[] = {Acc, Src, Mask, EVL};
426-
Type *Tys[] = {SrcTy};
427-
auto Decl = Intrinsic::getDeclaration(M, ID, Tys);
428-
return CreateCall(Decl, Ops);
429-
}
430-
431417
CallInst *IRBuilderBase::CreateFAddReduce(Value *Acc, Value *Src) {
432418
Module *M = GetInsertBlock()->getParent()->getParent();
433419
Value *Ops[] = {Acc, Src};
@@ -436,11 +422,6 @@ CallInst *IRBuilderBase::CreateFAddReduce(Value *Acc, Value *Src) {
436422
return CreateCall(Decl, Ops);
437423
}
438424

439-
CallInst *IRBuilderBase::CreateFAddReduce(Value *Acc, Value *Src, Value *EVL,
440-
Value *Mask) {
441-
return getReductionIntrinsic(Intrinsic::vp_reduce_fadd, Acc, Src, Mask, EVL);
442-
}
443-
444425
CallInst *IRBuilderBase::CreateFMulReduce(Value *Acc, Value *Src) {
445426
Module *M = GetInsertBlock()->getParent()->getParent();
446427
Value *Ops[] = {Acc, Src};
@@ -449,149 +430,46 @@ CallInst *IRBuilderBase::CreateFMulReduce(Value *Acc, Value *Src) {
449430
return CreateCall(Decl, Ops);
450431
}
451432

452-
CallInst *IRBuilderBase::CreateFMulReduce(Value *Acc, Value *Src, Value *EVL,
453-
Value *Mask) {
454-
return getReductionIntrinsic(Intrinsic::vp_reduce_fmul, Acc, Src, Mask, EVL);
455-
}
456-
457433
CallInst *IRBuilderBase::CreateAddReduce(Value *Src) {
458434
return getReductionIntrinsic(Intrinsic::vector_reduce_add, Src);
459435
}
460436

461-
CallInst *IRBuilderBase::CreateAddReduce(Value *Src, Value *EVL, Value *Mask) {
462-
auto *SrcTy = cast<VectorType>(Src->getType());
463-
auto *EltTy = SrcTy->getElementType();
464-
return getReductionIntrinsic(Intrinsic::vp_reduce_add,
465-
ConstantInt::get(EltTy, 0), Src, Mask, EVL);
466-
}
467-
468437
CallInst *IRBuilderBase::CreateMulReduce(Value *Src) {
469438
return getReductionIntrinsic(Intrinsic::vector_reduce_mul, Src);
470439
}
471440

472-
CallInst *IRBuilderBase::CreateMulReduce(Value *Src, Value *EVL, Value *Mask) {
473-
auto *SrcTy = cast<VectorType>(Src->getType());
474-
auto *EltTy = SrcTy->getElementType();
475-
return getReductionIntrinsic(Intrinsic::vp_reduce_mul,
476-
ConstantInt::get(EltTy, 1), Src, Mask, EVL);
477-
}
478-
479441
CallInst *IRBuilderBase::CreateAndReduce(Value *Src) {
480442
return getReductionIntrinsic(Intrinsic::vector_reduce_and, Src);
481443
}
482444

483-
CallInst *IRBuilderBase::CreateAndReduce(Value *Src, Value *EVL, Value *Mask) {
484-
auto *SrcTy = cast<VectorType>(Src->getType());
485-
auto *EltTy = SrcTy->getElementType();
486-
return getReductionIntrinsic(Intrinsic::vp_reduce_and,
487-
Constant::getAllOnesValue(EltTy), Src, Mask,
488-
EVL);
489-
}
490-
491445
CallInst *IRBuilderBase::CreateOrReduce(Value *Src) {
492446
return getReductionIntrinsic(Intrinsic::vector_reduce_or, Src);
493447
}
494448

495-
CallInst *IRBuilderBase::CreateOrReduce(Value *Src, Value *EVL, Value *Mask) {
496-
auto *SrcTy = cast<VectorType>(Src->getType());
497-
auto *EltTy = SrcTy->getElementType();
498-
return getReductionIntrinsic(Intrinsic::vp_reduce_or,
499-
ConstantInt::get(EltTy, 0), Src, Mask, EVL);
500-
}
501-
502449
CallInst *IRBuilderBase::CreateXorReduce(Value *Src) {
503450
return getReductionIntrinsic(Intrinsic::vector_reduce_xor, Src);
504451
}
505452

506-
CallInst *IRBuilderBase::CreateXorReduce(Value *Src, Value *EVL, Value *Mask) {
507-
auto *SrcTy = cast<VectorType>(Src->getType());
508-
auto *EltTy = SrcTy->getElementType();
509-
return getReductionIntrinsic(Intrinsic::vp_reduce_xor,
510-
ConstantInt::get(EltTy, 0), Src, Mask, EVL);
511-
}
512-
513453
CallInst *IRBuilderBase::CreateIntMaxReduce(Value *Src, bool IsSigned) {
514454
auto ID =
515455
IsSigned ? Intrinsic::vector_reduce_smax : Intrinsic::vector_reduce_umax;
516456
return getReductionIntrinsic(ID, Src);
517457
}
518458

519-
CallInst *IRBuilderBase::CreateIntMaxReduce(Value *Src, Value *EVL,
520-
bool IsSigned, Value *Mask) {
521-
auto *SrcTy = cast<VectorType>(Src->getType());
522-
auto *EltTy = SrcTy->getElementType();
523-
return getReductionIntrinsic(
524-
IsSigned ? Intrinsic::vp_reduce_smax : Intrinsic::vp_reduce_umax,
525-
IsSigned ? ConstantInt::get(EltTy, APInt::getSignedMinValue(
526-
EltTy->getIntegerBitWidth()))
527-
: ConstantInt::get(EltTy, 0),
528-
Src, Mask, EVL);
529-
}
530-
531459
CallInst *IRBuilderBase::CreateIntMinReduce(Value *Src, bool IsSigned) {
532460
auto ID =
533461
IsSigned ? Intrinsic::vector_reduce_smin : Intrinsic::vector_reduce_umin;
534462
return getReductionIntrinsic(ID, Src);
535463
}
536464

537-
CallInst *IRBuilderBase::CreateIntMinReduce(Value *Src, Value *EVL,
538-
bool IsSigned, Value *Mask) {
539-
auto *SrcTy = cast<VectorType>(Src->getType());
540-
auto *EltTy = SrcTy->getElementType();
541-
return getReductionIntrinsic(
542-
IsSigned ? Intrinsic::vp_reduce_smin : Intrinsic::vp_reduce_umin,
543-
IsSigned ? ConstantInt::get(EltTy, APInt::getSignedMaxValue(
544-
EltTy->getIntegerBitWidth()))
545-
: Constant::getAllOnesValue(EltTy),
546-
Src, Mask, EVL);
547-
}
548-
549465
CallInst *IRBuilderBase::CreateFPMaxReduce(Value *Src) {
550466
return getReductionIntrinsic(Intrinsic::vector_reduce_fmax, Src);
551467
}
552468

553-
CallInst *IRBuilderBase::CreateFPMaxReduce(Value *Src, Value *EVL,
554-
Value *Mask) {
555-
auto *SrcTy = cast<VectorType>(Src->getType());
556-
auto *EltTy = SrcTy->getElementType();
557-
FastMathFlags FMF = getFastMathFlags();
558-
Value *Neutral;
559-
if (FMF.noNaNs())
560-
Neutral = FMF.noInfs()
561-
? ConstantFP::get(
562-
EltTy, APFloat::getLargest(EltTy->getFltSemantics(),
563-
/*Negative=*/true))
564-
: ConstantFP::getInfinity(EltTy, true);
565-
else
566-
Neutral = ConstantFP::getQNaN(EltTy, /*Negative=*/true);
567-
568-
return getReductionIntrinsic(Intrinsic::vp_reduce_fmax, Neutral, Src, Mask,
569-
EVL);
570-
}
571-
572469
CallInst *IRBuilderBase::CreateFPMinReduce(Value *Src) {
573470
return getReductionIntrinsic(Intrinsic::vector_reduce_fmin, Src);
574471
}
575472

576-
CallInst *IRBuilderBase::CreateFPMinReduce(Value *Src, Value *EVL,
577-
Value *Mask) {
578-
auto *SrcTy = cast<VectorType>(Src->getType());
579-
auto *EltTy = SrcTy->getElementType();
580-
FastMathFlags FMF = getFastMathFlags();
581-
Value *Neutral;
582-
if (FMF.noNaNs())
583-
Neutral = FMF.noInfs()
584-
? ConstantFP::get(
585-
EltTy, APFloat::getLargest(EltTy->getFltSemantics(),
586-
/*Negative=*/false))
587-
: ConstantFP::getInfinity(EltTy, false);
588-
else
589-
Neutral = ConstantFP::getQNaN(EltTy, /*Negative=*/false);
590-
591-
return getReductionIntrinsic(Intrinsic::vp_reduce_fmin, Neutral, Src, Mask,
592-
EVL);
593-
}
594-
595473
CallInst *IRBuilderBase::CreateFPMaximumReduce(Value *Src) {
596474
return getReductionIntrinsic(Intrinsic::vector_reduce_fmaximum, Src);
597475
}

‎llvm/lib/Transforms/Utils/LoopUtils.cpp

Lines changed: 0 additions & 56 deletions
Original file line numberDiff line numberDiff line change
@@ -1192,48 +1192,6 @@ Value *llvm::createSimpleTargetReduction(IRBuilderBase &Builder, Value *Src,
11921192
}
11931193
}
11941194

1195-
Value *llvm::createSimpleTargetReduction(IRBuilderBase &Builder, Value *Src,
1196-
RecurKind RdxKind, Value *EVL,
1197-
Value *Mask) {
1198-
auto *SrcVecEltTy = cast<VectorType>(Src->getType())->getElementType();
1199-
switch (RdxKind) {
1200-
case RecurKind::Add:
1201-
return Builder.CreateAddReduce(Src, EVL, Mask);
1202-
case RecurKind::Mul:
1203-
return Builder.CreateMulReduce(Src, EVL, Mask);
1204-
case RecurKind::And:
1205-
return Builder.CreateAndReduce(Src, EVL, Mask);
1206-
case RecurKind::Or:
1207-
return Builder.CreateOrReduce(Src, EVL, Mask);
1208-
case RecurKind::Xor:
1209-
return Builder.CreateXorReduce(Src, EVL, Mask);
1210-
case RecurKind::FMulAdd:
1211-
case RecurKind::FAdd:
1212-
return Builder.CreateFAddReduce(ConstantFP::getNegativeZero(SrcVecEltTy),
1213-
Src, EVL, Mask);
1214-
case RecurKind::FMul:
1215-
return Builder.CreateFMulReduce(ConstantFP::get(SrcVecEltTy, 1.0), Src, EVL,
1216-
Mask);
1217-
case RecurKind::SMax:
1218-
return Builder.CreateIntMaxReduce(Src, EVL, true, Mask);
1219-
case RecurKind::SMin:
1220-
return Builder.CreateIntMinReduce(Src, EVL, true, Mask);
1221-
case RecurKind::UMax:
1222-
return Builder.CreateIntMaxReduce(Src, EVL, false, Mask);
1223-
case RecurKind::UMin:
1224-
return Builder.CreateIntMinReduce(Src, EVL, false, Mask);
1225-
case RecurKind::FMax:
1226-
return Builder.CreateFPMaxReduce(Src, EVL, Mask);
1227-
case RecurKind::FMin:
1228-
return Builder.CreateFPMinReduce(Src, EVL, Mask);
1229-
case RecurKind::FMinimum:
1230-
case RecurKind::FMaximum:
1231-
assert(0 && "FMaximum/FMinimum reduction VP intrinsic is not supported.");
1232-
default:
1233-
llvm_unreachable("Unhandled opcode");
1234-
}
1235-
}
1236-
12371195
Value *llvm::createSimpleTargetReduction(VectorBuilder &VBuilder, Value *Src,
12381196
const RecurrenceDescriptor &Desc) {
12391197
RecurKind Kind = Desc.getRecurrenceKind();
@@ -1275,20 +1233,6 @@ Value *llvm::createOrderedReduction(IRBuilderBase &B,
12751233
return B.CreateFAddReduce(Start, Src);
12761234
}
12771235

1278-
Value *llvm::createOrderedReduction(IRBuilderBase &B,
1279-
const RecurrenceDescriptor &Desc,
1280-
Value *Src, Value *Start, Value *EVL,
1281-
Value *Mask) {
1282-
assert((Desc.getRecurrenceKind() == RecurKind::FAdd ||
1283-
Desc.getRecurrenceKind() == RecurKind::FMulAdd) &&
1284-
"Unexpected reduction kind");
1285-
assert(Src->getType()->isVectorTy() && "Expected a vector type");
1286-
assert(!Start->getType()->isVectorTy() && "Expected a scalar type");
1287-
assert(EVL->getType()->isIntegerTy() && "Expected a integer type");
1288-
1289-
return B.CreateFAddReduce(Start, Src, EVL, Mask);
1290-
}
1291-
12921236
Value *llvm::createOrderedReduction(VectorBuilder &VBuilder,
12931237
const RecurrenceDescriptor &Desc,
12941238
Value *Src, Value *Start) {

0 commit comments

Comments
 (0)