Skip to content

Commit c97396d

Browse files
BruceGliffBruceGliff
committed
Extend GenXIntrinsics interface
Add some functions to get LSC special argument indices. Add function to get encoded LSCVectorSize.
1 parent 99ac111 commit c97396d

File tree

2 files changed

+181
-74
lines changed

2 files changed

+181
-74
lines changed

‎GenXIntrinsics/include/llvm/GenXIntrinsics/GenXIntrinsics.h

+160
Original file line numberDiff line numberDiff line change
@@ -657,6 +657,166 @@ inline bool isLSC2D(const Function *F) {
657657
return isLSC2D(getGenXIntrinsicID(F));
658658
}
659659

660+
661+
// Dependency from visa_igc_common_header.
662+
// Converts vector size into LSC-appropriate code.
663+
inline LSCVectorSize getLSCVectorSize(unsigned N) {
664+
switch (N) {
665+
case 0:
666+
return LSCVectorSize::N0;
667+
case 1:
668+
return LSCVectorSize::N1;
669+
case 2:
670+
return LSCVectorSize::N2;
671+
case 3:
672+
return LSCVectorSize::N3;
673+
case 4:
674+
return LSCVectorSize::N4;
675+
case 8:
676+
return LSCVectorSize::N8;
677+
case 16:
678+
return LSCVectorSize::N16;
679+
case 32:
680+
return LSCVectorSize::N32;
681+
case 64:
682+
return LSCVectorSize::N64;
683+
}
684+
llvm_unreachable("Unknown vector size");
685+
}
686+
// Gets encoded vector size for LSC instruction.
687+
inline uint8_t getEncodedLSCVectorSize(unsigned N) {
688+
return static_cast<uint8_t>(getLSCVectorSize(N));
689+
}
690+
691+
// Functions in this namespace return argument index for LSC instruction.
692+
namespace LSCArgIdx {
693+
constexpr int Invalid = -1;
694+
// Returns VectorSize index.
695+
inline int getLSCVectorSize(LSCCategory Cat) {
696+
switch (Cat) {
697+
case LSCCategory::Load:
698+
case LSCCategory::Prefetch:
699+
case LSCCategory::Store:
700+
case LSCCategory::Atomic:
701+
return 7;
702+
case LSCCategory::LegacyAtomic:
703+
return 8;
704+
case LSCCategory::Prefetch2D:
705+
case LSCCategory::Load2D:
706+
case LSCCategory::Store2D:
707+
case LSCCategory::Fence:
708+
case LSCCategory::NotLSC:
709+
default:
710+
llvm_unreachable("no such argument");
711+
return Invalid;
712+
}
713+
}
714+
// Returns VectorSize index.
715+
inline int getLSCVectorSize(unsigned IID) {
716+
return LSCArgIdx::getLSCVectorSize(getLSCCategory(IID));
717+
}
718+
719+
// Returns DataSize index.
720+
inline int getLSCDataSize(LSCCategory Cat) {
721+
switch (Cat) {
722+
case LSCCategory::Load:
723+
case LSCCategory::Prefetch:
724+
case LSCCategory::Store:
725+
case LSCCategory::LegacyAtomic:
726+
case LSCCategory::Atomic:
727+
return 6;
728+
case LSCCategory::Load2D:
729+
case LSCCategory::Prefetch2D:
730+
case LSCCategory::Store2D:
731+
return 3;
732+
case LSCCategory::Fence:
733+
case LSCCategory::NotLSC:
734+
default:
735+
llvm_unreachable("no such argument");
736+
return Invalid;
737+
}
738+
}
739+
// Returns DataSize index.
740+
inline int getLSCDataSize(unsigned IID) {
741+
return LSCArgIdx::getLSCDataSize(getLSCCategory(IID));
742+
}
743+
744+
// Returns immediate offset index.
745+
inline int getLSCImmOffset(LSCCategory Cat) {
746+
switch (Cat) {
747+
case LSCCategory::Load:
748+
case LSCCategory::Prefetch:
749+
case LSCCategory::Store:
750+
case LSCCategory::LegacyAtomic:
751+
case LSCCategory::Atomic:
752+
return 5;
753+
case LSCCategory::Prefetch2D:
754+
case LSCCategory::Load2D:
755+
case LSCCategory::Store2D:
756+
case LSCCategory::Fence:
757+
case LSCCategory::NotLSC:
758+
default:
759+
llvm_unreachable("no such argument");
760+
return Invalid;
761+
}
762+
}
763+
// Returns immediate offset index.
764+
inline int getLSCImmOffset(unsigned IID) {
765+
return LSCArgIdx::getLSCImmOffset(getLSCCategory(IID));
766+
}
767+
768+
// Returns data order index.
769+
inline int getLSCDataOrder(LSCCategory Cat) {
770+
switch (Cat) {
771+
case LSCCategory::Load:
772+
case LSCCategory::Prefetch:
773+
case LSCCategory::Store:
774+
case LSCCategory::Atomic:
775+
return 8;
776+
case LSCCategory::LegacyAtomic:
777+
return 7;
778+
case LSCCategory::Load2D:
779+
case LSCCategory::Prefetch2D:
780+
case LSCCategory::Store2D:
781+
return 4;
782+
case LSCCategory::Fence:
783+
case LSCCategory::NotLSC:
784+
default:
785+
llvm_unreachable("no such argument");
786+
return Invalid;
787+
}
788+
}
789+
// Returns data order index.
790+
inline int getLSCDataOrder(unsigned IID) {
791+
return LSCArgIdx::getLSCDataOrder(getLSCCategory(IID));
792+
}
793+
794+
// Returns width index.
795+
inline int getLSCWidth(LSCCategory Cat) {
796+
switch (Cat) {
797+
case LSCCategory::Load:
798+
case LSCCategory::Prefetch:
799+
case LSCCategory::Store:
800+
case LSCCategory::Fence:
801+
case LSCCategory::LegacyAtomic:
802+
case LSCCategory::Atomic:
803+
case LSCCategory::Prefetch2D:
804+
return 0;
805+
case LSCCategory::Load2D:
806+
case LSCCategory::Store2D:
807+
case LSCCategory::NotLSC:
808+
default:
809+
llvm_unreachable("no such argument");
810+
return Invalid;
811+
}
812+
}
813+
// Returns width index.
814+
inline int getLSCWidth(unsigned IID) {
815+
return LSCArgIdx::getLSCWidth(getLSCCategory(IID));
816+
}
817+
818+
} // namespace LSCArgIdx
819+
660820
inline unsigned getLSCNumVectorElements(LSCVectorSize VS) {
661821
switch (VS) {
662822
case LSCVectorSize::N0:

‎GenXIntrinsics/lib/GenXIntrinsics/GenXIntrinsics.cpp

+21-74
Original file line numberDiff line numberDiff line change
@@ -688,93 +688,40 @@ std::string GenXIntrinsic::getAnyName(unsigned id, ArrayRef<Type *> Tys) {
688688
GenXIntrinsic::LSCVectorSize GenXIntrinsic::getLSCVectorSize(
689689
const Instruction *I) {
690690
assert(isLSC(I));
691-
switch (getLSCCategory(I)) {
692-
case LSCCategory::Load:
693-
case LSCCategory::Prefetch:
694-
case LSCCategory::Store:
695-
case LSCCategory::Atomic:
696-
return static_cast<LSCVectorSize>(
697-
cast<ConstantInt>(I->getOperand(7))->getZExtValue());
698-
case LSCCategory::LegacyAtomic:
699-
return static_cast<LSCVectorSize>(
700-
cast<ConstantInt>(I->getOperand(8))->getZExtValue());
701-
case LSCCategory::Fence:
702-
case LSCCategory::Load2D:
703-
case LSCCategory::Prefetch2D:
704-
case LSCCategory::Store2D:
705-
case LSCCategory::NotLSC:
706-
return LSCVectorSize::N0;
707-
}
708-
llvm_unreachable("Unknown LSC category");
691+
const int VectorSizeIdx = LSCArgIdx::getLSCVectorSize(getLSCCategory(I));
692+
if (VectorSizeIdx == LSCArgIdx::Invalid)
693+
return LSCVectorSize::N0;
694+
return static_cast<LSCVectorSize>(
695+
cast<ConstantInt>(I->getOperand(VectorSizeIdx))->getZExtValue());
709696
}
710697

711698
GenXIntrinsic::LSCDataSize GenXIntrinsic::getLSCDataSize(
712699
const Instruction *I) {
713700
assert(isLSC(I));
714-
switch (getLSCCategory(I)) {
715-
case LSCCategory::Load:
716-
case LSCCategory::Prefetch:
717-
case LSCCategory::Store:
718-
case LSCCategory::LegacyAtomic:
719-
case LSCCategory::Atomic:
720-
return static_cast<LSCDataSize>(
721-
cast<ConstantInt>(I->getOperand(6))->getZExtValue());
722-
case LSCCategory::Load2D:
723-
case LSCCategory::Prefetch2D:
724-
case LSCCategory::Store2D:
725-
return static_cast<LSCDataSize>(
726-
cast<ConstantInt>(I->getOperand(3))->getZExtValue());
727-
case LSCCategory::Fence:
728-
case LSCCategory::NotLSC:
729-
return LSCDataSize::Invalid;
730-
}
731-
llvm_unreachable("Unknown LSC category");
701+
const int DataSizeIdx = LSCArgIdx::getLSCDataSize(getLSCCategory(I));
702+
if (DataSizeIdx == LSCArgIdx::Invalid)
703+
return LSCDataSize::Invalid;
704+
return static_cast<LSCDataSize>(
705+
cast<ConstantInt>(I->getOperand(DataSizeIdx))->getZExtValue());
732706
}
733707

734708
GenXIntrinsic::LSCDataOrder GenXIntrinsic::getLSCDataOrder(
735709
const Instruction *I) {
736710
assert(isLSC(I));
737-
switch (getLSCCategory(I)) {
738-
case LSCCategory::Load:
739-
case LSCCategory::Prefetch:
740-
case LSCCategory::Store:
741-
case LSCCategory::Atomic:
742-
return static_cast<LSCDataOrder>(
743-
cast<ConstantInt>(I->getOperand(8))->getZExtValue());
744-
case LSCCategory::LegacyAtomic:
745-
return static_cast<LSCDataOrder>(
746-
cast<ConstantInt>(I->getOperand(7))->getZExtValue());
747-
case LSCCategory::Load2D:
748-
case LSCCategory::Prefetch2D:
749-
case LSCCategory::Store2D:
750-
return static_cast<LSCDataOrder>(
751-
cast<ConstantInt>(I->getOperand(4))->getZExtValue());
752-
case LSCCategory::Fence:
753-
case LSCCategory::NotLSC:
754-
return LSCDataOrder::Invalid;
755-
}
756-
llvm_unreachable("Unknown LSC category");
711+
const int DataOrderIdx = LSCArgIdx::getLSCDataOrder(getLSCCategory(I));
712+
if (DataOrderIdx == LSCArgIdx::Invalid)
713+
return LSCDataOrder::Invalid;
714+
return static_cast<LSCDataOrder>(
715+
cast<ConstantInt>(I->getOperand(DataOrderIdx))->getZExtValue());
757716
}
758717

759718
unsigned GenXIntrinsic::getLSCWidth(const Instruction *I) {
760719
assert(isLSC(I));
761-
switch(getLSCCategory(I)) {
762-
case LSCCategory::Load:
763-
case LSCCategory::Prefetch:
764-
case LSCCategory::Store:
765-
case LSCCategory::Fence:
766-
case LSCCategory::LegacyAtomic:
767-
case LSCCategory::Atomic: {
768-
case LSCCategory::Prefetch2D:
769-
if (auto VT = dyn_cast<VectorType>(I->getOperand(0)->getType()))
770-
return VCINTR::VectorType::getNumElements(VT);
771-
return 1;
772-
}
773-
case LSCCategory::Load2D:
774-
case LSCCategory::Store2D:
775-
case LSCCategory::NotLSC:
776-
return 1;
777-
}
778-
llvm_unreachable("Unknown LSC category");
720+
const int WidthIdx = LSCArgIdx::getLSCWidth(getLSCCategory(I));
721+
if (WidthIdx == LSCArgIdx::Invalid)
722+
return 1;
723+
if (auto VT = dyn_cast<VectorType>(I->getOperand(WidthIdx)->getType()))
724+
return VCINTR::VectorType::getNumElements(VT);
725+
return 1;
779726
}
780727

0 commit comments

Comments
 (0)