BasicBlockUtils.cpp Source File (original) (raw)

45#include

46#include

47#include

48#include

49#include

51using namespace llvm;

53#define DEBUG_TYPE "basicblock-utils"

57 cl::desc("Set the maximum path length when checking whether a basic block "

58 "is followed by a block that either has a terminating "

59 "deoptimizing call or is terminated with an unreachable"));

64static void

67 bool KeepOneInputPHIs) {

72 Succ->removePredecessor(BB, KeepOneInputPHIs);

73 if (Updates && UniqueSuccessors.insert(Succ).second)

75 }

78 while (!BB->empty()) {

85 if (.use_empty())

88 }

91 "The successor list of BB isn't empty before "

92 "applying corresponding DTU updates.");

93}

99 return true;

100 }

101 return false;

102}

103

106 bool KeepOneInputPHIs) {

108 for (auto *BB : BBs) {

109 auto NonFirstPhiIt = BB->getFirstNonPHIIt();

110 if (NonFirstPhiIt != BB->end()) {

112

113

114

115

116

117

119 UniqueEHRetBlocksToDelete.clear();

120

123

124

125

129 UniqueEHRetBlocksToDelete.insert(ReturnInstrBB);

130 }

131 }

132

133 for (BasicBlock *EHRetBB : UniqueEHRetBlocksToDelete)

135 }

136 }

137

138 UniqueEHRetBlocksToDelete.clear();

139

140

142 }

143}

144

146 bool KeepOneInputPHIs) {

148}

149

151 bool KeepOneInputPHIs) {

152#ifndef NDEBUG

153

155 assert(Dead.size() == BBs.size() && "Duplicating blocks?");

156 for (auto *BB : Dead)

158 assert(Dead.count(Pred) && "All predecessors must be dead!");

159#endif

160

162 detachDeadBlocks(BBs, DTU ? &Updates : nullptr, KeepOneInputPHIs);

163

164 if (DTU)

166

168 if (DTU)

170 else

171 BB->eraseFromParent();

172}

173

175 bool KeepOneInputPHIs) {

177

178

180 (void)BB;

181

182

183 std::vector<BasicBlock*> DeadBlocks;

185 if (!Reachable.count(&BB))

186 DeadBlocks.push_back(&BB);

187

188

190

191 return !DeadBlocks.empty();

192}

193

197 return false;

198

200 if (PN->getIncomingValue(0) != PN)

201 PN->replaceAllUsesWith(PN->getIncomingValue(0));

202 else

204

205 if (MemDep)

207

208 PN->eraseFromParent();

209 }

210 return true;

211}

212

215

216

218

220 for (const auto &PHI : PHIs)

223

225}

226

230 bool PredecessorWithTwoSuccessors,

233 return false;

234

235

237 if (!PredBB) return false;

238

239

240 if (PredBB == BB) return false;

241

242

245 return false;

246

247

248 if (!PredecessorWithTwoSuccessors && PredBB->getUniqueSuccessor() != BB)

249 return false;

250

251

252

255 unsigned FallThruPath;

256 if (PredecessorWithTwoSuccessors) {

258 return false;

261 return false;

263 FallThruPath = PredBB_BI->getSuccessor(0) == BB ? 0 : 1;

264 }

265

266

269 return false;

270

271

272

273

276 return false;

277

279 << PredBB->getName() << "\n");

280

281

286 cast(PN.getIncomingValue(0))->getParent() != BB)

287 IncomingValues.push_back(PN.getIncomingValue(0));

289 }

290

291 if (DT) {

292 assert(!DTU && "cannot use both DT and DTU for updates");

295 if (PredNode) {

296 assert(BBNode && "PredNode unreachable but BBNode reachable?");

298 C->setIDom(PredNode);

299 }

300 }

301

302

303 std::vectorDominatorTree::UpdateType Updates;

304 if (DTU) {

305 assert(!DT && "cannot use both DT and DTU for updates");

306

310 Updates.reserve(Updates.size() + 2 * succ_size(BB) + 1);

311

312

313

314

315

316

318

319 if (!SuccsOfPredBB.contains(SuccOfBB))

320 if (SeenSuccs.insert(SuccOfBB).second)

322 SeenSuccs.clear();

324 if (SeenSuccs.insert(SuccOfBB).second)

327 }

328

331

332

333 if (Start == STI)

334 Start = PTI;

335

336

338

339 if (MSSAU)

341

342

343

345

346 if (PredecessorWithTwoSuccessors) {

347

349

350

351 PredBB_BI->setSuccessor(FallThruPath, NewSucc);

352 } else {

353

355

356

358

359

360 if (MSSAU)

364 }

365

367

368

371

372 if (LI)

374

375 if (MemDep)

377

378 if (DTU)

380

381 if (DT) {

383 "successors should have been transferred to PredBB");

385 }

386

387

389

390 return true;

391}

392

396 assert(!MergeBlocks.empty() && "MergeBlocks should not be empty");

397

398 bool BlocksHaveBeenMerged = false;

399 while (!MergeBlocks.empty()) {

402 if (Dest && (!L || L->contains(Dest))) {

404 (void)Fold;

407 "Expecting BB to be unique predecessor of the Dest block");

408 MergeBlocks.erase(Dest);

409 BlocksHaveBeenMerged = true;

410 } else

411 MergeBlocks.erase(BB);

412 } else

413 MergeBlocks.erase(BB);

414 }

415 return BlocksHaveBeenMerged;

416}

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

440 for (auto &I : reverse(*BB)) {

444 DVR.getDebugLoc()->getInlinedAt());

445 auto R = VariableSet.insert(Key);

446

447

448

449 if (R.second)

450 continue;

451

452 if (DVR.isDbgAssign()) {

453

455 continue;

456

457 }

458

460 }

461

462

463

464 VariableSet.clear();

465 }

466

467 for (auto &DVR : ToBeRemoved)

468 DVR->eraseFromParent();

469

470 return !ToBeRemoved.empty();

471}

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

493 bool RemovedAny = false;

495 std::pair<SmallVector<Value *, 4>, DIExpression *>, 4>

496 VariableMap;

497 for (auto &I : *BB) {

501 continue;

503 DVR.getDebugLoc()->getInlinedAt());

505

506

507 bool IsDbgValueKind =

509

510

511

513 if (Inserted || VMI->second.first != Values ||

514 VMI->second.second != DVR.getExpression()) {

515 if (IsDbgValueKind)

516 VMI->second = {Values, DVR.getExpression()};

517 else

518 VMI->second = {Values, nullptr};

519 continue;

520 }

521

522 if (!IsDbgValueKind)

523 continue;

524

525 DVR.eraseFromParent();

526 RemovedAny = true;

527 }

528 }

529

530 return RemovedAny;

531}

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

554 bool RemovedAny = false;

556

557

558

559 for (auto &I : *BB) {

562 if (!DVR.isDbgValue() && !DVR.isDbgAssign())

563 continue;

564 bool IsDbgValueKind =

566

568 if (!SeenDefForAggregate.contains(Aggregate)) {

569 bool IsKill = DVR.isKillLocation() && IsDbgValueKind;

570 if (!IsKill) {

571 SeenDefForAggregate.insert(Aggregate);

572 } else if (DVR.isDbgAssign()) {

573 DVR.eraseFromParent();

574 RemovedAny = true;

575 }

576 }

577 }

578 }

579

580 return RemovedAny;

581}

582

584 bool MadeChanges = false;

585

586

587

588

589

590

591

592

593

594

595

601

602 if (MadeChanges)

603 LLVM_DEBUG(dbgs() << "Removed redundant dbg instrs from: "

604 << BB->getName() << "\n");

605 return MadeChanges;

606}

607

610

611 I.replaceAllUsesWith(V);

612

613

614 if (I.hasName() && !V->hasName())

615 V->takeName(&I);

616

617

618 BI = BI->eraseFromParent();

619}

620

623 assert(I->getParent() == nullptr &&

624 "ReplaceInstWithInst: Instruction already inserted into basic block!");

625

626

627

628 if (->getDebugLoc())

629 I->setDebugLoc(BI->getDebugLoc());

630

631

633

634

636

637

638 BI = New;

639}

640

642

644 unsigned Depth = 0;

649 return true;

651 }

652 return false;

653}

654

659

662 const Twine &BBName) {

664

666

669

671

673 }

674

675

676

678

679

680 assert(SP == BB && "CFG broken");

681 (void)SP;

682 return SplitBlock(Succ, &Succ->front(), DT, LI, MSSAU, BBName,

683 true);

684 }

685

686

687

689 "Should have a single succ!");

691}

692

693

694

695

696

697

698

699

700

701template <typename TI, typename T>

704 static_assert(std::is_same_v<TI, CycleInfo> || std::is_same_v<TI, LoopInfo>,

705 "type must be CycleInfo or LoopInfo");

706 if (!LCI)

707 return false;

708

709 T *LC;

710 if constexpr (std::is_same_v<TI, CycleInfo>)

711 LC = LCI->getSmallestCommonCycle(CallBrBlock, Succ);

712 else

713 LC = LCI->getSmallestCommonLoop(CallBrBlock, Succ);

714 if (!LC)

715 return false;

716

717 if constexpr (std::is_same_v<TI, CycleInfo>)

718 LCI->addBlockToCycle(CallBrTarget, LC);

719 else

720 LC->addBasicBlockToLoop(CallBrTarget, *LCI);

721

722 return true;

723}

724

728 bool *UpdatedLI) {

730 assert(CallBr && "expected callbr terminator");

731 assert(SuccIdx < CallBr->getNumSuccessors() &&

732 Succ == CallBr->getSuccessor(SuccIdx) && "invalid successor index");

733

734

735

736

737

738

739

742 CallBrBlock->getName() + ".target." + Succ->getName(),

744

746

748

750

751 bool Updated =

753 if (UpdatedLI)

754 *UpdatedLI = Updated;

756 if (DTU) {

761 }

762

763 return CallBrTarget;

764}

765

768 II->setUnwindDest(Succ);

770 CS->setUnwindDest(Succ);

772 CR->setUnwindDest(Succ);

773 else

775}

776

779 int BBIdx = 0;

781

782

783 if (Until == &PN)

784 break;

785

786

787

788

789

790

791 if (PN.getIncomingBlock(BBIdx) != OldPred)

792 BBIdx = PN.getBasicBlockIndex(OldPred);

793

794 assert(BBIdx != -1 && "Invalid PHI Index!");

795 PN.setIncomingBlock(BBIdx, NewPred);

796 }

797}

798

801 PHINode *LandingPadReplacement,

803 const Twine &BBName) {

804

806 if (!LandingPadReplacement && !PadInst->isEHPad())

808

811

812

813

814 if (Options.PreserveLoopSimplify && LI) {

815 if (Loop *BBLoop = LI->getLoopFor(BB)) {

816

817

818

819

820

821

822

823

824

825

827 if (P == BB)

828 continue;

829 if (LI->getLoopFor(P) != BBLoop) {

830

831

832 LoopPreds.clear();

833 break;

834 }

836 }

837

838

841 })) {

842 return nullptr;

843 }

844 }

845 }

846

847 auto *NewBB =

850 updatePhiNodes(Succ, BB, NewBB, LandingPadReplacement);

851

852 if (LandingPadReplacement) {

853 auto *NewLP = OriginalPad->clone();

855 NewLP->insertBefore(Terminator->getIterator());

856 LandingPadReplacement->addIncoming(NewLP, NewBB);

857 } else {

858 Value *ParentPad = nullptr;

860 ParentPad = FuncletPad->getParentPad();

862 ParentPad = CatchSwitch->getParentPad();

864 ParentPad = CleanupPad->getParentPad();

866 ParentPad = LandingPad->getParent();

867 else

868 llvm_unreachable("handling for other EHPads not implemented yet");

869

872 }

873

875 auto *MSSAU = Options.MSSAU;

876 if (!DT && !LI)

877 return NewBB;

878

879 if (DT) {

880 DomTreeUpdater DTU(DT, DomTreeUpdater::UpdateStrategy::Lazy);

882

886

889

890 if (MSSAU) {

891 MSSAU->applyUpdates(Updates, *DT);

893 MSSAU->getMemorySSA()->verifyMemorySSA();

894 }

895 }

896

897 if (LI) {

898 if (Loop *BBLoop = LI->getLoopFor(BB)) {

899

900

901 if (Loop *SuccLoop = LI->getLoopFor(Succ)) {

902 if (BBLoop == SuccLoop) {

903

904 SuccLoop->addBasicBlockToLoop(NewBB, *LI);

905 } else if (BBLoop->contains(SuccLoop)) {

906

907 BBLoop->addBasicBlockToLoop(NewBB, *LI);

908 } else if (SuccLoop->contains(BBLoop)) {

909

910 SuccLoop->addBasicBlockToLoop(NewBB, *LI);

911 } else {

912

913

914

915

916 assert(SuccLoop->getHeader() == Succ &&

917 "Should not create irreducible loops!");

918 if (Loop *P = SuccLoop->getParentLoop())

919 P->addBasicBlockToLoop(NewBB, *LI);

920 }

921 }

922

923

924

925 if (!BBLoop->contains(Succ)) {

926 assert(!BBLoop->contains(NewBB) &&

927 "Split point for loop exit is contained in loop!");

928

929

930 if (Options.PreserveLCSSA) {

932 }

933

934 if (!LoopPreds.empty()) {

936 Succ, LoopPreds, "split", DT, LI, MSSAU, Options.PreserveLCSSA);

937 if (Options.PreserveLCSSA)

939 }

940 }

941 }

942 }

943

944 return NewBB;

945}

946

949

952 "SplitBB has non-PHI nodes!");

953

954

956 int Idx = PN.getBasicBlockIndex(SplitBB);

957 assert(Idx >= 0 && "Invalid Block Index");

958 Value *V = PN.getIncomingValue(Idx);

959

960

961

963 if (VP->getParent() == SplitBB)

964 continue;

965

966

974

975

976 PN.setIncomingValue(Idx, NewPN);

977 }

978}

979

980unsigned

983 unsigned NumBroken = 0;

987 for (unsigned i = 0, e = TI->getNumSuccessors(); i != e; ++i)

989 ++NumBroken;

990 }

991 return NumBroken;

992}

993

997 const Twine &BBName, bool Before) {

998 if (Before) {

999 DomTreeUpdater LocalDTU(DT, DomTreeUpdater::UpdateStrategy::Lazy);

1001 DTU ? DTU : (DT ? &LocalDTU : nullptr), LI, MSSAU,

1002 BBName);

1003 }

1005 while (isa(SplitIt) || SplitIt->isEHPad()) {

1006 ++SplitIt;

1007 assert(SplitIt != SplitPt->getParent()->end());

1008 }

1009 std::string Name = BBName.str();

1011 SplitIt, Name.empty() ? Old->getName() + ".split" : Name);

1012

1013

1014

1015 if (LI)

1017 L->addBasicBlockToLoop(New, *LI);

1018

1019 if (DTU) {

1021

1026 if (UniqueSuccessorsOfOld.insert(SuccessorOfOld).second) {

1029 }

1030

1032 } else if (DT)

1033

1035 std::vector<DomTreeNode *> Children(OldNode->begin(), OldNode->end());

1036

1040 }

1041

1042

1043

1044 if (MSSAU)

1046

1047 return New;

1048}

1049

1053 bool Before) {

1054 return SplitBlockImpl(Old, SplitPt, nullptr, DT, LI, MSSAU, BBName,

1055 Before);

1056}

1060 bool Before) {

1061 return SplitBlockImpl(Old, SplitPt, DTU, nullptr, LI, MSSAU, BBName,

1062 Before);

1063}

1064

1068 const Twine &BBName) {

1069

1071 while (isa(SplitIt) || SplitIt->isEHPad())

1072 ++SplitIt;

1073 std::string Name = BBName.str();

1075 SplitIt, Name.empty() ? Old->getName() + ".split" : Name,

1076 true);

1077

1078

1079

1080 if (LI)

1082 L->addBasicBlockToLoop(New, *LI);

1083

1084 if (DTU) {

1086

1087

1092 if (UniquePredecessorsOfOld.insert(PredecessorOfOld).second) {

1095 }

1096

1098

1099

1100

1101 if (MSSAU) {

1105 }

1106 }

1107 return New;

1108}

1109

1110

1111

1116 bool PreserveLCSSA, bool &HasLoopExit) {

1117

1118 if (DTU) {

1119

1120

1122

1123

1124

1126 } else {

1127

1132 for (auto *Pred : Preds)

1133 if (UniquePreds.insert(Pred).second) {

1136 }

1138 }

1139 } else if (DT) {

1143 } else {

1144

1146 }

1147 }

1148

1149

1150 if (MSSAU)

1152

1153

1154 if (!LI)

1155 return;

1156

1159 assert(DT && "DT should be available to update LoopInfo!");

1161

1162

1163

1164 bool IsLoopEntry = !!L;

1165 bool SplitMakesNewLoopHeader = false;

1167

1168

1169

1170

1172 continue;

1173

1174

1175 if (PreserveLCSSA)

1177 if (!PL->contains(OldBB))

1178 HasLoopExit = true;

1179

1180

1181

1182 if (!L)

1183 continue;

1184 if (L->contains(Pred))

1185 IsLoopEntry = false;

1186 else

1187 SplitMakesNewLoopHeader = true;

1188 }

1189

1190

1191 if (!L)

1192 return;

1193

1194 if (IsLoopEntry) {

1195

1196

1197

1198

1199 Loop *InnermostPredLoop = nullptr;

1202

1203

1204 while (PredLoop && !PredLoop->contains(OldBB))

1205 PredLoop = PredLoop->getParentLoop();

1206

1207

1208 if (PredLoop && PredLoop->contains(OldBB) &&

1209 (!InnermostPredLoop ||

1210 InnermostPredLoop->getLoopDepth() < PredLoop->getLoopDepth()))

1211 InnermostPredLoop = PredLoop;

1212 }

1213 }

1214

1215 if (InnermostPredLoop)

1217 } else {

1218 L->addBasicBlockToLoop(NewBB, *LI);

1219 if (SplitMakesNewLoopHeader)

1220 L->moveToHeader(NewBB);

1221 }

1222}

1223

1224

1225

1228 bool HasLoopExit) {

1229

1233

1234

1235

1236 Value *InVal = nullptr;

1237 if (!HasLoopExit) {

1241 continue;

1242 if (!InVal)

1245 InVal = nullptr;

1246 break;

1247 }

1248 }

1249 }

1250

1251 if (InVal) {

1252

1253

1254

1256 [&](unsigned Idx) {

1258 },

1259 false);

1260

1261

1262

1264 continue;

1265 }

1266

1267

1268

1269

1272

1273

1274

1275

1276

1279 if (PredSet.count(IncomingBB)) {

1282 }

1283 }

1284

1286 }

1287}

1288

1294

1300

1302 return nullptr;

1303

1304

1305

1308 std::string NewName = std::string(Suffix) + ".split-lp";

1309

1311 DTU, DT, LI, MSSAU, PreserveLCSSA);

1312 return NewBBs[0];

1313 }

1314

1315

1318

1319

1321

1322 Loop *L = nullptr;

1324

1327

1328

1330

1331

1332

1333

1334

1335 OldLatch = L->getLoopLatch();

1336 } else

1338

1339

1341

1342

1343

1345 "Cannot split an edge from an IndirectBrInst");

1346 Pred->getTerminator()->replaceSuccessorWith(BB, NewBB);

1347 }

1348

1349

1350

1351

1352

1353 if (Preds.empty()) {

1354

1357 }

1358

1359

1360 bool HasLoopExit = false;

1362 HasLoopExit);

1363

1364 if (!Preds.empty()) {

1365

1367 }

1368

1369 if (OldLatch) {

1370 BasicBlock *NewLatch = L->getLoopLatch();

1371 if (NewLatch != OldLatch) {

1374

1375

1379 }

1380 }

1381

1382 return NewBB;

1383}

1384

1389 bool PreserveLCSSA) {

1391 MSSAU, PreserveLCSSA);

1392}

1395 const char *Suffix,

1398 bool PreserveLCSSA) {

1400 nullptr, LI, MSSAU, PreserveLCSSA);

1401}

1402

1408 assert(OrigBB->isLandingPad() && "Trying to split a non-landing pad!");

1409

1410

1411

1413 OrigBB->getName() + Suffix1,

1416

1417

1420

1421

1423

1424

1425

1427 "Cannot split an edge from an IndirectBrInst");

1428 Pred->getTerminator()->replaceUsesOfWith(OrigBB, NewBB1);

1429 }

1430

1431 bool HasLoopExit = false;

1433 PreserveLCSSA, HasLoopExit);

1434

1435

1436 UpdatePHINodes(OrigBB, NewBB1, Preds, BI1, HasLoopExit);

1437

1438

1441 i != e; ) {

1443 if (Pred == NewBB1) continue;

1445 "Cannot split an edge from an IndirectBrInst");

1448 }

1449

1451 if (!NewBB2Preds.empty()) {

1452

1454 OrigBB->getName() + Suffix2,

1457

1458

1461

1462

1463 for (BasicBlock *NewBB2Pred : NewBB2Preds)

1464 NewBB2Pred->getTerminator()->replaceUsesOfWith(OrigBB, NewBB2);

1465

1466

1467 HasLoopExit = false;

1469 PreserveLCSSA, HasLoopExit);

1470

1471

1472 UpdatePHINodes(OrigBB, NewBB2, NewBB2Preds, BI2, HasLoopExit);

1473 }

1474

1479

1480 if (NewBB2) {

1484

1485

1486

1489 "Split cannot be applied if LPad is token type. Otherwise an "

1490 "invalid PHINode of token type would be created.");

1495 }

1497 } else {

1498

1499

1502 }

1503}

1504

1507 const char *Suffix1, const char *Suffix2,

1511 bool PreserveLCSSA) {

1513 NewBBs, DTU, nullptr, LI, MSSAU,

1514 PreserveLCSSA);

1515}

1516

1520 Instruction *UncondBranch = Pred->getTerminator();

1521

1523 NewRet->insertInto(Pred, Pred->end());

1524

1525

1526

1531

1532

1533 V = BCI->getOperand(0);

1534 NewBC = BCI->clone();

1536 Op = NewBC;

1537 }

1538

1541 V = EVI->getOperand(0);

1542 NewEV = EVI->clone();

1543 if (NewBC) {

1546 } else {

1548 Op = NewEV;

1549 }

1550 }

1551

1553 if (PN->getParent() == BB) {

1554 if (NewEV) {

1555 NewEV->setOperand(0, PN->getIncomingValueForBlock(Pred));

1556 } else if (NewBC)

1557 NewBC->setOperand(0, PN->getIncomingValueForBlock(Pred));

1558 else

1559 Op = PN->getIncomingValueForBlock(Pred);

1560 }

1561 }

1562 }

1563

1564

1565

1568

1569 if (DTU)

1571

1573}

1574

1577 bool Unreachable,

1578 MDNode *BranchWeights,

1582 Cond, SplitBefore, &ThenBlock, nullptr,

1583 Unreachable,

1584 false, BranchWeights, DTU, LI);

1586}

1587

1590 bool Unreachable,

1591 MDNode *BranchWeights,

1595 Cond, SplitBefore, nullptr, &ElseBlock,

1596 false,

1597 Unreachable, BranchWeights, DTU, LI);

1599}

1600

1604 MDNode *BranchWeights,

1609 Cond, SplitBefore, &ThenBlock, &ElseBlock, false,

1610 false, BranchWeights, DTU, LI);

1611

1614}

1615

1618 BasicBlock **ElseBlock, bool UnreachableThen, bool UnreachableElse,

1620 assert((ThenBlock || ElseBlock) &&

1621 "At least one branch block must be created");

1622 assert((!UnreachableThen || !UnreachableElse) &&

1623 "Split block tail must be reachable");

1624

1628 if (DTU) {

1630 Updates.reserve(4 + 2 * UniqueOrigSuccessors.size());

1631 }

1632

1637 bool ThenToTailEdge = false;

1638 bool ElseToTailEdge = false;

1639

1640

1642 bool &ToTailEdge) {

1643 if (PBB == nullptr)

1644 return;

1645

1646 if (*PBB)

1647 BB = *PBB;

1648 else {

1649

1651 if (Unreachable)

1653 else {

1655 ToTailEdge = true;

1656 }

1657 BB->getTerminator()->setDebugLoc(SplitBefore->getDebugLoc());

1658

1659 *PBB = BB;

1660 }

1661 };

1662

1663 handleBlock(ThenBlock, UnreachableThen, TrueBlock, ThenToTailEdge);

1664 handleBlock(ElseBlock, UnreachableElse, FalseBlock, ElseToTailEdge);

1665

1669 HeadNewTerm->setMetadata(LLVMContext::MD_prof, BranchWeights);

1671

1672 if (DTU) {

1675 if (ThenToTailEdge)

1677 if (ElseToTailEdge)

1679 for (BasicBlock *UniqueOrigSuccessor : UniqueOrigSuccessors)

1681 for (BasicBlock *UniqueOrigSuccessor : UniqueOrigSuccessors)

1684 }

1685

1686 if (LI) {

1688 if (ThenToTailEdge)

1689 L->addBasicBlockToLoop(TrueBlock, *LI);

1690 if (ElseToTailEdge)

1691 L->addBasicBlockToLoop(FalseBlock, *LI);

1692 L->addBasicBlockToLoop(Tail, *LI);

1693 }

1694 }

1695}

1696

1697std::pair<Instruction *, Value *>

1703

1704 auto *Ty = End->getType();

1705 auto &DL = SplitBefore->getDataLayout();

1706 const unsigned Bitwidth = DL.getTypeSizeInBits(Ty);

1707

1709 auto *IV = Builder.CreatePHI(Ty, 2, "iv");

1710 auto *IVNext =

1711 Builder.CreateAdd(IV, ConstantInt::get(Ty, 1), IV->getName() + ".next",

1712 true, Bitwidth != 2);

1713 auto *IVCheck = Builder.CreateICmpEQ(IVNext, End,

1714 IV->getName() + ".check");

1715 Builder.CreateCondBr(IVCheck, LoopExit, LoopBody);

1717

1718

1719 IV->addIncoming(ConstantInt::get(Ty, 0), LoopPred);

1720 IV->addIncoming(IVNext, LoopBody);

1721

1723}

1724

1728

1729 IRBuilder<> IRB(InsertBefore->getParent(), InsertBefore);

1730

1731 if (EC.isScalable()) {

1733

1734 auto [BodyIP, Index] =

1736

1738 Func(IRB, Index);

1739 return;

1740 }

1741

1742 unsigned Num = EC.getFixedValue();

1743 for (unsigned Idx = 0; Idx < Num; ++Idx) {

1745 Func(IRB, ConstantInt::get(IndexTy, Idx));

1746 }

1747}

1748

1752

1753 IRBuilder<> IRB(InsertBefore->getParent(), InsertBefore);

1755

1759 Func(IRB, Index);

1760 return;

1761 }

1762

1764 for (unsigned Idx = 0; Idx < Num; ++Idx) {

1766 Func(IRB, ConstantInt::get(Ty, Idx));

1767 }

1768}

1769

1775

1776 if (SomePHI) {

1778 return nullptr;

1781 } else {

1783 if (PI == PE)

1784 return nullptr;

1785 Pred1 = *PI++;

1786 if (PI == PE)

1787 return nullptr;

1788 Pred2 = *PI++;

1789 if (PI != PE)

1790 return nullptr;

1791 }

1792

1793

1794

1797 if (!Pred1Br || !Pred2Br)

1798 return nullptr;

1799

1800

1801

1803

1804

1805

1806

1808 return nullptr;

1809

1812 }

1813

1815

1816

1817

1819 return nullptr;

1820

1821

1822

1825 IfTrue = Pred1;

1826 IfFalse = Pred2;

1827 } else if (Pred1Br->getSuccessor(0) == Pred2 &&

1829 IfTrue = Pred2;

1830 IfFalse = Pred1;

1831 } else {

1832

1833

1834 return nullptr;

1835 }

1836

1837 return Pred1Br;

1838 }

1839

1840

1841

1842

1845 return nullptr;

1846

1847

1849 if (!BI) return nullptr;

1850

1853 IfTrue = Pred1;

1854 IfFalse = Pred2;

1855 } else {

1856 IfTrue = Pred2;

1857 IfFalse = Pred1;

1858 }

1859 return BI;

1860}

1861

1864

1865

1869 } else

1870 NewCond = Builder.CreateNot(NewCond, NewCond->getName() + ".not");

1871

1874}

1875

1877 for (auto &BB : F) {

1878 auto *Term = BB.getTerminator();

1881 return false;

1882 }

1883 return true;

1884}

1885

1888 if (!BB) {

1889 OS << "";

1890 return;

1891 }

1893 });

1894}

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

MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL

static BasicBlock * SplitBlockPredecessorsImpl(BasicBlock *BB, ArrayRef< BasicBlock * > Preds, const char *Suffix, DomTreeUpdater *DTU, DominatorTree *DT, LoopInfo *LI, MemorySSAUpdater *MSSAU, bool PreserveLCSSA)

Definition BasicBlockUtils.cpp:1296

static bool removeRedundantDbgInstrsUsingBackwardScan(BasicBlock *BB)

Remove redundant instructions within sequences of consecutive dbg.value instructions.

Definition BasicBlockUtils.cpp:437

static BasicBlock * SplitBlockImpl(BasicBlock *Old, BasicBlock::iterator SplitPt, DomTreeUpdater *DTU, DominatorTree *DT, LoopInfo *LI, MemorySSAUpdater *MSSAU, const Twine &BBName, bool Before)

Definition BasicBlockUtils.cpp:994

static void UpdatePHINodes(BasicBlock *OrigBB, BasicBlock *NewBB, ArrayRef< BasicBlock * > Preds, BranchInst *BI, bool HasLoopExit)

Update the PHI nodes in OrigBB to include the values coming from NewBB.

Definition BasicBlockUtils.cpp:1226

static bool removeUndefDbgAssignsFromEntryBlock(BasicBlock *BB)

Remove redundant undef dbg.assign intrinsic from an entry block using a forward scan.

Definition BasicBlockUtils.cpp:552

static bool updateCycleLoopInfo(TI *LCI, BasicBlock *CallBrBlock, BasicBlock *CallBrTarget, BasicBlock *Succ)

Helper function to update the cycle or loop information after inserting a new block between a callbr ...

Definition BasicBlockUtils.cpp:702

static void UpdateAnalysisInformation(BasicBlock *OldBB, BasicBlock *NewBB, ArrayRef< BasicBlock * > Preds, DomTreeUpdater *DTU, DominatorTree *DT, LoopInfo *LI, MemorySSAUpdater *MSSAU, bool PreserveLCSSA, bool &HasLoopExit)

Update DominatorTree, LoopInfo, and LCCSA analysis information.

Definition BasicBlockUtils.cpp:1112

static bool removeRedundantDbgInstrsUsingForwardScan(BasicBlock *BB)

Remove redundant dbg.value instructions using a forward scan.

Definition BasicBlockUtils.cpp:492

static void SplitLandingPadPredecessorsImpl(BasicBlock *OrigBB, ArrayRef< BasicBlock * > Preds, const char *Suffix1, const char *Suffix2, SmallVectorImpl< BasicBlock * > &NewBBs, DomTreeUpdater *DTU, DominatorTree *DT, LoopInfo *LI, MemorySSAUpdater *MSSAU, bool PreserveLCSSA)

Definition BasicBlockUtils.cpp:1403

static cl::opt< unsigned > MaxDeoptOrUnreachableSuccessorCheckDepth("max-deopt-or-unreachable-succ-check-depth", cl::init(8), cl::Hidden, cl::desc("Set the maximum path length when checking whether a basic block " "is followed by a block that either has a terminating " "deoptimizing call or is terminated with an unreachable"))

static void emptyAndDetachBlock(BasicBlock *BB, SmallVectorImpl< DominatorTree::UpdateType > *Updates, bool KeepOneInputPHIs)

Zap all the instructions in the block and replace them with an unreachable instruction and notify the...

Definition BasicBlockUtils.cpp:65

This file contains the declarations for the subclasses of Constant, which represent the different fla...

SmallPtrSet< const BasicBlock *, 8 > VisitedBlocks

This file provides various utilities for inspecting and working with the control flow graph in LLVM I...

uint64_t IntrinsicInst * II

const SmallVectorImpl< MachineOperand > & Cond

This file defines the SmallPtrSet class.

This file defines the SmallVector class.

static const uint32_t IV[8]

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

size_t size() const

size - Get the array size.

bool empty() const

empty - Check if the array is empty.

LLVM Basic Block Representation.

iterator begin()

Instruction iterator methods.

iterator_range< const_phi_iterator > phis() const

Returns a range that iterates over the phis in the basic block.

LLVM_ABI const LandingPadInst * getLandingPadInst() const

Return the landingpad instruction associated with the landing pad.

LLVM_ABI const_iterator getFirstInsertionPt() const

Returns an iterator to the first instruction in this block that is suitable for inserting a non-PHI i...

const Function * getParent() const

Return the enclosing method, or null if none.

const Instruction & back() const

bool hasAddressTaken() const

Returns true if there are any uses of this basic block other than direct branches,...

LLVM_ABI InstListType::const_iterator getFirstNonPHIIt() const

Returns an iterator to the first instruction in this block that is not a PHINode instruction.

static BasicBlock * Create(LLVMContext &Context, const Twine &Name="", Function *Parent=nullptr, BasicBlock *InsertBefore=nullptr)

Creates a new BasicBlock.

LLVM_ABI bool isEntryBlock() const

Return true if this is the entry block of the containing function.

LLVM_ABI InstListType::const_iterator getFirstNonPHIOrDbg(bool SkipPseudoOp=true) const

Returns a pointer to the first instruction in this block that is not a PHINode or a debug intrinsic,...

LLVM_ABI BasicBlock * splitBasicBlock(iterator I, const Twine &BBName="", bool Before=false)

Split the basic block into two basic blocks at the specified instruction.

LLVM_ABI const BasicBlock * getUniqueSuccessor() const

Return the successor of this block if it has a unique successor.

LLVM_ABI const BasicBlock * getSinglePredecessor() const

Return the predecessor of this block if it has a single predecessor block.

const Instruction & front() const

LLVM_ABI const CallInst * getTerminatingDeoptimizeCall() const

Returns the call instruction calling @llvm.experimental.deoptimize prior to the terminating return in...

LLVM_ABI void replacePhiUsesWith(BasicBlock *Old, BasicBlock *New)

Update all phi nodes in this basic block to refer to basic block New instead of basic block Old.

LLVM_ABI const BasicBlock * getUniquePredecessor() const

Return the predecessor of this block if it has a unique predecessor block.

LLVM_ABI const BasicBlock * getSingleSuccessor() const

Return the successor of this block if it has a single successor.

InstListType::iterator iterator

Instruction iterators...

LLVM_ABI LLVMContext & getContext() const

Get the context in which this basic block lives.

LLVM_ABI bool isLandingPad() const

Return true if this basic block is a landing pad.

LLVM_ABI bool canSplitPredecessors() const

const Instruction * getTerminator() const LLVM_READONLY

Returns the terminator instruction if the block is well formed or null if the block is not well forme...

void splice(BasicBlock::iterator ToIt, BasicBlock *FromBB)

Transfer all instructions from FromBB to this basic block at ToIt.

LLVM_ABI void removePredecessor(BasicBlock *Pred, bool KeepOneInputPHIs=false)

Update PHI nodes in this BasicBlock before removal of predecessor Pred.

This class represents a no-op cast from one type to another.

Conditional or Unconditional Branch instruction.

void setCondition(Value *V)

LLVM_ABI void swapSuccessors()

Swap the successors of this branch instruction.

bool isConditional() const

static BranchInst * Create(BasicBlock *IfTrue, InsertPosition InsertBefore=nullptr)

BasicBlock * getSuccessor(unsigned i) const

bool isUnconditional() const

void setSuccessor(unsigned idx, BasicBlock *NewSucc)

Value * getCondition() const

CallBr instruction, tracking function calls that may not return control but instead transfer it to a ...

void setSuccessor(unsigned i, BasicBlock *NewSucc)

BasicBlock * getSuccessor(unsigned i) const

static CleanupPadInst * Create(Value *ParentPad, ArrayRef< Value * > Args={}, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)

static CleanupReturnInst * Create(Value *CleanupPad, BasicBlock *UnwindBB=nullptr, InsertPosition InsertBefore=nullptr)

This class is the base class for the comparison instructions.

void setPredicate(Predicate P)

Set the predicate for this instruction to the specified value.

Predicate getInversePredicate() const

For example, EQ -> NE, UGT -> ULE, SLT -> SGE, OEQ -> UNE, UGT -> OLE, OLT -> UGE,...

Represents calls to the llvm.experimintal.convergence.* intrinsics.

Record of a variable value-assignment, aka a non instruction representation of the dbg....

Identifies a unique instance of a whole variable (discards/ignores fragment information).

Identifies a unique instance of a variable.

std::pair< iterator, bool > try_emplace(KeyT &&Key, Ts &&...Args)

Implements a dense probed hash-table based set.

iterator_range< iterator > children()

LLVM_ABI void deleteBB(BasicBlock *DelBB)

Delete DelBB.

DomTreeNodeBase< NodeT > * getRootNode()

getRootNode - This returns the entry node for the CFG of the function.

void changeImmediateDominator(DomTreeNodeBase< NodeT > *N, DomTreeNodeBase< NodeT > *NewIDom)

changeImmediateDominator - This method is used to update the dominator tree information when a node's...

DomTreeNodeBase< NodeT > * addNewBlock(NodeT *BB, NodeT *DomBB)

Add a new node to the dominator tree information.

void splitBlock(NodeT *NewBB)

splitBlock - BB is split and now it has one successor.

static constexpr UpdateKind Delete

DomTreeNodeBase< NodeT > * setNewRoot(NodeT *BB)

Add a new node to the forward dominator tree and make it a new root.

static constexpr UpdateKind Insert

void eraseNode(NodeT *BB)

eraseNode - Removes a node from the dominator tree.

DomTreeNodeBase< NodeT > * getNode(const NodeT *BB) const

getNode - return the (Post)DominatorTree node for the specified basic block.

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

LLVM_ABI bool isReachableFromEntry(const Use &U) const

Provide an overload for a Use.

LLVM_ABI bool dominates(const BasicBlock *BB, const Use &U) const

Return true if the (end of the) basic block BB dominates the use U.

DomTreeT & getDomTree()

Flush DomTree updates and return DomTree.

void applyUpdates(ArrayRef< UpdateT > Updates)

Submit updates to all available trees.

void flush()

Apply all pending updates to available trees and flush all BasicBlocks awaiting deletion.

bool hasDomTree() const

Returns true if it holds a DomTreeT.

void recalculate(FuncT &F)

Notify DTU that the entry block was replaced.

Module * getParent()

Get the module that this global value is contained inside of...

Common base class shared among various IRBuilders.

void SetInsertPoint(BasicBlock *TheBB)

This specifies that created instructions should be appended to the end of the specified block.

LLVM_ABI Value * CreateElementCount(Type *Ty, ElementCount EC)

Create an expression which evaluates to the number of elements in EC at runtime.

This provides a uniform API for creating instructions and inserting them into a basic block: either a...

LLVM_ABI Instruction * clone() const

Create a copy of 'this' instruction that is identical in all ways except the following:

LLVM_ABI unsigned getNumSuccessors() const LLVM_READONLY

Return the number of successors that this instruction has.

LLVM_ABI void insertBefore(InstListType::iterator InsertPos)

Insert an unlinked instruction into a basic block immediately before the specified position.

bool isEHPad() const

Return true if the instruction is a variety of EH-block.

LLVM_ABI InstListType::iterator eraseFromParent()

This method unlinks 'this' from the containing basic block and deletes it.

MDNode * getMetadata(unsigned KindID) const

Get the metadata of given kind attached to this Instruction.

LLVM_ABI bool mayHaveSideEffects() const LLVM_READONLY

Return true if the instruction may have side effects.

LLVM_ABI void setMetadata(unsigned KindID, MDNode *Node)

Set the metadata of the specified kind to the specified node.

LLVM_ABI void moveBeforePreserving(InstListType::iterator MovePos)

Perform a moveBefore operation, while signalling that the caller intends to preserve the original ord...

void setDebugLoc(DebugLoc Loc)

Set the debug location information for this instruction.

bool isSpecialTerminator() const

LLVM_ABI InstListType::iterator insertInto(BasicBlock *ParentBB, InstListType::iterator It)

Inserts an unlinked instruction into ParentBB at position It and returns the iterator of the inserted...

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

The landingpad instruction holds all of the information necessary to generate correct exception handl...

BlockT * getLoopLatch() const

If there is a single latch block for this loop, return it.

unsigned getLoopDepth() const

Return the nesting level of this loop.

void addBasicBlockToLoop(BlockT *NewBB, LoopInfoBase< BlockT, LoopT > &LI)

This method is used by other analyses to update loop information.

void removeBlock(BlockT *BB)

This method completely removes BB from all data structures, including all of the Loop objects it is n...

bool isLoopHeader(const BlockT *BB) const

LoopT * getLoopFor(const BlockT *BB) const

Return the inner most loop that BB lives in.

Represents a single loop in the control flow graph.

Provides a lazy, caching interface for making common memory aliasing information queries,...

void invalidateCachedPredecessors()

Clears the PredIteratorCache info.

void removeInstruction(Instruction *InstToRemove)

Removes an instruction from the dependence analysis, updating the dependence of instructions that pre...

MemorySSA * getMemorySSA() const

Get handle on MemorySSA.

LLVM_ABI void moveAllAfterSpliceBlocks(BasicBlock *From, BasicBlock *To, Instruction *Start)

From block was spliced into From and To.

LLVM_ABI void applyUpdates(ArrayRef< CFGUpdate > Updates, DominatorTree &DT, bool UpdateDTFirst=false)

Apply CFG updates, analogous with the DT edge updates.

LLVM_ABI void moveAllAfterMergeBlocks(BasicBlock *From, BasicBlock *To, Instruction *Start)

From block was merged into To.

LLVM_ABI void moveToPlace(MemoryUseOrDef *What, BasicBlock *BB, MemorySSA::InsertionPlace Where)

LLVM_ABI void wireOldPredecessorsToNewImmediatePredecessor(BasicBlock *Old, BasicBlock *New, ArrayRef< BasicBlock * > Preds, bool IdenticalEdgesWereMerged=true)

A new empty BasicBlock (New) now branches directly to Old.

LLVM_ABI void verifyMemorySSA(VerificationLevel=VerificationLevel::Fast) const

Verify that MemorySSA is self consistent (IE definitions dominate all uses, uses appear in the right ...

MemoryUseOrDef * getMemoryAccess(const Instruction *I) const

Given a memory Mod/Ref'ing instruction, get the MemorySSA access associated with it.

Class that has the common methods + fields of memory uses/defs.

void addIncoming(Value *V, BasicBlock *BB)

Add an incoming value to the end of the PHI list.

LLVM_ABI void removeIncomingValueIf(function_ref< bool(unsigned)> Predicate, bool DeletePHIIfEmpty=true)

Remove all incoming values for which the predicate returns true.

LLVM_ABI Value * removeIncomingValue(unsigned Idx, bool DeletePHIIfEmpty=true)

Remove an incoming value.

Value * getIncomingValueForBlock(const BasicBlock *BB) const

BasicBlock * getIncomingBlock(unsigned i) const

Return incoming basic block number i.

Value * getIncomingValue(unsigned i) const

Return incoming value number x.

unsigned getNumIncomingValues() const

Return the number of incoming edges.

static PHINode * Create(Type *Ty, unsigned NumReservedValues, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)

Constructors - NumReservedValues is a hint for the number of incoming edges that this phi node will h...

static LLVM_ABI PoisonValue * get(Type *T)

Static factory methods - Return an 'poison' object of the specified type.

Simple wrapper around std::function<void(raw_ostream&)>.

Return a value (possibly void), from a function.

Implements a dense probed hash-table based set with some number of buckets stored inline.

A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...

bool erase(PtrType Ptr)

Remove pointer from the set.

size_type count(ConstPtrType Ptr) const

count - Return 1 if the specified pointer is in the set, 0 otherwise.

void insert_range(Range &&R)

std::pair< iterator, bool > insert(PtrType Ptr)

Inserts Ptr if and only if there is no element in the container equal to Ptr.

bool contains(ConstPtrType Ptr) const

SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.

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

reference emplace_back(ArgTypes &&... Args)

void reserve(size_type N)

void push_back(const T &Elt)

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

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

Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...

LLVM_ABI std::string str() const

Return the twine contents as a std::string.

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

bool isTokenTy() const

Return true if this is 'token'.

This function has undefined behavior.

A Use represents the edge between a Value definition and its users.

void setOperand(unsigned i, Value *Val)

LLVM Value Representation.

Type * getType() const

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

LLVM_ABI void setName(const Twine &Name)

Change the name of the value.

bool hasOneUse() const

Return true if there is exactly one use of this value.

LLVM_ABI void replaceAllUsesWith(Value *V)

Change all uses of this to point to a new Value.

LLVM_ABI void printAsOperand(raw_ostream &O, bool PrintType=true, const Module *M=nullptr) const

Print the name of this Value out to the specified raw_ostream.

LLVM_ABI StringRef getName() const

Return a constant reference to the value's name.

LLVM_ABI void takeName(Value *V)

Transfer the name from V to this value.

std::pair< iterator, bool > insert(const ValueT &V)

bool contains(const_arg_type_t< ValueT > V) const

Check if the set contains the given element.

const ParentTy * getParent() const

self_iterator getIterator()

This class implements an extremely fast bulk output stream that can only output to a stream.

#define llvm_unreachable(msg)

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

@ Tail

Attemps to make calls as fast as possible while guaranteeing that tail call optimization can always b...

@ C

The default llvm calling convention, compatible with C.

LLVM_ABI AssignmentInstRange getAssignmentInsts(DIAssignID *ID)

Return a range of instructions (typically just one) that have ID as an attachment.

initializer< Ty > init(const Ty &Val)

This is an optimization pass for GlobalISel generic memory operations.

LLVM_ABI void ReplaceInstWithInst(BasicBlock *BB, BasicBlock::iterator &BI, Instruction *I)

Replace the instruction specified by BI with the instruction specified by I.

Definition BasicBlockUtils.cpp:621

iterator_range< df_ext_iterator< T, SetTy > > depth_first_ext(const T &G, SetTy &S)

LLVM_ABI bool RemoveRedundantDbgInstrs(BasicBlock *BB)

Try to remove redundant dbg.value instructions from given basic block.

Definition BasicBlockUtils.cpp:583

bool succ_empty(const Instruction *I)

LLVM_ABI bool IsBlockFollowedByDeoptOrUnreachable(const BasicBlock *BB)

Check if we can prove that all paths starting from this block converge to a block that either has a @...

Definition BasicBlockUtils.cpp:641

LLVM_ABI BranchInst * GetIfCondition(BasicBlock *BB, BasicBlock *&IfTrue, BasicBlock *&IfFalse)

Check whether BB is the merge point of a if-region.

Definition BasicBlockUtils.cpp:1770

LLVM_ABI unsigned GetSuccessorNumber(const BasicBlock *BB, const BasicBlock *Succ)

Search for the specified successor of basic block BB and return its position in the terminator instru...

auto pred_end(const MachineBasicBlock *BB)

LLVM_ABI void detachDeadBlocks(ArrayRef< BasicBlock * > BBs, SmallVectorImpl< DominatorTree::UpdateType > *Updates, bool KeepOneInputPHIs=false)

Replace contents of every block in BBs with single unreachable instruction.

Definition BasicBlockUtils.cpp:104

decltype(auto) dyn_cast(const From &Val)

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

LLVM_ABI bool hasOnlySimpleTerminator(const Function &F)

Definition BasicBlockUtils.cpp:1876

auto successors(const MachineBasicBlock *BB)

LLVM_ABI ReturnInst * FoldReturnIntoUncondBranch(ReturnInst *RI, BasicBlock *BB, BasicBlock *Pred, DomTreeUpdater *DTU=nullptr)

This method duplicates the specified return instruction into a predecessor which ends in an unconditi...

Definition BasicBlockUtils.cpp:1517

constexpr from_range_t from_range

LLVM_ABI std::pair< Instruction *, Value * > SplitBlockAndInsertSimpleForLoop(Value *End, BasicBlock::iterator SplitBefore)

Insert a for (int i = 0; i < End; i++) loop structure (with the exception that End is assumed > 0,...

Definition BasicBlockUtils.cpp:1698

LLVM_ABI BasicBlock * splitBlockBefore(BasicBlock *Old, BasicBlock::iterator SplitPt, DomTreeUpdater *DTU, LoopInfo *LI, MemorySSAUpdater *MSSAU, const Twine &BBName="")

Split the specified block at the specified instruction SplitPt.

Definition BasicBlockUtils.cpp:1065

LLVM_ABI Instruction * SplitBlockAndInsertIfElse(Value *Cond, BasicBlock::iterator SplitBefore, bool Unreachable, MDNode *BranchWeights=nullptr, DomTreeUpdater *DTU=nullptr, LoopInfo *LI=nullptr, BasicBlock *ElseBlock=nullptr)

Similar to SplitBlockAndInsertIfThen, but the inserted block is on the false path of the branch.

Definition BasicBlockUtils.cpp:1588

LLVM_ABI BasicBlock * SplitCallBrEdge(BasicBlock *CallBrBlock, BasicBlock *Succ, unsigned SuccIdx, DomTreeUpdater *DTU=nullptr, CycleInfo *CI=nullptr, LoopInfo *LI=nullptr, bool *UpdatedLI=nullptr)

Create a new intermediate target block for a callbr edge.

Definition BasicBlockUtils.cpp:725

iterator_range< early_inc_iterator_impl< detail::IterOfRange< RangeT > > > make_early_inc_range(RangeT &&Range)

Make a range that does early increment to allow mutation of the underlying range without disrupting i...

auto cast_or_null(const Y &Val)

auto pred_size(const MachineBasicBlock *BB)

LLVM_ABI void DeleteDeadBlock(BasicBlock *BB, DomTreeUpdater *DTU=nullptr, bool KeepOneInputPHIs=false)

Delete the specified block, which must have no predecessors.

Definition BasicBlockUtils.cpp:145

LLVM_ABI void ReplaceInstWithValue(BasicBlock::iterator &BI, Value *V)

Replace all uses of an instruction (specified by BI) with a value, then remove and delete the origina...

Definition BasicBlockUtils.cpp:608

LLVM_ABI BasicBlock * SplitKnownCriticalEdge(Instruction *TI, unsigned SuccNum, const CriticalEdgeSplittingOptions &Options=CriticalEdgeSplittingOptions(), const Twine &BBName="")

If it is known that an edge is critical, SplitKnownCriticalEdge can be called directly,...

DomTreeNodeBase< BasicBlock > DomTreeNode

auto dyn_cast_or_null(const Y &Val)

bool any_of(R &&range, UnaryPredicate P)

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

LLVM_ABI bool DeleteDeadPHIs(BasicBlock *BB, const TargetLibraryInfo *TLI=nullptr, MemorySSAUpdater *MSSAU=nullptr)

Examine each PHI in the given block and delete it if it is dead.

Definition BasicBlockUtils.cpp:213

LLVM_ABI bool HasLoopOrEntryConvergenceToken(const BasicBlock *BB)

Check if the given basic block contains any loop or entry convergent intrinsic instructions.

Definition BasicBlockUtils.cpp:95

auto reverse(ContainerTy &&C)

LLVM_ABI void InvertBranch(BranchInst *PBI, IRBuilderBase &Builder)

Definition BasicBlockUtils.cpp:1862

LLVM_ABI bool EliminateUnreachableBlocks(Function &F, DomTreeUpdater *DTU=nullptr, bool KeepOneInputPHIs=false)

Delete all basic blocks from F that are not reachable from its entry node.

Definition BasicBlockUtils.cpp:174

LLVM_ABI bool MergeBlockSuccessorsIntoGivenBlocks(SmallPtrSetImpl< BasicBlock * > &MergeBlocks, Loop *L=nullptr, DomTreeUpdater *DTU=nullptr, LoopInfo *LI=nullptr)

Merge block(s) sucessors, if possible.

Definition BasicBlockUtils.cpp:393

LLVM_ABI void SplitBlockAndInsertIfThenElse(Value *Cond, BasicBlock::iterator SplitBefore, Instruction **ThenTerm, Instruction **ElseTerm, MDNode *BranchWeights=nullptr, DomTreeUpdater *DTU=nullptr, LoopInfo *LI=nullptr)

SplitBlockAndInsertIfThenElse is similar to SplitBlockAndInsertIfThen, but also creates the ElseBlock...

Definition BasicBlockUtils.cpp:1601

LLVM_ABI raw_ostream & dbgs()

dbgs() - This returns a reference to a raw_ostream for debugging messages.

LLVM_ABI BasicBlock * ehAwareSplitEdge(BasicBlock *BB, BasicBlock *Succ, LandingPadInst *OriginalPad=nullptr, PHINode *LandingPadReplacement=nullptr, const CriticalEdgeSplittingOptions &Options=CriticalEdgeSplittingOptions(), const Twine &BBName="")

Split the edge connect the specficed blocks in the case that Succ is an Exception Handling Block.

Definition BasicBlockUtils.cpp:799

auto succ_size(const MachineBasicBlock *BB)

SmallVector< ValueTypeFromRangeType< R >, Size > to_vector(R &&Range)

Given a range of type R, iterate the entire range and return a SmallVector with elements of the vecto...

bool isa(const From &Val)

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

LLVM_ABI void SplitLandingPadPredecessors(BasicBlock *OrigBB, ArrayRef< BasicBlock * > Preds, const char *Suffix, const char *Suffix2, SmallVectorImpl< BasicBlock * > &NewBBs, DomTreeUpdater *DTU=nullptr, LoopInfo *LI=nullptr, MemorySSAUpdater *MSSAU=nullptr, bool PreserveLCSSA=false)

This method transforms the landing pad, OrigBB, by introducing two new basic blocks into the function...

Definition BasicBlockUtils.cpp:1505

LLVM_ATTRIBUTE_VISIBILITY_DEFAULT AnalysisKey InnerAnalysisManagerProxy< AnalysisManagerT, IRUnitT, ExtraArgTs... >::Key

LLVM_ABI BasicBlock * SplitBlockPredecessors(BasicBlock *BB, ArrayRef< BasicBlock * > Preds, const char *Suffix, DominatorTree *DT, LoopInfo *LI=nullptr, MemorySSAUpdater *MSSAU=nullptr, bool PreserveLCSSA=false)

This method introduces at least one new basic block into the function and moves some of the predecess...

Definition BasicBlockUtils.cpp:1385

LLVM_ABI bool VerifyMemorySSA

Enables verification of MemorySSA.

LLVM_ABI void createPHIsForSplitLoopExit(ArrayRef< BasicBlock * > Preds, BasicBlock *SplitBB, BasicBlock *DestBB)

When a loop exit edge is split, LCSSA form may require new PHIs in the new exit block.

Definition BasicBlockUtils.cpp:947

LLVM_ABI bool MergeBlockIntoPredecessor(BasicBlock *BB, DomTreeUpdater *DTU=nullptr, LoopInfo *LI=nullptr, MemorySSAUpdater *MSSAU=nullptr, MemoryDependenceResults *MemDep=nullptr, bool PredecessorWithTwoSuccessors=false, DominatorTree *DT=nullptr)

Attempts to merge a block into its predecessor, if possible.

Definition BasicBlockUtils.cpp:227

LLVM_ABI bool isAssignmentTrackingEnabled(const Module &M)

Return true if assignment tracking is enabled for module M.

DWARFExpression::Operation Op

PredIterator< BasicBlock, Value::user_iterator > pred_iterator

LLVM_ABI BasicBlock * SplitCriticalEdge(Instruction *TI, unsigned SuccNum, const CriticalEdgeSplittingOptions &Options=CriticalEdgeSplittingOptions(), const Twine &BBName="")

If this edge is a critical edge, insert a new node to split the critical edge.

LLVM_ABI bool FoldSingleEntryPHINodes(BasicBlock *BB, MemoryDependenceResults *MemDep=nullptr)

We know that BB has one predecessor.

Definition BasicBlockUtils.cpp:194

ArrayRef(const T &OneElt) -> ArrayRef< T >

LLVM_ABI bool isCriticalEdge(const Instruction *TI, unsigned SuccNum, bool AllowIdenticalEdges=false)

Return true if the specified edge is a critical edge.

LLVM_ABI unsigned SplitAllCriticalEdges(Function &F, const CriticalEdgeSplittingOptions &Options=CriticalEdgeSplittingOptions())

Loop over all of the edges in the CFG, breaking critical edges as they are found.

Definition BasicBlockUtils.cpp:981

LLVM_ABI void updatePhiNodes(BasicBlock *DestBB, BasicBlock *OldPred, BasicBlock *NewPred, PHINode *Until=nullptr)

Replaces all uses of OldPred with the NewPred block in all PHINodes in a block.

Definition BasicBlockUtils.cpp:777

LLVM_ABI Printable printBasicBlock(const BasicBlock *BB)

Print BasicBlock BB as an operand or print "" if BB is a nullptr.

auto pred_begin(const MachineBasicBlock *BB)

decltype(auto) cast(const From &Val)

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

LLVM_ABI BasicBlock * SplitBlock(BasicBlock *Old, BasicBlock::iterator SplitPt, DominatorTree *DT, LoopInfo *LI=nullptr, MemorySSAUpdater *MSSAU=nullptr, const Twine &BBName="", bool Before=false)

Split the specified block at the specified instruction.

Definition BasicBlockUtils.cpp:1050

auto predecessors(const MachineBasicBlock *BB)

iterator_range< pointer_iterator< WrappedIteratorT > > make_pointer_range(RangeT &&Range)

bool is_contained(R &&Range, const E &Element)

Returns true if Element is found in Range.

LLVM_ABI bool RecursivelyDeleteDeadPHINode(PHINode *PN, const TargetLibraryInfo *TLI=nullptr, MemorySSAUpdater *MSSAU=nullptr)

If the specified value is an effectively dead PHI node, due to being a def-use chain of single-use no...

LLVM_ABI Instruction * SplitBlockAndInsertIfThen(Value *Cond, BasicBlock::iterator SplitBefore, bool Unreachable, MDNode *BranchWeights=nullptr, DomTreeUpdater *DTU=nullptr, LoopInfo *LI=nullptr, BasicBlock *ThenBlock=nullptr)

Split the containing block at the specified instruction - everything before SplitBefore stays in the ...

Definition BasicBlockUtils.cpp:1575

LLVM_ABI void DeleteDeadBlocks(ArrayRef< BasicBlock * > BBs, DomTreeUpdater *DTU=nullptr, bool KeepOneInputPHIs=false)

Delete the specified blocks from BB.

Definition BasicBlockUtils.cpp:150

LLVM_ABI BasicBlock * SplitEdge(BasicBlock *From, BasicBlock *To, DominatorTree *DT=nullptr, LoopInfo *LI=nullptr, MemorySSAUpdater *MSSAU=nullptr, const Twine &BBName="")

Split the edge connecting the specified blocks, and return the newly created basic block between From...

Definition BasicBlockUtils.cpp:660

LLVM_ABI void setUnwindEdgeTo(Instruction *TI, BasicBlock *Succ)

Sets the unwind edge of an instruction to a particular successor.

Definition BasicBlockUtils.cpp:766

static auto filterDbgVars(iterator_range< simple_ilist< DbgRecord >::iterator > R)

Filter the DbgRecord range to DbgVariableRecord types only and downcast.

LLVM_ABI void SplitBlockAndInsertForEachLane(ElementCount EC, Type *IndexTy, BasicBlock::iterator InsertBefore, std::function< void(IRBuilderBase &, Value *)> Func)

Utility function for performing a given action on each lane of a vector with EC elements.

Definition BasicBlockUtils.cpp:1725

GenericCycleInfo< SSAContext > CycleInfo

void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)

Implement std::swap in terms of BitVector swap.

Option class for critical edge splitting.

CriticalEdgeSplittingOptions & setPreserveLCSSA()