Movatterモバイル変換

Go to the documentation of this file.

1//===- MachineFunction.cpp ------------------------------------------------===//

2//

3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

4// See https://llvm.org/LICENSE.txt for license information.

5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

6//

7//===----------------------------------------------------------------------===//

8//

9// Collect native machine code information for a function. This allows

10// target-specific information about the generated code to be stored with each

11// function.

12//

13//===----------------------------------------------------------------------===//

15#include "llvm/CodeGen/MachineFunction.h"

16#include "llvm/ADT/BitVector.h"

17#include "llvm/ADT/DenseMap.h"

18#include "llvm/ADT/DenseSet.h"

19#include "llvm/ADT/STLExtras.h"

20#include "llvm/ADT/SmallString.h"

21#include "llvm/ADT/SmallVector.h"

22#include "llvm/ADT/StringRef.h"

23#include "llvm/ADT/Twine.h"

24#include "llvm/Analysis/ConstantFolding.h"

25#include "llvm/Analysis/ProfileSummaryInfo.h"

26#include "llvm/CodeGen/MachineBasicBlock.h"

27#include "llvm/CodeGen/MachineConstantPool.h"

28#include "llvm/CodeGen/MachineFrameInfo.h"

29#include "llvm/CodeGen/MachineInstr.h"

30#include "llvm/CodeGen/MachineJumpTableInfo.h"

31#include "llvm/CodeGen/MachineMemOperand.h"

32#include "llvm/CodeGen/MachineModuleInfo.h"

33#include "llvm/CodeGen/MachineRegisterInfo.h"

34#include "llvm/CodeGen/PseudoSourceValue.h"

35#include "llvm/CodeGen/PseudoSourceValueManager.h"

36#include "llvm/CodeGen/TargetFrameLowering.h"

37#include "llvm/CodeGen/TargetInstrInfo.h"

38#include "llvm/CodeGen/TargetLowering.h"

39#include "llvm/CodeGen/TargetRegisterInfo.h"

40#include "llvm/CodeGen/TargetSubtargetInfo.h"

41#include "llvm/CodeGen/WasmEHFuncInfo.h"

42#include "llvm/CodeGen/WinEHFuncInfo.h"

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

44#include "llvm/IR/Attributes.h"

45#include "llvm/IR/BasicBlock.h"

46#include "llvm/IR/Constant.h"

47#include "llvm/IR/DataLayout.h"

48#include "llvm/IR/DerivedTypes.h"

49#include "llvm/IR/EHPersonalities.h"

50#include "llvm/IR/Function.h"

51#include "llvm/IR/GlobalValue.h"

52#include "llvm/IR/Instruction.h"

53#include "llvm/IR/Instructions.h"

54#include "llvm/IR/Metadata.h"

55#include "llvm/IR/Module.h"

56#include "llvm/IR/ModuleSlotTracker.h"

57#include "llvm/IR/Value.h"

58#include "llvm/MC/MCContext.h"

59#include "llvm/MC/MCSymbol.h"

60#include "llvm/MC/SectionKind.h"

61#include "llvm/Support/Casting.h"

62#include "llvm/Support/CommandLine.h"

63#include "llvm/Support/Compiler.h"

64#include "llvm/Support/DOTGraphTraits.h"

65#include "llvm/Support/ErrorHandling.h"

66#include "llvm/Support/GraphWriter.h"

67#include "llvm/Support/raw_ostream.h"

68#include "llvm/Target/TargetMachine.h"

69#include <algorithm>

70#include <cassert>

71#include <cstddef>

72#include <cstdint>

73#include <iterator>

74#include <string>

75#include <utility>

76#include <vector>

78#include "LiveDebugValues/LiveDebugValues.h"

80using namespacellvm;

82#define DEBUG_TYPE "codegen"

84staticcl::opt<unsigned>AlignAllFunctions(

85"align-all-functions",

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

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

88cl::init(0),cl::Hidden);

90staticconstchar *getPropertyName(MachineFunctionProperties::Property Prop) {

91usingP =MachineFunctionProperties::Property;

93// clang-format off

94switch(Prop) {

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

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

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

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

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

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

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

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

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

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

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

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

107 }

108// clang-format on

109llvm_unreachable("Invalid machine function property");

110}

111

112voidsetUnsafeStackSize(constFunction &F,MachineFrameInfo &FrameInfo) {

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

114return;

115

116auto *Existing =

117 dyn_cast_or_null<MDTuple>(F.getMetadata(LLVMContext::MD_annotation));

118

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

120return;

121

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

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

124if (N.equalsStr(MetadataName)) {

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

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

127 FrameInfo.setUnsafeStackSize(Val);

128 }

129 }

130 }

131}

132

133// Pin the vtable to this file.

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

135

136voidMachineFunctionProperties::print(raw_ostream &OS) const{

137constchar *Separator ="";

138for (BitVector::size_type I = 0;I < Properties.size(); ++I) {

139if (!Properties[I])

140continue;

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

142 Separator =", ";

143 }

144}

145

146//===----------------------------------------------------------------------===//

147// MachineFunction implementation

148//===----------------------------------------------------------------------===//

149

150// Out-of-line virtual method.

151MachineFunctionInfo::~MachineFunctionInfo() =default;

152

153voidilist_alloc_traits<MachineBasicBlock>::deleteNode(MachineBasicBlock *MBB) {

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

155}

156

157staticinlineAlign getFnStackAlignment(constTargetSubtargetInfo *STI,

158constFunction &F) {

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

160return *MA;

161return STI->getFrameLowering()->getStackAlign();

162}

163

164MachineFunction::MachineFunction(Function &F,constTargetMachine &Target,

165constTargetSubtargetInfo &STI,MCContext &Ctx,

166unsigned FunctionNum)

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

168 FunctionNumber = FunctionNum;

169 init();

170}

171

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

173if (TheDelegate)

174 TheDelegate->MF_HandleInsertion(MI);

175}

176

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

178if (TheDelegate)

179 TheDelegate->MF_HandleRemoval(MI);

180}

181

182voidMachineFunction::handleChangeDesc(MachineInstr &MI,

183constMCInstrDesc &TID) {

184if (TheDelegate)

185 TheDelegate->MF_HandleChangeDesc(MI, TID);

186}

187

188void MachineFunction::init() {

189// Assume the function starts in SSA form with correct liveness.

190 Properties.set(MachineFunctionProperties::Property::IsSSA);

191 Properties.set(MachineFunctionProperties::Property::TracksLiveness);

192if (STI->getRegisterInfo())

193 RegInfo =new (Allocator)MachineRegisterInfo(this);

194else

195 RegInfo =nullptr;

196

197 MFInfo =nullptr;

198

199// We can realign the stack if the target supports it and the user hasn't

200// explicitly asked us not to.

201bool CanRealignSP = STI->getFrameLowering()->isStackRealignable() &&

202 !F.hasFnAttribute("no-realign-stack");

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

204 F.hasFnAttribute("stackrealign");

205 FrameInfo =new (Allocator)MachineFrameInfo(

206getFnStackAlignment(STI, F),/*StackRealignable=*/CanRealignSP,

207/*ForcedRealign=*/ForceRealignSP && CanRealignSP);

208

209setUnsafeStackSize(F, *FrameInfo);

210

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

212 FrameInfo->ensureMaxAlignment(*F.getFnStackAlign());

213

214ConstantPool =new (Allocator)MachineConstantPool(getDataLayout());

215 Alignment = STI->getTargetLowering()->getMinFunctionAlignment();

216

217// FIXME: Shouldn't use pref alignment if explicit alignment is set on F.

218// FIXME: Use Function::hasOptSize().

219if (!F.hasFnAttribute(Attribute::OptimizeForSize))

220 Alignment = std::max(Alignment,

221 STI->getTargetLowering()->getPrefFunctionAlignment());

222

223// -fsanitize=function and -fsanitize=kcfi instrument indirect function calls

224// to load a type hash before the function label. Ensure functions are aligned

225// by a least 4 to avoid unaligned access, which is especially important for

226// -mno-unaligned-access.

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

228 F.getMetadata(LLVMContext::MD_kcfi_type))

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

230

231if (AlignAllFunctions)

232 Alignment =Align(1ULL <<AlignAllFunctions);

233

234 JumpTableInfo =nullptr;

235

236if (isFuncletEHPersonality(classifyEHPersonality(

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

238 WinEHInfo =new (Allocator)WinEHFuncInfo();

239 }

240

241if (isScopedEHPersonality(classifyEHPersonality(

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

243 WasmEHInfo =new (Allocator)WasmEHFuncInfo();

244 }

245

246assert(Target.isCompatibleDataLayout(getDataLayout()) &&

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

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

249

250 PSVManager = std::make_unique<PseudoSourceValueManager>(getTarget());

251}

252

253voidMachineFunction::initTargetMachineFunctionInfo(

254constTargetSubtargetInfo &STI) {

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

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

257}

258

259MachineFunction::~MachineFunction() {

260 clear();

261}

262

263void MachineFunction::clear() {

264 Properties.reset();

265// Don't call destructors on MachineInstr and MachineOperand. All of their

266// memory comes from the BumpPtrAllocator which is about to be purged.

267//

268// Do call MachineBasicBlock destructors, it contains std::vectors.

269for (iterator I =begin(), E =end();I != E;I = BasicBlocks.erase(I))

270I->Insts.clearAndLeakNodesUnsafely();

271 MBBNumbering.clear();

272

273 InstructionRecycler.clear(Allocator);

274 OperandRecycler.clear(Allocator);

275 BasicBlockRecycler.clear(Allocator);

276 CodeViewAnnotations.clear();

277VariableDbgInfos.clear();

278if (RegInfo) {

279 RegInfo->~MachineRegisterInfo();

280 Allocator.Deallocate(RegInfo);

281 }

282if (MFInfo) {

283 MFInfo->~MachineFunctionInfo();

284 Allocator.Deallocate(MFInfo);

285 }

286

287 FrameInfo->~MachineFrameInfo();

288 Allocator.Deallocate(FrameInfo);

289

290ConstantPool->~MachineConstantPool();

291 Allocator.Deallocate(ConstantPool);

292

293if (JumpTableInfo) {

294 JumpTableInfo->~MachineJumpTableInfo();

295 Allocator.Deallocate(JumpTableInfo);

296 }

297

298if (WinEHInfo) {

299 WinEHInfo->~WinEHFuncInfo();

300 Allocator.Deallocate(WinEHInfo);

301 }

302

303if (WasmEHInfo) {

304 WasmEHInfo->~WasmEHFuncInfo();

305 Allocator.Deallocate(WasmEHInfo);

306 }

307}

308

309constDataLayout &MachineFunction::getDataLayout() const{

310return F.getDataLayout();

311}

312

313/// Get the JumpTableInfo for this function.

314/// If it does not already exist, allocate one.

315MachineJumpTableInfo *MachineFunction::

316getOrCreateJumpTableInfo(unsigned EntryKind) {

317if (JumpTableInfo)return JumpTableInfo;

318

319 JumpTableInfo =new (Allocator)

320MachineJumpTableInfo((MachineJumpTableInfo::JTEntryKind)EntryKind);

321return JumpTableInfo;

322}

323

324DenormalMode MachineFunction::getDenormalMode(constfltSemantics &FPType) const{

325return F.getDenormalMode(FPType);

326}

327

328/// Should we be emitting segmented stack stuff for the function

329boolMachineFunction::shouldSplitStack() const{

330returngetFunction().hasFnAttribute("split-stack");

331}

332

333[[nodiscard]]unsigned

334MachineFunction::addFrameInst(constMCCFIInstruction &Inst) {

335 FrameInstructions.push_back(Inst);

336return FrameInstructions.size() - 1;

337}

338

339/// This discards all of the MachineBasicBlock numbers and recomputes them.

340/// This guarantees that the MBB numbers are sequential, dense, and match the

341/// ordering of the blocks within the function. If a specific MachineBasicBlock

342/// is specified, only that block and those after it are renumbered.

343voidMachineFunction::RenumberBlocks(MachineBasicBlock *MBB) {

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

345MachineFunction::iterator MBBI, E =end();

346if (MBB ==nullptr)

347MBBI =begin();

348else

349MBBI =MBB->getIterator();

350

351// Figure out the block number this should have.

352unsigned BlockNo = 0;

353if (MBBI !=begin())

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

355

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

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

358// Remove use of the old number.

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

360assert(MBBNumbering[MBBI->getNumber()] == &*MBBI &&

361"MBB number mismatch!");

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

363 }

364

365// If BlockNo is already taken, set that block's number to -1.

366if (MBBNumbering[BlockNo])

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

368

369 MBBNumbering[BlockNo] = &*MBBI;

370MBBI->setNumber(BlockNo);

371 }

372 }

373

374// Okay, all the blocks are renumbered. If we have compactified the block

375// numbering, shrink MBBNumbering now.

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

377 MBBNumbering.resize(BlockNo);

378 MBBNumberingEpoch++;

379}

380

381int64_tMachineFunction::estimateFunctionSizeInBytes() {

382constTargetInstrInfo &TII = *getSubtarget().getInstrInfo();

383constAlign FunctionAlignment =getAlignment();

384MachineFunction::iterator MBBI =begin(), E =end();

385 /// Offset - Distance from the beginning of the function to the end

386 /// of the basic block.

387 int64_tOffset = 0;

388

389for (;MBBI != E; ++MBBI) {

390constAlign Alignment =MBBI->getAlignment();

391 int64_tBlockSize = 0;

392

393for (auto &MI : *MBBI) {

394BlockSize +=TII.getInstSizeInBytes(MI);

395 }

396

397 int64_t OffsetBB;

398if (Alignment <= FunctionAlignment) {

399 OffsetBB =alignTo(Offset, Alignment);

400 }else {

401// The alignment of this MBB is larger than the function's alignment, so

402// we can't tell whether or not it will insert nops. Assume that it will.

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

404 FunctionAlignment.value();

405 }

406Offset = OffsetBB +BlockSize;

407 }

408

409returnOffset;

410}

411

412/// This method iterates over the basic blocks and assigns their IsBeginSection

413/// and IsEndSection fields. This must be called after MBB layout is finalized

414/// and the SectionID's are assigned to MBBs.

415voidMachineFunction::assignBeginEndSections() {

416front().setIsBeginSection();

417auto CurrentSectionID =front().getSectionID();

418for (autoMBBI = std::next(begin()), E =end();MBBI != E; ++MBBI) {

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

420continue;

421MBBI->setIsBeginSection();

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

423 CurrentSectionID =MBBI->getSectionID();

424 }

425back().setIsEndSection();

426}

427

428/// Allocate a new MachineInstr. Use this instead of `new MachineInstr'.

429MachineInstr *MachineFunction::CreateMachineInstr(constMCInstrDesc &MCID,

430DebugLoc DL,

431bool NoImplicit) {

432returnnew (InstructionRecycler.Allocate<MachineInstr>(Allocator))

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

434}

435

436/// Create a new MachineInstr which is a copy of the 'Orig' instruction,

437/// identical in all ways except the instruction has no parent, prev, or next.

438MachineInstr *

439MachineFunction::CloneMachineInstr(constMachineInstr *Orig) {

440returnnew (InstructionRecycler.Allocate<MachineInstr>(Allocator))

441MachineInstr(*this, *Orig);

442}

443

444MachineInstr &MachineFunction::cloneMachineInstrBundle(

445MachineBasicBlock &MBB,MachineBasicBlock::iterator InsertBefore,

446constMachineInstr &Orig) {

447MachineInstr *FirstClone =nullptr;

448MachineBasicBlock::const_instr_iterator I = Orig.getIterator();

449while (true) {

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

451MBB.insert(InsertBefore, Cloned);

452if (FirstClone ==nullptr) {

453 FirstClone = Cloned;

454 }else {

455 Cloned->bundleWithPred();

456 }

457

458if (!I->isBundledWithSucc())

459break;

460 ++I;

461 }

462// Copy over call info to the cloned instruction if needed. If Orig is in

463// a bundle, copyAdditionalCallInfo takes care of finding the call instruction

464// in the bundle.

465if (Orig.shouldUpdateAdditionalCallInfo())

466copyAdditionalCallInfo(&Orig, FirstClone);

467return *FirstClone;

468}

469

470/// Delete the given MachineInstr.

471///

472/// This function also serves as the MachineInstr destructor - the real

473/// ~MachineInstr() destructor must be empty.

474voidMachineFunction::deleteMachineInstr(MachineInstr *MI) {

475// Verify that a call site info is at valid state. This assertion should

476// be triggered during the implementation of support for the

477// call site info of a new architecture. If the assertion is triggered,

478// back trace will tell where to insert a call to updateCallSiteInfo().

479assert((!MI->isCandidateForAdditionalCallInfo() ||

480 !CallSitesInfo.contains(MI)) &&

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

482// Verify that the "called globals" info is in a valid state.

483assert((!MI->isCandidateForAdditionalCallInfo() ||

484 !CalledGlobalsInfo.contains(MI)) &&

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

486// Strip it for parts. The operand array and the MI object itself are

487// independently recyclable.

488if (MI->Operands)

489deallocateOperandArray(MI->CapOperands,MI->Operands);

490// Don't call ~MachineInstr() which must be trivial anyway because

491// ~MachineFunction drops whole lists of MachineInstrs wihout calling their

492// destructors.

493 InstructionRecycler.Deallocate(Allocator,MI);

494}

495

496/// Allocate a new MachineBasicBlock. Use this instead of

497/// `new MachineBasicBlock'.

498MachineBasicBlock *

499MachineFunction::CreateMachineBasicBlock(constBasicBlock *BB,

500 std::optional<UniqueBBID> BBID) {

501MachineBasicBlock *MBB =

502new (BasicBlockRecycler.Allocate<MachineBasicBlock>(Allocator))

503MachineBasicBlock(*this, BB);

504// Set BBID for `-basic-block-sections=list` and `-basic-block-address-map` to

505// allow robust mapping of profiles to basic blocks.

506if (Target.Options.BBAddrMap ||

507Target.getBBSectionsType() ==BasicBlockSection::List)

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

509returnMBB;

510}

511

512/// Delete the given MachineBasicBlock.

513voidMachineFunction::deleteMachineBasicBlock(MachineBasicBlock *MBB) {

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

515// Clean up any references to MBB in jump tables before deleting it.

516if (JumpTableInfo)

517 JumpTableInfo->RemoveMBBFromJumpTables(MBB);

518MBB->~MachineBasicBlock();

519 BasicBlockRecycler.Deallocate(Allocator,MBB);

520}

521

522MachineMemOperand *MachineFunction::getMachineMemOperand(

523MachinePointerInfo PtrInfo,MachineMemOperand::Flags F,LocationSize Size,

524Align BaseAlignment,constAAMDNodes &AAInfo,constMDNode *Ranges,

525SyncScope::ID SSID,AtomicOrdering Ordering,

526AtomicOrdering FailureOrdering) {

527assert((!Size.hasValue() ||

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

529"Unexpected an unknown size to be represented using "

530"LocationSize::beforeOrAfter()");

531returnnew (Allocator)

532MachineMemOperand(PtrInfo,F,Size, BaseAlignment, AAInfo, Ranges, SSID,

533 Ordering, FailureOrdering);

534}

535

536MachineMemOperand *MachineFunction::getMachineMemOperand(

537MachinePointerInfo PtrInfo,MachineMemOperand::Flags f,LLT MemTy,

538Align base_alignment,constAAMDNodes &AAInfo,constMDNode *Ranges,

539SyncScope::ID SSID,AtomicOrdering Ordering,

540AtomicOrdering FailureOrdering) {

541returnnew (Allocator)

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

543 Ordering, FailureOrdering);

544}

545

546MachineMemOperand *

547MachineFunction::getMachineMemOperand(constMachineMemOperand *MMO,

548constMachinePointerInfo &PtrInfo,

549LocationSize Size) {

550assert((!Size.hasValue() ||

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

552"Unexpected an unknown size to be represented using "

553"LocationSize::beforeOrAfter()");

554returnnew (Allocator)

555MachineMemOperand(PtrInfo, MMO->getFlags(),Size, MMO->getBaseAlign(),

556AAMDNodes(),nullptr, MMO->getSyncScopeID(),

557 MMO->getSuccessOrdering(), MMO->getFailureOrdering());

558}

559

560MachineMemOperand *MachineFunction::getMachineMemOperand(

561constMachineMemOperand *MMO,constMachinePointerInfo &PtrInfo,LLT Ty) {

562returnnew (Allocator)

563MachineMemOperand(PtrInfo, MMO->getFlags(), Ty, MMO->getBaseAlign(),

564AAMDNodes(),nullptr, MMO->getSyncScopeID(),

565 MMO->getSuccessOrdering(), MMO->getFailureOrdering());

566}

567

568MachineMemOperand *

569MachineFunction::getMachineMemOperand(constMachineMemOperand *MMO,

570 int64_tOffset,LLT Ty) {

571constMachinePointerInfo &PtrInfo = MMO->getPointerInfo();

572

573// If there is no pointer value, the offset isn't tracked so we need to adjust

574// the base alignment.

575Align Alignment = PtrInfo.V.isNull()

576 ?commonAlignment(MMO->getBaseAlign(),Offset)

577 : MMO->getBaseAlign();

578

579// Do not preserve ranges, since we don't necessarily know what the high bits

580// are anymore.

581returnnew (Allocator)MachineMemOperand(

582 PtrInfo.getWithOffset(Offset), MMO->getFlags(), Ty, Alignment,

583 MMO->getAAInfo(),nullptr, MMO->getSyncScopeID(),

584 MMO->getSuccessOrdering(), MMO->getFailureOrdering());

585}

586

587MachineMemOperand *

588MachineFunction::getMachineMemOperand(constMachineMemOperand *MMO,

589constAAMDNodes &AAInfo) {

590MachinePointerInfo MPI = MMO->getValue() ?

591MachinePointerInfo(MMO->getValue(), MMO->getOffset()) :

592MachinePointerInfo(MMO->getPseudoValue(), MMO->getOffset());

593

594returnnew (Allocator)MachineMemOperand(

595 MPI, MMO->getFlags(), MMO->getSize(), MMO->getBaseAlign(), AAInfo,

596 MMO->getRanges(), MMO->getSyncScopeID(), MMO->getSuccessOrdering(),

597 MMO->getFailureOrdering());

598}

599

600MachineMemOperand *

601MachineFunction::getMachineMemOperand(constMachineMemOperand *MMO,

602MachineMemOperand::Flags Flags) {

603returnnew (Allocator)MachineMemOperand(

604 MMO->getPointerInfo(), Flags, MMO->getSize(), MMO->getBaseAlign(),

605 MMO->getAAInfo(), MMO->getRanges(), MMO->getSyncScopeID(),

606 MMO->getSuccessOrdering(), MMO->getFailureOrdering());

607}

608

609MachineInstr::ExtraInfo *MachineFunction::createMIExtraInfo(

610ArrayRef<MachineMemOperand *> MMOs,MCSymbol *PreInstrSymbol,

611MCSymbol *PostInstrSymbol,MDNode *HeapAllocMarker,MDNode *PCSections,

612uint32_t CFIType,MDNode *MMRAs) {

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

614 PostInstrSymbol, HeapAllocMarker,

615 PCSections, CFIType, MMRAs);

616}

617

618constchar *MachineFunction::createExternalSymbolName(StringRef Name) {

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

620llvm::copy(Name, Dest);

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

622return Dest;

623}

624

625uint32_t *MachineFunction::allocateRegMask() {

626unsigned NumRegs =getSubtarget().getRegisterInfo()->getNumRegs();

627unsignedSize =MachineOperand::getRegMaskSize(NumRegs);

628uint32_t *Mask = Allocator.Allocate<uint32_t>(Size);

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

630return Mask;

631}

632

633ArrayRef<int>MachineFunction::allocateShuffleMask(ArrayRef<int> Mask) {

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

635copy(Mask, AllocMask);

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

637}

638

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

640LLVM_DUMP_METHODvoidMachineFunction::dump() const{

641print(dbgs());

642}

643#endif

644

645StringRef MachineFunction::getName() const{

646returngetFunction().getName();

647}

648

649voidMachineFunction::print(raw_ostream &OS,constSlotIndexes *Indexes) const{

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

651getProperties().print(OS);

652OS <<'\n';

653

654// Print Frame Information

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

656

657// Print JumpTable Information

658if (JumpTableInfo)

659 JumpTableInfo->print(OS);

660

661// Print Constant Pool

662ConstantPool->print(OS);

663

664constTargetRegisterInfo *TRI =getSubtarget().getRegisterInfo();

665

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

667OS <<"Function Live Ins: ";

668for (MachineRegisterInfo::livein_iterator

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

670OS <<printReg(I->first,TRI);

671if (I->second)

672OS <<" in " <<printReg(I->second,TRI);

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

674OS <<", ";

675 }

676OS <<'\n';

677 }

678

679ModuleSlotTracker MST(getFunction().getParent());

680 MST.incorporateFunction(getFunction());

681for (constauto &BB : *this) {

682OS <<'\n';

683// If we print the whole function, print it at its most verbose level.

684 BB.print(OS, MST, Indexes,/*IsStandalone=*/true);

685 }

686

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

688}

689

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

691boolMachineFunction::needsFrameMoves() const{

692// TODO: Ideally, what we'd like is to have a switch that allows emitting

693// synchronous (precise at call-sites only) CFA into .eh_frame. However, even

694// under this switch, we'd like .debug_frame to be precise when using -g. At

695// this moment, there's no way to specify that some CFI directives go into

696// .eh_frame only, while others go into .debug_frame only.

697returngetTarget().Options.ForceDwarfFrameSection ||

698 F.needsUnwindTableEntry() ||

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

700}

701

702namespacellvm {

703

704template<>

705structDOTGraphTraits<const MachineFunction*> :publicDefaultDOTGraphTraits {

706DOTGraphTraits(boolisSimple =false) :DefaultDOTGraphTraits(isSimple) {}

707

708static std::stringgetGraphName(constMachineFunction *F) {

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

710 }

711

712 std::stringgetNodeLabel(constMachineBasicBlock *Node,

713constMachineFunction *Graph) {

714 std::string OutStr;

715 {

716raw_string_ostream OSS(OutStr);

717

718if (isSimple()) {

719 OSS <<printMBBReference(*Node);

720if (constBasicBlock *BB = Node->getBasicBlock())

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

722 }else

723 Node->print(OSS);

724 }

725

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

727

728// Process string output to make it nicer...

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

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

731 OutStr[i] ='\\';

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

733 }

734return OutStr;

735 }

736 };

737

738}// end namespace llvm

739

740voidMachineFunction::viewCFG() const

741{

742#ifndef NDEBUG

743ViewGraph(this,"mf" +getName());

744#else

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

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

747#endif// NDEBUG

748}

749

750voidMachineFunction::viewCFGOnly() const

751{

752#ifndef NDEBUG

753ViewGraph(this,"mf" +getName(),true);

754#else

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

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

757#endif// NDEBUG

758}

759

760/// Add the specified physical register as a live-in value and

761/// create a corresponding virtual register for it.

762Register MachineFunction::addLiveIn(MCRegister PReg,

763constTargetRegisterClass *RC) {

764MachineRegisterInfo &MRI =getRegInfo();

765Register VReg =MRI.getLiveInVirtReg(PReg);

766if (VReg) {

767constTargetRegisterClass *VRegRC =MRI.getRegClass(VReg);

768 (void)VRegRC;

769// A physical register can be added several times.

770// Between two calls, the register class of the related virtual register

771// may have been constrained to match some operation constraints.

772// In that case, check that the current register class includes the

773// physical register and is a sub class of the specified RC.

774assert((VRegRC == RC || (VRegRC->contains(PReg) &&

775 RC->hasSubClassEq(VRegRC))) &&

776"Register class mismatch!");

777return VReg;

778 }

779 VReg =MRI.createVirtualRegister(RC);

780MRI.addLiveIn(PReg, VReg);

781return VReg;

782}

783

784/// Return the MCSymbol for the specified non-empty jump table.

785/// If isLinkerPrivate is specified, an 'l' label is returned, otherwise a

786/// normal 'L' label is returned.

787MCSymbol *MachineFunction::getJTISymbol(unsigned JTI,MCContext &Ctx,

788bool isLinkerPrivate) const{

789constDataLayout &DL =getDataLayout();

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

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

792

793StringRef Prefix = isLinkerPrivate ?DL.getLinkerPrivateGlobalPrefix()

794 :DL.getPrivateGlobalPrefix();

795SmallString<60>Name;

796raw_svector_ostream(Name)

797 << Prefix <<"JTI" <<getFunctionNumber() <<'_' << JTI;

798return Ctx.getOrCreateSymbol(Name);

799}

800

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

802MCSymbol *MachineFunction::getPICBaseSymbol() const{

803constDataLayout &DL =getDataLayout();

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

805Twine(getFunctionNumber()) +"$pb");

806}

807

808/// \name Exception Handling

809/// \{

810

811LandingPadInfo &

812MachineFunction::getOrCreateLandingPadInfo(MachineBasicBlock *LandingPad) {

813unsignedN = LandingPads.size();

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

815LandingPadInfo &LP = LandingPads[i];

816if (LP.LandingPadBlock == LandingPad)

817return LP;

818 }

819

820 LandingPads.push_back(LandingPadInfo(LandingPad));

821return LandingPads[N];

822}

823

824voidMachineFunction::addInvoke(MachineBasicBlock *LandingPad,

825MCSymbol *BeginLabel,MCSymbol *EndLabel) {

826LandingPadInfo &LP =getOrCreateLandingPadInfo(LandingPad);

827 LP.BeginLabels.push_back(BeginLabel);

828 LP.EndLabels.push_back(EndLabel);

829}

830

831MCSymbol *MachineFunction::addLandingPad(MachineBasicBlock *LandingPad) {

832MCSymbol *LandingPadLabel = Ctx.createTempSymbol();

833LandingPadInfo &LP =getOrCreateLandingPadInfo(LandingPad);

834 LP.LandingPadLabel = LandingPadLabel;

835

836BasicBlock::const_iterator FirstI =

837 LandingPad->getBasicBlock()->getFirstNonPHIIt();

838if (constauto *LPI = dyn_cast<LandingPadInst>(FirstI)) {

839// If there's no typeid list specified, then "cleanup" is implicit.

840// Otherwise, id 0 is reserved for the cleanup action.

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

842 LP.TypeIds.push_back(0);

843

844// FIXME: New EH - Add the clauses in reverse order. This isn't 100%

845// correct, but we need to do it this way because of how the DWARF EH

846// emitter processes the clauses.

847for (unsignedI = LPI->getNumClauses();I != 0; --I) {

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

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

850 LP.TypeIds.push_back(

851getTypeIDFor(dyn_cast<GlobalValue>(Val->stripPointerCasts())));

852 }else {

853// Add filters in a list.

854auto *CVal = cast<Constant>(Val);

855SmallVector<unsigned, 4> FilterList;

856for (constUse &U : CVal->operands())

857 FilterList.push_back(

858getTypeIDFor(cast<GlobalValue>(U->stripPointerCasts())));

859

860 LP.TypeIds.push_back(getFilterIDFor(FilterList));

861 }

862 }

863

864 }elseif (constauto *CPI = dyn_cast<CatchPadInst>(FirstI)) {

865for (unsignedI = CPI->arg_size();I != 0; --I) {

866auto *TypeInfo =

867 dyn_cast<GlobalValue>(CPI->getArgOperand(I - 1)->stripPointerCasts());

868 LP.TypeIds.push_back(getTypeIDFor(TypeInfo));

869 }

870

871 }else {

872assert(isa<CleanupPadInst>(FirstI) &&"Invalid landingpad!");

873 }

874

875return LandingPadLabel;

876}

877

878voidMachineFunction::setCallSiteLandingPad(MCSymbol *Sym,

879ArrayRef<unsigned> Sites) {

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

881}

882

883unsignedMachineFunction::getTypeIDFor(constGlobalValue *TI) {

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

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

886

887 TypeInfos.push_back(TI);

888return TypeInfos.size();

889}

890

891intMachineFunction::getFilterIDFor(ArrayRef<unsigned> TyIds) {

892// If the new filter coincides with the tail of an existing filter, then

893// re-use the existing filter. Folding filters more than this requires

894// re-ordering filters and/or their elements - probably not worth it.

895for (unsigned i : FilterEnds) {

896unsigned j = TyIds.size();

897

898while (i && j)

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

900goto try_next;

901

902if (!j)

903// The new filter coincides with range [i, end) of the existing filter.

904return -(1 + i);

905

906try_next:;

907 }

908

909// Add the new filter.

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

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

912llvm::append_range(FilterIds, TyIds);

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

914 FilterIds.push_back(0);// terminator

915return FilterID;

916}

917

918MachineFunction::CallSiteInfoMap::iterator

919MachineFunction::getCallSiteInfo(constMachineInstr *MI) {

920assert(MI->isCandidateForAdditionalCallInfo() &&

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

922

923if (!Target.Options.EmitCallSiteInfo)

924return CallSitesInfo.end();

925return CallSitesInfo.find(MI);

926}

927

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

929staticconstMachineInstr *getCallInstr(constMachineInstr *MI) {

930if (!MI->isBundle())

931returnMI;

932

933for (constauto &BMI :make_range(getBundleStart(MI->getIterator()),

934getBundleEnd(MI->getIterator())))

935if (BMI.isCandidateForAdditionalCallInfo())

936return &BMI;

937

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

939}

940

941voidMachineFunction::eraseAdditionalCallInfo(constMachineInstr *MI) {

942assert(MI->shouldUpdateAdditionalCallInfo() &&

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

944"candidates inside bundles");

945

946constMachineInstr *CallMI =getCallInstr(MI);

947

948CallSiteInfoMap::iterator CSIt = getCallSiteInfo(CallMI);

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

950 CallSitesInfo.erase(CSIt);

951

952CalledGlobalsMap::iterator CGIt = CalledGlobalsInfo.find(CallMI);

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

954 CalledGlobalsInfo.erase(CGIt);

955}

956

957voidMachineFunction::copyAdditionalCallInfo(constMachineInstr *Old,

958constMachineInstr *New) {

959assert(Old->shouldUpdateAdditionalCallInfo() &&

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

961"candidates inside bundles");

962

963if (!New->isCandidateForAdditionalCallInfo())

964returneraseAdditionalCallInfo(Old);

965

966constMachineInstr *OldCallMI =getCallInstr(Old);

967CallSiteInfoMap::iterator CSIt = getCallSiteInfo(OldCallMI);

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

969CallSiteInfo CSInfo = CSIt->second;

970 CallSitesInfo[New] = CSInfo;

971 }

972

973CalledGlobalsMap::iterator CGIt = CalledGlobalsInfo.find(OldCallMI);

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

975CalledGlobalInfo CGInfo = CGIt->second;

976 CalledGlobalsInfo[New] = CGInfo;

977 }

978}

979

980voidMachineFunction::moveAdditionalCallInfo(constMachineInstr *Old,

981constMachineInstr *New) {

982assert(Old->shouldUpdateAdditionalCallInfo() &&

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

984"candidates inside bundles");

985

986if (!New->isCandidateForAdditionalCallInfo())

987returneraseAdditionalCallInfo(Old);

988

989constMachineInstr *OldCallMI =getCallInstr(Old);

990CallSiteInfoMap::iterator CSIt = getCallSiteInfo(OldCallMI);

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

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

993 CallSitesInfo.erase(CSIt);

994 CallSitesInfo[New] = CSInfo;

995 }

996

997CalledGlobalsMap::iterator CGIt = CalledGlobalsInfo.find(OldCallMI);

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

999CalledGlobalInfo CGInfo = std::move(CGIt->second);

1000 CalledGlobalsInfo.erase(CGIt);

1001 CalledGlobalsInfo[New] = CGInfo;

1002 }

1003}

1004

1005voidMachineFunction::setDebugInstrNumberingCount(unsigned Num) {

1006DebugInstrNumberingCount = Num;

1007}

1008

1009voidMachineFunction::makeDebugValueSubstitution(DebugInstrOperandPair A,

1010DebugInstrOperandPair B,

1011unsigned Subreg) {

1012// Catch any accidental self-loops.

1013assert(A.first !=B.first);

1014// Don't allow any substitutions _from_ the memory operand number.

1015assert(A.second !=DebugOperandMemNumber);

1016

1017DebugValueSubstitutions.push_back({A,B, Subreg});

1018}

1019

1020voidMachineFunction::substituteDebugValuesForInst(constMachineInstr &Old,

1021MachineInstr &New,

1022unsigned MaxOperand) {

1023// If the Old instruction wasn't tracked at all, there is no work to do.

1024unsigned OldInstrNum = Old.peekDebugInstrNum();

1025if (!OldInstrNum)

1026return;

1027

1028// Iterate over all operands looking for defs to create substitutions for.

1029// Avoid creating new instr numbers unless we create a new substitution.

1030// While this has no functional effect, it risks confusing someone reading

1031// MIR output.

1032// Examine all the operands, or the first N specified by the caller.

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

1034for (unsignedintI = 0;I < MaxOperand; ++I) {

1035constauto &OldMO = Old.getOperand(I);

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

1037 (void)NewMO;

1038

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

1040continue;

1041assert(NewMO.isDef());

1042

1043unsigned NewInstrNum = New.getDebugInstrNum();

1044makeDebugValueSubstitution(std::make_pair(OldInstrNum,I),

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

1046 }

1047}

1048

1049autoMachineFunction::salvageCopySSA(

1050MachineInstr &MI,DenseMap<Register, DebugInstrOperandPair> &DbgPHICache)

1051 ->DebugInstrOperandPair {

1052constTargetInstrInfo &TII = *getSubtarget().getInstrInfo();

1053

1054// Check whether this copy-like instruction has already been salvaged into

1055// an operand pair.

1056Register Dest;

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

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

1059 }else {

1060assert(MI.isSubregToReg());

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

1062 }

1063

1064auto CacheIt = DbgPHICache.find(Dest);

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

1066return CacheIt->second;

1067

1068// Calculate the instruction number to use, or install a DBG_PHI.

1069auto OperandPair = salvageCopySSAImpl(MI);

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

1071return OperandPair;

1072}

1073

1074autoMachineFunction::salvageCopySSAImpl(MachineInstr &MI)

1075 ->DebugInstrOperandPair {

1076MachineRegisterInfo &MRI = getRegInfo();

1077constTargetRegisterInfo &TRI = *MRI.getTargetRegisterInfo();

1078constTargetInstrInfo &TII = *getSubtarget().getInstrInfo();

1079

1080// Chase the value read by a copy-like instruction back to the instruction

1081// that ultimately _defines_ that value. This may pass:

1082// * Through multiple intermediate copies, including subregister moves /

1083// copies,

1084// * Copies from physical registers that must then be traced back to the

1085// defining instruction,

1086// * Or, physical registers may be live-in to (only) the entry block, which

1087// requires a DBG_PHI to be created.

1088// We can pursue this problem in that order: trace back through copies,

1089// optionally through a physical register, to a defining instruction. We

1090// should never move from physreg to vreg. As we're still in SSA form, no need

1091// to worry about partial definitions of registers.

1092

1093// Helper lambda to interpret a copy-like instruction. Takes instruction,

1094// returns the register read and any subregister identifying which part is

1095// read.

1096auto GetRegAndSubreg =

1097 [&](constMachineInstr &Cpy) -> std::pair<Register, unsigned> {

1098Register NewReg, OldReg;

1099unsignedSubReg;

1100if (Cpy.isCopy()) {

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

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

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

1104 }elseif (Cpy.isSubregToReg()) {

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

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

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

1108 }else {

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

1110constMachineOperand &Src = *CopyDetails.Source;

1111constMachineOperand &Dest = *CopyDetails.Destination;

1112 OldReg = Dest.getReg();

1113 NewReg = Src.getReg();

1114SubReg = Src.getSubReg();

1115 }

1116

1117return {NewReg,SubReg};

1118 };

1119

1120// First seek either the defining instruction, or a copy from a physreg.

1121// During search, the current state is the current copy instruction, and which

1122// register we've read. Accumulate qualifying subregisters into SubregsSeen;

1123// deal with those later.

1124auto State = GetRegAndSubreg(MI);

1125auto CurInst =MI.getIterator();

1126SmallVector<unsigned, 4> SubregsSeen;

1127while (true) {

1128// If we've found a copy from a physreg, first portion of search is over.

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

1130break;

1131

1132// Record any subregister qualifier.

1133if (State.second)

1134 SubregsSeen.push_back(State.second);

1135

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

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

1138 CurInst = Inst.getIterator();

1139

1140// Any non-copy instruction is the defining instruction we're seeking.

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

1142break;

1143 State = GetRegAndSubreg(Inst);

1144 };

1145

1146// Helper lambda to apply additional subregister substitutions to a known

1147// instruction/operand pair. Adds new (fake) substitutions so that we can

1148// record the subregister. FIXME: this isn't very space efficient if multiple

1149// values are tracked back through the same copies; cache something later.

1150auto ApplySubregisters =

1151 [&](DebugInstrOperandPair P) ->DebugInstrOperandPair {

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

1153// Fetch a new instruction number, not attached to an actual instruction.

1154unsigned NewInstrNumber = getNewDebugInstrNum();

1155// Add a substitution from the "new" number to the known one, with a

1156// qualifying subreg.

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

1158// Return the new number; to find the underlying value, consumers need to

1159// deal with the qualifying subreg.

1160P = {NewInstrNumber, 0};

1161 }

1162returnP;

1163 };

1164

1165// If we managed to find the defining instruction after COPYs, return an

1166// instruction / operand pair after adding subregister qualifiers.

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

1168// Virtual register def -- we can just look up where this happens.

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

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

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

1172continue;

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

1174 }

1175

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

1177 }

1178

1179// Our search ended in a copy from a physreg: walk back up the function

1180// looking for whatever defines the physreg.

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

1182 State = GetRegAndSubreg(*CurInst);

1183Register RegToSeek = State.first;

1184

1185auto RMII = CurInst->getReverseIterator();

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

1187for (auto &ToExamine : PrevInstrs) {

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

1189// Test for operand that defines something aliasing RegToSeek.

1190if (!TRI.regsOverlap(RegToSeek, MO.getReg()))

1191continue;

1192

1193return ApplySubregisters(

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

1195 }

1196 }

1197

1198MachineBasicBlock &InsertBB = *CurInst->getParent();

1199

1200// We reached the start of the block before finding a defining instruction.

1201// There are numerous scenarios where this can happen:

1202// * Constant physical registers,

1203// * Several intrinsics that allow LLVM-IR to read arbitary registers,

1204// * Arguments in the entry block,

1205// * Exception handling landing pads.

1206// Validating all of them is too difficult, so just insert a DBG_PHI reading

1207// the variable value at this position, rather than checking it makes sense.

1208

1209// Create DBG_PHI for specified physreg.

1210auto Builder =BuildMI(InsertBB, InsertBB.getFirstNonPHI(),DebugLoc(),

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

1212 Builder.addReg(State.first);

1213unsigned NewNum = getNewDebugInstrNum();

1214 Builder.addImm(NewNum);

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

1216}

1217

1218voidMachineFunction::finalizeDebugInstrRefs() {

1219auto *TII =getSubtarget().getInstrInfo();

1220

1221auto MakeUndefDbgValue = [&](MachineInstr &MI) {

1222constMCInstrDesc &RefII =TII->get(TargetOpcode::DBG_VALUE_LIST);

1223MI.setDesc(RefII);

1224MI.setDebugValueUndef();

1225 };

1226

1227DenseMap<Register, DebugInstrOperandPair> ArgDbgPHIs;

1228for (auto &MBB : *this) {

1229for (auto &MI :MBB) {

1230if (!MI.isDebugRef())

1231continue;

1232

1233bool IsValidRef =true;

1234

1235for (MachineOperand &MO :MI.debug_operands()) {

1236if (!MO.isReg())

1237continue;

1238

1239Register Reg = MO.getReg();

1240

1241// Some vregs can be deleted as redundant in the meantime. Mark those

1242// as DBG_VALUE $noreg. Additionally, some normal instructions are

1243// quickly deleted, leaving dangling references to vregs with no def.

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

1245 IsValidRef =false;

1246break;

1247 }

1248

1249assert(Reg.isVirtual());

1250MachineInstr &DefMI = *RegInfo->def_instr_begin(Reg);

1251

1252// If we've found a copy-like instruction, follow it back to the

1253// instruction that defines the source value, see salvageCopySSA docs

1254// for why this is important.

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

1256auto Result =salvageCopySSA(DefMI, ArgDbgPHIs);

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

1258 }else {

1259// Otherwise, identify the operand number that the VReg refers to.

1260unsigned OperandIdx = 0;

1261for (constauto &DefMO :DefMI.operands()) {

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

1263break;

1264 ++OperandIdx;

1265 }

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

1267

1268// Morph this instr ref to point at the given instruction and operand.

1269unsignedID =DefMI.getDebugInstrNum();

1270 MO.ChangeToDbgInstrRef(ID, OperandIdx);

1271 }

1272 }

1273

1274if (!IsValidRef)

1275 MakeUndefDbgValue(MI);

1276 }

1277 }

1278}

1279

1280boolMachineFunction::shouldUseDebugInstrRef() const{

1281// Disable instr-ref at -O0: it's very slow (in compile time). We can still

1282// have optimized code inlined into this unoptimized code, however with

1283// fewer and less aggressive optimizations happening, coverage and accuracy

1284// should not suffer.

1285if (getTarget().getOptLevel() ==CodeGenOptLevel::None)

1286returnfalse;

1287

1288// Don't use instr-ref if this function is marked optnone.

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

1290returnfalse;

1291

1292if (llvm::debuginfoShouldUseDebugInstrRef(getTarget().getTargetTriple()))

1293returntrue;

1294

1295returnfalse;

1296}

1297

1298boolMachineFunction::useDebugInstrRef() const{

1299returnUseDebugInstrRef;

1300}

1301

1302voidMachineFunction::setUseDebugInstrRef(boolUse) {

1303UseDebugInstrRef =Use;

1304}

1305

1306// Use one million as a high / reserved number.

1307constunsignedMachineFunction::DebugOperandMemNumber = 1000000;

1308

1309/// \}

1310

1311//===----------------------------------------------------------------------===//

1312// MachineJumpTableInfo implementation

1313//===----------------------------------------------------------------------===//

1314

1315MachineJumpTableEntry::MachineJumpTableEntry(

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

1317 : MBBs(MBBs), Hotness(MachineFunctionDataHotness::Unknown) {}

1318

1319/// Return the size of each entry in the jump table.

1320unsignedMachineJumpTableInfo::getEntrySize(constDataLayout &TD) const{

1321// The size of a jump table entry is 4 bytes unless the entry is just the

1322// address of a block, in which case it is the pointer size.

1323switch (getEntryKind()) {

1324caseMachineJumpTableInfo::EK_BlockAddress:

1325return TD.getPointerSize();

1326caseMachineJumpTableInfo::EK_GPRel64BlockAddress:

1327caseMachineJumpTableInfo::EK_LabelDifference64:

1328return 8;

1329caseMachineJumpTableInfo::EK_GPRel32BlockAddress:

1330caseMachineJumpTableInfo::EK_LabelDifference32:

1331caseMachineJumpTableInfo::EK_Custom32:

1332return 4;

1333caseMachineJumpTableInfo::EK_Inline:

1334return 0;

1335 }

1336llvm_unreachable("Unknown jump table encoding!");

1337}

1338

1339/// Return the alignment of each entry in the jump table.

1340unsignedMachineJumpTableInfo::getEntryAlignment(constDataLayout &TD) const{

1341// The alignment of a jump table entry is the alignment of int32 unless the

1342// entry is just the address of a block, in which case it is the pointer

1343// alignment.

1344switch (getEntryKind()) {

1345caseMachineJumpTableInfo::EK_BlockAddress:

1346return TD.getPointerABIAlignment(0).value();

1347caseMachineJumpTableInfo::EK_GPRel64BlockAddress:

1348caseMachineJumpTableInfo::EK_LabelDifference64:

1349return TD.getABIIntegerTypeAlignment(64).value();

1350caseMachineJumpTableInfo::EK_GPRel32BlockAddress:

1351caseMachineJumpTableInfo::EK_LabelDifference32:

1352caseMachineJumpTableInfo::EK_Custom32:

1353return TD.getABIIntegerTypeAlignment(32).value();

1354caseMachineJumpTableInfo::EK_Inline:

1355return 1;

1356 }

1357llvm_unreachable("Unknown jump table encoding!");

1358}

1359

1360/// Create a new jump table entry in the jump table info.

1361unsignedMachineJumpTableInfo::createJumpTableIndex(

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

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

1364 JumpTables.push_back(MachineJumpTableEntry(DestBBs));

1365return JumpTables.size()-1;

1366}

1367

1368boolMachineJumpTableInfo::updateJumpTableEntryHotness(

1369size_t JTI,MachineFunctionDataHotness Hotness) {

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

1371// Record the largest hotness value.

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

1373returnfalse;

1374

1375 JumpTables[JTI].Hotness = Hotness;

1376returntrue;

1377}

1378

1379/// If Old is the target of any jump tables, update the jump tables to branch

1380/// to New instead.

1381boolMachineJumpTableInfo::ReplaceMBBInJumpTables(MachineBasicBlock *Old,

1382MachineBasicBlock *New) {

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

1384bool MadeChange =false;

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

1386ReplaceMBBInJumpTable(i, Old, New);

1387return MadeChange;

1388}

1389

1390/// If MBB is present in any jump tables, remove it.

1391boolMachineJumpTableInfo::RemoveMBBFromJumpTables(MachineBasicBlock *MBB) {

1392bool MadeChange =false;

1393for (MachineJumpTableEntry &JTE : JumpTables) {

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

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

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

1397 }

1398return MadeChange;

1399}

1400

1401/// If Old is a target of the jump tables, update the jump table to branch to

1402/// New instead.

1403boolMachineJumpTableInfo::ReplaceMBBInJumpTable(unsignedIdx,

1404MachineBasicBlock *Old,

1405MachineBasicBlock *New) {

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

1407bool MadeChange =false;

1408MachineJumpTableEntry &JTE = JumpTables[Idx];

1409for (MachineBasicBlock *&MBB : JTE.MBBs)

1410if (MBB == Old) {

1411MBB = New;

1412 MadeChange =true;

1413 }

1414return MadeChange;

1415}

1416

1417voidMachineJumpTableInfo::print(raw_ostream &OS) const{

1418if (JumpTables.empty())return;

1419

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

1421

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

1423OS <<printJumpTableEntryReference(i) <<':';

1424for (constMachineBasicBlock *MBB : JumpTables[i].MBBs)

1425OS <<' ' <<printMBBReference(*MBB);

1426if (i != e)

1427OS <<'\n';

1428 }

1429

1430OS <<'\n';

1431}

1432

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

1434LLVM_DUMP_METHODvoidMachineJumpTableInfo::dump() const{print(dbgs()); }

1435#endif

1436

1437Printable llvm::printJumpTableEntryReference(unsignedIdx) {

1438returnPrintable([Idx](raw_ostream &OS) {OS <<"%jump-table." <<Idx; });

1439}

1440

1441//===----------------------------------------------------------------------===//

1442// MachineConstantPool implementation

1443//===----------------------------------------------------------------------===//

1444

1445void MachineConstantPoolValue::anchor() {}

1446

1447unsignedMachineConstantPoolValue::getSizeInBytes(constDataLayout &DL) const{

1448returnDL.getTypeAllocSize(Ty);

1449}

1450

1451unsignedMachineConstantPoolEntry::getSizeInBytes(constDataLayout &DL) const{

1452if (isMachineConstantPoolEntry())

1453returnVal.MachineCPVal->getSizeInBytes(DL);

1454returnDL.getTypeAllocSize(Val.ConstVal->getType());

1455}

1456

1457boolMachineConstantPoolEntry::needsRelocation() const{

1458if (isMachineConstantPoolEntry())

1459returntrue;

1460returnVal.ConstVal->needsDynamicRelocation();

1461}

1462

1463SectionKind

1464MachineConstantPoolEntry::getSectionKind(constDataLayout *DL) const{

1465if (needsRelocation())

1466returnSectionKind::getReadOnlyWithRel();

1467switch (getSizeInBytes(*DL)) {

1468case 4:

1469returnSectionKind::getMergeableConst4();

1470case 8:

1471returnSectionKind::getMergeableConst8();

1472case 16:

1473returnSectionKind::getMergeableConst16();

1474case 32:

1475returnSectionKind::getMergeableConst32();

1476default:

1477returnSectionKind::getReadOnly();

1478 }

1479}

1480

1481MachineConstantPool::~MachineConstantPool() {

1482// A constant may be a member of both Constants and MachineCPVsSharingEntries,

1483// so keep track of which we've deleted to avoid double deletions.

1484DenseSet<MachineConstantPoolValue*>Deleted;

1485for (constMachineConstantPoolEntry &C : Constants)

1486if (C.isMachineConstantPoolEntry()) {

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

1488deleteC.Val.MachineCPVal;

1489 }

1490for (MachineConstantPoolValue *CPV : MachineCPVsSharingEntries) {

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

1492delete CPV;

1493 }

1494}

1495

1496/// Test whether the given two constants can be allocated the same constant pool

1497/// entry referenced by \param A.

1498staticboolCanShareConstantPoolEntry(constConstant *A,constConstant *B,

1499constDataLayout &DL) {

1500// Handle the trivial case quickly.

1501if (A ==B)returntrue;

1502

1503// If they have the same type but weren't the same constant, quickly

1504// reject them.

1505if (A->getType() ==B->getType())returnfalse;

1506

1507// We can't handle structs or arrays.

1508if (isa<StructType>(A->getType()) || isa<ArrayType>(A->getType()) ||

1509 isa<StructType>(B->getType()) || isa<ArrayType>(B->getType()))

1510returnfalse;

1511

1512// For now, only support constants with the same size.

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

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

1515returnfalse;

1516

1517bool ContainsUndefOrPoisonA =A->containsUndefOrPoisonElement();

1518

1519Type *IntTy =IntegerType::get(A->getContext(), StoreSize*8);

1520

1521// Try constant folding a bitcast of both instructions to an integer. If we

1522// get two identical ConstantInt's, then we are good to share them. We use

1523// the constant folding APIs to do this so that we get the benefit of

1524// DataLayout.

1525if (isa<PointerType>(A->getType()))

1526A =ConstantFoldCastOperand(Instruction::PtrToInt,

1527const_cast<Constant *>(A), IntTy,DL);

1528elseif (A->getType() != IntTy)

1529A =ConstantFoldCastOperand(Instruction::BitCast,const_cast<Constant *>(A),

1530 IntTy,DL);

1531if (isa<PointerType>(B->getType()))

1532B =ConstantFoldCastOperand(Instruction::PtrToInt,

1533const_cast<Constant *>(B), IntTy,DL);

1534elseif (B->getType() != IntTy)

1535B =ConstantFoldCastOperand(Instruction::BitCast,const_cast<Constant *>(B),

1536 IntTy,DL);

1537

1538if (A !=B)

1539returnfalse;

1540

1541// Constants only safely match if A doesn't contain undef/poison.

1542// As we'll be reusing A, it doesn't matter if B contain undef/poison.

1543// TODO: Handle cases where A and B have the same undef/poison elements.

1544// TODO: Merge A and B with mismatching undef/poison elements.

1545return !ContainsUndefOrPoisonA;

1546}

1547

1548/// Create a new entry in the constant pool or return an existing one.

1549/// User must specify the log2 of the minimum required alignment for the object.

1550unsignedMachineConstantPool::getConstantPoolIndex(constConstant *C,

1551Align Alignment) {

1552if (Alignment > PoolAlignment) PoolAlignment = Alignment;

1553

1554// Check to see if we already have this constant.

1555//

1556// FIXME, this could be made much more efficient for large constant pools.

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

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

1559CanShareConstantPoolEntry(Constants[i].Val.ConstVal,C,DL)) {

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

1561 Constants[i].Alignment = Alignment;

1562return i;

1563 }

1564

1565 Constants.push_back(MachineConstantPoolEntry(C, Alignment));

1566return Constants.size()-1;

1567}

1568

1569unsignedMachineConstantPool::getConstantPoolIndex(MachineConstantPoolValue *V,

1570Align Alignment) {

1571if (Alignment > PoolAlignment) PoolAlignment = Alignment;

1572

1573// Check to see if we already have this constant.

1574//

1575// FIXME, this could be made much more efficient for large constant pools.

1576intIdx = V->getExistingMachineCPValue(this, Alignment);

1577if (Idx != -1) {

1578 MachineCPVsSharingEntries.insert(V);

1579return (unsigned)Idx;

1580 }

1581

1582 Constants.push_back(MachineConstantPoolEntry(V, Alignment));

1583return Constants.size()-1;

1584}

1585

1586voidMachineConstantPool::print(raw_ostream &OS) const{

1587if (Constants.empty())return;

1588

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

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

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

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

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

1594else

1595 Constants[i].Val.ConstVal->printAsOperand(OS,/*PrintType=*/false);

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

1597OS <<"\n";

1598 }

1599}

1600

1601//===----------------------------------------------------------------------===//

1602// Template specialization for MachineFunction implementation of

1603// ProfileSummaryInfo::getEntryCount().

1604//===----------------------------------------------------------------------===//

1605template <>

1606std::optional<Function::ProfileCount>

1607ProfileSummaryInfo::getEntryCount<llvm::MachineFunction>(

1608constllvm::MachineFunction *F) const{

1609returnF->getFunction().getEntryCount();

1610}

1611

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

1613LLVM_DUMP_METHODvoidMachineConstantPool::dump() const{print(dbgs()); }

1614#endif

SubReg

unsigned SubReg

Definition:AArch64AdvSIMDScalarPass.cpp:104

MRI

unsigned const MachineRegisterInfo * MRI

Definition:AArch64AdvSIMDScalarPass.cpp:105

DefMI

MachineInstrBuilder MachineInstrBuilder & DefMI

Definition:AArch64ExpandPseudoInsts.cpp:113

const

aarch64 promote const

Definition:AArch64PromoteConstant.cpp:230

MBB

MachineBasicBlock & MBB

Definition:ARMSLSHardening.cpp:71

MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL

Definition:ARMSLSHardening.cpp:73

MBBI

MachineBasicBlock MachineBasicBlock::iterator MBBI

Definition:ARMSLSHardening.cpp:72

Attributes.h

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

getParent

static const Function * getParent(const Value *V)

Definition:BasicAliasAnalysis.cpp:863

BitVector.h

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.

Definition:Compiler.h:622

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

Definition:DeadArgumentElimination.cpp:353

DenseMap.h

This file defines the DenseMap class.

DenseSet.h

This file defines the DenseSet and SmallDenseSet classes.

DerivedTypes.h

EHPersonalities.h

Name

std::string Name

Definition:ELFObjHandler.cpp:77

Size

uint64_t Size

Definition:ELFObjHandler.cpp:81

Sym

Symbol * Sym

Definition:ELF_riscv.cpp:479

GlobalValue.h

GraphWriter.h

TII

const HexagonInstrInfo * TII

Definition:HexagonCopyToCombine.cpp:125

IRTranslator LLVM IR MI

Definition:IRTranslator.cpp:112

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

Value.h

Instructions.h

LiveDebugValues.h

LoopDeletionResult::Deleted

@ Deleted

MCContext.h

MCSymbol.h

#define F(x, y, z)

Definition:MD5.cpp:55

#define I(x, y, z)

Definition:MD5.cpp:58

MachineBasicBlock.h

MachineConstantPool.h

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

MachineFrameInfo.h

getFnStackAlignment

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

Definition:MachineFunction.cpp:157

AlignAllFunctions

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)

getCallInstr

static const MachineInstr * getCallInstr(const MachineInstr *MI)

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

Definition:MachineFunction.cpp:929

CanShareConstantPoolEntry

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

setUnsafeStackSize

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

Definition:MachineFunction.cpp:112

getPropertyName

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

Definition:MachineFunction.cpp:90

MachineFunction.h

MachineInstr.h

MachineJumpTableInfo.h

MachineMemOperand.h

MachineModuleInfo.h

MachineRegisterInfo.h

TRI

unsigned const TargetRegisterInfo * TRI

Definition:MachineSink.cpp:2029

Reg

unsigned Reg

Definition:MachineSink.cpp:2028

Metadata.h

This file contains the declarations for metadata subclasses.

ModuleSlotTracker.h

#define P(N)

ProfileSummaryInfo.h

PseudoSourceValueManager.h

PseudoSourceValue.h

assert

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

isSimple

static bool isSimple(Instruction *I)

Definition:SLPVectorizer.cpp:1137

STLExtras.h

This file contains some templates that are useful if you are working with the STL at all.

raw_pwrite_stream & OS

Definition:SampleProfWriter.cpp:51

SectionKind.h

SmallString.h

This file defines the SmallString class.

SmallVector.h

This file defines the SmallVector class.

StringRef.h

BlockSize

static const int BlockSize

Definition:TarWriter.cpp:33

TargetFrameLowering.h

TargetInstrInfo.h

TargetLowering.h

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

TargetRegisterInfo.h

TargetSubtargetInfo.h

Twine.h

WasmEHFuncInfo.h

WinEHFuncInfo.h

llvm::ArrayRecycler::clear

void clear(AllocatorType &Allocator)

Release all the tracked allocations to the allocator.

Definition:ArrayRecycler.h:104

llvm::ArrayRef

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

Definition:ArrayRef.h:41

llvm::ArrayRef::end

iterator end() const

Definition:ArrayRef.h:157

llvm::ArrayRef::size

size_t size() const

size - Get the array size.

Definition:ArrayRef.h:168

llvm::ArrayRef::begin

iterator begin() const

Definition:ArrayRef.h:156

llvm::BasicBlock

LLVM Basic Block Representation.

Definition:BasicBlock.h:61

llvm::BasicBlock::getFirstNonPHIIt

InstListType::const_iterator getFirstNonPHIIt() const

Iterator returning form of getFirstNonPHI.

Definition:BasicBlock.cpp:374

llvm::BasicBlock::const_iterator

InstListType::const_iterator const_iterator

Definition:BasicBlock.h:178

llvm::BumpPtrAllocatorImpl::Allocate

LLVM_ATTRIBUTE_RETURNS_NONNULL void * Allocate(size_t Size, Align Alignment)

Allocate space at the specified alignment.

Definition:Allocator.h:148

llvm::BumpPtrAllocatorImpl::Deallocate

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

Definition:Allocator.h:225

llvm::ConstantPool

Definition:ConstantPools.h:43

llvm::Constant

This is an important base class in LLVM.

Definition:Constant.h:42

llvm::DWARFExpression::Operation

This class represents an Operation in the Expression.

Definition:DWARFExpression.h:32

llvm::DataLayout

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

Definition:DataLayout.h:63

llvm::DataLayout::getABIIntegerTypeAlignment

Align getABIIntegerTypeAlignment(unsigned BitWidth) const

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

Definition:DataLayout.h:486

llvm::DataLayout::getPointerSize

unsigned getPointerSize(unsigned AS=0) const

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

Definition:DataLayout.cpp:739

llvm::DataLayout::getPointerABIAlignment

Align getPointerABIAlignment(unsigned AS) const

Layout pointer alignment.

Definition:DataLayout.cpp:731

llvm::DebugLoc

A debug info location.

Definition:DebugLoc.h:33

llvm::DenseMapBase::find

iterator find(const_arg_type_t< KeyT > Val)

Definition:DenseMap.h:156

llvm::DenseMapBase::erase

bool erase(const KeyT &Val)

Definition:DenseMap.h:321

llvm::DenseMapBase::end

iterator end()

Definition:DenseMap.h:84

llvm::DenseMapBase::contains

bool contains(const_arg_type_t< KeyT > Val) const

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

Definition:DenseMap.h:147

llvm::DenseMapIterator

Definition:DenseMap.h:1189

llvm::DenseMap

Definition:DenseMap.h:727

llvm::DenseSet

Implements a dense probed hash-table based set.

Definition:DenseSet.h:278

llvm::Function

Definition:Function.h:63

llvm::Function::getDataLayout

const DataLayout & getDataLayout() const

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

Definition:Function.cpp:373

llvm::Function::getFnStackAlign

MaybeAlign getFnStackAlign() const

Return the stack alignment for the function.

Definition:Function.h:470

llvm::Function::hasPersonalityFn

bool hasPersonalityFn() const

Check whether this function has a personality function.

Definition:Function.h:905

llvm::Function::getPersonalityFn

Constant * getPersonalityFn() const

Get the personality function associated with this function.

Definition:Function.cpp:1048

llvm::Function::getDenormalMode

DenormalMode getDenormalMode(const fltSemantics &FPType) const

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

Definition:Function.cpp:807

llvm::Function::needsUnwindTableEntry

bool needsUnwindTableEntry() const

True if this function needs an unwind table.

Definition:Function.h:682

llvm::Function::hasFnAttribute

bool hasFnAttribute(Attribute::AttrKind Kind) const

Return true if the function has the attribute.

Definition:Function.cpp:731

llvm::GlobalObject::hasMetadata

bool hasMetadata() const

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

Definition:Value.h:589

llvm::GlobalObject::getMetadata

MDNode * getMetadata(unsigned KindID) const

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

Definition:Value.h:565

llvm::GlobalValue

Definition:GlobalValue.h:48

llvm::GlobalValue::getParent

Module * getParent()

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

Definition:GlobalValue.h:657

llvm::IntegerType::get

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

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

Definition:Type.cpp:311

llvm::LLT

Definition:LowLevelType.h:39

llvm::LocationSize

Definition:MemoryLocation.h:68

llvm::MCCFIInstruction

Definition:MCDwarf.h:499

llvm::MCContext

Context object for machine code objects.

Definition:MCContext.h:83

llvm::MCContext::createTempSymbol

MCSymbol * createTempSymbol()

Create a temporary symbol with a unique name.

Definition:MCContext.cpp:345

llvm::MCContext::getOrCreateSymbol

MCSymbol * getOrCreateSymbol(const Twine &Name)

Lookup the symbol inside with the specified Name.

Definition:MCContext.cpp:212

llvm::MCInstrDesc

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

Definition:MCInstrDesc.h:198

llvm::MCRegisterInfo::getNumRegs

unsigned getNumRegs() const

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

Definition:MCRegisterInfo.h:414

llvm::MCRegister

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

Definition:MCRegister.h:33

llvm::MCSymbol

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

Definition:MCSymbol.h:41

llvm::MDNode

Metadata node.

Definition:Metadata.h:1073

llvm::MachineBasicBlock

Definition:MachineBasicBlock.h:125

llvm::MachineBasicBlock::setBBID

void setBBID(const UniqueBBID &V)

Sets the fixed BBID of this basic block.

Definition:MachineBasicBlock.h:687

llvm::MachineBasicBlock::setIsEndSection

void setIsEndSection(bool V=true)

Definition:MachineBasicBlock.h:679

llvm::MachineBasicBlock::insert

instr_iterator insert(instr_iterator I, MachineInstr *M)

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

Definition:MachineBasicBlock.cpp:1456

llvm::MachineBasicBlock::getNumber

int getNumber() const

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

Definition:MachineBasicBlock.h:1217

llvm::MachineBasicBlock::getBasicBlock

const BasicBlock * getBasicBlock() const

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

Definition:MachineBasicBlock.h:256

llvm::MachineBasicBlock::setNumber

void setNumber(int N)

Definition:MachineBasicBlock.h:1218

llvm::MachineBasicBlock::getSectionID

MBBSectionID getSectionID() const

Returns the section ID of this basic block.

Definition:MachineBasicBlock.h:684

llvm::MachineBasicBlock::getFirstNonPHI

iterator getFirstNonPHI()

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

Definition:MachineBasicBlock.cpp:202

llvm::MachineBasicBlock::const_instr_iterator

Instructions::const_iterator const_instr_iterator

Definition:MachineBasicBlock.h:315

llvm::MachineBasicBlock::getParent

const MachineFunction * getParent() const

Return the MachineFunction containing this basic block.

Definition:MachineBasicBlock.h:311

llvm::MachineBasicBlock::getAlignment

Align getAlignment() const

Return alignment of the basic block.

Definition:MachineBasicBlock.h:614

llvm::MachineBasicBlock::setIsBeginSection

void setIsBeginSection(bool V=true)

Definition:MachineBasicBlock.h:677

llvm::MachineConstantPoolEntry

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

Definition:MachineConstantPool.h:67

llvm::MachineConstantPoolEntry::needsRelocation

bool needsRelocation() const

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

Definition:MachineFunction.cpp:1457

llvm::MachineConstantPoolEntry::isMachineConstantPoolEntry

bool isMachineConstantPoolEntry() const

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

Definition:MachineConstantPool.h:93

llvm::MachineConstantPoolEntry::Val

union llvm::MachineConstantPoolEntry::@204 Val

The constant itself.

llvm::MachineConstantPoolEntry::getSizeInBytes

unsigned getSizeInBytes(const DataLayout &DL) const

Definition:MachineFunction.cpp:1451

llvm::MachineConstantPoolEntry::getSectionKind

SectionKind getSectionKind(const DataLayout *DL) const

Definition:MachineFunction.cpp:1464

llvm::MachineConstantPoolValue

Abstract base class for all machine specific constantpool value subclasses.

Definition:MachineConstantPool.h:35

llvm::MachineConstantPoolValue::getSizeInBytes

virtual unsigned getSizeInBytes(const DataLayout &DL) const

Definition:MachineFunction.cpp:1447

llvm::MachineConstantPool

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

Definition:MachineConstantPool.h:117

llvm::MachineConstantPool::dump

void dump() const

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

Definition:MachineFunction.cpp:1613

llvm::MachineConstantPool::print

void print(raw_ostream &OS) const

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

Definition:MachineFunction.cpp:1586

llvm::MachineConstantPool::~MachineConstantPool

~MachineConstantPool()

Definition:MachineFunction.cpp:1481

llvm::MachineConstantPool::getConstantPoolIndex

unsigned getConstantPoolIndex(const Constant *C, Align Alignment)

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

Definition:MachineFunction.cpp:1550

llvm::MachineFrameInfo

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

Definition:MachineFrameInfo.h:106

llvm::MachineFrameInfo::ensureMaxAlignment

void ensureMaxAlignment(Align Alignment)

Make sure the function is at least Align bytes aligned.

Definition:MachineFrameInfo.cpp:31

llvm::MachineFrameInfo::print

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

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

Definition:MachineFrameInfo.cpp:209

llvm::MachineFrameInfo::setUnsafeStackSize

void setUnsafeStackSize(uint64_t Size)

Definition:MachineFrameInfo.h:829

llvm::MachineFunctionProperties::print

void print(raw_ostream &OS) const

Print the MachineFunctionProperties in human-readable form.

Definition:MachineFunction.cpp:136

llvm::MachineFunctionProperties::set

MachineFunctionProperties & set(Property P)

Definition:MachineFunction.h:207

llvm::MachineFunctionProperties::Property

Property

Definition:MachineFunction.h:187

llvm::MachineFunctionProperties::Property::TracksLiveness

@ TracksLiveness

llvm::MachineFunctionProperties::Property::IsSSA

@ IsSSA

llvm::MachineFunctionProperties::reset

MachineFunctionProperties & reset(Property P)

Definition:MachineFunction.h:212

llvm::MachineFunction::Delegate::MF_HandleChangeDesc

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

Callback before changing MCInstrDesc.

Definition:MachineFunction.h:480

llvm::MachineFunction::Delegate::MF_HandleRemoval

virtual void MF_HandleRemoval(MachineInstr &MI)=0

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

llvm::MachineFunction::Delegate::MF_HandleInsertion

virtual void MF_HandleInsertion(MachineInstr &MI)=0

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

llvm::MachineFunction

Definition:MachineFunction.h:267

llvm::MachineFunction::createMIExtraInfo

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.

Definition:MachineFunction.cpp:609

llvm::MachineFunction::getFilterIDFor

int getFilterIDFor(ArrayRef< unsigned > TyIds)

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

Definition:MachineFunction.cpp:891

llvm::MachineFunction::UseDebugInstrRef

bool UseDebugInstrRef

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

Definition:MachineFunction.h:599

llvm::MachineFunction::moveAdditionalCallInfo

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

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

Definition:MachineFunction.cpp:980

llvm::MachineFunction::DebugInstrOperandPair

std::pair< unsigned, unsigned > DebugInstrOperandPair

Pair of instruction number and operand number.

Definition:MachineFunction.h:545

llvm::MachineFunction::addFrameInst

unsigned addFrameInst(const MCCFIInstruction &Inst)

Definition:MachineFunction.cpp:334

llvm::MachineFunction::useDebugInstrRef

bool useDebugInstrRef() const

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

Definition:MachineFunction.cpp:1298

llvm::MachineFunction::DebugValueSubstitutions

SmallVector< DebugSubstitution, 8 > DebugValueSubstitutions

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

Definition:MachineFunction.h:577

llvm::MachineFunction::getFunctionNumber

unsigned getFunctionNumber() const

getFunctionNumber - Return a unique ID for the current function.

Definition:MachineFunction.h:713

llvm::MachineFunction::getPICBaseSymbol

MCSymbol * getPICBaseSymbol() const

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

Definition:MachineFunction.cpp:802

llvm::MachineFunction::viewCFGOnly

void viewCFGOnly() const

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

Definition:MachineFunction.cpp:750

llvm::MachineFunction::allocateShuffleMask

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

Definition:MachineFunction.cpp:633

llvm::MachineFunction::substituteDebugValuesForInst

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

llvm::MachineFunction::getSubtarget

const TargetSubtargetInfo & getSubtarget() const

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

Definition:MachineFunction.h:733

llvm::MachineFunction::cloneMachineInstrBundle

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

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

Definition:MachineFunction.cpp:444

llvm::MachineFunction::getOrCreateJumpTableInfo

MachineJumpTableInfo * getOrCreateJumpTableInfo(unsigned JTEntryKind)

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

Definition:MachineFunction.cpp:316

llvm::MachineFunction::getName

StringRef getName() const

getName - Return the name of the corresponding LLVM function.

Definition:MachineFunction.cpp:645

llvm::MachineFunction::dump

void dump() const

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

Definition:MachineFunction.cpp:640

llvm::MachineFunction::CreateMachineInstr

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

CreateMachineInstr - Allocate a new MachineInstr.

Definition:MachineFunction.cpp:429

llvm::MachineFunction::makeDebugValueSubstitution

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

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

Definition:MachineFunction.cpp:1009

llvm::MachineFunction::getMachineMemOperand

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

llvm::MachineFunction::MachineFunction

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

Definition:MachineFunction.cpp:164

llvm::MachineFunction::needsFrameMoves

bool needsFrameMoves() const

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

Definition:MachineFunction.cpp:691

llvm::MachineFunction::getTypeIDFor

unsigned getTypeIDFor(const GlobalValue *TI)

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

Definition:MachineFunction.cpp:883

llvm::MachineFunction::finalizeDebugInstrRefs

void finalizeDebugInstrRefs()

Finalise any partially emitted debug instructions.

Definition:MachineFunction.cpp:1218

llvm::MachineFunction::deallocateOperandArray

void deallocateOperandArray(OperandCapacity Cap, MachineOperand *Array)

Dellocate an array of MachineOperands and recycle the memory.

Definition:MachineFunction.h:1137

llvm::MachineFunction::getDenormalMode

DenormalMode getDenormalMode(const fltSemantics &FPType) const

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

Definition:MachineFunction.cpp:324

llvm::MachineFunction::deleteMachineInstr

void deleteMachineInstr(MachineInstr *MI)

DeleteMachineInstr - Delete the given MachineInstr.

Definition:MachineFunction.cpp:474

llvm::MachineFunction::initTargetMachineFunctionInfo

void initTargetMachineFunctionInfo(const TargetSubtargetInfo &STI)

Initialize the target specific MachineFunctionInfo.

Definition:MachineFunction.cpp:253

llvm::MachineFunction::createExternalSymbolName

const char * createExternalSymbolName(StringRef Name)

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

Definition:MachineFunction.cpp:618

llvm::MachineFunction::allocateRegMask

uint32_t * allocateRegMask()

Allocate and initialize a register mask with NumRegister bits.

Definition:MachineFunction.cpp:625

llvm::MachineFunction::getJTISymbol

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

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

Definition:MachineFunction.cpp:787

llvm::MachineFunction::setCallSiteLandingPad

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

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

Definition:MachineFunction.cpp:878

llvm::MachineFunction::setUseDebugInstrRef

void setUseDebugInstrRef(bool UseInstrRef)

Set whether this function will use instruction referencing or not.

Definition:MachineFunction.cpp:1302

llvm::MachineFunction::getOrCreateLandingPadInfo

LandingPadInfo & getOrCreateLandingPadInfo(MachineBasicBlock *LandingPad)

Find or create an LandingPadInfo for the specified MachineBasicBlock.

Definition:MachineFunction.cpp:812

llvm::MachineFunction::size

unsigned size() const

Definition:MachineFunction.h:957

llvm::MachineFunction::getRegInfo

MachineRegisterInfo & getRegInfo()

getRegInfo - Return information about the registers currently in use.

Definition:MachineFunction.h:743

llvm::MachineFunction::getDataLayout

const DataLayout & getDataLayout() const

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

Definition:MachineFunction.cpp:309

llvm::MachineFunction::addLandingPad

MCSymbol * addLandingPad(MachineBasicBlock *LandingPad)

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

Definition:MachineFunction.cpp:831

llvm::MachineFunction::DebugInstrNumberingCount

unsigned DebugInstrNumberingCount

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

Definition:MachineFunction.h:538

llvm::MachineFunction::deleteMachineBasicBlock

void deleteMachineBasicBlock(MachineBasicBlock *MBB)

DeleteMachineBasicBlock - Delete the given MachineBasicBlock.

Definition:MachineFunction.cpp:513

llvm::MachineFunction::getAlignment

Align getAlignment() const

getAlignment - Return the alignment of the function.

Definition:MachineFunction.h:781

llvm::MachineFunction::handleChangeDesc

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

Definition:MachineFunction.cpp:182

llvm::MachineFunction::DebugOperandMemNumber

static const unsigned int DebugOperandMemNumber

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

Definition:MachineFunction.h:654

llvm::MachineFunction::~MachineFunction

~MachineFunction()

Definition:MachineFunction.cpp:259

llvm::MachineFunction::getFunction

Function & getFunction()

Return the LLVM function that this machine code represents.

Definition:MachineFunction.h:704

llvm::MachineFunction::end

iterator end()

Definition:MachineFunction.h:949

llvm::MachineFunction::salvageCopySSAImpl

DebugInstrOperandPair salvageCopySSAImpl(MachineInstr &MI)

Definition:MachineFunction.cpp:1074

llvm::MachineFunction::back

const MachineBasicBlock & back() const

Definition:MachineFunction.h:961

llvm::MachineFunction::iterator

BasicBlockListType::iterator iterator

Definition:MachineFunction.h:929

llvm::MachineFunction::setDebugInstrNumberingCount

void setDebugInstrNumberingCount(unsigned Num)

Set value of DebugInstrNumberingCount field.

Definition:MachineFunction.cpp:1005

llvm::MachineFunction::begin

iterator begin()

Definition:MachineFunction.h:947

llvm::MachineFunction::shouldSplitStack

bool shouldSplitStack() const

Should we be emitting segmented stack stuff for the function.

Definition:MachineFunction.cpp:329

llvm::MachineFunction::viewCFG

void viewCFG() const

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

Definition:MachineFunction.cpp:740

llvm::MachineFunction::shouldUseDebugInstrRef

bool shouldUseDebugInstrRef() const

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

Definition:MachineFunction.cpp:1280

llvm::MachineFunction::getProperties

const MachineFunctionProperties & getProperties() const

Get the function properties.

Definition:MachineFunction.h:824

llvm::MachineFunction::eraseAdditionalCallInfo

void eraseAdditionalCallInfo(const MachineInstr *MI)

Following functions update call site info.

Definition:MachineFunction.cpp:941

llvm::MachineFunction::CloneMachineInstr

MachineInstr * CloneMachineInstr(const MachineInstr *Orig)

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

Definition:MachineFunction.cpp:439

llvm::MachineFunction::RenumberBlocks

void RenumberBlocks(MachineBasicBlock *MBBFrom=nullptr)

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

Definition:MachineFunction.cpp:343

llvm::MachineFunction::front

const MachineBasicBlock & front() const

Definition:MachineFunction.h:959

llvm::MachineFunction::addLiveIn

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

Definition:MachineFunction.cpp:762

llvm::MachineFunction::empty

bool empty() const

Definition:MachineFunction.h:958

llvm::MachineFunction::estimateFunctionSizeInBytes

int64_t estimateFunctionSizeInBytes()

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

Definition:MachineFunction.cpp:381

llvm::MachineFunction::print

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

llvm::MachineFunction::addInvoke

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

llvm::MachineFunction::CreateMachineBasicBlock

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

CreateMachineBasicBlock - Allocate a new MachineBasicBlock.

Definition:MachineFunction.cpp:499

llvm::MachineFunction::copyAdditionalCallInfo

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

Copy the call site info from Old to \ New.

Definition:MachineFunction.cpp:957

llvm::MachineFunction::VariableDbgInfos

VariableDbgInfoMapTy VariableDbgInfos

Definition:MachineFunction.h:533

llvm::MachineFunction::assignBeginEndSections

void assignBeginEndSections()

Assign IsBeginSection IsEndSection fields for basic blocks in this function.

Definition:MachineFunction.cpp:415

llvm::MachineFunction::getTarget

const TargetMachine & getTarget() const

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

Definition:MachineFunction.h:729

llvm::MachineFunction::salvageCopySSA

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

llvm::MachineInstrBundleIterator< MachineInstr >

llvm::MachineInstr

Representation of each machine instruction.

Definition:MachineInstr.h:71

llvm::MachineInstr::bundleWithPred

void bundleWithPred()

Bundle this instruction with its predecessor.

Definition:MachineInstr.cpp:829

llvm::MachineInstr::isCopyLike

bool isCopyLike() const

Return true if the instruction behaves like a copy.

Definition:MachineInstr.h:1456

llvm::MachineInstr::getNumOperands

unsigned getNumOperands() const

Retuns the total number of operands.

Definition:MachineInstr.h:580

llvm::MachineInstr::peekDebugInstrNum

unsigned peekDebugInstrNum() const

Examine the instruction number of this MachineInstr.

Definition:MachineInstr.h:548

llvm::MachineInstr::getDebugInstrNum

unsigned getDebugInstrNum()

Fetch the instruction number of this MachineInstr.

Definition:MachineInstr.cpp:2560

llvm::MachineInstr::getOperand

const MachineOperand & getOperand(unsigned i) const

Definition:MachineInstr.h:587

llvm::MachineInstr::shouldUpdateAdditionalCallInfo

bool shouldUpdateAdditionalCallInfo() const

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

Definition:MachineInstr.cpp:790

llvm::MachineInstr::all_defs

iterator_range< filtered_mop_iterator > all_defs()

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

Definition:MachineInstr.h:764

llvm::MachineJumpTableInfo

Definition:MachineJumpTableInfo.h:46

llvm::MachineJumpTableInfo::RemoveMBBFromJumpTables

bool RemoveMBBFromJumpTables(MachineBasicBlock *MBB)

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

Definition:MachineFunction.cpp:1391

llvm::MachineJumpTableInfo::ReplaceMBBInJumpTables

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

llvm::MachineJumpTableInfo::print

void print(raw_ostream &OS) const

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

Definition:MachineFunction.cpp:1417

llvm::MachineJumpTableInfo::getEntrySize

unsigned getEntrySize(const DataLayout &TD) const

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

Definition:MachineFunction.cpp:1320

llvm::MachineJumpTableInfo::createJumpTableIndex

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

createJumpTableIndex - Create a new jump table.

Definition:MachineFunction.cpp:1361

llvm::MachineJumpTableInfo::dump

void dump() const

dump - Call to stderr.

Definition:MachineFunction.cpp:1434

llvm::MachineJumpTableInfo::ReplaceMBBInJumpTable

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

llvm::MachineJumpTableInfo::updateJumpTableEntryHotness

bool updateJumpTableEntryHotness(size_t JTI, MachineFunctionDataHotness Hotness)

Definition:MachineFunction.cpp:1368

llvm::MachineJumpTableInfo::JTEntryKind

JTEntryKind

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

Definition:MachineJumpTableInfo.h:50

llvm::MachineJumpTableInfo::EK_GPRel32BlockAddress

@ EK_GPRel32BlockAddress

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

Definition:MachineJumpTableInfo.h:63

llvm::MachineJumpTableInfo::EK_Inline

@ EK_Inline

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

Definition:MachineJumpTableInfo.h:82

llvm::MachineJumpTableInfo::EK_LabelDifference32

@ EK_LabelDifference32

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

Definition:MachineJumpTableInfo.h:72

llvm::MachineJumpTableInfo::EK_Custom32

@ EK_Custom32

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

Definition:MachineJumpTableInfo.h:86

llvm::MachineJumpTableInfo::EK_LabelDifference64

@ EK_LabelDifference64

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

Definition:MachineJumpTableInfo.h:78

llvm::MachineJumpTableInfo::EK_BlockAddress

@ EK_BlockAddress

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

Definition:MachineJumpTableInfo.h:53

llvm::MachineJumpTableInfo::EK_GPRel64BlockAddress

@ EK_GPRel64BlockAddress

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

Definition:MachineJumpTableInfo.h:58

llvm::MachineJumpTableInfo::getEntryAlignment

unsigned getEntryAlignment(const DataLayout &TD) const

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

Definition:MachineFunction.cpp:1340

llvm::MachineJumpTableInfo::getEntryKind

JTEntryKind getEntryKind() const

Definition:MachineJumpTableInfo.h:95

llvm::MachineMemOperand

A description of a memory reference used in the backend.

Definition:MachineMemOperand.h:129

llvm::MachineMemOperand::getSize

LocationSize getSize() const

Return the size in bytes of the memory reference.

Definition:MachineMemOperand.h:240

llvm::MachineMemOperand::getFailureOrdering

AtomicOrdering getFailureOrdering() const

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

Definition:MachineMemOperand.h:285

llvm::MachineMemOperand::getPseudoValue

const PseudoSourceValue * getPseudoValue() const

Definition:MachineMemOperand.h:217

llvm::MachineMemOperand::getRanges

const MDNode * getRanges() const

Return the range tag for the memory reference.

Definition:MachineMemOperand.h:269

llvm::MachineMemOperand::getSyncScopeID

SyncScope::ID getSyncScopeID() const

Returns the synchronization scope ID for this memory operation.

Definition:MachineMemOperand.h:272

llvm::MachineMemOperand::Flags

Flags

Flags values. These may be or'd together.

Definition:MachineMemOperand.h:132

llvm::MachineMemOperand::getSuccessOrdering

AtomicOrdering getSuccessOrdering() const

Return the atomic ordering requirements for this memory operation.

Definition:MachineMemOperand.h:279

llvm::MachineMemOperand::getPointerInfo

const MachinePointerInfo & getPointerInfo() const

Definition:MachineMemOperand.h:204

llvm::MachineMemOperand::getFlags

Flags getFlags() const

Return the raw flags of the source value,.

Definition:MachineMemOperand.h:224

llvm::MachineMemOperand::getAAInfo

AAMDNodes getAAInfo() const

Return the AA tags for the memory reference.

Definition:MachineMemOperand.h:266

llvm::MachineMemOperand::getValue

const Value * getValue() const

Return the base address of the memory access.

Definition:MachineMemOperand.h:213

llvm::MachineMemOperand::getBaseAlign

Align getBaseAlign() const

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

Definition:MachineMemOperand.h:263

llvm::MachineMemOperand::getOffset

int64_t getOffset() const

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

Definition:MachineMemOperand.h:231

llvm::MachineOperand

MachineOperand class - Representation of each machine instruction operand.

Definition:MachineOperand.h:48

llvm::MachineOperand::getRegMaskSize

static unsigned getRegMaskSize(unsigned NumRegs)

Returns number of elements needed for a regmask array.

Definition:MachineOperand.h:666

llvm::MachineOperand::getReg

getReg - Returns the register number.

Definition:MachineOperand.h:369

llvm::MachineRegisterInfo

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

Definition:MachineRegisterInfo.h:51

llvm::MachineRegisterInfo::livein_empty

bool livein_empty() const

Definition:MachineRegisterInfo.h:1016

llvm::MachineRegisterInfo::def_instr_begin

def_instr_iterator def_instr_begin(Register RegNo) const

Definition:MachineRegisterInfo.h:413

llvm::MachineRegisterInfo::livein_iterator

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

Definition:MachineRegisterInfo.h:1013

llvm::MachineRegisterInfo::hasOneDef

bool hasOneDef(Register RegNo) const

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

Definition:MachineRegisterInfo.h:460

llvm::MachineRegisterInfo::livein_end

livein_iterator livein_end() const

Definition:MachineRegisterInfo.h:1015

llvm::MachineRegisterInfo::livein_begin

livein_iterator livein_begin() const

Definition:MachineRegisterInfo.h:1014

llvm::ModuleSlotTracker

Manage lifetime of a slot tracker for printing IR.

Definition:ModuleSlotTracker.h:44

llvm::ModuleSlotTracker::incorporateFunction

void incorporateFunction(const Function &F)

Incorporate the given function.

Definition:AsmWriter.cpp:904

llvm::Module::debug_compile_units

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

Definition:Module.h:870

llvm::PointerUnion::isNull

bool isNull() const

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

Definition:PointerUnion.h:142

llvm::Printable

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

Definition:Printable.h:38

llvm::Register

Wrapper class representing virtual and physical registers.

Definition:Register.h:19

llvm::SectionKind

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

Definition:SectionKind.h:22

llvm::SectionKind::getMergeableConst4

static SectionKind getMergeableConst4()

Definition:SectionKind.h:202

llvm::SectionKind::getReadOnlyWithRel

static SectionKind getReadOnlyWithRel()

Definition:SectionKind.h:214

llvm::SectionKind::getMergeableConst8

static SectionKind getMergeableConst8()

Definition:SectionKind.h:203

llvm::SectionKind::getMergeableConst16

static SectionKind getMergeableConst16()

Definition:SectionKind.h:204

llvm::SectionKind::getReadOnly

static SectionKind getReadOnly()

Definition:SectionKind.h:192

llvm::SectionKind::getMergeableConst32

static SectionKind getMergeableConst32()

Definition:SectionKind.h:205

llvm::SlotIndexes

SlotIndexes pass.

Definition:SlotIndexes.h:297

llvm::SmallString

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

Definition:SmallString.h:26

llvm::SmallVectorImpl::clear

void clear()

Definition:SmallVector.h:610

llvm::SmallVectorTemplateBase::push_back

void push_back(const T &Elt)

Definition:SmallVector.h:413

llvm::SmallVector

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

Definition:SmallVector.h:1196

llvm::StringRef

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

Definition:StringRef.h:51

llvm::TargetFrameLowering::isStackRealignable

bool isStackRealignable() const

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

Definition:TargetFrameLowering.h:131

llvm::TargetFrameLowering::getStackAlign

Align getStackAlign() const

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

Definition:TargetFrameLowering.h:105

llvm::TargetInstrInfo

TargetInstrInfo - Interface to description of machine instruction set.

Definition:TargetInstrInfo.h:112

llvm::TargetLoweringBase::getPrefFunctionAlignment

Align getPrefFunctionAlignment() const

Return the preferred function alignment.

Definition:TargetLowering.h:2046

llvm::TargetLoweringBase::getMinFunctionAlignment

Align getMinFunctionAlignment() const

Return the minimum function alignment.

Definition:TargetLowering.h:2043

llvm::TargetMachine

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

Definition:TargetMachine.h:77

llvm::TargetMachine::Options

TargetOptions Options

Definition:TargetMachine.h:118

llvm::TargetOptions::ForceDwarfFrameSection

unsigned ForceDwarfFrameSection

Emit DWARF debug frame section.

Definition:TargetOptions.h:353

llvm::TargetRegisterClass

Definition:TargetRegisterInfo.h:44

llvm::TargetRegisterClass::contains

bool contains(Register Reg) const

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

Definition:TargetRegisterInfo.h:94

llvm::TargetRegisterClass::hasSubClassEq

bool hasSubClassEq(const TargetRegisterClass *RC) const

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

Definition:TargetRegisterInfo.h:130

llvm::TargetRegisterInfo

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

Definition:TargetRegisterInfo.h:235

llvm::TargetSubtargetInfo

TargetSubtargetInfo - Generic base class for all target subtargets.

Definition:TargetSubtargetInfo.h:63

llvm::TargetSubtargetInfo::getRegisterInfo

virtual const TargetRegisterInfo * getRegisterInfo() const

getRegisterInfo - If register information is available, return it.

Definition:TargetSubtargetInfo.h:129

llvm::TargetSubtargetInfo::getFrameLowering

virtual const TargetFrameLowering * getFrameLowering() const

Definition:TargetSubtargetInfo.h:98

llvm::TargetSubtargetInfo::getInstrInfo

virtual const TargetInstrInfo * getInstrInfo() const

Definition:TargetSubtargetInfo.h:97

llvm::TargetSubtargetInfo::getTargetLowering

virtual const TargetLowering * getTargetLowering() const

Definition:TargetSubtargetInfo.h:101

llvm::Target

Target - Wrapper for Target specific information.

Definition:TargetRegistry.h:144

llvm::Twine

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

Definition:Twine.h:81

llvm::Type

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

Definition:Type.h:45

llvm::Use

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

Definition:Use.h:43

llvm::Value

LLVM Value Representation.

Definition:Value.h:74

llvm::Value::stripPointerCasts

const Value * stripPointerCasts() const

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

Definition:Value.cpp:694

llvm::Value::getName

StringRef getName() const

Return a constant reference to the value's name.

Definition:Value.cpp:309

llvm::cl::opt

Definition:CommandLine.h:1423

llvm::ilist_node_impl::getIterator

self_iterator getIterator()

Definition:ilist_node.h:132

llvm::iplist_impl::erase

iterator erase(iterator where)

Definition:ilist.h:204

llvm::raw_ostream

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

Definition:raw_ostream.h:52

llvm::raw_string_ostream

A raw_ostream that writes to an std::string.

Definition:raw_ostream.h:661

llvm::raw_svector_ostream

A raw_ostream that writes to an SmallVector or SmallString.

Definition:raw_ostream.h:691

#define llvm_unreachable(msg)

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

Definition:ErrorHandling.h:143

TargetMachine.h

llvm::CallingConv::C

@ C

The default llvm calling convention, compatible with C.

Definition:CallingConv.h:34

llvm::cl::Hidden

@ Hidden

Definition:CommandLine.h:137

llvm::cl::init

initializer< Ty > init(const Ty &Val)

Definition:CommandLine.h:443

llvm

This is an optimization pass for GlobalISel generic memory operations.

Definition:AddressRanges.h:18

llvm::Offset

@ Offset

Definition:DWP.cpp:480

llvm::getBundleStart

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

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

Definition:MachineInstrBundle.h:44

llvm::CGDataKind::Unknown

@ Unknown

llvm::BuildMI

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

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

Definition:MachineInstrBuilder.h:373

llvm::make_range

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

Convenience function for iterating over sub-ranges.

Definition:iterator_range.h:77

llvm::append_range

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

Wrapper function to append range R to container C.

Definition:STLExtras.h:2115

llvm::getAlign

MaybeAlign getAlign(const Function &F, unsigned Index)

Definition:NVPTXUtilities.cpp:323

llvm::printJumpTableEntryReference

Printable printJumpTableEntryReference(unsigned Idx)

Prints a jump table entry reference.

Definition:MachineFunction.cpp:1437

llvm::isScopedEHPersonality

bool isScopedEHPersonality(EHPersonality Pers)

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

Definition:EHPersonalities.h:80

llvm::MachineFunctionDataHotness

MachineFunctionDataHotness

Definition:MachineFunction.h:94

llvm::reverse

auto reverse(ContainerTy &&C)

Definition:STLExtras.h:420

llvm::dbgs

raw_ostream & dbgs()

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

Definition:Debug.cpp:163

llvm::getBundleEnd

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

Returns an iterator pointing beyond the bundle containing I.

Definition:MachineInstrBundle.h:60

llvm::ConstantFoldCastOperand

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

Attempt to constant fold a cast with the specified operand.

Definition:ConstantFolding.cpp:1462

llvm::classifyEHPersonality

EHPersonality classifyEHPersonality(const Value *Pers)

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

Definition:EHPersonalities.cpp:23

llvm::CodeGenOptLevel::None

@ None

-O0

llvm::errs

raw_fd_ostream & errs()

This returns a reference to a raw_ostream for standard error.

Definition:raw_ostream.cpp:907

llvm::AtomicOrdering

AtomicOrdering

Atomic ordering for LLVM's memory model.

Definition:AtomicOrdering.h:56

llvm::isFuncletEHPersonality

bool isFuncletEHPersonality(EHPersonality Pers)

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

Definition:EHPersonalities.h:65

llvm::alignTo

uint64_t alignTo(uint64_t Size, Align A)

Returns a multiple of A needed to store Size bytes.

Definition:Alignment.h:155

llvm::ViewGraph

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.

Definition:GraphWriter.h:427

llvm::copy

OutputIt copy(R &&Range, OutputIt Out)

Definition:STLExtras.h:1841

llvm::commonAlignment

Align commonAlignment(Align A, uint64_t Offset)

Returns the alignment that satisfies both alignments.

Definition:Alignment.h:212

llvm::BasicBlockSection::List

@ List

llvm::printReg

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.

Definition:TargetRegisterInfo.cpp:107

llvm::printMBBReference

Printable printMBBReference(const MachineBasicBlock &MBB)

Prints a machine basic block reference.

Definition:MachineBasicBlock.cpp:122

llvm::debuginfoShouldUseDebugInstrRef

bool debuginfoShouldUseDebugInstrRef(const Triple &T)

Definition:LiveDebugValues.cpp:123

raw_ostream.h

#define N

llvm::AAMDNodes

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

Definition:Metadata.h:764

llvm::Align

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

Definition:Alignment.h:39

llvm::Align::value

uint64_t value() const

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

Definition:Alignment.h:85

llvm::DOTGraphTraits< const MachineFunction * >::getNodeLabel

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

Definition:MachineFunction.cpp:712

llvm::DOTGraphTraits< const MachineFunction * >::DOTGraphTraits

DOTGraphTraits(bool isSimple=false)

Definition:MachineFunction.cpp:706

llvm::DOTGraphTraits< const MachineFunction * >::getGraphName

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

Definition:MachineFunction.cpp:708

llvm::DOTGraphTraits

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

Definition:DOTGraphTraits.h:166

llvm::DefaultDOTGraphTraits

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

Definition:DOTGraphTraits.h:28

llvm::DenormalMode

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

Definition:FloatingPointMode.h:70

llvm::LandingPadInfo

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

Definition:MachineFunction.h:255

llvm::LandingPadInfo::EndLabels

SmallVector< MCSymbol *, 1 > EndLabels

Definition:MachineFunction.h:258

llvm::LandingPadInfo::LandingPadLabel

MCSymbol * LandingPadLabel

Definition:MachineFunction.h:260

llvm::LandingPadInfo::LandingPadBlock

MachineBasicBlock * LandingPadBlock

Definition:MachineFunction.h:256

llvm::LandingPadInfo::BeginLabels

SmallVector< MCSymbol *, 1 > BeginLabels

Definition:MachineFunction.h:257

llvm::LandingPadInfo::TypeIds

std::vector< int > TypeIds

Definition:MachineFunction.h:261

llvm::MachineFunctionInfo::~MachineFunctionInfo

virtual ~MachineFunctionInfo()

llvm::MachineFunction::CallSiteInfo

Definition:MachineFunction.h:496

llvm::MachineFunction::CalledGlobalInfo

Definition:MachineFunction.h:501

llvm::MachineJumpTableEntry

MachineJumpTableEntry - One jump table in the jump table info.

Definition:MachineJumpTableInfo.h:35

llvm::MachineJumpTableEntry::MachineJumpTableEntry

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

Definition:MachineFunction.cpp:1315

llvm::MachineJumpTableEntry::MBBs

std::vector< MachineBasicBlock * > MBBs

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

Definition:MachineJumpTableInfo.h:37

llvm::MachinePointerInfo

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

Definition:MachineMemOperand.h:41

llvm::MachinePointerInfo::V

PointerUnion< const Value *, const PseudoSourceValue * > V

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

Definition:MachineMemOperand.h:43

llvm::MachinePointerInfo::getWithOffset

MachinePointerInfo getWithOffset(int64_t O) const

Definition:MachineMemOperand.h:81

llvm::UniqueBBID

Definition:MachineBasicBlock.h:102

llvm::WasmEHFuncInfo

Definition:WasmEHFuncInfo.h:32

llvm::WinEHFuncInfo

Definition:WinEHFuncInfo.h:90

llvm::cl::desc

Definition:CommandLine.h:409

llvm::fltSemantics

Definition:APFloat.cpp:103

llvm::ilist_alloc_traits::deleteNode

static void deleteNode(NodeTy *V)

Definition:ilist.h:42