TargetTransformInfoImpl.h Source File (original) (raw)

14#ifndef LLVM_ANALYSIS_TARGETTRANSFORMINFOIMPL_H

15#define LLVM_ANALYSIS_TARGETTRANSFORMINFOIMPL_H

25#include

26#include

28namespace llvm {

36protected:

43public:

56 Type *AccessType,

60 for (const Value *Operand : Operands)

65 }

74 virtual unsigned

78 (void)PSI;

79 (void)BFI;

80 JTSize = 0;

81 return SI.getNumCases();

82 }

100 return 15000;

101 }

109

111

115

117

118

119

120

121

122

123

127

129

133

135

137

141

145

147

152

154 virtual bool

156 return AS == 0;

157 };

158

160

162

163 virtual std::pair<const Value *, unsigned>

165 return std::make_pair(nullptr, -1);

166 }

167

170 Value *NewV) const {

171 return nullptr;

172 }

173

175 assert(F && "A concrete function must be provided to this routine.");

176

177

178

179

180

181

182 if (F->isIntrinsic())

183 return false;

184

185 if (F->hasLocalLinkage() || ->hasName())

186 return true;

187

189

190

191

192 if (Name == "copysign" || Name == "copysignf" || Name == "copysignl" ||

193 Name == "fabs" || Name == "fabsf" || Name == "fabsl" ||

194 Name == "fmin" || Name == "fminf" || Name == "fminl" ||

195 Name == "fmax" || Name == "fmaxf" || Name == "fmaxl" ||

196 Name == "sin" || Name == "sinf" || Name == "sinl" ||

197 Name == "cos" || Name == "cosf" || Name == "cosl" ||

198 Name == "tan" || Name == "tanf" || Name == "tanl" ||

199 Name == "asin" || Name == "asinf" || Name == "asinl" ||

200 Name == "acos" || Name == "acosf" || Name == "acosl" ||

201 Name == "atan" || Name == "atanf" || Name == "atanl" ||

202 Name == "atan2" || Name == "atan2f" || Name == "atan2l"||

203 Name == "sinh" || Name == "sinhf" || Name == "sinhl" ||

204 Name == "cosh" || Name == "coshf" || Name == "coshl" ||

205 Name == "tanh" || Name == "tanhf" || Name == "tanhl" ||

206 Name == "sqrt" || Name == "sqrtf" || Name == "sqrtl" ||

207 Name == "exp10" || Name == "exp10l" || Name == "exp10f")

208 return false;

209

210

211 if (Name == "pow" || Name == "powf" || Name == "powl" || Name == "exp2" ||

212 Name == "exp2l" || Name == "exp2f" || Name == "floor" ||

213 Name == "floorf" || Name == "ceil" || Name == "round" ||

214 Name == "ffs" || Name == "ffsl" || Name == "abs" || Name == "labs" ||

215 Name == "llabs")

216 return false;

217

218 return true;

219 }

220

227

229

233

238

239 virtual std::optional<Instruction *>

241 return std::nullopt;

242 }

243

244 virtual std::optional<Value *>

247 bool &KnownBitsComputed) const {

248 return std::nullopt;

249 }

250

253 APInt &UndefElts2, APInt &UndefElts3,

255 SimplifyAndSetOp) const {

256 return std::nullopt;

257 }

258

262

265

267

269

271

273 int64_t BaseOffset, bool HasBaseReg,

274 int64_t Scale, unsigned AddrSpace,

276 int64_t ScalableOffset = 0) const {

277

278

279 return !BaseGV && BaseOffset == 0 && (Scale == 0 || Scale == 1);

280 }

281

289

291

293

297

299

305

310

316

322

324

325

326 unsigned DataSize = DL.getTypeStoreSize(DataType);

328 }

329

331

332

333 unsigned DataSize = DL.getTypeStoreSize(DataType);

335 }

336

341

345

349

351 Align Alignment) const {

352 return false;

353 }

354

356 Align Alignment) const {

357 return false;

358 }

359

361 Align Alignment) const {

362 return false;

363 }

364

366 unsigned Opcode1,

368 return false;

369 }

370

374

378

381 unsigned AddrSpace) const {

382 return false;

383 }

384

386 Type *DataType) const {

387 return false;

388 }

389

391

395

399

401

404 bool HasBaseReg, int64_t Scale,

405 unsigned AddrSpace) const {

406

408 Scale, AddrSpace, nullptr,

410 return 0;

412 }

413

415

417

419

420 virtual bool useAA() const { return false; }

421

423

425

427

431

433

435

437

441

443 unsigned ScalarOpdIdx) const {

444 return false;

445 }

446

448 int OpdIdx) const {

449 return OpdIdx == -1;

450 }

451

452 virtual bool

454 int RetIdx) const {

455 return RetIdx == 0;

456 }

457

459 VectorType *Ty, const APInt &DemandedElts, bool Insert, bool Extract,

462 return 0;

463 }

464

470

472

474

478

482

487

489

491

492

495 return false;

496

497

501 }

502

504

508

510

515 unsigned *Fast) const {

516 return false;

517 }

518

523

525

529

531

535

537 const APInt &Imm,

538 Type *Ty) const {

539 return 0;

540 }

541

546

553

559

564

569

571 Type *Ty = nullptr) const {

572 return Vector ? 1 : 0;

573 }

574

576 switch (ClassID) {

577 default:

578 return "Generic::Unknown Register Class";

579 case 0:

580 return "Generic::ScalarRC";

581 case 1:

582 return "Generic::VectorRC";

583 }

584 }

585

590

592

593 virtual std::optional getMaxVScale() const { return std::nullopt; }

595 return std::nullopt;

596 }

598

599 virtual bool

603

607

608 virtual unsigned getMaximumVF(unsigned ElemWidth, unsigned Opcode) const {

609 return 0;

610 }

614

616 const Instruction &I, bool &AllowPromotionWithoutCommonHeader) const {

617 AllowPromotionWithoutCommonHeader = false;

618 return false;

619 }

620

622 virtual std::optional

624 switch (Level) {

626 [[fallthrough]];

628 return std::nullopt;

629 }

631 }

632

633 virtual std::optional

635 switch (Level) {

637 [[fallthrough]];

639 return std::nullopt;

640 }

641

643 }

644

645 virtual std::optional getMinPageSize() const { return {}; }

646

649 unsigned NumStridedMemAccesses,

650 unsigned NumPrefetches,

651 bool HasCall) const {

652 return 1;

653 }

657

659 unsigned Opcode, Type *InputTypeA, Type *InputTypeB, Type *AccumType,

664 }

665

667

672

673

674 auto IsWidenableCondition = [](const Value *V) {

676 if (II->getIntrinsicID() == Intrinsic::experimental_widenable_condition)

677 return true;

678 return false;

679 };

680

681

682 switch (Opcode) {

683 default:

684 break;

685 case Instruction::FDiv:

686 case Instruction::FRem:

687 case Instruction::SDiv:

688 case Instruction::SRem:

689 case Instruction::UDiv:

690 case Instruction::URem:

691

693 case Instruction::And:

694 case Instruction::Or:

695 if (any_of(Args, IsWidenableCondition))

697 break;

698 }

699

700

702 if (Ty->getScalarType()->isFloatingPointTy())

703 return 3;

704

705 return 1;

706 }

707

709 unsigned Opcode1,

713 }

714

719 const Instruction *CxtI = nullptr) const {

720 return 1;

721 }

722

727 switch (Opcode) {

728 default:

729 break;

730 case Instruction::IntToPtr: {

731 unsigned SrcSize = Src->getScalarSizeInBits();

732 if (DL.isLegalInteger(SrcSize) &&

733 SrcSize <= DL.getPointerTypeSizeInBits(Dst))

734 return 0;

735 break;

736 }

737 case Instruction::PtrToAddr: {

738 unsigned DstSize = Dst->getScalarSizeInBits();

739 assert(DstSize == DL.getAddressSizeInBits(Src));

740 if (DL.isLegalInteger(DstSize))

741 return 0;

742 break;

743 }

744 case Instruction::PtrToInt: {

745 unsigned DstSize = Dst->getScalarSizeInBits();

746 if (DL.isLegalInteger(DstSize) &&

747 DstSize >= DL.getPointerTypeSizeInBits(Src))

748 return 0;

749 break;

750 }

751 case Instruction::BitCast:

752 if (Dst == Src || (Dst->isPointerTy() && Src->isPointerTy()))

753

754 return 0;

755 break;

756 case Instruction::Trunc: {

757

758

759 TypeSize DstSize = DL.getTypeSizeInBits(Dst);

761 return 0;

762 break;

763 }

764 }

765 return 1;

766 }

767

773

777

778

780 return 0;

781 return 1;

782 }

783

790

793 unsigned Index, const Value *Op0,

794 const Value *Op1) const {

795 return 1;

796 }

797

798

799

800

801

805 ArrayRef<std::tuple<Value *, User *, int>> ScalarUserAndIdx) const {

806 return 1;

807 }

808

811 unsigned Index) const {

812 return 1;

813 }

814

818 unsigned Index) const {

819 return 1;

820 }

821

824 const APInt &DemandedDstElts,

826 return 1;

827 }

828

832

833

834

835 if (Opcode == Instruction::InsertValue &&

839 }

840

847

851 bool UseMaskForCond, bool UseMaskForGaps) const {

852 return 1;

853 }

854

858 switch (ICA.getID()) {

859 default:

860 break;

861 case Intrinsic::allow_runtime_check:

862 case Intrinsic::allow_ubsan_check:

863 case Intrinsic::annotation:

864 case Intrinsic::assume:

865 case Intrinsic::sideeffect:

866 case Intrinsic::pseudoprobe:

867 case Intrinsic::arithmetic_fence:

868 case Intrinsic::dbg_assign:

869 case Intrinsic::dbg_declare:

870 case Intrinsic::dbg_value:

871 case Intrinsic::dbg_label:

872 case Intrinsic::invariant_start:

873 case Intrinsic::invariant_end:

874 case Intrinsic::launder_invariant_group:

875 case Intrinsic::strip_invariant_group:

876 case Intrinsic::is_constant:

877 case Intrinsic::lifetime_start:

878 case Intrinsic::lifetime_end:

879 case Intrinsic::experimental_noalias_scope_decl:

880 case Intrinsic::objectsize:

881 case Intrinsic::ptr_annotation:

882 case Intrinsic::var_annotation:

883 case Intrinsic::experimental_gc_result:

884 case Intrinsic::experimental_gc_relocate:

885 case Intrinsic::coro_alloc:

886 case Intrinsic::coro_begin:

887 case Intrinsic::coro_begin_custom_abi:

888 case Intrinsic::coro_free:

889 case Intrinsic::coro_end:

890 case Intrinsic::coro_frame:

891 case Intrinsic::coro_size:

892 case Intrinsic::coro_align:

893 case Intrinsic::coro_suspend:

894 case Intrinsic::coro_subfn_addr:

895 case Intrinsic::threadlocal_address:

896 case Intrinsic::experimental_widenable_condition:

897 case Intrinsic::ssa_copy:

898

899 return 0;

900 }

901 return 1;

902 }

903

907 switch (MICA.getID()) {

908 case Intrinsic::masked_scatter:

909 case Intrinsic::masked_gather:

910 case Intrinsic::masked_load:

911 case Intrinsic::masked_store:

912 case Intrinsic::vp_scatter:

913 case Intrinsic::vp_gather:

914 case Intrinsic::masked_compressstore:

915 case Intrinsic::masked_expandload:

916 return 1;

917 }

919 }

920

926

927

929

932 const SCEV *,

934 return 0;

935 }

936

939 std::optional FMF,

941 return 1;

942 }

943

949

952 VectorType *Ty, std::optional FMF,

954 return 1;

955 }

956

962

967

972

974

975

976

977

978

979 return 0;

980 }

981

984 bool CanCreate = true) const {

985 return nullptr;

986 }

987

988 virtual Type *

990 unsigned SrcAddrSpace, unsigned DestAddrSpace,

992 std::optional<uint32_t> AtomicElementSize) const {

993 return AtomicElementSize ? Type::getIntNTy(Context, *AtomicElementSize * 8)

995 }

996

999 unsigned RemainingBytes, unsigned SrcAddrSpace, unsigned DestAddrSpace,

1001 std::optional<uint32_t> AtomicCpySize) const {

1002 unsigned OpSizeInBytes = AtomicCpySize.value_or(1);

1004 for (unsigned i = 0; i != RemainingBytes; i += OpSizeInBytes)

1006 }

1007

1009 const Function *Callee) const {

1010 return (Caller->getFnAttribute("target-cpu") ==

1011 Callee->getFnAttribute("target-cpu")) &&

1012 (Caller->getFnAttribute("target-features") ==

1013 Callee->getFnAttribute("target-features"));

1014 }

1015

1017 unsigned DefaultCallPenalty) const {

1018 return DefaultCallPenalty;

1019 }

1020

1024 return (Caller->getFnAttribute("target-cpu") ==

1025 Callee->getFnAttribute("target-cpu")) &&

1026 (Caller->getFnAttribute("target-features") ==

1027 Callee->getFnAttribute("target-features"));

1028 }

1029

1031 return false;

1032 }

1033

1035 return false;

1036 }

1037

1041

1043

1045

1047 Align Alignment,

1048 unsigned AddrSpace) const {

1049 return true;

1050 }

1051

1053 Align Alignment,

1054 unsigned AddrSpace) const {

1055 return true;

1056 }

1057

1062

1066

1068 unsigned ChainSizeInBytes,

1070 return VF;

1071 }

1072

1074 unsigned ChainSizeInBytes,

1076 return VF;

1077 }

1078

1080 return false;

1081 }

1082

1084 return false;

1085 }

1087

1089

1091

1093

1097

1102

1104

1106

1108

1110

1112

1115 return false;

1116 }

1117

1119

1126

1128

1132

1134 return false;

1135 }

1136

1138

1143

1147

1149

1150protected:

1151

1152

1156

1157

1158

1160

1161

1163

1164

1165 unsigned MaxRequiredSize =

1166 VT->getElementType()->getPrimitiveSizeInBits().getFixedValue();

1167

1168 unsigned MinRequiredSize = 0;

1169 for (unsigned i = 0, e = VT->getNumElements(); i < e; ++i) {

1170 if (auto *IntElement =

1172 bool signedElement = IntElement->getValue().isNegative();

1173

1174 unsigned ElementMinRequiredSize =

1175 IntElement->getValue().getSignificantBits() - 1;

1176

1178

1179 MinRequiredSize = std::max(MinRequiredSize, ElementMinRequiredSize);

1180 } else {

1181

1182 return MaxRequiredSize;

1183 }

1184 }

1185 return MinRequiredSize;

1186 }

1187

1189 isSigned = CI->getValue().isNegative();

1190 return CI->getValue().getSignificantBits() - 1;

1191 }

1192

1195 return Cast->getSrcTy()->getScalarSizeInBits() - 1;

1196 }

1197

1200 return Cast->getSrcTy()->getScalarSizeInBits();

1201 }

1202

1205 }

1206

1210

1212 const SCEV *Ptr) const {

1214 return nullptr;

1217 }

1218

1220 int64_t MergeDistance) const {

1222 if (!Step)

1223 return false;

1226 return false;

1227

1228 return StrideVal.getSExtValue() < MergeDistance;

1229 }

1230};

1231

1232

1233

1234template

1236private:

1238

1239protected:

1241

1242public:

1246 assert(PointeeType && Ptr && "can't get GEPCost of nullptr");

1248 bool HasBaseReg = (BaseGV == nullptr);

1249

1250 auto PtrSizeBits = DL.getPointerTypeSizeInBits(Ptr->getType());

1251 APInt BaseOffset(PtrSizeBits, 0);

1252 int64_t Scale = 0;

1253

1255 Type *TargetType = nullptr;

1256

1257

1258

1259 if (Operands.empty())

1261

1262 for (auto I = Operands.begin(); I != Operands.end(); ++I, ++GTI) {

1263 TargetType = GTI.getIndexedType();

1264

1265

1267 if (!ConstIdx)

1270 if (StructType *STy = GTI.getStructTypeOrNull()) {

1271

1272 assert(ConstIdx && "Unexpected GEP index");

1274 BaseOffset += DL.getStructLayout(STy)->getElementOffset(Field);

1275 } else {

1276

1277

1280 int64_t ElementSize =

1281 GTI.getSequentialElementStride(DL).getFixedValue();

1282 if (ConstIdx) {

1283 BaseOffset +=

1285 } else {

1286

1287 if (Scale != 0)

1288

1290 Scale = ElementSize;

1291 }

1292 }

1293 }

1294

1295

1296

1297

1298

1299

1300

1301

1302

1303

1304 if (!AccessType)

1305 AccessType = TargetType;

1306

1307

1308

1310 AccessType, const_cast<GlobalValue *>(BaseGV),

1314

1315

1316

1317

1319 }

1320

1326

1327

1328

1329

1330

1331

1332

1333

1334

1335

1336 for (const Value *V : Ptrs) {

1338 if ( GEP )

1339 continue;

1340 if (Info.isSameBase() && V != Base) {

1341 if (GEP->hasAllConstantIndices())

1342 continue;

1344 Instruction::Add, GEP->getType(), CostKind,

1345 {TTI::OK_AnyValue, TTI::OP_None}, {TTI::OK_AnyValue, TTI::OP_None},

1346 {});

1347 } else {

1350 GEP->getSourceElementType(), GEP->getPointerOperand(), Indices,

1352 }

1353 }

1354 return Cost;

1355 }

1356

1361

1362 auto *TargetTTI = static_cast<const T *>(this);

1363

1364

1367 if (const Function *F = CB->getCalledFunction()) {

1368 if (!TargetTTI->isLoweredToCall(F))

1369 return TTI::TCC_Basic;

1370

1371 return TTI::TCC_Basic * (F->getFunctionType()->getNumParams() + 1);

1372 }

1373

1375 }

1376

1377 Type *Ty = U->getType();

1380 switch (Opcode) {

1381 default:

1382 break;

1383 case Instruction::Call: {

1387 return TargetTTI->getIntrinsicInstrCost(CostAttrs, CostKind);

1388 }

1389 case Instruction::Br:

1390 case Instruction::Ret:

1391 case Instruction::PHI:

1392 case Instruction::Switch:

1393 return TargetTTI->getCFInstrCost(Opcode, CostKind, I);

1394 case Instruction::Freeze:

1396 case Instruction::ExtractValue:

1397 case Instruction::InsertValue:

1398 return TargetTTI->getInsertExtractValueCost(Opcode, CostKind);

1399 case Instruction::Alloca:

1402 break;

1403 case Instruction::GetElementPtr: {

1405 Type *AccessType = nullptr;

1406

1407

1408 if (GEP->hasOneUser() && I)

1409 AccessType = I->user_back()->getAccessType();

1410

1411 return TargetTTI->getGEPCost(GEP->getSourceElementType(),

1414 }

1415 case Instruction::Add:

1416 case Instruction::FAdd:

1417 case Instruction::Sub:

1418 case Instruction::FSub:

1419 case Instruction::Mul:

1420 case Instruction::FMul:

1421 case Instruction::UDiv:

1422 case Instruction::SDiv:

1423 case Instruction::FDiv:

1424 case Instruction::URem:

1425 case Instruction::SRem:

1426 case Instruction::FRem:

1427 case Instruction::Shl:

1428 case Instruction::LShr:

1429 case Instruction::AShr:

1430 case Instruction::And:

1431 case Instruction::Or:

1432 case Instruction::Xor:

1433 case Instruction::FNeg: {

1436 if (Opcode != Instruction::FNeg)

1438 return TargetTTI->getArithmeticInstrCost(Opcode, Ty, CostKind, Op1Info,

1439 Op2Info, Operands, I);

1440 }

1441 case Instruction::IntToPtr:

1442 case Instruction::PtrToAddr:

1443 case Instruction::PtrToInt:

1444 case Instruction::SIToFP:

1445 case Instruction::UIToFP:

1446 case Instruction::FPToUI:

1447 case Instruction::FPToSI:

1448 case Instruction::Trunc:

1449 case Instruction::FPTrunc:

1450 case Instruction::BitCast:

1451 case Instruction::FPExt:

1452 case Instruction::SExt:

1453 case Instruction::ZExt:

1454 case Instruction::AddrSpaceCast: {

1455 Type *OpTy = Operands[0]->getType();

1456 return TargetTTI->getCastInstrCost(

1458 }

1459 case Instruction::Store: {

1461 Type *ValTy = Operands[0]->getType();

1463 return TargetTTI->getMemoryOpCost(Opcode, ValTy, SI->getAlign(),

1464 SI->getPointerAddressSpace(), CostKind,

1465 OpInfo, I);

1466 }

1467 case Instruction::Load: {

1468

1470 return 4;

1472 Type *LoadType = U->getType();

1473

1474

1475

1476

1477

1478

1479

1483 LoadType = TI->getDestTy();

1484 }

1485 return TargetTTI->getMemoryOpCost(Opcode, LoadType, LI->getAlign(),

1487 {TTI::OK_AnyValue, TTI::OP_None}, I);

1488 }

1489 case Instruction::Select: {

1490 const Value *Op0, *Op1;

1493

1494

1499

1501 return TargetTTI->getArithmeticInstrCost(

1502 match(U, m_LogicalOr()) ? Instruction::Or : Instruction::And, Ty,

1503 CostKind, Op1Info, Op2Info, Operands, I);

1504 }

1507 Type *CondTy = Operands[0]->getType();

1508 return TargetTTI->getCmpSelInstrCost(Opcode, U->getType(), CondTy,

1511 }

1512 case Instruction::ICmp:

1513 case Instruction::FCmp: {

1516 Type *ValTy = Operands[0]->getType();

1517

1518 return TargetTTI->getCmpSelInstrCost(Opcode, ValTy, U->getType(),

1522 }

1523 case Instruction::InsertElement: {

1525 if (!IE)

1527 unsigned Idx = -1;

1529 if (CI->getValue().getActiveBits() <= 32)

1530 Idx = CI->getZExtValue();

1531 return TargetTTI->getVectorInstrCost(*IE, Ty, CostKind, Idx);

1532 }

1533 case Instruction::ShuffleVector: {

1535 if (!Shuffle)

1537

1541 int NumSubElts, SubIndex;

1542

1543

1544 if (all_of(Mask, [](int M) { return M < 0; }))

1546

1547

1548 if (Shuffle->changesLength()) {

1549

1550 if (Shuffle->increasesLength() && Shuffle->isIdentityWithPadding())

1552

1553 if (Shuffle->isExtractSubvectorMask(SubIndex))

1555 VecSrcTy, Mask, CostKind, SubIndex,

1556 VecTy, Operands, Shuffle);

1557

1558 if (Shuffle->isInsertSubvectorMask(NumSubElts, SubIndex))

1559 return TargetTTI->getShuffleCost(

1561 SubIndex,

1563 Operands, Shuffle);

1564

1565 int ReplicationFactor, VF;

1566 if (Shuffle->isReplicationMask(ReplicationFactor, VF)) {

1570 DemandedDstElts.setBit(I.index());

1571 }

1572 return TargetTTI->getReplicationShuffleCost(

1573 VecSrcTy->getElementType(), ReplicationFactor, VF,

1575 }

1576

1578 NumSubElts = VecSrcTy->getElementCount().getKnownMinValue();

1580

1581

1582

1583

1584 if (Shuffle->increasesLength()) {

1585 for (int &M : AdjustMask)

1586 M = M >= NumSubElts ? (M + (Mask.size() - NumSubElts)) : M;

1587

1588 return TargetTTI->getShuffleCost(

1590 VecTy, AdjustMask, CostKind, 0, nullptr, Operands, Shuffle);

1591 }

1592

1593

1594

1595

1596

1598

1599 InstructionCost ShuffleCost = TargetTTI->getShuffleCost(

1601 VecSrcTy, VecSrcTy, AdjustMask, CostKind, 0, nullptr, Operands,

1602 Shuffle);

1603

1605 std::iota(ExtractMask.begin(), ExtractMask.end(), 0);

1606 return ShuffleCost + TargetTTI->getShuffleCost(

1608 ExtractMask, CostKind, 0, VecTy, {}, Shuffle);

1609 }

1610

1611 if (Shuffle->isIdentity())

1613

1614 if (Shuffle->isReverse())

1615 return TargetTTI->getShuffleCost(TTI::SK_Reverse, VecTy, VecSrcTy, Mask,

1616 CostKind, 0, nullptr, Operands,

1617 Shuffle);

1618

1619 if (Shuffle->isTranspose())

1620 return TargetTTI->getShuffleCost(TTI::SK_Transpose, VecTy, VecSrcTy,

1621 Mask, CostKind, 0, nullptr, Operands,

1622 Shuffle);

1623

1624 if (Shuffle->isZeroEltSplat())

1625 return TargetTTI->getShuffleCost(TTI::SK_Broadcast, VecTy, VecSrcTy,

1626 Mask, CostKind, 0, nullptr, Operands,

1627 Shuffle);

1628

1629 if (Shuffle->isSingleSource())

1631 VecSrcTy, Mask, CostKind, 0, nullptr,

1632 Operands, Shuffle);

1633

1634 if (Shuffle->isInsertSubvectorMask(NumSubElts, SubIndex))

1635 return TargetTTI->getShuffleCost(

1638 Shuffle);

1639

1640 if (Shuffle->isSelect())

1641 return TargetTTI->getShuffleCost(TTI::SK_Select, VecTy, VecSrcTy, Mask,

1642 CostKind, 0, nullptr, Operands,

1643 Shuffle);

1644

1645 if (Shuffle->isSplice(SubIndex))

1646 return TargetTTI->getShuffleCost(TTI::SK_Splice, VecTy, VecSrcTy, Mask,

1647 CostKind, SubIndex, nullptr, Operands,

1648 Shuffle);

1649

1651 Mask, CostKind, 0, nullptr, Operands,

1652 Shuffle);

1653 }

1654 case Instruction::ExtractElement: {

1656 if (!EEI)

1658 unsigned Idx = -1;

1660 if (CI->getValue().getActiveBits() <= 32)

1661 Idx = CI->getZExtValue();

1662 Type *DstTy = Operands[0]->getType();

1663 return TargetTTI->getVectorInstrCost(*EEI, DstTy, CostKind, Idx);

1664 }

1665 }

1666

1667

1669 }

1670

1672 auto *TargetTTI = static_cast<const T *>(this);

1677 }

1678

1682};

1683}

1684

1685#endif

assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")

Analysis containing CSE Info

static cl::opt< OutputCostKind > CostKind("cost-kind", cl::desc("Target cost kind"), cl::init(OutputCostKind::RecipThroughput), cl::values(clEnumValN(OutputCostKind::RecipThroughput, "throughput", "Reciprocal throughput"), clEnumValN(OutputCostKind::Latency, "latency", "Instruction latency"), clEnumValN(OutputCostKind::CodeSize, "code-size", "Code size"), clEnumValN(OutputCostKind::SizeAndLatency, "size-latency", "Code size and latency"), clEnumValN(OutputCostKind::All, "all", "Print all cost kinds")))

static bool isSigned(unsigned int Opcode)

const AbstractManglingParser< Derived, Alloc >::OperatorInfo AbstractManglingParser< Derived, Alloc >::Ops[]

uint64_t IntrinsicInst * II

OptimizedStructLayoutField Field

static cl::opt< RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode > Mode("regalloc-enable-advisor", cl::Hidden, cl::init(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Default), cl::desc("Enable regalloc advisor mode"), cl::values(clEnumValN(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Default, "default", "Default"), clEnumValN(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Release, "release", "precompiled"), clEnumValN(RegAllocEvictionAdvisorAnalysisLegacy::AdvisorMode::Development, "development", "for training")))

static SymbolRef::Type getType(const Symbol *Sym)

This pass exposes codegen information to IR-level passes.

Class for arbitrary precision integers.

void setBit(unsigned BitPosition)

Set the given bit to 1 whose position is given as "bitPosition".

unsigned getBitWidth() const

Return the number of bits in the APInt.

LLVM_ABI APInt sextOrTrunc(unsigned width) const

Sign extend or truncate to width.

static APInt getZero(unsigned numBits)

Get the '0' value for the specified bit-width.

int64_t getSExtValue() const

Get sign extended value.

an instruction to allocate memory on the stack

ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...

ArrayRef< T > drop_front(size_t N=1) const

Drop the first N elements of the array.

const T & front() const

front - Get the first element.

bool empty() const

empty - Check if the array is empty.

Class to represent array types.

A cache of @llvm.assume calls within a function.

BlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate IR basic block frequen...

Conditional or Unconditional Branch instruction.

Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...

Predicate

This enumeration lists the possible predicates for CmpInst subclasses.

This is the shared class of boolean and integer constants.

uint64_t getZExtValue() const

Return the constant as a 64-bit unsigned integer value after it has been zero extended as appropriate...

const APInt & getValue() const

Return the constant as an APInt value reference.

This is an important base class in LLVM.

A parsed version of the target data layout string in and methods for querying it.

Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.

static constexpr ElementCount get(ScalarTy MinVal, bool Scalable)

Convenience struct for specifying and reasoning about fast-math flags.

static LLVM_ABI FixedVectorType * get(Type *ElementType, unsigned NumElts)

The core instruction combiner logic.

static InstructionCost getInvalid(CostType Val=0)

Intrinsic::ID getID() const

A wrapper class for inspecting calls to intrinsic functions.

This is an important class for using LLVM in a threaded context.

An instruction for reading from memory.

Represents a single loop in the control flow graph.

Information for memory intrinsic cost model.

Intrinsic::ID getID() const

unsigned getOpcode() const

Return the opcode for this Instruction or ConstantExpr.

Analysis providing profile information.

The RecurrenceDescriptor is used to identify recurrences variables in a loop.

This node represents a polynomial recurrence on the trip count of the specified loop.

const SCEV * getStepRecurrence(ScalarEvolution &SE) const

Constructs and returns the recurrence indicating how much this expression steps by.

This class represents a constant integer value.

const APInt & getAPInt() const

This class represents an analyzed expression in the program.

The main scalar evolution driver.

This is a 'bitvector' (really, a variable-sized bit array), optimized for the case when the array is ...

This class consists of common code factored out of the SmallVector class to reduce code duplication b...

void append(ItTy in_start, ItTy in_end)

Add the specified range to the end of the SmallVector.

void push_back(const T &Elt)

This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.

StackOffset holds a fixed and a scalable offset in bytes.

static StackOffset getScalable(int64_t Scalable)

static StackOffset getFixed(int64_t Fixed)

An instruction for storing to memory.

StringRef - Represent a constant reference to a string, i.e.

Class to represent struct types.

Provides information about what library functions are available for the current target.

virtual InstructionCost getPointersChainCost(ArrayRef< const Value * > Ptrs, const Value *Base, const TTI::PointersChainInfo &Info, Type *AccessTy, TTI::TargetCostKind CostKind) const

Definition TargetTransformInfoImpl.h:68

virtual bool preferAlternateOpcodeVectorization() const

Definition TargetTransformInfoImpl.h:1086

virtual bool isProfitableLSRChainElement(Instruction *I) const

Definition TargetTransformInfoImpl.h:294

virtual unsigned getCallerAllocaCost(const CallBase *CB, const AllocaInst *AI) const

Definition TargetTransformInfoImpl.h:105

virtual bool shouldBuildLookupTables() const

Definition TargetTransformInfoImpl.h:426

virtual int getInliningLastCallToStaticBonus() const

Definition TargetTransformInfoImpl.h:97

virtual bool getTgtMemIntrinsic(IntrinsicInst *Inst, MemIntrinsicInfo &Info) const

Definition TargetTransformInfoImpl.h:968

virtual InstructionCost getCostOfKeepingLiveOverCall(ArrayRef< Type * > Tys) const

Definition TargetTransformInfoImpl.h:964

virtual unsigned getMaximumVF(unsigned ElemWidth, unsigned Opcode) const

Definition TargetTransformInfoImpl.h:608

virtual InstructionCost getMulAccReductionCost(bool IsUnsigned, unsigned RedOpcode, Type *ResTy, VectorType *Ty, TTI::TargetCostKind CostKind) const

Definition TargetTransformInfoImpl.h:958

virtual const DataLayout & getDataLayout() const

Definition TargetTransformInfoImpl.h:50

virtual bool preferFixedOverScalableIfEqualCost(bool IsEpilogue) const

Definition TargetTransformInfoImpl.h:1079

virtual std::optional< unsigned > getCacheAssociativity(TargetTransformInfo::CacheLevel Level) const

Definition TargetTransformInfoImpl.h:634

virtual InstructionCost getCallInstrCost(Function *F, Type *RetTy, ArrayRef< Type * > Tys, TTI::TargetCostKind CostKind) const

Definition TargetTransformInfoImpl.h:921

virtual bool enableInterleavedAccessVectorization() const

Definition TargetTransformInfoImpl.h:503

virtual InstructionCost getFPOpCost(Type *Ty) const

Definition TargetTransformInfoImpl.h:532

virtual unsigned getMaxInterleaveFactor(ElementCount VF) const

Definition TargetTransformInfoImpl.h:666

virtual bool isLegalMaskedExpandLoad(Type *DataType, Align Alignment) const

Definition TargetTransformInfoImpl.h:371

virtual TTI::MemCmpExpansionOptions enableMemCmpExpansion(bool OptSize, bool IsZeroCmp) const

Definition TargetTransformInfoImpl.h:484

virtual bool supportsTailCalls() const

Definition TargetTransformInfoImpl.h:473

virtual bool isLegalToVectorizeLoadChain(unsigned ChainSizeInBytes, Align Alignment, unsigned AddrSpace) const

Definition TargetTransformInfoImpl.h:1046

bool isStridedAccess(const SCEV *Ptr) const

Definition TargetTransformInfoImpl.h:1207

virtual ~TargetTransformInfoImplBase()

virtual unsigned getAtomicMemIntrinsicMaxElementSize() const

Definition TargetTransformInfoImpl.h:973

virtual Value * rewriteIntrinsicWithAddressSpace(IntrinsicInst *II, Value *OldV, Value *NewV) const

Definition TargetTransformInfoImpl.h:168

virtual bool supportsScalableVectors() const

Definition TargetTransformInfoImpl.h:1107

virtual TargetTransformInfo::VPLegalization getVPLegalizationStrategy(const VPIntrinsic &PI) const

Definition TargetTransformInfoImpl.h:1121

virtual bool enableAggressiveInterleaving(bool LoopHasReductions) const

Definition TargetTransformInfoImpl.h:479

virtual std::optional< Value * > simplifyDemandedVectorEltsIntrinsic(InstCombiner &IC, IntrinsicInst &II, APInt DemandedElts, APInt &UndefElts, APInt &UndefElts2, APInt &UndefElts3, std::function< void(Instruction *, unsigned, APInt, APInt &)> SimplifyAndSetOp) const

Definition TargetTransformInfoImpl.h:251

virtual bool isLegalMaskedStore(Type *DataType, Align Alignment, unsigned AddressSpace, TTI::MaskKind MaskKind) const

Definition TargetTransformInfoImpl.h:311

virtual InstructionCost getAddressComputationCost(Type *PtrTy, ScalarEvolution *, const SCEV *, TTI::TargetCostKind) const

Definition TargetTransformInfoImpl.h:930

virtual InstructionCost getVectorInstrCost(unsigned Opcode, Type *Val, TTI::TargetCostKind CostKind, unsigned Index, const Value *Op0, const Value *Op1) const

Definition TargetTransformInfoImpl.h:791

virtual bool isLegalBroadcastLoad(Type *ElementTy, ElementCount NumElements) const

Definition TargetTransformInfoImpl.h:337

virtual bool isSingleThreaded() const

Definition TargetTransformInfoImpl.h:161

virtual bool isIndexedLoadLegal(TTI::MemIndexedMode Mode, Type *Ty) const

Definition TargetTransformInfoImpl.h:1030

virtual unsigned adjustInliningThreshold(const CallBase *CB) const

Definition TargetTransformInfoImpl.h:102

virtual InstructionCost getPartialReductionCost(unsigned Opcode, Type *InputTypeA, Type *InputTypeB, Type *AccumType, ElementCount VF, TTI::PartialReductionExtendKind OpAExtend, TTI::PartialReductionExtendKind OpBExtend, std::optional< unsigned > BinOp, TTI::TargetCostKind CostKind) const

Definition TargetTransformInfoImpl.h:658

virtual unsigned getLoadVectorFactor(unsigned VF, unsigned LoadSize, unsigned ChainSizeInBytes, VectorType *VecTy) const

Definition TargetTransformInfoImpl.h:1067

virtual bool shouldDropLSRSolutionIfLessProfitable() const

Definition TargetTransformInfoImpl.h:292

virtual bool hasVolatileVariant(Instruction *I, unsigned AddrSpace) const

Definition TargetTransformInfoImpl.h:396

virtual bool canMacroFuseCmp() const

Definition TargetTransformInfoImpl.h:298

virtual int getInlinerVectorBonusPercent() const

Definition TargetTransformInfoImpl.h:110

virtual bool prefersVectorizedAddressing() const

Definition TargetTransformInfoImpl.h:400

virtual bool isLegalMaskedLoad(Type *DataType, Align Alignment, unsigned AddressSpace, TTI::MaskKind MaskKind) const

Definition TargetTransformInfoImpl.h:317

virtual bool hasDivRemOp(Type *DataType, bool IsSigned) const

Definition TargetTransformInfoImpl.h:392

virtual bool isLegalStridedLoadStore(Type *DataType, Align Alignment) const

Definition TargetTransformInfoImpl.h:375

virtual unsigned getStoreMinimumVF(unsigned VF, Type *, Type *) const

Definition TargetTransformInfoImpl.h:611

virtual bool isLegalICmpImmediate(int64_t Imm) const

Definition TargetTransformInfoImpl.h:270

virtual bool LSRWithInstrQueries() const

Definition TargetTransformInfoImpl.h:414

virtual bool preferPredicatedReductionSelect() const

Definition TargetTransformInfoImpl.h:1088

virtual InstructionCost getMemoryOpCost(unsigned Opcode, Type *Src, Align Alignment, unsigned AddressSpace, TTI::TargetCostKind CostKind, TTI::OperandValueInfo OpInfo, const Instruction *I) const

Definition TargetTransformInfoImpl.h:842

virtual bool useAA() const

Definition TargetTransformInfoImpl.h:420

virtual bool preferPredicateOverEpilogue(TailFoldingInfo *TFI) const

Definition TargetTransformInfoImpl.h:230

virtual bool haveFastSqrt(Type *Ty) const

Definition TargetTransformInfoImpl.h:524

virtual ElementCount getMinimumVF(unsigned ElemWidth, bool IsScalable) const

Definition TargetTransformInfoImpl.h:604

virtual bool collectFlatAddressOperands(SmallVectorImpl< int > &OpIndexes, Intrinsic::ID IID) const

Definition TargetTransformInfoImpl.h:148

virtual bool addrspacesMayAlias(unsigned AS0, unsigned AS1) const

Definition TargetTransformInfoImpl.h:142

virtual bool canSaveCmp(Loop *L, BranchInst **BI, ScalarEvolution *SE, LoopInfo *LI, DominatorTree *DT, AssumptionCache *AC, TargetLibraryInfo *LibInfo) const

Definition TargetTransformInfoImpl.h:300

virtual InstructionCost getVectorInstrCost(const Instruction &I, Type *Val, TTI::TargetCostKind CostKind, unsigned Index) const

Definition TargetTransformInfoImpl.h:809

virtual unsigned getRegisterClassForType(bool Vector, Type *Ty=nullptr) const

Definition TargetTransformInfoImpl.h:570

virtual std::optional< unsigned > getVScaleForTuning() const

Definition TargetTransformInfoImpl.h:594

virtual InstructionCost getIntImmCost(const APInt &Imm, Type *Ty, TTI::TargetCostKind CostKind) const

Definition TargetTransformInfoImpl.h:542

virtual InstructionCost getScalingFactorCost(Type *Ty, GlobalValue *BaseGV, StackOffset BaseOffset, bool HasBaseReg, int64_t Scale, unsigned AddrSpace) const

Definition TargetTransformInfoImpl.h:402

virtual unsigned getNumberOfParts(Type *Tp) const

Definition TargetTransformInfoImpl.h:928

virtual bool isLegalMaskedCompressStore(Type *DataType, Align Alignment) const

Definition TargetTransformInfoImpl.h:360

virtual bool isHardwareLoopProfitable(Loop *L, ScalarEvolution &SE, AssumptionCache &AC, TargetLibraryInfo *LibInfo, HardwareLoopInfo &HWLoopInfo) const

Definition TargetTransformInfoImpl.h:221

virtual void getPeelingPreferences(Loop *, ScalarEvolution &, TTI::PeelingPreferences &) const

Definition TargetTransformInfoImpl.h:263

virtual std::optional< Value * > simplifyDemandedUseBitsIntrinsic(InstCombiner &IC, IntrinsicInst &II, APInt DemandedMask, KnownBits &Known, bool &KnownBitsComputed) const

Definition TargetTransformInfoImpl.h:245

virtual bool useColdCCForColdCall(Function &F) const

Definition TargetTransformInfoImpl.h:434

virtual unsigned getNumberOfRegisters(unsigned ClassID) const

Definition TargetTransformInfoImpl.h:565

virtual unsigned getPrefetchDistance() const

Definition TargetTransformInfoImpl.h:647

virtual bool canHaveNonUndefGlobalInitializerInAddressSpace(unsigned AS) const

Definition TargetTransformInfoImpl.h:155

virtual bool isLegalAddScalableImmediate(int64_t Imm) const

Definition TargetTransformInfoImpl.h:268

virtual bool isLegalInterleavedAccessType(VectorType *VTy, unsigned Factor, Align Alignment, unsigned AddrSpace) const

Definition TargetTransformInfoImpl.h:379

TargetTransformInfoImplBase(TargetTransformInfoImplBase &&Arg)

Definition TargetTransformInfoImpl.h:48

virtual bool shouldPrefetchAddressSpace(unsigned AS) const

Definition TargetTransformInfoImpl.h:656

virtual bool forceScalarizeMaskedScatter(VectorType *DataType, Align Alignment) const

Definition TargetTransformInfoImpl.h:355

virtual uint64_t getMaxMemIntrinsicInlineSizeThreshold() const

Definition TargetTransformInfoImpl.h:116

virtual unsigned getMinVectorRegisterBitWidth() const

Definition TargetTransformInfoImpl.h:591

unsigned minRequiredElementSize(const Value *Val, bool &isSigned) const

Definition TargetTransformInfoImpl.h:1153

virtual bool shouldBuildLookupTablesForConstant(Constant *C) const

Definition TargetTransformInfoImpl.h:428

virtual bool isFPVectorizationPotentiallyUnsafe() const

Definition TargetTransformInfoImpl.h:509

virtual bool isLegalToVectorizeReduction(const RecurrenceDescriptor &RdxDesc, ElementCount VF) const

Definition TargetTransformInfoImpl.h:1058

virtual InstructionCost getIntImmCostInst(unsigned Opcode, unsigned Idx, const APInt &Imm, Type *Ty, TTI::TargetCostKind CostKind, Instruction *Inst=nullptr) const

Definition TargetTransformInfoImpl.h:547

virtual bool isLegalAltInstr(VectorType *VecTy, unsigned Opcode0, unsigned Opcode1, const SmallBitVector &OpcodeMask) const

Definition TargetTransformInfoImpl.h:365

virtual InstructionCost getIndexedVectorInstrCostFromEnd(unsigned Opcode, Type *Val, TTI::TargetCostKind CostKind, unsigned Index) const

Definition TargetTransformInfoImpl.h:816

virtual std::optional< unsigned > getCacheSize(TargetTransformInfo::CacheLevel Level) const

Definition TargetTransformInfoImpl.h:623

virtual InstructionCost getExtractWithExtendCost(unsigned Opcode, Type *Dst, VectorType *VecTy, unsigned Index, TTI::TargetCostKind CostKind) const

Definition TargetTransformInfoImpl.h:769

virtual bool shouldTreatInstructionLikeSelect(const Instruction *I) const

Definition TargetTransformInfoImpl.h:490

virtual std::optional< Instruction * > instCombineIntrinsic(InstCombiner &IC, IntrinsicInst &II) const

Definition TargetTransformInfoImpl.h:240

virtual unsigned getEpilogueVectorizationMinVF() const

Definition TargetTransformInfoImpl.h:228

virtual std::pair< const Value *, unsigned > getPredicatedAddrSpace(const Value *V) const

Definition TargetTransformInfoImpl.h:164

virtual bool shouldMaximizeVectorBandwidth(TargetTransformInfo::RegisterKind K) const

Definition TargetTransformInfoImpl.h:600

virtual void getMemcpyLoopResidualLoweringType(SmallVectorImpl< Type * > &OpsOut, LLVMContext &Context, unsigned RemainingBytes, unsigned SrcAddrSpace, unsigned DestAddrSpace, Align SrcAlign, Align DestAlign, std::optional< uint32_t > AtomicCpySize) const

Definition TargetTransformInfoImpl.h:997

virtual TTI::PopcntSupportKind getPopcntSupport(unsigned IntTyWidthInBit) const

Definition TargetTransformInfoImpl.h:520

virtual TTI::AddressingModeKind getPreferredAddressingMode(const Loop *L, ScalarEvolution *SE) const

Definition TargetTransformInfoImpl.h:307

virtual bool forceScalarizeMaskedGather(VectorType *DataType, Align Alignment) const

Definition TargetTransformInfoImpl.h:350

virtual unsigned getMaxPrefetchIterationsAhead() const

Definition TargetTransformInfoImpl.h:654

virtual bool allowVectorElementIndexingUsingGEP() const

Definition TargetTransformInfoImpl.h:1148

virtual InstructionCost getInstructionCost(const User *U, ArrayRef< const Value * > Operands, TTI::TargetCostKind CostKind) const

Definition TargetTransformInfoImpl.h:85

virtual TTI::ReductionShuffle getPreferredExpandedReductionShuffle(const IntrinsicInst *II) const

Definition TargetTransformInfoImpl.h:1099

const SCEVConstant * getConstantStrideStep(ScalarEvolution *SE, const SCEV *Ptr) const

Definition TargetTransformInfoImpl.h:1211

virtual bool hasBranchDivergence(const Function *F=nullptr) const

Definition TargetTransformInfoImpl.h:130

virtual InstructionCost getArithmeticReductionCost(unsigned, VectorType *, std::optional< FastMathFlags > FMF, TTI::TargetCostKind) const

Definition TargetTransformInfoImpl.h:938

virtual bool isProfitableToHoist(Instruction *I) const

Definition TargetTransformInfoImpl.h:418

virtual const char * getRegisterClassName(unsigned ClassID) const

Definition TargetTransformInfoImpl.h:575

virtual InstructionCost getMinMaxReductionCost(Intrinsic::ID IID, VectorType *, FastMathFlags, TTI::TargetCostKind) const

Definition TargetTransformInfoImpl.h:944

virtual unsigned getCacheLineSize() const

Definition TargetTransformInfoImpl.h:621

virtual bool isLegalToVectorizeLoad(LoadInst *LI) const

Definition TargetTransformInfoImpl.h:1042

virtual bool isTargetIntrinsicTriviallyScalarizable(Intrinsic::ID ID) const

Definition TargetTransformInfoImpl.h:438

virtual unsigned getLoadStoreVecRegBitWidth(unsigned AddrSpace) const

Definition TargetTransformInfoImpl.h:1038

virtual InstructionCost getAltInstrCost(VectorType *VecTy, unsigned Opcode0, unsigned Opcode1, const SmallBitVector &OpcodeMask, TTI::TargetCostKind CostKind) const

Definition TargetTransformInfoImpl.h:708

virtual unsigned getInlineCallPenalty(const Function *F, const CallBase &Call, unsigned DefaultCallPenalty) const

Definition TargetTransformInfoImpl.h:1016

virtual bool hasArmWideBranch(bool) const

Definition TargetTransformInfoImpl.h:1127

virtual bool isVectorShiftByScalarCheap(Type *Ty) const

Definition TargetTransformInfoImpl.h:1118

virtual bool isLegalNTStore(Type *DataType, Align Alignment) const

Definition TargetTransformInfoImpl.h:323

virtual APInt getFeatureMask(const Function &F) const

Definition TargetTransformInfoImpl.h:1129

virtual InstructionCost getMemIntrinsicInstrCost(const MemIntrinsicCostAttributes &MICA, TTI::TargetCostKind CostKind) const

Definition TargetTransformInfoImpl.h:905

virtual std::optional< unsigned > getMinPageSize() const

Definition TargetTransformInfoImpl.h:645

virtual unsigned getRegUsageForType(Type *Ty) const

Definition TargetTransformInfoImpl.h:424

virtual bool isLegalAddressingMode(Type *Ty, GlobalValue *BaseGV, int64_t BaseOffset, bool HasBaseReg, int64_t Scale, unsigned AddrSpace, Instruction *I=nullptr, int64_t ScalableOffset=0) const

Definition TargetTransformInfoImpl.h:272

virtual bool isElementTypeLegalForScalableVector(Type *Ty) const

Definition TargetTransformInfoImpl.h:1063

virtual bool isLoweredToCall(const Function *F) const

Definition TargetTransformInfoImpl.h:174

virtual bool isLegalMaskedScatter(Type *DataType, Align Alignment) const

Definition TargetTransformInfoImpl.h:342

virtual bool isTruncateFree(Type *Ty1, Type *Ty2) const

Definition TargetTransformInfoImpl.h:416

virtual InstructionCost getArithmeticInstrCost(unsigned Opcode, Type *Ty, TTI::TargetCostKind CostKind, TTI::OperandValueInfo Opd1Info, TTI::OperandValueInfo Opd2Info, ArrayRef< const Value * > Args, const Instruction *CxtI=nullptr) const

Definition TargetTransformInfoImpl.h:668

virtual bool isIndexedStoreLegal(TTI::MemIndexedMode Mode, Type *Ty) const

Definition TargetTransformInfoImpl.h:1034

virtual InstructionCost getGEPCost(Type *PointeeType, const Value *Ptr, ArrayRef< const Value * > Operands, Type *AccessType, TTI::TargetCostKind CostKind) const

Definition TargetTransformInfoImpl.h:54

virtual BranchProbability getPredictableBranchThreshold() const

Definition TargetTransformInfoImpl.h:124

virtual bool isValidAddrSpaceCast(unsigned FromAS, unsigned ToAS) const

Definition TargetTransformInfoImpl.h:138

virtual InstructionCost getReplicationShuffleCost(Type *EltTy, int ReplicationFactor, int VF, const APInt &DemandedDstElts, TTI::TargetCostKind CostKind) const

Definition TargetTransformInfoImpl.h:823

virtual bool enableScalableVectorization() const

Definition TargetTransformInfoImpl.h:1109

virtual bool isLegalToVectorizeStore(StoreInst *SI) const

Definition TargetTransformInfoImpl.h:1044

virtual bool areInlineCompatible(const Function *Caller, const Function *Callee) const

Definition TargetTransformInfoImpl.h:1008

virtual bool isTargetIntrinsicWithStructReturnOverloadAtField(Intrinsic::ID ID, int RetIdx) const

Definition TargetTransformInfoImpl.h:453

virtual bool hasConditionalLoadStoreForType(Type *Ty, bool IsStore) const

Definition TargetTransformInfoImpl.h:566

virtual bool preferInLoopReduction(RecurKind Kind, Type *Ty) const

Definition TargetTransformInfoImpl.h:1083

virtual bool isMultiversionedFunction(const Function &F) const

Definition TargetTransformInfoImpl.h:1133

virtual InstructionCost getCFInstrCost(unsigned Opcode, TTI::TargetCostKind CostKind, const Instruction *I=nullptr) const

Definition TargetTransformInfoImpl.h:774

virtual bool isNoopAddrSpaceCast(unsigned, unsigned) const

Definition TargetTransformInfoImpl.h:153

virtual bool isVScaleKnownToBeAPowerOfTwo() const

Definition TargetTransformInfoImpl.h:597

virtual bool isExpensiveToSpeculativelyExecute(const Instruction *I) const

Definition TargetTransformInfoImpl.h:526

virtual bool isLSRCostLess(const TTI::LSRCost &C1, const TTI::LSRCost &C2) const

Definition TargetTransformInfoImpl.h:282

virtual bool isLegalMaskedVectorHistogram(Type *AddrType, Type *DataType) const

Definition TargetTransformInfoImpl.h:385

virtual bool isLegalMaskedGather(Type *DataType, Align Alignment) const

Definition TargetTransformInfoImpl.h:346

virtual unsigned getEstimatedNumberOfCaseClusters(const SwitchInst &SI, unsigned &JTSize, ProfileSummaryInfo *PSI, BlockFrequencyInfo *BFI) const

Definition TargetTransformInfoImpl.h:75

virtual bool hasActiveVectorLength() const

Definition TargetTransformInfoImpl.h:1111

virtual bool isLegalAddImmediate(int64_t Imm) const

Definition TargetTransformInfoImpl.h:266

virtual InstructionCost getInsertExtractValueCost(unsigned Opcode, TTI::TargetCostKind CostKind) const

Definition TargetTransformInfoImpl.h:830

virtual InstructionCost getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src, TTI::CastContextHint CCH, TTI::TargetCostKind CostKind, const Instruction *I) const

Definition TargetTransformInfoImpl.h:723

virtual bool isLegalNTLoad(Type *DataType, Align Alignment) const

Definition TargetTransformInfoImpl.h:330

virtual InstructionCost getBranchMispredictPenalty() const

Definition TargetTransformInfoImpl.h:128

virtual bool isTargetIntrinsicWithOverloadTypeAtArg(Intrinsic::ID ID, int OpdIdx) const

Definition TargetTransformInfoImpl.h:447

virtual InstructionCost getIntImmCostIntrin(Intrinsic::ID IID, unsigned Idx, const APInt &Imm, Type *Ty, TTI::TargetCostKind CostKind) const

Definition TargetTransformInfoImpl.h:555

TargetTransformInfo TTI

Definition TargetTransformInfoImpl.h:37

virtual InstructionCost getIntImmCodeSizeCost(unsigned Opcode, unsigned Idx, const APInt &Imm, Type *Ty) const

Definition TargetTransformInfoImpl.h:536

bool isConstantStridedAccessLessThan(ScalarEvolution *SE, const SCEV *Ptr, int64_t MergeDistance) const

Definition TargetTransformInfoImpl.h:1219

virtual bool enableOrderedReductions() const

Definition TargetTransformInfoImpl.h:390

virtual Value * getOrCreateResultFromMemIntrinsic(IntrinsicInst *Inst, Type *ExpectedType, bool CanCreate=true) const

Definition TargetTransformInfoImpl.h:983

virtual bool enableMaskedInterleavedAccessVectorization() const

Definition TargetTransformInfoImpl.h:505

virtual Type * getMemcpyLoopLoweringType(LLVMContext &Context, Value *Length, unsigned SrcAddrSpace, unsigned DestAddrSpace, Align SrcAlign, Align DestAlign, std::optional< uint32_t > AtomicElementSize) const

Definition TargetTransformInfoImpl.h:989

virtual unsigned getInliningThresholdMultiplier() const

Definition TargetTransformInfoImpl.h:90

TargetTransformInfoImplBase(const DataLayout &DL)

Definition TargetTransformInfoImpl.h:41

virtual InstructionCost getIntrinsicInstrCost(const IntrinsicCostAttributes &ICA, TTI::TargetCostKind CostKind) const

Definition TargetTransformInfoImpl.h:856

virtual bool isAlwaysUniform(const Value *V) const

Definition TargetTransformInfoImpl.h:136

virtual InstructionCost getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy, CmpInst::Predicate VecPred, TTI::TargetCostKind CostKind, TTI::OperandValueInfo Op1Info, TTI::OperandValueInfo Op2Info, const Instruction *I) const

Definition TargetTransformInfoImpl.h:784

virtual bool shouldExpandReduction(const IntrinsicInst *II) const

Definition TargetTransformInfoImpl.h:1094

virtual bool isLegalToVectorizeStoreChain(unsigned ChainSizeInBytes, Align Alignment, unsigned AddrSpace) const

Definition TargetTransformInfoImpl.h:1052

virtual unsigned getGISelRematGlobalCost() const

Definition TargetTransformInfoImpl.h:1103

virtual InstructionCost getInterleavedMemoryOpCost(unsigned Opcode, Type *VecTy, unsigned Factor, ArrayRef< unsigned > Indices, Align Alignment, unsigned AddressSpace, TTI::TargetCostKind CostKind, bool UseMaskForCond, bool UseMaskForGaps) const

Definition TargetTransformInfoImpl.h:848

virtual bool isTypeLegal(Type *Ty) const

Definition TargetTransformInfoImpl.h:422

virtual bool enableSelectOptimize() const

Definition TargetTransformInfoImpl.h:488

virtual unsigned getAssumedAddrSpace(const Value *V) const

Definition TargetTransformInfoImpl.h:159

virtual bool allowsMisalignedMemoryAccesses(LLVMContext &Context, unsigned BitWidth, unsigned AddressSpace, Align Alignment, unsigned *Fast) const

Definition TargetTransformInfoImpl.h:511

virtual bool enableWritePrefetching() const

Definition TargetTransformInfoImpl.h:655

virtual unsigned getStoreVectorFactor(unsigned VF, unsigned StoreSize, unsigned ChainSizeInBytes, VectorType *VecTy) const

Definition TargetTransformInfoImpl.h:1073

virtual InstructionCost getExtendedReductionCost(unsigned Opcode, bool IsUnsigned, Type *ResTy, VectorType *Ty, std::optional< FastMathFlags > FMF, TTI::TargetCostKind CostKind) const

Definition TargetTransformInfoImpl.h:951

virtual unsigned getInliningCostBenefitAnalysisSavingsMultiplier() const

Definition TargetTransformInfoImpl.h:91

virtual bool areTypesABICompatible(const Function *Caller, const Function *Callee, ArrayRef< Type * > Types) const

Definition TargetTransformInfoImpl.h:1021

virtual InstructionCost getVectorInstrCost(unsigned Opcode, Type *Val, TTI::TargetCostKind CostKind, unsigned Index, Value *Scalar, ArrayRef< std::tuple< Value *, User *, int > > ScalarUserAndIdx) const

Definition TargetTransformInfoImpl.h:802

virtual unsigned getMaxNumArgs() const

Definition TargetTransformInfoImpl.h:1137

virtual unsigned getNumBytesToPadGlobalArray(unsigned Size, Type *ArrayType) const

Definition TargetTransformInfoImpl.h:1139

virtual bool preferToKeepConstantsAttached(const Instruction &Inst, const Function &Fn) const

Definition TargetTransformInfoImpl.h:560

virtual InstructionCost getShuffleCost(TTI::ShuffleKind Kind, VectorType *DstTy, VectorType *SrcTy, ArrayRef< int > Mask, TTI::TargetCostKind CostKind, int Index, VectorType *SubTp, ArrayRef< const Value * > Args={}, const Instruction *CxtI=nullptr) const

Definition TargetTransformInfoImpl.h:716

virtual bool isFCmpOrdCheaperThanFCmpZero(Type *Ty) const

Definition TargetTransformInfoImpl.h:530

virtual bool supportsTailCallFor(const CallBase *CB) const

Definition TargetTransformInfoImpl.h:475

virtual std::optional< unsigned > getMaxVScale() const

Definition TargetTransformInfoImpl.h:593

virtual bool shouldBuildRelLookupTables() const

Definition TargetTransformInfoImpl.h:432

virtual bool shouldConsiderAddressTypePromotion(const Instruction &I, bool &AllowPromotionWithoutCommonHeader) const

Definition TargetTransformInfoImpl.h:615

virtual InstructionCost getScalarizationOverhead(VectorType *Ty, const APInt &DemandedElts, bool Insert, bool Extract, TTI::TargetCostKind CostKind, bool ForPoisonSrc=true, ArrayRef< Value * > VL={}) const

Definition TargetTransformInfoImpl.h:458

virtual unsigned getFlatAddressSpace() const

Definition TargetTransformInfoImpl.h:146

virtual bool isTargetIntrinsicWithScalarOpAtArg(Intrinsic::ID ID, unsigned ScalarOpdIdx) const

Definition TargetTransformInfoImpl.h:442

virtual bool shouldConsiderVectorizationRegPressure() const

Definition TargetTransformInfoImpl.h:1092

const DataLayout & DL

Definition TargetTransformInfoImpl.h:39

virtual InstructionCost getMemcpyCost(const Instruction *I) const

Definition TargetTransformInfoImpl.h:112

virtual unsigned getInliningCostBenefitAnalysisProfitableMultiplier() const

Definition TargetTransformInfoImpl.h:94

virtual bool isSourceOfDivergence(const Value *V) const

Definition TargetTransformInfoImpl.h:134

virtual bool useFastCCForInternalCall(Function &F) const

Definition TargetTransformInfoImpl.h:436

virtual bool isNumRegsMajorCostOfLSR() const

Definition TargetTransformInfoImpl.h:290

virtual InstructionCost getOperandsScalarizationOverhead(ArrayRef< Type * > Tys, TTI::TargetCostKind CostKind) const

Definition TargetTransformInfoImpl.h:466

virtual TailFoldingStyle getPreferredTailFoldingStyle(bool IVUpdateMayOverflow=true) const

Definition TargetTransformInfoImpl.h:235

virtual void getUnrollingPreferences(Loop *, ScalarEvolution &, TTI::UnrollingPreferences &, OptimizationRemarkEmitter *) const

Definition TargetTransformInfoImpl.h:259

TargetTransformInfoImplBase(const TargetTransformInfoImplBase &Arg)=default

virtual bool isProfitableToSinkOperands(Instruction *I, SmallVectorImpl< Use * > &Ops) const

Definition TargetTransformInfoImpl.h:1113

virtual bool supportsEfficientVectorElementLoadStore() const

Definition TargetTransformInfoImpl.h:471

virtual unsigned getMinPrefetchStride(unsigned NumMemAccesses, unsigned NumStridedMemAccesses, unsigned NumPrefetches, bool HasCall) const

Definition TargetTransformInfoImpl.h:648

virtual unsigned getMinTripCountTailFoldingThreshold() const

Definition TargetTransformInfoImpl.h:1105

virtual TypeSize getRegisterBitWidth(TargetTransformInfo::RegisterKind K) const

Definition TargetTransformInfoImpl.h:587

virtual void collectKernelLaunchBounds(const Function &F, SmallVectorImpl< std::pair< StringRef, int64_t > > &LB) const

Definition TargetTransformInfoImpl.h:1144

virtual bool preferEpilogueVectorization() const

Definition TargetTransformInfoImpl.h:1090

bool supportsTailCallFor(const CallBase *CB) const override

Definition TargetTransformInfoImpl.h:1679

TargetTransformInfoImplCRTPBase(const DataLayout &DL)

Definition TargetTransformInfoImpl.h:1240

bool isExpensiveToSpeculativelyExecute(const Instruction *I) const override

Definition TargetTransformInfoImpl.h:1671

InstructionCost getInstructionCost(const User *U, ArrayRef< const Value * > Operands, TTI::TargetCostKind CostKind) const override

Definition TargetTransformInfoImpl.h:1358

InstructionCost getPointersChainCost(ArrayRef< const Value * > Ptrs, const Value *Base, const TTI::PointersChainInfo &Info, Type *AccessTy, TTI::TargetCostKind CostKind) const override

Definition TargetTransformInfoImpl.h:1322

InstructionCost getGEPCost(Type *PointeeType, const Value *Ptr, ArrayRef< const Value * > Operands, Type *AccessType, TTI::TargetCostKind CostKind) const override

Definition TargetTransformInfoImpl.h:1243

This pass provides access to the codegen interfaces that are needed for IR-level transformations.

static LLVM_ABI CastContextHint getCastContextHint(const Instruction *I)

Calculates a CastContextHint from I.

MaskKind

Some targets only support masked load/store with a constant mask.

static LLVM_ABI OperandValueInfo getOperandInfo(const Value *V)

Collect properties of V used in cost analysis, e.g. OP_PowerOf2.

TargetCostKind

The kind of cost model.

@ TCK_RecipThroughput

Reciprocal throughput.

@ TCK_CodeSize

Instruction code size.

@ TCK_SizeAndLatency

The weighted sum of size and latency.

@ TCK_Latency

The latency of instruction.

PopcntSupportKind

Flags indicating the kind of support for population count.

PartialReductionExtendKind

@ TCC_Expensive

The cost of a 'div' instruction on x86.

@ TCC_Free

Expected to fold away in lowering.

@ TCC_Basic

The cost of a typical 'add' instruction.

MemIndexedMode

The type of load/store indexing.

AddressingModeKind

Which addressing mode Loop Strength Reduction will try to generate.

@ AMK_None

Don't prefer any addressing mode.

ShuffleKind

The various kinds of shuffle patterns for vector queries.

@ SK_InsertSubvector

InsertSubvector. Index indicates start offset.

@ SK_Select

Selects elements from the corresponding lane of either source operand.

@ SK_PermuteSingleSrc

Shuffle elements of single source vector with any shuffle mask.

@ SK_Transpose

Transpose two vectors.

@ SK_Splice

Concatenates elements from the first input vector with elements of the second input vector.

@ SK_Broadcast

Broadcast element 0 to all other elements.

@ SK_PermuteTwoSrc

Merge elements from two source vectors into one with any shuffle mask.

@ SK_Reverse

Reverse the order of the vector.

@ SK_ExtractSubvector

ExtractSubvector Index indicates start offset.

CastContextHint

Represents a hint about the context in which a cast is used.

CacheLevel

The possible cache levels.

This class represents a truncation of integer types.

static constexpr TypeSize getFixed(ScalarTy ExactSize)

The instances of the Type class are immutable: once they are created, they are never changed.

bool isVectorTy() const

True if this is an instance of VectorType.

LLVM_ABI bool isScalableTy(SmallPtrSetImpl< const Type * > &Visited) const

Return true if this is a type whose size is a known multiple of vscale.

LLVM_ABI unsigned getPointerAddressSpace() const

Get the address space of this pointer or pointer vector type.

static LLVM_ABI IntegerType * getInt8Ty(LLVMContext &C)

LLVM_ABI unsigned getScalarSizeInBits() const LLVM_READONLY

If this is a vector type, return the getPrimitiveSizeInBits value for the element type.

static LLVM_ABI IntegerType * getIntNTy(LLVMContext &C, unsigned N)

This is the common base class for vector predication intrinsics.

LLVM Value Representation.

Type * getType() const

All values are typed, get the type of this value.

LLVM_ABI const Value * stripPointerCasts() const

Strip off pointer casts, all-zero GEPs and address space casts.

Base class of all SIMD vector types.

constexpr ScalarTy getFixedValue() const

constexpr bool isScalable() const

Returns whether the quantity is scaled by a runtime quantity (vscale).

#define llvm_unreachable(msg)

Marks that the current location is not supposed to be reachable.

unsigned ID

LLVM IR allows to use arbitrary numbers as calling convention identifiers.

@ Fast

Attempts to make calls as fast as possible (e.g.

@ C

The default llvm calling convention, compatible with C.

This namespace contains an enum with a value for every intrinsic/builtin function known by LLVM.

class_match< Constant > m_Constant()

Match an arbitrary Constant and ignore it.

bool match(Val *V, const Pattern &P)

ThreeOps_match< Cond, LHS, RHS, Instruction::Select > m_Select(const Cond &C, const LHS &L, const RHS &R)

Matches SelectInst.

auto m_LogicalOr()

Matches L || R where L and R are arbitrary values.

class_match< Value > m_Value()

Match an arbitrary value and ignore it.

auto m_LogicalAnd()

Matches L && R where L and R are arbitrary values.

match_combine_or< LTy, RTy > m_CombineOr(const LTy &L, const RTy &R)

Combine two pattern matchers matching L || R.

This is an optimization pass for GlobalISel generic memory operations.

bool all_of(R &&range, UnaryPredicate P)

Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.

auto enumerate(FirstRange &&First, RestRanges &&...Rest)

Given two or more input ranges, returns a new range whose values are tuples (A, B,...

decltype(auto) dyn_cast(const From &Val)

dyn_cast - Return the argument parameter cast to the specified type.

FunctionAddr VTableAddr uintptr_t uintptr_t DataSize

LLVM_ABI Value * getSplatValue(const Value *V)

Get splat value if the input is a splat vector or return nullptr.

bool any_of(R &&range, UnaryPredicate P)

Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.

constexpr bool isPowerOf2_32(uint32_t Value)

Return true if the argument is a power of two > 0.

bool isa(const From &Val)

isa - Return true if the parameter to the template is an instance of one of the template type argu...

constexpr int PoisonMaskElem

RecurKind

These are the kinds of recurrences that we support.

constexpr unsigned BitWidth

decltype(auto) cast(const From &Val)

cast - Return the argument parameter cast to the specified type.

gep_type_iterator gep_type_begin(const User *GEP)

@ DataWithoutLaneMask

Same as Data, but avoids using the get.active.lane.mask intrinsic to calculate the mask and instead i...

This struct is a compact representation of a valid (non-zero power of two) alignment.

Attributes of a target dependent hardware loop.

Information about a load/store intrinsic defined by the target.

Returns options for expansion of memcmp. IsZeroCmp is.

Describe known properties for a set of pointers.

Parameters that control the generic loop unrolling transformation.