PrologEpilogInserter.cpp Source File (original) (raw)

61#include

62#include

63#include

64#include

65#include

66#include

68using namespace llvm;

70#define DEBUG_TYPE "prologepilog"

74 STATISTIC(NumLeafFuncWithSpills, "Number of leaf functions with CSRs");

75 STATISTIC(NumFuncSeen, "Number of functions seen in PEI");

78namespace {

80class PEIImpl {

91 bool FrameIndexVirtualScavenging = false;

95 bool FrameIndexEliminationScavenging = false;

103

107 int &SPAdj);

108

109

110

112 unsigned OpIdx, int SPAdj = 0);

113

114

117 int &SPAdj);

118

121

122public:

124 bool run(MachineFunction &MF);

125};

126

128public:

129 static char ID;

130

131 PEILegacy() : MachineFunctionPass(ID) {

133 }

134

135 void getAnalysisUsage(AnalysisUsage &AU) const override;

136

137

138

139 bool runOnMachineFunction(MachineFunction &MF) override;

140};

141

142}

143

144char PEILegacy::ID = 0;

145

147

149 false, false)

154 "Prologue/Epilogue Insertion & Frame Finalization", false,

156

158 return new PEILegacy();

159}

160

162 "Number of bytes used for stack in all functions");

163

164void PEILegacy::getAnalysisUsage(AnalysisUsage &AU) const {

170}

171

172

174

177

178

179

180

184

185 for (auto &MI : MBB) {

186 if (.isDebugInstr())

187 break;

188 if (.isDebugValue() || .getDebugVariable()->isParameter())

189 continue;

190 if (any_of(MI.debug_operands(),

191 [](const MachineOperand &MO) { return MO.isFI(); })) {

192

193

195 continue;

196 }

199 auto Overlaps = [Var, Expr](const MachineInstr *DV) {

200 return Var == DV->getDebugVariable() &&

202 };

203

204

205

207 EntryDbgValues[&MBB].push_back(&MI);

208 }

209

210

211 if (auto It = EntryDbgValues.find(&MBB); It != EntryDbgValues.end())

212 for (auto *MI : It->second)

213 MI->removeFromParent();

214}

215

216bool PEIImpl::run(MachineFunction &MF) {

217 NumFuncSeen++;

221

222 RS = TRI->requiresRegisterScavenging(MF) ? new RegScavenger() : nullptr;

223 FrameIndexVirtualScavenging = TRI->requiresFrameIndexScavenging(MF);

224

225

226

227

229

230

231

232 calculateCallFrameInfo(MF);

233

234

235

236 calculateSaveRestoreBlocks(MF);

237

238

240 for (MachineBasicBlock *SaveBlock : SaveBlocks)

242

243

245 spillCalleeSavedRegs(MF);

246

247

248

250

251

252 calculateFrameObjectOffsets(MF);

253

254

255

256

257

258

259 if (.hasFnAttribute(Attribute::Naked))

260 insertPrologEpilogCode(MF);

261

262

263 for (auto &I : EntryDbgValues)

264 I.first->insert(I.first->begin(), I.second.begin(), I.second.end());

265

266

267

269

270

271

273

274 FrameIndexEliminationScavenging =

275 (RS && !FrameIndexVirtualScavenging) ||

276 TRI->requiresFrameIndexReplacementScavenging(MF);

277

278 if (TRI->eliminateFrameIndicesBackwards())

279 replaceFrameIndicesBackward(MF);

280 else

281 replaceFrameIndices(MF);

282 }

283

284

285

286

287 if (TRI->requiresRegisterScavenging(MF) && FrameIndexVirtualScavenging)

289

290

293

300

301 assert( Failed && "Invalid warn-stack-size fn attr value");

303 }

306 StackSize += UnsafeStackSize;

307

308 if (StackSize > Threshold) {

309 DiagnosticInfoStackSize DiagStackSize(F, StackSize, Threshold, DS_Warning);

310 F.getContext().diagnose(DiagStackSize);

311 int64_t SpillSize = 0;

313 Idx != End; ++Idx) {

316 }

317

318 [[maybe_unused]] float SpillPct =

319 static_cast<float>(SpillSize) / static_cast<float>(StackSize);

321 dbgs() << formatv("{0}/{1} ({3:P}) spills, {2}/{1} ({4:P}) variables",

322 SpillSize, StackSize, StackSize - SpillSize, SpillPct,

323 1.0f - SpillPct));

324 if (UnsafeStackSize != 0) {

326 UnsafeStackSize,

327 static_cast<float>(UnsafeStackSize) /

328 static_cast<float>(StackSize),

329 StackSize));

330 }

332 }

333

334 ORE->emit([&]() {

335 return MachineOptimizationRemarkAnalysis(DEBUG_TYPE, "StackSize",

338 << ore::NV("NumStackBytes", StackSize)

339 << " stack bytes in function '"

341 });

342

343

345

346 delete RS;

347 SaveBlocks.clear();

348 RestoreBlocks.clear();

351 return true;

352}

353

354

355

356bool PEILegacy::runOnMachineFunction(MachineFunction &MF) {

357 MachineOptimizationRemarkEmitter *ORE =

358 &getAnalysis().getORE();

359 return PEIImpl(ORE).run(MF);

360}

361

362PreservedAnalyses

367 if (!PEIImpl(&ORE).run(MF))

369

372 .preserve()

374}

375

376

377

378void PEIImpl::calculateCallFrameInfo(MachineFunction &MF) {

382

383

384 unsigned FrameSetupOpcode = TII.getCallFrameSetupOpcode();

385 unsigned FrameDestroyOpcode = TII.getCallFrameDestroyOpcode();

386

387

388

389 if (FrameSetupOpcode == ~0u && FrameDestroyOpcode == ~0u)

390 return;

391

392

393 [[maybe_unused]] uint64_t MaxCFSIn =

395 std::vectorMachineBasicBlock::iterator FrameSDOps;

398 "Recomputing MaxCFS gave a larger value.");

400 "AdjustsStack not set in presence of a frame pseudo instruction.");

401

403

404

405

406

409

410

411

413 MBB.setCallFrameSize(0);

414 }

415}

416

417

418

419void PEIImpl::calculateSaveRestoreBlocks(MachineFunction &MF) {

420 const MachineFrameInfo &MFI = MF.getFrameInfo();

421

422

423

424

425

428 "Multiple save points are not yet supported!");

429 const auto &SavePoint = *MFI.getSavePoints().begin();

430 SaveBlocks.push_back(SavePoint.first);

432 "Multiple restore points are not yet supported!");

434 MachineBasicBlock *RestoreBlock = RestorePoint.first;

435

436

437

439 RestoreBlocks.push_back(RestoreBlock);

440 return;

441 }

442

443

444 SaveBlocks.push_back(&MF.front());

445 for (MachineBasicBlock &MBB : MF) {

447 SaveBlocks.push_back(&MBB);

450 }

451}

452

455 if (SavedRegs.empty())

456 return;

457

459 const MCPhysReg *CSRegs = F.getRegInfo().getCalleeSavedRegs();

461

462 for (unsigned i = 0; CSRegs[i]; ++i)

463 CSMask.set(CSRegs[i]);

464

465 std::vector CSI;

466 for (unsigned i = 0; CSRegs[i]; ++i) {

467 unsigned Reg = CSRegs[i];

468 if (SavedRegs.test(Reg)) {

469 bool SavedSuper = false;

471

472

473 if (SavedRegs.test(SuperReg) && CSMask.test(SuperReg)) {

474 SavedSuper = true;

475 break;

476 }

477 }

478

479 if (!SavedSuper)

481 }

482 }

483

487

488

489 if (CSI.empty())

490 return;

491

492 unsigned NumFixedSpillSlots;

495

496

497

498 for (auto &CS : CSI) {

499

500

501 if (CS.isSpilledToReg())

502 continue;

503

506

507 int FrameIdx;

508 if (RegInfo->hasReservedSpillSlot(F, Reg, FrameIdx)) {

509 CS.setFrameIdx(FrameIdx);

510 continue;

511 }

512

513

514

516 while (FixedSlot != FixedSpillSlots + NumFixedSpillSlots &&

517 FixedSlot->Reg != Reg)

518 ++FixedSlot;

519

520 unsigned Size = RegInfo->getSpillSize(*RC);

521 if (FixedSlot == FixedSpillSlots + NumFixedSpillSlots) {

522

523 Align Alignment = RegInfo->getSpillAlign(*RC);

524

525

526

527 Alignment = std::min(Alignment, TFI->getStackAlign());

530 } else {

531

533 }

534

535 CS.setFrameIdx(FrameIdx);

536 }

537 }

538

540}

541

542

543

546

547

548

549

550

551

552

556

558 "Multiple save points not yet supported!");

560 ? nullptr

562

563 if (!Save)

564 Save = Entry;

565

566 if (Entry != Save) {

568 Visited.insert(Entry);

569 }

570 Visited.insert(Save);

571

573 "Multiple restore points not yet supported!");

575 ? nullptr

577 if (Restore)

578

579

580

582

583 while (!WorkList.empty()) {

585

586

587 if (CurBB == Save && Save != Restore)

588 continue;

589

590

592 if (Visited.insert(SuccBB).second)

594 }

595

597

602

603

604 if ( MRI .isReserved(Reg) && MBB ->isLiveIn(Reg))

606 }

607

608

609

610

611

612 if (I.isSpilledToReg()) {

614 if (Visited.count(&MBB))

615 continue;

617 if ( MBB .isLiveIn(DstReg))

618 MBB.addLiveIn(DstReg);

619 }

620 }

621 }

622}

623

624

639

640

642 std::vector &CSI) {

647

648

649

651

655 }

656 }

657}

658

659void PEIImpl::spillCalleeSavedRegs(MachineFunction &MF) {

660

661

662

663

664

666

670

671

672 BitVector SavedRegs;

674

675

677

678

679 if (.hasFnAttribute(Attribute::Naked)) {

681

683

684

687 for (const auto &SavePoint : MFI.getSavePoints())

688 SaveRestorePts.insert({SavePoint.first, CSI});

690

691 SaveRestorePts.clear();

693 SaveRestorePts.insert({RestorePoint.first, CSI});

695 }

696

697 if (!CSI.empty()) {

699 NumLeafFuncWithSpills++;

700

701 for (MachineBasicBlock *SaveBlock : SaveBlocks)

703

704

706

707 for (MachineBasicBlock *RestoreBlock : RestoreBlocks)

709 }

710 }

711}

712

713

715 bool StackGrowsDown, int64_t &Offset,

716 Align &MaxAlign) {

717

718 if (StackGrowsDown)

720

722

723

724

725 MaxAlign = std::max(MaxAlign, Alignment);

726

727

729

730 if (StackGrowsDown) {

732 << "]\n");

734 } else {

736 << "]\n");

739 }

740}

741

742

743

745 bool StackGrowsDown,

746 int64_t FixedCSEnd,

748

749 if (FixedCSEnd > std::numeric_limits::max())

750 return;

751

752 StackBytesFree.resize(FixedCSEnd, true);

753

755

757

759 AllocatedFrameSlots.push_back(i);

760

764 AllocatedFrameSlots.push_back(i);

765

766 for (int i : AllocatedFrameSlots) {

767

768

771 int ObjStart, ObjEnd;

772 if (StackGrowsDown) {

773

774 ObjStart = -ObjOffset - ObjSize;

775 ObjEnd = -ObjOffset;

776 } else {

777 ObjStart = ObjOffset;

778 ObjEnd = ObjOffset + ObjSize;

779 }

780

781 if (ObjEnd > 0)

782 StackBytesFree.reset(ObjStart, ObjEnd);

783 }

784}

785

786

787

789 bool StackGrowsDown, Align MaxAlign,

792 return false;

793

794 if (StackBytesFree.none()) {

795

796

797 StackBytesFree.clear();

798 return false;

799 }

800

802 if (ObjAlign > MaxAlign)

803 return false;

804

806 int FreeStart;

807 for (FreeStart = StackBytesFree.find_first(); FreeStart != -1;

808 FreeStart = StackBytesFree.find_next(FreeStart)) {

809

810

811 unsigned ObjStart = StackGrowsDown ? FreeStart + ObjSize : FreeStart;

812 if (alignTo(ObjStart, ObjAlign) != ObjStart)

813 continue;

814

815 if (FreeStart + ObjSize > StackBytesFree.size())

816 return false;

817

818 bool AllBytesFree = true;

819 for (unsigned Byte = 0; Byte < ObjSize; ++Byte)

820 if (!StackBytesFree.test(FreeStart + Byte)) {

821 AllBytesFree = false;

822 break;

823 }

824 if (AllBytesFree)

825 break;

826 }

827

828 if (FreeStart == -1)

829 return false;

830

831 if (StackGrowsDown) {

832 int ObjStart = -(FreeStart + ObjSize);

833 LLVM_DEBUG(dbgs() << "alloc FI(" << FrameIdx << ") scavenged at SP["

834 << ObjStart << "]\n");

836 } else {

837 LLVM_DEBUG(dbgs() << "alloc FI(" << FrameIdx << ") scavenged at SP["

838 << FreeStart << "]\n");

840 }

841

842 StackBytesFree.reset(FreeStart, FreeStart + ObjSize);

843 return true;

844}

845

846

847

852

853 for (int i : UnassignedObjs) {

855 ProtectedObjs.insert(i);

856 }

857}

858

859

860

861void PEIImpl::calculateFrameObjectOffsets(MachineFunction &MF) {

863

864 bool StackGrowsDown =

866

867

869

870

871

872

874 if (StackGrowsDown)

875 LocalAreaOffset = -LocalAreaOffset;

876 assert(LocalAreaOffset >= 0

877 && "Local area offset should be in direction of stack growth");

878 int64_t Offset = LocalAreaOffset;

879

880#ifdef EXPENSIVE_CHECKS

885 "MaxAlignment is invalid");

886#endif

887

888

889

890

891

893

895 continue;

896

897 int64_t FixedOff;

898 if (StackGrowsDown) {

899

900

901

903 } else {

904

905

907 }

909 }

910

912

913

914 if (StackGrowsDown) {

916 FI++) {

917

920 continue;

921

923 }

924 } else {

926 FI--) {

927

930 continue;

931

933 continue;

934

936 }

937 }

938

940 "MFI.getMaxAlign should already account for all callee-saved "

941 "registers without a fixed stack slot");

942

943

944

945 int64_t FixedCSEnd = Offset;

946

947

948

949

952 if (RS && EarlyScavengingSlots) {

953 SmallVector<int, 2> SFIs;

955 for (int SFI : SFIs)

957 }

958

959

960

961

962

965

966

968

970

971

974 int64_t FIOffset = (StackGrowsDown ? -Offset : Offset) + Entry.second;

975 LLVM_DEBUG(dbgs() << "alloc FI(" << Entry.first << ") at SP[" << FIOffset

976 << "]\n");

978 }

979

981

982 MaxAlign = std::max(Alignment, MaxAlign);

983 }

984

985

986 int EHRegNodeFrameIndex = std::numeric_limits::max();

988 EHRegNodeFrameIndex = FuncInfo->EHRegNodeFrameIndex;

989

990

991

992 SmallSet<int, 16> ProtectedObjs;

998

999

1000

1001

1002

1004

1005

1007 "Offset of stack protector on non-default stack expected to be "

1008 "already set.");

1010 "Stack protector on non-default stack expected to not be "

1011 "pre-allocated by LocalStackSlotPass.");

1014 MaxAlign);

1017 "Stack protector not pre-allocated by LocalStackSlotPass.");

1018 }

1019

1020

1021 for (unsigned i = 0, e = MFI.getObjectIndexEnd(); i != e; ++i) {

1023 continue;

1025 continue;

1027 continue;

1029 continue;

1030 if (StackProtectorFI == (int)i || EHRegNodeFrameIndex == (int)i)

1031 continue;

1032

1034 continue;

1035

1038 continue;

1040 SmallArrayObjs.insert(i);

1041 continue;

1043 AddrOfObjs.insert(i);

1044 continue;

1046 LargeArrayObjs.insert(i);

1047 continue;

1048 }

1050 }

1051

1052

1053

1054

1056 !(LargeArrayObjs.empty() && SmallArrayObjs.empty() &&

1057 AddrOfObjs.empty()))

1058 llvm_unreachable("Found protected stack objects not pre-allocated by "

1059 "LocalStackSlotPass.");

1060

1067 }

1068

1069 SmallVector<int, 8> ObjectsToAllocate;

1070

1071

1072

1073 for (unsigned i = 0, e = MFI.getObjectIndexEnd(); i != e; ++i) {

1075 continue;

1077 continue;

1079 continue;

1081 continue;

1083 continue;

1084 if (ProtectedObjs.count(i))

1085 continue;

1086

1088 continue;

1089

1090

1092 }

1093

1094

1095 if (EHRegNodeFrameIndex != std::numeric_limits::max())

1097 MaxAlign);

1098

1099

1103

1104

1105

1106

1107

1108 BitVector StackBytesFree;

1109 if (!ObjectsToAllocate.empty() &&

1113

1114

1115 for (auto &Object : ObjectsToAllocate)

1117 StackBytesFree))

1119

1120

1121

1122 if (RS && !EarlyScavengingSlots) {

1123 SmallVector<int, 2> SFIs;

1125 for (int SFI : SFIs)

1127 }

1128

1130

1131

1132

1135

1136

1137

1138

1139

1140

1141 Align StackAlign;

1145 else

1147

1148

1149

1150 StackAlign = std::max(StackAlign, MaxAlign);

1151 int64_t OffsetBeforeAlignment = Offset;

1153

1154

1155

1156

1157 if (StackGrowsDown && OffsetBeforeAlignment != Offset && RS &&

1158 !EarlyScavengingSlots) {

1159 SmallVector<int, 2> SFIs;

1162 << "Adjusting emergency spill slots!\n";);

1163 int64_t Delta = Offset - OffsetBeforeAlignment;

1164 for (int SFI : SFIs) {

1166 << "Adjusting offset of emergency spill slot #" << SFI

1170 }

1171 }

1172 }

1173

1174

1175 int64_t StackSize = Offset - LocalAreaOffset;

1177 NumBytesStackSpace += StackSize;

1178}

1179

1180

1181

1182

1183void PEIImpl::insertPrologEpilogCode(MachineFunction &MF) {

1185

1186

1187 for (MachineBasicBlock *SaveBlock : SaveBlocks)

1189

1190

1191 for (MachineBasicBlock *RestoreBlock : RestoreBlocks)

1193

1194

1195 insertZeroCallUsedRegs(MF);

1196

1197 for (MachineBasicBlock *SaveBlock : SaveBlocks)

1199

1200

1201

1202

1203

1205 for (MachineBasicBlock *SaveBlock : SaveBlocks)

1207 }

1208

1209

1210

1211

1212

1213

1215 for (MachineBasicBlock *SaveBlock : SaveBlocks)

1217}

1218

1219

1220void PEIImpl::insertZeroCallUsedRegs(MachineFunction &MF) {

1222

1223 if (.hasFnAttribute("zero-call-used-regs"))

1224 return;

1225

1226 using namespace ZeroCallUsedRegs;

1227

1229 StringSwitch(

1230 F.getFnAttribute("zero-call-used-regs").getValueAsString())

1231 .Case("skip", ZeroCallUsedRegsKind::Skip)

1232 .Case("used-gpr-arg", ZeroCallUsedRegsKind::UsedGPRArg)

1233 .Case("used-gpr", ZeroCallUsedRegsKind::UsedGPR)

1234 .Case("used-arg", ZeroCallUsedRegsKind::UsedArg)

1235 .Case("used", ZeroCallUsedRegsKind::Used)

1236 .Case("all-gpr-arg", ZeroCallUsedRegsKind::AllGPRArg)

1237 .Case("all-gpr", ZeroCallUsedRegsKind::AllGPR)

1238 .Case("all-arg", ZeroCallUsedRegsKind::AllArg)

1239 .Case("all", ZeroCallUsedRegsKind::All);

1240

1241 if (ZeroRegsKind == ZeroCallUsedRegsKind::Skip)

1242 return;

1243

1244 const bool OnlyGPR = static_cast<unsigned>(ZeroRegsKind) & ONLY_GPR;

1245 const bool OnlyUsed = static_cast<unsigned>(ZeroRegsKind) & ONLY_USED;

1246 const bool OnlyArg = static_cast<unsigned>(ZeroRegsKind) & ONLY_ARG;

1247

1249 const BitVector AllocatableSet(TRI.getAllocatableSet(MF));

1250

1251

1252 BitVector UsedRegs(TRI.getNumRegs());

1253 if (OnlyUsed)

1254 for (const MachineBasicBlock &MBB : MF)

1255 for (const MachineInstr &MI : MBB) {

1256

1257 if (MI.isDebugInstr())

1258 continue;

1259

1260 for (const MachineOperand &MO : MI.operands()) {

1261 if (!MO.isReg())

1262 continue;

1263

1264 MCRegister Reg = MO.getReg();

1265 if (AllocatableSet[Reg.id()] && !MO.isImplicit() &&

1266 (MO.isDef() || MO.isUse()))

1267 UsedRegs.set(Reg.id());

1268 }

1269 }

1270

1271

1272 BitVector LiveIns(TRI.getNumRegs());

1273 for (const MachineBasicBlock::RegisterMaskPair &LI : MF.front().liveins())

1274 LiveIns.set(LI.PhysReg);

1275

1276 BitVector RegsToZero(TRI.getNumRegs());

1277 for (MCRegister Reg : AllocatableSet.set_bits()) {

1278

1279 if (TRI.isFixedRegister(MF, Reg))

1280 continue;

1281

1282

1283 if (OnlyGPR && TRI .isGeneralPurposeRegister(MF, Reg))

1284 continue;

1285

1286

1287 if (OnlyUsed && !UsedRegs[Reg.id()])

1288 continue;

1289

1290

1291 if (OnlyArg) {

1292 if (OnlyUsed) {

1293 if (!LiveIns[Reg.id()])

1294 continue;

1295 } else if ( TRI .isArgumentRegister(MF, Reg)) {

1296 continue;

1297 }

1298 }

1299

1300 RegsToZero.set(Reg.id());

1301 }

1302

1303

1304 for (const MachineBasicBlock &MBB : MF)

1306 if (.isReturn())

1307 continue;

1308

1309 for (const auto &MO : MI.operands()) {

1310 if (!MO.isReg())

1311 continue;

1312

1313 MCRegister Reg = MO.getReg();

1314 if ( Reg )

1315 continue;

1316

1317

1318

1319 for (MCRegUnit Unit : TRI.regunits(Reg))

1320 RegsToZero.reset(static_cast<unsigned>(Unit));

1321

1322 for (MCPhysReg SReg : TRI.sub_and_superregs_inclusive(Reg))

1323 RegsToZero.reset(SReg);

1324 }

1325 }

1326

1327

1328

1329 for (const MachineBasicBlock &MBB : MF) {

1331 continue;

1332

1335 ++I) {

1336 for (const MachineOperand &MO : I->operands()) {

1337 if (!MO.isReg())

1338 continue;

1339

1340 MCRegister Reg = MO.getReg();

1341 if ( Reg )

1342 continue;

1343

1345 RegsToZero.reset(Reg);

1346 }

1347 }

1348 }

1349

1350

1351 for (const MCPhysReg *CSRegs = TRI.getCalleeSavedRegs(&MF);

1352 MCPhysReg CSReg = *CSRegs; ++CSRegs)

1353 for (MCRegister Reg : TRI.sub_and_superregs_inclusive(CSReg))

1354 RegsToZero.reset(Reg.id());

1355

1356 const TargetFrameLowering &TFI = *MF.getSubtarget().getFrameLowering();

1357 for (MachineBasicBlock &MBB : MF)

1360}

1361

1362

1363

1364void PEIImpl::replaceFrameIndicesBackward(MachineFunction &MF) {

1366

1367 for (auto &MBB : MF) {

1368 int SPAdj = 0;

1370

1371

1373 return Succ->getCallFrameSize() ==

1374 (*MBB.succ_begin())->getCallFrameSize();

1375 }));

1376 const MachineBasicBlock &FirstSucc = **MBB.succ_begin();

1379 SPAdj = -SPAdj;

1380 }

1381

1382 replaceFrameIndicesBackward(&MBB, MF, SPAdj);

1383

1384

1385

1387 }

1388}

1389

1390

1391

1392void PEIImpl::replaceFrameIndices(MachineFunction &MF) {

1394

1395 for (auto &MBB : MF) {

1398 SPAdj = -SPAdj;

1399

1400 replaceFrameIndices(&MBB, MF, SPAdj);

1401

1402

1403

1405 }

1406}

1407

1408bool PEIImpl::replaceFrameIndexDebugInstr(MachineFunction &MF, MachineInstr &MI,

1409 unsigned OpIdx, int SPAdj) {

1412 if (MI.isDebugValue()) {

1413

1414 MachineOperand &Op = MI.getOperand(OpIdx);

1416 "Frame indices can only appear as a debug operand in a DBG_VALUE*"

1417 " machine instruction");

1419 unsigned FrameIdx = Op.getIndex();

1421

1423 Op.ChangeToRegister(Reg, false );

1424

1425 const DIExpression *DIExpr = MI.getDebugExpression();

1426

1427

1428

1429

1430

1431

1432

1433 if (MI.isNonListDebugValue()) {

1435 if (.isIndirectDebugValue() && !DIExpr->isComplex())

1437

1438

1439

1440

1441

1442 if (MI.isIndirectDebugValue() && DIExpr->isImplicit()) {

1444 bool WithStackValue = true;

1446

1447 MI.getDebugOffset().ChangeToRegister(0, false);

1448 }

1449 DIExpr = TRI.prependOffsetExpression(DIExpr, PrependFlags, Offset);

1450 } else {

1451

1452

1453

1454 unsigned DebugOpIndex = MI.getDebugOperandIndex(&Op);

1458 }

1459 MI.getDebugExpressionOp().setMetadata(DIExpr);

1460 return true;

1461 }

1462

1463 if (MI.isDebugPHI()) {

1464

1465 return true;

1466 }

1467

1468

1469

1470

1471

1472

1473 if (MI.getOpcode() == TargetOpcode::STATEPOINT) {

1475 "Frame indices can only appear as the first operand of a "

1476 "DBG_VALUE machine instruction");

1478 MachineOperand &Offset = MI.getOperand(OpIdx + 1);

1480 MF, MI.getOperand(OpIdx).getIndex(), Reg, false);

1482 "Frame offsets with a scalable component are not supported");

1484 MI.getOperand(OpIdx).ChangeToRegister(Reg, false );

1485 return true;

1486 }

1487 return false;

1488}

1489

1490void PEIImpl::replaceFrameIndicesBackward(MachineBasicBlock *BB,

1491 MachineFunction &MF, int &SPAdj) {

1493 "getRegisterInfo() must be implemented!");

1494

1498

1499 RegScavenger *LocalRS = FrameIndexEliminationScavenging ? RS : nullptr;

1500 if (LocalRS)

1502

1504 MachineInstr &MI = *std::prev(I);

1505

1509 continue;

1510 }

1511

1512

1513 if (LocalRS)

1515

1516 bool RemovedMI = false;

1517 for (const auto &[Idx, Op] : enumerate(MI.operands())) {

1518 if (.isFI())

1519 continue;

1520

1521 if (replaceFrameIndexDebugInstr(MF, MI, Idx, SPAdj))

1522 continue;

1523

1524

1525 RemovedMI = TRI.eliminateFrameIndex(MI, SPAdj, Idx, LocalRS);

1526 if (RemovedMI)

1527 break;

1528 }

1529

1530 if (!RemovedMI)

1531 --I;

1532 }

1533}

1534

1535void PEIImpl::replaceFrameIndices(MachineBasicBlock *BB, MachineFunction &MF,

1536 int &SPAdj) {

1538 "getRegisterInfo() must be implemented!");

1542

1543 bool InsideCallSequence = false;

1544

1550 continue;

1551 }

1552

1553 MachineInstr &MI = *I;

1554 bool DoIncr = true;

1555 bool DidFinishLoop = true;

1556 for (unsigned i = 0, e = MI.getNumOperands(); i != e; ++i) {

1557 if (.getOperand(i).isFI())

1558 continue;

1559

1560 if (replaceFrameIndexDebugInstr(MF, MI, i, SPAdj))

1561 continue;

1562

1563

1564

1565

1566

1567

1568

1569

1570 bool AtBeginning = (I == BB->begin());

1571 if (!AtBeginning) --I;

1572

1573

1574

1575

1576 TRI.eliminateFrameIndex(MI, SPAdj, i, RS);

1577

1578

1579 if (AtBeginning) {

1581 DoIncr = false;

1582 }

1583

1584 DidFinishLoop = false;

1585 break;

1586 }

1587

1588

1589

1590

1591

1592

1593

1594

1595 if (DidFinishLoop && InsideCallSequence)

1597

1598 if (DoIncr && I != BB->end())

1599 ++I;

1600 }

1601}

unsigned const MachineRegisterInfo * MRI

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

const TargetInstrInfo & TII

MachineBasicBlock MachineBasicBlock::iterator MBBI

This file contains the simple types necessary to represent the attributes associated with functions a...

This file implements the BitVector class.

static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")

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

Promote Memory to Register

MachineInstr unsigned OpIdx

#define INITIALIZE_PASS_DEPENDENCY(depName)

#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)

#define INITIALIZE_PASS_BEGIN(passName, arg, name, cfg, analysis)

static void insertCSRRestores(MachineBasicBlock &RestoreBlock, std::vector< CalleeSavedInfo > &CSI)

Insert restore code for the callee-saved registers used in the function.

Definition PrologEpilogInserter.cpp:641

SmallVector< MachineBasicBlock *, 4 > MBBVector

Definition PrologEpilogInserter.cpp:72

static bool scavengeStackSlot(MachineFrameInfo &MFI, int FrameIdx, bool StackGrowsDown, Align MaxAlign, BitVector &StackBytesFree)

Assign frame object to an unused portion of the stack in the fixed stack object range.

Definition PrologEpilogInserter.cpp:788

static void insertCSRSaves(MachineBasicBlock &SaveBlock, ArrayRef< CalleeSavedInfo > CSI)

Insert spill code for the callee-saved registers used in the function.

Definition PrologEpilogInserter.cpp:625

static void AssignProtectedObjSet(const StackObjSet &UnassignedObjs, SmallSet< int, 16 > &ProtectedObjs, MachineFrameInfo &MFI, bool StackGrowsDown, int64_t &Offset, Align &MaxAlign)

AssignProtectedObjSet - Helper function to assign large stack objects (i.e., those required to be clo...

Definition PrologEpilogInserter.cpp:848

static void AdjustStackOffset(MachineFrameInfo &MFI, int FrameIdx, bool StackGrowsDown, int64_t &Offset, Align &MaxAlign)

AdjustStackOffset - Helper function used to adjust the stack frame offset.

Definition PrologEpilogInserter.cpp:714

SmallDenseMap< MachineBasicBlock *, SmallVector< MachineInstr *, 4 >, 4 > SavedDbgValuesMap

Definition PrologEpilogInserter.cpp:175

static void computeFreeStackSlots(MachineFrameInfo &MFI, bool StackGrowsDown, int64_t FixedCSEnd, BitVector &StackBytesFree)

Compute which bytes of fixed and callee-save stack area are unused and keep track of them in StackByt...

Definition PrologEpilogInserter.cpp:744

static void updateLiveness(MachineFunction &MF)

Helper function to update the liveness information for the callee-saved registers.

Definition PrologEpilogInserter.cpp:544

SmallSetVector< int, 8 > StackObjSet

StackObjSet - A set of stack object indexes.

Definition PrologEpilogInserter.cpp:173

static void stashEntryDbgValues(MachineBasicBlock &MBB, SavedDbgValuesMap &EntryDbgValues)

Stash DBG_VALUEs that describe parameters and which are placed at the start of the block.

Definition PrologEpilogInserter.cpp:181

static void assignCalleeSavedSpillSlots(MachineFunction &F, const BitVector &SavedRegs)

Definition PrologEpilogInserter.cpp:453

This file declares the machine register scavenger class.

This file implements a set that has insertion order iteration characteristics.

This file defines the SmallPtrSet class.

This file defines the SmallSet class.

This file defines the SmallVector class.

This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...

#define STATISTIC(VARNAME, DESC)

PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)

Get the result of an analysis pass for a given IR unit.

Represent the analysis usage information of a pass.

AnalysisUsage & addRequired()

AnalysisUsage & addPreserved()

Add the specified Pass class to the set of analyses preserved by this pass.

LLVM_ABI void setPreservesCFG()

This function should be called by the pass, iff they do not:

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

LLVM_ABI StringRef getValueAsString() const

Return the attribute's value as a string.

bool test(unsigned Idx) const

int find_first() const

find_first - Returns the index of the first set bit, -1 if none of the bits are set.

void resize(unsigned N, bool t=false)

resize - Grow or shrink the bitvector.

void clear()

clear - Removes all bits from the bitvector.

int find_next(unsigned Prev) const

find_next - Returns the index of the next set bit following the "Prev" bit.

bool none() const

none - Returns true if none of the bits are set.

size_type size() const

size - Returns the number of bits in this bitvector.

bool empty() const

empty - Tests whether there are no bits in this bitvector.

Represents analyses that only rely on functions' control flow.

The CalleeSavedInfo class tracks the information need to locate where a callee saved register is in t...

LLVM_ABI bool isImplicit() const

Return whether this is an implicit location description.

static bool fragmentsOverlap(const FragmentInfo &A, const FragmentInfo &B)

Check if fragments overlap between a pair of FragmentInfos.

static LLVM_ABI DIExpression * appendOpsToArg(const DIExpression *Expr, ArrayRef< uint64_t > Ops, unsigned ArgNo, bool StackValue=false)

Create a copy of Expr by appending the given list of Ops to each instance of the operand DW_OP_LLVM_a...

LLVM_ABI bool isComplex() const

Return whether the location is computed on the expression stack, meaning it cannot be a simple regist...

static LLVM_ABI DIExpression * prependOpcodes(const DIExpression *Expr, SmallVectorImpl< uint64_t > &Ops, bool StackValue=false, bool EntryValue=false)

Prepend DIExpr with the given opcodes and optionally turn it into a stack value.

Attribute getFnAttribute(Attribute::AttrKind Kind) const

Return the attribute for the given attribute kind.

DISubprogram * getSubprogram() const

Get the attached subprogram.

CallingConv::ID getCallingConv() const

getCallingConv()/setCallingConv(CC) - These method get and set the calling convention of this functio...

bool hasFnAttribute(Attribute::AttrKind Kind) const

Return true if the function has the attribute.

Wrapper class representing physical registers. Should be passed by value.

MachineInstrBundleIterator< const MachineInstr > const_iterator

void setCallFrameSize(unsigned N)

Set the call frame size on entry to this basic block.

succ_iterator succ_begin()

bool isEHFuncletEntry() const

Returns true if this is the entry block of an EH funclet.

LLVM_ABI iterator getFirstTerminator()

Returns an iterator to the first terminator instruction of this basic block.

bool isReturnBlock() const

Convenience function that returns true if the block ends in a return instruction.

const MachineFunction * getParent() const

Return the MachineFunction containing this basic block.

iterator_range< iterator > terminators()

unsigned getCallFrameSize() const

Return the call frame size on entry to this basic block.

iterator_range< succ_iterator > successors()

MachineInstrBundleIterator< MachineInstr > iterator

Analysis pass which computes a MachineDominatorTree.

The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted.

bool hasVarSizedObjects() const

This method may be called any time after instruction selection is complete to determine if the stack ...

SSPLayoutKind getObjectSSPLayout(int ObjectIdx) const

bool isObjectPreAllocated(int ObjectIdx) const

Return true if the object was pre-allocated into the local block.

LLVM_ABI void computeMaxCallFrameSize(MachineFunction &MF, std::vector< MachineBasicBlock::iterator > *FrameSDOps=nullptr)

Computes the maximum size of a callframe.

uint64_t getStackSize() const

Return the number of bytes that must be allocated to hold all of the fixed size frame objects.

bool adjustsStack() const

Return true if this function adjusts the stack – e.g., when calling another function.

LLVM_ABI int CreateStackObject(uint64_t Size, Align Alignment, bool isSpillSlot, const AllocaInst *Alloca=nullptr, uint8_t ID=0)

Create a new statically sized stack object, returning a nonnegative identifier to represent it.

int64_t getLocalFrameObjectCount() const

Return the number of objects allocated into the local object block.

bool hasCalls() const

Return true if the current function has any function calls.

Align getMaxAlign() const

Return the alignment in bytes that this function must be aligned to, which is greater than the defaul...

Align getLocalFrameMaxAlign() const

Return the required alignment of the local object blob.

void setObjectOffset(int ObjectIdx, int64_t SPOffset)

Set the stack frame offset of the specified object.

@ SSPLK_SmallArray

Array or nested array < SSP-buffer-size.

@ SSPLK_LargeArray

Array or nested array >= SSP-buffer-size.

@ SSPLK_AddrOf

The address of this allocation is exposed and triggered protection.

@ SSPLK_None

Did not trigger a stack protector.

bool isCalleeSavedObjectIndex(int ObjectIdx) const

void clearRestorePoints()

std::pair< int, int64_t > getLocalFrameObjectMap(int i) const

Get the local offset mapping for a for an object.

uint64_t getMaxCallFrameSize() const

Return the maximum size of a call frame that must be allocated for an outgoing function call.

void setSavePoints(SaveRestorePoints NewSavePoints)

bool getUseLocalStackAllocationBlock() const

Get whether the local allocation blob should be allocated together or let PEI allocate the locals in ...

int getStackProtectorIndex() const

Return the index for the stack protector object.

void setCalleeSavedInfoValid(bool v)

Align getObjectAlign(int ObjectIdx) const

Return the alignment of the specified stack object.

bool isSpillSlotObjectIndex(int ObjectIdx) const

Returns true if the specified index corresponds to a spill slot.

int64_t getObjectSize(int ObjectIdx) const

Return the size of the specified object.

bool isMaxCallFrameSizeComputed() const

int64_t getLocalFrameSize() const

Get the size of the local object blob.

const std::vector< CalleeSavedInfo > & getCalleeSavedInfo() const

Returns a reference to call saved info vector for the current function.

void setCalleeSavedInfo(std::vector< CalleeSavedInfo > CSI)

Used by prolog/epilog inserter to set the function's callee saved information.

bool isVariableSizedObjectIndex(int ObjectIdx) const

Returns true if the specified index corresponds to a variable sized object.

uint64_t getUnsafeStackSize() const

int getObjectIndexEnd() const

Return one past the maximum frame object index.

bool hasStackProtectorIndex() const

void setRestorePoints(SaveRestorePoints NewRestorePoints)

LLVM_ABI int CreateFixedSpillStackObject(uint64_t Size, int64_t SPOffset, bool IsImmutable=false)

Create a spill slot at a fixed location on the stack.

uint8_t getStackID(int ObjectIdx) const

const SaveRestorePoints & getRestorePoints() const

void setIsCalleeSavedObjectIndex(int ObjectIdx, bool IsCalleeSaved)

int64_t getObjectOffset(int ObjectIdx) const

Return the assigned stack offset of the specified object from the incoming stack pointer.

void setStackSize(uint64_t Size)

Set the size of the stack.

int getObjectIndexBegin() const

Return the minimum frame object index.

const SaveRestorePoints & getSavePoints() const

bool isDeadObjectIndex(int ObjectIdx) const

Returns true if the specified index corresponds to a dead object.

MachineFunctionPass - This class adapts the FunctionPass interface to allow convenient creation of pa...

void getAnalysisUsage(AnalysisUsage &AU) const override

getAnalysisUsage - Subclasses that override getAnalysisUsage must call this.

const WinEHFuncInfo * getWinEHFuncInfo() const

getWinEHFuncInfo - Return information about how the current function uses Windows exception handling.

const TargetSubtargetInfo & getSubtarget() const

getSubtarget - Return the subtarget for which this machine code is being compiled.

MachineFrameInfo & getFrameInfo()

getFrameInfo - Return the frame info object for the current function.

MachineRegisterInfo & getRegInfo()

getRegInfo - Return information about the registers currently in use.

Function & getFunction()

Return the LLVM function that this machine code represents.

bool shouldSplitStack() const

Should we be emitting segmented stack stuff for the function.

const MachineFunctionProperties & getProperties() const

Get the function properties.

const MachineBasicBlock & front() const

const TargetMachine & getTarget() const

getTarget - Return the target machine this machine code is compiled with

Representation of each machine instruction.

Analysis pass that exposes the MachineLoopInfo for a machine function.

MachineOperand class - Representation of each machine instruction operand.

MachineRegisterInfo - Keep track of information for virtual and physical registers,...

static LLVM_ABI PassRegistry * getPassRegistry()

getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...

static PreservedAnalyses all()

Construct a special preserved set that preserves all passes.

PreservedAnalyses & preserveSet()

Mark an analysis set as preserved.

PreservedAnalyses run(MachineFunction &MF, MachineFunctionAnalysisManager &MFAM)

Definition PrologEpilogInserter.cpp:363

void enterBasicBlockEnd(MachineBasicBlock &MBB)

Start tracking liveness from the end of basic block MBB.

void backward()

Update internal register state and move MBB iterator backwards.

void getScavengingFrameIndices(SmallVectorImpl< int > &A) const

Get an array of scavenging frame indices.

bool isScavengingFrameIndex(int FI) const

Query whether a frame index is a scavenging frame index.

constexpr unsigned id() const

bool empty() const

Determine if the SetVector is empty or not.

bool insert(const value_type &X)

Insert a new element into the SetVector.

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

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

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

A SetVector that performs no allocations if smaller than a certain size.

SmallSet - This maintains a set of unique values, optimizing for the case when the set is small (less...

size_type count(const T &V) const

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

std::pair< const_iterator, bool > insert(const T &V)

insert - Insert an element into the set if it isn't already there.

void push_back(const T &Elt)

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

static StackOffset getScalable(int64_t Scalable)

static StackOffset getFixed(int64_t Fixed)

bool getAsInteger(unsigned Radix, T &Result) const

Parse the current string as an integer of the specified radix.

Information about stack frame layout on the target.

virtual void spillFPBP(MachineFunction &MF) const

If frame pointer or base pointer is clobbered by an instruction, we should spill/restore it around th...

virtual void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const =0

virtual const SpillSlot * getCalleeSavedSpillSlots(unsigned &NumEntries) const

getCalleeSavedSpillSlots - This method returns a pointer to an array of pairs, that contains an entry...

virtual bool hasReservedCallFrame(const MachineFunction &MF) const

hasReservedCallFrame - Under normal circumstances, when a frame pointer is not required,...

virtual bool enableStackSlotScavenging(const MachineFunction &MF) const

Returns true if the stack slot holes in the fixed and callee-save stack area should be used when allo...

virtual bool allocateScavengingFrameIndexesNearIncomingSP(const MachineFunction &MF) const

Control the placement of special register scavenging spill slots when allocating a stack frame.

Align getTransientStackAlign() const

getTransientStackAlignment - This method returns the number of bytes to which the stack pointer must ...

virtual void determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs, RegScavenger *RS=nullptr) const

This method determines which of the registers reported by TargetRegisterInfo::getCalleeSavedRegs() sh...

virtual uint64_t getStackThreshold() const

getStackThreshold - Return the maximum stack size

virtual void processFunctionBeforeFrameFinalized(MachineFunction &MF, RegScavenger *RS=nullptr) const

processFunctionBeforeFrameFinalized - This method is called immediately before the specified function...

virtual void inlineStackProbe(MachineFunction &MF, MachineBasicBlock &PrologueMBB) const

Replace a StackProbe stub (if any) with the actual probe code inline.

void restoreCalleeSavedRegister(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI, const CalleeSavedInfo &CS, const TargetInstrInfo *TII, const TargetRegisterInfo *TRI) const

void spillCalleeSavedRegister(MachineBasicBlock &SaveBlock, MachineBasicBlock::iterator MI, const CalleeSavedInfo &CS, const TargetInstrInfo *TII, const TargetRegisterInfo *TRI) const

spillCalleeSavedRegister - Default implementation for spilling a single callee saved register.

virtual void orderFrameObjects(const MachineFunction &MF, SmallVectorImpl< int > &objectsToAllocate) const

Order the symbols in the local stack frame.

virtual void adjustForHiPEPrologue(MachineFunction &MF, MachineBasicBlock &PrologueMBB) const

Adjust the prologue to add Erlang Run-Time System (ERTS) specific code in the assembly prologue to ex...

virtual bool spillCalleeSavedRegisters(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI, ArrayRef< CalleeSavedInfo > CSI, const TargetRegisterInfo *TRI) const

spillCalleeSavedRegisters - Issues instruction(s) to spill all callee saved registers and returns tru...

int getOffsetOfLocalArea() const

getOffsetOfLocalArea - This method returns the offset of the local area from the stack pointer on ent...

virtual bool needsFrameIndexResolution(const MachineFunction &MF) const

virtual MachineBasicBlock::iterator eliminateCallFramePseudoInstr(MachineFunction &MF, MachineBasicBlock &MBB, MachineBasicBlock::iterator MI) const

This method is called during prolog/epilog code insertion to eliminate call frame setup and destroy p...

Align getStackAlign() const

getStackAlignment - This method returns the number of bytes to which the stack pointer must be aligne...

virtual bool assignCalleeSavedSpillSlots(MachineFunction &MF, const TargetRegisterInfo *TRI, std::vector< CalleeSavedInfo > &CSI) const

assignCalleeSavedSpillSlots - Allows target to override spill slot assignment logic.

virtual void processFunctionBeforeFrameIndicesReplaced(MachineFunction &MF, RegScavenger *RS=nullptr) const

processFunctionBeforeFrameIndicesReplaced - This method is called immediately before MO_FrameIndex op...

virtual StackOffset getFrameIndexReferencePreferSP(const MachineFunction &MF, int FI, Register &FrameReg, bool IgnoreSPUpdates) const

Same as getFrameIndexReference, except that the stack pointer (as opposed to the frame pointer) will ...

StackDirection getStackGrowthDirection() const

getStackGrowthDirection - Return the direction the stack grows

virtual void adjustForSegmentedStacks(MachineFunction &MF, MachineBasicBlock &PrologueMBB) const

Adjust the prologue to have the function use segmented stacks.

int alignSPAdjust(int SPAdj) const

alignSPAdjust - This method aligns the stack adjustment to the correct alignment.

virtual bool canSimplifyCallFramePseudos(const MachineFunction &MF) const

canSimplifyCallFramePseudos - When possible, it's best to simplify the call frame pseudo ops before d...

virtual void emitZeroCallUsedRegs(BitVector RegsToZero, MachineBasicBlock &MBB) const

emitZeroCallUsedRegs - Zeros out call used registers.

virtual void emitRemarks(const MachineFunction &MF, MachineOptimizationRemarkEmitter *ORE) const

This method is called at the end of prolog/epilog code insertion, so targets can emit remarks based o...

virtual bool targetHandlesStackFrameRounding() const

targetHandlesStackFrameRounding - Returns true if the target is responsible for rounding up the stack...

virtual void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const =0

emitProlog/emitEpilog - These methods insert prolog and epilog code into the function.

virtual bool restoreCalleeSavedRegisters(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI, MutableArrayRef< CalleeSavedInfo > CSI, const TargetRegisterInfo *TRI) const

restoreCalleeSavedRegisters - Issues instruction(s) to restore all callee saved registers and returns...

virtual StackOffset getFrameIndexReference(const MachineFunction &MF, int FI, Register &FrameReg) const

getFrameIndexReference - This method should return the base register and offset used to reference a f...

TargetInstrInfo - Interface to description of machine instruction set.

virtual int getSPAdjust(const MachineInstr &MI) const

Returns the actual stack pointer adjustment made by an instruction as part of a call sequence.

bool isFrameInstr(const MachineInstr &I) const

Returns true if the argument is a frame pseudo instruction.

bool isFrameSetup(const MachineInstr &I) const

Returns true if the argument is a frame setup pseudo instruction.

CodeGenOptLevel getOptLevel() const

Returns the optimization level: None, Less, Default, or Aggressive.

virtual bool usesPhysRegsForValues() const

True if the target uses physical regs (as nearly all targets do).

unsigned StackSymbolOrdering

StackSymbolOrdering - When true, this will allow CodeGen to order the local stack symbols (for code s...

TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...

bool hasStackRealignment(const MachineFunction &MF) const

True if stack realignment is required and still possible.

virtual const TargetFrameLowering * getFrameLowering() const

virtual const TargetInstrInfo * getInstrInfo() const

virtual const TargetRegisterInfo * getRegisterInfo() const =0

Return the target's register information.

LLVM_ABI StringRef getName() const

Return a constant reference to the value's name.

#define llvm_unreachable(msg)

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

constexpr char Align[]

Key for Kernel::Arg::Metadata::mAlign.

PointerTypeMap run(const Module &M)

Compute the PointerTypeMap for the module M.

DiagnosticInfoOptimizationBase::Argument NV

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,...

testing::Matcher< const detail::ErrorHolder & > Failed()

void scavengeFrameVirtualRegs(MachineFunction &MF, RegScavenger &RS)

Replaces all frame index virtual registers with physical registers.

LLVM_ABI MachineFunctionPass * createPrologEpilogInserterPass()

Definition PrologEpilogInserter.cpp:157

AnalysisManager< MachineFunction > MachineFunctionAnalysisManager

LLVM_ABI char & PrologEpilogCodeInserterID

PrologEpilogCodeInserter - This pass inserts prolog and epilog code, and eliminates abstract frame re...

Definition PrologEpilogInserter.cpp:146

LLVM_ABI PreservedAnalyses getMachineFunctionPassPreservedAnalyses()

Returns the minimum set of Analyses that all machine function passes must preserve.

bool any_of(R &&range, UnaryPredicate P)

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

auto formatv(bool Validate, const char *Fmt, Ts &&...Vals)

auto reverse(ContainerTy &&C)

DenseMap< MachineBasicBlock *, std::vector< CalleeSavedInfo > > SaveRestorePoints

LLVM_ABI raw_ostream & dbgs()

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

bool none_of(R &&Range, UnaryPredicate P)

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

class LLVM_GSL_OWNER SmallVector

Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference s...

uint16_t MCPhysReg

An unsigned integer type large enough to represent all physical registers, but not necessarily virtua...

uint64_t alignTo(uint64_t Size, Align A)

Returns a multiple of A needed to store Size bytes.

DWARFExpression::Operation Op

LLVM_ABI void initializePEILegacyPass(PassRegistry &)

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