LLVM  15.0.0git
InlineFunction.cpp
Go to the documentation of this file.
1 //===- InlineFunction.cpp - Code to perform function inlining -------------===//
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 inlining of a function into a call site, resolving
10 // parameters and the return value as appropriate.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "llvm/ADT/DenseMap.h"
15 #include "llvm/ADT/None.h"
16 #include "llvm/ADT/Optional.h"
17 #include "llvm/ADT/STLExtras.h"
18 #include "llvm/ADT/SetVector.h"
19 #include "llvm/ADT/SmallPtrSet.h"
20 #include "llvm/ADT/SmallVector.h"
21 #include "llvm/ADT/StringExtras.h"
35 #include "llvm/IR/Argument.h"
36 #include "llvm/IR/BasicBlock.h"
37 #include "llvm/IR/CFG.h"
38 #include "llvm/IR/Constant.h"
39 #include "llvm/IR/Constants.h"
40 #include "llvm/IR/DataLayout.h"
41 #include "llvm/IR/DebugInfo.h"
43 #include "llvm/IR/DebugLoc.h"
44 #include "llvm/IR/DerivedTypes.h"
45 #include "llvm/IR/Dominators.h"
46 #include "llvm/IR/Function.h"
47 #include "llvm/IR/IRBuilder.h"
48 #include "llvm/IR/InlineAsm.h"
49 #include "llvm/IR/InstrTypes.h"
50 #include "llvm/IR/Instruction.h"
51 #include "llvm/IR/Instructions.h"
52 #include "llvm/IR/IntrinsicInst.h"
53 #include "llvm/IR/Intrinsics.h"
54 #include "llvm/IR/LLVMContext.h"
55 #include "llvm/IR/MDBuilder.h"
56 #include "llvm/IR/Metadata.h"
57 #include "llvm/IR/Module.h"
58 #include "llvm/IR/Type.h"
59 #include "llvm/IR/User.h"
60 #include "llvm/IR/Value.h"
61 #include "llvm/Support/Casting.h"
68 #include <algorithm>
69 #include <cassert>
70 #include <cstdint>
71 #include <iterator>
72 #include <limits>
73 #include <string>
74 #include <utility>
75 #include <vector>
76 
77 using namespace llvm;
79 
80 static cl::opt<bool>
81 EnableNoAliasConversion("enable-noalias-to-md-conversion", cl::init(true),
82  cl::Hidden,
83  cl::desc("Convert noalias attributes to metadata during inlining."));
84 
85 static cl::opt<bool>
86  UseNoAliasIntrinsic("use-noalias-intrinsic-during-inlining", cl::Hidden,
87  cl::init(true),
88  cl::desc("Use the llvm.experimental.noalias.scope.decl "
89  "intrinsic during inlining."));
90 
91 // Disabled by default, because the added alignment assumptions may increase
92 // compile-time and block optimizations. This option is not suitable for use
93 // with frontends that emit comprehensive parameter alignment annotations.
94 static cl::opt<bool>
95 PreserveAlignmentAssumptions("preserve-alignment-assumptions-during-inlining",
96  cl::init(false), cl::Hidden,
97  cl::desc("Convert align attributes to assumptions during inlining."));
98 
100  "update-return-attrs", cl::init(true), cl::Hidden,
101  cl::desc("Update return attributes on calls within inlined body"));
102 
104  "max-inst-checked-for-throw-during-inlining", cl::Hidden,
105  cl::desc("the maximum number of instructions analyzed for may throw during "
106  "attribute inference in inlined body"),
107  cl::init(4));
108 
109 namespace {
110 
111  /// A class for recording information about inlining a landing pad.
112  class LandingPadInliningInfo {
113  /// Destination of the invoke's unwind.
114  BasicBlock *OuterResumeDest;
115 
116  /// Destination for the callee's resume.
117  BasicBlock *InnerResumeDest = nullptr;
118 
119  /// LandingPadInst associated with the invoke.
120  LandingPadInst *CallerLPad = nullptr;
121 
122  /// PHI for EH values from landingpad insts.
123  PHINode *InnerEHValuesPHI = nullptr;
124 
125  SmallVector<Value*, 8> UnwindDestPHIValues;
126 
127  public:
128  LandingPadInliningInfo(InvokeInst *II)
129  : OuterResumeDest(II->getUnwindDest()) {
130  // If there are PHI nodes in the unwind destination block, we need to keep
131  // track of which values came into them from the invoke before removing
132  // the edge from this block.
133  BasicBlock *InvokeBB = II->getParent();
134  BasicBlock::iterator I = OuterResumeDest->begin();
135  for (; isa<PHINode>(I); ++I) {
136  // Save the value to use for this edge.
137  PHINode *PHI = cast<PHINode>(I);
138  UnwindDestPHIValues.push_back(PHI->getIncomingValueForBlock(InvokeBB));
139  }
140 
141  CallerLPad = cast<LandingPadInst>(I);
142  }
143 
144  /// The outer unwind destination is the target of
145  /// unwind edges introduced for calls within the inlined function.
146  BasicBlock *getOuterResumeDest() const {
147  return OuterResumeDest;
148  }
149 
150  BasicBlock *getInnerResumeDest();
151 
152  LandingPadInst *getLandingPadInst() const { return CallerLPad; }
153 
154  /// Forward the 'resume' instruction to the caller's landing pad block.
155  /// When the landing pad block has only one predecessor, this is
156  /// a simple branch. When there is more than one predecessor, we need to
157  /// split the landing pad block after the landingpad instruction and jump
158  /// to there.
159  void forwardResume(ResumeInst *RI,
160  SmallPtrSetImpl<LandingPadInst*> &InlinedLPads);
161 
162  /// Add incoming-PHI values to the unwind destination block for the given
163  /// basic block, using the values for the original invoke's source block.
164  void addIncomingPHIValuesFor(BasicBlock *BB) const {
165  addIncomingPHIValuesForInto(BB, OuterResumeDest);
166  }
167 
168  void addIncomingPHIValuesForInto(BasicBlock *src, BasicBlock *dest) const {
169  BasicBlock::iterator I = dest->begin();
170  for (unsigned i = 0, e = UnwindDestPHIValues.size(); i != e; ++i, ++I) {
171  PHINode *phi = cast<PHINode>(I);
172  phi->addIncoming(UnwindDestPHIValues[i], src);
173  }
174  }
175  };
176 
177 } // end anonymous namespace
178 
179 /// Get or create a target for the branch from ResumeInsts.
180 BasicBlock *LandingPadInliningInfo::getInnerResumeDest() {
181  if (InnerResumeDest) return InnerResumeDest;
182 
183  // Split the landing pad.
184  BasicBlock::iterator SplitPoint = ++CallerLPad->getIterator();
185  InnerResumeDest =
186  OuterResumeDest->splitBasicBlock(SplitPoint,
187  OuterResumeDest->getName() + ".body");
188 
189  // The number of incoming edges we expect to the inner landing pad.
190  const unsigned PHICapacity = 2;
191 
192  // Create corresponding new PHIs for all the PHIs in the outer landing pad.
193  Instruction *InsertPoint = &InnerResumeDest->front();
194  BasicBlock::iterator I = OuterResumeDest->begin();
195  for (unsigned i = 0, e = UnwindDestPHIValues.size(); i != e; ++i, ++I) {
196  PHINode *OuterPHI = cast<PHINode>(I);
197  PHINode *InnerPHI = PHINode::Create(OuterPHI->getType(), PHICapacity,
198  OuterPHI->getName() + ".lpad-body",
199  InsertPoint);
200  OuterPHI->replaceAllUsesWith(InnerPHI);
201  InnerPHI->addIncoming(OuterPHI, OuterResumeDest);
202  }
203 
204  // Create a PHI for the exception values.
205  InnerEHValuesPHI = PHINode::Create(CallerLPad->getType(), PHICapacity,
206  "eh.lpad-body", InsertPoint);
207  CallerLPad->replaceAllUsesWith(InnerEHValuesPHI);
208  InnerEHValuesPHI->addIncoming(CallerLPad, OuterResumeDest);
209 
210  // All done.
211  return InnerResumeDest;
212 }
213 
214 /// Forward the 'resume' instruction to the caller's landing pad block.
215 /// When the landing pad block has only one predecessor, this is a simple
216 /// branch. When there is more than one predecessor, we need to split the
217 /// landing pad block after the landingpad instruction and jump to there.
218 void LandingPadInliningInfo::forwardResume(
219  ResumeInst *RI, SmallPtrSetImpl<LandingPadInst *> &InlinedLPads) {
220  BasicBlock *Dest = getInnerResumeDest();
221  BasicBlock *Src = RI->getParent();
222 
223  BranchInst::Create(Dest, Src);
224 
225  // Update the PHIs in the destination. They were inserted in an order which
226  // makes this work.
227  addIncomingPHIValuesForInto(Src, Dest);
228 
229  InnerEHValuesPHI->addIncoming(RI->getOperand(0), Src);
230  RI->eraseFromParent();
231 }
232 
233 /// Helper for getUnwindDestToken/getUnwindDestTokenHelper.
234 static Value *getParentPad(Value *EHPad) {
235  if (auto *FPI = dyn_cast<FuncletPadInst>(EHPad))
236  return FPI->getParentPad();
237  return cast<CatchSwitchInst>(EHPad)->getParentPad();
238 }
239 
241 
242 /// Helper for getUnwindDestToken that does the descendant-ward part of
243 /// the search.
245  UnwindDestMemoTy &MemoMap) {
246  SmallVector<Instruction *, 8> Worklist(1, EHPad);
247 
248  while (!Worklist.empty()) {
249  Instruction *CurrentPad = Worklist.pop_back_val();
250  // We only put pads on the worklist that aren't in the MemoMap. When
251  // we find an unwind dest for a pad we may update its ancestors, but
252  // the queue only ever contains uncles/great-uncles/etc. of CurrentPad,
253  // so they should never get updated while queued on the worklist.
254  assert(!MemoMap.count(CurrentPad));
255  Value *UnwindDestToken = nullptr;
256  if (auto *CatchSwitch = dyn_cast<CatchSwitchInst>(CurrentPad)) {
257  if (CatchSwitch->hasUnwindDest()) {
258  UnwindDestToken = CatchSwitch->getUnwindDest()->getFirstNonPHI();
259  } else {
260  // Catchswitch doesn't have a 'nounwind' variant, and one might be
261  // annotated as "unwinds to caller" when really it's nounwind (see
262  // e.g. SimplifyCFGOpt::SimplifyUnreachable), so we can't infer the
263  // parent's unwind dest from this. We can check its catchpads'
264  // descendants, since they might include a cleanuppad with an
265  // "unwinds to caller" cleanupret, which can be trusted.
266  for (auto HI = CatchSwitch->handler_begin(),
267  HE = CatchSwitch->handler_end();
268  HI != HE && !UnwindDestToken; ++HI) {
269  BasicBlock *HandlerBlock = *HI;
270  auto *CatchPad = cast<CatchPadInst>(HandlerBlock->getFirstNonPHI());
271  for (User *Child : CatchPad->users()) {
272  // Intentionally ignore invokes here -- since the catchswitch is
273  // marked "unwind to caller", it would be a verifier error if it
274  // contained an invoke which unwinds out of it, so any invoke we'd
275  // encounter must unwind to some child of the catch.
276  if (!isa<CleanupPadInst>(Child) && !isa<CatchSwitchInst>(Child))
277  continue;
278 
279  Instruction *ChildPad = cast<Instruction>(Child);
280  auto Memo = MemoMap.find(ChildPad);
281  if (Memo == MemoMap.end()) {
282  // Haven't figured out this child pad yet; queue it.
283  Worklist.push_back(ChildPad);
284  continue;
285  }
286  // We've already checked this child, but might have found that
287  // it offers no proof either way.
288  Value *ChildUnwindDestToken = Memo->second;
289  if (!ChildUnwindDestToken)
290  continue;
291  // We already know the child's unwind dest, which can either
292  // be ConstantTokenNone to indicate unwind to caller, or can
293  // be another child of the catchpad. Only the former indicates
294  // the unwind dest of the catchswitch.
295  if (isa<ConstantTokenNone>(ChildUnwindDestToken)) {
296  UnwindDestToken = ChildUnwindDestToken;
297  break;
298  }
299  assert(getParentPad(ChildUnwindDestToken) == CatchPad);
300  }
301  }
302  }
303  } else {
304  auto *CleanupPad = cast<CleanupPadInst>(CurrentPad);
305  for (User *U : CleanupPad->users()) {
306  if (auto *CleanupRet = dyn_cast<CleanupReturnInst>(U)) {
307  if (BasicBlock *RetUnwindDest = CleanupRet->getUnwindDest())
308  UnwindDestToken = RetUnwindDest->getFirstNonPHI();
309  else
310  UnwindDestToken = ConstantTokenNone::get(CleanupPad->getContext());
311  break;
312  }
313  Value *ChildUnwindDestToken;
314  if (auto *Invoke = dyn_cast<InvokeInst>(U)) {
315  ChildUnwindDestToken = Invoke->getUnwindDest()->getFirstNonPHI();
316  } else if (isa<CleanupPadInst>(U) || isa<CatchSwitchInst>(U)) {
317  Instruction *ChildPad = cast<Instruction>(U);
318  auto Memo = MemoMap.find(ChildPad);
319  if (Memo == MemoMap.end()) {
320  // Haven't resolved this child yet; queue it and keep searching.
321  Worklist.push_back(ChildPad);
322  continue;
323  }
324  // We've checked this child, but still need to ignore it if it
325  // had no proof either way.
326  ChildUnwindDestToken = Memo->second;
327  if (!ChildUnwindDestToken)
328  continue;
329  } else {
330  // Not a relevant user of the cleanuppad
331  continue;
332  }
333  // In a well-formed program, the child/invoke must either unwind to
334  // an(other) child of the cleanup, or exit the cleanup. In the
335  // first case, continue searching.
336  if (isa<Instruction>(ChildUnwindDestToken) &&
337  getParentPad(ChildUnwindDestToken) == CleanupPad)
338  continue;
339  UnwindDestToken = ChildUnwindDestToken;
340  break;
341  }
342  }
343  // If we haven't found an unwind dest for CurrentPad, we may have queued its
344  // children, so move on to the next in the worklist.
345  if (!UnwindDestToken)
346  continue;
347 
348  // Now we know that CurrentPad unwinds to UnwindDestToken. It also exits
349  // any ancestors of CurrentPad up to but not including UnwindDestToken's
350  // parent pad. Record this in the memo map, and check to see if the
351  // original EHPad being queried is one of the ones exited.
352  Value *UnwindParent;
353  if (auto *UnwindPad = dyn_cast<Instruction>(UnwindDestToken))
354  UnwindParent = getParentPad(UnwindPad);
355  else
356  UnwindParent = nullptr;
357  bool ExitedOriginalPad = false;
358  for (Instruction *ExitedPad = CurrentPad;
359  ExitedPad && ExitedPad != UnwindParent;
360  ExitedPad = dyn_cast<Instruction>(getParentPad(ExitedPad))) {
361  // Skip over catchpads since they just follow their catchswitches.
362  if (isa<CatchPadInst>(ExitedPad))
363  continue;
364  MemoMap[ExitedPad] = UnwindDestToken;
365  ExitedOriginalPad |= (ExitedPad == EHPad);
366  }
367 
368  if (ExitedOriginalPad)
369  return UnwindDestToken;
370 
371  // Continue the search.
372  }
373 
374  // No definitive information is contained within this funclet.
375  return nullptr;
376 }
377 
378 /// Given an EH pad, find where it unwinds. If it unwinds to an EH pad,
379 /// return that pad instruction. If it unwinds to caller, return
380 /// ConstantTokenNone. If it does not have a definitive unwind destination,
381 /// return nullptr.
382 ///
383 /// This routine gets invoked for calls in funclets in inlinees when inlining
384 /// an invoke. Since many funclets don't have calls inside them, it's queried
385 /// on-demand rather than building a map of pads to unwind dests up front.
386 /// Determining a funclet's unwind dest may require recursively searching its
387 /// descendants, and also ancestors and cousins if the descendants don't provide
388 /// an answer. Since most funclets will have their unwind dest immediately
389 /// available as the unwind dest of a catchswitch or cleanupret, this routine
390 /// searches top-down from the given pad and then up. To avoid worst-case
391 /// quadratic run-time given that approach, it uses a memo map to avoid
392 /// re-processing funclet trees. The callers that rewrite the IR as they go
393 /// take advantage of this, for correctness, by checking/forcing rewritten
394 /// pads' entries to match the original callee view.
396  UnwindDestMemoTy &MemoMap) {
397  // Catchpads unwind to the same place as their catchswitch;
398  // redirct any queries on catchpads so the code below can
399  // deal with just catchswitches and cleanuppads.
400  if (auto *CPI = dyn_cast<CatchPadInst>(EHPad))
401  EHPad = CPI->getCatchSwitch();
402 
403  // Check if we've already determined the unwind dest for this pad.
404  auto Memo = MemoMap.find(EHPad);
405  if (Memo != MemoMap.end())
406  return Memo->second;
407 
408  // Search EHPad and, if necessary, its descendants.
409  Value *UnwindDestToken = getUnwindDestTokenHelper(EHPad, MemoMap);
410  assert((UnwindDestToken == nullptr) != (MemoMap.count(EHPad) != 0));
411  if (UnwindDestToken)
412  return UnwindDestToken;
413 
414  // No information is available for this EHPad from itself or any of its
415  // descendants. An unwind all the way out to a pad in the caller would
416  // need also to agree with the unwind dest of the parent funclet, so
417  // search up the chain to try to find a funclet with information. Put
418  // null entries in the memo map to avoid re-processing as we go up.
419  MemoMap[EHPad] = nullptr;
420 #ifndef NDEBUG
422  TempMemos.insert(EHPad);
423 #endif
424  Instruction *LastUselessPad = EHPad;
425  Value *AncestorToken;
426  for (AncestorToken = getParentPad(EHPad);
427  auto *AncestorPad = dyn_cast<Instruction>(AncestorToken);
428  AncestorToken = getParentPad(AncestorToken)) {
429  // Skip over catchpads since they just follow their catchswitches.
430  if (isa<CatchPadInst>(AncestorPad))
431  continue;
432  // If the MemoMap had an entry mapping AncestorPad to nullptr, since we
433  // haven't yet called getUnwindDestTokenHelper for AncestorPad in this
434  // call to getUnwindDestToken, that would mean that AncestorPad had no
435  // information in itself, its descendants, or its ancestors. If that
436  // were the case, then we should also have recorded the lack of information
437  // for the descendant that we're coming from. So assert that we don't
438  // find a null entry in the MemoMap for AncestorPad.
439  assert(!MemoMap.count(AncestorPad) || MemoMap[AncestorPad]);
440  auto AncestorMemo = MemoMap.find(AncestorPad);
441  if (AncestorMemo == MemoMap.end()) {
442  UnwindDestToken = getUnwindDestTokenHelper(AncestorPad, MemoMap);
443  } else {
444  UnwindDestToken = AncestorMemo->second;
445  }
446  if (UnwindDestToken)
447  break;
448  LastUselessPad = AncestorPad;
449  MemoMap[LastUselessPad] = nullptr;
450 #ifndef NDEBUG
451  TempMemos.insert(LastUselessPad);
452 #endif
453  }
454 
455  // We know that getUnwindDestTokenHelper was called on LastUselessPad and
456  // returned nullptr (and likewise for EHPad and any of its ancestors up to
457  // LastUselessPad), so LastUselessPad has no information from below. Since
458  // getUnwindDestTokenHelper must investigate all downward paths through
459  // no-information nodes to prove that a node has no information like this,
460  // and since any time it finds information it records it in the MemoMap for
461  // not just the immediately-containing funclet but also any ancestors also
462  // exited, it must be the case that, walking downward from LastUselessPad,
463  // visiting just those nodes which have not been mapped to an unwind dest
464  // by getUnwindDestTokenHelper (the nullptr TempMemos notwithstanding, since
465  // they are just used to keep getUnwindDestTokenHelper from repeating work),
466  // any node visited must have been exhaustively searched with no information
467  // for it found.
468  SmallVector<Instruction *, 8> Worklist(1, LastUselessPad);
469  while (!Worklist.empty()) {
470  Instruction *UselessPad = Worklist.pop_back_val();
471  auto Memo = MemoMap.find(UselessPad);
472  if (Memo != MemoMap.end() && Memo->second) {
473  // Here the name 'UselessPad' is a bit of a misnomer, because we've found
474  // that it is a funclet that does have information about unwinding to
475  // a particular destination; its parent was a useless pad.
476  // Since its parent has no information, the unwind edge must not escape
477  // the parent, and must target a sibling of this pad. This local unwind
478  // gives us no information about EHPad. Leave it and the subtree rooted
479  // at it alone.
480  assert(getParentPad(Memo->second) == getParentPad(UselessPad));
481  continue;
482  }
483  // We know we don't have information for UselesPad. If it has an entry in
484  // the MemoMap (mapping it to nullptr), it must be one of the TempMemos
485  // added on this invocation of getUnwindDestToken; if a previous invocation
486  // recorded nullptr, it would have had to prove that the ancestors of
487  // UselessPad, which include LastUselessPad, had no information, and that
488  // in turn would have required proving that the descendants of
489  // LastUselesPad, which include EHPad, have no information about
490  // LastUselessPad, which would imply that EHPad was mapped to nullptr in
491  // the MemoMap on that invocation, which isn't the case if we got here.
492  assert(!MemoMap.count(UselessPad) || TempMemos.count(UselessPad));
493  // Assert as we enumerate users that 'UselessPad' doesn't have any unwind
494  // information that we'd be contradicting by making a map entry for it
495  // (which is something that getUnwindDestTokenHelper must have proved for
496  // us to get here). Just assert on is direct users here; the checks in
497  // this downward walk at its descendants will verify that they don't have
498  // any unwind edges that exit 'UselessPad' either (i.e. they either have no
499  // unwind edges or unwind to a sibling).
500  MemoMap[UselessPad] = UnwindDestToken;
501  if (auto *CatchSwitch = dyn_cast<CatchSwitchInst>(UselessPad)) {
502  assert(CatchSwitch->getUnwindDest() == nullptr && "Expected useless pad");
503  for (BasicBlock *HandlerBlock : CatchSwitch->handlers()) {
504  auto *CatchPad = HandlerBlock->getFirstNonPHI();
505  for (User *U : CatchPad->users()) {
506  assert(
507  (!isa<InvokeInst>(U) ||
508  (getParentPad(
509  cast<InvokeInst>(U)->getUnwindDest()->getFirstNonPHI()) ==
510  CatchPad)) &&
511  "Expected useless pad");
512  if (isa<CatchSwitchInst>(U) || isa<CleanupPadInst>(U))
513  Worklist.push_back(cast<Instruction>(U));
514  }
515  }
516  } else {
517  assert(isa<CleanupPadInst>(UselessPad));
518  for (User *U : UselessPad->users()) {
519  assert(!isa<CleanupReturnInst>(U) && "Expected useless pad");
520  assert((!isa<InvokeInst>(U) ||
521  (getParentPad(
522  cast<InvokeInst>(U)->getUnwindDest()->getFirstNonPHI()) ==
523  UselessPad)) &&
524  "Expected useless pad");
525  if (isa<CatchSwitchInst>(U) || isa<CleanupPadInst>(U))
526  Worklist.push_back(cast<Instruction>(U));
527  }
528  }
529  }
530 
531  return UnwindDestToken;
532 }
533 
534 /// When we inline a basic block into an invoke,
535 /// we have to turn all of the calls that can throw into invokes.
536 /// This function analyze BB to see if there are any calls, and if so,
537 /// it rewrites them to be invokes that jump to InvokeDest and fills in the PHI
538 /// nodes in that block with the values specified in InvokeDestPHIValues.
540  BasicBlock *BB, BasicBlock *UnwindEdge,
541  UnwindDestMemoTy *FuncletUnwindMap = nullptr) {
543  // We only need to check for function calls: inlined invoke
544  // instructions require no special handling.
545  CallInst *CI = dyn_cast<CallInst>(&I);
546 
547  if (!CI || CI->doesNotThrow())
548  continue;
549 
550  if (CI->isInlineAsm()) {
551  InlineAsm *IA = cast<InlineAsm>(CI->getCalledOperand());
552  if (!IA->canThrow()) {
553  continue;
554  }
555  }
556 
557  // We do not need to (and in fact, cannot) convert possibly throwing calls
558  // to @llvm.experimental_deoptimize (resp. @llvm.experimental.guard) into
559  // invokes. The caller's "segment" of the deoptimization continuation
560  // attached to the newly inlined @llvm.experimental_deoptimize
561  // (resp. @llvm.experimental.guard) call should contain the exception
562  // handling logic, if any.
563  if (auto *F = CI->getCalledFunction())
564  if (F->getIntrinsicID() == Intrinsic::experimental_deoptimize ||
565  F->getIntrinsicID() == Intrinsic::experimental_guard)
566  continue;
567 
568  if (auto FuncletBundle = CI->getOperandBundle(LLVMContext::OB_funclet)) {
569  // This call is nested inside a funclet. If that funclet has an unwind
570  // destination within the inlinee, then unwinding out of this call would
571  // be UB. Rewriting this call to an invoke which targets the inlined
572  // invoke's unwind dest would give the call's parent funclet multiple
573  // unwind destinations, which is something that subsequent EH table
574  // generation can't handle and that the veirifer rejects. So when we
575  // see such a call, leave it as a call.
576  auto *FuncletPad = cast<Instruction>(FuncletBundle->Inputs[0]);
577  Value *UnwindDestToken =
578  getUnwindDestToken(FuncletPad, *FuncletUnwindMap);
579  if (UnwindDestToken && !isa<ConstantTokenNone>(UnwindDestToken))
580  continue;
581 #ifndef NDEBUG
582  Instruction *MemoKey;
583  if (auto *CatchPad = dyn_cast<CatchPadInst>(FuncletPad))
584  MemoKey = CatchPad->getCatchSwitch();
585  else
586  MemoKey = FuncletPad;
587  assert(FuncletUnwindMap->count(MemoKey) &&
588  (*FuncletUnwindMap)[MemoKey] == UnwindDestToken &&
589  "must get memoized to avoid confusing later searches");
590 #endif // NDEBUG
591  }
592 
593  changeToInvokeAndSplitBasicBlock(CI, UnwindEdge);
594  return BB;
595  }
596  return nullptr;
597 }
598 
599 /// If we inlined an invoke site, we need to convert calls
600 /// in the body of the inlined function into invokes.
601 ///
602 /// II is the invoke instruction being inlined. FirstNewBlock is the first
603 /// block of the inlined code (the last block is the end of the function),
604 /// and InlineCodeInfo is information about the code that got inlined.
605 static void HandleInlinedLandingPad(InvokeInst *II, BasicBlock *FirstNewBlock,
606  ClonedCodeInfo &InlinedCodeInfo) {
607  BasicBlock *InvokeDest = II->getUnwindDest();
608 
609  Function *Caller = FirstNewBlock->getParent();
610 
611  // The inlined code is currently at the end of the function, scan from the
612  // start of the inlined code to its end, checking for stuff we need to
613  // rewrite.
614  LandingPadInliningInfo Invoke(II);
615 
616  // Get all of the inlined landing pad instructions.
618  for (Function::iterator I = FirstNewBlock->getIterator(), E = Caller->end();
619  I != E; ++I)
620  if (InvokeInst *II = dyn_cast<InvokeInst>(I->getTerminator()))
621  InlinedLPads.insert(II->getLandingPadInst());
622 
623  // Append the clauses from the outer landing pad instruction into the inlined
624  // landing pad instructions.
625  LandingPadInst *OuterLPad = Invoke.getLandingPadInst();
626  for (LandingPadInst *InlinedLPad : InlinedLPads) {
627  unsigned OuterNum = OuterLPad->getNumClauses();
628  InlinedLPad->reserveClauses(OuterNum);
629  for (unsigned OuterIdx = 0; OuterIdx != OuterNum; ++OuterIdx)
630  InlinedLPad->addClause(OuterLPad->getClause(OuterIdx));
631  if (OuterLPad->isCleanup())
632  InlinedLPad->setCleanup(true);
633  }
634 
635  for (Function::iterator BB = FirstNewBlock->getIterator(), E = Caller->end();
636  BB != E; ++BB) {
637  if (InlinedCodeInfo.ContainsCalls)
639  &*BB, Invoke.getOuterResumeDest()))
640  // Update any PHI nodes in the exceptional block to indicate that there
641  // is now a new entry in them.
642  Invoke.addIncomingPHIValuesFor(NewBB);
643 
644  // Forward any resumes that are remaining here.
645  if (ResumeInst *RI = dyn_cast<ResumeInst>(BB->getTerminator()))
646  Invoke.forwardResume(RI, InlinedLPads);
647  }
648 
649  // Now that everything is happy, we have one final detail. The PHI nodes in
650  // the exception destination block still have entries due to the original
651  // invoke instruction. Eliminate these entries (which might even delete the
652  // PHI node) now.
653  InvokeDest->removePredecessor(II->getParent());
654 }
655 
656 /// If we inlined an invoke site, we need to convert calls
657 /// in the body of the inlined function into invokes.
658 ///
659 /// II is the invoke instruction being inlined. FirstNewBlock is the first
660 /// block of the inlined code (the last block is the end of the function),
661 /// and InlineCodeInfo is information about the code that got inlined.
662 static void HandleInlinedEHPad(InvokeInst *II, BasicBlock *FirstNewBlock,
663  ClonedCodeInfo &InlinedCodeInfo) {
664  BasicBlock *UnwindDest = II->getUnwindDest();
665  Function *Caller = FirstNewBlock->getParent();
666 
667  assert(UnwindDest->getFirstNonPHI()->isEHPad() && "unexpected BasicBlock!");
668 
669  // If there are PHI nodes in the unwind destination block, we need to keep
670  // track of which values came into them from the invoke before removing the
671  // edge from this block.
672  SmallVector<Value *, 8> UnwindDestPHIValues;
673  BasicBlock *InvokeBB = II->getParent();
674  for (PHINode &PHI : UnwindDest->phis()) {
675  // Save the value to use for this edge.
676  UnwindDestPHIValues.push_back(PHI.getIncomingValueForBlock(InvokeBB));
677  }
678 
679  // Add incoming-PHI values to the unwind destination block for the given basic
680  // block, using the values for the original invoke's source block.
681  auto UpdatePHINodes = [&](BasicBlock *Src) {
682  BasicBlock::iterator I = UnwindDest->begin();
683  for (Value *V : UnwindDestPHIValues) {
684  PHINode *PHI = cast<PHINode>(I);
685  PHI->addIncoming(V, Src);
686  ++I;
687  }
688  };
689 
690  // This connects all the instructions which 'unwind to caller' to the invoke
691  // destination.
692  UnwindDestMemoTy FuncletUnwindMap;
693  for (Function::iterator BB = FirstNewBlock->getIterator(), E = Caller->end();
694  BB != E; ++BB) {
695  if (auto *CRI = dyn_cast<CleanupReturnInst>(BB->getTerminator())) {
696  if (CRI->unwindsToCaller()) {
697  auto *CleanupPad = CRI->getCleanupPad();
698  CleanupReturnInst::Create(CleanupPad, UnwindDest, CRI);
699  CRI->eraseFromParent();
700  UpdatePHINodes(&*BB);
701  // Finding a cleanupret with an unwind destination would confuse
702  // subsequent calls to getUnwindDestToken, so map the cleanuppad
703  // to short-circuit any such calls and recognize this as an "unwind
704  // to caller" cleanup.
705  assert(!FuncletUnwindMap.count(CleanupPad) ||
706  isa<ConstantTokenNone>(FuncletUnwindMap[CleanupPad]));
707  FuncletUnwindMap[CleanupPad] =
708  ConstantTokenNone::get(Caller->getContext());
709  }
710  }
711 
712  Instruction *I = BB->getFirstNonPHI();
713  if (!I->isEHPad())
714  continue;
715 
716  Instruction *Replacement = nullptr;
717  if (auto *CatchSwitch = dyn_cast<CatchSwitchInst>(I)) {
718  if (CatchSwitch->unwindsToCaller()) {
719  Value *UnwindDestToken;
720  if (auto *ParentPad =
721  dyn_cast<Instruction>(CatchSwitch->getParentPad())) {
722  // This catchswitch is nested inside another funclet. If that
723  // funclet has an unwind destination within the inlinee, then
724  // unwinding out of this catchswitch would be UB. Rewriting this
725  // catchswitch to unwind to the inlined invoke's unwind dest would
726  // give the parent funclet multiple unwind destinations, which is
727  // something that subsequent EH table generation can't handle and
728  // that the veirifer rejects. So when we see such a call, leave it
729  // as "unwind to caller".
730  UnwindDestToken = getUnwindDestToken(ParentPad, FuncletUnwindMap);
731  if (UnwindDestToken && !isa<ConstantTokenNone>(UnwindDestToken))
732  continue;
733  } else {
734  // This catchswitch has no parent to inherit constraints from, and
735  // none of its descendants can have an unwind edge that exits it and
736  // targets another funclet in the inlinee. It may or may not have a
737  // descendant that definitively has an unwind to caller. In either
738  // case, we'll have to assume that any unwinds out of it may need to
739  // be routed to the caller, so treat it as though it has a definitive
740  // unwind to caller.
741  UnwindDestToken = ConstantTokenNone::get(Caller->getContext());
742  }
743  auto *NewCatchSwitch = CatchSwitchInst::Create(
744  CatchSwitch->getParentPad(), UnwindDest,
745  CatchSwitch->getNumHandlers(), CatchSwitch->getName(),
746  CatchSwitch);
747  for (BasicBlock *PadBB : CatchSwitch->handlers())
748  NewCatchSwitch->addHandler(PadBB);
749  // Propagate info for the old catchswitch over to the new one in
750  // the unwind map. This also serves to short-circuit any subsequent
751  // checks for the unwind dest of this catchswitch, which would get
752  // confused if they found the outer handler in the callee.
753  FuncletUnwindMap[NewCatchSwitch] = UnwindDestToken;
754  Replacement = NewCatchSwitch;
755  }
756  } else if (!isa<FuncletPadInst>(I)) {
757  llvm_unreachable("unexpected EHPad!");
758  }
759 
760  if (Replacement) {
761  Replacement->takeName(I);
762  I->replaceAllUsesWith(Replacement);
763  I->eraseFromParent();
764  UpdatePHINodes(&*BB);
765  }
766  }
767 
768  if (InlinedCodeInfo.ContainsCalls)
769  for (Function::iterator BB = FirstNewBlock->getIterator(),
770  E = Caller->end();
771  BB != E; ++BB)
773  &*BB, UnwindDest, &FuncletUnwindMap))
774  // Update any PHI nodes in the exceptional block to indicate that there
775  // is now a new entry in them.
776  UpdatePHINodes(NewBB);
777 
778  // Now that everything is happy, we have one final detail. The PHI nodes in
779  // the exception destination block still have entries due to the original
780  // invoke instruction. Eliminate these entries (which might even delete the
781  // PHI node) now.
782  UnwindDest->removePredecessor(InvokeBB);
783 }
784 
785 /// When inlining a call site that has !llvm.mem.parallel_loop_access,
786 /// !llvm.access.group, !alias.scope or !noalias metadata, that metadata should
787 /// be propagated to all memory-accessing cloned instructions.
789  Function::iterator FEnd) {
790  MDNode *MemParallelLoopAccess =
791  CB.getMetadata(LLVMContext::MD_mem_parallel_loop_access);
792  MDNode *AccessGroup = CB.getMetadata(LLVMContext::MD_access_group);
793  MDNode *AliasScope = CB.getMetadata(LLVMContext::MD_alias_scope);
794  MDNode *NoAlias = CB.getMetadata(LLVMContext::MD_noalias);
795  if (!MemParallelLoopAccess && !AccessGroup && !AliasScope && !NoAlias)
796  return;
797 
798  for (BasicBlock &BB : make_range(FStart, FEnd)) {
799  for (Instruction &I : BB) {
800  // This metadata is only relevant for instructions that access memory.
801  if (!I.mayReadOrWriteMemory())
802  continue;
803 
804  if (MemParallelLoopAccess) {
805  // TODO: This probably should not overwrite MemParalleLoopAccess.
806  MemParallelLoopAccess = MDNode::concatenate(
807  I.getMetadata(LLVMContext::MD_mem_parallel_loop_access),
808  MemParallelLoopAccess);
809  I.setMetadata(LLVMContext::MD_mem_parallel_loop_access,
810  MemParallelLoopAccess);
811  }
812 
813  if (AccessGroup)
814  I.setMetadata(LLVMContext::MD_access_group, uniteAccessGroups(
815  I.getMetadata(LLVMContext::MD_access_group), AccessGroup));
816 
817  if (AliasScope)
818  I.setMetadata(LLVMContext::MD_alias_scope, MDNode::concatenate(
819  I.getMetadata(LLVMContext::MD_alias_scope), AliasScope));
820 
821  if (NoAlias)
822  I.setMetadata(LLVMContext::MD_noalias, MDNode::concatenate(
823  I.getMetadata(LLVMContext::MD_noalias), NoAlias));
824  }
825  }
826 }
827 
828 namespace {
829 /// Utility for cloning !noalias and !alias.scope metadata. When a code region
830 /// using scoped alias metadata is inlined, the aliasing relationships may not
831 /// hold between the two version. It is necessary to create a deep clone of the
832 /// metadata, putting the two versions in separate scope domains.
833 class ScopedAliasMetadataDeepCloner {
836  MetadataMap MDMap;
837  void addRecursiveMetadataUses();
838 
839 public:
840  ScopedAliasMetadataDeepCloner(const Function *F);
841 
842  /// Create a new clone of the scoped alias metadata, which will be used by
843  /// subsequent remap() calls.
844  void clone();
845 
846  /// Remap instructions in the given range from the original to the cloned
847  /// metadata.
848  void remap(Function::iterator FStart, Function::iterator FEnd);
849 };
850 } // namespace
851 
852 ScopedAliasMetadataDeepCloner::ScopedAliasMetadataDeepCloner(
853  const Function *F) {
854  for (const BasicBlock &BB : *F) {
855  for (const Instruction &I : BB) {
856  if (const MDNode *M = I.getMetadata(LLVMContext::MD_alias_scope))
857  MD.insert(M);
858  if (const MDNode *M = I.getMetadata(LLVMContext::MD_noalias))
859  MD.insert(M);
860 
861  // We also need to clone the metadata in noalias intrinsics.
862  if (const auto *Decl = dyn_cast<NoAliasScopeDeclInst>(&I))
863  MD.insert(Decl->getScopeList());
864  }
865  }
866  addRecursiveMetadataUses();
867 }
868 
869 void ScopedAliasMetadataDeepCloner::addRecursiveMetadataUses() {
870  SmallVector<const Metadata *, 16> Queue(MD.begin(), MD.end());
871  while (!Queue.empty()) {
872  const MDNode *M = cast<MDNode>(Queue.pop_back_val());
873  for (const Metadata *Op : M->operands())
874  if (const MDNode *OpMD = dyn_cast<MDNode>(Op))
875  if (MD.insert(OpMD))
876  Queue.push_back(OpMD);
877  }
878 }
879 
880 void ScopedAliasMetadataDeepCloner::clone() {
881  assert(MDMap.empty() && "clone() already called ?");
882 
883  SmallVector<TempMDTuple, 16> DummyNodes;
884  for (const MDNode *I : MD) {
885  DummyNodes.push_back(MDTuple::getTemporary(I->getContext(), None));
886  MDMap[I].reset(DummyNodes.back().get());
887  }
888 
889  // Create new metadata nodes to replace the dummy nodes, replacing old
890  // metadata references with either a dummy node or an already-created new
891  // node.
893  for (const MDNode *I : MD) {
894  for (const Metadata *Op : I->operands()) {
895  if (const MDNode *M = dyn_cast<MDNode>(Op))
896  NewOps.push_back(MDMap[M]);
897  else
898  NewOps.push_back(const_cast<Metadata *>(Op));
899  }
900 
901  MDNode *NewM = MDNode::get(I->getContext(), NewOps);
902  MDTuple *TempM = cast<MDTuple>(MDMap[I]);
903  assert(TempM->isTemporary() && "Expected temporary node");
904 
905  TempM->replaceAllUsesWith(NewM);
906  NewOps.clear();
907  }
908 }
909 
910 void ScopedAliasMetadataDeepCloner::remap(Function::iterator FStart,
911  Function::iterator FEnd) {
912  if (MDMap.empty())
913  return; // Nothing to do.
914 
915  for (BasicBlock &BB : make_range(FStart, FEnd)) {
916  for (Instruction &I : BB) {
917  // TODO: The null checks for the MDMap.lookup() results should no longer
918  // be necessary.
919  if (MDNode *M = I.getMetadata(LLVMContext::MD_alias_scope))
920  if (MDNode *MNew = MDMap.lookup(M))
921  I.setMetadata(LLVMContext::MD_alias_scope, MNew);
922 
923  if (MDNode *M = I.getMetadata(LLVMContext::MD_noalias))
924  if (MDNode *MNew = MDMap.lookup(M))
925  I.setMetadata(LLVMContext::MD_noalias, MNew);
926 
927  if (auto *Decl = dyn_cast<NoAliasScopeDeclInst>(&I))
928  if (MDNode *MNew = MDMap.lookup(Decl->getScopeList()))
929  Decl->setScopeList(MNew);
930  }
931  }
932 }
933 
934 /// If the inlined function has noalias arguments,
935 /// then add new alias scopes for each noalias argument, tag the mapped noalias
936 /// parameters with noalias metadata specifying the new scope, and tag all
937 /// non-derived loads, stores and memory intrinsics with the new alias scopes.
939  const DataLayout &DL, AAResults *CalleeAAR,
940  ClonedCodeInfo &InlinedFunctionInfo) {
942  return;
943 
944  const Function *CalledFunc = CB.getCalledFunction();
946 
947  for (const Argument &Arg : CalledFunc->args())
948  if (CB.paramHasAttr(Arg.getArgNo(), Attribute::NoAlias) && !Arg.use_empty())
949  NoAliasArgs.push_back(&Arg);
950 
951  if (NoAliasArgs.empty())
952  return;
953 
954  // To do a good job, if a noalias variable is captured, we need to know if
955  // the capture point dominates the particular use we're considering.
956  DominatorTree DT;
957  DT.recalculate(const_cast<Function&>(*CalledFunc));
958 
959  // noalias indicates that pointer values based on the argument do not alias
960  // pointer values which are not based on it. So we add a new "scope" for each
961  // noalias function argument. Accesses using pointers based on that argument
962  // become part of that alias scope, accesses using pointers not based on that
963  // argument are tagged as noalias with that scope.
964 
966  MDBuilder MDB(CalledFunc->getContext());
967 
968  // Create a new scope domain for this function.
969  MDNode *NewDomain =
970  MDB.createAnonymousAliasScopeDomain(CalledFunc->getName());
971  for (unsigned i = 0, e = NoAliasArgs.size(); i != e; ++i) {
972  const Argument *A = NoAliasArgs[i];
973 
974  std::string Name = std::string(CalledFunc->getName());
975  if (A->hasName()) {
976  Name += ": %";
977  Name += A->getName();
978  } else {
979  Name += ": argument ";
980  Name += utostr(i);
981  }
982 
983  // Note: We always create a new anonymous root here. This is true regardless
984  // of the linkage of the callee because the aliasing "scope" is not just a
985  // property of the callee, but also all control dependencies in the caller.
986  MDNode *NewScope = MDB.createAnonymousAliasScope(NewDomain, Name);
987  NewScopes.insert(std::make_pair(A, NewScope));
988 
989  if (UseNoAliasIntrinsic) {
990  // Introduce a llvm.experimental.noalias.scope.decl for the noalias
991  // argument.
992  MDNode *AScopeList = MDNode::get(CalledFunc->getContext(), NewScope);
993  auto *NoAliasDecl =
995  // Ignore the result for now. The result will be used when the
996  // llvm.noalias intrinsic is introduced.
997  (void)NoAliasDecl;
998  }
999  }
1000 
1001  // Iterate over all new instructions in the map; for all memory-access
1002  // instructions, add the alias scope metadata.
1003  for (ValueToValueMapTy::iterator VMI = VMap.begin(), VMIE = VMap.end();
1004  VMI != VMIE; ++VMI) {
1005  if (const Instruction *I = dyn_cast<Instruction>(VMI->first)) {
1006  if (!VMI->second)
1007  continue;
1008 
1009  Instruction *NI = dyn_cast<Instruction>(VMI->second);
1010  if (!NI || InlinedFunctionInfo.isSimplified(I, NI))
1011  continue;
1012 
1013  bool IsArgMemOnlyCall = false, IsFuncCall = false;
1015 
1016  if (const LoadInst *LI = dyn_cast<LoadInst>(I))
1017  PtrArgs.push_back(LI->getPointerOperand());
1018  else if (const StoreInst *SI = dyn_cast<StoreInst>(I))
1019  PtrArgs.push_back(SI->getPointerOperand());
1020  else if (const VAArgInst *VAAI = dyn_cast<VAArgInst>(I))
1021  PtrArgs.push_back(VAAI->getPointerOperand());
1022  else if (const AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(I))
1023  PtrArgs.push_back(CXI->getPointerOperand());
1024  else if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(I))
1025  PtrArgs.push_back(RMWI->getPointerOperand());
1026  else if (const auto *Call = dyn_cast<CallBase>(I)) {
1027  // If we know that the call does not access memory, then we'll still
1028  // know that about the inlined clone of this call site, and we don't
1029  // need to add metadata.
1030  if (Call->doesNotAccessMemory())
1031  continue;
1032 
1033  IsFuncCall = true;
1034  if (CalleeAAR) {
1035  FunctionModRefBehavior MRB = CalleeAAR->getModRefBehavior(Call);
1036 
1037  // We'll retain this knowledge without additional metadata.
1039  continue;
1040 
1042  IsArgMemOnlyCall = true;
1043  }
1044 
1045  for (Value *Arg : Call->args()) {
1046  // We need to check the underlying objects of all arguments, not just
1047  // the pointer arguments, because we might be passing pointers as
1048  // integers, etc.
1049  // However, if we know that the call only accesses pointer arguments,
1050  // then we only need to check the pointer arguments.
1051  if (IsArgMemOnlyCall && !Arg->getType()->isPointerTy())
1052  continue;
1053 
1054  PtrArgs.push_back(Arg);
1055  }
1056  }
1057 
1058  // If we found no pointers, then this instruction is not suitable for
1059  // pairing with an instruction to receive aliasing metadata.
1060  // However, if this is a call, this we might just alias with none of the
1061  // noalias arguments.
1062  if (PtrArgs.empty() && !IsFuncCall)
1063  continue;
1064 
1065  // It is possible that there is only one underlying object, but you
1066  // need to go through several PHIs to see it, and thus could be
1067  // repeated in the Objects list.
1070 
1072  for (const Value *V : PtrArgs) {
1074  getUnderlyingObjects(V, Objects, /* LI = */ nullptr);
1075 
1076  for (const Value *O : Objects)
1077  ObjSet.insert(O);
1078  }
1079 
1080  // Figure out if we're derived from anything that is not a noalias
1081  // argument.
1082  bool RequiresNoCaptureBefore = false, UsesAliasingPtr = false;
1083  for (const Value *V : ObjSet) {
1084  // Is this value a constant that cannot be derived from any pointer
1085  // value (we need to exclude constant expressions, for example, that
1086  // are formed from arithmetic on global symbols).
1087  bool IsNonPtrConst = isa<ConstantInt>(V) || isa<ConstantFP>(V) ||
1088  isa<ConstantPointerNull>(V) ||
1089  isa<ConstantDataVector>(V) || isa<UndefValue>(V);
1090  if (IsNonPtrConst)
1091  continue;
1092 
1093  // If this is anything other than a noalias argument, then we cannot
1094  // completely describe the aliasing properties using alias.scope
1095  // metadata (and, thus, won't add any).
1096  if (const Argument *A = dyn_cast<Argument>(V)) {
1097  if (!CB.paramHasAttr(A->getArgNo(), Attribute::NoAlias))
1098  UsesAliasingPtr = true;
1099  } else {
1100  UsesAliasingPtr = true;
1101  }
1102 
1103  // If this is not some identified function-local object (which cannot
1104  // directly alias a noalias argument), or some other argument (which,
1105  // by definition, also cannot alias a noalias argument), then we could
1106  // alias a noalias argument that has been captured).
1107  if (!isa<Argument>(V) && !isIdentifiedFunctionLocal(V))
1108  RequiresNoCaptureBefore = true;
1109  }
1110 
1111  // A function call can always get captured noalias pointers (via other
1112  // parameters, globals, etc.).
1113  if (IsFuncCall && !IsArgMemOnlyCall)
1114  RequiresNoCaptureBefore = true;
1115 
1116  // First, we want to figure out all of the sets with which we definitely
1117  // don't alias. Iterate over all noalias set, and add those for which:
1118  // 1. The noalias argument is not in the set of objects from which we
1119  // definitely derive.
1120  // 2. The noalias argument has not yet been captured.
1121  // An arbitrary function that might load pointers could see captured
1122  // noalias arguments via other noalias arguments or globals, and so we
1123  // must always check for prior capture.
1124  for (const Argument *A : NoAliasArgs) {
1125  if (ObjSet.contains(A))
1126  continue; // May be based on a noalias argument.
1127 
1128  // It might be tempting to skip the PointerMayBeCapturedBefore check if
1129  // A->hasNoCaptureAttr() is true, but this is incorrect because
1130  // nocapture only guarantees that no copies outlive the function, not
1131  // that the value cannot be locally captured.
1132  if (!RequiresNoCaptureBefore ||
1133  !PointerMayBeCapturedBefore(A, /* ReturnCaptures */ false,
1134  /* StoreCaptures */ false, I, &DT))
1135  NoAliases.push_back(NewScopes[A]);
1136  }
1137 
1138  if (!NoAliases.empty())
1139  NI->setMetadata(LLVMContext::MD_noalias,
1141  NI->getMetadata(LLVMContext::MD_noalias),
1142  MDNode::get(CalledFunc->getContext(), NoAliases)));
1143 
1144  // Next, we want to figure out all of the sets to which we might belong.
1145  // We might belong to a set if the noalias argument is in the set of
1146  // underlying objects. If there is some non-noalias argument in our list
1147  // of underlying objects, then we cannot add a scope because the fact
1148  // that some access does not alias with any set of our noalias arguments
1149  // cannot itself guarantee that it does not alias with this access
1150  // (because there is some pointer of unknown origin involved and the
1151  // other access might also depend on this pointer). We also cannot add
1152  // scopes to arbitrary functions unless we know they don't access any
1153  // non-parameter pointer-values.
1154  bool CanAddScopes = !UsesAliasingPtr;
1155  if (CanAddScopes && IsFuncCall)
1156  CanAddScopes = IsArgMemOnlyCall;
1157 
1158  if (CanAddScopes)
1159  for (const Argument *A : NoAliasArgs) {
1160  if (ObjSet.count(A))
1161  Scopes.push_back(NewScopes[A]);
1162  }
1163 
1164  if (!Scopes.empty())
1165  NI->setMetadata(
1166  LLVMContext::MD_alias_scope,
1167  MDNode::concatenate(NI->getMetadata(LLVMContext::MD_alias_scope),
1168  MDNode::get(CalledFunc->getContext(), Scopes)));
1169  }
1170  }
1171 }
1172 
1174  Instruction *End) {
1175 
1176  assert(Begin->getParent() == End->getParent() &&
1177  "Expected to be in same basic block!");
1179  Begin->getIterator(), End->getIterator(), InlinerAttributeWindow + 1);
1180 }
1181 
1183 
1185  if (!AB.hasAttributes())
1186  return AB;
1187  AttrBuilder Valid(CB.getContext());
1188  // Only allow these white listed attributes to be propagated back to the
1189  // callee. This is because other attributes may only be valid on the call
1190  // itself, i.e. attributes such as signext and zeroext.
1191  if (auto DerefBytes = AB.getDereferenceableBytes())
1192  Valid.addDereferenceableAttr(DerefBytes);
1193  if (auto DerefOrNullBytes = AB.getDereferenceableOrNullBytes())
1194  Valid.addDereferenceableOrNullAttr(DerefOrNullBytes);
1195  if (AB.contains(Attribute::NoAlias))
1196  Valid.addAttribute(Attribute::NoAlias);
1197  if (AB.contains(Attribute::NonNull))
1198  Valid.addAttribute(Attribute::NonNull);
1199  return Valid;
1200 }
1201 
1204  return;
1205 
1207  if (!Valid.hasAttributes())
1208  return;
1209  auto *CalledFunction = CB.getCalledFunction();
1210  auto &Context = CalledFunction->getContext();
1211 
1212  for (auto &BB : *CalledFunction) {
1213  auto *RI = dyn_cast<ReturnInst>(BB.getTerminator());
1214  if (!RI || !isa<CallBase>(RI->getOperand(0)))
1215  continue;
1216  auto *RetVal = cast<CallBase>(RI->getOperand(0));
1217  // Check that the cloned RetVal exists and is a call, otherwise we cannot
1218  // add the attributes on the cloned RetVal. Simplification during inlining
1219  // could have transformed the cloned instruction.
1220  auto *NewRetVal = dyn_cast_or_null<CallBase>(VMap.lookup(RetVal));
1221  if (!NewRetVal)
1222  continue;
1223  // Backward propagation of attributes to the returned value may be incorrect
1224  // if it is control flow dependent.
1225  // Consider:
1226  // @callee {
1227  // %rv = call @foo()
1228  // %rv2 = call @bar()
1229  // if (%rv2 != null)
1230  // return %rv2
1231  // if (%rv == null)
1232  // exit()
1233  // return %rv
1234  // }
1235  // caller() {
1236  // %val = call nonnull @callee()
1237  // }
1238  // Here we cannot add the nonnull attribute on either foo or bar. So, we
1239  // limit the check to both RetVal and RI are in the same basic block and
1240  // there are no throwing/exiting instructions between these instructions.
1241  if (RI->getParent() != RetVal->getParent() ||
1242  MayContainThrowingOrExitingCall(RetVal, RI))
1243  continue;
1244  // Add to the existing attributes of NewRetVal, i.e. the cloned call
1245  // instruction.
1246  // NB! When we have the same attribute already existing on NewRetVal, but
1247  // with a differing value, the AttributeList's merge API honours the already
1248  // existing attribute value (i.e. attributes such as dereferenceable,
1249  // dereferenceable_or_null etc). See AttrBuilder::merge for more details.
1250  AttributeList AL = NewRetVal->getAttributes();
1251  AttributeList NewAL = AL.addRetAttributes(Context, Valid);
1252  NewRetVal->setAttributes(NewAL);
1253  }
1254 }
1255 
1256 /// If the inlined function has non-byval align arguments, then
1257 /// add @llvm.assume-based alignment assumptions to preserve this information.
1260  return;
1261 
1262  AssumptionCache *AC = &IFI.GetAssumptionCache(*CB.getCaller());
1263  auto &DL = CB.getCaller()->getParent()->getDataLayout();
1264 
1265  // To avoid inserting redundant assumptions, we should check for assumptions
1266  // already in the caller. To do this, we might need a DT of the caller.
1267  DominatorTree DT;
1268  bool DTCalculated = false;
1269 
1270  Function *CalledFunc = CB.getCalledFunction();
1271  for (Argument &Arg : CalledFunc->args()) {
1272  unsigned Align = Arg.getType()->isPointerTy() ? Arg.getParamAlignment() : 0;
1273  if (Align && !Arg.hasPassPointeeByValueCopyAttr() && !Arg.hasNUses(0)) {
1274  if (!DTCalculated) {
1275  DT.recalculate(*CB.getCaller());
1276  DTCalculated = true;
1277  }
1278 
1279  // If we can already prove the asserted alignment in the context of the
1280  // caller, then don't bother inserting the assumption.
1281  Value *ArgVal = CB.getArgOperand(Arg.getArgNo());
1282  if (getKnownAlignment(ArgVal, DL, &CB, AC, &DT) >= Align)
1283  continue;
1284 
1285  CallInst *NewAsmp =
1287  AC->registerAssumption(cast<AssumeInst>(NewAsmp));
1288  }
1289  }
1290 }
1291 
1292 /// Once we have cloned code over from a callee into the caller,
1293 /// update the specified callgraph to reflect the changes we made.
1294 /// Note that it's possible that not all code was copied over, so only
1295 /// some edges of the callgraph may remain.
1297  Function::iterator FirstNewBlock,
1298  ValueToValueMapTy &VMap,
1299  InlineFunctionInfo &IFI) {
1300  CallGraph &CG = *IFI.CG;
1301  const Function *Caller = CB.getCaller();
1302  const Function *Callee = CB.getCalledFunction();
1303  CallGraphNode *CalleeNode = CG[Callee];
1304  CallGraphNode *CallerNode = CG[Caller];
1305 
1306  // Since we inlined some uninlined call sites in the callee into the caller,
1307  // add edges from the caller to all of the callees of the callee.
1308  CallGraphNode::iterator I = CalleeNode->begin(), E = CalleeNode->end();
1309 
1310  // Consider the case where CalleeNode == CallerNode.
1312  if (CalleeNode == CallerNode) {
1313  CallCache.assign(I, E);
1314  I = CallCache.begin();
1315  E = CallCache.end();
1316  }
1317 
1318  for (; I != E; ++I) {
1319  // Skip 'refererence' call records.
1320  if (!I->first)
1321  continue;
1322 
1323  const Value *OrigCall = *I->first;
1324 
1325  ValueToValueMapTy::iterator VMI = VMap.find(OrigCall);
1326  // Only copy the edge if the call was inlined!
1327  if (VMI == VMap.end() || VMI->second == nullptr)
1328  continue;
1329 
1330  // If the call was inlined, but then constant folded, there is no edge to
1331  // add. Check for this case.
1332  auto *NewCall = dyn_cast<CallBase>(VMI->second);
1333  if (!NewCall)
1334  continue;
1335 
1336  // We do not treat intrinsic calls like real function calls because we
1337  // expect them to become inline code; do not add an edge for an intrinsic.
1338  if (NewCall->getCalledFunction() &&
1339  NewCall->getCalledFunction()->isIntrinsic())
1340  continue;
1341 
1342  // Remember that this call site got inlined for the client of
1343  // InlineFunction.
1344  IFI.InlinedCalls.push_back(NewCall);
1345 
1346  // It's possible that inlining the callsite will cause it to go from an
1347  // indirect to a direct call by resolving a function pointer. If this
1348  // happens, set the callee of the new call site to a more precise
1349  // destination. This can also happen if the call graph node of the caller
1350  // was just unnecessarily imprecise.
1351  if (!I->second->getFunction())
1352  if (Function *F = NewCall->getCalledFunction()) {
1353  // Indirect call site resolved to direct call.
1354  CallerNode->addCalledFunction(NewCall, CG[F]);
1355 
1356  continue;
1357  }
1358 
1359  CallerNode->addCalledFunction(NewCall, I->second);
1360  }
1361 
1362  // Update the call graph by deleting the edge from Callee to Caller. We must
1363  // do this after the loop above in case Caller and Callee are the same.
1364  CallerNode->removeCallEdgeFor(*cast<CallBase>(&CB));
1365 }
1366 
1367 static void HandleByValArgumentInit(Type *ByValType, Value *Dst, Value *Src,
1368  Module *M, BasicBlock *InsertBlock,
1369  InlineFunctionInfo &IFI) {
1370  IRBuilder<> Builder(InsertBlock, InsertBlock->begin());
1371 
1372  Value *Size =
1373  Builder.getInt64(M->getDataLayout().getTypeStoreSize(ByValType));
1374 
1375  // Always generate a memcpy of alignment 1 here because we don't know
1376  // the alignment of the src pointer. Other optimizations can infer
1377  // better alignment.
1378  Builder.CreateMemCpy(Dst, /*DstAlign*/ Align(1), Src,
1379  /*SrcAlign*/ Align(1), Size);
1380 }
1381 
1382 /// When inlining a call site that has a byval argument,
1383 /// we have to make the implicit memcpy explicit by adding it.
1384 static Value *HandleByValArgument(Type *ByValType, Value *Arg,
1385  Instruction *TheCall,
1386  const Function *CalledFunc,
1387  InlineFunctionInfo &IFI,
1388  unsigned ByValAlignment) {
1389  assert(cast<PointerType>(Arg->getType())
1390  ->isOpaqueOrPointeeTypeMatches(ByValType));
1391  Function *Caller = TheCall->getFunction();
1392  const DataLayout &DL = Caller->getParent()->getDataLayout();
1393 
1394  // If the called function is readonly, then it could not mutate the caller's
1395  // copy of the byval'd memory. In this case, it is safe to elide the copy and
1396  // temporary.
1397  if (CalledFunc->onlyReadsMemory()) {
1398  // If the byval argument has a specified alignment that is greater than the
1399  // passed in pointer, then we either have to round up the input pointer or
1400  // give up on this transformation.
1401  if (ByValAlignment <= 1) // 0 = unspecified, 1 = no particular alignment.
1402  return Arg;
1403 
1404  AssumptionCache *AC =
1405  IFI.GetAssumptionCache ? &IFI.GetAssumptionCache(*Caller) : nullptr;
1406 
1407  // If the pointer is already known to be sufficiently aligned, or if we can
1408  // round it up to a larger alignment, then we don't need a temporary.
1409  if (getOrEnforceKnownAlignment(Arg, Align(ByValAlignment), DL, TheCall,
1410  AC) >= ByValAlignment)
1411  return Arg;
1412 
1413  // Otherwise, we have to make a memcpy to get a safe alignment. This is bad
1414  // for code quality, but rarely happens and is required for correctness.
1415  }
1416 
1417  // Create the alloca. If we have DataLayout, use nice alignment.
1418  Align Alignment(DL.getPrefTypeAlignment(ByValType));
1419 
1420  // If the byval had an alignment specified, we *must* use at least that
1421  // alignment, as it is required by the byval argument (and uses of the
1422  // pointer inside the callee).
1423  if (ByValAlignment > 0)
1424  Alignment = std::max(Alignment, Align(ByValAlignment));
1425 
1426  Value *NewAlloca =
1427  new AllocaInst(ByValType, DL.getAllocaAddrSpace(), nullptr, Alignment,
1428  Arg->getName(), &*Caller->begin()->begin());
1429  IFI.StaticAllocas.push_back(cast<AllocaInst>(NewAlloca));
1430 
1431  // Uses of the argument in the function should use our new alloca
1432  // instead.
1433  return NewAlloca;
1434 }
1435 
1436 // Check whether this Value is used by a lifetime intrinsic.
1438  for (User *U : V->users())
1439  if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(U))
1440  if (II->isLifetimeStartOrEnd())
1441  return true;
1442  return false;
1443 }
1444 
1445 // Check whether the given alloca already has
1446 // lifetime.start or lifetime.end intrinsics.
1447 static bool hasLifetimeMarkers(AllocaInst *AI) {
1448  Type *Ty = AI->getType();
1449  Type *Int8PtrTy = Type::getInt8PtrTy(Ty->getContext(),
1450  Ty->getPointerAddressSpace());
1451  if (Ty == Int8PtrTy)
1452  return isUsedByLifetimeMarker(AI);
1453 
1454  // Do a scan to find all the casts to i8*.
1455  for (User *U : AI->users()) {
1456  if (U->getType() != Int8PtrTy) continue;
1457  if (U->stripPointerCasts() != AI) continue;
1458  if (isUsedByLifetimeMarker(U))
1459  return true;
1460  }
1461  return false;
1462 }
1463 
1464 /// Return the result of AI->isStaticAlloca() if AI were moved to the entry
1465 /// block. Allocas used in inalloca calls and allocas of dynamic array size
1466 /// cannot be static.
1467 static bool allocaWouldBeStaticInEntry(const AllocaInst *AI ) {
1468  return isa<Constant>(AI->getArraySize()) && !AI->isUsedWithInAlloca();
1469 }
1470 
1471 /// Returns a DebugLoc for a new DILocation which is a clone of \p OrigDL
1472 /// inlined at \p InlinedAt. \p IANodes is an inlined-at cache.
1473 static DebugLoc inlineDebugLoc(DebugLoc OrigDL, DILocation *InlinedAt,
1474  LLVMContext &Ctx,
1476  auto IA = DebugLoc::appendInlinedAt(OrigDL, InlinedAt, Ctx, IANodes);
1477  return DILocation::get(Ctx, OrigDL.getLine(), OrigDL.getCol(),
1478  OrigDL.getScope(), IA);
1479 }
1480 
1481 /// Update inlined instructions' line numbers to
1482 /// to encode location where these instructions are inlined.
1484  Instruction *TheCall, bool CalleeHasDebugInfo) {
1485  const DebugLoc &TheCallDL = TheCall->getDebugLoc();
1486  if (!TheCallDL)
1487  return;
1488 
1489  auto &Ctx = Fn->getContext();
1490  DILocation *InlinedAtNode = TheCallDL;
1491 
1492  // Create a unique call site, not to be confused with any other call from the
1493  // same location.
1494  InlinedAtNode = DILocation::getDistinct(
1495  Ctx, InlinedAtNode->getLine(), InlinedAtNode->getColumn(),
1496  InlinedAtNode->getScope(), InlinedAtNode->getInlinedAt());
1497 
1498  // Cache the inlined-at nodes as they're built so they are reused, without
1499  // this every instruction's inlined-at chain would become distinct from each
1500  // other.
1502 
1503  // Check if we are not generating inline line tables and want to use
1504  // the call site location instead.
1505  bool NoInlineLineTables = Fn->hasFnAttribute("no-inline-line-tables");
1506 
1507  for (; FI != Fn->end(); ++FI) {
1508  for (BasicBlock::iterator BI = FI->begin(), BE = FI->end();
1509  BI != BE; ++BI) {
1510  // Loop metadata needs to be updated so that the start and end locs
1511  // reference inlined-at locations.
1512  auto updateLoopInfoLoc = [&Ctx, &InlinedAtNode,
1513  &IANodes](Metadata *MD) -> Metadata * {
1514  if (auto *Loc = dyn_cast_or_null<DILocation>(MD))
1515  return inlineDebugLoc(Loc, InlinedAtNode, Ctx, IANodes).get();
1516  return MD;
1517  };
1518  updateLoopMetadataDebugLocations(*BI, updateLoopInfoLoc);
1519 
1520  if (!NoInlineLineTables)
1521  if (DebugLoc DL = BI->getDebugLoc()) {
1522  DebugLoc IDL =
1523  inlineDebugLoc(DL, InlinedAtNode, BI->getContext(), IANodes);
1524  BI->setDebugLoc(IDL);
1525  continue;
1526  }
1527 
1528  if (CalleeHasDebugInfo && !NoInlineLineTables)
1529  continue;
1530 
1531  // If the inlined instruction has no line number, or if inline info
1532  // is not being generated, make it look as if it originates from the call
1533  // location. This is important for ((__always_inline, __nodebug__))
1534  // functions which must use caller location for all instructions in their
1535  // function body.
1536 
1537  // Don't update static allocas, as they may get moved later.
1538  if (auto *AI = dyn_cast<AllocaInst>(BI))
1540  continue;
1541 
1542  BI->setDebugLoc(TheCallDL);
1543  }
1544 
1545  // Remove debug info intrinsics if we're not keeping inline info.
1546  if (NoInlineLineTables) {
1547  BasicBlock::iterator BI = FI->begin();
1548  while (BI != FI->end()) {
1549  if (isa<DbgInfoIntrinsic>(BI)) {
1550  BI = BI->eraseFromParent();
1551  continue;
1552  }
1553  ++BI;
1554  }
1555  }
1556 
1557  }
1558 }
1559 
1560 /// Update the block frequencies of the caller after a callee has been inlined.
1561 ///
1562 /// Each block cloned into the caller has its block frequency scaled by the
1563 /// ratio of CallSiteFreq/CalleeEntryFreq. This ensures that the cloned copy of
1564 /// callee's entry block gets the same frequency as the callsite block and the
1565 /// relative frequencies of all cloned blocks remain the same after cloning.
1566 static void updateCallerBFI(BasicBlock *CallSiteBlock,
1567  const ValueToValueMapTy &VMap,
1568  BlockFrequencyInfo *CallerBFI,
1569  BlockFrequencyInfo *CalleeBFI,
1570  const BasicBlock &CalleeEntryBlock) {
1572  for (auto Entry : VMap) {
1573  if (!isa<BasicBlock>(Entry.first) || !Entry.second)
1574  continue;
1575  auto *OrigBB = cast<BasicBlock>(Entry.first);
1576  auto *ClonedBB = cast<BasicBlock>(Entry.second);
1577  uint64_t Freq = CalleeBFI->getBlockFreq(OrigBB).getFrequency();
1578  if (!ClonedBBs.insert(ClonedBB).second) {
1579  // Multiple blocks in the callee might get mapped to one cloned block in
1580  // the caller since we prune the callee as we clone it. When that happens,
1581  // we want to use the maximum among the original blocks' frequencies.
1582  uint64_t NewFreq = CallerBFI->getBlockFreq(ClonedBB).getFrequency();
1583  if (NewFreq > Freq)
1584  Freq = NewFreq;
1585  }
1586  CallerBFI->setBlockFreq(ClonedBB, Freq);
1587  }
1588  BasicBlock *EntryClone = cast<BasicBlock>(VMap.lookup(&CalleeEntryBlock));
1589  CallerBFI->setBlockFreqAndScale(
1590  EntryClone, CallerBFI->getBlockFreq(CallSiteBlock).getFrequency(),
1591  ClonedBBs);
1592 }
1593 
1594 /// Update the branch metadata for cloned call instructions.
1595 static void updateCallProfile(Function *Callee, const ValueToValueMapTy &VMap,
1596  const ProfileCount &CalleeEntryCount,
1597  const CallBase &TheCall, ProfileSummaryInfo *PSI,
1598  BlockFrequencyInfo *CallerBFI) {
1599  if (CalleeEntryCount.isSynthetic() || CalleeEntryCount.getCount() < 1)
1600  return;
1601  auto CallSiteCount = PSI ? PSI->getProfileCount(TheCall, CallerBFI) : None;
1602  int64_t CallCount =
1603  std::min(CallSiteCount.value_or(0), CalleeEntryCount.getCount());
1604  updateProfileCallee(Callee, -CallCount, &VMap);
1605 }
1606 
1608  Function *Callee, int64_t EntryDelta,
1610  auto CalleeCount = Callee->getEntryCount();
1611  if (!CalleeCount)
1612  return;
1613 
1614  const uint64_t PriorEntryCount = CalleeCount->getCount();
1615 
1616  // Since CallSiteCount is an estimate, it could exceed the original callee
1617  // count and has to be set to 0 so guard against underflow.
1618  const uint64_t NewEntryCount =
1619  (EntryDelta < 0 && static_cast<uint64_t>(-EntryDelta) > PriorEntryCount)
1620  ? 0
1621  : PriorEntryCount + EntryDelta;
1622 
1623  // During inlining ?
1624  if (VMap) {
1625  uint64_t CloneEntryCount = PriorEntryCount - NewEntryCount;
1626  for (auto Entry : *VMap)
1627  if (isa<CallInst>(Entry.first))
1628  if (auto *CI = dyn_cast_or_null<CallInst>(Entry.second))
1629  CI->updateProfWeight(CloneEntryCount, PriorEntryCount);
1630  }
1631 
1632  if (EntryDelta) {
1633  Callee->setEntryCount(NewEntryCount);
1634 
1635  for (BasicBlock &BB : *Callee)
1636  // No need to update the callsite if it is pruned during inlining.
1637  if (!VMap || VMap->count(&BB))
1638  for (Instruction &I : BB)
1639  if (CallInst *CI = dyn_cast<CallInst>(&I))
1640  CI->updateProfWeight(NewEntryCount, PriorEntryCount);
1641  }
1642 }
1643 
1644 /// An operand bundle "clang.arc.attachedcall" on a call indicates the call
1645 /// result is implicitly consumed by a call to retainRV or claimRV immediately
1646 /// after the call. This function inlines the retainRV/claimRV calls.
1647 ///
1648 /// There are three cases to consider:
1649 ///
1650 /// 1. If there is a call to autoreleaseRV that takes a pointer to the returned
1651 /// object in the callee return block, the autoreleaseRV call and the
1652 /// retainRV/claimRV call in the caller cancel out. If the call in the caller
1653 /// is a claimRV call, a call to objc_release is emitted.
1654 ///
1655 /// 2. If there is a call in the callee return block that doesn't have operand
1656 /// bundle "clang.arc.attachedcall", the operand bundle on the original call
1657 /// is transferred to the call in the callee.
1658 ///
1659 /// 3. Otherwise, a call to objc_retain is inserted if the call in the caller is
1660 /// a retainRV call.
1661 static void
1663  const SmallVectorImpl<ReturnInst *> &Returns) {
1664  Module *Mod = CB.getModule();
1665  assert(objcarc::isRetainOrClaimRV(RVCallKind) && "unexpected ARC function");
1666  bool IsRetainRV = RVCallKind == objcarc::ARCInstKind::RetainRV,
1667  IsUnsafeClaimRV = !IsRetainRV;
1668 
1669  for (auto *RI : Returns) {
1670  Value *RetOpnd = objcarc::GetRCIdentityRoot(RI->getOperand(0));
1671  bool InsertRetainCall = IsRetainRV;
1673 
1674  // Walk backwards through the basic block looking for either a matching
1675  // autoreleaseRV call or an unannotated call.
1676  auto InstRange = llvm::make_range(++(RI->getIterator().getReverse()),
1677  RI->getParent()->rend());
1678  for (Instruction &I : llvm::make_early_inc_range(InstRange)) {
1679  // Ignore casts.
1680  if (isa<CastInst>(I))
1681  continue;
1682 
1683  if (auto *II = dyn_cast<IntrinsicInst>(&I)) {
1684  if (II->getIntrinsicID() != Intrinsic::objc_autoreleaseReturnValue ||
1685  !II->hasNUses(0) ||
1686  objcarc::GetRCIdentityRoot(II->getOperand(0)) != RetOpnd)
1687  break;
1688 
1689  // If we've found a matching authoreleaseRV call:
1690  // - If claimRV is attached to the call, insert a call to objc_release
1691  // and erase the autoreleaseRV call.
1692  // - If retainRV is attached to the call, just erase the autoreleaseRV
1693  // call.
1694  if (IsUnsafeClaimRV) {
1695  Builder.SetInsertPoint(II);
1696  Function *IFn =
1697  Intrinsic::getDeclaration(Mod, Intrinsic::objc_release);
1698  Value *BC = Builder.CreateBitCast(RetOpnd, IFn->getArg(0)->getType());
1699  Builder.CreateCall(IFn, BC, "");
1700  }
1701  II->eraseFromParent();
1702  InsertRetainCall = false;
1703  break;
1704  }
1705 
1706  auto *CI = dyn_cast<CallInst>(&I);
1707 
1708  if (!CI)
1709  break;
1710 
1711  if (objcarc::GetRCIdentityRoot(CI) != RetOpnd ||
1713  break;
1714 
1715  // If we've found an unannotated call that defines RetOpnd, add a
1716  // "clang.arc.attachedcall" operand bundle.
1717  Value *BundleArgs[] = {*objcarc::getAttachedARCFunction(&CB)};
1718  OperandBundleDef OB("clang.arc.attachedcall", BundleArgs);
1719  auto *NewCall = CallBase::addOperandBundle(
1721  NewCall->copyMetadata(*CI);
1722  CI->replaceAllUsesWith(NewCall);
1723  CI->eraseFromParent();
1724  InsertRetainCall = false;
1725  break;
1726  }
1727 
1728  if (InsertRetainCall) {
1729  // The retainRV is attached to the call and we've failed to find a
1730  // matching autoreleaseRV or an annotated call in the callee. Emit a call
1731  // to objc_retain.
1732  Builder.SetInsertPoint(RI);
1733  Function *IFn = Intrinsic::getDeclaration(Mod, Intrinsic::objc_retain);
1734  Value *BC = Builder.CreateBitCast(RetOpnd, IFn->getArg(0)->getType());
1735  Builder.CreateCall(IFn, BC, "");
1736  }
1737  }
1738 }
1739 
1740 /// This function inlines the called function into the basic block of the
1741 /// caller. This returns false if it is not possible to inline this call.
1742 /// The program is still in a well defined state if this occurs though.
1743 ///
1744 /// Note that this only does one level of inlining. For example, if the
1745 /// instruction 'call B' is inlined, and 'B' calls 'C', then the call to 'C' now
1746 /// exists in the instruction stream. Similarly this will inline a recursive
1747 /// function by one level.
1749  AAResults *CalleeAAR,
1750  bool InsertLifetime,
1751  Function *ForwardVarArgsTo) {
1752  assert(CB.getParent() && CB.getFunction() && "Instruction not in function!");
1753 
1754  // FIXME: we don't inline callbr yet.
1755  if (isa<CallBrInst>(CB))
1756  return InlineResult::failure("We don't inline callbr yet.");
1757 
1758  // If IFI has any state in it, zap it before we fill it in.
1759  IFI.reset();
1760 
1761  Function *CalledFunc = CB.getCalledFunction();
1762  if (!CalledFunc || // Can't inline external function or indirect
1763  CalledFunc->isDeclaration()) // call!
1764  return InlineResult::failure("external or indirect");
1765 
1766  // The inliner does not know how to inline through calls with operand bundles
1767  // in general ...
1768  if (CB.hasOperandBundles()) {
1769  for (int i = 0, e = CB.getNumOperandBundles(); i != e; ++i) {
1771  // ... but it knows how to inline through "deopt" operand bundles ...
1772  if (Tag == LLVMContext::OB_deopt)
1773  continue;
1774  // ... and "funclet" operand bundles.
1776  continue;
1778  continue;
1779 
1780  return InlineResult::failure("unsupported operand bundle");
1781  }
1782  }
1783 
1784  // If the call to the callee cannot throw, set the 'nounwind' flag on any
1785  // calls that we inline.
1786  bool MarkNoUnwind = CB.doesNotThrow();
1787 
1788  BasicBlock *OrigBB = CB.getParent();
1789  Function *Caller = OrigBB->getParent();
1790 
1791  // Do not inline strictfp function into non-strictfp one. It would require
1792  // conversion of all FP operations in host function to constrained intrinsics.
1793  if (CalledFunc->getAttributes().hasFnAttr(Attribute::StrictFP) &&
1794  !Caller->getAttributes().hasFnAttr(Attribute::StrictFP)) {
1795  return InlineResult::failure("incompatible strictfp attributes");
1796  }
1797 
1798  // GC poses two hazards to inlining, which only occur when the callee has GC:
1799  // 1. If the caller has no GC, then the callee's GC must be propagated to the
1800  // caller.
1801  // 2. If the caller has a differing GC, it is invalid to inline.
1802  if (CalledFunc->hasGC()) {
1803  if (!Caller->hasGC())
1804  Caller->setGC(CalledFunc->getGC());
1805  else if (CalledFunc->getGC() != Caller->getGC())
1806  return InlineResult::failure("incompatible GC");
1807  }
1808 
1809  // Get the personality function from the callee if it contains a landing pad.
1810  Constant *CalledPersonality =
1811  CalledFunc->hasPersonalityFn()
1812  ? CalledFunc->getPersonalityFn()->stripPointerCasts()
1813  : nullptr;
1814 
1815  // Find the personality function used by the landing pads of the caller. If it
1816  // exists, then check to see that it matches the personality function used in
1817  // the callee.
1818  Constant *CallerPersonality =
1819  Caller->hasPersonalityFn()
1820  ? Caller->getPersonalityFn()->stripPointerCasts()
1821  : nullptr;
1822  if (CalledPersonality) {
1823  if (!CallerPersonality)
1824  Caller->setPersonalityFn(CalledPersonality);
1825  // If the personality functions match, then we can perform the
1826  // inlining. Otherwise, we can't inline.
1827  // TODO: This isn't 100% true. Some personality functions are proper
1828  // supersets of others and can be used in place of the other.
1829  else if (CalledPersonality != CallerPersonality)
1830  return InlineResult::failure("incompatible personality");
1831  }
1832 
1833  // We need to figure out which funclet the callsite was in so that we may
1834  // properly nest the callee.
1835  Instruction *CallSiteEHPad = nullptr;
1836  if (CallerPersonality) {
1837  EHPersonality Personality = classifyEHPersonality(CallerPersonality);
1838  if (isScopedEHPersonality(Personality)) {
1839  Optional<OperandBundleUse> ParentFunclet =
1841  if (ParentFunclet)
1842  CallSiteEHPad = cast<FuncletPadInst>(ParentFunclet->Inputs.front());
1843 
1844  // OK, the inlining site is legal. What about the target function?
1845 
1846  if (CallSiteEHPad) {
1847  if (Personality == EHPersonality::MSVC_CXX) {
1848  // The MSVC personality cannot tolerate catches getting inlined into
1849  // cleanup funclets.
1850  if (isa<CleanupPadInst>(CallSiteEHPad)) {
1851  // Ok, the call site is within a cleanuppad. Let's check the callee
1852  // for catchpads.
1853  for (const BasicBlock &CalledBB : *CalledFunc) {
1854  if (isa<CatchSwitchInst>(CalledBB.getFirstNonPHI()))
1855  return InlineResult::failure("catch in cleanup funclet");
1856  }
1857  }
1858  } else if (isAsynchronousEHPersonality(Personality)) {
1859  // SEH is even less tolerant, there may not be any sort of exceptional
1860  // funclet in the callee.
1861  for (const BasicBlock &CalledBB : *CalledFunc) {
1862  if (CalledBB.isEHPad())
1863  return InlineResult::failure("SEH in cleanup funclet");
1864  }
1865  }
1866  }
1867  }
1868  }
1869 
1870  // Determine if we are dealing with a call in an EHPad which does not unwind
1871  // to caller.
1872  bool EHPadForCallUnwindsLocally = false;
1873  if (CallSiteEHPad && isa<CallInst>(CB)) {
1874  UnwindDestMemoTy FuncletUnwindMap;
1875  Value *CallSiteUnwindDestToken =
1876  getUnwindDestToken(CallSiteEHPad, FuncletUnwindMap);
1877 
1878  EHPadForCallUnwindsLocally =
1879  CallSiteUnwindDestToken &&
1880  !isa<ConstantTokenNone>(CallSiteUnwindDestToken);
1881  }
1882 
1883  // Get an iterator to the last basic block in the function, which will have
1884  // the new function inlined after it.
1885  Function::iterator LastBlock = --Caller->end();
1886 
1887  // Make sure to capture all of the return instructions from the cloned
1888  // function.
1890  ClonedCodeInfo InlinedFunctionInfo;
1891  Function::iterator FirstNewBlock;
1892 
1893  { // Scope to destroy VMap after cloning.
1894  ValueToValueMapTy VMap;
1895  struct ByValInit {
1896  Value *Dst;
1897  Value *Src;
1898  Type *Ty;
1899  };
1900  // Keep a list of pair (dst, src) to emit byval initializations.
1901  SmallVector<ByValInit, 4> ByValInits;
1902 
1903  // When inlining a function that contains noalias scope metadata,
1904  // this metadata needs to be cloned so that the inlined blocks
1905  // have different "unique scopes" at every call site.
1906  // Track the metadata that must be cloned. Do this before other changes to
1907  // the function, so that we do not get in trouble when inlining caller ==
1908  // callee.
1909  ScopedAliasMetadataDeepCloner SAMetadataCloner(CB.getCalledFunction());
1910 
1911  auto &DL = Caller->getParent()->getDataLayout();
1912 
1913  // Calculate the vector of arguments to pass into the function cloner, which
1914  // matches up the formal to the actual argument values.
1915  auto AI = CB.arg_begin();
1916  unsigned ArgNo = 0;
1917  for (Function::arg_iterator I = CalledFunc->arg_begin(),
1918  E = CalledFunc->arg_end(); I != E; ++I, ++AI, ++ArgNo) {
1919  Value *ActualArg = *AI;
1920 
1921  // When byval arguments actually inlined, we need to make the copy implied
1922  // by them explicit. However, we don't do this if the callee is readonly
1923  // or readnone, because the copy would be unneeded: the callee doesn't
1924  // modify the struct.
1925  if (CB.isByValArgument(ArgNo)) {
1926  ActualArg = HandleByValArgument(CB.getParamByValType(ArgNo), ActualArg,
1927  &CB, CalledFunc, IFI,
1928  CalledFunc->getParamAlignment(ArgNo));
1929  if (ActualArg != *AI)
1930  ByValInits.push_back(
1931  {ActualArg, (Value *)*AI, CB.getParamByValType(ArgNo)});
1932  }
1933 
1934  VMap[&*I] = ActualArg;
1935  }
1936 
1937  // TODO: Remove this when users have been updated to the assume bundles.
1938  // Add alignment assumptions if necessary. We do this before the inlined
1939  // instructions are actually cloned into the caller so that we can easily
1940  // check what will be known at the start of the inlined code.
1941  AddAlignmentAssumptions(CB, IFI);
1942 
1943  AssumptionCache *AC =
1944  IFI.GetAssumptionCache ? &IFI.GetAssumptionCache(*Caller) : nullptr;
1945 
1946  /// Preserve all attributes on of the call and its parameters.
1947  salvageKnowledge(&CB, AC);
1948 
1949  // We want the inliner to prune the code as it copies. We would LOVE to
1950  // have no dead or constant instructions leftover after inlining occurs
1951  // (which can happen, e.g., because an argument was constant), but we'll be
1952  // happy with whatever the cloner can do.
1953  CloneAndPruneFunctionInto(Caller, CalledFunc, VMap,
1954  /*ModuleLevelChanges=*/false, Returns, ".i",
1955  &InlinedFunctionInfo);
1956  // Remember the first block that is newly cloned over.
1957  FirstNewBlock = LastBlock; ++FirstNewBlock;
1958 
1959  // Insert retainRV/clainRV runtime calls.
1961  if (RVCallKind != objcarc::ARCInstKind::None)
1962  inlineRetainOrClaimRVCalls(CB, RVCallKind, Returns);
1963 
1964  // Updated caller/callee profiles only when requested. For sample loader
1965  // inlining, the context-sensitive inlinee profile doesn't need to be
1966  // subtracted from callee profile, and the inlined clone also doesn't need
1967  // to be scaled based on call site count.
1968  if (IFI.UpdateProfile) {
1969  if (IFI.CallerBFI != nullptr && IFI.CalleeBFI != nullptr)
1970  // Update the BFI of blocks cloned into the caller.
1971  updateCallerBFI(OrigBB, VMap, IFI.CallerBFI, IFI.CalleeBFI,
1972  CalledFunc->front());
1973 
1974  if (auto Profile = CalledFunc->getEntryCount())
1975  updateCallProfile(CalledFunc, VMap, *Profile, CB, IFI.PSI,
1976  IFI.CallerBFI);
1977  }
1978 
1979  // Inject byval arguments initialization.
1980  for (ByValInit &Init : ByValInits)
1981  HandleByValArgumentInit(Init.Ty, Init.Dst, Init.Src, Caller->getParent(),
1982  &*FirstNewBlock, IFI);
1983 
1984  Optional<OperandBundleUse> ParentDeopt =
1986  if (ParentDeopt) {
1988 
1989  for (auto &VH : InlinedFunctionInfo.OperandBundleCallSites) {
1990  CallBase *ICS = dyn_cast_or_null<CallBase>(VH);
1991  if (!ICS)
1992  continue; // instruction was DCE'd or RAUW'ed to undef
1993 
1994  OpDefs.clear();
1995 
1996  OpDefs.reserve(ICS->getNumOperandBundles());
1997 
1998  for (unsigned COBi = 0, COBe = ICS->getNumOperandBundles(); COBi < COBe;
1999  ++COBi) {
2000  auto ChildOB = ICS->getOperandBundleAt(COBi);
2001  if (ChildOB.getTagID() != LLVMContext::OB_deopt) {
2002  // If the inlined call has other operand bundles, let them be
2003  OpDefs.emplace_back(ChildOB);
2004  continue;
2005  }
2006 
2007  // It may be useful to separate this logic (of handling operand
2008  // bundles) out to a separate "policy" component if this gets crowded.
2009  // Prepend the parent's deoptimization continuation to the newly
2010  // inlined call's deoptimization continuation.
2011  std::vector<Value *> MergedDeoptArgs;
2012  MergedDeoptArgs.reserve(ParentDeopt->Inputs.size() +
2013  ChildOB.Inputs.size());
2014 
2015  llvm::append_range(MergedDeoptArgs, ParentDeopt->Inputs);
2016  llvm::append_range(MergedDeoptArgs, ChildOB.Inputs);
2017 
2018  OpDefs.emplace_back("deopt", std::move(MergedDeoptArgs));
2019  }
2020 
2021  Instruction *NewI = CallBase::Create(ICS, OpDefs, ICS);
2022 
2023  // Note: the RAUW does the appropriate fixup in VMap, so we need to do
2024  // this even if the call returns void.
2025  ICS->replaceAllUsesWith(NewI);
2026 
2027  VH = nullptr;
2028  ICS->eraseFromParent();
2029  }
2030  }
2031 
2032  // Update the callgraph if requested.
2033  if (IFI.CG)
2034  UpdateCallGraphAfterInlining(CB, FirstNewBlock, VMap, IFI);
2035 
2036  // For 'nodebug' functions, the associated DISubprogram is always null.
2037  // Conservatively avoid propagating the callsite debug location to
2038  // instructions inlined from a function whose DISubprogram is not null.
2039  fixupLineNumbers(Caller, FirstNewBlock, &CB,
2040  CalledFunc->getSubprogram() != nullptr);
2041 
2042  // Now clone the inlined noalias scope metadata.
2043  SAMetadataCloner.clone();
2044  SAMetadataCloner.remap(FirstNewBlock, Caller->end());
2045 
2046  // Add noalias metadata if necessary.
2047  AddAliasScopeMetadata(CB, VMap, DL, CalleeAAR, InlinedFunctionInfo);
2048 
2049  // Clone return attributes on the callsite into the calls within the inlined
2050  // function which feed into its return value.
2051  AddReturnAttributes(CB, VMap);
2052 
2053  // Propagate metadata on the callsite if necessary.
2054  PropagateCallSiteMetadata(CB, FirstNewBlock, Caller->end());
2055 
2056  // Register any cloned assumptions.
2057  if (IFI.GetAssumptionCache)
2058  for (BasicBlock &NewBlock :
2059  make_range(FirstNewBlock->getIterator(), Caller->end()))
2060  for (Instruction &I : NewBlock)
2061  if (auto *II = dyn_cast<AssumeInst>(&I))
2062  IFI.GetAssumptionCache(*Caller).registerAssumption(II);
2063  }
2064 
2065  // If there are any alloca instructions in the block that used to be the entry
2066  // block for the callee, move them to the entry block of the caller. First
2067  // calculate which instruction they should be inserted before. We insert the
2068  // instructions at the end of the current alloca list.
2069  {
2070  BasicBlock::iterator InsertPoint = Caller->begin()->begin();
2071  for (BasicBlock::iterator I = FirstNewBlock->begin(),
2072  E = FirstNewBlock->end(); I != E; ) {
2073  AllocaInst *AI = dyn_cast<AllocaInst>(I++);
2074  if (!AI) continue;
2075 
2076  // If the alloca is now dead, remove it. This often occurs due to code
2077  // specialization.
2078  if (AI->use_empty()) {
2079  AI->eraseFromParent();
2080  continue;
2081  }
2082 
2083  if (!allocaWouldBeStaticInEntry(AI))
2084  continue;
2085 
2086  // Keep track of the static allocas that we inline into the caller.
2087  IFI.StaticAllocas.push_back(AI);
2088 
2089  // Scan for the block of allocas that we can move over, and move them
2090  // all at once.
2091  while (isa<AllocaInst>(I) &&
2092  !cast<AllocaInst>(I)->use_empty() &&
2093  allocaWouldBeStaticInEntry(cast<AllocaInst>(I))) {
2094  IFI.StaticAllocas.push_back(cast<AllocaInst>(I));
2095  ++I;
2096  }
2097 
2098  // Transfer all of the allocas over in a block. Using splice means
2099  // that the instructions aren't removed from the symbol table, then
2100  // reinserted.
2101  Caller->getEntryBlock().getInstList().splice(
2102  InsertPoint, FirstNewBlock->getInstList(), AI->getIterator(), I);
2103  }
2104  }
2105 
2106  SmallVector<Value*,4> VarArgsToForward;
2107  SmallVector<AttributeSet, 4> VarArgsAttrs;
2108  for (unsigned i = CalledFunc->getFunctionType()->getNumParams();
2109  i < CB.arg_size(); i++) {
2110  VarArgsToForward.push_back(CB.getArgOperand(i));
2111  VarArgsAttrs.push_back(CB.getAttributes().getParamAttrs(i));
2112  }
2113 
2114  bool InlinedMustTailCalls = false, InlinedDeoptimizeCalls = false;
2115  if (InlinedFunctionInfo.ContainsCalls) {
2116  CallInst::TailCallKind CallSiteTailKind = CallInst::TCK_None;
2117  if (CallInst *CI = dyn_cast<CallInst>(&CB))
2118  CallSiteTailKind = CI->getTailCallKind();
2119 
2120  // For inlining purposes, the "notail" marker is the same as no marker.
2121  if (CallSiteTailKind == CallInst::TCK_NoTail)
2122  CallSiteTailKind = CallInst::TCK_None;
2123 
2124  for (Function::iterator BB = FirstNewBlock, E = Caller->end(); BB != E;
2125  ++BB) {
2127  CallInst *CI = dyn_cast<CallInst>(&I);
2128  if (!CI)
2129  continue;
2130 
2131  // Forward varargs from inlined call site to calls to the
2132  // ForwardVarArgsTo function, if requested, and to musttail calls.
2133  if (!VarArgsToForward.empty() &&
2134  ((ForwardVarArgsTo &&
2135  CI->getCalledFunction() == ForwardVarArgsTo) ||
2136  CI->isMustTailCall())) {
2137  // Collect attributes for non-vararg parameters.
2140  if (!Attrs.isEmpty() || !VarArgsAttrs.empty()) {
2141  for (unsigned ArgNo = 0;
2142  ArgNo < CI->getFunctionType()->getNumParams(); ++ArgNo)
2143  ArgAttrs.push_back(Attrs.getParamAttrs(ArgNo));
2144  }
2145 
2146  // Add VarArg attributes.
2147  ArgAttrs.append(VarArgsAttrs.begin(), VarArgsAttrs.end());
2148  Attrs = AttributeList::get(CI->getContext(), Attrs.getFnAttrs(),
2149  Attrs.getRetAttrs(), ArgAttrs);
2150  // Add VarArgs to existing parameters.
2151  SmallVector<Value *, 6> Params(CI->args());
2152  Params.append(VarArgsToForward.begin(), VarArgsToForward.end());
2153  CallInst *NewCI = CallInst::Create(
2154  CI->getFunctionType(), CI->getCalledOperand(), Params, "", CI);
2155  NewCI->setDebugLoc(CI->getDebugLoc());
2156  NewCI->setAttributes(Attrs);
2157  NewCI->setCallingConv(CI->getCallingConv());
2158  CI->replaceAllUsesWith(NewCI);
2159  CI->eraseFromParent();
2160  CI = NewCI;
2161  }
2162 
2163  if (Function *F = CI->getCalledFunction())
2164  InlinedDeoptimizeCalls |=
2165  F->getIntrinsicID() == Intrinsic::experimental_deoptimize;
2166 
2167  // We need to reduce the strength of any inlined tail calls. For
2168  // musttail, we have to avoid introducing potential unbounded stack
2169  // growth. For example, if functions 'f' and 'g' are mutually recursive
2170  // with musttail, we can inline 'g' into 'f' so long as we preserve
2171  // musttail on the cloned call to 'f'. If either the inlined call site
2172  // or the cloned call site is *not* musttail, the program already has
2173  // one frame of stack growth, so it's safe to remove musttail. Here is
2174  // a table of example transformations:
2175  //
2176  // f -> musttail g -> musttail f ==> f -> musttail f
2177  // f -> musttail g -> tail f ==> f -> tail f
2178  // f -> g -> musttail f ==> f -> f
2179  // f -> g -> tail f ==> f -> f
2180  //
2181  // Inlined notail calls should remain notail calls.
2182  CallInst::TailCallKind ChildTCK = CI->getTailCallKind();
2183  if (ChildTCK != CallInst::TCK_NoTail)
2184  ChildTCK = std::min(CallSiteTailKind, ChildTCK);
2185  CI->setTailCallKind(ChildTCK);
2186  InlinedMustTailCalls |= CI->isMustTailCall();
2187 
2188  // Calls inlined through a 'nounwind' call site should be marked
2189  // 'nounwind'.
2190  if (MarkNoUnwind)
2191  CI->setDoesNotThrow();
2192  }
2193  }
2194  }
2195 
2196  // Leave lifetime markers for the static alloca's, scoping them to the
2197  // function we just inlined.
2198  // We need to insert lifetime intrinsics even at O0 to avoid invalid
2199  // access caused by multithreaded coroutines. The check
2200  // `Caller->isPresplitCoroutine()` would affect AlwaysInliner at O0 only.
2201  if ((InsertLifetime || Caller->isPresplitCoroutine()) &&
2202  !IFI.StaticAllocas.empty()) {
2203  IRBuilder<> builder(&FirstNewBlock->front());
2204  for (unsigned ai = 0, ae = IFI.StaticAllocas.size(); ai != ae; ++ai) {
2205  AllocaInst *AI = IFI.StaticAllocas[ai];
2206  // Don't mark swifterror allocas. They can't have bitcast uses.
2207  if (AI->isSwiftError())
2208  continue;
2209 
2210  // If the alloca is already scoped to something smaller than the whole
2211  // function then there's no need to add redundant, less accurate markers.
2212  if (hasLifetimeMarkers(AI))
2213  continue;
2214 
2215  // Try to determine the size of the allocation.
2216  ConstantInt *AllocaSize = nullptr;
2217  if (ConstantInt *AIArraySize =
2218  dyn_cast<ConstantInt>(AI->getArraySize())) {
2219  auto &DL = Caller->getParent()->getDataLayout();
2220  Type *AllocaType = AI->getAllocatedType();
2221  TypeSize AllocaTypeSize = DL.getTypeAllocSize(AllocaType);
2222  uint64_t AllocaArraySize = AIArraySize->getLimitedValue();
2223 
2224  // Don't add markers for zero-sized allocas.
2225  if (AllocaArraySize == 0)
2226  continue;
2227 
2228  // Check that array size doesn't saturate uint64_t and doesn't
2229  // overflow when it's multiplied by type size.
2230  if (!AllocaTypeSize.isScalable() &&
2231  AllocaArraySize != std::numeric_limits<uint64_t>::max() &&
2232  std::numeric_limits<uint64_t>::max() / AllocaArraySize >=
2233  AllocaTypeSize.getFixedSize()) {
2234  AllocaSize = ConstantInt::get(Type::getInt64Ty(AI->getContext()),
2235  AllocaArraySize * AllocaTypeSize);
2236  }
2237  }
2238 
2239  builder.CreateLifetimeStart(AI, AllocaSize);
2240  for (ReturnInst *RI : Returns) {
2241  // Don't insert llvm.lifetime.end calls between a musttail or deoptimize
2242  // call and a return. The return kills all local allocas.
2243  if (InlinedMustTailCalls &&
2245  continue;
2246  if (InlinedDeoptimizeCalls &&
2248  continue;
2249  IRBuilder<>(RI).CreateLifetimeEnd(AI, AllocaSize);
2250  }
2251  }
2252  }
2253 
2254  // If the inlined code contained dynamic alloca instructions, wrap the inlined
2255  // code with llvm.stacksave/llvm.stackrestore intrinsics.
2256  if (InlinedFunctionInfo.ContainsDynamicAllocas) {
2257  Module *M = Caller->getParent();
2258  // Get the two intrinsics we care about.
2259  Function *StackSave = Intrinsic::getDeclaration(M, Intrinsic::stacksave);
2260  Function *StackRestore=Intrinsic::getDeclaration(M,Intrinsic::stackrestore);
2261 
2262  // Insert the llvm.stacksave.
2263  CallInst *SavedPtr = IRBuilder<>(&*FirstNewBlock, FirstNewBlock->begin())
2264  .CreateCall(StackSave, {}, "savedstack");
2265 
2266  // Insert a call to llvm.stackrestore before any return instructions in the
2267  // inlined function.
2268  for (ReturnInst *RI : Returns) {
2269  // Don't insert llvm.stackrestore calls between a musttail or deoptimize
2270  // call and a return. The return will restore the stack pointer.
2271  if (InlinedMustTailCalls && RI->getParent()->getTerminatingMustTailCall())
2272  continue;
2273  if (InlinedDeoptimizeCalls && RI->getParent()->getTerminatingDeoptimizeCall())
2274  continue;
2275  IRBuilder<>(RI).CreateCall(StackRestore, SavedPtr);
2276  }
2277  }
2278 
2279  // If we are inlining for an invoke instruction, we must make sure to rewrite
2280  // any call instructions into invoke instructions. This is sensitive to which
2281  // funclet pads were top-level in the inlinee, so must be done before
2282  // rewriting the "parent pad" links.
2283  if (auto *II = dyn_cast<InvokeInst>(&CB)) {
2284  BasicBlock *UnwindDest = II->getUnwindDest();
2285  Instruction *FirstNonPHI = UnwindDest->getFirstNonPHI();
2286  if (isa<LandingPadInst>(FirstNonPHI)) {
2287  HandleInlinedLandingPad(II, &*FirstNewBlock, InlinedFunctionInfo);
2288  } else {
2289  HandleInlinedEHPad(II, &*FirstNewBlock, InlinedFunctionInfo);
2290  }
2291  }
2292 
2293  // Update the lexical scopes of the new funclets and callsites.
2294  // Anything that had 'none' as its parent is now nested inside the callsite's
2295  // EHPad.
2296 
2297  if (CallSiteEHPad) {
2298  for (Function::iterator BB = FirstNewBlock->getIterator(),
2299  E = Caller->end();
2300  BB != E; ++BB) {
2301  // Add bundle operands to any top-level call sites.
2303  for (Instruction &II : llvm::make_early_inc_range(*BB)) {
2304  CallBase *I = dyn_cast<CallBase>(&II);
2305  if (!I)
2306  continue;
2307 
2308  // Skip call sites which are nounwind intrinsics.
2309  auto *CalledFn =
2310  dyn_cast<Function>(I->getCalledOperand()->stripPointerCasts());
2311  if (CalledFn && CalledFn->isIntrinsic() && I->doesNotThrow())
2312  continue;
2313 
2314  // Skip call sites which already have a "funclet" bundle.
2315  if (I->getOperandBundle(LLVMContext::OB_funclet))
2316  continue;
2317 
2318  I->getOperandBundlesAsDefs(OpBundles);
2319  OpBundles.emplace_back("funclet", CallSiteEHPad);
2320 
2321  Instruction *NewInst = CallBase::Create(I, OpBundles, I);
2322  NewInst->takeName(I);
2323  I->replaceAllUsesWith(NewInst);
2324  I->eraseFromParent();
2325 
2326  OpBundles.clear();
2327  }
2328 
2329  // It is problematic if the inlinee has a cleanupret which unwinds to
2330  // caller and we inline it into a call site which doesn't unwind but into
2331  // an EH pad that does. Such an edge must be dynamically unreachable.
2332  // As such, we replace the cleanupret with unreachable.
2333  if (auto *CleanupRet = dyn_cast<CleanupReturnInst>(BB->getTerminator()))
2334  if (CleanupRet->unwindsToCaller() && EHPadForCallUnwindsLocally)
2335  changeToUnreachable(CleanupRet);
2336 
2337  Instruction *I = BB->getFirstNonPHI();
2338  if (!I->isEHPad())
2339  continue;
2340 
2341  if (auto *CatchSwitch = dyn_cast<CatchSwitchInst>(I)) {
2342  if (isa<ConstantTokenNone>(CatchSwitch->getParentPad()))
2343  CatchSwitch->setParentPad(CallSiteEHPad);
2344  } else {
2345  auto *FPI = cast<FuncletPadInst>(I);
2346  if (isa<ConstantTokenNone>(FPI->getParentPad()))
2347  FPI->setParentPad(CallSiteEHPad);
2348  }
2349  }
2350  }
2351 
2352  if (InlinedDeoptimizeCalls) {
2353  // We need to at least remove the deoptimizing returns from the Return set,
2354  // so that the control flow from those returns does not get merged into the
2355  // caller (but terminate it instead). If the caller's return type does not
2356  // match the callee's return type, we also need to change the return type of
2357  // the intrinsic.
2358  if (Caller->getReturnType() == CB.getType()) {
2359  llvm::erase_if(Returns, [](ReturnInst *RI) {
2360  return RI->getParent()->getTerminatingDeoptimizeCall() != nullptr;
2361  });
2362  } else {
2363  SmallVector<ReturnInst *, 8> NormalReturns;
2364  Function *NewDeoptIntrinsic = Intrinsic::getDeclaration(
2365  Caller->getParent(), Intrinsic::experimental_deoptimize,
2366  {Caller->getReturnType()});
2367 
2368  for (ReturnInst *RI : Returns) {
2369  CallInst *DeoptCall = RI->getParent()->getTerminatingDeoptimizeCall();
2370  if (!DeoptCall) {
2371  NormalReturns.push_back(RI);
2372  continue;
2373  }
2374 
2375  // The calling convention on the deoptimize call itself may be bogus,
2376  // since the code we're inlining may have undefined behavior (and may
2377  // never actually execute at runtime); but all
2378  // @llvm.experimental.deoptimize declarations have to have the same
2379  // calling convention in a well-formed module.
2380  auto CallingConv = DeoptCall->getCalledFunction()->getCallingConv();
2381  NewDeoptIntrinsic->setCallingConv(CallingConv);
2382  auto *CurBB = RI->getParent();
2383  RI->eraseFromParent();
2384 
2385  SmallVector<Value *, 4> CallArgs(DeoptCall->args());
2386 
2388  DeoptCall->getOperandBundlesAsDefs(OpBundles);
2389  auto DeoptAttributes = DeoptCall->getAttributes();
2390  DeoptCall->eraseFromParent();
2391  assert(!OpBundles.empty() &&
2392  "Expected at least the deopt operand bundle");
2393 
2394  IRBuilder<> Builder(CurBB);
2395  CallInst *NewDeoptCall =
2396  Builder.CreateCall(NewDeoptIntrinsic, CallArgs, OpBundles);
2397  NewDeoptCall->setCallingConv(CallingConv);
2398  NewDeoptCall->setAttributes(DeoptAttributes);
2399  if (NewDeoptCall->getType()->isVoidTy())
2400  Builder.CreateRetVoid();
2401  else
2402  Builder.CreateRet(NewDeoptCall);
2403  }
2404 
2405  // Leave behind the normal returns so we can merge control flow.
2406  std::swap(Returns, NormalReturns);
2407  }
2408  }
2409 
2410  // Handle any inlined musttail call sites. In order for a new call site to be
2411  // musttail, the source of the clone and the inlined call site must have been
2412  // musttail. Therefore it's safe to return without merging control into the
2413  // phi below.
2414  if (InlinedMustTailCalls) {
2415  // Check if we need to bitcast the result of any musttail calls.
2416  Type *NewRetTy = Caller->getReturnType();
2417  bool NeedBitCast = !CB.use_empty() && CB.getType() != NewRetTy;
2418 
2419  // Handle the returns preceded by musttail calls separately.
2420  SmallVector<ReturnInst *, 8> NormalReturns;
2421  for (ReturnInst *RI : Returns) {
2422  CallInst *ReturnedMustTail =
2424  if (!ReturnedMustTail) {
2425  NormalReturns.push_back(RI);
2426  continue;
2427  }
2428  if (!NeedBitCast)
2429  continue;
2430 
2431  // Delete the old return and any preceding bitcast.
2432  BasicBlock *CurBB = RI->getParent();
2433  auto *OldCast = dyn_cast_or_null<BitCastInst>(RI->getReturnValue());
2434  RI->eraseFromParent();
2435  if (OldCast)
2436  OldCast->eraseFromParent();
2437 
2438  // Insert a new bitcast and return with the right type.
2439  IRBuilder<> Builder(CurBB);
2440  Builder.CreateRet(Builder.CreateBitCast(ReturnedMustTail, NewRetTy));
2441  }
2442 
2443  // Leave behind the normal returns so we can merge control flow.
2444  std::swap(Returns, NormalReturns);
2445  }
2446 
2447  // Now that all of the transforms on the inlined code have taken place but
2448  // before we splice the inlined code into the CFG and lose track of which
2449  // blocks were actually inlined, collect the call sites. We only do this if
2450  // call graph updates weren't requested, as those provide value handle based
2451  // tracking of inlined call sites instead. Calls to intrinsics are not
2452  // collected because they are not inlineable.
2453  if (InlinedFunctionInfo.ContainsCalls && !IFI.CG) {
2454  // Otherwise just collect the raw call sites that were inlined.
2455  for (BasicBlock &NewBB :
2456  make_range(FirstNewBlock->getIterator(), Caller->end()))
2457  for (Instruction &I : NewBB)
2458  if (auto *CB = dyn_cast<CallBase>(&I))
2459  if (!(CB->getCalledFunction() &&
2460  CB->getCalledFunction()->isIntrinsic()))
2461  IFI.InlinedCallSites.push_back(CB);
2462  }
2463 
2464  // If we cloned in _exactly one_ basic block, and if that block ends in a
2465  // return instruction, we splice the body of the inlined callee directly into
2466  // the calling basic block.
2467  if (Returns.size() == 1 && std::distance(FirstNewBlock, Caller->end()) == 1) {
2468  // Move all of the instructions right before the call.
2469  OrigBB->getInstList().splice(CB.getIterator(), FirstNewBlock->getInstList(),
2470  FirstNewBlock->begin(), FirstNewBlock->end());
2471  // Remove the cloned basic block.
2472  Caller->getBasicBlockList().pop_back();
2473 
2474  // If the call site was an invoke instruction, add a branch to the normal
2475  // destination.
2476  if (InvokeInst *II = dyn_cast<InvokeInst>(&CB)) {
2477  BranchInst *NewBr = BranchInst::Create(II->getNormalDest(), &CB);
2478  NewBr->setDebugLoc(Returns[0]->getDebugLoc());
2479  }
2480 
2481  // If the return instruction returned a value, replace uses of the call with
2482  // uses of the returned value.
2483  if (!CB.use_empty()) {
2484  ReturnInst *R = Returns[0];
2485  if (&CB == R->getReturnValue())
2487  else
2488  CB.replaceAllUsesWith(R->getReturnValue());
2489  }
2490  // Since we are now done with the Call/Invoke, we can delete it.
2491  CB.eraseFromParent();
2492 
2493  // Since we are now done with the return instruction, delete it also.
2494  Returns[0]->eraseFromParent();
2495 
2496  // We are now done with the inlining.
2497  return InlineResult::success();
2498  }
2499 
2500  // Otherwise, we have the normal case, of more than one block to inline or
2501  // multiple return sites.
2502 
2503  // We want to clone the entire callee function into the hole between the
2504  // "starter" and "ender" blocks. How we accomplish this depends on whether
2505  // this is an invoke instruction or a call instruction.
2506  BasicBlock *AfterCallBB;
2507  BranchInst *CreatedBranchToNormalDest = nullptr;
2508  if (InvokeInst *II = dyn_cast<InvokeInst>(&CB)) {
2509 
2510  // Add an unconditional branch to make this look like the CallInst case...
2511  CreatedBranchToNormalDest = BranchInst::Create(II->getNormalDest(), &CB);
2512 
2513  // Split the basic block. This guarantees that no PHI nodes will have to be
2514  // updated due to new incoming edges, and make the invoke case more
2515  // symmetric to the call case.
2516  AfterCallBB =
2517  OrigBB->splitBasicBlock(CreatedBranchToNormalDest->getIterator(),
2518  CalledFunc->getName() + ".exit");
2519 
2520  } else { // It's a call
2521  // If this is a call instruction, we need to split the basic block that
2522  // the call lives in.
2523  //
2524  AfterCallBB = OrigBB->splitBasicBlock(CB.getIterator(),
2525  CalledFunc->getName() + ".exit");
2526  }
2527 
2528  if (IFI.CallerBFI) {
2529  // Copy original BB's block frequency to AfterCallBB
2530  IFI.CallerBFI->setBlockFreq(
2531  AfterCallBB, IFI.CallerBFI->getBlockFreq(OrigBB).getFrequency());
2532  }
2533 
2534  // Change the branch that used to go to AfterCallBB to branch to the first
2535  // basic block of the inlined function.
2536  //
2537  Instruction *Br = OrigBB->getTerminator();
2538  assert(Br && Br->getOpcode() == Instruction::Br &&
2539  "splitBasicBlock broken!");
2540  Br->setOperand(0, &*FirstNewBlock);
2541 
2542  // Now that the function is correct, make it a little bit nicer. In
2543  // particular, move the basic blocks inserted from the end of the function
2544  // into the space made by splitting the source basic block.
2545  Caller->getBasicBlockList().splice(AfterCallBB->getIterator(),
2546  Caller->getBasicBlockList(), FirstNewBlock,
2547  Caller->end());
2548 
2549  // Handle all of the return instructions that we just cloned in, and eliminate
2550  // any users of the original call/invoke instruction.
2551  Type *RTy = CalledFunc->getReturnType();
2552 
2553  PHINode *PHI = nullptr;
2554  if (Returns.size() > 1) {
2555  // The PHI node should go at the front of the new basic block to merge all
2556  // possible incoming values.
2557  if (!CB.use_empty()) {
2558  PHI = PHINode::Create(RTy, Returns.size(), CB.getName(),
2559  &AfterCallBB->front());
2560  // Anything that used the result of the function call should now use the
2561  // PHI node as their operand.
2562  CB.replaceAllUsesWith(PHI);
2563  }
2564 
2565  // Loop over all of the return instructions adding entries to the PHI node
2566  // as appropriate.
2567  if (PHI) {
2568  for (unsigned i = 0, e = Returns.size(); i != e; ++i) {
2569  ReturnInst *RI = Returns[i];
2570  assert(RI->getReturnValue()->getType() == PHI->getType() &&
2571  "Ret value not consistent in function!");
2572  PHI->addIncoming(RI->getReturnValue(), RI->getParent());
2573  }
2574  }
2575 
2576  // Add a branch to the merge points and remove return instructions.
2577  DebugLoc Loc;
2578  for (unsigned i = 0, e = Returns.size(); i != e; ++i) {
2579  ReturnInst *RI = Returns[i];
2580  BranchInst* BI = BranchInst::Create(AfterCallBB, RI);
2581  Loc = RI->getDebugLoc();
2582  BI->setDebugLoc(Loc);
2583  RI->eraseFromParent();
2584  }
2585  // We need to set the debug location to *somewhere* inside the
2586  // inlined function. The line number may be nonsensical, but the
2587  // instruction will at least be associated with the right
2588  // function.
2589  if (CreatedBranchToNormalDest)
2590  CreatedBranchToNormalDest->setDebugLoc(Loc);
2591  } else if (!Returns.empty()) {
2592  // Otherwise, if there is exactly one return value, just replace anything
2593  // using the return value of the call with the computed value.
2594  if (!CB.use_empty()) {
2595  if (&CB == Returns[0]->getReturnValue())
2597  else
2598  CB.replaceAllUsesWith(Returns[0]->getReturnValue());
2599  }
2600 
2601  // Update PHI nodes that use the ReturnBB to use the AfterCallBB.
2602  BasicBlock *ReturnBB = Returns[0]->getParent();
2603  ReturnBB->replaceAllUsesWith(AfterCallBB);
2604 
2605  // Splice the code from the return block into the block that it will return
2606  // to, which contains the code that was after the call.
2607  AfterCallBB->getInstList().splice(AfterCallBB->begin(),
2608  ReturnBB->getInstList());
2609 
2610  if (CreatedBranchToNormalDest)
2611  CreatedBranchToNormalDest->setDebugLoc(Returns[0]->getDebugLoc());
2612 
2613  // Delete the return instruction now and empty ReturnBB now.
2614  Returns[0]->eraseFromParent();
2615  ReturnBB->eraseFromParent();
2616  } else if (!CB.use_empty()) {
2617  // No returns, but something is using the return value of the call. Just
2618  // nuke the result.
2620  }
2621 
2622  // Since we are now done with the Call/Invoke, we can delete it.
2623  CB.eraseFromParent();
2624 
2625  // If we inlined any musttail calls and the original return is now
2626  // unreachable, delete it. It can only contain a bitcast and ret.
2627  if (InlinedMustTailCalls && pred_empty(AfterCallBB))
2628  AfterCallBB->eraseFromParent();
2629 
2630  // We should always be able to fold the entry block of the function into the
2631  // single predecessor of the block...
2632  assert(cast<BranchInst>(Br)->isUnconditional() && "splitBasicBlock broken!");
2633  BasicBlock *CalleeEntry = cast<BranchInst>(Br)->getSuccessor(0);
2634 
2635  // Splice the code entry block into calling block, right before the
2636  // unconditional branch.
2637  CalleeEntry->replaceAllUsesWith(OrigBB); // Update PHI nodes
2638  OrigBB->getInstList().splice(Br->getIterator(), CalleeEntry->getInstList());
2639 
2640  // Remove the unconditional branch.
2641  OrigBB->getInstList().erase(Br);
2642 
2643  // Now we can remove the CalleeEntry block, which is now empty.
2644  Caller->getBasicBlockList().erase(CalleeEntry);
2645 
2646  // If we inserted a phi node, check to see if it has a single value (e.g. all
2647  // the entries are the same or undef). If so, remove the PHI so it doesn't
2648  // block other optimizations.
2649  if (PHI) {
2650  AssumptionCache *AC =
2651  IFI.GetAssumptionCache ? &IFI.GetAssumptionCache(*Caller) : nullptr;
2652  auto &DL = Caller->getParent()->getDataLayout();
2653  if (Value *V = simplifyInstruction(PHI, {DL, nullptr, nullptr, AC})) {
2654  PHI->replaceAllUsesWith(V);
2655  PHI->eraseFromParent();
2656  }
2657  }
2658 
2659  return InlineResult::success();
2660 }
llvm::EHPersonality::MSVC_CXX
@ MSVC_CXX
llvm::AttrBuilder::addDereferenceableOrNullAttr
AttrBuilder & addDereferenceableOrNullAttr(uint64_t Bytes)
This turns the number of dereferenceable_or_null bytes into the form used internally in Attribute.
Definition: Attributes.cpp:1687
i
i
Definition: README.txt:29
llvm::InvokeInst::getNormalDest
BasicBlock * getNormalDest() const
Definition: Instructions.h:3895
llvm::BasicBlock::getTerminatingDeoptimizeCall
const CallInst * getTerminatingDeoptimizeCall() const
Returns the call instruction calling @llvm.experimental.deoptimize prior to the terminating return in...
Definition: BasicBlock.cpp:182
llvm::CallBase::getNumOperandBundles
unsigned getNumOperandBundles() const
Return the number of operand bundles associated with this User.
Definition: InstrTypes.h:1940
IdentifyValidAttributes
static AttrBuilder IdentifyValidAttributes(CallBase &CB)
Definition: InlineFunction.cpp:1182
llvm::isAsynchronousEHPersonality
bool isAsynchronousEHPersonality(EHPersonality Pers)
Returns true if this personality function catches asynchronous exceptions.
Definition: EHPersonalities.h:49
llvm::Argument
This class represents an incoming formal argument to a Function.
Definition: Argument.h:28
AssumptionCache.h
Attrs
Function Attrs
Definition: README_ALTIVEC.txt:215
llvm::InlineResult::success
static InlineResult success()
Definition: InlineCost.h:169
llvm::Function::isIntrinsic
bool isIntrinsic() const
isIntrinsic - Returns true if the function's name starts with "llvm.".
Definition: Function.h:210
llvm::CatchSwitchInst::Create
static CatchSwitchInst * Create(Value *ParentPad, BasicBlock *UnwindDest, unsigned NumHandlers, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Definition: Instructions.h:4311
llvm::CallGraphNode::CalledFunctionsVector
std::vector< CallRecord > CalledFunctionsVector
Definition: CallGraph.h:181
llvm::AArch64CC::HI
@ HI
Definition: AArch64BaseInfo.h:263
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
HandleInlinedEHPad
static void HandleInlinedEHPad(InvokeInst *II, BasicBlock *FirstNewBlock, ClonedCodeInfo &InlinedCodeInfo)
If we inlined an invoke site, we need to convert calls in the body of the inlined function into invok...
Definition: InlineFunction.cpp:662
llvm::objcarc::hasAttachedCallOpBundle
bool hasAttachedCallOpBundle(const CallBase *CB)
Definition: ObjCARCUtil.h:29
llvm::LandingPadInst::isCleanup
bool isCleanup() const
Return 'true' if this landingpad instruction is a cleanup.
Definition: Instructions.h:2950
getUnwindDestToken
static Value * getUnwindDestToken(Instruction *EHPad, UnwindDestMemoTy &MemoMap)
Given an EH pad, find where it unwinds.
Definition: InlineFunction.cpp:395
llvm::CallBase::getOperandBundlesAsDefs
void getOperandBundlesAsDefs(SmallVectorImpl< OperandBundleDef > &Defs) const
Return the list of operand bundles attached to this instruction as a vector of OperandBundleDefs.
Definition: Instructions.cpp:396
llvm::Function::args
iterator_range< arg_iterator > args()
Definition: Function.h:765
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
llvm::Instruction::getModule
const Module * getModule() const
Return the module owning the function this instruction belongs to or nullptr it the function does not...
Definition: Instruction.cpp:65
llvm::AArch64CC::AL
@ AL
Definition: AArch64BaseInfo.h:269
llvm::objcarc::getAttachedARCFunction
Optional< Function * > getAttachedARCFunction(const CallBase *CB)
This function returns operand bundle clang_arc_attachedcall's argument, which is the address of the A...
Definition: ObjCARCUtil.h:43
llvm::CallGraphNode::iterator
std::vector< CallRecord >::iterator iterator
Definition: CallGraph.h:193
llvm::make_range
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
Definition: iterator_range.h:53
llvm::AssumptionCache::registerAssumption
void registerAssumption(AssumeInst *CI)
Add an @llvm.assume intrinsic to this function's cache.
Definition: AssumptionCache.cpp:224
llvm::ReturnInst
Return a value (possibly void), from a function.
Definition: Instructions.h:3004
llvm::VAArgInst
This class represents the va_arg llvm instruction, which returns an argument of the specified type gi...
Definition: Instructions.h:1819
llvm::ClonedCodeInfo
This struct can be used to capture information about code being cloned, while it is being cloned.
Definition: Cloning.h:62
llvm::CallBase::getOperandBundle
Optional< OperandBundleUse > getOperandBundle(StringRef Name) const
Return an operand bundle by name, if present.
Definition: InstrTypes.h:2027
Optional.h
ValueMapper.h
llvm::DataLayout
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:113
allocaWouldBeStaticInEntry
static bool allocaWouldBeStaticInEntry(const AllocaInst *AI)
Return the result of AI->isStaticAlloca() if AI were moved to the entry block.
Definition: InlineFunction.cpp:1467
llvm::IRBuilderBase::CreateLifetimeEnd
CallInst * CreateLifetimeEnd(Value *Ptr, ConstantInt *Size=nullptr)
Create a lifetime.end intrinsic.
Definition: IRBuilder.cpp:495
MayContainThrowingOrExitingCall
static bool MayContainThrowingOrExitingCall(Instruction *Begin, Instruction *End)
Definition: InlineFunction.cpp:1173
llvm::Intrinsic::getDeclaration
Function * getDeclaration(Module *M, ID id, ArrayRef< Type * > Tys=None)
Create or insert an LLVM Function declaration for an intrinsic, and return it.
Definition: Function.cpp:1418
Metadata.h
llvm::Type::getInt8PtrTy
static PointerType * getInt8PtrTy(LLVMContext &C, unsigned AS=0)
Definition: Type.cpp:291
llvm::Function::end
iterator end()
Definition: Function.h:728
llvm::BasicBlock::iterator
InstListType::iterator iterator
Instruction iterators...
Definition: BasicBlock.h:87
llvm::BasicBlock::getParent
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:104
IntrinsicInst.h
DebugInfoMetadata.h
llvm::ValueMap::end
iterator end()
Definition: ValueMap.h:136
llvm::TypeSize::getFixedSize
ScalarTy getFixedSize() const
Definition: TypeSize.h:444
llvm::Function
Definition: Function.h:60
fixupLineNumbers
static void fixupLineNumbers(Function *Fn, Function::iterator FI, Instruction *TheCall, bool CalleeHasDebugInfo)
Update inlined instructions' line numbers to to encode location where these instructions are inlined.
Definition: InlineFunction.cpp:1483
getUnwindDestTokenHelper
static Value * getUnwindDestTokenHelper(Instruction *EHPad, UnwindDestMemoTy &MemoMap)
Helper for getUnwindDestToken that does the descendant-ward part of the search.
Definition: InlineFunction.cpp:244
llvm::ReturnInst::getReturnValue
Value * getReturnValue() const
Convenience accessor. Returns null if there is no return value.
Definition: Instructions.h:3049
llvm::AllocaInst::getType
PointerType * getType() const
Overload to return most specific pointer type.
Definition: Instructions.h:100
llvm::SmallVector< Value *, 8 >
llvm::CallInst::setTailCallKind
void setTailCallKind(TailCallKind TCK)
Definition: Instructions.h:1664
InlineAsm.h
llvm::LandingPadInst
The landingpad instruction holds all of the information necessary to generate correct exception handl...
Definition: Instructions.h:2903
CaptureTracking.h
llvm::CallGraphNode::removeCallEdgeFor
void removeCallEdgeFor(CallBase &Call)
Removes the edge in the node for the specified call site.
Definition: CallGraph.cpp:212
llvm::CallBase::isInlineAsm
bool isInlineAsm() const
Check if this call is an inline asm statement.
Definition: InstrTypes.h:1464
llvm::Function::getSubprogram
DISubprogram * getSubprogram() const
Get the attached subprogram.
Definition: Metadata.cpp:1639
ErrorHandling.h
builder
assume builder
Definition: AssumeBundleBuilder.cpp:650
llvm::Type::getPointerAddressSpace
unsigned getPointerAddressSpace() const
Get the address space of this pointer or pointer vector type.
Definition: DerivedTypes.h:729
llvm::IRBuilder<>
llvm::erase_if
void erase_if(Container &C, UnaryPredicate P)
Provide a container algorithm similar to C++ Library Fundamentals v2's erase_if which is equivalent t...
Definition: STLExtras.h:1807
ValueTracking.h
Local.h
llvm::AttributeList::get
static AttributeList get(LLVMContext &C, ArrayRef< std::pair< unsigned, Attribute >> Attrs)
Create an AttributeList with the specified parameters in it.
Definition: Attributes.cpp:1050
llvm::CallGraph
The basic data container for the call graph of a Module of IR.
Definition: CallGraph.h:72
llvm::DominatorTree
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
Definition: Dominators.h:166
llvm::cl::Hidden
@ Hidden
Definition: CommandLine.h:139
llvm::AAResults::onlyAccessesArgPointees
static bool onlyAccessesArgPointees(FunctionModRefBehavior MRB)
Checks if functions with the specified behavior are known to read and write at most from objects poin...
Definition: AliasAnalysis.h:692
llvm::CallBase::addOperandBundle
static CallBase * addOperandBundle(CallBase *CB, uint32_t ID, OperandBundleDef OB, Instruction *InsertPt=nullptr)
Create a clone of CB with operand bundle OB added.
Definition: Instructions.cpp:475
HandleByValArgument
static Value * HandleByValArgument(Type *ByValType, Value *Arg, Instruction *TheCall, const Function *CalledFunc, InlineFunctionInfo &IFI, unsigned ByValAlignment)
When inlining a call site that has a byval argument, we have to make the implicit memcpy explicit by ...
Definition: InlineFunction.cpp:1384
llvm::DILocation
Debug location.
Definition: DebugInfoMetadata.h:1557
llvm::Function::getContext
LLVMContext & getContext() const
getContext - Return a reference to the LLVMContext associated with this function.
Definition: Function.cpp:319
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
DenseMap.h
Module.h
llvm::BasicBlock::eraseFromParent
SymbolTableList< BasicBlock >::iterator eraseFromParent()
Unlink 'this' from the containing function and delete it.
Definition: BasicBlock.cpp:132
llvm::AttributeList
Definition: Attributes.h:425
llvm::getOrEnforceKnownAlignment
Align getOrEnforceKnownAlignment(Value *V, MaybeAlign PrefAlign, const DataLayout &DL, const Instruction *CxtI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr)
Try to ensure that the alignment of V is at least PrefAlign bytes.
Definition: Local.cpp:1356
llvm::CallBase::getAttributes
AttributeList getAttributes() const
Return the parameter attributes for this call.
Definition: InstrTypes.h:1474
llvm::OperandBundleDefT
A container for an operand bundle being viewed as a set of values rather than a set of uses.
Definition: AutoUpgrade.h:32
llvm::CallBase::getFunctionType
FunctionType * getFunctionType() const
Definition: InstrTypes.h:1254
EHPersonalities.h
llvm::BasicBlock::splitBasicBlock
BasicBlock * splitBasicBlock(iterator I, const Twine &BBName="", bool Before=false)
Split the basic block into two basic blocks at the specified instruction.
Definition: BasicBlock.cpp:378
llvm::objcarc::isRetainOrClaimRV
bool isRetainOrClaimRV(ARCInstKind Kind)
Check whether the function is retainRV/unsafeClaimRV.
Definition: ObjCARCUtil.h:52
llvm::Optional
Definition: APInt.h:33
llvm::DenseMapBase::count
size_type count(const_arg_type_t< KeyT > Val) const
Return 1 if the specified key is in the map, 0 otherwise.
Definition: DenseMap.h:147
llvm::ProfileSummaryInfo::getProfileCount
Optional< uint64_t > getProfileCount(const CallBase &CallInst, BlockFrequencyInfo *BFI, bool AllowSynthetic=false) const
Returns the profile count for CallInst.
Definition: ProfileSummaryInfo.cpp:76
llvm::SmallPtrSet< Instruction *, 4 >
llvm::CallBase::isByValArgument
bool isByValArgument(unsigned ArgNo) const
Determine whether this argument is passed by value.
Definition: InstrTypes.h:1678
llvm::max
Expected< ExpressionValue > max(const ExpressionValue &Lhs, const ExpressionValue &Rhs)
Definition: FileCheck.cpp:337
llvm::FunctionType::getNumParams
unsigned getNumParams() const
Return the number of fixed parameters this function type requires.
Definition: DerivedTypes.h:139
llvm::Function::ProfileCount::isSynthetic
bool isSynthetic() const
Definition: Function.h:263
HandleCallsInBlockInlinedThroughInvoke
static BasicBlock * HandleCallsInBlockInlinedThroughInvoke(BasicBlock *BB, BasicBlock *UnwindEdge, UnwindDestMemoTy *FuncletUnwindMap=nullptr)
When we inline a basic block into an invoke, we have to turn all of the calls that can throw into inv...
Definition: InlineFunction.cpp:539
STLExtras.h
llvm::CallBase::arg_begin
User::op_iterator arg_begin()
Return the iterator pointing to the beginning of the argument list.
Definition: InstrTypes.h:1316
llvm::SmallVectorImpl::pop_back_val
LLVM_NODISCARD T pop_back_val()
Definition: SmallVector.h:654
llvm::CallInst::TCK_None
@ TCK_None
Definition: Instructions.h:1639
llvm::CallBase::setDoesNotThrow
void setDoesNotThrow()
Definition: InstrTypes.h:1900
llvm::dwarf::Tag
Tag
Definition: Dwarf.h:105
llvm::uniteAccessGroups
MDNode * uniteAccessGroups(MDNode *AccGroups1, MDNode *AccGroups2)
Compute the union of two access-group lists.
Definition: VectorUtils.cpp:772
llvm::BasicBlock::rend
reverse_iterator rend()
Definition: BasicBlock.h:304
llvm::LinearPolySize::isScalable
bool isScalable() const
Returns whether the size is scaled by a runtime quantity (vscale).
Definition: TypeSize.h:298
llvm::CallGraphNode::addCalledFunction
void addCalledFunction(CallBase *Call, CallGraphNode *M)
Adds a function to the list of functions called by this one.
Definition: CallGraph.h:242
llvm::MDBuilder::createAnonymousAliasScope
MDNode * createAnonymousAliasScope(MDNode *Domain, StringRef Name=StringRef())
Return metadata appropriate for an alias scope root node.
Definition: MDBuilder.h:144
llvm::AMDGPU::HSAMD::ValueKind::Queue
@ Queue
llvm::MDNode::get
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Definition: Metadata.h:1384
F
#define F(x, y, z)
Definition: MD5.cpp:55
llvm::InlineFunctionInfo::CallerBFI
BlockFrequencyInfo * CallerBFI
Definition: Cloning.h:216
llvm::Instruction::setMetadata
void setMetadata(unsigned KindID, MDNode *Node)
Set the metadata of the specified kind to the specified node.
Definition: Metadata.cpp:1434
llvm::InlineFunctionInfo::PSI
ProfileSummaryInfo * PSI
Definition: Cloning.h:215
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:55
AliasAnalysis.h
Context
LLVMContext & Context
Definition: NVVMIntrRange.cpp:66
llvm::isIdentifiedFunctionLocal
bool isIdentifiedFunctionLocal(const Value *V)
Return true if V is umabigously identified at the function-level.
Definition: AliasAnalysis.cpp:986
llvm::classifyEHPersonality
EHPersonality classifyEHPersonality(const Value *Pers)
See if the given exception handling personality function is one that we understand.
Definition: EHPersonalities.cpp:22
Arg
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
Definition: AMDGPULibCalls.cpp:186
Instruction.h
CommandLine.h
llvm::ConstantInt
This is the shared class of boolean and integer constants.
Definition: Constants.h:79
AddAliasScopeMetadata
static void AddAliasScopeMetadata(CallBase &CB, ValueToValueMapTy &VMap, const DataLayout &DL, AAResults *CalleeAAR, ClonedCodeInfo &InlinedFunctionInfo)
If the inlined function has noalias arguments, then add new alias scopes for each noalias argument,...
Definition: InlineFunction.cpp:938
llvm::Instruction::getOpcode
unsigned getOpcode() const
Returns a member of one of the enums like Instruction::Add.
Definition: Instruction.h:157
llvm::BlockFrequencyInfo
BlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate IR basic block frequen...
Definition: BlockFrequencyInfo.h:37
PropagateCallSiteMetadata
static void PropagateCallSiteMetadata(CallBase &CB, Function::iterator FStart, Function::iterator FEnd)
When inlining a call site that has !llvm.mem.parallel_loop_access, !llvm.access.group,...
Definition: InlineFunction.cpp:788
llvm::CallGraphNode::end
iterator end()
Definition: CallGraph.h:200
llvm::InlineFunctionInfo::CG
CallGraph * CG
If non-null, InlineFunction will update the callgraph to reflect the changes it makes.
Definition: Cloning.h:213
llvm::ms_demangle::CallingConv
CallingConv
Definition: MicrosoftDemangleNodes.h:58
llvm::GlobalValue::isDeclaration
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Definition: Globals.cpp:264
Constants.h
llvm::AAResults
Definition: AliasAnalysis.h:511
llvm::AllocaInst::getAllocatedType
Type * getAllocatedType() const
Return the type that is being allocated by the instruction.
Definition: Instructions.h:114
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
UpdateReturnAttributes
static cl::opt< bool > UpdateReturnAttributes("update-return-attrs", cl::init(true), cl::Hidden, cl::desc("Update return attributes on calls within inlined body"))
llvm::DebugLoc::getCol
unsigned getCol() const
Definition: DebugLoc.cpp:29
llvm::SmallVectorImpl::append
void append(in_iter in_start, in_iter in_end)
Add the specified range to the end of the SmallVector.
Definition: SmallVector.h:667
llvm::InvokeInst::getLandingPadInst
LandingPadInst * getLandingPadInst() const
Get the landingpad instruction from the landing pad block (the unwind destination).
Definition: Instructions.cpp:916
llvm::User
Definition: User.h:44
llvm::getKnownAlignment
Align getKnownAlignment(Value *V, const DataLayout &DL, const Instruction *CxtI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr)
Try to infer an alignment for the specified pointer.
Definition: Local.h:222
Intrinsics.h
llvm::CleanupReturnInst::Create
static CleanupReturnInst * Create(Value *CleanupPad, BasicBlock *UnwindBB=nullptr, Instruction *InsertBefore=nullptr)
Definition: Instructions.h:4638
llvm::LandingPadInst::getNumClauses
unsigned getNumClauses() const
Get the number of clauses for this landing pad.
Definition: Instructions.h:2975
InstrTypes.h
llvm::CallBase::getCalledFunction
Function * getCalledFunction() const
Returns the function called, or null if this is an indirect function invocation or the function signa...
Definition: InstrTypes.h:1396
llvm::CallBase::setAttributes
void setAttributes(AttributeList A)
Set the parameter attributes for this call.
Definition: InstrTypes.h:1478
llvm::BasicBlock::begin
iterator begin()
Instruction iterator methods.
Definition: BasicBlock.h:297
UpdatePHINodes
static void UpdatePHINodes(BasicBlock *OrigBB, BasicBlock *NewBB, ArrayRef< BasicBlock * > Preds, BranchInst *BI, bool HasLoopExit)
Update the PHI nodes in OrigBB to include the values coming from NewBB.
Definition: BasicBlockUtils.cpp:1012
llvm::CallInst::Create
static CallInst * Create(FunctionType *Ty, Value *F, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Definition: Instructions.h:1504
llvm::MDTuple
Tuple of metadata.
Definition: Metadata.h:1315
llvm::updateProfileCallee
void updateProfileCallee(Function *Callee, int64_t EntryDelta, const ValueMap< const Value *, WeakTrackingVH > *VMap=nullptr)
Updates profile information by adjusting the entry count by adding EntryDelta then scaling callsite i...
Definition: InlineFunction.cpp:1607
llvm::LLVMContext::OB_clang_arc_attachedcall
@ OB_clang_arc_attachedcall
Definition: LLVMContext.h:96
llvm::objcarc::ARCInstKind::RetainRV
@ RetainRV
objc_retainAutoreleasedReturnValue
AssumeBundleBuilder.h
llvm::BlockFrequencyInfo::setBlockFreq
void setBlockFreq(const BasicBlock *BB, uint64_t Freq)
Definition: BlockFrequencyInfo.cpp:228
llvm::ClonedCodeInfo::OperandBundleCallSites
std::vector< WeakTrackingVH > OperandBundleCallSites
All cloned call sites that have operand bundles attached are appended to this vector.
Definition: Cloning.h:74
llvm::Function::arg_end
arg_iterator arg_end()
Definition: Function.h:750
llvm::PHINode::getIncomingValueForBlock
Value * getIncomingValueForBlock(const BasicBlock *BB) const
Definition: Instructions.h:2836
llvm::Instruction
Definition: Instruction.h:42
UseNoAliasIntrinsic
static cl::opt< bool > UseNoAliasIntrinsic("use-noalias-intrinsic-during-inlining", cl::Hidden, cl::init(true), cl::desc("Use the llvm.experimental.noalias.scope.decl " "intrinsic during inlining."))
llvm::AttributeList::hasFnAttr
bool hasFnAttr(Attribute::AttrKind Kind) const
Return true if the attribute exists for the function.
Definition: Attributes.cpp:1405
llvm::ClonedCodeInfo::isSimplified
bool isSimplified(const Value *From, const Value *To) const
Definition: Cloning.h:83
MDBuilder.h
llvm::AllocaInst::getArraySize
const Value * getArraySize() const
Get the number of elements allocated.
Definition: Instructions.h:96
HandleInlinedLandingPad
static void HandleInlinedLandingPad(InvokeInst *II, BasicBlock *FirstNewBlock, ClonedCodeInfo &InlinedCodeInfo)
If we inlined an invoke site, we need to convert calls in the body of the inlined function into invok...
Definition: InlineFunction.cpp:605
llvm::BasicBlock::phis
iterator_range< const_phi_iterator > phis() const
Returns a range that iterates over the phis in the basic block.
Definition: BasicBlock.h:355
llvm::Function::hasPersonalityFn
bool hasPersonalityFn() const
Check whether this function has a personality function.
Definition: Function.h:778
llvm::UndefValue::get
static UndefValue * get(Type *T)
Static factory methods - Return an 'undef' object of the specified type.
Definition: Constants.cpp:1777
llvm::ConstantInt::get
static Constant * get(Type *Ty, uint64_t V, bool IsSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
Definition: Constants.cpp:928
llvm::CallBase::getParamByValType
Type * getParamByValType(unsigned ArgNo) const
Extract the byval type for a call or parameter.
Definition: InstrTypes.h:1751
DebugLoc.h
SmallPtrSet.h
llvm::CallGraphNode
A node in the call graph for a module.
Definition: CallGraph.h:166
llvm::ValueMap::begin
iterator begin()
Definition: ValueMap.h:135
isUsedByLifetimeMarker
static bool isUsedByLifetimeMarker(Value *V)
Definition: InlineFunction.cpp:1437
Align
uint64_t Align
Definition: ELFObjHandler.cpp:81
llvm::BasicBlock::getFirstNonPHI
const Instruction * getFirstNonPHI() const
Returns a pointer to the first instruction in this block that is not a PHINode instruction.
Definition: BasicBlock.cpp:209
llvm::Align
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
llvm::Metadata
Root of the metadata hierarchy.
Definition: Metadata.h:62
llvm::CallBase::getCallingConv
CallingConv::ID getCallingConv() const
Definition: InstrTypes.h:1455
llvm::ValueMap::count
size_type count(const KeyT &Val) const
Return 1 if the specified key is in the map, 0 otherwise.
Definition: ValueMap.h:152
llvm::Instruction::isLifetimeStartOrEnd
bool isLifetimeStartOrEnd() const
Return true if the instruction is a llvm.lifetime.start or llvm.lifetime.end marker.
Definition: Instruction.cpp:718
llvm::None
const NoneType None
Definition: None.h:24
llvm::Value::use_empty
bool use_empty() const
Definition: Value.h:344
llvm::objcarc::ARCInstKind
ARCInstKind
Definition: ObjCARCInstKind.h:28
Type.h
getParentPad
static Value * getParentPad(Value *EHPad)
Helper for getUnwindDestToken/getUnwindDestTokenHelper.
Definition: InlineFunction.cpp:234
llvm::CallBase::getCaller
Function * getCaller()
Helper to get the caller (the parent function).
Definition: Instructions.cpp:282
llvm::DebugLoc::appendInlinedAt
static DebugLoc appendInlinedAt(const DebugLoc &DL, DILocation *InlinedAt, LLVMContext &Ctx, DenseMap< const MDNode *, MDNode * > &Cache)
Rebuild the entire inlined-at chain for this instruction so that the top of the chain now is inlined-...
Definition: DebugLoc.cpp:70
llvm::MDBuilder::createAnonymousAliasScopeDomain
MDNode * createAnonymousAliasScopeDomain(StringRef Name=StringRef())
Return metadata appropriate for an alias scope domain node.
Definition: MDBuilder.h:137
llvm::Instruction::getMetadata
MDNode * getMetadata(unsigned KindID) const
Get the metadata of given kind attached to this Instruction.
Definition: Instruction.h:279
llvm::OperandBundleUse::getTagID
uint32_t getTagID() const
Return the tag of this operand bundle as an integer.
Definition: InstrTypes.h:1097
CFG.h
llvm::AllocaInst::isSwiftError
bool isSwiftError() const
Return true if this alloca is used as a swifterror argument to a call.
Definition: Instructions.h:146
llvm::ProfileSummaryInfo
Analysis providing profile information.
Definition: ProfileSummaryInfo.h:39
llvm::Function::getAttributes
AttributeList getAttributes() const
Return the attribute list for this Function.
Definition: Function.h:314
llvm::InvokeInst
Invoke instruction.
Definition: Instructions.h:3763
llvm::Function::getGC
const std::string & getGC() const
Definition: Function.cpp:686
llvm::AttrBuilder::addAttribute
AttrBuilder & addAttribute(Attribute::AttrKind Val)
Add an attribute to the builder.
Definition: Attributes.cpp:1616
llvm::InlineAsm
Definition: InlineAsm.h:31
VectorUtils.h
llvm::Function::hasFnAttribute
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
Definition: Function.cpp:625
BasicBlock.h
llvm::cl::opt< bool >
llvm::LLVMContext::OB_funclet
@ OB_funclet
Definition: LLVMContext.h:91
llvm::RISCVFenceField::O
@ O
Definition: RISCVBaseInfo.h:239
llvm::Function::getEntryCount
Optional< ProfileCount > getEntryCount(bool AllowSynthetic=false) const
Get the entry count for this function.
Definition: Function.cpp:1992
llvm::StoreInst
An instruction for storing to memory.
Definition: Instructions.h:297
llvm::AttributeList::getRetAttrs
AttributeSet getRetAttrs() const
The attributes for the ret value are returned.
Definition: Attributes.cpp:1384
llvm::Constant
This is an important base class in LLVM.
Definition: Constant.h:41
llvm::getUnderlyingObjects
void getUnderlyingObjects(const Value *V, SmallVectorImpl< const Value * > &Objects, LoopInfo *LI=nullptr, unsigned MaxLookup=6)
This method is similar to getUnderlyingObject except that it can look through phi and select instruct...
Definition: ValueTracking.cpp:4500
llvm::Instruction::eraseFromParent
SymbolTableList< Instruction >::iterator eraseFromParent()
This method unlinks 'this' from the containing basic block and deletes it.
Definition: Instruction.cpp:77
llvm::Function::getReturnType
Type * getReturnType() const
Returns the type of the ret val.
Definition: Function.h:180
llvm::InlineAsm::canThrow
bool canThrow() const
Definition: InlineAsm.h:71
inlineDebugLoc
static DebugLoc inlineDebugLoc(DebugLoc OrigDL, DILocation *InlinedAt, LLVMContext &Ctx, DenseMap< const MDNode *, MDNode * > &IANodes)
Returns a DebugLoc for a new DILocation which is a clone of OrigDL inlined at InlinedAt.
Definition: InlineFunction.cpp:1473
llvm::InlineFunctionInfo::InlinedCalls
SmallVector< WeakTrackingVH, 8 > InlinedCalls
InlineFunction fills this in with callsites that were inlined from the callee.
Definition: Cloning.h:224
uint64_t
ProfileSummaryInfo.h
llvm::Function::getCallingConv
CallingConv::ID getCallingConv() const
getCallingConv()/setCallingConv(CC) - These method get and set the calling convention of this functio...
Definition: Function.h:238
llvm::GlobalValue::getParent
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:620
llvm::CallInst::TailCallKind
TailCallKind
Definition: Instructions.h:1638
hasLifetimeMarkers
static bool hasLifetimeMarkers(AllocaInst *AI)
Definition: InlineFunction.cpp:1447
llvm::Function::hasGC
bool hasGC() const
hasGC/getGC/setGC/clearGC - The name of the garbage collection algorithm to use during code generatio...
Definition: Function.h:306
llvm::PHINode::addIncoming
void addIncoming(Value *V, BasicBlock *BB)
Add an incoming value to the end of the PHI list.
Definition: Instructions.h:2801
move
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Definition: README.txt:546
llvm::LLVMContext
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:68
llvm::numbers::e
constexpr double e
Definition: MathExtras.h:57
llvm::BranchInst::Create
static BranchInst * Create(BasicBlock *IfTrue, Instruction *InsertBefore=nullptr)
Definition: Instructions.h:3142
llvm::DenseMap
Definition: DenseMap.h:716
DebugInfo.h
I
#define I(x, y, z)
Definition: MD5.cpp:58
llvm::DebugLoc::get
DILocation * get() const
Get the underlying DILocation.
Definition: DebugLoc.cpp:20
llvm::AttrBuilder
Definition: Attributes.h:1024
Cloning.h
StringExtras.h
llvm::BlockFrequency::getFrequency
uint64_t getFrequency() const
Returns the frequency as a fixpoint number scaled by the entry frequency.
Definition: BlockFrequency.h:34
llvm::isScopedEHPersonality
bool isScopedEHPersonality(EHPersonality Pers)
Returns true if this personality uses scope-style EH IR instructions: catchswitch,...
Definition: EHPersonalities.h:79
llvm::cl::init
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:432
llvm::make_early_inc_range
iterator_range< early_inc_iterator_impl< detail::IterOfRange< RangeT > > > make_early_inc_range(RangeT &&Range)
Make a range that does early increment to allow mutation of the underlying range without disrupting i...
Definition: STLExtras.h:618
UpdateCallGraphAfterInlining
static void UpdateCallGraphAfterInlining(CallBase &CB, Function::iterator FirstNewBlock, ValueToValueMapTy &VMap, InlineFunctionInfo &IFI)
Once we have cloned code over from a callee into the caller, update the specified callgraph to reflec...
Definition: InlineFunction.cpp:1296
llvm::simplifyInstruction
Value * simplifyInstruction(Instruction *I, const SimplifyQuery &Q, OptimizationRemarkEmitter *ORE=nullptr)
See if we can compute a simplified version of this instruction.
Definition: InstructionSimplify.cpp:6486
llvm::Instruction::setDebugLoc
void setDebugLoc(DebugLoc Loc)
Set the debug location information for this instruction.
Definition: Instruction.h:364
llvm::LandingPadInst::getClause
Constant * getClause(unsigned Idx) const
Get the value of the clause at index Idx.
Definition: Instructions.h:2960
AddAlignmentAssumptions
static void AddAlignmentAssumptions(CallBase &CB, InlineFunctionInfo &IFI)
If the inlined function has non-byval align arguments, then add @llvm.assume-based alignment assumpti...
Definition: InlineFunction.cpp:1258
llvm::DenseMapBase::find
iterator find(const_arg_type_t< KeyT > Val)
Definition: DenseMap.h:152
IRBuilder.h
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::ValueMapIterator::ValueTypeProxy::second
ValueT & second
Definition: ValueMap.h:346
llvm::CallBase::hasOperandBundles
bool hasOperandBundles() const
Return true if this User has any operand bundles.
Definition: InstrTypes.h:1945
std::swap
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
Definition: BitVector.h:853
SI
StandardInstrumentations SI(Debug, VerifyEach)
iterator_range.h
llvm::Type::isVoidTy
bool isVoidTy() const
Return true if this is 'void'.
Definition: Type.h:139
llvm::salvageKnowledge
void salvageKnowledge(Instruction *I, AssumptionCache *AC=nullptr, DominatorTree *DT=nullptr)
Calls BuildAssumeFromInst and if the resulting llvm.assume is valid insert if before I.
Definition: AssumeBundleBuilder.cpp:293
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
llvm::MDNode
Metadata node.
Definition: Metadata.h:944
llvm::CallBase::Create
static CallBase * Create(CallBase *CB, ArrayRef< OperandBundleDef > Bundles, Instruction *InsertPt=nullptr)
Create a clone of CB with a different set of operand bundles and insert it before InsertPt.
Definition: Instructions.cpp:255
llvm::changeToInvokeAndSplitBasicBlock
BasicBlock * changeToInvokeAndSplitBasicBlock(CallInst *CI, BasicBlock *UnwindEdge, DomTreeUpdater *DTU=nullptr)
Convert the CallInst to InvokeInst with the specified unwind edge basic block.
Definition: Local.cpp:2207
llvm::SmallPtrSetImpl::count
size_type count(ConstPtrType Ptr) const
count - Return 1 if the specified pointer is in the set, 0 otherwise.
Definition: SmallPtrSet.h:383
Builder
assume Assume Builder
Definition: AssumeBundleBuilder.cpp:651
llvm::User::setOperand
void setOperand(unsigned i, Value *Val)
Definition: User.h:174
llvm::IRBuilderBase::CreateNoAliasScopeDeclaration
Instruction * CreateNoAliasScopeDeclaration(Value *Scope)
Create a llvm.experimental.noalias.scope.decl intrinsic call.
Definition: IRBuilder.cpp:543
llvm::CallBase::getIntrinsicID
Intrinsic::ID getIntrinsicID() const
Returns the intrinsic ID of the intrinsic called or Intrinsic::not_intrinsic if the called function i...
Definition: Instructions.cpp:311
getDebugLoc
static DebugLoc getDebugLoc(MachineBasicBlock::instr_iterator FirstMI, MachineBasicBlock::instr_iterator LastMI)
Return the first found DebugLoc that has a DILocation, given a range of instructions.
Definition: MachineInstrBundle.cpp:110
llvm::DominatorTreeBase::recalculate
void recalculate(ParentType &Func)
recalculate - compute a dominator tree for the given function
Definition: GenericDomTree.h:778
llvm::CloneAndPruneFunctionInto
void CloneAndPruneFunctionInto(Function *NewFunc, const Function *OldFunc, ValueToValueMapTy &VMap, bool ModuleLevelChanges, SmallVectorImpl< ReturnInst * > &Returns, const char *NameSuffix="", ClonedCodeInfo *CodeInfo=nullptr)
This works exactly like CloneFunctionInto, except that it does some simple constant prop and DCE on t...
Definition: CloneFunction.cpp:873
None.h
llvm::min
Expected< ExpressionValue > min(const ExpressionValue &Lhs, const ExpressionValue &Rhs)
Definition: FileCheck.cpp:357
DataLayout.h
llvm::LLVMContext::OB_deopt
@ OB_deopt
Definition: LLVMContext.h:90
llvm::Function::setCallingConv
void setCallingConv(CallingConv::ID CC)
Definition: Function.h:242
llvm::AssumptionCache
A cache of @llvm.assume calls within a function.
Definition: AssumptionCache.h:42
llvm::CallBase::getOperandBundleAt
OperandBundleUse getOperandBundleAt(unsigned Index) const
Return the operand bundle at a specific index.
Definition: InstrTypes.h:1996
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:143
llvm::Value::getType
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:255
llvm::MDNode::concatenate
static MDNode * concatenate(MDNode *A, MDNode *B)
Methods for metadata merging.
Definition: Metadata.cpp:1012
llvm::Instruction::getFunction
const Function * getFunction() const
Return the function this instruction belongs to.
Definition: Instruction.cpp:69
llvm::Value::replaceAllUsesWith
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
Definition: Value.cpp:529
uint32_t
AddReturnAttributes
static void AddReturnAttributes(CallBase &CB, ValueToValueMapTy &VMap)
Definition: InlineFunction.cpp:1202
llvm::append_range
void append_range(Container &C, Range &&R)
Wrapper function to append a range to a container.
Definition: STLExtras.h:1823
llvm::Value::getContext
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:991
llvm::ilist_node_impl::getIterator
self_iterator getIterator()
Definition: ilist_node.h:82
DL
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Definition: AArch64SLSHardening.cpp:76
PreserveAlignmentAssumptions
static cl::opt< bool > PreserveAlignmentAssumptions("preserve-alignment-assumptions-during-inlining", cl::init(false), cl::Hidden, cl::desc("Convert align attributes to assumptions during inlining."))
llvm::objcarc::getAttachedARCFunctionKind
ARCInstKind getAttachedARCFunctionKind(const CallBase *CB)
This function returns the ARCInstKind of the function attached to operand bundle clang_arc_attachedca...
Definition: ObjCARCUtil.h:60
Profile
Load MIR Sample Profile
Definition: MIRSampleProfile.cpp:70
llvm::pred_empty
bool pred_empty(const BasicBlock *BB)
Definition: CFG.h:118
llvm::updateLoopMetadataDebugLocations
void updateLoopMetadataDebugLocations(Instruction &I, function_ref< Metadata *(Metadata *)> Updater)
Update the debug locations contained within the MD_loop metadata attached to the instruction I,...
Definition: DebugInfo.cpp:373
llvm::FunctionModRefBehavior
FunctionModRefBehavior
Summary of how a function affects memory in the program.
Definition: AliasAnalysis.h:262
llvm::CallInst::isMustTailCall
bool isMustTailCall() const
Definition: Instructions.h:1660
llvm::MDTuple::getTemporary
static TempMDTuple getTemporary(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Return a temporary node.
Definition: Metadata.h:1361
BlockFrequencyInfo.h
llvm::MDNode::getDistinct
static MDTuple * getDistinct(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Definition: Metadata.h:1392
llvm::Value::getName
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:305
llvm::Type::getContext
LLVMContext & getContext() const
Return the LLVMContext in which this type was uniqued.
Definition: Type.h:128
llvm::ValueMap< const Value *, WeakTrackingVH >
llvm::LoadInst
An instruction for reading from memory.
Definition: Instructions.h:173
llvm::DenseMapBase< DenseMap< KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >, KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >::insert
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Definition: DenseMap.h:209
llvm::EHPersonality
EHPersonality
Definition: EHPersonalities.h:21
llvm::CallBase::paramHasAttr
bool paramHasAttr(unsigned ArgNo, Attribute::AttrKind Kind) const
Determine whether the argument or parameter has the given attribute.
Definition: Instructions.cpp:341
llvm::objcarc::GetRCIdentityRoot
const Value * GetRCIdentityRoot(const Value *V)
The RCIdentity root of a value V is a dominating value U for which retaining or releasing U is equiva...
Definition: ObjCARCAnalysisUtils.h:110
llvm::Constant::stripPointerCasts
const Constant * stripPointerCasts() const
Definition: Constant.h:213
llvm::Init
Definition: Record.h:281
llvm::AAResults::getModRefBehavior
FunctionModRefBehavior getModRefBehavior(const CallBase *Call)
Return the behavior of the given call site.
Definition: AliasAnalysis.cpp:422
llvm::AtomicRMWInst
an instruction that atomically reads a memory location, combines it with another value,...
Definition: Instructions.h:714
llvm::ClonedCodeInfo::ContainsCalls
bool ContainsCalls
This is set to true if the cloned code contains a normal call instruction.
Definition: Cloning.h:64
ObjCARCAnalysisUtils.h
llvm::CallBase::doesNotThrow
bool doesNotThrow() const
Determine if the call cannot unwind.
Definition: InstrTypes.h:1899
llvm::Function::ProfileCount::getCount
uint64_t getCount() const
Definition: Function.h:261
llvm::OperandBundleUse::Inputs
ArrayRef< Use > Inputs
Definition: InstrTypes.h:1070
llvm::InlineFunctionInfo::InlinedCallSites
SmallVector< CallBase *, 8 > InlinedCallSites
All of the new call sites inlined into the caller.
Definition: Cloning.h:231
Argument.h
HandleByValArgumentInit
static void HandleByValArgumentInit(Type *ByValType, Value *Dst, Value *Src, Module *M, BasicBlock *InsertBlock, InlineFunctionInfo &IFI)
Definition: InlineFunction.cpp:1367
llvm::BasicBlock::front
const Instruction & front() const
Definition: BasicBlock.h:309
Callee
amdgpu Simplify well known AMD library false FunctionCallee Callee
Definition: AMDGPULibCalls.cpp:186
ObjCARCUtil.h
llvm::BlockFrequencyInfo::setBlockFreqAndScale
void setBlockFreqAndScale(const BasicBlock *ReferenceBB, uint64_t Freq, SmallPtrSetImpl< BasicBlock * > &BlocksToScale)
Set the frequency of ReferenceBB to Freq and scale the frequencies of the blocks in BlocksToScale suc...
Definition: BlockFrequencyInfo.cpp:233
llvm::InlineFunctionInfo::reset
void reset()
Definition: Cloning.h:237
llvm::Function::getParamAlignment
uint64_t getParamAlignment(unsigned ArgNo) const
Extract the alignment for a call or parameter (0=unknown).
Definition: Function.h:435
Constant.h
llvm::ResumeInst
Resume the propagation of an exception.
Definition: Instructions.h:4211
llvm::MDNode::replaceAllUsesWith
void replaceAllUsesWith(Metadata *MD)
RAUW a temporary.
Definition: Metadata.h:1119
llvm::Type::getInt64Ty
static IntegerType * getInt64Ty(LLVMContext &C)
Definition: Type.cpp:240
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:50
llvm::ValueMapIterator
Definition: ValueMap.h:49
llvm::DenseMapBase::end
iterator end()
Definition: DenseMap.h:84
llvm::AMDGPU::SendMsg::Op
Op
Definition: SIDefines.h:345
llvm::PHINode::Create
static PHINode * Create(Type *Ty, unsigned NumReservedValues, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Constructors - NumReservedValues is a hint for the number of incoming edges that this phi node will h...
Definition: Instructions.h:2693
llvm::Function::getArg
Argument * getArg(unsigned i) const
Definition: Function.h:759
llvm::CallBase::arg_size
unsigned arg_size() const
Definition: InstrTypes.h:1339
llvm::AAResults::onlyAccessesInaccessibleMem
static bool onlyAccessesInaccessibleMem(FunctionModRefBehavior MRB)
Checks if functions with the specified behavior are known to read and write at most from memory that ...
Definition: AliasAnalysis.h:706
ProfileCount
Function::ProfileCount ProfileCount
Definition: InlineFunction.cpp:78
llvm::isGuaranteedToTransferExecutionToSuccessor
bool isGuaranteedToTransferExecutionToSuccessor(const Instruction *I)
Return true if this function can prove that the instruction I will always transfer execution to one o...
Definition: ValueTracking.cpp:5435
llvm::TypeSize
Definition: TypeSize.h:435
llvm::ConstantTokenNone::get
static ConstantTokenNone * get(LLVMContext &Context)
Return the ConstantTokenNone.
Definition: Constants.cpp:1470
Casting.h
Function.h
updateCallProfile
static void updateCallProfile(Function *Callee, const ValueToValueMapTy &VMap, const ProfileCount &CalleeEntryCount, const CallBase &TheCall, ProfileSummaryInfo *PSI, BlockFrequencyInfo *CallerBFI)
Update the branch metadata for cloned call instructions.
Definition: InlineFunction.cpp:1595
llvm::Value::hasNUses
bool hasNUses(unsigned N) const
Return true if this Value has exactly N uses.
Definition: Value.cpp:145
llvm::X86II::OB
@ OB
Definition: X86BaseInfo.h:801
llvm::InlineFunctionInfo
This class captures the data input to the InlineFunction call, and records the auxiliary results prod...
Definition: Cloning.h:199
llvm::Function::getFunctionType
FunctionType * getFunctionType() const
Returns the FunctionType for me.
Definition: Function.h:175
llvm::ValueMap::find
iterator find(const KeyT &Val)
Definition: ValueMap.h:156
llvm::Instruction::isEHPad
bool isEHPad() const
Return true if the instruction is a variety of EH-block.
Definition: Instruction.h:662
llvm::InlineResult::failure
static InlineResult failure(const char *Reason)
Definition: InlineCost.h:170
llvm::SmallVectorImpl::clear
void clear()
Definition: SmallVector.h:591
llvm::CallBase::getCalledOperand
Value * getCalledOperand() const
Definition: InstrTypes.h:1389
llvm::BlockFrequencyInfo::getBlockFreq
BlockFrequency getBlockFreq(const BasicBlock *BB) const
getblockFreq - Return block frequency.
Definition: BlockFrequencyInfo.cpp:203
llvm::Function::getPersonalityFn
Constant * getPersonalityFn() const
Get the personality function associated with this function.
Definition: Function.cpp:1906
llvm::Function::arg_begin
arg_iterator arg_begin()
Definition: Function.h:741
EnableNoAliasConversion
static cl::opt< bool > EnableNoAliasConversion("enable-noalias-to-md-conversion", cl::init(true), cl::Hidden, cl::desc("Convert noalias attributes to metadata during inlining."))
llvm::IntrinsicInst
A wrapper class for inspecting calls to intrinsic functions.
Definition: IntrinsicInst.h:46
llvm::AttrBuilder::addDereferenceableAttr
AttrBuilder & addDereferenceableAttr(uint64_t Bytes)
This turns the number of dereferenceable bytes into the form used internally in Attribute.
Definition: Attributes.cpp:1681
llvm::MDBuilder
Definition: MDBuilder.h:35
llvm::Function::front
const BasicBlock & front() const
Definition: Function.h:733
CallGraph.h
llvm::DebugLoc::getLine
unsigned getLine() const
Definition: DebugLoc.cpp:24
llvm::changeToUnreachable
unsigned changeToUnreachable(Instruction *I, bool PreserveLCSSA=false, DomTreeUpdater *DTU=nullptr, MemorySSAUpdater *MSSAU=nullptr)
Insert an unreachable instruction before the specified instruction, making it and the rest of the cod...
Definition: Local.cpp:2122
llvm::BasicBlock::getInstList
const InstListType & getInstList() const
Return the underlying instruction list container.
Definition: BasicBlock.h:364
llvm::InlineFunctionInfo::StaticAllocas
SmallVector< AllocaInst *, 4 > StaticAllocas
InlineFunction fills this in with all static allocas that get copied into the caller.
Definition: Cloning.h:220
llvm::MDNode::isTemporary
bool isTemporary() const
Definition: Metadata.h:1114
Instructions.h
llvm::numbers::phi
constexpr double phi
Definition: MathExtras.h:71
llvm::AllocaInst::isUsedWithInAlloca
bool isUsedWithInAlloca() const
Return true if this alloca is used as an inalloca argument to a call.
Definition: Instructions.h:136
llvm::objcarc::ARCInstKind::None
@ None
anything that is inert from an ARC perspective.
SmallVector.h
llvm::AttrBuilder::hasAttributes
bool hasAttributes() const
Return true if the builder has IR-level attributes.
Definition: Attributes.h:1083
llvm::ilist_iterator::getReverse
ilist_iterator< OptionsT, !IsReverse, IsConst > getReverse() const
Get a reverse iterator to the same node.
Definition: ilist_iterator.h:121
llvm::Instruction::getDebugLoc
const DebugLoc & getDebugLoc() const
Return the debug location for this node as a DebugLoc.
Definition: Instruction.h:367
User.h
llvm::InlineFunctionInfo::UpdateProfile
bool UpdateProfile
Update profile for callee as well as cloned version.
Definition: Cloning.h:235
Dominators.h
NoAliases
static cl::opt< bool > NoAliases("csky-no-aliases", cl::desc("Disable the emission of assembler pseudo instructions"), cl::init(false), cl::Hidden)
updateCallerBFI
static void updateCallerBFI(BasicBlock *CallSiteBlock, const ValueToValueMapTy &VMap, BlockFrequencyInfo *CallerBFI, BlockFrequencyInfo *CalleeBFI, const BasicBlock &CalleeEntryBlock)
Update the block frequencies of the caller after a callee has been inlined.
Definition: InlineFunction.cpp:1566
llvm::CallBase::getArgOperand
Value * getArgOperand(unsigned i) const
Definition: InstrTypes.h:1341
llvm::Instruction::getParent
const BasicBlock * getParent() const
Definition: Instruction.h:91
InstructionSimplify.h
llvm::PHINode
Definition: Instructions.h:2651
llvm::BasicBlock::getTerminator
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:119
llvm::Function::onlyReadsMemory
bool onlyReadsMemory() const
Determine if the function does not access or only reads memory.
Definition: Function.h:503
llvm::BasicBlock::removePredecessor
void removePredecessor(BasicBlock *Pred, bool KeepOneInputPHIs=false)
Update PHI nodes in this BasicBlock before removal of predecessor Pred.
Definition: BasicBlock.cpp:318
inlineRetainOrClaimRVCalls
static void inlineRetainOrClaimRVCalls(CallBase &CB, objcarc::ARCInstKind RVCallKind, const SmallVectorImpl< ReturnInst * > &Returns)
An operand bundle "clang.arc.attachedcall" on a call indicates the call result is implicitly consumed...
Definition: InlineFunction.cpp:1662
llvm::SmallVectorImpl
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:42
llvm::InlineFunction
InlineResult InlineFunction(CallBase &CB, InlineFunctionInfo &IFI, AAResults *CalleeAAR=nullptr, bool InsertLifetime=true, Function *ForwardVarArgsTo=nullptr)
This function inlines the called function into the basic block of the caller.
Definition: InlineFunction.cpp:1748
llvm::CallBase
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1174
llvm::Module::getDataLayout
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.cpp:398
DerivedTypes.h
llvm::SmallPtrSetImpl
A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...
Definition: SmallPtrSet.h:344
llvm::SmallSetVector
A SetVector that performs no allocations if smaller than a certain size.
Definition: SetVector.h:307
llvm::CallInst
This class represents a function call, abstracting a target machine's calling convention.
Definition: Instructions.h:1461
BB
Common register allocation spilling lr str ldr sxth r3 ldr mla r4 can lr mov lr str ldr sxth r3 mla r4 and then merge mul and lr str ldr sxth r3 mla r4 It also increase the likelihood the store may become dead bb27 Successors according to LLVM BB
Definition: README.txt:39
llvm::ValueMap::lookup
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:165
LLVMContext.h
llvm::Value::takeName
void takeName(Value *V)
Transfer the name from V to this value.
Definition: Value.cpp:378
llvm::DebugLoc
A debug info location.
Definition: DebugLoc.h:33
llvm::AllocaInst
an instruction to allocate memory on the stack
Definition: Instructions.h:58
llvm::Function::ProfileCount
Class to represent profile counts.
Definition: Function.h:253
llvm::DebugLoc::getScope
MDNode * getScope() const
Definition: DebugLoc.cpp:34
llvm::User::getOperand
Value * getOperand(unsigned i) const
Definition: User.h:169
llvm::InlineFunctionInfo::GetAssumptionCache
function_ref< AssumptionCache &(Function &)> GetAssumptionCache
Definition: Cloning.h:214
llvm::BasicBlock::getTerminatingMustTailCall
const CallInst * getTerminatingMustTailCall() const
Returns the call instruction marked 'musttail' prior to the terminating return instruction of this ba...
Definition: BasicBlock.cpp:151
llvm::cl::desc
Definition: CommandLine.h:405
Mod
Module * Mod
Definition: PassBuilderBindings.cpp:54
llvm::BranchInst
Conditional or Unconditional Branch instruction.
Definition: Instructions.h:3086
InlinerAttributeWindow
static cl::opt< unsigned > InlinerAttributeWindow("max-inst-checked-for-throw-during-inlining", cl::Hidden, cl::desc("the maximum number of instructions analyzed for may throw during " "attribute inference in inlined body"), cl::init(4))
llvm::ClonedCodeInfo::ContainsDynamicAllocas
bool ContainsDynamicAllocas
This is set to true if the cloned code contains a 'dynamic' alloca.
Definition: Cloning.h:69
llvm::SetVector
A vector that has set insertion semantics.
Definition: SetVector.h:40
llvm::AttributeList::getParamAttrs
AttributeSet getParamAttrs(unsigned ArgNo) const
The attributes for the argument or parameter at the given index are returned.
Definition: Attributes.cpp:1380
llvm::SmallVectorImpl::reserve
void reserve(size_type N)
Definition: SmallVector.h:644
llvm::CallInst::TCK_NoTail
@ TCK_NoTail
Definition: Instructions.h:1642
llvm::IRBuilderBase::CreateAlignmentAssumption
CallInst * CreateAlignmentAssumption(const DataLayout &DL, Value *PtrValue, unsigned Alignment, Value *OffsetValue=nullptr)
Create an assume intrinsic call that represents an alignment assumption on the provided pointer.
Definition: IRBuilder.cpp:1279
Value.h
llvm::InvokeInst::getUnwindDest
BasicBlock * getUnwindDest() const
Definition: Instructions.h:3898
llvm::InlineFunctionInfo::CalleeBFI
BlockFrequencyInfo * CalleeBFI
Definition: Cloning.h:216
llvm::PointerMayBeCapturedBefore
bool PointerMayBeCapturedBefore(const Value *V, bool ReturnCaptures, bool StoreCaptures, const Instruction *I, const DominatorTree *DT, bool IncludeI=false, unsigned MaxUsesToExplore=0, const LoopInfo *LI=nullptr)
PointerMayBeCapturedBefore - Return true if this pointer value may be captured by the enclosing funct...
Definition: CaptureTracking.cpp:269
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::AtomicCmpXchgInst
An instruction that atomically checks whether a specified value is in a memory location,...
Definition: Instructions.h:509
llvm::InlineResult
InlineResult is basically true or false.
Definition: InlineCost.h:164
llvm::Value::users
iterator_range< user_iterator > users()
Definition: Value.h:421
llvm::CallInst::getTailCallKind
TailCallKind getTailCallKind() const
Definition: Instructions.h:1651
llvm::IRBuilderBase::CreateCall
CallInst * CreateCall(FunctionType *FTy, Value *Callee, ArrayRef< Value * > Args=None, const Twine &Name="", MDNode *FPMathTag=nullptr)
Definition: IRBuilder.h:2235
llvm::CallBase::args
iterator_range< User::op_iterator > args()
Iteration adapter for range-for loops.
Definition: InstrTypes.h:1332
SetVector.h
llvm::CallBase::setCallingConv
void setCallingConv(CallingConv::ID CC)
Definition: InstrTypes.h:1459
llvm::SmallVectorImpl::emplace_back
reference emplace_back(ArgTypes &&... Args)
Definition: SmallVector.h:927
llvm::Function::iterator
BasicBlockListType::iterator iterator
Definition: Function.h:66
llvm::SmallPtrSetImpl::insert
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:365
llvm::CallGraphNode::begin
iterator begin()
Definition: CallGraph.h:199