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 =

117 dyn_cast_or_null(F.getMetadata(LLVMContext::MD_annotation));

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)) {

126 auto Val = mdconst::extract(Op)->getZExtValue();

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

155}

156

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

160 return *MA;

162}

163

166 unsigned FunctionNum)

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)

186}

187

188void MachineFunction::init() {

189

194 else

195 RegInfo = nullptr;

196

197 MFInfo = nullptr;

198

199

200

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

207 ForceRealignSP && CanRealignSP);

208

210

213

216

217

218

220 Alignment = std::max(Alignment,

222

223

224

225

226

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

228 F.getMetadata(LLVMContext::MD_kcfi_type))

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

230

233

234 JumpTableInfo = nullptr;

235

239 }

240

244 }

245

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

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

249

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

251}

252

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

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

257}

258

260 clear();

261}

262

263void MachineFunction::clear() {

264 Properties.reset();

265

266

267

268

270 I->Insts.clearAndLeakNodesUnsafely();

271 MBBNumbering.clear();

272

273 InstructionRecycler.clear(Allocator);

274 OperandRecycler.clear(Allocator);

275 BasicBlockRecycler.clear(Allocator);

276 CodeViewAnnotations.clear();

278 if (RegInfo) {

279 RegInfo->~MachineRegisterInfo();

281 }

282 if (MFInfo) {

285 }

286

287 FrameInfo->~MachineFrameInfo();

289

292

293 if (JumpTableInfo) {

294 JumpTableInfo->~MachineJumpTableInfo();

296 }

297

298 if (WinEHInfo) {

299 WinEHInfo->~WinEHFuncInfo();

301 }

302

303 if (WasmEHInfo) {

304 WasmEHInfo->~WasmEHFuncInfo();

306 }

307}

308

311}

312

313

314

317 if (JumpTableInfo) return JumpTableInfo;

318

319 JumpTableInfo = new (Allocator)

321 return JumpTableInfo;

322}

323

326}

327

328

331}

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

350

351

352 unsigned BlockNo = 0;

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

355

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

358

361 "MBB number mismatch!");

363 }

364

365

366 if (MBBNumbering[BlockNo])

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

368

369 MBBNumbering[BlockNo] = &*MBBI;

371 }

372 }

373

374

375

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

377 MBBNumbering.resize(BlockNo);

378 MBBNumberingEpoch++;

379}

380

385

386

388

392

393 for (auto &MI : *MBBI) {

395 }

396

397 int64_t OffsetBB;

398 if (Alignment <= FunctionAlignment) {

400 } else {

401

402

404 FunctionAlignment.value();

405 }

407 }

408

410}

411

412

413

414

420 continue;

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

424 }

426}

427

428

431 bool NoImplicit) {

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

433 MachineInstr(*this, MCID, std::move(DL), NoImplicit);

434}

435

436

437

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

442}

443

449 while (true) {

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

475

476

477

478

479 assert((->isCandidateForAdditionalCallInfo() ||

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

482

483 assert((->isCandidateForAdditionalCallInfo() ||

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

509 return MBB;

510}

511

512

515

516 if (JumpTableInfo)

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

593

598}

599

607}

608

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

614 PostInstrSymbol, HeapAllocMarker,

615 PCSections, CFIType, MMRAs);

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)

642}

643#endif

644

647}

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

663

665

667 OS << "Function Live Ins: ";

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

700}

701

702namespace llvm {

703

704 template<>

707

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

710 }

711

714 std::string OutStr;

715 {

717

720 if (const BasicBlock *BB = Node->getBasicBlock())

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

722 } else

723 Node->print(OSS);

724 }

725

726 if (OutStr[0] == '\n') OutStr.erase(OutStr.begin());

727

728

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

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

731 OutStr[i] = '\\';

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

733 }

734 return OutStr;

735 }

736 };

737

738}

739

741{

742#ifndef NDEBUG

744#else

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

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

747#endif

748}

749

751{

752#ifndef NDEBUG

754#else

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

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

757#endif

758}

759

760

761

765 Register VReg = MRI.getLiveInVirtReg(PReg);

766 if (VReg) {

768 (void)VRegRC;

769

770

771

772

773

776 "Register class mismatch!");

777 return VReg;

778 }

779 VReg = MRI.createVirtualRegister(RC);

780 MRI.addLiveIn(PReg, VReg);

781 return VReg;

782}

783

784

785

786

788 bool isLinkerPrivate) const {

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

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

792

793 StringRef Prefix = isLinkerPrivate ? DL.getLinkerPrivateGlobalPrefix()

794 : DL.getPrivateGlobalPrefix();

799}

800

801

806}

807

808

809

810

813 unsigned N = LandingPads.size();

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

817 return LP;

818 }

819

821 return LandingPads[N];

822}

823

828 LP.EndLabels.push_back(EndLabel);

829}

830

835

837 if (const auto *LPI = dyn_cast(FirstI)) {

838

839

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

842

843

844

845

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

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

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

851 } else {

852

853 auto *CVal = cast(Val);

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

857 getTypeIDFor(cast(U->stripPointerCasts())));

858

860 }

861 }

862

863 } else if (const auto *CPI = dyn_cast(FirstI)) {

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

865 auto *TypeInfo =

866 dyn_cast(CPI->getArgOperand(I - 1)->stripPointerCasts());

868 }

869

870 } else {

871 assert(isa(FirstI) && "Invalid landingpad!");

872 }

873

874 return LandingPadLabel;

875}

876

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

880}

881

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

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

885

886 TypeInfos.push_back(TI);

887 return TypeInfos.size();

888}

889

891

892

893

894 for (unsigned i : FilterEnds) {

895 unsigned j = TyIds.size();

896

897 while (i && j)

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

899 goto try_next;

900

901 if (!j)

902

903 return -(1 + i);

904

905try_next:;

906 }

907

908

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

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

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

913 FilterIds.push_back(0);

914 return FilterID;

915}

916

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

919 assert(MI->isCandidateForAdditionalCallInfo() &&

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

921

922 if ( Target .Options.EmitCallSiteInfo)

923 return CallSitesInfo.end();

924 return CallSitesInfo.find(MI);

925}

926

927

929 if (->isBundle())

930 return MI;

931

934 if (BMI.isCandidateForAdditionalCallInfo())

935 return &BMI;

936

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

938}

939

941 assert(MI->shouldUpdateAdditionalCallInfo() &&

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

943 "candidates inside bundles");

944

946

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

949 CallSitesInfo.erase(CSIt);

950

952 if (CGIt != CalledGlobalsInfo.end())

953 CalledGlobalsInfo.erase(CGIt);

954}

955

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

960 "candidates inside bundles");

961

962 if (!New->isCandidateForAdditionalCallInfo())

964

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

969 CallSitesInfo[New] = CSInfo;

970 }

971

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

975 CalledGlobalsInfo[New] = CGInfo;

976 }

977}

978

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

983 "candidates inside bundles");

984

985 if (!New->isCandidateForAdditionalCallInfo())

987

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

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

992 CallSitesInfo.erase(CSIt);

993 CallSitesInfo[New] = CSInfo;

994 }

995

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

999 CalledGlobalsInfo.erase(CGIt);

1000 CalledGlobalsInfo[New] = CGInfo;

1001 }

1002}

1003

1006}

1007

1010 unsigned Subreg) {

1011

1013

1015

1017}

1018

1021 unsigned MaxOperand) {

1022

1024 if (!OldInstrNum)

1025 return;

1026

1027

1028

1029

1030

1031

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

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

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

1036 (void)NewMO;

1037

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

1039 continue;

1040 assert(NewMO.isDef());

1041

1042 unsigned NewInstrNum = New.getDebugInstrNum();

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

1045 }

1046}

1047

1052

1053

1054

1056 if (auto CopyDstSrc = TII.isCopyInstr(MI)) {

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

1058 } else {

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

1061 }

1062

1063 auto CacheIt = DbgPHICache.find(Dest);

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

1065 return CacheIt->second;

1066

1067

1068 auto OperandPair = salvageCopySSAImpl(MI);

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

1070 return OperandPair;

1071}

1072

1078

1079

1080

1081

1082

1083

1084

1085

1086

1087

1088

1089

1090

1091

1092

1093

1094

1095 auto GetRegAndSubreg =

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

1099 if (Cpy.isCopy()) {

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

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

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

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

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

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

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

1107 } else {

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

1110 const MachineOperand &Dest = *CopyDetails.Destination;

1111 OldReg = Dest.getReg();

1112 NewReg = Src.getReg();

1113 SubReg = Src.getSubReg();

1114 }

1115

1116 return {NewReg, SubReg};

1117 };

1118

1119

1120

1121

1122

1123 auto State = GetRegAndSubreg(MI);

1124 auto CurInst = MI.getIterator();

1126 while (true) {

1127

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

1129 break;

1130

1131

1132 if (State.second)

1133 SubregsSeen.push_back(State.second);

1134

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

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

1138

1139

1140 if (!Inst.isCopyLike() && TII .isCopyInstr(Inst))

1141 break;

1142 State = GetRegAndSubreg(Inst);

1143 };

1144

1145

1146

1147

1148

1149 auto ApplySubregisters =

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

1152

1153 unsigned NewInstrNumber = getNewDebugInstrNum();

1154

1155

1156 makeDebugValueSubstitution({NewInstrNumber, 0}, P, Subreg);

1157

1158

1159 P = {NewInstrNumber, 0};

1160 }

1161 return P;

1162 };

1163

1164

1165

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

1167

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

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

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

1171 continue;

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

1173 }

1174

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

1176 }

1177

1178

1179

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

1181 State = GetRegAndSubreg(*CurInst);

1182 Register RegToSeek = State.first;

1183

1184 auto RMII = CurInst->getReverseIterator();

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

1186 for (auto &ToExamine : PrevInstrs) {

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

1188

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

1190 continue;

1191

1192 return ApplySubregisters(

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

1194 }

1195 }

1196

1198

1199

1200

1201

1202

1203

1204

1205

1206

1207

1208

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

1211 Builder.addReg(State.first);

1212 unsigned NewNum = getNewDebugInstrNum();

1213 Builder.addImm(NewNum);

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

1215}

1216

1219

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

1222 MI.setDesc(RefII);

1223 MI.setDebugValueUndef();

1224 };

1225

1227 for (auto &MBB : *this) {

1228 for (auto &MI : MBB) {

1229 if (.isDebugRef())

1230 continue;

1231

1232 bool IsValidRef = true;

1233

1235 if (!MO.isReg())

1236 continue;

1237

1239

1240

1241

1242

1244 IsValidRef = false;

1245 break;

1246 }

1247

1250

1251

1252

1253

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

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

1257 } else {

1258

1259 unsigned OperandIdx = 0;

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

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

1262 break;

1263 ++OperandIdx;

1264 }

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

1266

1267

1268 unsigned ID = DefMI.getDebugInstrNum();

1269 MO.ChangeToDbgInstrRef(ID, OperandIdx);

1270 }

1271 }

1272

1273 if (!IsValidRef)

1274 MakeUndefDbgValue(MI);

1275 }

1276 }

1277}

1278

1280

1281

1282

1283

1285 return false;

1286

1287

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

1289 return false;

1290

1292 return true;

1293

1294 return false;

1295}

1296

1299}

1300

1303}

1304

1305

1307

1308

1309

1310

1311

1312

1313

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

1317

1318

1320

1321

1327 return 8;

1331 return 4;

1333 return 0;

1334 }

1336}

1337

1338

1340

1341

1342

1354 return 1;

1355 }

1357}

1358

1359

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

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

1364 return JumpTables.size()-1;

1365}

1366

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

1370

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

1372 return false;

1373

1374 JumpTables[JTI].Hotness = Hotness;

1375 return true;

1376}

1377

1378

1379

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

1383 bool MadeChange = false;

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

1386 return MadeChange;

1387}

1388

1389

1391 bool MadeChange = false;

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

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

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

1396 }

1397 return MadeChange;

1398}

1399

1400

1401

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

1406 bool MadeChange = false;

1409 if (MBB == Old) {

1410 MBB = New;

1411 MadeChange = true;

1412 }

1413 return MadeChange;

1414}

1415

1417 if (JumpTables.empty()) return;

1418

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

1420

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

1425 if (i != e)

1426 OS << '\n';

1427 }

1428

1429 OS << '\n';

1430}

1431

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

1434#endif

1435

1438}

1439

1440

1441

1442

1443

1444void MachineConstantPoolValue::anchor() {}

1445

1447 return DL.getTypeAllocSize(Ty);

1448}

1449

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

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

1454}

1455

1458 return true;

1459 return Val.ConstVal->needsDynamicRelocation();

1460}

1461

1467 case 4:

1469 case 8:

1471 case 16:

1473 case 32:

1475 default:

1477 }

1478}

1479

1481

1482

1485 if (C.isMachineConstantPoolEntry()) {

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

1487 delete C.Val.MachineCPVal;

1488 }

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

1491 delete CPV;

1492 }

1493}

1494

1495

1496

1499

1500 if (A == B) return true;

1501

1502

1503

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

1505

1506

1507 if (isa(A->getType()) || isa(A->getType()) ||

1508 isa(B->getType()) || isa(B->getType()))

1509 return false;

1510

1511

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

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

1514 return false;

1515

1516 bool ContainsUndefOrPoisonA = A->containsUndefOrPoisonElement();

1517

1519

1520

1521

1522

1523

1524 if (isa(A->getType()))

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

1529 IntTy, DL);

1530 if (isa(B->getType()))

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

1535 IntTy, DL);

1536

1537 if (A != B)

1538 return false;

1539

1540

1541

1542

1543

1544 return !ContainsUndefOrPoisonA;

1545}

1546

1547

1548

1550 Align Alignment) {

1551 if (Alignment > PoolAlignment) PoolAlignment = Alignment;

1552

1553

1554

1555

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

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

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

1560 Constants[i].Alignment = Alignment;

1561 return i;

1562 }

1563

1565 return Constants.size()-1;

1566}

1567

1569 Align Alignment) {

1570 if (Alignment > PoolAlignment) PoolAlignment = Alignment;

1571

1572

1573

1574

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

1576 if (Idx != -1) {

1577 MachineCPVsSharingEntries.insert(V);

1578 return (unsigned)Idx;

1579 }

1580

1582 return Constants.size()-1;

1583}

1584

1586 if (Constants.empty()) return;

1587

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

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

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

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

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

1593 else

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

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

1596 OS << "\n";

1597 }

1598}

1599

1600

1601

1602

1603

1604template <>

1605std::optionalFunction::ProfileCount

1606ProfileSummaryInfo::getEntryCountllvm::MachineFunction(

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

1609}

1610

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

1613#endif

unsigned const MachineRegisterInfo * MRI

MachineInstrBuilder MachineInstrBuilder & DefMI

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< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")

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

#define LLVM_DUMP_METHOD

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

Returns the sub type a function will return at a given Idx Should correspond to the result type of an ExtractValue instruction executed with just that one unsigned Idx

This file defines the DenseMap class.

This file defines the DenseSet and SmallDenseSet classes.

const HexagonInstrInfo * TII

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 Align getFnStackAlignment(const TargetSubtargetInfo *STI, const Function &F)

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.

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.

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

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

unsigned const TargetRegisterInfo * TRI

assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())

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

const Instruction * getFirstNonPHI() const

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

LLVM_ATTRIBUTE_RETURNS_NONNULL void * Allocate(size_t Size, Align Alignment)

Allocate space at the specified alignment.

void Deallocate(const void *Ptr, size_t Size, size_t)

This is an important base class in LLVM.

This class represents an Operation in the Expression.

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.

unsigned getPointerSize(unsigned AS=0) const

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

Align getPointerABIAlignment(unsigned AS) const

Layout pointer alignment.

iterator find(const_arg_type_t< KeyT > Val)

bool erase(const KeyT &Val)

bool contains(const_arg_type_t< KeyT > Val) const

Return true if the specified key is in the map, false otherwise.

Implements a dense probed hash-table based set.

const DataLayout & getDataLayout() const

Get the data layout of the module this function belongs to.

MaybeAlign getFnStackAlign() const

Return the stack alignment for the function.

bool hasPersonalityFn() const

Check whether this function has a personality function.

Constant * getPersonalityFn() const

Get the personality function associated with this function.

DenormalMode getDenormalMode(const fltSemantics &FPType) const

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

bool needsUnwindTableEntry() const

True if this function needs an unwind table.

bool hasFnAttribute(Attribute::AttrKind Kind) const

Return true if the function has the attribute.

bool hasMetadata() const

Return true if this value has any metadata attached to it.

MDNode * getMetadata(unsigned KindID) const

Get the current metadata attachments for the given kind, if any.

Module * getParent()

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

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

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

Context object for machine code objects.

MCSymbol * createTempSymbol()

Create a temporary symbol with a unique name.

MCSymbol * getOrCreateSymbol(const Twine &Name)

Lookup the symbol inside with the specified Name.

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

void setBBID(const UniqueBBID &V)

Sets the fixed BBID of this basic block.

void setIsEndSection(bool V=true)

instr_iterator insert(instr_iterator I, MachineInstr *M)

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

int getNumber() const

MachineBasicBlocks are uniquely numbered at the function level, unless they're not in a MachineFuncti...

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.

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.

Align getAlignment() const

Return alignment of the basic block.

void setIsBeginSection(bool V=true)

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

bool needsRelocation() const

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

bool isMachineConstantPoolEntry() const

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

union llvm::MachineConstantPoolEntry::@204 Val

The constant itself.

unsigned getSizeInBytes(const DataLayout &DL) const

SectionKind getSectionKind(const DataLayout *DL) const

Abstract base class for all machine specific constantpool value subclasses.

virtual unsigned getSizeInBytes(const DataLayout &DL) const

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.

void print(raw_ostream &OS) const

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

unsigned getConstantPoolIndex(const Constant *C, Align Alignment)

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

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

void ensureMaxAlignment(Align Alignment)

Make sure the function is at least Align bytes aligned.

void print(const MachineFunction &MF, raw_ostream &OS) const

Used by the MachineFunction printer to print information about stack objects.

void setUnsafeStackSize(uint64_t Size)

void print(raw_ostream &OS) const

Print the MachineFunctionProperties in human-readable form.

MachineFunctionProperties & set(Property P)

MachineFunctionProperties & reset(Property P)

virtual void MF_HandleChangeDesc(MachineInstr &MI, const MCInstrDesc &TID)

Callback before changing MCInstrDesc.

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.

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)

Allocate and construct an extra info structure for a MachineInstr.

int getFilterIDFor(ArrayRef< unsigned > TyIds)

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

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.

std::pair< unsigned, unsigned > DebugInstrOperandPair

Pair of instruction number and operand number.

unsigned addFrameInst(const MCCFIInstruction &Inst)

bool useDebugInstrRef() const

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

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.

void viewCFGOnly() const

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

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

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

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

const TargetSubtargetInfo & getSubtarget() const

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

MachineInstr & cloneMachineInstrBundle(MachineBasicBlock &MBB, MachineBasicBlock::iterator InsertBefore, const MachineInstr &Orig)

Clones instruction or the whole instruction bundle Orig and insert into MBB before InsertBefore.

MachineJumpTableInfo * getOrCreateJumpTableInfo(unsigned JTEntryKind)

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

StringRef getName() const

getName - Return the name of the corresponding LLVM function.

void dump() const

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

MachineInstr * CreateMachineInstr(const MCInstrDesc &MCID, DebugLoc DL, bool NoImplicit=false)

CreateMachineInstr - Allocate a new MachineInstr.

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

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

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.

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

bool needsFrameMoves() const

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

unsigned getTypeIDFor(const GlobalValue *TI)

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

void finalizeDebugInstrRefs()

Finalise any partially emitted debug instructions.

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.

void deleteMachineInstr(MachineInstr *MI)

DeleteMachineInstr - Delete the given MachineInstr.

void initTargetMachineFunctionInfo(const TargetSubtargetInfo &STI)

Initialize the target specific MachineFunctionInfo.

const char * createExternalSymbolName(StringRef Name)

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

uint32_t * allocateRegMask()

Allocate and initialize a register mask with NumRegister bits.

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

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

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

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

void setUseDebugInstrRef(bool UseInstrRef)

Set whether this function will use instruction referencing or not.

LandingPadInfo & getOrCreateLandingPadInfo(MachineBasicBlock *LandingPad)

Find or create an LandingPadInfo for the specified MachineBasicBlock.

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.

MCSymbol * addLandingPad(MachineBasicBlock *LandingPad)

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

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.

Align getAlignment() const

getAlignment - Return the alignment of the function.

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

static const unsigned int DebugOperandMemNumber

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

Function & getFunction()

Return the LLVM function that this machine code represents.

DebugInstrOperandPair salvageCopySSAImpl(MachineInstr &MI)

const MachineBasicBlock & back() const

BasicBlockListType::iterator iterator

void setDebugInstrNumberingCount(unsigned Num)

Set value of DebugInstrNumberingCount field.

bool shouldSplitStack() const

Should we be emitting segmented stack stuff for the function.

void viewCFG() const

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

bool shouldUseDebugInstrRef() const

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

const MachineFunctionProperties & getProperties() const

Get the function properties.

void eraseAdditionalCallInfo(const MachineInstr *MI)

Following functions update call site info.

MachineInstr * CloneMachineInstr(const MachineInstr *Orig)

Create a new MachineInstr which is a copy of Orig, identical in all ways except the instruction has n...

void RenumberBlocks(MachineBasicBlock *MBBFrom=nullptr)

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

const MachineBasicBlock & front() const

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

int64_t estimateFunctionSizeInBytes()

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

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

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

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

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

CreateMachineBasicBlock - Allocate a new MachineBasicBlock.

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

Copy the call site info from Old to \ New.

VariableDbgInfoMapTy VariableDbgInfos

void assignBeginEndSections()

Assign IsBeginSection IsEndSection fields for basic blocks in this function.

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.

Representation of each machine instruction.

void bundleWithPred()

Bundle this instruction with its predecessor.

bool isCopyLike() const

Return true if the instruction behaves like a copy.

unsigned getNumOperands() const

Retuns the total number of operands.

unsigned peekDebugInstrNum() const

Examine the instruction number of this MachineInstr.

unsigned getDebugInstrNum()

Fetch the instruction number of this MachineInstr.

const MachineOperand & getOperand(unsigned i) const

bool shouldUpdateAdditionalCallInfo() const

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

iterator_range< filtered_mop_iterator > all_defs()

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

bool RemoveMBBFromJumpTables(MachineBasicBlock *MBB)

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

bool ReplaceMBBInJumpTables(MachineBasicBlock *Old, MachineBasicBlock *New)

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

void print(raw_ostream &OS) const

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

unsigned getEntrySize(const DataLayout &TD) const

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

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

createJumpTableIndex - Create a new jump table.

void dump() const

dump - Call to stderr.

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

bool updateJumpTableEntryHotness(size_t JTI, MachineFunctionDataHotness Hotness)

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

unsigned getEntryAlignment(const DataLayout &TD) const

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

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

bool livein_empty() const

def_instr_iterator def_instr_begin(Register RegNo) const

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

bool hasOneDef(Register RegNo) const

Return true if there is exactly one operand defining the specified register.

livein_iterator livein_end() const

livein_iterator livein_begin() const

Manage lifetime of a slot tracker for printing IR.

void incorporateFunction(const Function &F)

Incorporate the given function.

iterator_range< debug_compile_units_iterator > debug_compile_units() const

Return an iterator for all DICompileUnits listed in this Module's llvm.dbg.cu named metadata node and...

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 TargetRegisterInfo * getRegisterInfo() const

getRegisterInfo - If register information is available, return it.

virtual const TargetFrameLowering * getFrameLowering() const

virtual const TargetInstrInfo * getInstrInfo() const

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.

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

LLVM Value Representation.

const Value * stripPointerCasts() const

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

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.

@ C

The default llvm calling convention, compatible with C.

initializer< Ty > init(const Ty &Val)

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.

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

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

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.

MaybeAlign getAlign(const Function &F, unsigned Index)

Printable printJumpTableEntryReference(unsigned Idx)

Prints a jump table entry reference.

bool isScopedEHPersonality(EHPersonality Pers)

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

MachineFunctionDataHotness

auto reverse(ContainerTy &&C)

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.

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

Attempt to constant fold a cast with the specified operand.

EHPersonality classifyEHPersonality(const Value *Pers)

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

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.

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)

Align commonAlignment(Align A, uint64_t Offset)

Returns the alignment that satisfies both alignments.

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.

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.

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)

DOTGraphTraits(bool isSimple=false)

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

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

DefaultDOTGraphTraits - This class provides the default implementations of all of the DOTGraphTraits ...

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()

MachineJumpTableEntry - One jump table in the jump table info.

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

std::vector< MachineBasicBlock * > MBBs

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

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)