CloneFunction.cpp Source File (original) (raw)

38#include

39#include

40using namespace llvm;

42#define DEBUG_TYPE "clone-function"

44 STATISTIC(RemappedAtomMax, "Highest global NextAtomGroup (after mapping)");

47 uint64_t CurGroup = DL->getAtomGroup();

48 if (!CurGroup)

49 return;

53 auto [It, Inserted] = VMap.AtomMap.insert({{DL.getInlinedAt(), CurGroup}, 0});

54 if (!Inserted)

55 return;

58 uint64_t NewGroup = DL->getContext().incNextDILocationAtomGroup();

59 assert(NewGroup > CurGroup && "Next should always be greater than current");

60 It->second = NewGroup;

62 RemappedAtomMax = std::max<uint64_t>(NewGroup, RemappedAtomMax);

63}

67 const Module *M = F.getParent();

68 if (!M)

69 return;

73}

80 return [](const Metadata *MD) { return false; };

82 DISubprogram *SPClonedWithinModule = F.getSubprogram();

85 auto ShouldKeep = [SPClonedWithinModule](const DISubprogram *SP) -> bool {

86 return SP != SPClonedWithinModule;

87 };

89 return [=](const Metadata *MD) {

92 return true;

95 return ShouldKeep(SP);

99 return ShouldKeep(LScope->getSubprogram());

100

101

104 return ShouldKeep(S->getSubprogram());

105

106 return false;

107 };

108}

109

110

117

118 bool hasCalls = false, hasDynamicAllocas = false, hasMemProfMetadata = false;

119

120

123 if (I.hasName())

124 NewInst->setName(I.getName() + NameSuffix);

125

128

129 VMap[&I] = NewInst;

130

131 if (MapAtoms) {

134 }

135

137 hasCalls = true;

138 hasMemProfMetadata |= I.hasMetadata(LLVMContext::MD_memprof);

139 hasMemProfMetadata |= I.hasMetadata(LLVMContext::MD_callsite);

140 }

142 if (!AI->isStaticAlloca()) {

143 hasDynamicAllocas = true;

144 }

145 }

146 }

147

148 if (CodeInfo) {

152 }

153 return NewBB;

154}

155

159 bool ModuleLevelChanges,

162

163

164 AttributeList NewAttrs = NewFunc->getAttributes();

167

168 const RemapFlags FuncGlobalRefFlags =

170

171

174 FuncGlobalRefFlags, TypeMapper,

175 Materializer));

176

179 FuncGlobalRefFlags, TypeMapper,

180 Materializer));

181 }

182

185 FuncGlobalRefFlags, TypeMapper,

186 Materializer));

187 }

188

190 AttributeList OldAttrs = OldFunc->getAttributes();

191

192

193 for (const Argument &OldArg : OldFunc->args()) {

195

196 NewArgAttrs[NewArg->getArgNo()] =

197 OldAttrs.getParamAttrs(OldArg.getArgNo());

198 }

199 }

200

202 AttributeList::get(NewFunc->getContext(), OldAttrs.getFnAttrs(),

203 OldAttrs.getRetAttrs(), NewArgAttrs));

204}

205

214 for (const auto &[Kind, MD] : MDs) {

216 Materializer, IdentityMD));

217 }

218}

219

223 const char *NameSuffix,

229 return;

230

231

232

233

234 for (const BasicBlock &BB : OldFunc) {

235

237 CloneBasicBlock(&BB, VMap, NameSuffix, &NewFunc, CodeInfo);

238

239

240 VMap[&BB] = CBB;

241

242

243

244

245

246

247

248 if (BB.hasAddressTaken()) {

252 }

253

254

257 }

258

259

260

263 BE = NewFunc.end();

264 BB != BE; ++BB)

265

266

269 IdentityMD);

271 RemapFlag, TypeMapper, Materializer, IdentityMD);

272 }

273}

274

275

276

284 assert(NameSuffix && "NameSuffix cannot be null!");

285

286#ifndef NDEBUG

288 assert(VMap.count(&I) && "No mapping from source argument specified!");

289#endif

290

292

294 TypeMapper, Materializer);

295

296

297

299 return;

300

304 "Expected NewFunc to have the same parent, or no parent");

305 } else {

308 "Expected NewFunc to have different parents, or no parent");

309

312 "Need parent of new function to maintain debug info invariants");

313 }

314 }

315

317

318

319

321

323 Materializer, &IdentityMD);

324

326 NameSuffix, CodeInfo, TypeMapper, Materializer,

327 &IdentityMD);

328

329

330

331

333 return;

334

335

336

337

338

339

340

341

342

343

344

347

349

350

351

357 if (Visited.insert(MappedUnit).second)

359 }

360}

361

362

363

364

365

366

367

368

371 std::vector<Type *> ArgTypes;

372

373

374

375

377 if (VMap.count(&I) == 0)

378 ArgTypes.push_back(I.getType());

379

380

383 F->getFunctionType()->isVarArg());

384

385

387 F->getName(), F->getParent());

388

389

392 if (VMap.count(&I) == 0) {

393 DestI->setName(I.getName());

394 VMap[&I] = &*DestI++;

395 }

396

399 Returns, "", CodeInfo);

400

401 return NewF;

402}

403

404namespace {

405

406struct PruningFunctionCloner {

410 bool ModuleLevelChanges;

411 const char *NameSuffix;

413 bool HostFuncIsStrictFP;

414

416

417public:

418 PruningFunctionCloner(Function *newFunc, const Function *oldFunc,

421 : NewFunc(newFunc), OldFunc(oldFunc), VMap(valueMap),

422 ModuleLevelChanges(moduleLevelChanges), NameSuffix(nameSuffix),

423 CodeInfo(codeInfo) {

424 HostFuncIsStrictFP =

425 newFunc->getAttributes().hasFnAttr(Attribute::StrictFP);

426 }

427

428

429

431 std::vector<const BasicBlock *> &ToClone);

432};

433}

434

439 if (HostFuncIsStrictFP) {

442

443

444

445

446

447

451 for (unsigned I = 0, E = Descriptor.size(); I != E; ++I) {

452 Intrinsic::IITDescriptor Operand = Descriptor[I];

453 switch (Operand.Kind) {

456 Intrinsic::IITDescriptor::AK_MatchType) {

457 if (I == 0)

459 else

461 }

462 break;

464 ++I;

465 break;

466 default:

467 break;

468 }

469 }

470

471

472 LLVMContext &Ctx = NewFunc->getContext();

474 CIID, TParams);

478 --NumOperands;

479 for (unsigned I = 0; I < NumOperands; ++I) {

482 }

484 FCmpInst::Predicate Pred = CmpI->getPredicate();

485 StringRef PredName = FCmpInst::getPredicateName(Pred);

487 }

488

489

490

491

493 Args.push_back(

495 Args.push_back(

497

499 }

500 }

501 if (!NewInst)

502 NewInst = II->clone();

503 return NewInst;

504}

505

506

507

508void PruningFunctionCloner::CloneBlock(

510 std::vector<const BasicBlock *> &ToClone) {

511 WeakTrackingVH &BBEntry = VMap[BB];

512

513

514 if (BBEntry)

515 return;

516

517

519 Twine NewName(BB->hasName() ? Twine(BB->getName()) + NameSuffix : "");

521

522

523

524

525

526

527

528

529

530

535 }

536

537 bool hasCalls = false, hasDynamicAllocas = false, hasStaticAllocas = false;

538 bool hasMemProfMetadata = false;

539

540

542 auto CloneDbgRecordsToHere =

544

545

546

547 for (; DbgCursor != II; ++DbgCursor)

550 DbgCursor = std::next(II);

551 };

552

553

554

556 ++II) {

557

558

559

561 if (IntrInst->getIntrinsicID() == Intrinsic::fake_use)

562 continue;

563

566

567 if (HostFuncIsStrictFP) {

568

569

572 }

573

574

575

579

580

581

582

583

587 VMap[&*II] = V;

589 continue;

590 }

591 }

592 }

593

594 if (II->hasName())

595 NewInst->setName(II->getName() + NameSuffix);

596 VMap[&*II] = NewInst;

598 hasCalls = true;

599 hasMemProfMetadata |= II->hasMetadata(LLVMContext::MD_memprof);

600 hasMemProfMetadata |= II->hasMetadata(LLVMContext::MD_callsite);

601 }

602

603 CloneDbgRecordsToHere(NewInst, II);

604

605 if (CodeInfo) {

608 if (CB->hasOperandBundles())

610 }

611

614 hasStaticAllocas = true;

615 else

616 hasDynamicAllocas = true;

617 }

618 }

619

620

622 bool TerminatorDone = false;

624 if (BI->isConditional()) {

625

627

631 }

632

633

635 BasicBlock *Dest = BI->getSuccessor( Cond ->getZExtValue());

637 NewBI->setDebugLoc(BI->getDebugLoc());

638 VMap[OldTI] = NewBI;

639 ToClone.push_back(Dest);

640 TerminatorDone = true;

641 }

642 }

644

646 if ( Cond ) {

649 }

650 if (Cond) {

654 NewBI->setDebugLoc(SI->getDebugLoc());

655 VMap[OldTI] = NewBI;

656 ToClone.push_back(Dest);

657 TerminatorDone = true;

658 }

659 }

660

661 if (!TerminatorDone) {

666

667 CloneDbgRecordsToHere(NewInst, OldTI->getIterator());

668

669 VMap[OldTI] = NewInst;

670

671 if (CodeInfo) {

672 CodeInfo->OrigVMap[OldTI] = NewInst;

674 if (CB->hasOperandBundles())

676 }

677

678

680 } else {

681

682

685

686 CloneDbgRecordsToHere(NewInst, OldTI->getIterator());

687 }

688

689 if (CodeInfo) {

695 }

696}

697

698

699

700

704 bool ModuleLevelChanges,

706 const char *NameSuffix,

708 assert(NameSuffix && "NameSuffix cannot be null!");

709

712

713#ifndef NDEBUG

714

715

716 if (!StartingInst)

718 assert(VMap.count(&II) && "No mapping from source argument specified!");

719#endif

720

721 PruningFunctionCloner PFC(NewFunc, OldFunc, VMap, ModuleLevelChanges,

722 NameSuffix, CodeInfo);

724 if (StartingInst)

725 StartingBB = StartingInst->getParent();

726 else {

728 StartingInst = &StartingBB->front();

729 }

730

731

732 std::vector<const BasicBlock *> CloneWorklist;

733 PFC.CloneBlock(StartingBB, StartingInst->getIterator(), CloneWorklist);

734 while (!CloneWorklist.empty()) {

735 const BasicBlock *BB = CloneWorklist.back();

736 CloneWorklist.pop_back();

737 PFC.CloneBlock(BB, BB->begin(), CloneWorklist);

738 }

739

740

741

742

743

744

746 for (const BasicBlock &BI : *OldFunc) {

749 if (!NewBB)

750 continue;

751

752

754

755

756

757 for (const PHINode &PN : BI.phis()) {

758

759

762 else

763 break;

764 }

765

766

767

770 TypeMapper, Materializer);

771 }

772

773

774

775 for (unsigned phino = 0, e = PHIToResolve.size(); phino != e;) {

776 const PHINode *OPN = PHIToResolve[phino];

780

781

782

783 for (; phino != PHIToResolve.size() &&

784 PHIToResolve[phino]->getParent() == OldBB;

785 ++phino) {

786 OPN = PHIToResolve[phino];

788 for (unsigned pred = 0, e = NumPreds; pred != e; ++pred) {

794 assert(InVal && "Unknown input value?");

797 } else {

799 --pred;

800 --e;

801 }

802 }

803 }

804

805

806

807

808

809

813 assert(NumPreds < PN->getNumIncomingValues());

814

815 std::map<BasicBlock *, unsigned> PredCount;

817 --PredCount[Pred];

818

819

821 ++PredCount[Pred];

822

823

824

825

828 for (const auto &[Pred, Count] : PredCount) {

831 }

832 }

833 }

834

835

836

837

845 assert(VMap[&*OldI] == PN && "VMap mismatch");

846 VMap[&*OldI] = NV;

848 ++OldI;

849 }

850 }

851 }

852

853

854

855

857 AttributeMask IncompatibleAttrs = AttributeFuncs::typeIncompatible(

860

861

862

864 for (const BasicBlock &BB : *OldFunc) {

867 if (!NewI)

868 continue;

869

871 NewI->replaceAllUsesWith(V);

872

874 NewI->eraseFromParent();

875 } else {

876

877

878 VMap[&I] = NewI;

879 }

880 }

881 }

882 }

883

884

886

887

888

889

890

891

896 ModuleLevelChanges ? RF_None

898 TypeMapper, Materializer);

899 }

900 }

901

902

903

904

905

906

909

910

911 {

915 while (!Worklist.empty()) {

917 if (ReachableBlocks.insert(BB).second)

919 }

920

923 if (!ReachableBlocks.contains(&BB))

924 UnreachableBlocks.push_back(&BB);

926 }

927

928

929

930

931

933 while (I != NewFunc->end()) {

936 ++I;

937 continue;

938 }

939

942 ++I;

943 continue;

944 }

945

946

947

949

950

951

953

954

956

957

958 I->splice(I->end(), Dest);

959

960

962

963

964 }

965

966

967

968

970 E = NewFunc->end();

971 I != E; ++I)

974}

975

976

977

978

979

980

981

982

988 ModuleLevelChanges, Returns, NameSuffix, CodeInfo);

989}

990

991

1004

1005

1006

1007

1008

1009

1018

1020 LMap[OrigLoop] = NewLoop;

1021 if (ParentLoop)

1023 else

1025

1027 assert(OrigPH && "No preheader");

1029

1030 VMap[OrigPH] = NewPH;

1032

1033

1034 if (ParentLoop)

1036

1037

1039

1041 Loop *&NewLoop = LMap[CurLoop];

1042 if (!NewLoop) {

1044

1045

1047 assert(OrigParent && "Could not find the original parent loop");

1048 Loop *NewParentLoop = LMap[OrigParent];

1049 assert(NewParentLoop && "Could not find the new parent loop");

1050

1052 }

1053 }

1054

1057 Loop *&NewLoop = LMap[CurLoop];

1058 assert(NewLoop && "Expecting new loop to be allocated");

1059

1061 VMap[BB] = NewBB;

1062

1063

1065

1066

1067

1069

1071 }

1072

1074

1078

1079

1083 }

1084

1085

1088 F->end());

1089

1090 return NewLoop;

1091}

1092

1093

1094

1098

1100 "There must be a single edge between PredBB and BB!");

1101

1102

1103

1107

1111

1112

1113

1117

1118

1119

1120

1121

1124 New->setName(BI->getName());

1125 New->insertBefore(NewTerm->getIterator());

1126 New->cloneDebugInfoFrom(&*BI);

1127 ValueMapping[&*BI] = New;

1128

1129

1130 for (unsigned i = 0, e = New->getNumOperands(); i != e; ++i)

1132 auto I = ValueMapping.find(Inst);

1133 if (I != ValueMapping.end())

1134 New->setOperand(i, I->second);

1135 }

1136

1137

1139 }

1140

1141 return NewBB;

1142}

1143

1148

1149 for (MDNode *ScopeList : NoAliasDeclScopes) {

1150 for (const MDOperand &MDOp : ScopeList->operands()) {

1153

1154 std::string Name;

1155 auto ScopeName = SNANode.getName();

1156 if (!ScopeName.empty())

1157 Name = (Twine(ScopeName) + ":" + Ext).str();

1158 else

1159 Name = std::string(Ext);

1160

1163 ClonedScopes.insert(std::make_pair(MD, NewScope));

1164 }

1165 }

1166 }

1167}

1168

1172 auto CloneScopeList = [&](const MDNode *ScopeList) -> MDNode * {

1173 bool NeedsReplacement = false;

1175 for (const MDOperand &MDOp : ScopeList->operands()) {

1177 if (auto *NewMD = ClonedScopes.lookup(MD)) {

1179 NeedsReplacement = true;

1180 continue;

1181 }

1183 }

1184 }

1185 if (NeedsReplacement)

1186 return MDNode::get(Context, NewScopeList);

1187 return nullptr;

1188 };

1189

1191 if (MDNode *NewScopeList = CloneScopeList(Decl->getScopeList()))

1192 Decl->setScopeList(NewScopeList);

1193

1194 auto replaceWhenNeeded = [&](unsigned MD_ID) {

1195 if (const MDNode *CSNoAlias = I->getMetadata(MD_ID))

1196 if (MDNode *NewScopeList = CloneScopeList(CSNoAlias))

1197 I->setMetadata(MD_ID, NewScopeList);

1198 };

1199 replaceWhenNeeded(LLVMContext::MD_noalias);

1200 replaceWhenNeeded(LLVMContext::MD_alias_scope);

1201}

1202

1206 if (NoAliasDeclScopes.empty())

1207 return;

1208

1210 LLVM_DEBUG(dbgs() << "cloneAndAdaptNoAliasScopes: cloning "

1211 << NoAliasDeclScopes.size() << " node(s)\n");

1212

1214

1215 for (BasicBlock *NewBlock : NewBlocks)

1218}

1219

1223 if (NoAliasDeclScopes.empty())

1224 return;

1225

1227 LLVM_DEBUG(dbgs() << "cloneAndAdaptNoAliasScopes: cloning "

1228 << NoAliasDeclScopes.size() << " node(s)\n");

1229

1231

1235 ++ItEnd;

1238}

1239

1245 NoAliasDeclScopes.push_back(Decl->getScopeList());

1246}

1247

1253 NoAliasDeclScopes.push_back(Decl->getScopeList());

1254}

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

MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL

Expand Atomic instructions

static const Function * getParent(const Value *V)

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

static MetadataPredicate createIdentityMDPredicate(const Function &F, CloneFunctionChangeType Changes)

Definition CloneFunction.cpp:78

static void collectDebugInfoFromInstructions(const Function &F, DebugInfoFinder &DIFinder)

Definition CloneFunction.cpp:65

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

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

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

uint64_t IntrinsicInst * II

const SmallVectorImpl< MachineOperand > & Cond

This file defines the SmallVector class.

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

#define STATISTIC(VARNAME, DESC)

This is a simple wrapper around an MDNode which provides a higher-level interface by hiding the detai...

const MDNode * getDomain() const

Get the MDNode for this AliasScopeNode's domain.

StringRef getName() const

an instruction to allocate memory on the stack

This class represents an incoming formal argument to a Function.

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

size_t size() const

size - Get the array size.

bool empty() const

empty - Check if the array is empty.

This class stores enough information to efficiently remove some attributes from an existing AttrBuild...

LLVM Basic Block Representation.

iterator begin()

Instruction iterator methods.

const Function * getParent() const

Return the enclosing method, or null if none.

bool hasAddressTaken() const

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

InstListType::const_iterator const_iterator

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

Creates a new BasicBlock.

LLVM_ABI const BasicBlock * getSinglePredecessor() const

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

const Instruction & front() const

LLVM_ABI const DataLayout & getDataLayout() const

Get the data layout of the module this basic block belongs to.

LLVM_ABI SymbolTableList< BasicBlock >::iterator eraseFromParent()

Unlink 'this' from the containing function and delete it.

InstListType::iterator iterator

Instruction iterators...

LLVM_ABI LLVMContext & getContext() const

Get the context in which this basic block lives.

void moveBefore(BasicBlock *MovePos)

Unlink this basic block from its current function and insert it into the function that MovePos lives ...

const Instruction * getTerminator() const LLVM_READONLY

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

static LLVM_ABI BlockAddress * get(Function *F, BasicBlock *BB)

Return a BlockAddress for the specified function and basic block.

Conditional or Unconditional Branch instruction.

bool isConditional() const

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

BasicBlock * getSuccessor(unsigned i) const

void addFnAttr(Attribute::AttrKind Kind)

Adds the attribute to the function.

static CallInst * Create(FunctionType *Ty, Value *F, const Twine &NameStr="", InsertPosition InsertBefore=nullptr)

This is an important base class in LLVM.

Subprogram description. Uses SubclassData1.

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

Utility to find all debug info in a module.

LLVM_ABI void processInstruction(const Module &M, const Instruction &I)

Process a single instruction and collect debug info anchors.

iterator_range< compile_unit_iterator > compile_units() const

ValueT lookup(const_arg_type_t< KeyT > Val) const

lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...

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

DomTreeNodeBase * getIDom() const

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

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

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

Add a new node to the dominator tree information.

static constexpr UpdateKind Delete

static constexpr UpdateKind Insert

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

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

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

Class to represent function types.

static LLVM_ABI FunctionType * get(Type *Result, ArrayRef< Type * > Params, bool isVarArg)

This static method is the primary way of constructing a FunctionType.

static Function * Create(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace, const Twine &N="", Module *M=nullptr)

const BasicBlock & getEntryBlock() const

BasicBlockListType::iterator iterator

void setPrefixData(Constant *PrefixData)

const DataLayout & getDataLayout() const

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

const BasicBlock & front() const

iterator_range< arg_iterator > args()

bool hasPrefixData() const

Check whether this function has prefix data.

bool hasPersonalityFn() const

Check whether this function has a personality function.

Constant * getPrologueData() const

Get the prologue data associated with this function.

Constant * getPersonalityFn() const

Get the personality function associated with this function.

void setPersonalityFn(Constant *Fn)

AttributeList getAttributes() const

Return the attribute list for this Function.

void setAttributes(AttributeList Attrs)

Set the attribute list for this Function.

LLVMContext & getContext() const

getContext - Return a reference to the LLVMContext associated with this function.

void setPrologueData(Constant *PrologueData)

void removeRetAttrs(const AttributeMask &Attrs)

removes the attributes from the return value list of attributes.

Type * getReturnType() const

Returns the type of the ret val.

Constant * getPrefixData() const

Get the prefix data associated with this function.

bool hasPrologueData() const

Check whether this function has prologue data.

void copyAttributesFrom(const Function *Src)

copyAttributesFrom - copy all additional attributes (those not needed to create a Function) from the ...

void applyUpdates(ArrayRef< UpdateT > Updates)

Submit updates to all available trees.

LLVM_ABI void getAllMetadata(SmallVectorImpl< std::pair< unsigned, MDNode * > > &MDs) const

Appends all metadata attached to this value to MDs, sorting by KindID.

LLVM_ABI void addMetadata(unsigned KindID, MDNode &MD)

Add a metadata attachment.

LLVM_ABI bool isDeclaration() const

Return true if the primary definition of this global value is outside of the current translation unit...

Module * getParent()

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

LLVM_ABI Instruction * clone() const

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

LLVM_ABI iterator_range< simple_ilist< DbgRecord >::iterator > cloneDebugInfoFrom(const Instruction *From, std::optional< simple_ilist< DbgRecord >::iterator > FromHere=std::nullopt, bool InsertAtHead=false)

Clone any debug-info attached to From onto this instruction.

const DebugLoc & getDebugLoc() const

Return the debug location for this node as a DebugLoc.

LLVM_ABI void insertBefore(InstListType::iterator InsertPos)

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

LLVM_ABI InstListType::iterator eraseFromParent()

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

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

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

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

SmallVector< const LoopT *, 4 > getLoopsInPreorder() const

Return all loops in the loop nest rooted by the loop in preorder, with siblings in forward program or...

BlockT * getHeader() const

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

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

void addChildLoop(LoopT *NewChild)

Add the specified loop to be a child of this loop.

BlockT * getLoopPreheader() const

If there is a preheader for this loop, return it.

ArrayRef< BlockT * > getBlocks() const

Get a list of the basic blocks which make up this loop.

LoopT * getParentLoop() const

Return the parent loop if it exists or nullptr for top level loops.

void addTopLevelLoop(LoopT *New)

This adds the specified loop to the collection of top-level loops.

LoopT * AllocateLoop(ArgsTy &&...Args)

LoopT * getLoopFor(const BlockT *BB) const

Return the inner most loop that BB lives in.

Represents a single loop in the control flow graph.

MDNode * createAnonymousAliasScope(MDNode *Domain, StringRef Name=StringRef())

Return metadata appropriate for an alias scope root node.

static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)

Tracking metadata reference owned by Metadata.

static LLVM_ABI MDString * get(LLVMContext &Context, StringRef Str)

A Module instance is used to store all the information related to an LLVM module.

NamedMDNode * getOrInsertNamedMetadata(StringRef Name)

Return the named MDNode in the module with the specified name.

iterator_range< op_iterator > operands()

LLVM_ABI void addOperand(MDNode *M)

iterator_range< const_block_iterator > blocks() const

void setIncomingBlock(unsigned i, BasicBlock *BB)

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

Remove an incoming value.

void setIncomingValue(unsigned i, Value *V)

Value * getIncomingValueForBlock(const BasicBlock *BB) const

BasicBlock * getIncomingBlock(unsigned i) const

Return incoming basic block number i.

Value * getIncomingValue(unsigned i) const

Return incoming value number x.

unsigned getNumIncomingValues() const

Return the number of incoming edges.

static LLVM_ABI PoisonValue * get(Type *T)

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

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

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

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

bool contains(ConstPtrType Ptr) const

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

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

void push_back(const T &Elt)

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

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

BasicBlockT * getCaseSuccessor() const

Resolves successor for current case.

CaseHandleImpl< const SwitchInst, const ConstantInt, const BasicBlock > ConstCaseHandle

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

Value * getOperand(unsigned i) const

unsigned getNumOperands() const

This is a class that can be implemented by clients to remap types when cloning constants and instruct...

ValueT lookup(const KeyT &Val) const

lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...

size_type count(const KeyT &Val) const

Return 1 if the specified key is in the map, 0 otherwise.

iterator find(const KeyT &Val)

DMAtomT AtomMap

Map {(InlinedAt, old atom number) -> new atom number}.

This is a class that can be implemented by clients to materialize Values on demand.

LLVM Value Representation.

Type * getType() const

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

LLVM_ABI void setName(const Twine &Name)

Change the name of the value.

LLVM_ABI void replaceAllUsesWith(Value *V)

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

LLVM_ABI StringRef getName() const

Return a constant reference to the value's name.

const ParentTy * getParent() const

self_iterator getIterator()

constexpr char Args[]

Key for Kernel::Metadata::mArgs.

@ BasicBlock

Various leaf nodes.

LLVM_ABI Function * getOrInsertDeclaration(Module *M, ID id, ArrayRef< Type * > Tys={})

Look up the Function declaration of the intrinsic id in the Module M.

LLVM_ABI void getIntrinsicInfoTableEntries(ID id, SmallVectorImpl< IITDescriptor > &T)

Return the IIT table descriptor for the specified intrinsic into an array of IITDescriptors.

LLVM_ABI bool hasConstrainedFPRoundingModeOperand(ID QID)

Returns true if the intrinsic ID is for one of the "ConstrainedFloating-Point Intrinsics" that take r...

friend class Instruction

Iterator for Instructions in a `BasicBlock.

This is an optimization pass for GlobalISel generic memory operations.

FunctionAddr VTableAddr Value

LLVM_ABI void CloneFunctionAttributesInto(Function *NewFunc, const Function *OldFunc, ValueToValueMapTy &VMap, bool ModuleLevelChanges, ValueMapTypeRemapper *TypeMapper=nullptr, ValueMaterializer *Materializer=nullptr)

Clone OldFunc's attributes into NewFunc, transforming values based on the mappings in VMap.

Definition CloneFunction.cpp:156

std::function< bool(const Metadata *)> MetadataPredicate

LLVM_ABI bool ConstantFoldTerminator(BasicBlock *BB, bool DeleteDeadConditions=false, const TargetLibraryInfo *TLI=nullptr, DomTreeUpdater *DTU=nullptr)

If a terminator instruction is predicated on a constant value, convert it into an unconditional branc...

static cl::opt< unsigned long > StopAt("sbvec-stop-at", cl::init(StopAtDisabled), cl::Hidden, cl::desc("Vectorize if the invocation count is < than this. 0 " "disables vectorization."))

LLVM_ABI BasicBlock * CloneBasicBlock(const BasicBlock *BB, ValueToValueMapTy &VMap, const Twine &NameSuffix="", Function *F=nullptr, ClonedCodeInfo *CodeInfo=nullptr, bool MapAtoms=true)

Return a copy of the specified basic block, but without embedding the block into a particular functio...

Definition CloneFunction.cpp:111

decltype(auto) dyn_cast(const From &Val)

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

auto successors(const MachineBasicBlock *BB)

LLVM_ABI Constant * ConstantFoldInstruction(const Instruction *I, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr)

ConstantFoldInstruction - Try to constant fold the specified instruction.

constexpr from_range_t from_range

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

Convenience function for iterating over sub-ranges.

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

Wrapper function to append range R to container C.

LLVM_ABI void remapDebugVariable(ValueToValueMapTy &Mapping, Instruction *Inst)

Remap the operands of the debug records attached to Inst, and the operands of Inst itself if it's a d...

auto cast_or_null(const Y &Val)

auto pred_size(const MachineBasicBlock *BB)

LLVM_ABI BasicBlock * DuplicateInstructionsInSplitBetween(BasicBlock *BB, BasicBlock *PredBB, Instruction *StopAt, ValueToValueMapTy &ValueMapping, DomTreeUpdater &DTU)

Split edge between BB and PredBB and duplicate all non-Phi instructions from BB between its beginning...

Definition CloneFunction.cpp:1095

LLVM_ABI void CloneFunctionMetadataInto(Function &NewFunc, const Function &OldFunc, ValueToValueMapTy &VMap, RemapFlags RemapFlag, ValueMapTypeRemapper *TypeMapper=nullptr, ValueMaterializer *Materializer=nullptr, const MetadataPredicate *IdentityMD=nullptr)

Clone OldFunc's metadata into NewFunc.

Definition CloneFunction.cpp:206

LLVM_ABI Value * simplifyInstruction(Instruction *I, const SimplifyQuery &Q)

See if we can compute a simplified version of this instruction.

auto dyn_cast_or_null(const Y &Val)

LLVM_ABI bool isInstructionTriviallyDead(Instruction *I, const TargetLibraryInfo *TLI=nullptr)

Return true if the result produced by the instruction is not used, and the instruction will return.

void RemapDbgRecordRange(Module *M, iterator_range< DbgRecordIterator > Range, ValueToValueMapTy &VM, RemapFlags Flags=RF_None, ValueMapTypeRemapper *TypeMapper=nullptr, ValueMaterializer *Materializer=nullptr, const MetadataPredicate *IdentityMD=nullptr)

Remap the Values used in the DbgRecords Range using the value map VM.

LLVM_ABI Loop * cloneLoopWithPreheader(BasicBlock *Before, BasicBlock *LoopDomBB, Loop *OrigLoop, ValueToValueMapTy &VMap, const Twine &NameSuffix, LoopInfo *LI, DominatorTree *DT, SmallVectorImpl< BasicBlock * > &Blocks)

Clones a loop OrigLoop.

Definition CloneFunction.cpp:1010

RemapFlags

These are flags that the value mapping APIs allow.

@ RF_IgnoreMissingLocals

If this flag is set, the remapper ignores missing function-local entries (Argument,...

@ RF_NoModuleLevelChanges

If this flag is set, the remapper knows that only local values within a function (such as an instruct...

LLVM_ABI void CloneAndPruneFunctionInto(Function *NewFunc, const Function *OldFunc, ValueToValueMapTy &VMap, bool ModuleLevelChanges, SmallVectorImpl< ReturnInst * > &Returns, const char *NameSuffix="", ClonedCodeInfo *CodeInfo=nullptr)

This works exactly like CloneFunctionInto, except that it does some simple constant prop and DCE on t...

Definition CloneFunction.cpp:983

LLVM_ABI raw_ostream & dbgs()

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

FunctionAddr VTableAddr Count

LLVM_ABI void cloneNoAliasScopes(ArrayRef< MDNode * > NoAliasDeclScopes, DenseMap< MDNode *, MDNode * > &ClonedScopes, StringRef Ext, LLVMContext &Context)

Duplicate the specified list of noalias decl scopes.

Definition CloneFunction.cpp:1144

LLVM_ABI Intrinsic::ID getConstrainedIntrinsicID(const Instruction &Instr)

Returns constrained intrinsic id to represent the given instruction in strictfp function.

class LLVM_GSL_OWNER SmallVector

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

bool isa(const From &Val)

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

LLVM_ABI void CloneFunctionBodyInto(Function &NewFunc, const Function &OldFunc, ValueToValueMapTy &VMap, RemapFlags RemapFlag, SmallVectorImpl< ReturnInst * > &Returns, const char *NameSuffix="", ClonedCodeInfo *CodeInfo=nullptr, ValueMapTypeRemapper *TypeMapper=nullptr, ValueMaterializer *Materializer=nullptr, const MetadataPredicate *IdentityMD=nullptr)

Clone OldFunc's body into NewFunc.

Definition CloneFunction.cpp:220

auto count(R &&Range, const E &Element)

Wrapper function around std::count to count the number of times an element Element occurs in the give...

LLVM_ABI void adaptNoAliasScopes(llvm::Instruction *I, const DenseMap< MDNode *, MDNode * > &ClonedScopes, LLVMContext &Context)

Adapt the metadata for the specified instruction according to the provided mapping.

Definition CloneFunction.cpp:1169

void RemapInstruction(Instruction *I, ValueToValueMapTy &VM, RemapFlags Flags=RF_None, ValueMapTypeRemapper *TypeMapper=nullptr, ValueMaterializer *Materializer=nullptr, const MetadataPredicate *IdentityMD=nullptr)

Convert the instruction operands from referencing the current values into those specified by VM.

DWARFExpression::Operation Op

LLVM_ABI void cloneAndAdaptNoAliasScopes(ArrayRef< MDNode * > NoAliasDeclScopes, ArrayRef< BasicBlock * > NewBlocks, LLVMContext &Context, StringRef Ext)

Clone the specified noalias decl scopes.

Definition CloneFunction.cpp:1203

LLVM_ABI void remapInstructionsInBlocks(ArrayRef< BasicBlock * > Blocks, ValueToValueMapTy &VMap)

Remaps instructions in Blocks using the mapping in VMap.

Definition CloneFunction.cpp:992

ValueMap< const Value *, WeakTrackingVH > ValueToValueMapTy

LLVM_ABI void CloneFunctionInto(Function *NewFunc, const Function *OldFunc, ValueToValueMapTy &VMap, CloneFunctionChangeType Changes, SmallVectorImpl< ReturnInst * > &Returns, const char *NameSuffix="", ClonedCodeInfo *CodeInfo=nullptr, ValueMapTypeRemapper *TypeMapper=nullptr, ValueMaterializer *Materializer=nullptr)

Clone OldFunc into NewFunc, transforming the old arguments into references to VMap values.

Definition CloneFunction.cpp:277

decltype(auto) cast(const From &Val)

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

Value * MapValue(const Value *V, ValueToValueMapTy &VM, RemapFlags Flags=RF_None, ValueMapTypeRemapper *TypeMapper=nullptr, ValueMaterializer *Materializer=nullptr, const MetadataPredicate *IdentityMD=nullptr)

Look up or compute a value in the value map.

auto predecessors(const MachineBasicBlock *BB)

auto seq(T Begin, T End)

Iterate over an integral type from Begin up to - but not including - End.

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

Delete the specified blocks from BB.

LLVM_ABI void identifyNoAliasScopesToClone(ArrayRef< BasicBlock * > BBs, SmallVectorImpl< MDNode * > &NoAliasDeclScopes)

Find the 'llvm.experimental.noalias.scope.decl' intrinsics in the specified basic blocks and extract ...

Definition CloneFunction.cpp:1240

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

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

LLVM_ABI void CloneAndPruneIntoFromInst(Function *NewFunc, const Function *OldFunc, const Instruction *StartingInst, ValueToValueMapTy &VMap, bool ModuleLevelChanges, SmallVectorImpl< ReturnInst * > &Returns, const char *NameSuffix="", ClonedCodeInfo *CodeInfo=nullptr)

This works like CloneAndPruneFunctionInto, except that it does not clone the entire function.

Definition CloneFunction.cpp:701

LLVM_ABI Function * CloneFunction(Function *F, ValueToValueMapTy &VMap, ClonedCodeInfo *CodeInfo=nullptr)

Return a copy of the specified function and add it to that function's module.

Definition CloneFunction.cpp:369

LLVM_ABI void mapAtomInstance(const DebugLoc &DL, ValueToValueMapTy &VMap)

Mark a cloned instruction as a new instance so that its source loc can be updated when remapped.

Definition CloneFunction.cpp:46

Metadata * MapMetadata(const Metadata *MD, ValueToValueMapTy &VM, RemapFlags Flags=RF_None, ValueMapTypeRemapper *TypeMapper=nullptr, ValueMaterializer *Materializer=nullptr, const MetadataPredicate *IdentityMD=nullptr)

Lookup or compute a mapping for a piece of metadata.

This struct can be used to capture information about code being cloned, while it is being cloned.

bool ContainsDynamicAllocas

This is set to true if the cloned code contains a 'dynamic' alloca.

bool ContainsCalls

This is set to true if the cloned code contains a normal call instruction.

bool ContainsMemProfMetadata

This is set to true if there is memprof related metadata (memprof or callsite metadata) in the cloned...

DenseMap< const Value *, const Value * > OrigVMap

Like VMap, but maps only unsimplified instructions.

std::vector< WeakTrackingVH > OperandBundleCallSites

All cloned call sites that have operand bundles attached are appended to this vector.

enum llvm::Intrinsic::IITDescriptor::IITDescriptorKind Kind

ArgKind getArgumentKind() const