CloneFunction.cpp Source File (original) (raw)

37#include

38#include

39using namespace llvm;

41#define DEBUG_TYPE "clone-function"

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

57 if (I.hasName())

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

63 VMap[&I] = NewInst;

65 if (isa(I) && .isDebugOrPseudoInst()) {

66 hasCalls = true;

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

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

69 }

70 if (const AllocaInst *AI = dyn_cast(&I)) {

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

72 hasDynamicAllocas = true;

73 }

74 }

75 }

77 if (CodeInfo) {

81 }

82 return NewBB;

83}

88 bool ModuleLevelChanges,

100

103 FuncGlobalRefFlags, TypeMapper,

104 Materializer));

105

108 FuncGlobalRefFlags, TypeMapper,

109 Materializer));

110 }

111

114 FuncGlobalRefFlags, TypeMapper,

115 Materializer));

116 }

117

120

121

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

123 if (Argument *NewArg = dyn_cast(VMap[&OldArg])) {

124

125 NewArgAttrs[NewArg->getArgNo()] =

127 }

128 }

129

133}

134

138 DISubprogram *SPClonedWithinModule = nullptr;

139 if (Changes < CloneFunctionChangeType::DifferentModule) {

140 SPClonedWithinModule = F.getSubprogram();

141 }

142 if (SPClonedWithinModule)

144

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

146 if (Changes != CloneFunctionChangeType::ClonedModule && M) {

147

150 }

151

152 return SPClonedWithinModule;

153}

154

159 bool ModuleLevelChanges = Changes > CloneFunctionChangeType::LocalChangesOnly;

160 if (Changes < CloneFunctionChangeType::DifferentModule &&

162

163

164

165

166

167 ModuleLevelChanges = true;

168

169 auto mapToSelfIfNew = [&MD](MDNode *N) {

170

172 };

173

174

176 if (ISP != SPClonedWithinModule)

177 mapToSelfIfNew(ISP);

178 }

179

180

182 auto *LScope = dyn_cast(S);

183 if (LScope && LScope->getSubprogram() != SPClonedWithinModule)

184 mapToSelfIfNew(S);

185 }

186

188 mapToSelfIfNew(CU);

189

191 mapToSelfIfNew(Type);

192 } else {

193 assert(!SPClonedWithinModule &&

194 "Subprogram should be in DIFinder->subprogram_count()...");

195 }

196

197 return ModuleLevelChanges;

198}

199

207 for (auto MD : MDs) {

209 TypeMapper, Materializer));

210 }

211}

212

216 const char *NameSuffix,

221 return;

222

223

224

225

226 for (const BasicBlock &BB : OldFunc) {

227

228

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

231

232

233 VMap[&BB] = CBB;

234

235

236

237

238

239

240

241 if (BB.hasAddressTaken()) {

245 }

246

247

250 }

251

252

253

255 BB = cast(VMap[&OldFunc.front()])->getIterator(),

256 BE = NewFunc.end();

257 BB != BE; ++BB)

258

259

263 RemapFlag, TypeMapper, Materializer);

264 }

265}

266

267

268

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

278

279#ifndef NDEBUG

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

282#endif

283

284 bool ModuleLevelChanges = Changes > CloneFunctionChangeType::LocalChangesOnly;

285

287 TypeMapper, Materializer);

288

289

290

292 return;

293

294

295

296

297

298

300

301

302

303 if (Changes < CloneFunctionChangeType::DifferentModule) {

304

305

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

309 } else {

310

311

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

315

316 if (Changes == CloneFunctionChangeType::DifferentModule) {

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

319 }

320 }

321

324

325 ModuleLevelChanges =

327

329

331 Materializer);

332

334 NameSuffix, CodeInfo, TypeMapper, Materializer);

335

336

337

338

339 if (Changes != CloneFunctionChangeType::DifferentModule)

340 return;

341

342

343

344

345

346

347

348

349

350

351

352 auto *NewModule = NewFunc->getParent();

354

356 for (auto *Operand : NMD->operands())

357 Visited.insert(Operand);

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

362 NMD->addOperand(MappedUnit);

363 }

364}

365

366

367

368

369

370

371

372

375 std::vector<Type *> ArgTypes;

376

377

378

379

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

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

383

384

386 FunctionType::get(F->getFunctionType()->getReturnType(), ArgTypes,

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

388

389

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

393

394

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

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

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

400 }

401

403 CloneFunctionInto(NewF, F, VMap, CloneFunctionChangeType::LocalChangesOnly,

404 Returns, "", CodeInfo);

405

406 return NewF;

407}

408

409namespace {

410

411struct PruningFunctionCloner {

415 bool ModuleLevelChanges;

416 const char *NameSuffix;

418 bool HostFuncIsStrictFP;

419

421

422public:

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

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

427 ModuleLevelChanges(moduleLevelChanges), NameSuffix(nameSuffix),

428 CodeInfo(codeInfo) {

429 HostFuncIsStrictFP =

431 }

432

433

434

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

437};

438}

439

444 if (HostFuncIsStrictFP) {

447

448

449

450

451

452

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

458 switch (Operand.Kind) {

461 Intrinsic::IITDescriptor::AK_MatchType) {

462 if (I == 0)

464 else

466 }

467 break;

469 ++I;

470 break;

471 default:

472 break;

473 }

474 }

475

476

479 CIID, TParams);

482 if (isa(OldInst))

483 --NumOperands;

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

487 }

488 if (const auto *CmpI = dyn_cast(&OldInst)) {

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

492 }

493

494

495

496

498 Args.push_back(

500 Args.push_back(

502

504 }

505 }

506 if (!NewInst)

507 NewInst = II->clone();

508 return NewInst;

509}

510

511

512

513void PruningFunctionCloner::CloneBlock(

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

517

518

519 if (BBEntry)

520 return;

521

522

527

528

529

530

531

532

533

534

535

536

541 }

542

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

544 bool hasMemProfMetadata = false;

545

546

548 auto CloneDbgRecordsToHere =

551 return;

552

553

554

555

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

557 NewInst->cloneDebugInfoFrom(&*DbgCursor, std::nullopt, false);

558 NewInst->cloneDebugInfoFrom(&*II);

559 DbgCursor = std::next(II);

560 };

561

562

563

565 ++II) {

566

567

568

569 if (auto *IntrInst = dyn_cast(II))

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

571 continue;

572

575

576 if (HostFuncIsStrictFP) {

577

578

579 if (auto *Call = dyn_cast(NewInst))

580 Call->addFnAttr(Attribute::StrictFP);

581 }

582

583

584

585

586 if (!isa(NewInst) && !isa(NewInst)) {

589

590

591

592

593

597 VMap[&*II] = V;

599 continue;

600 }

601 }

602 }

603

604 if (II->hasName())

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

606 VMap[&*II] = NewInst;

607 if (isa(II) && ->isDebugOrPseudoInst()) {

608 hasCalls = true;

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

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

611 }

612

613 CloneDbgRecordsToHere(NewInst, II);

614

615 if (CodeInfo) {

617 if (auto *CB = dyn_cast(&*II))

618 if (CB->hasOperandBundles())

620 }

621

622 if (const AllocaInst *AI = dyn_cast(II)) {

623 if (isa(AI->getArraySize()))

624 hasStaticAllocas = true;

625 else

626 hasDynamicAllocas = true;

627 }

628 }

629

630

632 bool TerminatorDone = false;

633 if (const BranchInst *BI = dyn_cast(OldTI)) {

634 if (BI->isConditional()) {

635

636 ConstantInt *Cond = dyn_cast(BI->getCondition());

637

640 Cond = dyn_cast_or_null(V);

641 }

642

643

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

647 ToClone.push_back(Dest);

648 TerminatorDone = true;

649 }

650 }

651 } else if (const SwitchInst *SI = dyn_cast(OldTI)) {

652

654 if ( Cond ) {

656 Cond = dyn_cast_or_null(V);

657 }

658 if (Cond) {

662 ToClone.push_back(Dest);

663 TerminatorDone = true;

664 }

665 }

666

667 if (!TerminatorDone) {

672

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

674

675 VMap[OldTI] = NewInst;

676

677 if (CodeInfo) {

678 CodeInfo->OrigVMap[OldTI] = NewInst;

679 if (auto *CB = dyn_cast(OldTI))

680 if (CB->hasOperandBundles())

682 }

683

684

686 } else {

687

688

691

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

693 }

694

695 if (CodeInfo) {

701 }

702}

703

704

705

706

710 bool ModuleLevelChanges,

712 const char *NameSuffix,

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

715

718

719#ifndef NDEBUG

720

721

722 if (!StartingInst)

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

725#endif

726

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

728 NameSuffix, CodeInfo);

730 if (StartingInst)

731 StartingBB = StartingInst->getParent();

732 else {

734 StartingInst = &StartingBB->front();

735 }

736

737

739 for (const auto &BB : *OldFunc) {

740 for (const auto &I : BB) {

741 if (const auto *DVI = dyn_cast(&I))

743 }

744 }

745

746

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

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

749 while (!CloneWorklist.empty()) {

751 CloneWorklist.pop_back();

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

753 }

754

755

756

757

758

759

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

763 BasicBlock *NewBB = cast_or_null(V);

764 if (!NewBB)

765 continue;

766

767

769

770

771

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

773

774

775 if (isa(VMap[&PN]))

777 else

778 break;

779 }

780

781

782

785 TypeMapper, Materializer);

786 }

787

788

789

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

791 const PHINode *OPN = PHIToResolve[phino];

794 BasicBlock *NewBB = cast(VMap[OldBB]);

795

796

797

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

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

800 ++phino) {

801 OPN = PHIToResolve[phino];

802 PHINode *PN = cast(VMap[OPN]);

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

805 if (BasicBlock *MappedBlock = cast_or_null(V)) {

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

812 } else {

814 --pred;

815 --e;

816 }

817 }

818 }

819

820

821

822

823

824

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

829

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

832 --PredCount[Pred];

833

834

837

838

839

840

842 for (; (PN = dyn_cast(I)); ++I) {

843 for (const auto &PCI : PredCount) {

845 for (unsigned NumToRemove = PCI.second; NumToRemove; --NumToRemove)

847 }

848 }

849 }

850

851

852

853

854 PN = cast(NewBB->begin());

858 while ((PN = dyn_cast(I++))) {

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

862 VMap[&*OldI] = NV;

864 ++OldI;

865 }

866 }

867 }

868

869

870

871

876

877

878

880 for (const auto &BB : *OldFunc) {

881 for (const auto &I : BB) {

882 auto *NewI = dyn_cast_or_null(VMap.lookup(&I));

883 if (!NewI)

884 continue;

885

887 NewI->replaceAllUsesWith(V);

888

890 NewI->eraseFromParent();

891 } else {

892

893

894 VMap[&I] = NewI;

895 }

896 }

897 }

898 }

899

900

902

903

904

905

906

907

908 for (const auto *DVI : DbgIntrinsics) {

910 cast_or_null(VMap.lookup(DVI)))

913 TypeMapper, Materializer);

914 }

915

916

917

918 Function::iterator Begin = cast(VMap[StartingBB])->getIterator();

922 ModuleLevelChanges ? RF_None

924 TypeMapper, Materializer);

925 }

926 }

927

928

929

930

931

932

935

936

937 {

941 while (!Worklist.empty()) {

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

945 }

946

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

950 UnreachableBlocks.push_back(&BB);

952 }

953

954

955

956

957

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

960 BranchInst *BI = dyn_cast(I->getTerminator());

962 ++I;

963 continue;

964 }

965

968 ++I;

969 continue;

970 }

971

972

973

975

976

977

979

980

982

983

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

985

986

988

989

990 }

991

992

993

994

995 for (Function::iterator I = cast(VMap[StartingBB])->getIterator(),

996 E = NewFunc->end();

997 I != E; ++I)

998 if (ReturnInst *RI = dyn_cast(I->getTerminator()))

1000}

1001

1002

1003

1004

1005

1006

1007

1008

1014 ModuleLevelChanges, Returns, NameSuffix, CodeInfo);

1015}

1016

1017

1020

1021 for (auto *BB : Blocks) {

1022 for (auto &Inst : *BB) {

1027 }

1028 }

1029}

1030

1031

1032

1033

1034

1035

1044

1046 LMap[OrigLoop] = NewLoop;

1047 if (ParentLoop)

1049 else

1051

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

1055

1056 VMap[OrigPH] = NewPH;

1057 Blocks.push_back(NewPH);

1058

1059

1060 if (ParentLoop)

1062

1063

1065

1067 Loop *&NewLoop = LMap[CurLoop];

1068 if (!NewLoop) {

1070

1071

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

1074 Loop *NewParentLoop = LMap[OrigParent];

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

1076

1078 }

1079 }

1080

1083 Loop *&NewLoop = LMap[CurLoop];

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

1085

1087 VMap[BB] = NewBB;

1088

1089

1091

1092

1093

1095

1096 Blocks.push_back(NewBB);

1097 }

1098

1100

1103 LMap[CurLoop]->moveToHeader(cast(VMap[BB]));

1104

1105

1108 cast(VMap[IDomBB]));

1109 }

1110

1111

1114 F->end());

1115

1116 return NewLoop;

1117}

1118

1119

1120

1124

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

1127

1128

1129

1131 for (; PHINode *PN = dyn_cast(BI); ++BI)

1133

1137

1138

1139

1140 DTU.applyUpdates({{DominatorTree::Delete, PredBB, BB},

1141 {DominatorTree::Insert, PredBB, NewBB},

1142 {DominatorTree::Insert, NewBB, BB}});

1143

1144

1145

1146

1147

1148 for (; StopAt != &*BI && BB->getTerminator() != &*BI; ++BI) {

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

1151 New->insertBefore(NewTerm);

1152 New->cloneDebugInfoFrom(&*BI);

1153 ValueMapping[&*BI] = New;

1154

1155

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

1157 if (Instruction *Inst = dyn_cast(New->getOperand(i))) {

1158 auto I = ValueMapping.find(Inst);

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

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

1161 }

1162

1163

1165 }

1166

1167 return NewBB;

1168}

1169

1174

1175 for (auto *ScopeList : NoAliasDeclScopes) {

1176 for (const auto &MDOperand : ScopeList->operands()) {

1179

1180 std::string Name;

1181 auto ScopeName = SNANode.getName();

1182 if (!ScopeName.empty())

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

1184 else

1185 Name = std::string(Ext);

1186

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

1190 }

1191 }

1192 }

1193}

1194

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

1199 bool NeedsReplacement = false;

1201 for (const auto &MDOp : ScopeList->operands()) {

1202 if (MDNode *MD = dyn_cast(MDOp)) {

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

1205 NeedsReplacement = true;

1206 continue;

1207 }

1209 }

1210 }

1211 if (NeedsReplacement)

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

1213 return nullptr;

1214 };

1215

1216 if (auto *Decl = dyn_cast(I))

1217 if (auto *NewScopeList = CloneScopeList(Decl->getScopeList()))

1218 Decl->setScopeList(NewScopeList);

1219

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

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

1222 if (auto *NewScopeList = CloneScopeList(CSNoAlias))

1223 I->setMetadata(MD_ID, NewScopeList);

1224 };

1225 replaceWhenNeeded(LLVMContext::MD_noalias);

1226 replaceWhenNeeded(LLVMContext::MD_alias_scope);

1227}

1228

1232 if (NoAliasDeclScopes.empty())

1233 return;

1234

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

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

1238

1240

1241 for (BasicBlock *NewBlock : NewBlocks)

1244}

1245

1249 if (NoAliasDeclScopes.empty())

1250 return;

1251

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

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

1255

1257

1261 ++ItEnd;

1264}

1265

1270 if (auto *Decl = dyn_cast(&I))

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

1272}

1273

1278 if (auto *Decl = dyn_cast(&I))

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

1280}

MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL

Expand Atomic instructions

static const Function * getParent(const Value *V)

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

DenseMap< Block *, BlockRelaxAux > Blocks

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

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

This file defines the SmallVector class.

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.

AttributeSet getFnAttrs() const

The function attributes are returned.

static AttributeList get(LLVMContext &C, ArrayRef< std::pair< unsigned, Attribute > > Attrs)

Create an AttributeList with the specified parameters in it.

AttributeSet getRetAttrs() const

The attributes for the ret value are returned.

bool hasFnAttr(Attribute::AttrKind Kind) const

Return true if the attribute exists for the function.

AttributeSet getParamAttrs(unsigned ArgNo) const

The attributes for the argument or parameter at the given index are returned.

LLVM Basic Block Representation.

iterator begin()

Instruction iterator methods.

bool hasAddressTaken() const

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

InstListType::const_iterator const_iterator

const Instruction & front() const

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

Creates a new BasicBlock.

const BasicBlock * getSinglePredecessor() const

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

const Function * getParent() const

Return the enclosing method, or null if none.

const DataLayout & getDataLayout() const

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

SymbolTableList< BasicBlock >::iterator eraseFromParent()

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

InstListType::iterator iterator

Instruction iterators...

LLVMContext & getContext() const

Get the context in which this basic block lives.

bool IsNewDbgInfoFormat

Flag recording whether or not this block stores debug-info in the form of intrinsic instructions (fal...

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

const Instruction & back() const

static 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

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

Predicate

This enumeration lists the possible predicates for CmpInst subclasses.

This is the shared class of boolean and integer constants.

This is an important base class in LLVM.

Base class for scope-like contexts.

This class represents an Operation in the Expression.

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

This is the common base class for debug info intrinsics for variables.

Utility to find all debug info in a module.

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

Process a single instruction and collect debug info anchors.

unsigned subprogram_count() const

void processSubprogram(DISubprogram *SP)

Process subprogram.

iterator_range< subprogram_iterator > subprograms() const

iterator_range< type_iterator > types() const

iterator_range< scope_iterator > scopes() const

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 > try_emplace(KeyT &&Key, Ts &&...Args)

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.

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

Is this function using intrinsics to record the position of debugging information,...

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.

void setIsNewDbgInfoFormat(bool NewVal)

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.

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

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

void addMetadata(unsigned KindID, MDNode &MD)

Add a metadata attachment.

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

Instruction * clone() const

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

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.

void insertBefore(Instruction *InsertPos)

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

InstListType::iterator eraseFromParent()

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

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

void setIncomingBlock(unsigned i, BasicBlock *BB)

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

A handle to a particular switch case.

BasicBlockT * getCaseSuccessor() const

Resolves successor for current case.

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

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

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)

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.

void setName(const Twine &Name)

Change the name of the value.

void replaceAllUsesWith(Value *V)

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

StringRef getName() const

Return a constant reference to the value's name.

Value handle that is nullable, but tries to track the Value.

const ParentTy * getParent() const

self_iterator getIterator()

constexpr char Args[]

Key for Kernel::Metadata::mArgs.

AttributeMask typeIncompatible(Type *Ty, AttributeSet AS, AttributeSafetyKind ASK=ASK_ALL)

Which attributes cannot be applied to a type.

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

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

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

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

bool hasConstrainedFPRoundingModeOperand(ID QID)

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

This is an optimization pass for GlobalISel generic memory operations.

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.

bool BuildDebugInfoMDMap(DenseMap< const Metadata *, TrackingMDRef > &MD, CloneFunctionChangeType Changes, DebugInfoFinder &DIFinder, DISubprogram *SPClonedWithinModule)

Build a map of debug info to use during Metadata cloning.

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

auto successors(const MachineBasicBlock *BB)

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.

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 pred_size(const MachineBasicBlock *BB)

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

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

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

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

Lookup or compute a mapping for a piece of metadata.

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

Clone OldFunc's body into NewFunc.

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

Clone OldFunc's metadata into NewFunc.

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

Clones a loop OrigLoop.

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

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

raw_ostream & dbgs()

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

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

Duplicate the specified list of noalias decl scopes.

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

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

Intrinsic::ID getConstrainedIntrinsicID(const Instruction &Instr)

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

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

Look up or compute a value in the value map.

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

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

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

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

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

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

ConstantFoldInstruction - Try to constant fold the specified instruction.

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

Clone the specified noalias decl scopes.

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

Remaps instructions in Blocks using the mapping in VMap.

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.

auto predecessors(const MachineBasicBlock *BB)

DISubprogram * CollectDebugInfoForCloning(const Function &F, CloneFunctionChangeType Changes, DebugInfoFinder &DIFinder)

Collect debug information such as types, compile units, and other subprograms that are reachable from...

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

Delete the specified blocks from BB.

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

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

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

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.

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

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

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

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

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.

This is a type descriptor which explains the type requirements of an intrinsic.

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

ArgKind getArgumentKind() const