LLVM  3.7.0
CloneFunction.cpp
Go to the documentation of this file.
1 //===- CloneFunction.cpp - Clone a function into another function ---------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the CloneFunctionInto interface, which is used as the
11 // low-level function cloner. This is used by the CloneFunction and function
12 // inliner to do the dirty work of copying the body of a function around.
13 //
14 //===----------------------------------------------------------------------===//
15 
17 #include "llvm/ADT/SmallVector.h"
20 #include "llvm/Analysis/LoopInfo.h"
21 #include "llvm/IR/CFG.h"
22 #include "llvm/IR/Constants.h"
23 #include "llvm/IR/DebugInfo.h"
24 #include "llvm/IR/DerivedTypes.h"
25 #include "llvm/IR/Function.h"
26 #include "llvm/IR/GlobalVariable.h"
27 #include "llvm/IR/Instructions.h"
28 #include "llvm/IR/IntrinsicInst.h"
29 #include "llvm/IR/LLVMContext.h"
30 #include "llvm/IR/Metadata.h"
31 #include "llvm/IR/Module.h"
35 #include <map>
36 using namespace llvm;
37 
38 /// See comments in Cloning.h.
40  ValueToValueMapTy &VMap,
41  const Twine &NameSuffix, Function *F,
42  ClonedCodeInfo *CodeInfo) {
43  BasicBlock *NewBB = BasicBlock::Create(BB->getContext(), "", F);
44  if (BB->hasName()) NewBB->setName(BB->getName()+NameSuffix);
45 
46  bool hasCalls = false, hasDynamicAllocas = false, hasStaticAllocas = false;
47 
48  // Loop over all instructions, and copy them over.
49  for (BasicBlock::const_iterator II = BB->begin(), IE = BB->end();
50  II != IE; ++II) {
51  Instruction *NewInst = II->clone();
52  if (II->hasName())
53  NewInst->setName(II->getName()+NameSuffix);
54  NewBB->getInstList().push_back(NewInst);
55  VMap[II] = NewInst; // Add instruction map to value.
56 
57  hasCalls |= (isa<CallInst>(II) && !isa<DbgInfoIntrinsic>(II));
58  if (const AllocaInst *AI = dyn_cast<AllocaInst>(II)) {
59  if (isa<ConstantInt>(AI->getArraySize()))
60  hasStaticAllocas = true;
61  else
62  hasDynamicAllocas = true;
63  }
64  }
65 
66  if (CodeInfo) {
67  CodeInfo->ContainsCalls |= hasCalls;
68  CodeInfo->ContainsDynamicAllocas |= hasDynamicAllocas;
69  CodeInfo->ContainsDynamicAllocas |= hasStaticAllocas &&
70  BB != &BB->getParent()->getEntryBlock();
71  }
72  return NewBB;
73 }
74 
75 // Clone OldFunc into NewFunc, transforming the old arguments into references to
76 // VMap values.
77 //
78 void llvm::CloneFunctionInto(Function *NewFunc, const Function *OldFunc,
79  ValueToValueMapTy &VMap,
80  bool ModuleLevelChanges,
82  const char *NameSuffix, ClonedCodeInfo *CodeInfo,
83  ValueMapTypeRemapper *TypeMapper,
84  ValueMaterializer *Materializer) {
85  assert(NameSuffix && "NameSuffix cannot be null!");
86 
87 #ifndef NDEBUG
88  for (Function::const_arg_iterator I = OldFunc->arg_begin(),
89  E = OldFunc->arg_end(); I != E; ++I)
90  assert(VMap.count(I) && "No mapping from source argument specified!");
91 #endif
92 
93  // Copy all attributes other than those stored in the AttributeSet. We need
94  // to remap the parameter indices of the AttributeSet.
95  AttributeSet NewAttrs = NewFunc->getAttributes();
96  NewFunc->copyAttributesFrom(OldFunc);
97  NewFunc->setAttributes(NewAttrs);
98 
99  AttributeSet OldAttrs = OldFunc->getAttributes();
100  // Clone any argument attributes that are present in the VMap.
101  for (const Argument &OldArg : OldFunc->args())
102  if (Argument *NewArg = dyn_cast<Argument>(VMap[&OldArg])) {
103  AttributeSet attrs =
104  OldAttrs.getParamAttributes(OldArg.getArgNo() + 1);
105  if (attrs.getNumSlots() > 0)
106  NewArg->addAttr(attrs);
107  }
108 
109  NewFunc->setAttributes(
110  NewFunc->getAttributes()
112  OldAttrs.getRetAttributes())
113  .addAttributes(NewFunc->getContext(), AttributeSet::FunctionIndex,
114  OldAttrs.getFnAttributes()));
115 
116  // Loop over all of the basic blocks in the function, cloning them as
117  // appropriate. Note that we save BE this way in order to handle cloning of
118  // recursive functions into themselves.
119  //
120  for (Function::const_iterator BI = OldFunc->begin(), BE = OldFunc->end();
121  BI != BE; ++BI) {
122  const BasicBlock &BB = *BI;
123 
124  // Create a new basic block and copy instructions into it!
125  BasicBlock *CBB = CloneBasicBlock(&BB, VMap, NameSuffix, NewFunc, CodeInfo);
126 
127  // Add basic block mapping.
128  VMap[&BB] = CBB;
129 
130  // It is only legal to clone a function if a block address within that
131  // function is never referenced outside of the function. Given that, we
132  // want to map block addresses from the old function to block addresses in
133  // the clone. (This is different from the generic ValueMapper
134  // implementation, which generates an invalid blockaddress when
135  // cloning a function.)
136  if (BB.hasAddressTaken()) {
137  Constant *OldBBAddr = BlockAddress::get(const_cast<Function*>(OldFunc),
138  const_cast<BasicBlock*>(&BB));
139  VMap[OldBBAddr] = BlockAddress::get(NewFunc, CBB);
140  }
141 
142  // Note return instructions for the caller.
143  if (ReturnInst *RI = dyn_cast<ReturnInst>(CBB->getTerminator()))
144  Returns.push_back(RI);
145  }
146 
147  // Loop over all of the instructions in the function, fixing up operand
148  // references as we go. This uses VMap to do all the hard work.
149  for (Function::iterator BB = cast<BasicBlock>(VMap[OldFunc->begin()]),
150  BE = NewFunc->end(); BB != BE; ++BB)
151  // Loop over all instructions, fixing each one as we find it...
152  for (BasicBlock::iterator II = BB->begin(); II != BB->end(); ++II)
153  RemapInstruction(II, VMap,
154  ModuleLevelChanges ? RF_None : RF_NoModuleLevelChanges,
155  TypeMapper, Materializer);
156 }
157 
158 // Find the MDNode which corresponds to the subprogram data that described F.
160  DebugInfoFinder &Finder) {
161  for (DISubprogram *Subprogram : Finder.subprograms()) {
162  if (Subprogram->describes(F))
163  return Subprogram;
164  }
165  return nullptr;
166 }
167 
168 // Add an operand to an existing MDNode. The new operand will be added at the
169 // back of the operand list.
170 static void AddOperand(DICompileUnit *CU, DISubprogramArray SPs,
171  Metadata *NewSP) {
173  NewSPs.reserve(SPs.size() + 1);
174  for (auto *SP : SPs)
175  NewSPs.push_back(SP);
176  NewSPs.push_back(NewSP);
177  CU->replaceSubprograms(MDTuple::get(CU->getContext(), NewSPs));
178 }
179 
180 // Clone the module-level debug info associated with OldFunc. The cloned data
181 // will point to NewFunc instead.
182 static void CloneDebugInfoMetadata(Function *NewFunc, const Function *OldFunc,
183  ValueToValueMapTy &VMap) {
184  DebugInfoFinder Finder;
185  Finder.processModule(*OldFunc->getParent());
186 
187  const DISubprogram *OldSubprogramMDNode = FindSubprogram(OldFunc, Finder);
188  if (!OldSubprogramMDNode) return;
189 
190  // Ensure that OldFunc appears in the map.
191  // (if it's already there it must point to NewFunc anyway)
192  VMap[OldFunc] = NewFunc;
193  auto *NewSubprogram =
194  cast<DISubprogram>(MapMetadata(OldSubprogramMDNode, VMap));
195 
196  for (auto *CU : Finder.compile_units()) {
197  auto Subprograms = CU->getSubprograms();
198  // If the compile unit's function list contains the old function, it should
199  // also contain the new one.
200  for (auto *SP : Subprograms) {
201  if (SP == OldSubprogramMDNode) {
202  AddOperand(CU, Subprograms, NewSubprogram);
203  break;
204  }
205  }
206  }
207 }
208 
209 /// Return a copy of the specified function, but without
210 /// embedding the function into another module. Also, any references specified
211 /// in the VMap are changed to refer to their mapped value instead of the
212 /// original one. If any of the arguments to the function are in the VMap,
213 /// the arguments are deleted from the resultant function. The VMap is
214 /// updated to include mappings from all of the instructions and basicblocks in
215 /// the function from their old to new values.
216 ///
218  bool ModuleLevelChanges,
219  ClonedCodeInfo *CodeInfo) {
220  std::vector<Type*> ArgTypes;
221 
222  // The user might be deleting arguments to the function by specifying them in
223  // the VMap. If so, we need to not add the arguments to the arg ty vector
224  //
225  for (Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end();
226  I != E; ++I)
227  if (VMap.count(I) == 0) // Haven't mapped the argument to anything yet?
228  ArgTypes.push_back(I->getType());
229 
230  // Create a new function type...
232  ArgTypes, F->getFunctionType()->isVarArg());
233 
234  // Create the new function...
235  Function *NewF = Function::Create(FTy, F->getLinkage(), F->getName());
236 
237  // Loop over the arguments, copying the names of the mapped arguments over...
238  Function::arg_iterator DestI = NewF->arg_begin();
239  for (Function::const_arg_iterator I = F->arg_begin(), E = F->arg_end();
240  I != E; ++I)
241  if (VMap.count(I) == 0) { // Is this argument preserved?
242  DestI->setName(I->getName()); // Copy the name over...
243  VMap[I] = DestI++; // Add mapping to VMap
244  }
245 
246  if (ModuleLevelChanges)
247  CloneDebugInfoMetadata(NewF, F, VMap);
248 
249  SmallVector<ReturnInst*, 8> Returns; // Ignore returns cloned.
250  CloneFunctionInto(NewF, F, VMap, ModuleLevelChanges, Returns, "", CodeInfo);
251  return NewF;
252 }
253 
254 
255 
256 namespace {
257  /// This is a private class used to implement CloneAndPruneFunctionInto.
258  struct PruningFunctionCloner {
259  Function *NewFunc;
260  const Function *OldFunc;
261  ValueToValueMapTy &VMap;
262  bool ModuleLevelChanges;
263  const char *NameSuffix;
264  ClonedCodeInfo *CodeInfo;
265  CloningDirector *Director;
266  ValueMapTypeRemapper *TypeMapper;
267  ValueMaterializer *Materializer;
268 
269  public:
270  PruningFunctionCloner(Function *newFunc, const Function *oldFunc,
271  ValueToValueMapTy &valueMap, bool moduleLevelChanges,
272  const char *nameSuffix, ClonedCodeInfo *codeInfo,
273  CloningDirector *Director)
274  : NewFunc(newFunc), OldFunc(oldFunc), VMap(valueMap),
275  ModuleLevelChanges(moduleLevelChanges), NameSuffix(nameSuffix),
276  CodeInfo(codeInfo), Director(Director) {
277  // These are optional components. The Director may return null.
278  if (Director) {
279  TypeMapper = Director->getTypeRemapper();
280  Materializer = Director->getValueMaterializer();
281  } else {
282  TypeMapper = nullptr;
283  Materializer = nullptr;
284  }
285  }
286 
287  /// The specified block is found to be reachable, clone it and
288  /// anything that it can reach.
289  void CloneBlock(const BasicBlock *BB,
290  BasicBlock::const_iterator StartingInst,
291  std::vector<const BasicBlock*> &ToClone);
292  };
293 }
294 
295 /// The specified block is found to be reachable, clone it and
296 /// anything that it can reach.
297 void PruningFunctionCloner::CloneBlock(const BasicBlock *BB,
298  BasicBlock::const_iterator StartingInst,
299  std::vector<const BasicBlock*> &ToClone){
300  WeakVH &BBEntry = VMap[BB];
301 
302  // Have we already cloned this block?
303  if (BBEntry) return;
304 
305  // Nope, clone it now.
306  BasicBlock *NewBB;
307  BBEntry = NewBB = BasicBlock::Create(BB->getContext());
308  if (BB->hasName()) NewBB->setName(BB->getName()+NameSuffix);
309 
310  // It is only legal to clone a function if a block address within that
311  // function is never referenced outside of the function. Given that, we
312  // want to map block addresses from the old function to block addresses in
313  // the clone. (This is different from the generic ValueMapper
314  // implementation, which generates an invalid blockaddress when
315  // cloning a function.)
316  //
317  // Note that we don't need to fix the mapping for unreachable blocks;
318  // the default mapping there is safe.
319  if (BB->hasAddressTaken()) {
320  Constant *OldBBAddr = BlockAddress::get(const_cast<Function*>(OldFunc),
321  const_cast<BasicBlock*>(BB));
322  VMap[OldBBAddr] = BlockAddress::get(NewFunc, NewBB);
323  }
324 
325  bool hasCalls = false, hasDynamicAllocas = false, hasStaticAllocas = false;
326 
327  // Loop over all instructions, and copy them over, DCE'ing as we go. This
328  // loop doesn't include the terminator.
329  for (BasicBlock::const_iterator II = StartingInst, IE = --BB->end();
330  II != IE; ++II) {
331  // If the "Director" remaps the instruction, don't clone it.
332  if (Director) {
334  = Director->handleInstruction(VMap, II, NewBB);
335  // If the cloning director says stop, we want to stop everything, not
336  // just break out of the loop (which would cause the terminator to be
337  // cloned). The cloning director is responsible for inserting a proper
338  // terminator into the new basic block in this case.
339  if (Action == CloningDirector::StopCloningBB)
340  return;
341  // If the cloning director says skip, continue to the next instruction.
342  // In this case, the cloning director is responsible for mapping the
343  // skipped instruction to some value that is defined in the new
344  // basic block.
345  if (Action == CloningDirector::SkipInstruction)
346  continue;
347  }
348 
349  Instruction *NewInst = II->clone();
350 
351  // Eagerly remap operands to the newly cloned instruction, except for PHI
352  // nodes for which we defer processing until we update the CFG.
353  if (!isa<PHINode>(NewInst)) {
354  RemapInstruction(NewInst, VMap,
355  ModuleLevelChanges ? RF_None : RF_NoModuleLevelChanges,
356  TypeMapper, Materializer);
357 
358  // If we can simplify this instruction to some other value, simply add
359  // a mapping to that value rather than inserting a new instruction into
360  // the basic block.
361  if (Value *V =
362  SimplifyInstruction(NewInst, BB->getModule()->getDataLayout())) {
363  // On the off-chance that this simplifies to an instruction in the old
364  // function, map it back into the new function.
365  if (Value *MappedV = VMap.lookup(V))
366  V = MappedV;
367 
368  VMap[II] = V;
369  delete NewInst;
370  continue;
371  }
372  }
373 
374  if (II->hasName())
375  NewInst->setName(II->getName()+NameSuffix);
376  VMap[II] = NewInst; // Add instruction map to value.
377  NewBB->getInstList().push_back(NewInst);
378  hasCalls |= (isa<CallInst>(II) && !isa<DbgInfoIntrinsic>(II));
379  if (const AllocaInst *AI = dyn_cast<AllocaInst>(II)) {
380  if (isa<ConstantInt>(AI->getArraySize()))
381  hasStaticAllocas = true;
382  else
383  hasDynamicAllocas = true;
384  }
385  }
386 
387  // Finally, clone over the terminator.
388  const TerminatorInst *OldTI = BB->getTerminator();
389  bool TerminatorDone = false;
390  if (Director) {
392  = Director->handleInstruction(VMap, OldTI, NewBB);
393  // If the cloning director says stop, we want to stop everything, not
394  // just break out of the loop (which would cause the terminator to be
395  // cloned). The cloning director is responsible for inserting a proper
396  // terminator into the new basic block in this case.
397  if (Action == CloningDirector::StopCloningBB)
398  return;
399  if (Action == CloningDirector::CloneSuccessors) {
400  // If the director says to skip with a terminate instruction, we still
401  // need to clone this block's successors.
402  const TerminatorInst *TI = NewBB->getTerminator();
403  for (unsigned i = 0, e = TI->getNumSuccessors(); i != e; ++i)
404  ToClone.push_back(TI->getSuccessor(i));
405  return;
406  }
407  assert(Action != CloningDirector::SkipInstruction &&
408  "SkipInstruction is not valid for terminators.");
409  }
410  if (const BranchInst *BI = dyn_cast<BranchInst>(OldTI)) {
411  if (BI->isConditional()) {
412  // If the condition was a known constant in the callee...
413  ConstantInt *Cond = dyn_cast<ConstantInt>(BI->getCondition());
414  // Or is a known constant in the caller...
415  if (!Cond) {
416  Value *V = VMap[BI->getCondition()];
417  Cond = dyn_cast_or_null<ConstantInt>(V);
418  }
419 
420  // Constant fold to uncond branch!
421  if (Cond) {
422  BasicBlock *Dest = BI->getSuccessor(!Cond->getZExtValue());
423  VMap[OldTI] = BranchInst::Create(Dest, NewBB);
424  ToClone.push_back(Dest);
425  TerminatorDone = true;
426  }
427  }
428  } else if (const SwitchInst *SI = dyn_cast<SwitchInst>(OldTI)) {
429  // If switching on a value known constant in the caller.
430  ConstantInt *Cond = dyn_cast<ConstantInt>(SI->getCondition());
431  if (!Cond) { // Or known constant after constant prop in the callee...
432  Value *V = VMap[SI->getCondition()];
433  Cond = dyn_cast_or_null<ConstantInt>(V);
434  }
435  if (Cond) { // Constant fold to uncond branch!
436  SwitchInst::ConstCaseIt Case = SI->findCaseValue(Cond);
437  BasicBlock *Dest = const_cast<BasicBlock*>(Case.getCaseSuccessor());
438  VMap[OldTI] = BranchInst::Create(Dest, NewBB);
439  ToClone.push_back(Dest);
440  TerminatorDone = true;
441  }
442  }
443 
444  if (!TerminatorDone) {
445  Instruction *NewInst = OldTI->clone();
446  if (OldTI->hasName())
447  NewInst->setName(OldTI->getName()+NameSuffix);
448  NewBB->getInstList().push_back(NewInst);
449  VMap[OldTI] = NewInst; // Add instruction map to value.
450 
451  // Recursively clone any reachable successor blocks.
452  const TerminatorInst *TI = BB->getTerminator();
453  for (unsigned i = 0, e = TI->getNumSuccessors(); i != e; ++i)
454  ToClone.push_back(TI->getSuccessor(i));
455  }
456 
457  if (CodeInfo) {
458  CodeInfo->ContainsCalls |= hasCalls;
459  CodeInfo->ContainsDynamicAllocas |= hasDynamicAllocas;
460  CodeInfo->ContainsDynamicAllocas |= hasStaticAllocas &&
461  BB != &BB->getParent()->front();
462  }
463 }
464 
465 /// This works like CloneAndPruneFunctionInto, except that it does not clone the
466 /// entire function. Instead it starts at an instruction provided by the caller
467 /// and copies (and prunes) only the code reachable from that instruction.
468 void llvm::CloneAndPruneIntoFromInst(Function *NewFunc, const Function *OldFunc,
469  const Instruction *StartingInst,
470  ValueToValueMapTy &VMap,
471  bool ModuleLevelChanges,
473  const char *NameSuffix,
474  ClonedCodeInfo *CodeInfo,
475  CloningDirector *Director) {
476  assert(NameSuffix && "NameSuffix cannot be null!");
477 
478  ValueMapTypeRemapper *TypeMapper = nullptr;
479  ValueMaterializer *Materializer = nullptr;
480 
481  if (Director) {
482  TypeMapper = Director->getTypeRemapper();
483  Materializer = Director->getValueMaterializer();
484  }
485 
486 #ifndef NDEBUG
487  // If the cloning starts at the begining of the function, verify that
488  // the function arguments are mapped.
489  if (!StartingInst)
490  for (Function::const_arg_iterator II = OldFunc->arg_begin(),
491  E = OldFunc->arg_end(); II != E; ++II)
492  assert(VMap.count(II) && "No mapping from source argument specified!");
493 #endif
494 
495  PruningFunctionCloner PFC(NewFunc, OldFunc, VMap, ModuleLevelChanges,
496  NameSuffix, CodeInfo, Director);
497  const BasicBlock *StartingBB;
498  if (StartingInst)
499  StartingBB = StartingInst->getParent();
500  else {
501  StartingBB = &OldFunc->getEntryBlock();
502  StartingInst = StartingBB->begin();
503  }
504 
505  // Clone the entry block, and anything recursively reachable from it.
506  std::vector<const BasicBlock*> CloneWorklist;
507  PFC.CloneBlock(StartingBB, StartingInst, CloneWorklist);
508  while (!CloneWorklist.empty()) {
509  const BasicBlock *BB = CloneWorklist.back();
510  CloneWorklist.pop_back();
511  PFC.CloneBlock(BB, BB->begin(), CloneWorklist);
512  }
513 
514  // Loop over all of the basic blocks in the old function. If the block was
515  // reachable, we have cloned it and the old block is now in the value map:
516  // insert it into the new function in the right order. If not, ignore it.
517  //
518  // Defer PHI resolution until rest of function is resolved.
519  SmallVector<const PHINode*, 16> PHIToResolve;
520  for (Function::const_iterator BI = OldFunc->begin(), BE = OldFunc->end();
521  BI != BE; ++BI) {
522  Value *V = VMap[BI];
523  BasicBlock *NewBB = cast_or_null<BasicBlock>(V);
524  if (!NewBB) continue; // Dead block.
525 
526  // Add the new block to the new function.
527  NewFunc->getBasicBlockList().push_back(NewBB);
528 
529  // Handle PHI nodes specially, as we have to remove references to dead
530  // blocks.
531  for (BasicBlock::const_iterator I = BI->begin(), E = BI->end(); I != E; ++I) {
532  // PHI nodes may have been remapped to non-PHI nodes by the caller or
533  // during the cloning process.
534  if (const PHINode *PN = dyn_cast<PHINode>(I)) {
535  if (isa<PHINode>(VMap[PN]))
536  PHIToResolve.push_back(PN);
537  else
538  break;
539  } else {
540  break;
541  }
542  }
543 
544  // Finally, remap the terminator instructions, as those can't be remapped
545  // until all BBs are mapped.
546  RemapInstruction(NewBB->getTerminator(), VMap,
547  ModuleLevelChanges ? RF_None : RF_NoModuleLevelChanges,
548  TypeMapper, Materializer);
549  }
550 
551  // Defer PHI resolution until rest of function is resolved, PHI resolution
552  // requires the CFG to be up-to-date.
553  for (unsigned phino = 0, e = PHIToResolve.size(); phino != e; ) {
554  const PHINode *OPN = PHIToResolve[phino];
555  unsigned NumPreds = OPN->getNumIncomingValues();
556  const BasicBlock *OldBB = OPN->getParent();
557  BasicBlock *NewBB = cast<BasicBlock>(VMap[OldBB]);
558 
559  // Map operands for blocks that are live and remove operands for blocks
560  // that are dead.
561  for (; phino != PHIToResolve.size() &&
562  PHIToResolve[phino]->getParent() == OldBB; ++phino) {
563  OPN = PHIToResolve[phino];
564  PHINode *PN = cast<PHINode>(VMap[OPN]);
565  for (unsigned pred = 0, e = NumPreds; pred != e; ++pred) {
566  Value *V = VMap[PN->getIncomingBlock(pred)];
567  if (BasicBlock *MappedBlock = cast_or_null<BasicBlock>(V)) {
568  Value *InVal = MapValue(PN->getIncomingValue(pred),
569  VMap,
570  ModuleLevelChanges ? RF_None : RF_NoModuleLevelChanges);
571  assert(InVal && "Unknown input value?");
572  PN->setIncomingValue(pred, InVal);
573  PN->setIncomingBlock(pred, MappedBlock);
574  } else {
575  PN->removeIncomingValue(pred, false);
576  --pred, --e; // Revisit the next entry.
577  }
578  }
579  }
580 
581  // The loop above has removed PHI entries for those blocks that are dead
582  // and has updated others. However, if a block is live (i.e. copied over)
583  // but its terminator has been changed to not go to this block, then our
584  // phi nodes will have invalid entries. Update the PHI nodes in this
585  // case.
586  PHINode *PN = cast<PHINode>(NewBB->begin());
587  NumPreds = std::distance(pred_begin(NewBB), pred_end(NewBB));
588  if (NumPreds != PN->getNumIncomingValues()) {
589  assert(NumPreds < PN->getNumIncomingValues());
590  // Count how many times each predecessor comes to this block.
591  std::map<BasicBlock*, unsigned> PredCount;
592  for (pred_iterator PI = pred_begin(NewBB), E = pred_end(NewBB);
593  PI != E; ++PI)
594  --PredCount[*PI];
595 
596  // Figure out how many entries to remove from each PHI.
597  for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i)
598  ++PredCount[PN->getIncomingBlock(i)];
599 
600  // At this point, the excess predecessor entries are positive in the
601  // map. Loop over all of the PHIs and remove excess predecessor
602  // entries.
603  BasicBlock::iterator I = NewBB->begin();
604  for (; (PN = dyn_cast<PHINode>(I)); ++I) {
605  for (std::map<BasicBlock*, unsigned>::iterator PCI =PredCount.begin(),
606  E = PredCount.end(); PCI != E; ++PCI) {
607  BasicBlock *Pred = PCI->first;
608  for (unsigned NumToRemove = PCI->second; NumToRemove; --NumToRemove)
609  PN->removeIncomingValue(Pred, false);
610  }
611  }
612  }
613 
614  // If the loops above have made these phi nodes have 0 or 1 operand,
615  // replace them with undef or the input value. We must do this for
616  // correctness, because 0-operand phis are not valid.
617  PN = cast<PHINode>(NewBB->begin());
618  if (PN->getNumIncomingValues() == 0) {
619  BasicBlock::iterator I = NewBB->begin();
620  BasicBlock::const_iterator OldI = OldBB->begin();
621  while ((PN = dyn_cast<PHINode>(I++))) {
622  Value *NV = UndefValue::get(PN->getType());
623  PN->replaceAllUsesWith(NV);
624  assert(VMap[OldI] == PN && "VMap mismatch");
625  VMap[OldI] = NV;
626  PN->eraseFromParent();
627  ++OldI;
628  }
629  }
630  }
631 
632  // Make a second pass over the PHINodes now that all of them have been
633  // remapped into the new function, simplifying the PHINode and performing any
634  // recursive simplifications exposed. This will transparently update the
635  // WeakVH in the VMap. Notably, we rely on that so that if we coalesce
636  // two PHINodes, the iteration over the old PHIs remains valid, and the
637  // mapping will just map us to the new node (which may not even be a PHI
638  // node).
639  for (unsigned Idx = 0, Size = PHIToResolve.size(); Idx != Size; ++Idx)
640  if (PHINode *PN = dyn_cast<PHINode>(VMap[PHIToResolve[Idx]]))
642 
643  // Now that the inlined function body has been fully constructed, go through
644  // and zap unconditional fall-through branches. This happens all the time when
645  // specializing code: code specialization turns conditional branches into
646  // uncond branches, and this code folds them.
647  Function::iterator Begin = cast<BasicBlock>(VMap[StartingBB]);
648  Function::iterator I = Begin;
649  while (I != NewFunc->end()) {
650  // Check if this block has become dead during inlining or other
651  // simplifications. Note that the first block will appear dead, as it has
652  // not yet been wired up properly.
653  if (I != Begin && (pred_begin(I) == pred_end(I) ||
654  I->getSinglePredecessor() == I)) {
655  BasicBlock *DeadBB = I++;
656  DeleteDeadBlock(DeadBB);
657  continue;
658  }
659 
660  // We need to simplify conditional branches and switches with a constant
661  // operand. We try to prune these out when cloning, but if the
662  // simplification required looking through PHI nodes, those are only
663  // available after forming the full basic block. That may leave some here,
664  // and we still want to prune the dead code as early as possible.
666 
667  BranchInst *BI = dyn_cast<BranchInst>(I->getTerminator());
668  if (!BI || BI->isConditional()) { ++I; continue; }
669 
670  BasicBlock *Dest = BI->getSuccessor(0);
671  if (!Dest->getSinglePredecessor()) {
672  ++I; continue;
673  }
674 
675  // We shouldn't be able to get single-entry PHI nodes here, as instsimplify
676  // above should have zapped all of them..
677  assert(!isa<PHINode>(Dest->begin()));
678 
679  // We know all single-entry PHI nodes in the inlined function have been
680  // removed, so we just need to splice the blocks.
681  BI->eraseFromParent();
682 
683  // Make all PHI nodes that referred to Dest now refer to I as their source.
684  Dest->replaceAllUsesWith(I);
685 
686  // Move all the instructions in the succ to the pred.
687  I->getInstList().splice(I->end(), Dest->getInstList());
688 
689  // Remove the dest block.
690  Dest->eraseFromParent();
691 
692  // Do not increment I, iteratively merge all things this block branches to.
693  }
694 
695  // Make a final pass over the basic blocks from the old function to gather
696  // any return instructions which survived folding. We have to do this here
697  // because we can iteratively remove and merge returns above.
698  for (Function::iterator I = cast<BasicBlock>(VMap[StartingBB]),
699  E = NewFunc->end();
700  I != E; ++I)
701  if (ReturnInst *RI = dyn_cast<ReturnInst>(I->getTerminator()))
702  Returns.push_back(RI);
703 }
704 
705 
706 /// This works exactly like CloneFunctionInto,
707 /// except that it does some simple constant prop and DCE on the fly. The
708 /// effect of this is to copy significantly less code in cases where (for
709 /// example) a function call with constant arguments is inlined, and those
710 /// constant arguments cause a significant amount of code in the callee to be
711 /// dead. Since this doesn't produce an exact copy of the input, it can't be
712 /// used for things like CloneFunction or CloneModule.
713 void llvm::CloneAndPruneFunctionInto(Function *NewFunc, const Function *OldFunc,
714  ValueToValueMapTy &VMap,
715  bool ModuleLevelChanges,
717  const char *NameSuffix,
718  ClonedCodeInfo *CodeInfo,
719  Instruction *TheCall) {
720  CloneAndPruneIntoFromInst(NewFunc, OldFunc, OldFunc->front().begin(), VMap,
721  ModuleLevelChanges, Returns, NameSuffix, CodeInfo,
722  nullptr);
723 }
724 
725 /// \brief Remaps instructions in \p Blocks using the mapping in \p VMap.
727  const SmallVectorImpl<BasicBlock *> &Blocks, ValueToValueMapTy &VMap) {
728  // Rewrite the code to refer to itself.
729  for (auto *BB : Blocks)
730  for (auto &Inst : *BB)
731  RemapInstruction(&Inst, VMap,
733 }
734 
735 /// \brief Clones a loop \p OrigLoop. Returns the loop and the blocks in \p
736 /// Blocks.
737 ///
738 /// Updates LoopInfo and DominatorTree assuming the loop is dominated by block
739 /// \p LoopDomBB. Insert the new blocks before block specified in \p Before.
741  Loop *OrigLoop, ValueToValueMapTy &VMap,
742  const Twine &NameSuffix, LoopInfo *LI,
743  DominatorTree *DT,
745  Function *F = OrigLoop->getHeader()->getParent();
746  Loop *ParentLoop = OrigLoop->getParentLoop();
747 
748  Loop *NewLoop = new Loop();
749  if (ParentLoop)
750  ParentLoop->addChildLoop(NewLoop);
751  else
752  LI->addTopLevelLoop(NewLoop);
753 
754  BasicBlock *OrigPH = OrigLoop->getLoopPreheader();
755  assert(OrigPH && "No preheader");
756  BasicBlock *NewPH = CloneBasicBlock(OrigPH, VMap, NameSuffix, F);
757  // To rename the loop PHIs.
758  VMap[OrigPH] = NewPH;
759  Blocks.push_back(NewPH);
760 
761  // Update LoopInfo.
762  if (ParentLoop)
763  ParentLoop->addBasicBlockToLoop(NewPH, *LI);
764 
765  // Update DominatorTree.
766  DT->addNewBlock(NewPH, LoopDomBB);
767 
768  for (BasicBlock *BB : OrigLoop->getBlocks()) {
769  BasicBlock *NewBB = CloneBasicBlock(BB, VMap, NameSuffix, F);
770  VMap[BB] = NewBB;
771 
772  // Update LoopInfo.
773  NewLoop->addBasicBlockToLoop(NewBB, *LI);
774 
775  // Update DominatorTree.
776  BasicBlock *IDomBB = DT->getNode(BB)->getIDom()->getBlock();
777  DT->addNewBlock(NewBB, cast<BasicBlock>(VMap[IDomBB]));
778 
779  Blocks.push_back(NewBB);
780  }
781 
782  // Move them physically from the end of the block list.
783  F->getBasicBlockList().splice(Before, F->getBasicBlockList(), NewPH);
784  F->getBasicBlockList().splice(Before, F->getBasicBlockList(),
785  NewLoop->getHeader(), F->end());
786 
787  return NewLoop;
788 }
DomTreeNodeBase< NodeT > * addNewBlock(NodeT *BB, NodeT *DomBB)
addNewBlock - Add a new node to the dominator tree information.
ReturnInst - Return a value (possibly void), from a function.
iplist< Instruction >::iterator eraseFromParent()
eraseFromParent - This method unlinks 'this' from the containing basic block and deletes it...
Definition: Instruction.cpp:70
LinkageTypes getLinkage() const
Definition: GlobalValue.h:289
void CloneAndPruneIntoFromInst(Function *NewFunc, const Function *OldFunc, const Instruction *StartingInst, ValueToValueMapTy &VMap, bool ModuleLevelChanges, SmallVectorImpl< ReturnInst * > &Returns, const char *NameSuffix="", ClonedCodeInfo *CodeInfo=nullptr, CloningDirector *Director=nullptr)
This works like CloneAndPruneFunctionInto, except that it does not clone the entire function...
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function. ...
Definition: Function.cpp:223
LLVM Argument representation.
Definition: Argument.h:35
const Instruction & back() const
Definition: BasicBlock.h:245
bool hasName() const
Definition: Value.h:228
AttributeSet getParamAttributes(unsigned Index) const
The attributes for the specified index are returned.
Definition: Attributes.cpp:930
iterator end()
Definition: Function.h:459
void DeleteDeadBlock(BasicBlock *BB)
DeleteDeadBlock - Delete the specified block, which must have no predecessors.
size_type count(const KeyT &Val) const
Return 1 if the specified key is in the map, 0 otherwise.
Definition: ValueMap.h:128
This file contains the declarations for metadata subclasses.
LoopT * getParentLoop() const
Definition: LoopInfo.h:97
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:111
arg_iterator arg_end()
Definition: Function.h:480
F(f)
static void CloneDebugInfoMetadata(Function *NewFunc, const Function *OldFunc, ValueToValueMapTy &VMap)
void reserve(size_type N)
Definition: SmallVector.h:401
const std::vector< BlockT * > & getBlocks() const
getBlocks - Get a list of the basic blocks which make up this loop.
Definition: LoopInfo.h:139
virtual ValueMaterializer * getValueMaterializer()
Definition: Cloning.h:161
BlockT * getHeader() const
Definition: LoopInfo.h:96
void processModule(const Module &M)
Process entire module and collect debug info anchors.
Definition: DebugInfo.cpp:122
void remapInstructionsInBlocks(const SmallVectorImpl< BasicBlock * > &Blocks, ValueToValueMapTy &VMap)
Remaps instructions in Blocks using the mapping in VMap.
AttributeSet getRetAttributes() const
The attributes for the ret value are returned.
Definition: Attributes.cpp:938
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:188
iterator begin()
Instruction iterator methods.
Definition: BasicBlock.h:231
void push_back(NodeTy *val)
Definition: ilist.h:554
static DISubprogram * FindSubprogram(const Function *F, DebugInfoFinder &Finder)
Value * removeIncomingValue(unsigned Idx, bool DeletePHIIfEmpty=true)
removeIncomingValue - Remove an incoming value.
void CloneAndPruneFunctionInto(Function *NewFunc, const Function *OldFunc, ValueToValueMapTy &VMap, bool ModuleLevelChanges, SmallVectorImpl< ReturnInst * > &Returns, const char *NameSuffix="", ClonedCodeInfo *CodeInfo=nullptr, Instruction *TheCall=nullptr)
CloneAndPruneFunctionInto - This works exactly like CloneFunctionInto, except that it does some simpl...
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:79
const Module * getModule() const
Return the module owning the function this basic block belongs to, or nullptr it the function does no...
Definition: BasicBlock.cpp:116
bool ConstantFoldTerminator(BasicBlock *BB, bool DeleteDeadConditions=false, const TargetLibraryInfo *TLI=nullptr)
ConstantFoldTerminator - If a terminator instruction is predicated on a constant value, convert it into an unconditional branch to the constant destination.
Definition: Local.cpp:64
void CloneFunctionInto(Function *NewFunc, const Function *OldFunc, ValueToValueMapTy &VMap, bool ModuleLevelChanges, 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...
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APInt.h:33
virtual CloningAction handleInstruction(ValueToValueMapTy &VMap, const Instruction *Inst, BasicBlock *NewBB)=0
Subclasses must override this function to customize cloning behavior.
bool hasAddressTaken() const
Returns true if there are any uses of this basic block other than direct branches, switches, etc.
Definition: BasicBlock.h:306
Utility to find all debug info in a module.
Definition: DebugInfo.h:72
void setName(const Twine &Name)
Change the name of the value.
Definition: Value.cpp:250
Instruction * clone() const
clone() - Create a copy of 'this' instruction that is identical in all ways except the following: ...
uint64_t getZExtValue() const
Return the constant as a 64-bit unsigned integer value after it has been zero extended as appropriate...
Definition: Constants.h:117
Subprogram description.
FunctionType - Class to represent function types.
Definition: DerivedTypes.h:96
void addBasicBlockToLoop(BlockT *NewBB, LoopInfoBase< BlockT, LoopT > &LI)
addBasicBlockToLoop - This method is used by other analyses to update loop information.
Definition: LoopInfoImpl.h:187
virtual ValueMapTypeRemapper * getTypeRemapper()
Definition: Cloning.h:160
Value handle that is nullable, but tries to track the Value.
Definition: ValueHandle.h:141
void addChildLoop(LoopT *NewChild)
addChildLoop - Add the specified loop to be a child of this loop.
Definition: LoopInfo.h:265
BasicBlock * getSuccessor(unsigned i) const
static FunctionType * get(Type *Result, ArrayRef< Type * > Params, bool isVarArg)
FunctionType::get - This static method is the primary way of constructing a FunctionType.
Definition: Type.cpp:361
iterator_range< compile_unit_iterator > compile_units() const
Definition: DebugInfo.h:110
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
Definition: Value.cpp:351
iterator begin()
Definition: Function.h:457
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree...
Definition: Dominators.h:67
RF_NoModuleLevelChanges - If this flag is set, the remapper knows that only local values within a fun...
Definition: ValueMapper.h:57
iterator_range< subprogram_iterator > subprograms() const
Definition: DebugInfo.h:114
RF_IgnoreMissingEntries - If this flag is set, the remapper ignores entries that are not in the value...
Definition: ValueMapper.h:62
unsigned getNumIncomingValues() const
getNumIncomingValues - Return the number of incoming edges
unsigned getNumSuccessors() const
Return the number of successors that this terminator has.
Definition: InstrTypes.h:57
A helper class used with CloneAndPruneIntoFromInst to change the default behavior while instructions ...
Definition: Cloning.h:138
unsigned getNumSlots() const
Return the number of slots used in this attribute list.
ValueMaterializer - This is a class that can be implemented by clients to materialize Values on deman...
Definition: ValueMapper.h:39
Subclasses of this class are all able to terminate a basic block.
Definition: InstrTypes.h:35
BlockT * getLoopPreheader() const
getLoopPreheader - If there is a preheader for this loop, return it.
Definition: LoopInfoImpl.h:108
static void AddOperand(DICompileUnit *CU, DISubprogramArray SPs, Metadata *NewSP)
LLVM Basic Block Representation.
Definition: BasicBlock.h:65
BasicBlock * getSuccessor(unsigned idx) const
Return the specified successor.
Definition: InstrTypes.h:62
BranchInst - Conditional or Unconditional Branch instruction.
static BlockAddress * get(Function *F, BasicBlock *BB)
get - Return a BlockAddress for the specified function and basic block.
Definition: Constants.cpp:1496
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Definition: Metadata.h:998
void replaceSubprograms(DISubprogramArray N)
This is an important base class in LLVM.
Definition: Constant.h:41
Metadata * MapMetadata(const Metadata *MD, ValueToValueMapTy &VM, RemapFlags Flags=RF_None, ValueMapTypeRemapper *TypeMapper=nullptr, ValueMaterializer *Materializer=nullptr)
This file contains the declarations for the subclasses of Constant, which represent the different fla...
Interval::pred_iterator pred_begin(Interval *I)
pred_begin/pred_end - define methods so that Intervals may be used just like BasicBlocks can with the...
Definition: Interval.h:114
BasicBlock * getIncomingBlock(unsigned i) const
getIncomingBlock - Return incoming basic block number i.
Value * MapValue(const Value *V, ValueToValueMapTy &VM, RemapFlags Flags=RF_None, ValueMapTypeRemapper *TypeMapper=nullptr, ValueMaterializer *Materializer=nullptr)
Definition: ValueMapper.cpp:28
const InstListType & getInstList() const
Return the underlying instruction list container.
Definition: BasicBlock.h:252
void copyAttributesFrom(const GlobalValue *Src) override
copyAttributesFrom - copy all additional attributes (those not needed to create a Function) from the ...
Definition: Function.cpp:416
Interval::pred_iterator pred_end(Interval *I)
Definition: Interval.h:117
static BasicBlock * Create(LLVMContext &Context, const Twine &Name="", Function *Parent=nullptr, BasicBlock *InsertBefore=nullptr)
Creates a new BasicBlock.
Definition: BasicBlock.h:103
arg_iterator arg_begin()
Definition: Function.h:472
static UndefValue * get(Type *T)
get() - Static factory methods - Return an 'undef' object of the specified type.
Definition: Constants.cpp:1473
bool recursivelySimplifyInstruction(Instruction *I, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr)
Recursively attempt to simplify an instruction.
hexagon gen pred
bool isConditional() const
const BasicBlockListType & getBasicBlockList() const
Definition: Function.h:436
DomTreeNodeBase< NodeT > * getIDom() const
This is the shared class of boolean and integer constants.
Definition: Constants.h:47
void setIncomingBlock(unsigned i, BasicBlock *BB)
Value * getIncomingValue(unsigned i) const
getIncomingValue - Return incoming value number x
iterator end()
Definition: BasicBlock.h:233
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:861
Module.h This file contains the declarations for the Module class.
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:222
BasicBlockTy * getCaseSuccessor()
Resolves successor for current case.
static BranchInst * Create(BasicBlock *IfTrue, Instruction *InsertBefore=nullptr)
const BasicBlock & getEntryBlock() const
Definition: Function.h:442
void addTopLevelLoop(LoopT *New)
addTopLevelLoop - This adds the specified loop to the collection of top-level loops.
Definition: LoopInfo.h:597
void splice(iterator where, iplist &L2)
Definition: ilist.h:570
AttributeSet getAttributes() const
Return the attribute list for this Function.
Definition: Function.h:181
BasicBlock * getSinglePredecessor()
Return the predecessor of this block if it has a single predecessor block.
Definition: BasicBlock.cpp:211
void RemapInstruction(Instruction *I, ValueToValueMapTy &VM, RemapFlags Flags=RF_None, ValueMapTypeRemapper *TypeMapper=nullptr, ValueMaterializer *Materializer=nullptr)
RemapInstruction - Convert the instruction operands from referencing the current values into those sp...
NodeT * getBlock() const
LLVM_ATTRIBUTE_UNUSED_RESULT std::enable_if< !is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:285
Skip this instruction and stop cloning the current basic block.
Definition: Cloning.h:146
Loop * cloneLoopWithPreheader(BasicBlock *Before, BasicBlock *LoopDomBB, Loop *OrigLoop, ValueToValueMapTy &VMap, const Twine &NameSuffix, LoopInfo *LI, DominatorTree *DT, SmallVectorImpl< BasicBlock * > &Blocks)
Clones a loop OrigLoop.
ValueMapTypeRemapper - This is a class that can be implemented by clients to remap types when cloning...
Definition: ValueMapper.h:27
Don't clone the terminator but clone the current block's successors.
Definition: Cloning.h:148
bool ContainsCalls
ContainsCalls - This is set to true if the cloned code contains a normal call instruction.
Definition: Cloning.h:60
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.cpp:372
iplist< BasicBlock >::iterator eraseFromParent()
Unlink 'this' from the containing function and delete it.
Definition: BasicBlock.cpp:97
#define I(x, y, z)
Definition: MD5.cpp:54
TerminatorInst * getTerminator()
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
Definition: BasicBlock.cpp:124
FunctionType * getFunctionType() const
Definition: Function.cpp:227
ClonedCodeInfo - This struct can be used to capture information about code being cloned, while it is being cloned.
Definition: Cloning.h:57
LLVMContext & getContext() const
Definition: Metadata.h:799
void setAttributes(AttributeSet attrs)
Set the attribute list for this Function.
Definition: Function.h:184
bool isVarArg() const
Definition: DerivedTypes.h:120
SwitchInst - Multiway switch.
CloningAction
This enumeration describes the way CloneAndPruneIntoFromInst should proceed after the CloningDirector...
Definition: Cloning.h:142
Type * getReturnType() const
Definition: DerivedTypes.h:121
bool ContainsDynamicAllocas
ContainsDynamicAllocas - This is set to true if the cloned code contains a 'dynamic' alloca...
Definition: Cloning.h:66
const BasicBlock & front() const
Definition: Function.h:464
LLVMContext & getContext() const
Get the context in which this basic block lives.
Definition: BasicBlock.cpp:32
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:365
LLVM Value Representation.
Definition: Value.h:69
Function * CloneFunction(const Function *F, ValueToValueMapTy &VMap, bool ModuleLevelChanges, ClonedCodeInfo *CodeInfo=nullptr)
CloneFunction - Return a copy of the specified function, but without embedding the function into anot...
static Function * Create(FunctionType *Ty, LinkageTypes Linkage, const Twine &N="", Module *M=nullptr)
Definition: Function.h:121
Value * SimplifyInstruction(Instruction *I, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr)
SimplifyInstruction - See if we can compute a simplified version of this instruction.
DomTreeNodeBase< NodeT > * getNode(NodeT *BB) const
getNode - return the (Post)DominatorTree node for the specified basic block.
void setIncomingValue(unsigned i, Value *V)
AttributeSet addAttributes(LLVMContext &C, unsigned Index, AttributeSet Attrs) const
Add attributes to the attribute set at the given index.
Definition: Attributes.cpp:773
Root of the metadata hierarchy.
Definition: Metadata.h:45
BasicBlock * CloneBasicBlock(const BasicBlock *BB, ValueToValueMapTy &VMap, const Twine &NameSuffix="", Function *F=nullptr, ClonedCodeInfo *CodeInfo=nullptr)
CloneBasicBlock - Return a copy of the specified basic block, but without embedding the block into a ...
const BasicBlock * getParent() const
Definition: Instruction.h:72
iterator_range< arg_iterator > args()
Definition: Function.h:489
AllocaInst - an instruction to allocate memory on the stack.
Definition: Instructions.h:76
AttributeSet getFnAttributes() const
The function attributes are returned.
Definition: Attributes.cpp:947