LLVM 20.0.0git
CloneFunction.cpp
Go to the documentation of this file.
1//===- CloneFunction.cpp - Clone a function into another function ---------===//
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// This file implements the CloneFunctionInto interface, which is used as the
10// low-level function cloner. This is used by the CloneFunction and function
11// inliner to do the dirty work of copying the body of a function around.
12//
13//===----------------------------------------------------------------------===//
14
21#include "llvm/IR/CFG.h"
22#include "llvm/IR/Constants.h"
23#include "llvm/IR/DebugInfo.h"
25#include "llvm/IR/Function.h"
29#include "llvm/IR/LLVMContext.h"
30#include "llvm/IR/MDBuilder.h"
31#include "llvm/IR/Metadata.h"
32#include "llvm/IR/Module.h"
37#include <map>
38#include <optional>
39using namespace llvm;
40
41#define DEBUG_TYPE "clone-function"
42
43/// See comments in Cloning.h.
45 const Twine &NameSuffix, Function *F,
46 ClonedCodeInfo *CodeInfo) {
47 BasicBlock *NewBB = BasicBlock::Create(BB->getContext(), "", F);
49 if (BB->hasName())
50 NewBB->setName(BB->getName() + NameSuffix);
51
52 bool hasCalls = false, hasDynamicAllocas = false, hasMemProfMetadata = false;
53
54 // Loop over all instructions, and copy them over.
55 for (const Instruction &I : *BB) {
56 Instruction *NewInst = I.clone();
57 if (I.hasName())
58 NewInst->setName(I.getName() + NameSuffix);
59
60 NewInst->insertBefore(*NewBB, NewBB->end());
61 NewInst->cloneDebugInfoFrom(&I);
62
63 VMap[&I] = NewInst; // Add instruction map to value.
64
65 if (isa<CallInst>(I) && !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<AllocaInst>(&I)) {
71 if (!AI->isStaticAlloca()) {
72 hasDynamicAllocas = true;
73 }
74 }
75 }
76
77 if (CodeInfo) {
78 CodeInfo->ContainsCalls |= hasCalls;
79 CodeInfo->ContainsMemProfMetadata |= hasMemProfMetadata;
80 CodeInfo->ContainsDynamicAllocas |= hasDynamicAllocas;
81 }
82 return NewBB;
83}
84
86 const Function *OldFunc,
88 bool ModuleLevelChanges,
89 ValueMapTypeRemapper *TypeMapper,
90 ValueMaterializer *Materializer) {
91 // Copy all attributes other than those stored in Function's AttributeList
92 // which holds e.g. parameters and return value attributes.
93 AttributeList NewAttrs = NewFunc->getAttributes();
94 NewFunc->copyAttributesFrom(OldFunc);
95 NewFunc->setAttributes(NewAttrs);
96
97 const RemapFlags FuncGlobalRefFlags =
98 ModuleLevelChanges ? RF_None : RF_NoModuleLevelChanges;
99
100 // Fix up the personality function that got copied over.
101 if (OldFunc->hasPersonalityFn())
102 NewFunc->setPersonalityFn(MapValue(OldFunc->getPersonalityFn(), VMap,
103 FuncGlobalRefFlags, TypeMapper,
104 Materializer));
105
106 if (OldFunc->hasPrefixData()) {
107 NewFunc->setPrefixData(MapValue(OldFunc->getPrefixData(), VMap,
108 FuncGlobalRefFlags, TypeMapper,
109 Materializer));
110 }
111
112 if (OldFunc->hasPrologueData()) {
113 NewFunc->setPrologueData(MapValue(OldFunc->getPrologueData(), VMap,
114 FuncGlobalRefFlags, TypeMapper,
115 Materializer));
116 }
117
118 SmallVector<AttributeSet, 4> NewArgAttrs(NewFunc->arg_size());
119 AttributeList OldAttrs = OldFunc->getAttributes();
120
121 // Clone any argument attributes that are present in the VMap.
122 for (const Argument &OldArg : OldFunc->args()) {
123 if (Argument *NewArg = dyn_cast<Argument>(VMap[&OldArg])) {
124 // Remap the parameter indices.
125 NewArgAttrs[NewArg->getArgNo()] =
126 OldAttrs.getParamAttrs(OldArg.getArgNo());
127 }
128 }
129
130 NewFunc->setAttributes(
131 AttributeList::get(NewFunc->getContext(), OldAttrs.getFnAttrs(),
132 OldAttrs.getRetAttrs(), NewArgAttrs));
133}
134
137 DebugInfoFinder &DIFinder) {
138 DISubprogram *SPClonedWithinModule = nullptr;
139 if (Changes < CloneFunctionChangeType::DifferentModule) {
140 SPClonedWithinModule = F.getSubprogram();
141 }
142 if (SPClonedWithinModule)
143 DIFinder.processSubprogram(SPClonedWithinModule);
144
145 const Module *M = F.getParent();
146 if (Changes != CloneFunctionChangeType::ClonedModule && M) {
147 // Inspect instructions to process e.g. DILexicalBlocks of inlined functions
148 for (const auto &I : instructions(F))
149 DIFinder.processInstruction(*M, I);
150 }
151
152 return SPClonedWithinModule;
153}
154
157 DebugInfoFinder &DIFinder,
158 DISubprogram *SPClonedWithinModule) {
159 MetadataSetTy MD;
160
161 if (Changes < CloneFunctionChangeType::DifferentModule &&
162 DIFinder.subprogram_count() > 0) {
163 // Avoid cloning types, compile units, and (other) subprograms.
164 for (DISubprogram *ISP : DIFinder.subprograms()) {
165 if (ISP != SPClonedWithinModule)
166 MD.insert(ISP);
167 }
168
169 // If a subprogram isn't going to be cloned skip its lexical blocks as well.
170 for (DIScope *S : DIFinder.scopes()) {
171 auto *LScope = dyn_cast<DILocalScope>(S);
172 if (LScope && LScope->getSubprogram() != SPClonedWithinModule)
173 MD.insert(S);
174 }
175
176 for (DICompileUnit *CU : DIFinder.compile_units())
177 MD.insert(CU);
178
179 for (DIType *Type : DIFinder.types())
180 MD.insert(Type);
181 } else {
182 assert(!SPClonedWithinModule &&
183 "Subprogram should be in DIFinder->subprogram_count()...");
184 }
185
186 return MD;
187}
188
190 ValueToValueMapTy &VMap,
191 RemapFlags RemapFlag,
192 ValueMapTypeRemapper *TypeMapper,
193 ValueMaterializer *Materializer,
194 const MetadataSetTy *IdentityMD) {
196 OldFunc.getAllMetadata(MDs);
197 for (auto MD : MDs) {
198 NewFunc.addMetadata(MD.first,
199 *MapMetadata(MD.second, VMap, RemapFlag, TypeMapper,
200 Materializer, IdentityMD));
201 }
202}
203
204void llvm::CloneFunctionBodyInto(Function &NewFunc, const Function &OldFunc,
205 ValueToValueMapTy &VMap, RemapFlags RemapFlag,
207 const char *NameSuffix,
208 ClonedCodeInfo *CodeInfo,
209 ValueMapTypeRemapper *TypeMapper,
210 ValueMaterializer *Materializer,
211 const MetadataSetTy *IdentityMD) {
212 if (OldFunc.isDeclaration())
213 return;
214
215 // Loop over all of the basic blocks in the function, cloning them as
216 // appropriate. Note that we save BE this way in order to handle cloning of
217 // recursive functions into themselves.
218 for (const BasicBlock &BB : OldFunc) {
219
220 // Create a new basic block and copy instructions into it!
221 BasicBlock *CBB =
222 CloneBasicBlock(&BB, VMap, NameSuffix, &NewFunc, CodeInfo);
223
224 // Add basic block mapping.
225 VMap[&BB] = CBB;
226
227 // It is only legal to clone a function if a block address within that
228 // function is never referenced outside of the function. Given that, we
229 // want to map block addresses from the old function to block addresses in
230 // the clone. (This is different from the generic ValueMapper
231 // implementation, which generates an invalid blockaddress when
232 // cloning a function.)
233 if (BB.hasAddressTaken()) {
234 Constant *OldBBAddr = BlockAddress::get(const_cast<Function *>(&OldFunc),
235 const_cast<BasicBlock *>(&BB));
236 VMap[OldBBAddr] = BlockAddress::get(&NewFunc, CBB);
237 }
238
239 // Note return instructions for the caller.
240 if (ReturnInst *RI = dyn_cast<ReturnInst>(CBB->getTerminator()))
241 Returns.push_back(RI);
242 }
243
244 // Loop over all of the instructions in the new function, fixing up operand
245 // references as we go. This uses VMap to do all the hard work.
247 BB = cast<BasicBlock>(VMap[&OldFunc.front()])->getIterator(),
248 BE = NewFunc.end();
249 BB != BE; ++BB)
250 // Loop over all instructions, fixing each one as we find it, and any
251 // attached debug-info records.
252 for (Instruction &II : *BB) {
253 RemapInstruction(&II, VMap, RemapFlag, TypeMapper, Materializer,
254 IdentityMD);
255 RemapDbgRecordRange(II.getModule(), II.getDbgRecordRange(), VMap,
256 RemapFlag, TypeMapper, Materializer, IdentityMD);
257 }
258}
259
260// Clone OldFunc into NewFunc, transforming the old arguments into references to
261// VMap values.
262void llvm::CloneFunctionInto(Function *NewFunc, const Function *OldFunc,
263 ValueToValueMapTy &VMap,
266 const char *NameSuffix, ClonedCodeInfo *CodeInfo,
267 ValueMapTypeRemapper *TypeMapper,
268 ValueMaterializer *Materializer) {
269 NewFunc->setIsNewDbgInfoFormat(OldFunc->IsNewDbgInfoFormat);
270 assert(NameSuffix && "NameSuffix cannot be null!");
271
272#ifndef NDEBUG
273 for (const Argument &I : OldFunc->args())
274 assert(VMap.count(&I) && "No mapping from source argument specified!");
275#endif
276
277 bool ModuleLevelChanges = Changes > CloneFunctionChangeType::LocalChangesOnly;
278
279 CloneFunctionAttributesInto(NewFunc, OldFunc, VMap, ModuleLevelChanges,
280 TypeMapper, Materializer);
281
282 // Everything else beyond this point deals with function instructions,
283 // so if we are dealing with a function declaration, we're done.
284 if (OldFunc->isDeclaration())
285 return;
286
287 // When we remap instructions within the same module, we want to avoid
288 // duplicating inlined DISubprograms, so record all subprograms we find as we
289 // duplicate instructions and then freeze them in the MD map. We also record
290 // information about dbg.value and dbg.declare to avoid duplicating the
291 // types.
292 DebugInfoFinder DIFinder;
293
294 // Track the subprogram attachment that needs to be cloned to fine-tune the
295 // mapping within the same module.
296 if (Changes < CloneFunctionChangeType::DifferentModule) {
297 // Need to find subprograms, types, and compile units.
298
299 assert((NewFunc->getParent() == nullptr ||
300 NewFunc->getParent() == OldFunc->getParent()) &&
301 "Expected NewFunc to have the same parent, or no parent");
302 } else {
303 // Need to find all the compile units.
304
305 assert((NewFunc->getParent() == nullptr ||
306 NewFunc->getParent() != OldFunc->getParent()) &&
307 "Expected NewFunc to have different parents, or no parent");
308
309 if (Changes == CloneFunctionChangeType::DifferentModule) {
310 assert(NewFunc->getParent() &&
311 "Need parent of new function to maintain debug info invariants");
312 }
313 }
314
315 DISubprogram *SPClonedWithinModule =
316 CollectDebugInfoForCloning(*OldFunc, Changes, DIFinder);
317
318 MetadataSetTy IdentityMD =
319 FindDebugInfoToIdentityMap(Changes, DIFinder, SPClonedWithinModule);
320
321 // Cloning is always a Module level operation, since Metadata needs to be
322 // cloned.
323 const auto RemapFlag = RF_None;
324
325 CloneFunctionMetadataInto(*NewFunc, *OldFunc, VMap, RemapFlag, TypeMapper,
326 Materializer, &IdentityMD);
327
328 CloneFunctionBodyInto(*NewFunc, *OldFunc, VMap, RemapFlag, Returns,
329 NameSuffix, CodeInfo, TypeMapper, Materializer,
330 &IdentityMD);
331
332 // Only update !llvm.dbg.cu for DifferentModule (not CloneModule). In the
333 // same module, the compile unit will already be listed (or not). When
334 // cloning a module, CloneModule() will handle creating the named metadata.
335 if (Changes != CloneFunctionChangeType::DifferentModule)
336 return;
337
338 // Update !llvm.dbg.cu with compile units added to the new module if this
339 // function is being cloned in isolation.
340 //
341 // FIXME: This is making global / module-level changes, which doesn't seem
342 // like the right encapsulation Consider dropping the requirement to update
343 // !llvm.dbg.cu (either obsoleting the node, or restricting it to
344 // non-discardable compile units) instead of discovering compile units by
345 // visiting the metadata attached to global values, which would allow this
346 // code to be deleted. Alternatively, perhaps give responsibility for this
347 // update to CloneFunctionInto's callers.
348 auto *NewModule = NewFunc->getParent();
349 auto *NMD = NewModule->getOrInsertNamedMetadata("llvm.dbg.cu");
350 // Avoid multiple insertions of the same DICompileUnit to NMD.
352 for (auto *Operand : NMD->operands())
353 Visited.insert(Operand);
354 for (auto *Unit : DIFinder.compile_units()) {
355 MDNode *MappedUnit =
356 MapMetadata(Unit, VMap, RF_None, TypeMapper, Materializer);
357 if (Visited.insert(MappedUnit).second)
358 NMD->addOperand(MappedUnit);
359 }
360}
361
362/// Return a copy of the specified function and add it to that function's
363/// module. Also, any references specified in the VMap are changed to refer to
364/// their mapped value instead of the original one. If any of the arguments to
365/// the function are in the VMap, the arguments are deleted from the resultant
366/// function. The VMap is updated to include mappings from all of the
367/// instructions and basicblocks in the function from their old to new values.
368///
370 ClonedCodeInfo *CodeInfo) {
371 std::vector<Type *> ArgTypes;
372
373 // The user might be deleting arguments to the function by specifying them in
374 // the VMap. If so, we need to not add the arguments to the arg ty vector
375 //
376 for (const Argument &I : F->args())
377 if (VMap.count(&I) == 0) // Haven't mapped the argument to anything yet?
378 ArgTypes.push_back(I.getType());
379
380 // Create a new function type...
381 FunctionType *FTy =
382 FunctionType::get(F->getFunctionType()->getReturnType(), ArgTypes,
383 F->getFunctionType()->isVarArg());
384
385 // Create the new function...
386 Function *NewF = Function::Create(FTy, F->getLinkage(), F->getAddressSpace(),
387 F->getName(), F->getParent());
388 NewF->setIsNewDbgInfoFormat(F->IsNewDbgInfoFormat);
389
390 // Loop over the arguments, copying the names of the mapped arguments over...
391 Function::arg_iterator DestI = NewF->arg_begin();
392 for (const Argument &I : F->args())
393 if (VMap.count(&I) == 0) { // Is this argument preserved?
394 DestI->setName(I.getName()); // Copy the name over...
395 VMap[&I] = &*DestI++; // Add mapping to VMap
396 }
397
398 SmallVector<ReturnInst *, 8> Returns; // Ignore returns cloned.
399 CloneFunctionInto(NewF, F, VMap, CloneFunctionChangeType::LocalChangesOnly,
400 Returns, "", CodeInfo);
401
402 return NewF;
403}
404
405namespace {
406/// This is a private class used to implement CloneAndPruneFunctionInto.
407struct PruningFunctionCloner {
408 Function *NewFunc;
409 const Function *OldFunc;
410 ValueToValueMapTy &VMap;
411 bool ModuleLevelChanges;
412 const char *NameSuffix;
413 ClonedCodeInfo *CodeInfo;
414 bool HostFuncIsStrictFP;
415
416 Instruction *cloneInstruction(BasicBlock::const_iterator II);
417
418public:
419 PruningFunctionCloner(Function *newFunc, const Function *oldFunc,
420 ValueToValueMapTy &valueMap, bool moduleLevelChanges,
421 const char *nameSuffix, ClonedCodeInfo *codeInfo)
422 : NewFunc(newFunc), OldFunc(oldFunc), VMap(valueMap),
423 ModuleLevelChanges(moduleLevelChanges), NameSuffix(nameSuffix),
424 CodeInfo(codeInfo) {
425 HostFuncIsStrictFP =
426 newFunc->getAttributes().hasFnAttr(Attribute::StrictFP);
427 }
428
429 /// The specified block is found to be reachable, clone it and
430 /// anything that it can reach.
431 void CloneBlock(const BasicBlock *BB, BasicBlock::const_iterator StartingInst,
432 std::vector<const BasicBlock *> &ToClone);
433};
434} // namespace
435
437PruningFunctionCloner::cloneInstruction(BasicBlock::const_iterator II) {
438 const Instruction &OldInst = *II;
439 Instruction *NewInst = nullptr;
440 if (HostFuncIsStrictFP) {
442 if (CIID != Intrinsic::not_intrinsic) {
443 // Instead of cloning the instruction, a call to constrained intrinsic
444 // should be created.
445 // Assume the first arguments of constrained intrinsics are the same as
446 // the operands of original instruction.
447
448 // Determine overloaded types of the intrinsic.
451 getIntrinsicInfoTableEntries(CIID, Descriptor);
452 for (unsigned I = 0, E = Descriptor.size(); I != E; ++I) {
453 Intrinsic::IITDescriptor Operand = Descriptor[I];
454 switch (Operand.Kind) {
456 if (Operand.getArgumentKind() !=
457 Intrinsic::IITDescriptor::AK_MatchType) {
458 if (I == 0)
459 TParams.push_back(OldInst.getType());
460 else
461 TParams.push_back(OldInst.getOperand(I - 1)->getType());
462 }
463 break;
465 ++I;
466 break;
467 default:
468 break;
469 }
470 }
471
472 // Create intrinsic call.
473 LLVMContext &Ctx = NewFunc->getContext();
475 CIID, TParams);
477 unsigned NumOperands = OldInst.getNumOperands();
478 if (isa<CallInst>(OldInst))
479 --NumOperands;
480 for (unsigned I = 0; I < NumOperands; ++I) {
481 Value *Op = OldInst.getOperand(I);
482 Args.push_back(Op);
483 }
484 if (const auto *CmpI = dyn_cast<FCmpInst>(&OldInst)) {
485 FCmpInst::Predicate Pred = CmpI->getPredicate();
486 StringRef PredName = FCmpInst::getPredicateName(Pred);
487 Args.push_back(MetadataAsValue::get(Ctx, MDString::get(Ctx, PredName)));
488 }
489
490 // The last arguments of a constrained intrinsic are metadata that
491 // represent rounding mode (absents in some intrinsics) and exception
492 // behavior. The inlined function uses default settings.
494 Args.push_back(
495 MetadataAsValue::get(Ctx, MDString::get(Ctx, "round.tonearest")));
496 Args.push_back(
497 MetadataAsValue::get(Ctx, MDString::get(Ctx, "fpexcept.ignore")));
498
499 NewInst = CallInst::Create(IFn, Args, OldInst.getName() + ".strict");
500 }
501 }
502 if (!NewInst)
503 NewInst = II->clone();
504 return NewInst;
505}
506
507/// The specified block is found to be reachable, clone it and
508/// anything that it can reach.
509void PruningFunctionCloner::CloneBlock(
510 const BasicBlock *BB, BasicBlock::const_iterator StartingInst,
511 std::vector<const BasicBlock *> &ToClone) {
512 WeakTrackingVH &BBEntry = VMap[BB];
513
514 // Have we already cloned this block?
515 if (BBEntry)
516 return;
517
518 // Nope, clone it now.
519 BasicBlock *NewBB;
520 Twine NewName(BB->hasName() ? Twine(BB->getName()) + NameSuffix : "");
521 BBEntry = NewBB = BasicBlock::Create(BB->getContext(), NewName, NewFunc);
523
524 // It is only legal to clone a function if a block address within that
525 // function is never referenced outside of the function. Given that, we
526 // want to map block addresses from the old function to block addresses in
527 // the clone. (This is different from the generic ValueMapper
528 // implementation, which generates an invalid blockaddress when
529 // cloning a function.)
530 //
531 // Note that we don't need to fix the mapping for unreachable blocks;
532 // the default mapping there is safe.
533 if (BB->hasAddressTaken()) {
534 Constant *OldBBAddr = BlockAddress::get(const_cast<Function *>(OldFunc),
535 const_cast<BasicBlock *>(BB));
536 VMap[OldBBAddr] = BlockAddress::get(NewFunc, NewBB);
537 }
538
539 bool hasCalls = false, hasDynamicAllocas = false, hasStaticAllocas = false;
540 bool hasMemProfMetadata = false;
541
542 // Keep a cursor pointing at the last place we cloned debug-info records from.
543 BasicBlock::const_iterator DbgCursor = StartingInst;
544 auto CloneDbgRecordsToHere =
545 [NewBB, &DbgCursor](Instruction *NewInst, BasicBlock::const_iterator II) {
546 if (!NewBB->IsNewDbgInfoFormat)
547 return;
548
549 // Clone debug-info records onto this instruction. Iterate through any
550 // source-instructions we've cloned and then subsequently optimised
551 // away, so that their debug-info doesn't go missing.
552 for (; DbgCursor != II; ++DbgCursor)
553 NewInst->cloneDebugInfoFrom(&*DbgCursor, std::nullopt, false);
554 NewInst->cloneDebugInfoFrom(&*II);
555 DbgCursor = std::next(II);
556 };
557
558 // Loop over all instructions, and copy them over, DCE'ing as we go. This
559 // loop doesn't include the terminator.
560 for (BasicBlock::const_iterator II = StartingInst, IE = --BB->end(); II != IE;
561 ++II) {
562
563 // Don't clone fake_use as it may suppress many optimizations
564 // due to inlining, especially SROA.
565 if (auto *IntrInst = dyn_cast<IntrinsicInst>(II))
566 if (IntrInst->getIntrinsicID() == Intrinsic::fake_use)
567 continue;
568
569 Instruction *NewInst = cloneInstruction(II);
570 NewInst->insertInto(NewBB, NewBB->end());
571
572 if (HostFuncIsStrictFP) {
573 // All function calls in the inlined function must get 'strictfp'
574 // attribute to prevent undesirable optimizations.
575 if (auto *Call = dyn_cast<CallInst>(NewInst))
576 Call->addFnAttr(Attribute::StrictFP);
577 }
578
579 // Eagerly remap operands to the newly cloned instruction, except for PHI
580 // nodes for which we defer processing until we update the CFG. Also defer
581 // debug intrinsic processing because they may contain use-before-defs.
582 if (!isa<PHINode>(NewInst) && !isa<DbgVariableIntrinsic>(NewInst)) {
583 RemapInstruction(NewInst, VMap,
584 ModuleLevelChanges ? RF_None : RF_NoModuleLevelChanges);
585
586 // Eagerly constant fold the newly cloned instruction. If successful, add
587 // a mapping to the new value. Non-constant operands may be incomplete at
588 // this stage, thus instruction simplification is performed after
589 // processing phi-nodes.
591 NewInst, BB->getDataLayout())) {
592 if (isInstructionTriviallyDead(NewInst)) {
593 VMap[&*II] = V;
594 NewInst->eraseFromParent();
595 continue;
596 }
597 }
598 }
599
600 if (II->hasName())
601 NewInst->setName(II->getName() + NameSuffix);
602 VMap[&*II] = NewInst; // Add instruction map to value.
603 if (isa<CallInst>(II) && !II->isDebugOrPseudoInst()) {
604 hasCalls = true;
605 hasMemProfMetadata |= II->hasMetadata(LLVMContext::MD_memprof);
606 hasMemProfMetadata |= II->hasMetadata(LLVMContext::MD_callsite);
607 }
608
609 CloneDbgRecordsToHere(NewInst, II);
610
611 if (CodeInfo) {
612 CodeInfo->OrigVMap[&*II] = NewInst;
613 if (auto *CB = dyn_cast<CallBase>(&*II))
614 if (CB->hasOperandBundles())
615 CodeInfo->OperandBundleCallSites.push_back(NewInst);
616 }
617
618 if (const AllocaInst *AI = dyn_cast<AllocaInst>(II)) {
619 if (isa<ConstantInt>(AI->getArraySize()))
620 hasStaticAllocas = true;
621 else
622 hasDynamicAllocas = true;
623 }
624 }
625
626 // Finally, clone over the terminator.
627 const Instruction *OldTI = BB->getTerminator();
628 bool TerminatorDone = false;
629 if (const BranchInst *BI = dyn_cast<BranchInst>(OldTI)) {
630 if (BI->isConditional()) {
631 // If the condition was a known constant in the callee...
632 ConstantInt *Cond = dyn_cast<ConstantInt>(BI->getCondition());
633 // Or is a known constant in the caller...
634 if (!Cond) {
635 Value *V = VMap.lookup(BI->getCondition());
636 Cond = dyn_cast_or_null<ConstantInt>(V);
637 }
638
639 // Constant fold to uncond branch!
640 if (Cond) {
641 BasicBlock *Dest = BI->getSuccessor(!Cond->getZExtValue());
642 VMap[OldTI] = BranchInst::Create(Dest, NewBB);
643 ToClone.push_back(Dest);
644 TerminatorDone = true;
645 }
646 }
647 } else if (const SwitchInst *SI = dyn_cast<SwitchInst>(OldTI)) {
648 // If switching on a value known constant in the caller.
649 ConstantInt *Cond = dyn_cast<ConstantInt>(SI->getCondition());
650 if (!Cond) { // Or known constant after constant prop in the callee...
651 Value *V = VMap.lookup(SI->getCondition());
652 Cond = dyn_cast_or_null<ConstantInt>(V);
653 }
654 if (Cond) { // Constant fold to uncond branch!
655 SwitchInst::ConstCaseHandle Case = *SI->findCaseValue(Cond);
656 BasicBlock *Dest = const_cast<BasicBlock *>(Case.getCaseSuccessor());
657 VMap[OldTI] = BranchInst::Create(Dest, NewBB);
658 ToClone.push_back(Dest);
659 TerminatorDone = true;
660 }
661 }
662
663 if (!TerminatorDone) {
664 Instruction *NewInst = OldTI->clone();
665 if (OldTI->hasName())
666 NewInst->setName(OldTI->getName() + NameSuffix);
667 NewInst->insertInto(NewBB, NewBB->end());
668
669 CloneDbgRecordsToHere(NewInst, OldTI->getIterator());
670
671 VMap[OldTI] = NewInst; // Add instruction map to value.
672
673 if (CodeInfo) {
674 CodeInfo->OrigVMap[OldTI] = NewInst;
675 if (auto *CB = dyn_cast<CallBase>(OldTI))
676 if (CB->hasOperandBundles())
677 CodeInfo->OperandBundleCallSites.push_back(NewInst);
678 }
679
680 // Recursively clone any reachable successor blocks.
681 append_range(ToClone, successors(BB->getTerminator()));
682 } else {
683 // If we didn't create a new terminator, clone DbgVariableRecords from the
684 // old terminator onto the new terminator.
685 Instruction *NewInst = NewBB->getTerminator();
686 assert(NewInst);
687
688 CloneDbgRecordsToHere(NewInst, OldTI->getIterator());
689 }
690
691 if (CodeInfo) {
692 CodeInfo->ContainsCalls |= hasCalls;
693 CodeInfo->ContainsMemProfMetadata |= hasMemProfMetadata;
694 CodeInfo->ContainsDynamicAllocas |= hasDynamicAllocas;
695 CodeInfo->ContainsDynamicAllocas |=
696 hasStaticAllocas && BB != &BB->getParent()->front();
697 }
698}
699
700/// This works like CloneAndPruneFunctionInto, except that it does not clone the
701/// entire function. Instead it starts at an instruction provided by the caller
702/// and copies (and prunes) only the code reachable from that instruction.
704 const Instruction *StartingInst,
705 ValueToValueMapTy &VMap,
706 bool ModuleLevelChanges,
708 const char *NameSuffix,
709 ClonedCodeInfo *CodeInfo) {
710 assert(NameSuffix && "NameSuffix cannot be null!");
711
712 ValueMapTypeRemapper *TypeMapper = nullptr;
713 ValueMaterializer *Materializer = nullptr;
714
715#ifndef NDEBUG
716 // If the cloning starts at the beginning of the function, verify that
717 // the function arguments are mapped.
718 if (!StartingInst)
719 for (const Argument &II : OldFunc->args())
720 assert(VMap.count(&II) && "No mapping from source argument specified!");
721#endif
722
723 PruningFunctionCloner PFC(NewFunc, OldFunc, VMap, ModuleLevelChanges,
724 NameSuffix, CodeInfo);
725 const BasicBlock *StartingBB;
726 if (StartingInst)
727 StartingBB = StartingInst->getParent();
728 else {
729 StartingBB = &OldFunc->getEntryBlock();
730 StartingInst = &StartingBB->front();
731 }
732
733 // Collect debug intrinsics for remapping later.
735 for (const auto &BB : *OldFunc) {
736 for (const auto &I : BB) {
737 if (const auto *DVI = dyn_cast<DbgVariableIntrinsic>(&I))
738 DbgIntrinsics.push_back(DVI);
739 }
740 }
741
742 // Clone the entry block, and anything recursively reachable from it.
743 std::vector<const BasicBlock *> CloneWorklist;
744 PFC.CloneBlock(StartingBB, StartingInst->getIterator(), CloneWorklist);
745 while (!CloneWorklist.empty()) {
746 const BasicBlock *BB = CloneWorklist.back();
747 CloneWorklist.pop_back();
748 PFC.CloneBlock(BB, BB->begin(), CloneWorklist);
749 }
750
751 // Loop over all of the basic blocks in the old function. If the block was
752 // reachable, we have cloned it and the old block is now in the value map:
753 // insert it into the new function in the right order. If not, ignore it.
754 //
755 // Defer PHI resolution until rest of function is resolved.
757 for (const BasicBlock &BI : *OldFunc) {
758 Value *V = VMap.lookup(&BI);
759 BasicBlock *NewBB = cast_or_null<BasicBlock>(V);
760 if (!NewBB)
761 continue; // Dead block.
762
763 // Move the new block to preserve the order in the original function.
764 NewBB->moveBefore(NewFunc->end());
765
766 // Handle PHI nodes specially, as we have to remove references to dead
767 // blocks.
768 for (const PHINode &PN : BI.phis()) {
769 // PHI nodes may have been remapped to non-PHI nodes by the caller or
770 // during the cloning process.
771 if (isa<PHINode>(VMap[&PN]))
772 PHIToResolve.push_back(&PN);
773 else
774 break;
775 }
776
777 // Finally, remap the terminator instructions, as those can't be remapped
778 // until all BBs are mapped.
779 RemapInstruction(NewBB->getTerminator(), VMap,
780 ModuleLevelChanges ? RF_None : RF_NoModuleLevelChanges,
781 TypeMapper, Materializer);
782 }
783
784 // Defer PHI resolution until rest of function is resolved, PHI resolution
785 // requires the CFG to be up-to-date.
786 for (unsigned phino = 0, e = PHIToResolve.size(); phino != e;) {
787 const PHINode *OPN = PHIToResolve[phino];
788 unsigned NumPreds = OPN->getNumIncomingValues();
789 const BasicBlock *OldBB = OPN->getParent();
790 BasicBlock *NewBB = cast<BasicBlock>(VMap[OldBB]);
791
792 // Map operands for blocks that are live and remove operands for blocks
793 // that are dead.
794 for (; phino != PHIToResolve.size() &&
795 PHIToResolve[phino]->getParent() == OldBB;
796 ++phino) {
797 OPN = PHIToResolve[phino];
798 PHINode *PN = cast<PHINode>(VMap[OPN]);
799 for (unsigned pred = 0, e = NumPreds; pred != e; ++pred) {
800 Value *V = VMap.lookup(PN->getIncomingBlock(pred));
801 if (BasicBlock *MappedBlock = cast_or_null<BasicBlock>(V)) {
802 Value *InVal =
803 MapValue(PN->getIncomingValue(pred), VMap,
804 ModuleLevelChanges ? RF_None : RF_NoModuleLevelChanges);
805 assert(InVal && "Unknown input value?");
806 PN->setIncomingValue(pred, InVal);
807 PN->setIncomingBlock(pred, MappedBlock);
808 } else {
809 PN->removeIncomingValue(pred, false);
810 --pred; // Revisit the next entry.
811 --e;
812 }
813 }
814 }
815
816 // The loop above has removed PHI entries for those blocks that are dead
817 // and has updated others. However, if a block is live (i.e. copied over)
818 // but its terminator has been changed to not go to this block, then our
819 // phi nodes will have invalid entries. Update the PHI nodes in this
820 // case.
821 PHINode *PN = cast<PHINode>(NewBB->begin());
822 NumPreds = pred_size(NewBB);
823 if (NumPreds != PN->getNumIncomingValues()) {
824 assert(NumPreds < PN->getNumIncomingValues());
825 // Count how many times each predecessor comes to this block.
826 std::map<BasicBlock *, unsigned> PredCount;
827 for (BasicBlock *Pred : predecessors(NewBB))
828 --PredCount[Pred];
829
830 // Figure out how many entries to remove from each PHI.
831 for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i)
832 ++PredCount[PN->getIncomingBlock(i)];
833
834 // At this point, the excess predecessor entries are positive in the
835 // map. Loop over all of the PHIs and remove excess predecessor
836 // entries.
837 BasicBlock::iterator I = NewBB->begin();
838 for (; (PN = dyn_cast<PHINode>(I)); ++I) {
839 for (const auto &PCI : PredCount) {
840 BasicBlock *Pred = PCI.first;
841 for (unsigned NumToRemove = PCI.second; NumToRemove; --NumToRemove)
842 PN->removeIncomingValue(Pred, false);
843 }
844 }
845 }
846
847 // If the loops above have made these phi nodes have 0 or 1 operand,
848 // replace them with poison or the input value. We must do this for
849 // correctness, because 0-operand phis are not valid.
850 PN = cast<PHINode>(NewBB->begin());
851 if (PN->getNumIncomingValues() == 0) {
852 BasicBlock::iterator I = NewBB->begin();
853 BasicBlock::const_iterator OldI = OldBB->begin();
854 while ((PN = dyn_cast<PHINode>(I++))) {
855 Value *NV = PoisonValue::get(PN->getType());
856 PN->replaceAllUsesWith(NV);
857 assert(VMap[&*OldI] == PN && "VMap mismatch");
858 VMap[&*OldI] = NV;
859 PN->eraseFromParent();
860 ++OldI;
861 }
862 }
863 }
864
865 // Drop all incompatible return attributes that cannot be applied to NewFunc
866 // during cloning, so as to allow instruction simplification to reason on the
867 // old state of the function. The original attributes are restored later.
868 AttributeList Attrs = NewFunc->getAttributes();
870 OldFunc->getReturnType(), Attrs.getRetAttrs());
871 NewFunc->removeRetAttrs(IncompatibleAttrs);
872
873 // As phi-nodes have been now remapped, allow incremental simplification of
874 // newly-cloned instructions.
875 const DataLayout &DL = NewFunc->getDataLayout();
876 for (const auto &BB : *OldFunc) {
877 for (const auto &I : BB) {
878 auto *NewI = dyn_cast_or_null<Instruction>(VMap.lookup(&I));
879 if (!NewI)
880 continue;
881
882 if (Value *V = simplifyInstruction(NewI, DL)) {
883 NewI->replaceAllUsesWith(V);
884
885 if (isInstructionTriviallyDead(NewI)) {
886 NewI->eraseFromParent();
887 } else {
888 // Did not erase it? Restore the new instruction into VMap previously
889 // dropped by `ValueIsRAUWd`.
890 VMap[&I] = NewI;
891 }
892 }
893 }
894 }
895
896 // Restore attributes.
897 NewFunc->setAttributes(Attrs);
898
899 // Remap debug intrinsic operands now that all values have been mapped.
900 // Doing this now (late) preserves use-before-defs in debug intrinsics. If
901 // we didn't do this, ValueAsMetadata(use-before-def) operands would be
902 // replaced by empty metadata. This would signal later cleanup passes to
903 // remove the debug intrinsics, potentially causing incorrect locations.
904 for (const auto *DVI : DbgIntrinsics) {
905 if (DbgVariableIntrinsic *NewDVI =
906 cast_or_null<DbgVariableIntrinsic>(VMap.lookup(DVI)))
907 RemapInstruction(NewDVI, VMap,
908 ModuleLevelChanges ? RF_None : RF_NoModuleLevelChanges,
909 TypeMapper, Materializer);
910 }
911
912 // Do the same for DbgVariableRecords, touching all the instructions in the
913 // cloned range of blocks.
914 Function::iterator Begin = cast<BasicBlock>(VMap[StartingBB])->getIterator();
915 for (BasicBlock &BB : make_range(Begin, NewFunc->end())) {
916 for (Instruction &I : BB) {
917 RemapDbgRecordRange(I.getModule(), I.getDbgRecordRange(), VMap,
918 ModuleLevelChanges ? RF_None
920 TypeMapper, Materializer);
921 }
922 }
923
924 // Simplify conditional branches and switches with a constant operand. We try
925 // to prune these out when cloning, but if the simplification required
926 // looking through PHI nodes, those are only available after forming the full
927 // basic block. That may leave some here, and we still want to prune the dead
928 // code as early as possible.
929 for (BasicBlock &BB : make_range(Begin, NewFunc->end()))
931
932 // Some blocks may have become unreachable as a result. Find and delete them.
933 {
934 SmallPtrSet<BasicBlock *, 16> ReachableBlocks;
936 Worklist.push_back(&*Begin);
937 while (!Worklist.empty()) {
938 BasicBlock *BB = Worklist.pop_back_val();
939 if (ReachableBlocks.insert(BB).second)
940 append_range(Worklist, successors(BB));
941 }
942
943 SmallVector<BasicBlock *, 16> UnreachableBlocks;
944 for (BasicBlock &BB : make_range(Begin, NewFunc->end()))
945 if (!ReachableBlocks.contains(&BB))
946 UnreachableBlocks.push_back(&BB);
947 DeleteDeadBlocks(UnreachableBlocks);
948 }
949
950 // Now that the inlined function body has been fully constructed, go through
951 // and zap unconditional fall-through branches. This happens all the time when
952 // specializing code: code specialization turns conditional branches into
953 // uncond branches, and this code folds them.
954 Function::iterator I = Begin;
955 while (I != NewFunc->end()) {
956 BranchInst *BI = dyn_cast<BranchInst>(I->getTerminator());
957 if (!BI || BI->isConditional()) {
958 ++I;
959 continue;
960 }
961
962 BasicBlock *Dest = BI->getSuccessor(0);
963 if (!Dest->getSinglePredecessor()) {
964 ++I;
965 continue;
966 }
967
968 // We shouldn't be able to get single-entry PHI nodes here, as instsimplify
969 // above should have zapped all of them..
970 assert(!isa<PHINode>(Dest->begin()));
971
972 // We know all single-entry PHI nodes in the inlined function have been
973 // removed, so we just need to splice the blocks.
974 BI->eraseFromParent();
975
976 // Make all PHI nodes that referred to Dest now refer to I as their source.
977 Dest->replaceAllUsesWith(&*I);
978
979 // Move all the instructions in the succ to the pred.
980 I->splice(I->end(), Dest);
981
982 // Remove the dest block.
983 Dest->eraseFromParent();
984
985 // Do not increment I, iteratively merge all things this block branches to.
986 }
987
988 // Make a final pass over the basic blocks from the old function to gather
989 // any return instructions which survived folding. We have to do this here
990 // because we can iteratively remove and merge returns above.
991 for (Function::iterator I = cast<BasicBlock>(VMap[StartingBB])->getIterator(),
992 E = NewFunc->end();
993 I != E; ++I)
994 if (ReturnInst *RI = dyn_cast<ReturnInst>(I->getTerminator()))
995 Returns.push_back(RI);
996}
997
998/// This works exactly like CloneFunctionInto,
999/// except that it does some simple constant prop and DCE on the fly. The
1000/// effect of this is to copy significantly less code in cases where (for
1001/// example) a function call with constant arguments is inlined, and those
1002/// constant arguments cause a significant amount of code in the callee to be
1003/// dead. Since this doesn't produce an exact copy of the input, it can't be
1004/// used for things like CloneFunction or CloneModule.
1006 Function *NewFunc, const Function *OldFunc, ValueToValueMapTy &VMap,
1007 bool ModuleLevelChanges, SmallVectorImpl<ReturnInst *> &Returns,
1008 const char *NameSuffix, ClonedCodeInfo *CodeInfo) {
1009 CloneAndPruneIntoFromInst(NewFunc, OldFunc, &OldFunc->front().front(), VMap,
1010 ModuleLevelChanges, Returns, NameSuffix, CodeInfo);
1011}
1012
1013/// Remaps instructions in \p Blocks using the mapping in \p VMap.
1015 ValueToValueMapTy &VMap) {
1016 // Rewrite the code to refer to itself.
1017 for (auto *BB : Blocks) {
1018 for (auto &Inst : *BB) {
1019 RemapDbgRecordRange(Inst.getModule(), Inst.getDbgRecordRange(), VMap,
1021 RemapInstruction(&Inst, VMap,
1023 }
1024 }
1025}
1026
1027/// Clones a loop \p OrigLoop. Returns the loop and the blocks in \p
1028/// Blocks.
1029///
1030/// Updates LoopInfo and DominatorTree assuming the loop is dominated by block
1031/// \p LoopDomBB. Insert the new blocks before block specified in \p Before.
1033 Loop *OrigLoop, ValueToValueMapTy &VMap,
1034 const Twine &NameSuffix, LoopInfo *LI,
1035 DominatorTree *DT,
1037 Function *F = OrigLoop->getHeader()->getParent();
1038 Loop *ParentLoop = OrigLoop->getParentLoop();
1040
1041 Loop *NewLoop = LI->AllocateLoop();
1042 LMap[OrigLoop] = NewLoop;
1043 if (ParentLoop)
1044 ParentLoop->addChildLoop(NewLoop);
1045 else
1046 LI->addTopLevelLoop(NewLoop);
1047
1048 BasicBlock *OrigPH = OrigLoop->getLoopPreheader();
1049 assert(OrigPH && "No preheader");
1050 BasicBlock *NewPH = CloneBasicBlock(OrigPH, VMap, NameSuffix, F);
1051 // To rename the loop PHIs.
1052 VMap[OrigPH] = NewPH;
1053 Blocks.push_back(NewPH);
1054
1055 // Update LoopInfo.
1056 if (ParentLoop)
1057 ParentLoop->addBasicBlockToLoop(NewPH, *LI);
1058
1059 // Update DominatorTree.
1060 DT->addNewBlock(NewPH, LoopDomBB);
1061
1062 for (Loop *CurLoop : OrigLoop->getLoopsInPreorder()) {
1063 Loop *&NewLoop = LMap[CurLoop];
1064 if (!NewLoop) {
1065 NewLoop = LI->AllocateLoop();
1066
1067 // Establish the parent/child relationship.
1068 Loop *OrigParent = CurLoop->getParentLoop();
1069 assert(OrigParent && "Could not find the original parent loop");
1070 Loop *NewParentLoop = LMap[OrigParent];
1071 assert(NewParentLoop && "Could not find the new parent loop");
1072
1073 NewParentLoop->addChildLoop(NewLoop);
1074 }
1075 }
1076
1077 for (BasicBlock *BB : OrigLoop->getBlocks()) {
1078 Loop *CurLoop = LI->getLoopFor(BB);
1079 Loop *&NewLoop = LMap[CurLoop];
1080 assert(NewLoop && "Expecting new loop to be allocated");
1081
1082 BasicBlock *NewBB = CloneBasicBlock(BB, VMap, NameSuffix, F);
1083 VMap[BB] = NewBB;
1084
1085 // Update LoopInfo.
1086 NewLoop->addBasicBlockToLoop(NewBB, *LI);
1087
1088 // Add DominatorTree node. After seeing all blocks, update to correct
1089 // IDom.
1090 DT->addNewBlock(NewBB, NewPH);
1091
1092 Blocks.push_back(NewBB);
1093 }
1094
1095 for (BasicBlock *BB : OrigLoop->getBlocks()) {
1096 // Update loop headers.
1097 Loop *CurLoop = LI->getLoopFor(BB);
1098 if (BB == CurLoop->getHeader())
1099 LMap[CurLoop]->moveToHeader(cast<BasicBlock>(VMap[BB]));
1100
1101 // Update DominatorTree.
1102 BasicBlock *IDomBB = DT->getNode(BB)->getIDom()->getBlock();
1103 DT->changeImmediateDominator(cast<BasicBlock>(VMap[BB]),
1104 cast<BasicBlock>(VMap[IDomBB]));
1105 }
1106
1107 // Move them physically from the end of the block list.
1108 F->splice(Before->getIterator(), F, NewPH->getIterator());
1109 F->splice(Before->getIterator(), F, NewLoop->getHeader()->getIterator(),
1110 F->end());
1111
1112 return NewLoop;
1113}
1114
1115/// Duplicate non-Phi instructions from the beginning of block up to
1116/// StopAt instruction into a split block between BB and its predecessor.
1118 BasicBlock *BB, BasicBlock *PredBB, Instruction *StopAt,
1119 ValueToValueMapTy &ValueMapping, DomTreeUpdater &DTU) {
1120
1121 assert(count(successors(PredBB), BB) == 1 &&
1122 "There must be a single edge between PredBB and BB!");
1123 // We are going to have to map operands from the original BB block to the new
1124 // copy of the block 'NewBB'. If there are PHI nodes in BB, evaluate them to
1125 // account for entry from PredBB.
1126 BasicBlock::iterator BI = BB->begin();
1127 for (; PHINode *PN = dyn_cast<PHINode>(BI); ++BI)
1128 ValueMapping[PN] = PN->getIncomingValueForBlock(PredBB);
1129
1130 BasicBlock *NewBB = SplitEdge(PredBB, BB);
1131 NewBB->setName(PredBB->getName() + ".split");
1132 Instruction *NewTerm = NewBB->getTerminator();
1133
1134 // FIXME: SplitEdge does not yet take a DTU, so we include the split edge
1135 // in the update set here.
1136 DTU.applyUpdates({{DominatorTree::Delete, PredBB, BB},
1137 {DominatorTree::Insert, PredBB, NewBB},
1138 {DominatorTree::Insert, NewBB, BB}});
1139
1140 // Clone the non-phi instructions of BB into NewBB, keeping track of the
1141 // mapping and using it to remap operands in the cloned instructions.
1142 // Stop once we see the terminator too. This covers the case where BB's
1143 // terminator gets replaced and StopAt == BB's terminator.
1144 for (; StopAt != &*BI && BB->getTerminator() != &*BI; ++BI) {
1145 Instruction *New = BI->clone();
1146 New->setName(BI->getName());
1147 New->insertBefore(NewTerm->getIterator());
1148 New->cloneDebugInfoFrom(&*BI);
1149 ValueMapping[&*BI] = New;
1150
1151 // Remap operands to patch up intra-block references.
1152 for (unsigned i = 0, e = New->getNumOperands(); i != e; ++i)
1153 if (Instruction *Inst = dyn_cast<Instruction>(New->getOperand(i))) {
1154 auto I = ValueMapping.find(Inst);
1155 if (I != ValueMapping.end())
1156 New->setOperand(i, I->second);
1157 }
1158
1159 // Remap debug variable operands.
1160 remapDebugVariable(ValueMapping, New);
1161 }
1162
1163 return NewBB;
1164}
1165
1167 DenseMap<MDNode *, MDNode *> &ClonedScopes,
1168 StringRef Ext, LLVMContext &Context) {
1169 MDBuilder MDB(Context);
1170
1171 for (auto *ScopeList : NoAliasDeclScopes) {
1172 for (const auto &MDOperand : ScopeList->operands()) {
1173 if (MDNode *MD = dyn_cast<MDNode>(MDOperand)) {
1174 AliasScopeNode SNANode(MD);
1175
1176 std::string Name;
1177 auto ScopeName = SNANode.getName();
1178 if (!ScopeName.empty())
1179 Name = (Twine(ScopeName) + ":" + Ext).str();
1180 else
1181 Name = std::string(Ext);
1182
1183 MDNode *NewScope = MDB.createAnonymousAliasScope(
1184 const_cast<MDNode *>(SNANode.getDomain()), Name);
1185 ClonedScopes.insert(std::make_pair(MD, NewScope));
1186 }
1187 }
1188 }
1189}
1190
1192 const DenseMap<MDNode *, MDNode *> &ClonedScopes,
1193 LLVMContext &Context) {
1194 auto CloneScopeList = [&](const MDNode *ScopeList) -> MDNode * {
1195 bool NeedsReplacement = false;
1196 SmallVector<Metadata *, 8> NewScopeList;
1197 for (const auto &MDOp : ScopeList->operands()) {
1198 if (MDNode *MD = dyn_cast<MDNode>(MDOp)) {
1199 if (auto *NewMD = ClonedScopes.lookup(MD)) {
1200 NewScopeList.push_back(NewMD);
1201 NeedsReplacement = true;
1202 continue;
1203 }
1204 NewScopeList.push_back(MD);
1205 }
1206 }
1207 if (NeedsReplacement)
1208 return MDNode::get(Context, NewScopeList);
1209 return nullptr;
1210 };
1211
1212 if (auto *Decl = dyn_cast<NoAliasScopeDeclInst>(I))
1213 if (auto *NewScopeList = CloneScopeList(Decl->getScopeList()))
1214 Decl->setScopeList(NewScopeList);
1215
1216 auto replaceWhenNeeded = [&](unsigned MD_ID) {
1217 if (const MDNode *CSNoAlias = I->getMetadata(MD_ID))
1218 if (auto *NewScopeList = CloneScopeList(CSNoAlias))
1219 I->setMetadata(MD_ID, NewScopeList);
1220 };
1221 replaceWhenNeeded(LLVMContext::MD_noalias);
1222 replaceWhenNeeded(LLVMContext::MD_alias_scope);
1223}
1224
1226 ArrayRef<BasicBlock *> NewBlocks,
1227 LLVMContext &Context, StringRef Ext) {
1228 if (NoAliasDeclScopes.empty())
1229 return;
1230
1231 DenseMap<MDNode *, MDNode *> ClonedScopes;
1232 LLVM_DEBUG(dbgs() << "cloneAndAdaptNoAliasScopes: cloning "
1233 << NoAliasDeclScopes.size() << " node(s)\n");
1234
1235 cloneNoAliasScopes(NoAliasDeclScopes, ClonedScopes, Ext, Context);
1236 // Identify instructions using metadata that needs adaptation
1237 for (BasicBlock *NewBlock : NewBlocks)
1238 for (Instruction &I : *NewBlock)
1239 adaptNoAliasScopes(&I, ClonedScopes, Context);
1240}
1241
1243 Instruction *IStart, Instruction *IEnd,
1244 LLVMContext &Context, StringRef Ext) {
1245 if (NoAliasDeclScopes.empty())
1246 return;
1247
1248 DenseMap<MDNode *, MDNode *> ClonedScopes;
1249 LLVM_DEBUG(dbgs() << "cloneAndAdaptNoAliasScopes: cloning "
1250 << NoAliasDeclScopes.size() << " node(s)\n");
1251
1252 cloneNoAliasScopes(NoAliasDeclScopes, ClonedScopes, Ext, Context);
1253 // Identify instructions using metadata that needs adaptation
1254 assert(IStart->getParent() == IEnd->getParent() && "different basic block ?");
1255 auto ItStart = IStart->getIterator();
1256 auto ItEnd = IEnd->getIterator();
1257 ++ItEnd; // IEnd is included, increment ItEnd to get the end of the range
1258 for (auto &I : llvm::make_range(ItStart, ItEnd))
1259 adaptNoAliasScopes(&I, ClonedScopes, Context);
1260}
1261
1263 ArrayRef<BasicBlock *> BBs, SmallVectorImpl<MDNode *> &NoAliasDeclScopes) {
1264 for (BasicBlock *BB : BBs)
1265 for (Instruction &I : *BB)
1266 if (auto *Decl = dyn_cast<NoAliasScopeDeclInst>(&I))
1267 NoAliasDeclScopes.push_back(Decl->getScopeList());
1268}
1269
1272 SmallVectorImpl<MDNode *> &NoAliasDeclScopes) {
1273 for (Instruction &I : make_range(Start, End))
1274 if (auto *Decl = dyn_cast<NoAliasScopeDeclInst>(&I))
1275 NoAliasDeclScopes.push_back(Decl->getScopeList());
1276}
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...
#define LLVM_DEBUG(...)
Definition: Debug.h:106
std::string Name
bool End
Definition: ELF_riscv.cpp:480
DenseMap< Block *, BlockRelaxAux > Blocks
Definition: ELF_riscv.cpp:507
hexagon gen pred
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.
#define F(x, y, z)
Definition: MD5.cpp:55
#define I(x, y, z)
Definition: MD5.cpp:58
This file contains the declarations for metadata subclasses.
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...
Definition: Metadata.h:1573
const MDNode * getDomain() const
Get the MDNode for this AliasScopeNode's domain.
Definition: Metadata.h:1584
StringRef getName() const
Definition: Metadata.h:1589
an instruction to allocate memory on the stack
Definition: Instructions.h:63
This class represents an incoming formal argument to a Function.
Definition: Argument.h:31
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:168
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:163
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.
Definition: BasicBlock.h:61
iterator end()
Definition: BasicBlock.h:464
iterator begin()
Instruction iterator methods.
Definition: BasicBlock.h:451
bool hasAddressTaken() const
Returns true if there are any uses of this basic block other than direct branches,...
Definition: BasicBlock.h:661
InstListType::const_iterator const_iterator
Definition: BasicBlock.h:178
const Instruction & front() const
Definition: BasicBlock.h:474
static BasicBlock * Create(LLVMContext &Context, const Twine &Name="", Function *Parent=nullptr, BasicBlock *InsertBefore=nullptr)
Creates a new BasicBlock.
Definition: BasicBlock.h:213
const BasicBlock * getSinglePredecessor() const
Return the predecessor of this block if it has a single predecessor block.
Definition: BasicBlock.cpp:471
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:220
const DataLayout & getDataLayout() const
Get the data layout of the module this basic block belongs to.
Definition: BasicBlock.cpp:296
SymbolTableList< BasicBlock >::iterator eraseFromParent()
Unlink 'this' from the containing function and delete it.
Definition: BasicBlock.cpp:279
InstListType::iterator iterator
Instruction iterators...
Definition: BasicBlock.h:177
LLVMContext & getContext() const
Get the context in which this basic block lives.
Definition: BasicBlock.cpp:168
bool IsNewDbgInfoFormat
Flag recording whether or not this block stores debug-info in the form of intrinsic instructions (fal...
Definition: BasicBlock.h:67
void moveBefore(BasicBlock *MovePos)
Unlink this basic block from its current function and insert it into the function that MovePos lives ...
Definition: BasicBlock.h:379
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...
Definition: BasicBlock.h:240
const Instruction & back() const
Definition: BasicBlock.h:476
static BlockAddress * get(Function *F, BasicBlock *BB)
Return a BlockAddress for the specified function and basic block.
Definition: Constants.cpp:1897
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.
Definition: InstrTypes.h:673
This is the shared class of boolean and integer constants.
Definition: Constants.h:83
This is an important base class in LLVM.
Definition: Constant.h:42
Base class for scope-like contexts.
Subprogram description.
Base class for types.
This class represents an Operation in the Expression.
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:63
This is the common base class for debug info intrinsics for variables.
Utility to find all debug info in a module.
Definition: DebugInfo.h:105
void processInstruction(const Module &M, const Instruction &I)
Process a single instruction and collect debug info anchors.
Definition: DebugInfo.cpp:256
unsigned subprogram_count() const
Definition: DebugInfo.h:167
void processSubprogram(DISubprogram *SP)
Process subprogram.
Definition: DebugInfo.cpp:331
iterator_range< subprogram_iterator > subprograms() const
Definition: DebugInfo.h:149
iterator_range< type_iterator > types() const
Definition: DebugInfo.h:157
iterator_range< scope_iterator > scopes() const
Definition: DebugInfo.h:161
iterator_range< compile_unit_iterator > compile_units() const
Definition: DebugInfo.h:145
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...
Definition: DenseMap.h:194
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Definition: DenseMap.h:211
DomTreeNodeBase * getIDom() const
NodeT * getBlock() 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.
Definition: Dominators.h:162
Class to represent function types.
Definition: DerivedTypes.h:105
static Function * Create(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace, const Twine &N="", Module *M=nullptr)
Definition: Function.h:173
const BasicBlock & getEntryBlock() const
Definition: Function.h:809
BasicBlockListType::iterator iterator
Definition: Function.h:68
void setPrefixData(Constant *PrefixData)
Definition: Function.cpp:1063
const DataLayout & getDataLayout() const
Get the data layout of the module this function belongs to.
Definition: Function.cpp:373
const BasicBlock & front() const
Definition: Function.h:860
iterator_range< arg_iterator > args()
Definition: Function.h:892
bool IsNewDbgInfoFormat
Is this function using intrinsics to record the position of debugging information,...
Definition: Function.h:116
bool hasPrefixData() const
Check whether this function has prefix data.
Definition: Function.h:914
bool hasPersonalityFn() const
Check whether this function has a personality function.
Definition: Function.h:905
Constant * getPrologueData() const
Get the prologue data associated with this function.
Definition: Function.cpp:1068
Constant * getPersonalityFn() const
Get the personality function associated with this function.
Definition: Function.cpp:1048
void setPersonalityFn(Constant *Fn)
Definition: Function.cpp:1053
AttributeList getAttributes() const
Return the attribute list for this Function.
Definition: Function.h:353
arg_iterator arg_begin()
Definition: Function.h:868
void setAttributes(AttributeList Attrs)
Set the attribute list for this Function.
Definition: Function.h:356
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function.
Definition: Function.cpp:369
size_t arg_size() const
Definition: Function.h:901
void setPrologueData(Constant *PrologueData)
Definition: Function.cpp:1073
void removeRetAttrs(const AttributeMask &Attrs)
removes the attributes from the return value list of attributes.
Definition: Function.cpp:709
void setIsNewDbgInfoFormat(bool NewVal)
Definition: Function.cpp:105
Type * getReturnType() const
Returns the type of the ret val.
Definition: Function.h:221
Constant * getPrefixData() const
Get the prefix data associated with this function.
Definition: Function.cpp:1058
iterator end()
Definition: Function.h:855
bool hasPrologueData() const
Check whether this function has prologue data.
Definition: Function.h:923
void copyAttributesFrom(const Function *Src)
copyAttributesFrom - copy all additional attributes (those not needed to create a Function) from the ...
Definition: Function.cpp:860
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.
Definition: Metadata.cpp:1521
void addMetadata(unsigned KindID, MDNode &MD)
Add a metadata attachment.
Definition: Metadata.cpp:1565
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Definition: Globals.cpp:296
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:657
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.
Definition: Instruction.cpp:99
InstListType::iterator eraseFromParent()
This method unlinks 'this' from the containing basic block and deletes it.
Definition: Instruction.cpp:94
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.
Definition: LLVMContext.h:67
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.
Definition: LoopInfo.h:39
MDNode * createAnonymousAliasScope(MDNode *Domain, StringRef Name=StringRef())
Return metadata appropriate for an alias scope root node.
Definition: MDBuilder.h:174
Metadata node.
Definition: Metadata.h:1073
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Definition: Metadata.h:1549
Tracking metadata reference owned by Metadata.
Definition: Metadata.h:895
static MDString * get(LLVMContext &Context, StringRef Str)
Definition: Metadata.cpp:606
static MetadataAsValue * get(LLVMContext &Context, Metadata *MD)
Definition: Metadata.cpp:103
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
NamedMDNode * getOrInsertNamedMetadata(StringRef Name)
Return the named MDNode in the module with the specified name.
Definition: Module.cpp:304
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.
Definition: Constants.cpp:1878
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.
Definition: SmallPtrSet.h:384
bool contains(ConstPtrType Ptr) const
Definition: SmallPtrSet.h:458
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
Definition: SmallPtrSet.h:519
bool empty() const
Definition: SmallVector.h:81
size_t size() const
Definition: SmallVector.h:78
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: SmallVector.h:573
void push_back(const T &Elt)
Definition: SmallVector.h:413
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1196
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:51
A handle to a particular switch case.
BasicBlockT * getCaseSuccessor() const
Resolves successor for current case.
Multiway switch.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
Value * getOperand(unsigned i) const
Definition: User.h:228
unsigned getNumOperands() const
Definition: User.h:250
This is a class that can be implemented by clients to remap types when cloning constants and instruct...
Definition: ValueMapper.h:43
ValueT lookup(const KeyT &Val) const
lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...
Definition: ValueMap.h:164
size_type count(const KeyT &Val) const
Return 1 if the specified key is in the map, 0 otherwise.
Definition: ValueMap.h:151
iterator find(const KeyT &Val)
Definition: ValueMap.h:155
iterator end()
Definition: ValueMap.h:135
This is a class that can be implemented by clients to materialize Values on demand.
Definition: ValueMapper.h:56
LLVM Value Representation.
Definition: Value.h:74
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:255
void setName(const Twine &Name)
Change the name of the value.
Definition: Value.cpp:377
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
Definition: Value.cpp:534
bool hasName() const
Definition: Value.h:261
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:309
Value handle that is nullable, but tries to track the Value.
Definition: ValueHandle.h:204
const ParentTy * getParent() const
Definition: ilist_node.h:32
self_iterator getIterator()
Definition: ilist_node.h:132
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.
Definition: Intrinsics.cpp:732
void getIntrinsicInfoTableEntries(ID id, SmallVectorImpl< IITDescriptor > &T)
Return the IIT table descriptor for the specified intrinsic into an array of IITDescriptors.
Definition: Intrinsics.cpp:447
bool hasConstrainedFPRoundingModeOperand(ID QID)
Returns true if the intrinsic ID is for one of the "Constrained Floating-Point Intrinsics" that take ...
Definition: Intrinsics.cpp:775
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
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 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...
Definition: Local.cpp:136
auto successors(const MachineBasicBlock *BB)
Metadata * MapMetadata(const Metadata *MD, ValueToValueMapTy &VM, RemapFlags Flags=RF_None, ValueMapTypeRemapper *TypeMapper=nullptr, ValueMaterializer *Materializer=nullptr, const MetadataSetTy *IdentityMD=nullptr)
Lookup or compute a mapping for a piece of metadata.
Definition: ValueMapper.h:250
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.
Definition: STLExtras.h:2115
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...
Definition: Local.cpp:3787
void RemapDbgRecordRange(Module *M, iterator_range< DbgRecordIterator > Range, ValueToValueMapTy &VM, RemapFlags Flags=RF_None, ValueMapTypeRemapper *TypeMapper=nullptr, ValueMaterializer *Materializer=nullptr, const MetadataSetTy *IdentityMD=nullptr)
Remap the Values used in the DbgRecords Range using the value map VM.
Definition: ValueMapper.h:299
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.
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.
Definition: Local.cpp:406
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.
Definition: ValueMapper.h:72
@ RF_IgnoreMissingLocals
If this flag is set, the remapper ignores missing function-local entries (Argument,...
Definition: ValueMapper.h:96
@ RF_None
Definition: ValueMapper.h:73
@ RF_NoModuleLevelChanges
If this flag is set, the remapper knows that only local values within a function (such as an instruct...
Definition: ValueMapper.h:78
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.
Definition: Debug.cpp:163
Value * MapValue(const Value *V, ValueToValueMapTy &VM, RemapFlags Flags=RF_None, ValueMapTypeRemapper *TypeMapper=nullptr, ValueMaterializer *Materializer=nullptr, const MetadataSetTy *IdentityMD=nullptr)
Look up or compute a value in the value map.
Definition: ValueMapper.h:224
void RemapInstruction(Instruction *I, ValueToValueMapTy &VM, RemapFlags Flags=RF_None, ValueMapTypeRemapper *TypeMapper=nullptr, ValueMaterializer *Materializer=nullptr, const MetadataSetTy *IdentityMD=nullptr)
Convert the instruction operands from referencing the current values into those specified by VM.
Definition: ValueMapper.h:277
void cloneNoAliasScopes(ArrayRef< MDNode * > NoAliasDeclScopes, DenseMap< MDNode *, MDNode * > &ClonedScopes, StringRef Ext, LLVMContext &Context)
Duplicate the specified list of noalias decl scopes.
Intrinsic::ID getConstrainedIntrinsicID(const Instruction &Instr)
Returns constrained intrinsic id to represent the given instruction in strictfp function.
Definition: FPEnv.cpp:90
MetadataSetTy FindDebugInfoToIdentityMap(CloneFunctionChangeType Changes, DebugInfoFinder &DIFinder, DISubprogram *SPClonedWithinModule)
Based on Changes and DIFinder return debug info that needs to be identity mapped during Metadata clon...
void CloneFunctionMetadataInto(Function &NewFunc, const Function &OldFunc, ValueToValueMapTy &VMap, RemapFlags RemapFlag, ValueMapTypeRemapper *TypeMapper=nullptr, ValueMaterializer *Materializer=nullptr, const MetadataSetTy *IdentityMD=nullptr)
Clone OldFunc's metadata into NewFunc.
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...
Definition: STLExtras.h:1938
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.
CloneFunctionChangeType
Definition: Cloning.h:138
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 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 MetadataSetTy *IdentityMD=nullptr)
Clone OldFunc's body into NewFunc.
This struct can be used to capture information about code being cloned, while it is being cloned.
Definition: Cloning.h:63
bool ContainsDynamicAllocas
This is set to true if the cloned code contains a 'dynamic' alloca.
Definition: Cloning.h:74
bool ContainsCalls
This is set to true if the cloned code contains a normal call instruction.
Definition: Cloning.h:65
bool ContainsMemProfMetadata
This is set to true if there is memprof related metadata (memprof or callsite metadata) in the cloned...
Definition: Cloning.h:69
DenseMap< const Value *, const Value * > OrigVMap
Like VMap, but maps only unsimplified instructions.
Definition: Cloning.h:84
std::vector< WeakTrackingVH > OperandBundleCallSites
All cloned call sites that have operand bundles attached are appended to this vector.
Definition: Cloning.h:79
This is a type descriptor which explains the type requirements of an intrinsic.
Definition: Intrinsics.h:131
enum llvm::Intrinsic::IITDescriptor::IITDescriptorKind Kind
ArgKind getArgumentKind() const
Definition: Intrinsics.h:186