MachineFunction.cpp Source File (original) (raw)

43#include "llvm/Config/llvm-config.h"

69#include

70#include

71#include

72#include

73#include

74#include

75#include

76#include

80using namespace llvm;

82#define DEBUG_TYPE "codegen"

85 "align-all-functions",

86 cl::desc("Force the alignment of all functions in log2 format (e.g. 4 "

87 "means align on 16B boundaries)."),

94 switch(Prop) {

95 case P::FailedISel: return "FailedISel";

96 case P::IsSSA: return "IsSSA";

97 case P::Legalized: return "Legalized";

98 case P::NoPHIs: return "NoPHIs";

99 case P::NoVRegs: return "NoVRegs";

100 case P::RegBankSelected: return "RegBankSelected";

101 case P::Selected: return "Selected";

102 case P::TracksLiveness: return "TracksLiveness";

103 case P::TiedOpsRewritten: return "TiedOpsRewritten";

104 case P::FailsVerification: return "FailsVerification";

105 case P::FailedRegAlloc: return "FailedRegAlloc";

106 case P::TracksDebugUserValues: return "TracksDebugUserValues";

107 }

108

110}

111

113 if (.hasFnAttribute(Attribute::SafeStack))

114 return;

115

116 auto *Existing =

118

119 if (!Existing || Existing->getNumOperands() != 2)

120 return;

121

122 auto *MetadataName = "unsafe-stack-size";

123 if (auto &N = Existing->getOperand(0)) {

124 if (N.equalsStr(MetadataName)) {

125 if (auto &Op = Existing->getOperand(1)) {

128 }

129 }

130 }

131}

132

133

134void MachineFunction::Delegate::anchor() {}

135

137 const char *Separator = "";

139 if (!Properties[I])

140 continue;

141 OS << Separator << getPropertyName(static_cast(I));

142 Separator = ", ";

143 }

144}

145

146

147

148

149

150

152

154 MBB->getParent()->deleteMachineBasicBlock(MBB);

155}

156

159 if (auto MA = F.getFnStackAlign())

160 return *MA;

162}

163

166 unsigned FunctionNum)

167 : F(F), Target(Target), STI(STI), Ctx(Ctx) {

168 FunctionNumber = FunctionNum;

169 init();

170}

171

172void MachineFunction::handleInsertion(MachineInstr &MI) {

173 if (TheDelegate)

175}

176

177void MachineFunction::handleRemoval(MachineInstr &MI) {

178 if (TheDelegate)

180}

181

184 if (TheDelegate)

185 TheDelegate->MF_HandleChangeDesc(MI, TID);

186}

187

188void MachineFunction::init() {

189

190 Properties.setIsSSA();

191 Properties.setTracksLiveness();

193

194 MFInfo = nullptr;

195

196

197

199 .hasFnAttribute("no-realign-stack");

200 bool ForceRealignSP = F.hasFnAttribute(Attribute::StackAlignment) ||

201 F.hasFnAttribute("stackrealign");

204 ForceRealignSP && CanRealignSP);

205

207

208 if (F.hasFnAttribute(Attribute::StackAlignment))

210

213

214

215 if (.hasOptSize())

216 Alignment = std::max(Alignment,

218

219

220

221

222

223 if (F.hasMetadata(LLVMContext::MD_func_sanitize) ||

224 F.getMetadata(LLVMContext::MD_kcfi_type))

225 Alignment = std::max(Alignment, Align(4));

226

229

230 JumpTableInfo = nullptr;

231

233 F.hasPersonalityFn() ? F.getPersonalityFn() : nullptr))) {

235 }

236

238 F.hasPersonalityFn() ? F.getPersonalityFn() : nullptr))) {

240 }

241

243 "Can't create a MachineFunction using a Module with a "

244 "Target-incompatible DataLayout attached\n");

245

246 PSVManager = std::make_unique(getTarget());

247}

248

251 assert(!MFInfo && "MachineFunctionInfo already set");

252 MFInfo = Target.createMachineFunctionInfo(Allocator, F, &STI);

253}

254

258

259void MachineFunction::clear() {

260 Properties.reset();

261

262

263

264 if (JumpTableInfo) {

265 JumpTableInfo->~MachineJumpTableInfo();

266 Allocator.Deallocate(JumpTableInfo);

267 JumpTableInfo = nullptr;

268 }

269

270

271

272

273

275 I->Insts.clearAndLeakNodesUnsafely();

276 MBBNumbering.clear();

277

278 InstructionRecycler.clear(Allocator);

280 BasicBlockRecycler.clear(Allocator);

281 CodeViewAnnotations.clear();

284 RegInfo->~MachineRegisterInfo();

286 }

287 if (MFInfo) {

288 MFInfo->~MachineFunctionInfo();

289 Allocator.Deallocate(MFInfo);

290 }

291

292 FrameInfo->~MachineFrameInfo();

293 Allocator.Deallocate(FrameInfo);

294

295 ConstantPool->~MachineConstantPool();

296 Allocator.Deallocate(ConstantPool);

297

298 if (WinEHInfo) {

299 WinEHInfo->~WinEHFuncInfo();

300 Allocator.Deallocate(WinEHInfo);

301 }

302

303 if (WasmEHInfo) {

304 WasmEHInfo->~WasmEHFuncInfo();

305 Allocator.Deallocate(WasmEHInfo);

306 }

307}

308

310 return F.getDataLayout();

311}

312

313

314

317 if (JumpTableInfo) return JumpTableInfo;

318

319 JumpTableInfo = new (Allocator)

321 return JumpTableInfo;

322}

323

325 return F.getDenormalMode(FPType);

326}

327

328

332

333[[nodiscard]] unsigned

335 FrameInstructions.push_back(Inst);

336 return FrameInstructions.size() - 1;

337}

338

339

340

341

342

344 if (empty()) { MBBNumbering.clear(); return; }

346 if (MBB == nullptr)

348 else

349 MBBI = MBB->getIterator();

350

351

352 unsigned BlockNo = 0;

354 BlockNo = std::prev(MBBI)->getNumber() + 1;

355

356 for (; MBBI != E; ++MBBI, ++BlockNo) {

357 if (MBBI->getNumber() != (int)BlockNo) {

358

359 if (MBBI->getNumber() != -1) {

361 "MBB number mismatch!");

362 MBBNumbering[MBBI->getNumber()] = nullptr;

363 }

364

365

366 if (MBBNumbering[BlockNo])

367 MBBNumbering[BlockNo]->setNumber(-1);

368

369 MBBNumbering[BlockNo] = &*MBBI;

370 MBBI->setNumber(BlockNo);

371 }

372 }

373

374

375

376 assert(BlockNo <= MBBNumbering.size() && "Mismatch!");

377 MBBNumbering.resize(BlockNo);

378 MBBNumberingEpoch++;

379}

380

385

386

388

390 const Align Alignment = MBBI->getAlignment();

392

393 for (auto &MI : *MBBI) {

395 }

396

397 int64_t OffsetBB;

398 if (Alignment <= FunctionAlignment) {

400 } else {

401

402

403 OffsetBB = alignTo(Offset, Alignment) + Alignment.value() -

404 FunctionAlignment.value();

405 }

407 }

408

410}

411

412

413

414

419 if (MBBI->getSectionID() == CurrentSectionID)

420 continue;

421 MBBI->setIsBeginSection();

422 std::prev(MBBI)->setIsEndSection();

423 CurrentSectionID = MBBI->getSectionID();

424 }

426}

427

428

431 bool NoImplicit) {

432 return new (InstructionRecycler.Allocate<MachineInstr>(Allocator))

434}

435

436

437

439MachineFunction::CloneMachineInstr(const MachineInstr *Orig) {

442}

443

444MachineInstr &MachineFunction::cloneMachineInstrBundle(

447 MachineInstr *FirstClone = nullptr;

449 while (true) {

450 MachineInstr *Cloned = CloneMachineInstr(&*I);

451 MBB.insert(InsertBefore, Cloned);

452 if (FirstClone == nullptr) {

453 FirstClone = Cloned;

454 } else {

456 }

457

458 if (->isBundledWithSucc())

459 break;

460 ++I;

461 }

462

463

464

467 return *FirstClone;

468}

469

470

471

472

473

474void MachineFunction::deleteMachineInstr(MachineInstr *MI) {

475

476

477

478

479 assert((->isCandidateForAdditionalCallInfo() ||

480 !CallSitesInfo.contains(MI)) &&

481 "Call site info was not updated!");

482

483 assert((->isCandidateForAdditionalCallInfo() ||

484 !CalledGlobalsInfo.contains(MI)) &&

485 "Called globals info was not updated!");

486

487

488 if (MI->Operands)

490

491

492

493 InstructionRecycler.Deallocate(Allocator, MI);

494}

495

496

497

500 std::optional BBID) {

504

505

506 if (Target.Options.BBAddrMap ||

508 MBB->setBBID(BBID.has_value() ? *BBID : UniqueBBID{NextBBID++, 0});

509 return MBB;

510}

511

512

514 assert(MBB->getParent() == this && "MBB parent mismatch!");

515

516 if (JumpTableInfo)

517 JumpTableInfo->RemoveMBBFromJumpTables(MBB);

518 MBB->~MachineBasicBlock();

519 BasicBlockRecycler.Deallocate(Allocator, MBB);

520}

521

528 Size.getValue().getKnownMinValue() != ~UINT64_C(0)) &&

529 "Unexpected an unknown size to be represented using "

530 "LocationSize::beforeOrAfter()");

531 return new (Allocator)

533 Ordering, FailureOrdering);

534}

535

541 return new (Allocator)

542 MachineMemOperand(PtrInfo, f, MemTy, base_alignment, AAInfo, Ranges, SSID,

543 Ordering, FailureOrdering);

544}

545

551 Size.getValue().getKnownMinValue() != ~UINT64_C(0)) &&

552 "Unexpected an unknown size to be represented using "

553 "LocationSize::beforeOrAfter()");

554 return new (Allocator)

558}

559

562 return new (Allocator)

566}

567

572

573

574

578

579

580

585}

586

599

608

613 return MachineInstr::ExtraInfo::create(Allocator, MMOs, PreInstrSymbol,

614 PostInstrSymbol, HeapAllocMarker,

615 PCSections, CFIType, MMRAs, DS);

616}

617

619 char *Dest = Allocator.Allocate<char>(Name.size() + 1);

621 Dest[Name.size()] = 0;

622 return Dest;

623}

624

629 memset(Mask, 0, Size * sizeof(Mask[0]));

630 return Mask;

631}

632

634 int* AllocMask = Allocator.Allocate<int>(Mask.size());

635 copy(Mask, AllocMask);

636 return {AllocMask, Mask.size()};

637}

638

639#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)

643#endif

644

648

650 OS << "# Machine code for function " << getName() << ": ";

652 OS << '\n';

653

654

655 FrameInfo->print(*this, OS);

656

657

658 if (JumpTableInfo)

659 JumpTableInfo->print(OS);

660

661

662 ConstantPool->print(OS);

663

665

666 if (RegInfo && !RegInfo->livein_empty()) {

667 OS << "Function Live Ins: ";

669 I = RegInfo->livein_begin(), E = RegInfo->livein_end(); I != E; ++I) {

671 if (I->second)

673 if (std::next(I) != E)

674 OS << ", ";

675 }

676 OS << '\n';

677 }

678

681 for (const auto &BB : *this) {

682 OS << '\n';

683

684 BB.print(OS, MST, Indexes, true);

685 }

686

687 OS << "\n# End machine code for function " << getName() << ".\n\n";

688}

689

690

692

693

694

695

696

698 F.needsUnwindTableEntry() ||

699 !F.getParent()->debug_compile_units().empty();

700}

701

703

705 return;

706

707 MDNode *CalleeTypeList = CB.getMetadata(LLVMContext::MD_callee_type);

708 if (!CalleeTypeList)

709 return;

710

714

718 ConstantInt::get(Int64Ty, TypeIdVal, false));

719 }

720}

721

722template <>

726

728 return ("CFG for '" + F->getName() + "' function").str();

729 }

730

733 std::string OutStr;

734 {

736

740 OSS << ": " << BB->getName();

741 } else

743 }

744

745 if (OutStr[0] == '\n')

746 OutStr.erase(OutStr.begin());

747

748

749 for (unsigned i = 0; i != OutStr.length(); ++i)

750 if (OutStr[i] == '\n') {

751 OutStr[i] = '\\';

752 OutStr.insert(OutStr.begin() + i + 1, 'l');

753 }

754 return OutStr;

755 }

756};

757

759{

760#ifndef NDEBUG

762#else

763 errs() << "MachineFunction::viewCFG is only available in debug builds on "

764 << "systems with Graphviz or gv!\n";

765#endif

766}

767

769{

770#ifndef NDEBUG

772#else

773 errs() << "MachineFunction::viewCFGOnly is only available in debug builds on "

774 << "systems with Graphviz or gv!\n";

775#endif

776}

777

778

779

783 Register VReg = MRI.getLiveInVirtReg(PReg);

784 if (VReg) {

786 (void)VRegRC;

787

788

789

790

791

794 "Register class mismatch!");

795 return VReg;

796 }

797 VReg = MRI.createVirtualRegister(RC);

798 MRI.addLiveIn(PReg, VReg);

799 return VReg;

800}

801

802

803

804

806 bool isLinkerPrivate) const {

808 assert(JumpTableInfo && "No jump tables");

809 assert(JTI < JumpTableInfo->getJumpTables().size() && "Invalid JTI!");

810

811 StringRef Prefix = isLinkerPrivate ? DL.getLinkerPrivateGlobalPrefix()

812 : DL.getPrivateGlobalPrefix();

816 return Ctx.getOrCreateSymbol(Name);

817}

818

819

822 return Ctx.getOrCreateSymbol(Twine(DL.getPrivateGlobalPrefix()) +

824}

825

826

827

828

831 unsigned N = LandingPads.size();

832 for (unsigned i = 0; i < N; ++i) {

835 return LP;

836 }

837

839 return LandingPads[N];

840}

841

848

850 MCSymbol *LandingPadLabel = Ctx.createTempSymbol();

853

857

858

859 if (LPI->isCleanup() && LPI->getNumClauses() != 0)

861

862

863

864

865 for (unsigned I = LPI->getNumClauses(); I != 0; --I) {

866 Value *Val = LPI->getClause(I - 1);

867 if (LPI->isCatch(I - 1)) {

870 } else {

871

874 for (const Use &U : CVal->operands())

877

879 }

880 }

881

883 for (unsigned I = CPI->arg_size(); I != 0; --I) {

884 auto *TypeInfo =

887 }

888

889 } else {

891 }

892

893 return LandingPadLabel;

894}

895

898 LPadToCallSiteMap[Sym].append(Sites.begin(), Sites.end());

899}

900

902 for (unsigned i = 0, N = TypeInfos.size(); i != N; ++i)

903 if (TypeInfos[i] == TI) return i + 1;

904

905 TypeInfos.push_back(TI);

906 return TypeInfos.size();

907}

908

910

911

912

913 for (unsigned i : FilterEnds) {

914 unsigned j = TyIds.size();

915

916 while (i && j)

917 if (FilterIds[--i] != TyIds[--j])

918 goto try_next;

919

920 if (!j)

921

922 return -(1 + i);

923

924try_next:;

925 }

926

927

928 int FilterID = -(1 + FilterIds.size());

929 FilterIds.reserve(FilterIds.size() + TyIds.size() + 1);

931 FilterEnds.push_back(FilterIds.size());

932 FilterIds.push_back(0);

933 return FilterID;

934}

935

937MachineFunction::getCallSiteInfo(const MachineInstr *MI) {

938 assert(MI->isCandidateForAdditionalCallInfo() &&

939 "Call site info refers only to call (MI) candidates");

940

941 if ( Target .Options.EmitCallSiteInfo && Target .Options.EmitCallGraphSection)

942 return CallSitesInfo.end();

943 return CallSitesInfo.find(MI);

944}

945

946

948 if (->isBundle())

949 return MI;

950

953 if (BMI.isCandidateForAdditionalCallInfo())

954 return &BMI;

955

956 llvm_unreachable("Unexpected bundle without a call site candidate");

957}

958

960 assert(MI->shouldUpdateAdditionalCallInfo() &&

961 "Call info refers only to call (MI) candidates or "

962 "candidates inside bundles");

963

965

967 if (CSIt != CallSitesInfo.end())

968 CallSitesInfo.erase(CSIt);

969

970 CalledGlobalsInfo.erase(CallMI);

971}

972

976 "Call info refers only to call (MI) candidates or "

977 "candidates inside bundles");

978

979 if (!New->isCandidateForAdditionalCallInfo())

981

984 if (CSIt != CallSitesInfo.end()) {

986 CallSitesInfo[New] = std::move(CSInfo);

987 }

988

990 if (CGIt != CalledGlobalsInfo.end()) {

992 CalledGlobalsInfo[New] = std::move(CGInfo);

993 }

994}

995

999 "Call info refers only to call (MI) candidates or "

1000 "candidates inside bundles");

1001

1002 if (!New->isCandidateForAdditionalCallInfo())

1004

1007 if (CSIt != CallSitesInfo.end()) {

1008 CallSiteInfo CSInfo = std::move(CSIt->second);

1009 CallSitesInfo.erase(CSIt);

1010 CallSitesInfo[New] = std::move(CSInfo);

1011 }

1012

1014 if (CGIt != CalledGlobalsInfo.end()) {

1016 CalledGlobalsInfo.erase(CGIt);

1017 CalledGlobalsInfo[New] = std::move(CGInfo);

1018 }

1019}

1020

1024

1027 unsigned Subreg) {

1028

1030

1032

1034}

1035

1038 unsigned MaxOperand) {

1039

1041 if (!OldInstrNum)

1042 return;

1043

1044

1045

1046

1047

1048

1049 MaxOperand = std::min(MaxOperand, Old.getNumOperands());

1050 for (unsigned int I = 0; I < MaxOperand; ++I) {

1052 auto &NewMO = New.getOperand(I);

1053 (void)NewMO;

1054

1055 if (!OldMO.isReg() || !OldMO.isDef())

1056 continue;

1057 assert(NewMO.isDef());

1058

1059 unsigned NewInstrNum = New.getDebugInstrNum();

1061 std::make_pair(NewInstrNum, I));

1062 }

1063}

1064

1069

1070

1071

1073 if (auto CopyDstSrc = TII.isCopyLikeInstr(MI)) {

1074 Dest = CopyDstSrc->Destination->getReg();

1075 } else {

1077 Dest = MI.getOperand(0).getReg();

1078 }

1079

1080 auto CacheIt = DbgPHICache.find(Dest);

1081 if (CacheIt != DbgPHICache.end())

1082 return CacheIt->second;

1083

1084

1086 DbgPHICache.insert({Dest, OperandPair});

1087 return OperandPair;

1088}

1089

1095

1096

1097

1098

1099

1100

1101

1102

1103

1104

1105

1106

1107

1108

1109

1110

1111

1112 auto GetRegAndSubreg =

1113 [&](const MachineInstr &Cpy) -> std::pair<Register, unsigned> {

1116 if (Cpy.isCopy()) {

1117 OldReg = Cpy.getOperand(0).getReg();

1118 NewReg = Cpy.getOperand(1).getReg();

1119 SubReg = Cpy.getOperand(1).getSubReg();

1120 } else if (Cpy.isSubregToReg()) {

1121 OldReg = Cpy.getOperand(0).getReg();

1122 NewReg = Cpy.getOperand(2).getReg();

1123 SubReg = Cpy.getOperand(3).getImm();

1124 } else {

1125 auto CopyDetails = *TII.isCopyInstr(Cpy);

1127 const MachineOperand &Dest = *CopyDetails.Destination;

1128 OldReg = Dest.getReg();

1129 NewReg = Src.getReg();

1130 SubReg = Src.getSubReg();

1131 }

1132

1133 return {NewReg, SubReg};

1134 };

1135

1136

1137

1138

1139

1140 auto State = GetRegAndSubreg(MI);

1141 auto CurInst = MI.getIterator();

1143 while (true) {

1144

1145 if (!State.first.isVirtual())

1146 break;

1147

1148

1149 if (State.second)

1150 SubregsSeen.push_back(State.second);

1151

1152 assert(MRI.hasOneDef(State.first));

1153 MachineInstr &Inst = *MRI.def_begin(State.first)->getParent();

1155

1156

1157 if (!Inst.isCopyLike() && TII .isCopyLikeInstr(Inst))

1158 break;

1159 State = GetRegAndSubreg(Inst);

1160 };

1161

1162

1163

1164

1165

1166 auto ApplySubregisters =

1168 for (unsigned Subreg : reverse(SubregsSeen)) {

1169

1171

1172

1174

1175

1176 P = {NewInstrNumber, 0};

1177 }

1178 return P;

1179 };

1180

1181

1182

1183 if (State.first.isVirtual()) {

1184

1185 MachineInstr *Inst = MRI.def_begin(State.first)->getParent();

1186 for (auto &MO : Inst->all_defs()) {

1187 if (MO.getReg() != State.first)

1188 continue;

1189 return ApplySubregisters({Inst->getDebugInstrNum(), MO.getOperandNo()});

1190 }

1191

1192 llvm_unreachable("Vreg def with no corresponding operand?");

1193 }

1194

1195

1196

1197 assert(CurInst->isCopyLike() || TII.isCopyInstr(*CurInst));

1198 State = GetRegAndSubreg(*CurInst);

1199 Register RegToSeek = State.first;

1200

1201 auto RMII = CurInst->getReverseIterator();

1202 auto PrevInstrs = make_range(RMII, CurInst->getParent()->instr_rend());

1203 for (auto &ToExamine : PrevInstrs) {

1204 for (auto &MO : ToExamine.all_defs()) {

1205

1206 if ( TRI .regsOverlap(RegToSeek, MO.getReg()))

1207 continue;

1208

1209 return ApplySubregisters(

1210 {ToExamine.getDebugInstrNum(), MO.getOperandNo()});

1211 }

1212 }

1213

1215

1216

1217

1218

1219

1220

1221

1222

1223

1224

1225

1227 TII.get(TargetOpcode::DBG_PHI));

1228 Builder.addReg(State.first);

1230 Builder.addImm(NewNum);

1231 return ApplySubregisters({NewNum, 0u});

1232}

1233

1236

1238 const MCInstrDesc &RefII = TII->get(TargetOpcode::DBG_VALUE_LIST);

1239 MI.setDesc(RefII);

1240 MI.setDebugValueUndef();

1241 };

1242

1244 for (auto &MBB : *this) {

1245 for (auto &MI : MBB) {

1246 if (.isDebugRef())

1247 continue;

1248

1249 bool IsValidRef = true;

1250

1252 if (!MO.isReg())

1253 continue;

1254

1256

1257

1258

1259

1260 if (Reg == 0 || !RegInfo->hasOneDef(Reg)) {

1261 IsValidRef = false;

1262 break;

1263 }

1264

1265 assert(Reg.isVirtual());

1267

1268

1269

1270

1271 if (DefMI.isCopyLike() || TII->isCopyInstr(DefMI)) {

1273 MO.ChangeToDbgInstrRef(Result.first, Result.second);

1274 } else {

1275

1276 unsigned OperandIdx = 0;

1277 for (const auto &DefMO : DefMI.operands()) {

1278 if (DefMO.isReg() && DefMO.isDef() && DefMO.getReg() == Reg)

1279 break;

1280 ++OperandIdx;

1281 }

1282 assert(OperandIdx < DefMI.getNumOperands());

1283

1284

1285 unsigned ID = DefMI.getDebugInstrNum();

1286 MO.ChangeToDbgInstrRef(ID, OperandIdx);

1287 }

1288 }

1289

1290 if (!IsValidRef)

1291 MakeUndefDbgValue(MI);

1292 }

1293 }

1294}

1295

1297

1298

1299

1300

1302 return false;

1303

1304

1305 if (F.hasFnAttribute(Attribute::OptimizeNone))

1306 return false;

1307

1309 return true;

1310

1311 return false;

1312}

1313

1317

1321

1322

1324

1325

1326

1327

1328

1329

1330

1332 const std::vector<MachineBasicBlock *> &MBBs)

1334

1335

1337

1338

1344 return 8;

1348 return 4;

1350 return 0;

1351 }

1353}

1354

1355

1357

1358

1359

1371 return 1;

1372 }

1374}

1375

1376

1378 const std::vector<MachineBasicBlock*> &DestBBs) {

1379 assert(!DestBBs.empty() && "Cannot create an empty jump table!");

1381 return JumpTables.size()-1;

1382}

1383

1386 assert(JTI < JumpTables.size() && "Invalid JTI!");

1387

1388 if (Hotness <= JumpTables[JTI].Hotness)

1389 return false;

1390

1391 JumpTables[JTI].Hotness = Hotness;

1392 return true;

1393}

1394

1395

1396

1399 assert(Old != New && "Not making a change?");

1400 bool MadeChange = false;

1401 for (size_t i = 0, e = JumpTables.size(); i != e; ++i)

1403 return MadeChange;

1404}

1405

1406

1408 bool MadeChange = false;

1410 auto removeBeginItr = std::remove(JTE.MBBs.begin(), JTE.MBBs.end(), MBB);

1411 MadeChange |= (removeBeginItr != JTE.MBBs.end());

1412 JTE.MBBs.erase(removeBeginItr, JTE.MBBs.end());

1413 }

1414 return MadeChange;

1415}

1416

1417

1418

1422 assert(Old != New && "Not making a change?");

1423 bool MadeChange = false;

1426 if (MBB == Old) {

1427 MBB = New;

1428 MadeChange = true;

1429 }

1430 return MadeChange;

1431}

1432

1434 if (JumpTables.empty()) return;

1435

1436 OS << "Jump Tables:\n";

1437

1438 for (unsigned i = 0, e = JumpTables.size(); i != e; ++i) {

1442 if (i != e)

1443 OS << '\n';

1444 }

1445

1446 OS << '\n';

1447}

1448

1449#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)

1451#endif

1452

1456

1457

1458

1459

1460

1461void MachineConstantPoolValue::anchor() {}

1462

1464 return DL.getTypeAllocSize(Ty);

1465}

1466

1469 return Val.MachineCPVal->getSizeInBytes(DL);

1470 return DL.getTypeAllocSize(Val.ConstVal->getType());

1471}

1472

1475 return true;

1476 return Val.ConstVal->needsDynamicRelocation();

1477}

1478

1484 case 4:

1486 case 8:

1488 case 16:

1490 case 32:

1492 default:

1494 }

1495}

1496

1498

1499

1502 if (C.isMachineConstantPoolEntry()) {

1503 Deleted.insert(C.Val.MachineCPVal);

1504 delete C.Val.MachineCPVal;

1505 }

1507 if (Deleted.count(CPV) == 0)

1508 delete CPV;

1509 }

1510}

1511

1512

1513

1516

1517 if (A == B) return true;

1518

1519

1520

1521 if (A->getType() == B->getType()) return false;

1522

1523

1526 return false;

1527

1528

1529 uint64_t StoreSize = DL.getTypeStoreSize(A->getType());

1530 if (StoreSize != DL.getTypeStoreSize(B->getType()) || StoreSize > 128)

1531 return false;

1532

1533 bool ContainsUndefOrPoisonA = A->containsUndefOrPoisonElement();

1534

1536

1537

1538

1539

1540

1544 else if (A->getType() != IntTy)

1546 IntTy, DL);

1550 else if (B->getType() != IntTy)

1552 IntTy, DL);

1553

1554 if (A != B)

1555 return false;

1556

1557

1558

1559

1560

1561 return !ContainsUndefOrPoisonA;

1562}

1563

1564

1565

1567 Align Alignment) {

1568 if (Alignment > PoolAlignment) PoolAlignment = Alignment;

1569

1570

1571

1572

1573 for (unsigned i = 0, e = Constants.size(); i != e; ++i)

1574 if (!Constants[i].isMachineConstantPoolEntry() &&

1576 if (Constants[i].getAlign() < Alignment)

1577 Constants[i].Alignment = Alignment;

1578 return i;

1579 }

1580

1582 return Constants.size()-1;

1583}

1584

1586 Align Alignment) {

1587 if (Alignment > PoolAlignment) PoolAlignment = Alignment;

1588

1589

1590

1591

1592 int Idx = V->getExistingMachineCPValue(this, Alignment);

1593 if (Idx != -1) {

1594 MachineCPVsSharingEntries.insert(V);

1595 return (unsigned)Idx;

1596 }

1597

1599 return Constants.size()-1;

1600}

1601

1603 if (Constants.empty()) return;

1604

1605 OS << "Constant Pool:\n";

1606 for (unsigned i = 0, e = Constants.size(); i != e; ++i) {

1607 OS << " cp#" << i << ": ";

1608 if (Constants[i].isMachineConstantPoolEntry())

1609 Constants[i].Val.MachineCPVal->print(OS);

1610 else

1611 Constants[i].Val.ConstVal->printAsOperand(OS, false);

1612 OS << ", align=" << Constants[i].getAlign().value();

1613 OS << "\n";

1614 }

1615}

1616

1617

1618

1619

1620

1621template <>

1622std::optionalFunction::ProfileCount

1623ProfileSummaryInfo::getEntryCountllvm::MachineFunction(

1625 return F->getFunction().getEntryCount();

1626}

1627

1628#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)

1630#endif

unsigned const MachineRegisterInfo * MRI

MachineInstrBuilder MachineInstrBuilder & DefMI

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

const TargetInstrInfo & TII

MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL

MachineBasicBlock MachineBasicBlock::iterator MBBI

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

static const Function * getParent(const Value *V)

This file implements the BitVector class.

static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")

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

static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")

#define LLVM_DUMP_METHOD

Mark debug helper function definitions like dump() that should not be stripped from debug builds.

This file defines the DenseMap class.

This file defines the DenseSet and SmallDenseSet classes.

Module.h This file contains the declarations for the Module class.

This file declares the MachineConstantPool class which is an abstract constant pool to keep track of ...

static cl::opt< unsigned > AlignAllFunctions("align-all-functions", cl::desc("Force the alignment of all functions in log2 format (e.g. 4 " "means align on 16B boundaries)."), cl::init(0), cl::Hidden)

static const MachineInstr * getCallInstr(const MachineInstr *MI)

Return the call machine instruction or find a call within bundle.

Definition MachineFunction.cpp:947

static Align getFnStackAlignment(const TargetSubtargetInfo &STI, const Function &F)

Definition MachineFunction.cpp:157

static bool CanShareConstantPoolEntry(const Constant *A, const Constant *B, const DataLayout &DL)

Test whether the given two constants can be allocated the same constant pool entry referenced by.

Definition MachineFunction.cpp:1514

void setUnsafeStackSize(const Function &F, MachineFrameInfo &FrameInfo)

Definition MachineFunction.cpp:112

static const char * getPropertyName(MachineFunctionProperties::Property Prop)

Definition MachineFunction.cpp:90

static bool isSimple(Instruction *I)

This file defines the SmallString class.

This file defines the SmallVector class.

static const int BlockSize

This file describes how to lower LLVM code to machine code.

void print(OutputBuffer &OB) const

void clear(AllocatorType &Allocator)

Release all the tracked allocations to the allocator.

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

size_t size() const

size - Get the array size.

LLVM Basic Block Representation.

LLVM_ABI InstListType::const_iterator getFirstNonPHIIt() const

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

InstListType::const_iterator const_iterator

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

LLVM_ABI bool isIndirectCall() const

Return true if the callsite is an indirect call.

This is an important base class in LLVM.

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

Align getABIIntegerTypeAlignment(unsigned BitWidth) const

Returns the minimum ABI-required alignment for an integer type of the specified bitwidth.

LLVM_ABI unsigned getPointerSize(unsigned AS=0) const

The pointer representation size in bytes, rounded up to a whole number of bytes.

LLVM_ABI Align getPointerABIAlignment(unsigned AS) const

Layout pointer alignment.

iterator find(const_arg_type_t< KeyT > Val)

DenseMapIterator< KeyT, ValueT, KeyInfoT, BucketT > iterator

Implements a dense probed hash-table based set.

bool hasFnAttribute(Attribute::AttrKind Kind) const

Return true if the function has the attribute.

MDNode * getMetadata(unsigned KindID) const

Get the metadata of given kind attached to this Instruction.

Class to represent integer types.

static LLVM_ABI IntegerType * get(LLVMContext &C, unsigned NumBits)

This static method is the primary way of constructing an IntegerType.

Context object for machine code objects.

Describe properties that are true of each instruction in the target description file.

unsigned getNumRegs() const

Return the number of registers this target has (useful for sizing arrays holding per register informa...

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

MCSymbol - Instances of this class represent a symbol name in the MC file, and MCSymbols are created ...

const MDOperand & getOperand(unsigned I) const

ArrayRef< MDOperand > operands() const

Tracking metadata reference owned by Metadata.

LLVM_ABI StringRef getString() const

void setIsEndSection(bool V=true)

LLVM_ABI instr_iterator insert(instr_iterator I, MachineInstr *M)

Insert MI into the instruction list before I, possibly inside a bundle.

const BasicBlock * getBasicBlock() const

Return the LLVM basic block that this instance corresponded to originally.

MBBSectionID getSectionID() const

Returns the section ID of this basic block.

LLVM_ABI iterator getFirstNonPHI()

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

Instructions::const_iterator const_instr_iterator

const MachineFunction * getParent() const

Return the MachineFunction containing this basic block.

MachineInstrBundleIterator< MachineInstr > iterator

void setIsBeginSection(bool V=true)

This class is a data container for one entry in a MachineConstantPool.

union llvm::MachineConstantPoolEntry::@004270020304201266316354007027341142157160323045 Val

The constant itself.

bool needsRelocation() const

This method classifies the entry according to whether or not it may generate a relocation entry.

Definition MachineFunction.cpp:1473

bool isMachineConstantPoolEntry() const

isMachineConstantPoolEntry - Return true if the MachineConstantPoolEntry is indeed a target specific ...

unsigned getSizeInBytes(const DataLayout &DL) const

Definition MachineFunction.cpp:1467

SectionKind getSectionKind(const DataLayout *DL) const

Definition MachineFunction.cpp:1480

Abstract base class for all machine specific constantpool value subclasses.

virtual unsigned getSizeInBytes(const DataLayout &DL) const

Definition MachineFunction.cpp:1463

The MachineConstantPool class keeps track of constants referenced by a function which must be spilled...

void dump() const

dump - Call print(cerr) to be called from the debugger.

Definition MachineFunction.cpp:1629

void print(raw_ostream &OS) const

print - Used by the MachineFunction printer to print information about constant pool objects.

Definition MachineFunction.cpp:1602

~MachineConstantPool()

Definition MachineFunction.cpp:1497

unsigned getConstantPoolIndex(const Constant *C, Align Alignment)

getConstantPoolIndex - Create a new entry in the constant pool or return an existing one.

Definition MachineFunction.cpp:1566

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

LLVM_ABI void ensureMaxAlignment(Align Alignment)

Make sure the function is at least Align bytes aligned.

void setUnsafeStackSize(uint64_t Size)

LLVM_ABI void print(raw_ostream &OS) const

Print the MachineFunctionProperties in human-readable form.

Definition MachineFunction.cpp:136

MachineFunctionProperties & reset(Property P)

virtual void MF_HandleRemoval(MachineInstr &MI)=0

Callback before a removal. This should not modify the MI directly.

virtual void MF_HandleInsertion(MachineInstr &MI)=0

Callback after an insertion. This should not modify the MI directly.

int getFilterIDFor(ArrayRef< unsigned > TyIds)

Return the id of the filter encoded by TyIds. This is function wide.

Definition MachineFunction.cpp:909

bool UseDebugInstrRef

Flag for whether this function contains DBG_VALUEs (false) or DBG_INSTR_REF (true).

void moveAdditionalCallInfo(const MachineInstr *Old, const MachineInstr *New)

Move the call site info from Old to \New call site info.

Definition MachineFunction.cpp:996

std::pair< unsigned, unsigned > DebugInstrOperandPair

Pair of instruction number and operand number.

unsigned addFrameInst(const MCCFIInstruction &Inst)

Definition MachineFunction.cpp:334

bool useDebugInstrRef() const

Returns true if the function's variable locations are tracked with instruction referencing.

Definition MachineFunction.cpp:1314

SmallVector< DebugSubstitution, 8 > DebugValueSubstitutions

Debug value substitutions: a collection of DebugSubstitution objects, recording changes in where a va...

unsigned getFunctionNumber() const

getFunctionNumber - Return a unique ID for the current function.

MCSymbol * getPICBaseSymbol() const

getPICBaseSymbol - Return a function-local symbol to represent the PIC base.

Definition MachineFunction.cpp:820

void viewCFGOnly() const

viewCFGOnly - This function is meant for use from the debugger.

Definition MachineFunction.cpp:768

ArrayRef< int > allocateShuffleMask(ArrayRef< int > Mask)

Definition MachineFunction.cpp:633

void substituteDebugValuesForInst(const MachineInstr &Old, MachineInstr &New, unsigned MaxOperand=UINT_MAX)

Create substitutions for any tracked values in Old, to point at New.

Definition MachineFunction.cpp:1036

const TargetSubtargetInfo & getSubtarget() const

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

MachineJumpTableInfo * getOrCreateJumpTableInfo(unsigned JTEntryKind)

getOrCreateJumpTableInfo - Get the JumpTableInfo for this function, if it does already exist,...

Definition MachineFunction.cpp:316

StringRef getName() const

getName - Return the name of the corresponding LLVM function.

Definition MachineFunction.cpp:645

unsigned getNewDebugInstrNum()

void dump() const

dump - Print the current MachineFunction to cerr, useful for debugger use.

Definition MachineFunction.cpp:640

void makeDebugValueSubstitution(DebugInstrOperandPair, DebugInstrOperandPair, unsigned SubReg=0)

Create a substitution between one <instr,operand> value to a different, new value.

Definition MachineFunction.cpp:1025

MachineMemOperand * getMachineMemOperand(MachinePointerInfo PtrInfo, MachineMemOperand::Flags f, LLT MemTy, Align base_alignment, const AAMDNodes &AAInfo=AAMDNodes(), const MDNode *Ranges=nullptr, SyncScope::ID SSID=SyncScope::System, AtomicOrdering Ordering=AtomicOrdering::NotAtomic, AtomicOrdering FailureOrdering=AtomicOrdering::NotAtomic)

getMachineMemOperand - Allocate a new MachineMemOperand.

Definition MachineFunction.cpp:536

MachineFunction(Function &F, const TargetMachine &Target, const TargetSubtargetInfo &STI, MCContext &Ctx, unsigned FunctionNum)

Definition MachineFunction.cpp:164

bool needsFrameMoves() const

True if this function needs frame moves for debug or exceptions.

Definition MachineFunction.cpp:691

MachineInstr::ExtraInfo * createMIExtraInfo(ArrayRef< MachineMemOperand * > MMOs, MCSymbol *PreInstrSymbol=nullptr, MCSymbol *PostInstrSymbol=nullptr, MDNode *HeapAllocMarker=nullptr, MDNode *PCSections=nullptr, uint32_t CFIType=0, MDNode *MMRAs=nullptr, Value *DS=nullptr)

Allocate and construct an extra info structure for a MachineInstr.

Definition MachineFunction.cpp:609

unsigned getTypeIDFor(const GlobalValue *TI)

Return the type id for the specified typeinfo. This is function wide.

Definition MachineFunction.cpp:901

void finalizeDebugInstrRefs()

Finalise any partially emitted debug instructions.

Definition MachineFunction.cpp:1234

void deallocateOperandArray(OperandCapacity Cap, MachineOperand *Array)

Dellocate an array of MachineOperands and recycle the memory.

DenormalMode getDenormalMode(const fltSemantics &FPType) const

Returns the denormal handling type for the default rounding mode of the function.

Definition MachineFunction.cpp:324

void initTargetMachineFunctionInfo(const TargetSubtargetInfo &STI)

Initialize the target specific MachineFunctionInfo.

Definition MachineFunction.cpp:249

const char * createExternalSymbolName(StringRef Name)

Allocate a string and populate it with the given external symbol name.

Definition MachineFunction.cpp:618

uint32_t * allocateRegMask()

Allocate and initialize a register mask with NumRegister bits.

Definition MachineFunction.cpp:625

MCSymbol * getJTISymbol(unsigned JTI, MCContext &Ctx, bool isLinkerPrivate=false) const

getJTISymbol - Return the MCSymbol for the specified non-empty jump table.

Definition MachineFunction.cpp:805

void setCallSiteLandingPad(MCSymbol *Sym, ArrayRef< unsigned > Sites)

Map the landing pad's EH symbol to the call site indexes.

Definition MachineFunction.cpp:896

void setUseDebugInstrRef(bool UseInstrRef)

Set whether this function will use instruction referencing or not.

Definition MachineFunction.cpp:1318

LandingPadInfo & getOrCreateLandingPadInfo(MachineBasicBlock *LandingPad)

Find or create an LandingPadInfo for the specified MachineBasicBlock.

Definition MachineFunction.cpp:830

MachineRegisterInfo & getRegInfo()

getRegInfo - Return information about the registers currently in use.

const DataLayout & getDataLayout() const

Return the DataLayout attached to the Module associated to this MF.

Definition MachineFunction.cpp:309

MCSymbol * addLandingPad(MachineBasicBlock *LandingPad)

Add a new panding pad, and extract the exception handling information from the landingpad instruction...

Definition MachineFunction.cpp:849

unsigned DebugInstrNumberingCount

A count of how many instructions in the function have had numbers assigned to them.

void deleteMachineBasicBlock(MachineBasicBlock *MBB)

DeleteMachineBasicBlock - Delete the given MachineBasicBlock.

Definition MachineFunction.cpp:513

Align getAlignment() const

getAlignment - Return the alignment of the function.

void handleChangeDesc(MachineInstr &MI, const MCInstrDesc &TID)

Definition MachineFunction.cpp:182

static const unsigned int DebugOperandMemNumber

A reserved operand number representing the instructions memory operand, for instructions that have a ...

~MachineFunction()

Definition MachineFunction.cpp:255

Function & getFunction()

Return the LLVM function that this machine code represents.

DebugInstrOperandPair salvageCopySSAImpl(MachineInstr &MI)

Definition MachineFunction.cpp:1090

const MachineBasicBlock & back() const

BasicBlockListType::iterator iterator

void setDebugInstrNumberingCount(unsigned Num)

Set value of DebugInstrNumberingCount field.

Definition MachineFunction.cpp:1021

bool shouldSplitStack() const

Should we be emitting segmented stack stuff for the function.

Definition MachineFunction.cpp:329

void viewCFG() const

viewCFG - This function is meant for use from the debugger.

Definition MachineFunction.cpp:758

bool shouldUseDebugInstrRef() const

Determine whether, in the current machine configuration, we should use instruction referencing or not...

Definition MachineFunction.cpp:1296

const MachineFunctionProperties & getProperties() const

Get the function properties.

void eraseAdditionalCallInfo(const MachineInstr *MI)

Following functions update call site info.

Definition MachineFunction.cpp:959

void RenumberBlocks(MachineBasicBlock *MBBFrom=nullptr)

RenumberBlocks - This discards all of the MachineBasicBlock numbers and recomputes them.

Definition MachineFunction.cpp:343

const MachineBasicBlock & front() const

addLiveIn - Add the specified physical register as a live-in value and create a corresponding virtual...

Definition MachineFunction.cpp:780

int64_t estimateFunctionSizeInBytes()

Return an estimate of the function's code size, taking into account block and function alignment.

Definition MachineFunction.cpp:381

void print(raw_ostream &OS, const SlotIndexes *=nullptr) const

print - Print out the MachineFunction in a format suitable for debugging to the specified stream.

Definition MachineFunction.cpp:649

void addInvoke(MachineBasicBlock *LandingPad, MCSymbol *BeginLabel, MCSymbol *EndLabel)

Provide the begin and end labels of an invoke style call and associate it with a try landing pad bloc...

Definition MachineFunction.cpp:842

MachineBasicBlock * CreateMachineBasicBlock(const BasicBlock *BB=nullptr, std::optional< UniqueBBID > BBID=std::nullopt)

CreateMachineInstr - Allocate a new MachineInstr.

Definition MachineFunction.cpp:499

void copyAdditionalCallInfo(const MachineInstr *Old, const MachineInstr *New)

Copy the call site info from Old to \ New.

Definition MachineFunction.cpp:973

VariableDbgInfoMapTy VariableDbgInfos

void assignBeginEndSections()

Assign IsBeginSection IsEndSection fields for basic blocks in this function.

Definition MachineFunction.cpp:415

const TargetMachine & getTarget() const

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

DebugInstrOperandPair salvageCopySSA(MachineInstr &MI, DenseMap< Register, DebugInstrOperandPair > &DbgPHICache)

Find the underlying defining instruction / operand for a COPY instruction while in SSA form.

Definition MachineFunction.cpp:1065

Representation of each machine instruction.

LLVM_ABI void bundleWithPred()

Bundle this instruction with its predecessor.

bool isCopyLike() const

Return true if the instruction behaves like a copy.

filtered_mop_range all_defs()

Returns an iterator range over all operands that are (explicit or implicit) register defs.

unsigned getNumOperands() const

Retuns the total number of operands.

unsigned peekDebugInstrNum() const

Examine the instruction number of this MachineInstr.

LLVM_ABI unsigned getDebugInstrNum()

Fetch the instruction number of this MachineInstr.

const MachineOperand & getOperand(unsigned i) const

LLVM_ABI bool shouldUpdateAdditionalCallInfo() const

Return true if copying, moving, or erasing this instruction requires updating additional call info (s...

LLVM_ABI bool RemoveMBBFromJumpTables(MachineBasicBlock *MBB)

RemoveMBBFromJumpTables - If MBB is present in any jump tables, remove it.

Definition MachineFunction.cpp:1407

LLVM_ABI bool ReplaceMBBInJumpTables(MachineBasicBlock *Old, MachineBasicBlock *New)

ReplaceMBBInJumpTables - If Old is the target of any jump tables, update the jump tables to branch to...

Definition MachineFunction.cpp:1397

LLVM_ABI void print(raw_ostream &OS) const

print - Used by the MachineFunction printer to print information about jump tables.

Definition MachineFunction.cpp:1433

LLVM_ABI unsigned getEntrySize(const DataLayout &TD) const

getEntrySize - Return the size of each entry in the jump table.

Definition MachineFunction.cpp:1336

LLVM_ABI unsigned createJumpTableIndex(const std::vector< MachineBasicBlock * > &DestBBs)

createJumpTableIndex - Create a new jump table.

Definition MachineFunction.cpp:1377

LLVM_ABI void dump() const

dump - Call to stderr.

Definition MachineFunction.cpp:1450

LLVM_ABI bool ReplaceMBBInJumpTable(unsigned Idx, MachineBasicBlock *Old, MachineBasicBlock *New)

ReplaceMBBInJumpTable - If Old is a target of the jump tables, update the jump table to branch to New...

Definition MachineFunction.cpp:1419

LLVM_ABI bool updateJumpTableEntryHotness(size_t JTI, MachineFunctionDataHotness Hotness)

Definition MachineFunction.cpp:1384

JTEntryKind

JTEntryKind - This enum indicates how each entry of the jump table is represented and emitted.

@ EK_GPRel32BlockAddress

EK_GPRel32BlockAddress - Each entry is an address of block, encoded with a relocation as gp-relative,...

@ EK_Inline

EK_Inline - Jump table entries are emitted inline at their point of use.

@ EK_LabelDifference32

EK_LabelDifference32 - Each entry is the address of the block minus the address of the jump table.

@ EK_Custom32

EK_Custom32 - Each entry is a 32-bit value that is custom lowered by the TargetLowering::LowerCustomJ...

@ EK_LabelDifference64

EK_LabelDifference64 - Each entry is the address of the block minus the address of the jump table.

@ EK_BlockAddress

EK_BlockAddress - Each entry is a plain address of block, e.g.: .word LBB123.

@ EK_GPRel64BlockAddress

EK_GPRel64BlockAddress - Each entry is an address of block, encoded with a relocation as gp-relative,...

LLVM_ABI unsigned getEntryAlignment(const DataLayout &TD) const

getEntryAlignment - Return the alignment of each entry in the jump table.

Definition MachineFunction.cpp:1356

JTEntryKind getEntryKind() const

A description of a memory reference used in the backend.

LocationSize getSize() const

Return the size in bytes of the memory reference.

AtomicOrdering getFailureOrdering() const

For cmpxchg atomic operations, return the atomic ordering requirements when store does not occur.

const PseudoSourceValue * getPseudoValue() const

const MDNode * getRanges() const

Return the range tag for the memory reference.

SyncScope::ID getSyncScopeID() const

Returns the synchronization scope ID for this memory operation.

Flags

Flags values. These may be or'd together.

AtomicOrdering getSuccessOrdering() const

Return the atomic ordering requirements for this memory operation.

const MachinePointerInfo & getPointerInfo() const

Flags getFlags() const

Return the raw flags of the source value,.

AAMDNodes getAAInfo() const

Return the AA tags for the memory reference.

const Value * getValue() const

Return the base address of the memory access.

Align getBaseAlign() const

Return the minimum known alignment in bytes of the base address, without the offset.

int64_t getOffset() const

For normal values, this is a byte offset added to the base address.

MachineOperand class - Representation of each machine instruction operand.

static unsigned getRegMaskSize(unsigned NumRegs)

Returns number of elements needed for a regmask array.

getReg - Returns the register number.

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

std::vector< std::pair< MCRegister, Register > >::const_iterator livein_iterator

Manage lifetime of a slot tracker for printing IR.

void incorporateFunction(const Function &F)

Incorporate the given function.

bool isNull() const

Test if the pointer held in the union is null, regardless of which type it is.

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

Wrapper class representing virtual and physical registers.

SectionKind - This is a simple POD value that classifies the properties of a section.

static SectionKind getMergeableConst4()

static SectionKind getReadOnlyWithRel()

static SectionKind getMergeableConst8()

static SectionKind getMergeableConst16()

static SectionKind getReadOnly()

static SectionKind getMergeableConst32()

SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better...

void push_back(const T &Elt)

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

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

bool isStackRealignable() const

isStackRealignable - This method returns whether the stack can be realigned.

Align getStackAlign() const

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

TargetInstrInfo - Interface to description of machine instruction set.

Align getPrefFunctionAlignment() const

Return the preferred function alignment.

Align getMinFunctionAlignment() const

Return the minimum function alignment.

Primary interface to the complete machine description for the target machine.

unsigned ForceDwarfFrameSection

Emit DWARF debug frame section.

bool contains(Register Reg) const

Return true if the specified register is included in this register class.

bool hasSubClassEq(const TargetRegisterClass *RC) const

Returns true if RC is a sub-class of or equal to this class.

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

TargetSubtargetInfo - Generic base class for all target subtargets.

virtual const TargetFrameLowering * getFrameLowering() const

virtual const TargetInstrInfo * getInstrInfo() const

virtual const TargetRegisterInfo * getRegisterInfo() const =0

Return the target's register information.

virtual const TargetLowering * getTargetLowering() const

Target - Wrapper for Target specific information.

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

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

static LLVM_ABI IntegerType * getInt64Ty(LLVMContext &C)

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

LLVM Value Representation.

LLVM_ABI const Value * stripPointerCasts() const

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

LLVM_ABI LLVMContext & getContext() const

All values hold a context through their type.

LLVM_ABI StringRef getName() const

Return a constant reference to the value's name.

self_iterator getIterator()

iterator erase(iterator where)

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

A raw_ostream that writes to an std::string.

A raw_ostream that writes to an SmallVector or SmallString.

#define llvm_unreachable(msg)

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

unsigned ID

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

@ C

The default llvm calling convention, compatible with C.

initializer< Ty > init(const Ty &Val)

std::enable_if_t< detail::IsValidPointer< X, Y >::value, X * > extract(Y &&MD)

Extract a Value from Metadata.

uint64_t MD5Hash(const FunctionId &Obj)

This is an optimization pass for GlobalISel generic memory operations.

MachineBasicBlock::instr_iterator getBundleStart(MachineBasicBlock::instr_iterator I)

Returns an iterator to the first instruction in the bundle containing I.

MaybeAlign getAlign(const CallInst &I, unsigned Index)

MachineInstrBuilder BuildMI(MachineFunction &MF, const MIMetadata &MIMD, const MCInstrDesc &MCID)

Builder interface. Specify how to create the initial instruction itself.

decltype(auto) dyn_cast(const From &Val)

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

iterator_range< T > make_range(T x, T y)

Convenience function for iterating over sub-ranges.

void append_range(Container &C, Range &&R)

Wrapper function to append range R to container C.

LLVM_ABI Printable printJumpTableEntryReference(unsigned Idx)

Prints a jump table entry reference.

Definition MachineFunction.cpp:1453

bool isScopedEHPersonality(EHPersonality Pers)

Returns true if this personality uses scope-style EH IR instructions: catchswitch,...

MachineFunctionDataHotness

auto dyn_cast_or_null(const Y &Val)

auto reverse(ContainerTy &&C)

LLVM_ABI raw_ostream & dbgs()

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

MachineBasicBlock::instr_iterator getBundleEnd(MachineBasicBlock::instr_iterator I)

Returns an iterator pointing beyond the bundle containing I.

LLVM_ABI Constant * ConstantFoldCastOperand(unsigned Opcode, Constant *C, Type *DestTy, const DataLayout &DL)

Attempt to constant fold a cast with the specified operand.

LLVM_ABI EHPersonality classifyEHPersonality(const Value *Pers)

See if the given exception handling personality function is one that we understand.

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 raw_fd_ostream & errs()

This returns a reference to a raw_ostream for standard error.

AtomicOrdering

Atomic ordering for LLVM's memory model.

bool isFuncletEHPersonality(EHPersonality Pers)

Returns true if this is a personality function that invokes handler funclets (which must return to it...

uint64_t alignTo(uint64_t Size, Align A)

Returns a multiple of A needed to store Size bytes.

DWARFExpression::Operation Op

void ViewGraph(const GraphType &G, const Twine &Name, bool ShortNames=false, const Twine &Title="", GraphProgram::Name Program=GraphProgram::DOT)

ViewGraph - Emit a dot graph, run 'dot', run gv on the postscript file, then cleanup.

OutputIt copy(R &&Range, OutputIt Out)

decltype(auto) cast(const From &Val)

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

Align commonAlignment(Align A, uint64_t Offset)

Returns the alignment that satisfies both alignments.

LLVM_ABI Printable printReg(Register Reg, const TargetRegisterInfo *TRI=nullptr, unsigned SubIdx=0, const MachineRegisterInfo *MRI=nullptr)

Prints virtual and physical registers with or without a TRI instance.

LLVM_ABI Printable printMBBReference(const MachineBasicBlock &MBB)

Prints a machine basic block reference.

bool debuginfoShouldUseDebugInstrRef(const Triple &T)

A collection of metadata nodes that might be associated with a memory access used by the alias-analys...

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

constexpr uint64_t value() const

This is a hole in the type system and should not be abused.

std::string getNodeLabel(const MachineBasicBlock *Node, const MachineFunction *Graph)

Definition MachineFunction.cpp:731

DOTGraphTraits(bool isSimple=false)

Definition MachineFunction.cpp:725

static std::string getGraphName(const MachineFunction *F)

Definition MachineFunction.cpp:727

DOTGraphTraits - Template class that can be specialized to customize how graphs are converted to 'dot...

DefaultDOTGraphTraits(bool simple=false)

Represent subnormal handling kind for floating point instruction inputs and outputs.

This structure is used to retain landing pad info for the current function.

SmallVector< MCSymbol *, 1 > EndLabels

MCSymbol * LandingPadLabel

MachineBasicBlock * LandingPadBlock

SmallVector< MCSymbol *, 1 > BeginLabels

std::vector< int > TypeIds

virtual ~MachineFunctionInfo()

SmallVector< ConstantInt *, 4 > CalleeTypeIds

Callee type ids.

MachineJumpTableEntry - One jump table in the jump table info.

LLVM_ABI MachineJumpTableEntry(const std::vector< MachineBasicBlock * > &M)

Definition MachineFunction.cpp:1331

std::vector< MachineBasicBlock * > MBBs

MBBs - The vector of basic blocks from which to create the jump table.

MachineFunctionDataHotness Hotness

The hotness of MJTE is inferred from the hotness of the source basic block(s) that reference it.

This class contains a discriminated union of information about pointers in memory operands,...

PointerUnion< const Value *, const PseudoSourceValue * > V

This is the IR pointer value for the access, or it is null if unknown.

MachinePointerInfo getWithOffset(int64_t O) const

static void deleteNode(NodeTy *V)