LLVM  4.0.0
Local.cpp
Go to the documentation of this file.
1 //===-- Local.cpp - Functions to perform local transformations ------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This family of functions perform various local transformations to the
11 // program.
12 //
13 //===----------------------------------------------------------------------===//
14 
16 #include "llvm/ADT/DenseMap.h"
17 #include "llvm/ADT/DenseSet.h"
18 #include "llvm/ADT/Hashing.h"
19 #include "llvm/ADT/STLExtras.h"
20 #include "llvm/ADT/SetVector.h"
21 #include "llvm/ADT/SmallPtrSet.h"
22 #include "llvm/ADT/Statistic.h"
28 #include "llvm/IR/CFG.h"
29 #include "llvm/IR/Constants.h"
30 #include "llvm/IR/DIBuilder.h"
31 #include "llvm/IR/DataLayout.h"
32 #include "llvm/IR/DebugInfo.h"
33 #include "llvm/IR/DerivedTypes.h"
34 #include "llvm/IR/Dominators.h"
36 #include "llvm/IR/GlobalAlias.h"
37 #include "llvm/IR/GlobalVariable.h"
38 #include "llvm/IR/IRBuilder.h"
39 #include "llvm/IR/Instructions.h"
40 #include "llvm/IR/IntrinsicInst.h"
41 #include "llvm/IR/Intrinsics.h"
42 #include "llvm/IR/MDBuilder.h"
43 #include "llvm/IR/Metadata.h"
44 #include "llvm/IR/Operator.h"
45 #include "llvm/IR/PatternMatch.h"
46 #include "llvm/IR/ValueHandle.h"
47 #include "llvm/Support/Debug.h"
50 using namespace llvm;
51 using namespace llvm::PatternMatch;
52 
53 #define DEBUG_TYPE "local"
54 
55 STATISTIC(NumRemoved, "Number of unreachable basic blocks removed");
56 
57 //===----------------------------------------------------------------------===//
58 // Local constant propagation.
59 //
60 
61 /// ConstantFoldTerminator - If a terminator instruction is predicated on a
62 /// constant value, convert it into an unconditional branch to the constant
63 /// destination. This is a nontrivial operation because the successors of this
64 /// basic block must have their PHI nodes updated.
65 /// Also calls RecursivelyDeleteTriviallyDeadInstructions() on any branch/switch
66 /// conditions and indirectbr addresses this might make dead if
67 /// DeleteDeadConditions is true.
68 bool llvm::ConstantFoldTerminator(BasicBlock *BB, bool DeleteDeadConditions,
69  const TargetLibraryInfo *TLI) {
71  IRBuilder<> Builder(T);
72 
73  // Branch - See if we are conditional jumping on constant
74  if (BranchInst *BI = dyn_cast<BranchInst>(T)) {
75  if (BI->isUnconditional()) return false; // Can't optimize uncond branch
76  BasicBlock *Dest1 = BI->getSuccessor(0);
77  BasicBlock *Dest2 = BI->getSuccessor(1);
78 
79  if (ConstantInt *Cond = dyn_cast<ConstantInt>(BI->getCondition())) {
80  // Are we branching on constant?
81  // YES. Change to unconditional branch...
82  BasicBlock *Destination = Cond->getZExtValue() ? Dest1 : Dest2;
83  BasicBlock *OldDest = Cond->getZExtValue() ? Dest2 : Dest1;
84 
85  //cerr << "Function: " << T->getParent()->getParent()
86  // << "\nRemoving branch from " << T->getParent()
87  // << "\n\nTo: " << OldDest << endl;
88 
89  // Let the basic block know that we are letting go of it. Based on this,
90  // it will adjust it's PHI nodes.
91  OldDest->removePredecessor(BB);
92 
93  // Replace the conditional branch with an unconditional one.
94  Builder.CreateBr(Destination);
95  BI->eraseFromParent();
96  return true;
97  }
98 
99  if (Dest2 == Dest1) { // Conditional branch to same location?
100  // This branch matches something like this:
101  // br bool %cond, label %Dest, label %Dest
102  // and changes it into: br label %Dest
103 
104  // Let the basic block know that we are letting go of one copy of it.
105  assert(BI->getParent() && "Terminator not inserted in block!");
106  Dest1->removePredecessor(BI->getParent());
107 
108  // Replace the conditional branch with an unconditional one.
109  Builder.CreateBr(Dest1);
110  Value *Cond = BI->getCondition();
111  BI->eraseFromParent();
112  if (DeleteDeadConditions)
114  return true;
115  }
116  return false;
117  }
118 
119  if (SwitchInst *SI = dyn_cast<SwitchInst>(T)) {
120  // If we are switching on a constant, we can convert the switch to an
121  // unconditional branch.
122  ConstantInt *CI = dyn_cast<ConstantInt>(SI->getCondition());
123  BasicBlock *DefaultDest = SI->getDefaultDest();
124  BasicBlock *TheOnlyDest = DefaultDest;
125 
126  // If the default is unreachable, ignore it when searching for TheOnlyDest.
127  if (isa<UnreachableInst>(DefaultDest->getFirstNonPHIOrDbg()) &&
128  SI->getNumCases() > 0) {
129  TheOnlyDest = SI->case_begin().getCaseSuccessor();
130  }
131 
132  // Figure out which case it goes to.
133  for (SwitchInst::CaseIt i = SI->case_begin(), e = SI->case_end();
134  i != e; ++i) {
135  // Found case matching a constant operand?
136  if (i.getCaseValue() == CI) {
137  TheOnlyDest = i.getCaseSuccessor();
138  break;
139  }
140 
141  // Check to see if this branch is going to the same place as the default
142  // dest. If so, eliminate it as an explicit compare.
143  if (i.getCaseSuccessor() == DefaultDest) {
144  MDNode *MD = SI->getMetadata(LLVMContext::MD_prof);
145  unsigned NCases = SI->getNumCases();
146  // Fold the case metadata into the default if there will be any branches
147  // left, unless the metadata doesn't match the switch.
148  if (NCases > 1 && MD && MD->getNumOperands() == 2 + NCases) {
149  // Collect branch weights into a vector.
150  SmallVector<uint32_t, 8> Weights;
151  for (unsigned MD_i = 1, MD_e = MD->getNumOperands(); MD_i < MD_e;
152  ++MD_i) {
153  auto *CI = mdconst::extract<ConstantInt>(MD->getOperand(MD_i));
154  Weights.push_back(CI->getValue().getZExtValue());
155  }
156  // Merge weight of this case to the default weight.
157  unsigned idx = i.getCaseIndex();
158  Weights[0] += Weights[idx+1];
159  // Remove weight for this case.
160  std::swap(Weights[idx+1], Weights.back());
161  Weights.pop_back();
162  SI->setMetadata(LLVMContext::MD_prof,
163  MDBuilder(BB->getContext()).
164  createBranchWeights(Weights));
165  }
166  // Remove this entry.
167  DefaultDest->removePredecessor(SI->getParent());
168  SI->removeCase(i);
169  --i; --e;
170  continue;
171  }
172 
173  // Otherwise, check to see if the switch only branches to one destination.
174  // We do this by reseting "TheOnlyDest" to null when we find two non-equal
175  // destinations.
176  if (i.getCaseSuccessor() != TheOnlyDest) TheOnlyDest = nullptr;
177  }
178 
179  if (CI && !TheOnlyDest) {
180  // Branching on a constant, but not any of the cases, go to the default
181  // successor.
182  TheOnlyDest = SI->getDefaultDest();
183  }
184 
185  // If we found a single destination that we can fold the switch into, do so
186  // now.
187  if (TheOnlyDest) {
188  // Insert the new branch.
189  Builder.CreateBr(TheOnlyDest);
190  BasicBlock *BB = SI->getParent();
191 
192  // Remove entries from PHI nodes which we no longer branch to...
193  for (BasicBlock *Succ : SI->successors()) {
194  // Found case matching a constant operand?
195  if (Succ == TheOnlyDest)
196  TheOnlyDest = nullptr; // Don't modify the first branch to TheOnlyDest
197  else
198  Succ->removePredecessor(BB);
199  }
200 
201  // Delete the old switch.
202  Value *Cond = SI->getCondition();
203  SI->eraseFromParent();
204  if (DeleteDeadConditions)
206  return true;
207  }
208 
209  if (SI->getNumCases() == 1) {
210  // Otherwise, we can fold this switch into a conditional branch
211  // instruction if it has only one non-default destination.
212  SwitchInst::CaseIt FirstCase = SI->case_begin();
213  Value *Cond = Builder.CreateICmpEQ(SI->getCondition(),
214  FirstCase.getCaseValue(), "cond");
215 
216  // Insert the new branch.
217  BranchInst *NewBr = Builder.CreateCondBr(Cond,
218  FirstCase.getCaseSuccessor(),
219  SI->getDefaultDest());
220  MDNode *MD = SI->getMetadata(LLVMContext::MD_prof);
221  if (MD && MD->getNumOperands() == 3) {
222  ConstantInt *SICase =
223  mdconst::dyn_extract<ConstantInt>(MD->getOperand(2));
224  ConstantInt *SIDef =
225  mdconst::dyn_extract<ConstantInt>(MD->getOperand(1));
226  assert(SICase && SIDef);
227  // The TrueWeight should be the weight for the single case of SI.
229  MDBuilder(BB->getContext()).
230  createBranchWeights(SICase->getValue().getZExtValue(),
231  SIDef->getValue().getZExtValue()));
232  }
233 
234  // Update make.implicit metadata to the newly-created conditional branch.
235  MDNode *MakeImplicitMD = SI->getMetadata(LLVMContext::MD_make_implicit);
236  if (MakeImplicitMD)
237  NewBr->setMetadata(LLVMContext::MD_make_implicit, MakeImplicitMD);
238 
239  // Delete the old switch.
240  SI->eraseFromParent();
241  return true;
242  }
243  return false;
244  }
245 
246  if (IndirectBrInst *IBI = dyn_cast<IndirectBrInst>(T)) {
247  // indirectbr blockaddress(@F, @BB) -> br label @BB
248  if (BlockAddress *BA =
249  dyn_cast<BlockAddress>(IBI->getAddress()->stripPointerCasts())) {
250  BasicBlock *TheOnlyDest = BA->getBasicBlock();
251  // Insert the new branch.
252  Builder.CreateBr(TheOnlyDest);
253 
254  for (unsigned i = 0, e = IBI->getNumDestinations(); i != e; ++i) {
255  if (IBI->getDestination(i) == TheOnlyDest)
256  TheOnlyDest = nullptr;
257  else
258  IBI->getDestination(i)->removePredecessor(IBI->getParent());
259  }
260  Value *Address = IBI->getAddress();
261  IBI->eraseFromParent();
262  if (DeleteDeadConditions)
264 
265  // If we didn't find our destination in the IBI successor list, then we
266  // have undefined behavior. Replace the unconditional branch with an
267  // 'unreachable' instruction.
268  if (TheOnlyDest) {
270  new UnreachableInst(BB->getContext(), BB);
271  }
272 
273  return true;
274  }
275  }
276 
277  return false;
278 }
279 
280 
281 //===----------------------------------------------------------------------===//
282 // Local dead code elimination.
283 //
284 
285 /// isInstructionTriviallyDead - Return true if the result produced by the
286 /// instruction is not used, and the instruction has no side effects.
287 ///
289  const TargetLibraryInfo *TLI) {
290  if (!I->use_empty() || isa<TerminatorInst>(I)) return false;
291 
292  // We don't want the landingpad-like instructions removed by anything this
293  // general.
294  if (I->isEHPad())
295  return false;
296 
297  // We don't want debug info removed by anything this general, unless
298  // debug info is empty.
299  if (DbgDeclareInst *DDI = dyn_cast<DbgDeclareInst>(I)) {
300  if (DDI->getAddress())
301  return false;
302  return true;
303  }
304  if (DbgValueInst *DVI = dyn_cast<DbgValueInst>(I)) {
305  if (DVI->getValue())
306  return false;
307  return true;
308  }
309 
310  if (!I->mayHaveSideEffects()) return true;
311 
312  // Special case intrinsics that "may have side effects" but can be deleted
313  // when dead.
314  if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) {
315  // Safe to delete llvm.stacksave if dead.
316  if (II->getIntrinsicID() == Intrinsic::stacksave)
317  return true;
318 
319  // Lifetime intrinsics are dead when their right-hand is undef.
320  if (II->getIntrinsicID() == Intrinsic::lifetime_start ||
321  II->getIntrinsicID() == Intrinsic::lifetime_end)
322  return isa<UndefValue>(II->getArgOperand(1));
323 
324  // Assumptions are dead if their condition is trivially true. Guards on
325  // true are operationally no-ops. In the future we can consider more
326  // sophisticated tradeoffs for guards considering potential for check
327  // widening, but for now we keep things simple.
328  if (II->getIntrinsicID() == Intrinsic::assume ||
329  II->getIntrinsicID() == Intrinsic::experimental_guard) {
330  if (ConstantInt *Cond = dyn_cast<ConstantInt>(II->getArgOperand(0)))
331  return !Cond->isZero();
332 
333  return false;
334  }
335  }
336 
337  if (isAllocLikeFn(I, TLI)) return true;
338 
339  if (CallInst *CI = isFreeCall(I, TLI))
340  if (Constant *C = dyn_cast<Constant>(CI->getArgOperand(0)))
341  return C->isNullValue() || isa<UndefValue>(C);
342 
343  if (CallSite CS = CallSite(I))
344  if (isMathLibCallNoop(CS, TLI))
345  return true;
346 
347  return false;
348 }
349 
350 /// RecursivelyDeleteTriviallyDeadInstructions - If the specified value is a
351 /// trivially dead instruction, delete it. If that makes any of its operands
352 /// trivially dead, delete them too, recursively. Return true if any
353 /// instructions were deleted.
354 bool
356  const TargetLibraryInfo *TLI) {
358  if (!I || !I->use_empty() || !isInstructionTriviallyDead(I, TLI))
359  return false;
360 
362  DeadInsts.push_back(I);
363 
364  do {
365  I = DeadInsts.pop_back_val();
366 
367  // Null out all of the instruction's operands to see if any operand becomes
368  // dead as we go.
369  for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i) {
370  Value *OpV = I->getOperand(i);
371  I->setOperand(i, nullptr);
372 
373  if (!OpV->use_empty()) continue;
374 
375  // If the operand is an instruction that became dead as we nulled out the
376  // operand, and if it is 'trivially' dead, delete it in a future loop
377  // iteration.
378  if (Instruction *OpI = dyn_cast<Instruction>(OpV))
379  if (isInstructionTriviallyDead(OpI, TLI))
380  DeadInsts.push_back(OpI);
381  }
382 
383  I->eraseFromParent();
384  } while (!DeadInsts.empty());
385 
386  return true;
387 }
388 
389 /// areAllUsesEqual - Check whether the uses of a value are all the same.
390 /// This is similar to Instruction::hasOneUse() except this will also return
391 /// true when there are no uses or multiple uses that all refer to the same
392 /// value.
395  Value::user_iterator UE = I->user_end();
396  if (UI == UE)
397  return true;
398 
399  User *TheUse = *UI;
400  for (++UI; UI != UE; ++UI) {
401  if (*UI != TheUse)
402  return false;
403  }
404  return true;
405 }
406 
407 /// RecursivelyDeleteDeadPHINode - If the specified value is an effectively
408 /// dead PHI node, due to being a def-use chain of single-use nodes that
409 /// either forms a cycle or is terminated by a trivially dead instruction,
410 /// delete it. If that makes any of its operands trivially dead, delete them
411 /// too, recursively. Return true if a change was made.
413  const TargetLibraryInfo *TLI) {
415  for (Instruction *I = PN; areAllUsesEqual(I) && !I->mayHaveSideEffects();
416  I = cast<Instruction>(*I->user_begin())) {
417  if (I->use_empty())
419 
420  // If we find an instruction more than once, we're on a cycle that
421  // won't prove fruitful.
422  if (!Visited.insert(I).second) {
423  // Break the cycle and delete the instruction and its operands.
424  I->replaceAllUsesWith(UndefValue::get(I->getType()));
426  return true;
427  }
428  }
429  return false;
430 }
431 
432 static bool
435  const DataLayout &DL,
436  const TargetLibraryInfo *TLI) {
437  if (isInstructionTriviallyDead(I, TLI)) {
438  // Null out all of the instruction's operands to see if any operand becomes
439  // dead as we go.
440  for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i) {
441  Value *OpV = I->getOperand(i);
442  I->setOperand(i, nullptr);
443 
444  if (!OpV->use_empty() || I == OpV)
445  continue;
446 
447  // If the operand is an instruction that became dead as we nulled out the
448  // operand, and if it is 'trivially' dead, delete it in a future loop
449  // iteration.
450  if (Instruction *OpI = dyn_cast<Instruction>(OpV))
451  if (isInstructionTriviallyDead(OpI, TLI))
452  WorkList.insert(OpI);
453  }
454 
455  I->eraseFromParent();
456 
457  return true;
458  }
459 
460  if (Value *SimpleV = SimplifyInstruction(I, DL)) {
461  // Add the users to the worklist. CAREFUL: an instruction can use itself,
462  // in the case of a phi node.
463  for (User *U : I->users()) {
464  if (U != I) {
465  WorkList.insert(cast<Instruction>(U));
466  }
467  }
468 
469  // Replace the instruction with its simplified value.
470  bool Changed = false;
471  if (!I->use_empty()) {
472  I->replaceAllUsesWith(SimpleV);
473  Changed = true;
474  }
475  if (isInstructionTriviallyDead(I, TLI)) {
476  I->eraseFromParent();
477  Changed = true;
478  }
479  return Changed;
480  }
481  return false;
482 }
483 
484 /// SimplifyInstructionsInBlock - Scan the specified basic block and try to
485 /// simplify any instructions in it and recursively delete dead instructions.
486 ///
487 /// This returns true if it changed the code, note that it can delete
488 /// instructions in other blocks as well in this block.
490  const TargetLibraryInfo *TLI) {
491  bool MadeChange = false;
492  const DataLayout &DL = BB->getModule()->getDataLayout();
493 
494 #ifndef NDEBUG
495  // In debug builds, ensure that the terminator of the block is never replaced
496  // or deleted by these simplifications. The idea of simplification is that it
497  // cannot introduce new instructions, and there is no way to replace the
498  // terminator of a block without introducing a new instruction.
499  AssertingVH<Instruction> TerminatorVH(&BB->back());
500 #endif
501 
503  // Iterate over the original function, only adding insts to the worklist
504  // if they actually need to be revisited. This avoids having to pre-init
505  // the worklist with the entire function's worth of instructions.
506  for (BasicBlock::iterator BI = BB->begin(), E = std::prev(BB->end());
507  BI != E;) {
508  assert(!BI->isTerminator());
509  Instruction *I = &*BI;
510  ++BI;
511 
512  // We're visiting this instruction now, so make sure it's not in the
513  // worklist from an earlier visit.
514  if (!WorkList.count(I))
515  MadeChange |= simplifyAndDCEInstruction(I, WorkList, DL, TLI);
516  }
517 
518  while (!WorkList.empty()) {
519  Instruction *I = WorkList.pop_back_val();
520  MadeChange |= simplifyAndDCEInstruction(I, WorkList, DL, TLI);
521  }
522  return MadeChange;
523 }
524 
525 //===----------------------------------------------------------------------===//
526 // Control Flow Graph Restructuring.
527 //
528 
529 
530 /// RemovePredecessorAndSimplify - Like BasicBlock::removePredecessor, this
531 /// method is called when we're about to delete Pred as a predecessor of BB. If
532 /// BB contains any PHI nodes, this drops the entries in the PHI nodes for Pred.
533 ///
534 /// Unlike the removePredecessor method, this attempts to simplify uses of PHI
535 /// nodes that collapse into identity values. For example, if we have:
536 /// x = phi(1, 0, 0, 0)
537 /// y = and x, z
538 ///
539 /// .. and delete the predecessor corresponding to the '1', this will attempt to
540 /// recursively fold the and to 0.
542  // This only adjusts blocks with PHI nodes.
543  if (!isa<PHINode>(BB->begin()))
544  return;
545 
546  // Remove the entries for Pred from the PHI nodes in BB, but do not simplify
547  // them down. This will leave us with single entry phi nodes and other phis
548  // that can be removed.
549  BB->removePredecessor(Pred, true);
550 
551  WeakVH PhiIt = &BB->front();
552  while (PHINode *PN = dyn_cast<PHINode>(PhiIt)) {
553  PhiIt = &*++BasicBlock::iterator(cast<Instruction>(PhiIt));
554  Value *OldPhiIt = PhiIt;
555 
557  continue;
558 
559  // If recursive simplification ended up deleting the next PHI node we would
560  // iterate to, then our iterator is invalid, restart scanning from the top
561  // of the block.
562  if (PhiIt != OldPhiIt) PhiIt = &BB->front();
563  }
564 }
565 
566 
567 /// MergeBasicBlockIntoOnlyPred - DestBB is a block with one predecessor and its
568 /// predecessor is known to have one successor (DestBB!). Eliminate the edge
569 /// between them, moving the instructions in the predecessor into DestBB and
570 /// deleting the predecessor block.
571 ///
573  // If BB has single-entry PHI nodes, fold them.
574  while (PHINode *PN = dyn_cast<PHINode>(DestBB->begin())) {
575  Value *NewVal = PN->getIncomingValue(0);
576  // Replace self referencing PHI with undef, it must be dead.
577  if (NewVal == PN) NewVal = UndefValue::get(PN->getType());
578  PN->replaceAllUsesWith(NewVal);
579  PN->eraseFromParent();
580  }
581 
582  BasicBlock *PredBB = DestBB->getSinglePredecessor();
583  assert(PredBB && "Block doesn't have a single predecessor!");
584 
585  // Zap anything that took the address of DestBB. Not doing this will give the
586  // address an invalid value.
587  if (DestBB->hasAddressTaken()) {
588  BlockAddress *BA = BlockAddress::get(DestBB);
589  Constant *Replacement =
592  BA->getType()));
593  BA->destroyConstant();
594  }
595 
596  // Anything that branched to PredBB now branches to DestBB.
597  PredBB->replaceAllUsesWith(DestBB);
598 
599  // Splice all the instructions from PredBB to DestBB.
600  PredBB->getTerminator()->eraseFromParent();
601  DestBB->getInstList().splice(DestBB->begin(), PredBB->getInstList());
602 
603  // If the PredBB is the entry block of the function, move DestBB up to
604  // become the entry block after we erase PredBB.
605  if (PredBB == &DestBB->getParent()->getEntryBlock())
606  DestBB->moveAfter(PredBB);
607 
608  if (DT) {
609  BasicBlock *PredBBIDom = DT->getNode(PredBB)->getIDom()->getBlock();
610  DT->changeImmediateDominator(DestBB, PredBBIDom);
611  DT->eraseNode(PredBB);
612  }
613  // Nuke BB.
614  PredBB->eraseFromParent();
615 }
616 
617 /// CanMergeValues - Return true if we can choose one of these values to use
618 /// in place of the other. Note that we will always choose the non-undef
619 /// value to keep.
620 static bool CanMergeValues(Value *First, Value *Second) {
621  return First == Second || isa<UndefValue>(First) || isa<UndefValue>(Second);
622 }
623 
624 /// CanPropagatePredecessorsForPHIs - Return true if we can fold BB, an
625 /// almost-empty BB ending in an unconditional branch to Succ, into Succ.
626 ///
627 /// Assumption: Succ is the single successor for BB.
628 ///
630  assert(*succ_begin(BB) == Succ && "Succ is not successor of BB!");
631 
632  DEBUG(dbgs() << "Looking to fold " << BB->getName() << " into "
633  << Succ->getName() << "\n");
634  // Shortcut, if there is only a single predecessor it must be BB and merging
635  // is always safe
636  if (Succ->getSinglePredecessor()) return true;
637 
638  // Make a list of the predecessors of BB
640 
641  // Look at all the phi nodes in Succ, to see if they present a conflict when
642  // merging these blocks
643  for (BasicBlock::iterator I = Succ->begin(); isa<PHINode>(I); ++I) {
644  PHINode *PN = cast<PHINode>(I);
645 
646  // If the incoming value from BB is again a PHINode in
647  // BB which has the same incoming value for *PI as PN does, we can
648  // merge the phi nodes and then the blocks can still be merged
650  if (BBPN && BBPN->getParent() == BB) {
651  for (unsigned PI = 0, PE = PN->getNumIncomingValues(); PI != PE; ++PI) {
652  BasicBlock *IBB = PN->getIncomingBlock(PI);
653  if (BBPreds.count(IBB) &&
654  !CanMergeValues(BBPN->getIncomingValueForBlock(IBB),
655  PN->getIncomingValue(PI))) {
656  DEBUG(dbgs() << "Can't fold, phi node " << PN->getName() << " in "
657  << Succ->getName() << " is conflicting with "
658  << BBPN->getName() << " with regard to common predecessor "
659  << IBB->getName() << "\n");
660  return false;
661  }
662  }
663  } else {
664  Value* Val = PN->getIncomingValueForBlock(BB);
665  for (unsigned PI = 0, PE = PN->getNumIncomingValues(); PI != PE; ++PI) {
666  // See if the incoming value for the common predecessor is equal to the
667  // one for BB, in which case this phi node will not prevent the merging
668  // of the block.
669  BasicBlock *IBB = PN->getIncomingBlock(PI);
670  if (BBPreds.count(IBB) &&
671  !CanMergeValues(Val, PN->getIncomingValue(PI))) {
672  DEBUG(dbgs() << "Can't fold, phi node " << PN->getName() << " in "
673  << Succ->getName() << " is conflicting with regard to common "
674  << "predecessor " << IBB->getName() << "\n");
675  return false;
676  }
677  }
678  }
679  }
680 
681  return true;
682 }
683 
686 
687 /// \brief Determines the value to use as the phi node input for a block.
688 ///
689 /// Select between \p OldVal any value that we know flows from \p BB
690 /// to a particular phi on the basis of which one (if either) is not
691 /// undef. Update IncomingValues based on the selected value.
692 ///
693 /// \param OldVal The value we are considering selecting.
694 /// \param BB The block that the value flows in from.
695 /// \param IncomingValues A map from block-to-value for other phi inputs
696 /// that we have examined.
697 ///
698 /// \returns the selected value.
700  IncomingValueMap &IncomingValues) {
701  if (!isa<UndefValue>(OldVal)) {
702  assert((!IncomingValues.count(BB) ||
703  IncomingValues.find(BB)->second == OldVal) &&
704  "Expected OldVal to match incoming value from BB!");
705 
706  IncomingValues.insert(std::make_pair(BB, OldVal));
707  return OldVal;
708  }
709 
710  IncomingValueMap::const_iterator It = IncomingValues.find(BB);
711  if (It != IncomingValues.end()) return It->second;
712 
713  return OldVal;
714 }
715 
716 /// \brief Create a map from block to value for the operands of a
717 /// given phi.
718 ///
719 /// Create a map from block to value for each non-undef value flowing
720 /// into \p PN.
721 ///
722 /// \param PN The phi we are collecting the map for.
723 /// \param IncomingValues [out] The map from block to value for this phi.
725  IncomingValueMap &IncomingValues) {
726  for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
727  BasicBlock *BB = PN->getIncomingBlock(i);
728  Value *V = PN->getIncomingValue(i);
729 
730  if (!isa<UndefValue>(V))
731  IncomingValues.insert(std::make_pair(BB, V));
732  }
733 }
734 
735 /// \brief Replace the incoming undef values to a phi with the values
736 /// from a block-to-value map.
737 ///
738 /// \param PN The phi we are replacing the undefs in.
739 /// \param IncomingValues A map from block to value.
741  const IncomingValueMap &IncomingValues) {
742  for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) {
743  Value *V = PN->getIncomingValue(i);
744 
745  if (!isa<UndefValue>(V)) continue;
746 
747  BasicBlock *BB = PN->getIncomingBlock(i);
748  IncomingValueMap::const_iterator It = IncomingValues.find(BB);
749  if (It == IncomingValues.end()) continue;
750 
751  PN->setIncomingValue(i, It->second);
752  }
753 }
754 
755 /// \brief Replace a value flowing from a block to a phi with
756 /// potentially multiple instances of that value flowing from the
757 /// block's predecessors to the phi.
758 ///
759 /// \param BB The block with the value flowing into the phi.
760 /// \param BBPreds The predecessors of BB.
761 /// \param PN The phi that we are updating.
763  const PredBlockVector &BBPreds,
764  PHINode *PN) {
765  Value *OldVal = PN->removeIncomingValue(BB, false);
766  assert(OldVal && "No entry in PHI for Pred BB!");
767 
768  IncomingValueMap IncomingValues;
769 
770  // We are merging two blocks - BB, and the block containing PN - and
771  // as a result we need to redirect edges from the predecessors of BB
772  // to go to the block containing PN, and update PN
773  // accordingly. Since we allow merging blocks in the case where the
774  // predecessor and successor blocks both share some predecessors,
775  // and where some of those common predecessors might have undef
776  // values flowing into PN, we want to rewrite those values to be
777  // consistent with the non-undef values.
778 
779  gatherIncomingValuesToPhi(PN, IncomingValues);
780 
781  // If this incoming value is one of the PHI nodes in BB, the new entries
782  // in the PHI node are the entries from the old PHI.
783  if (isa<PHINode>(OldVal) && cast<PHINode>(OldVal)->getParent() == BB) {
784  PHINode *OldValPN = cast<PHINode>(OldVal);
785  for (unsigned i = 0, e = OldValPN->getNumIncomingValues(); i != e; ++i) {
786  // Note that, since we are merging phi nodes and BB and Succ might
787  // have common predecessors, we could end up with a phi node with
788  // identical incoming branches. This will be cleaned up later (and
789  // will trigger asserts if we try to clean it up now, without also
790  // simplifying the corresponding conditional branch).
791  BasicBlock *PredBB = OldValPN->getIncomingBlock(i);
792  Value *PredVal = OldValPN->getIncomingValue(i);
793  Value *Selected = selectIncomingValueForBlock(PredVal, PredBB,
794  IncomingValues);
795 
796  // And add a new incoming value for this predecessor for the
797  // newly retargeted branch.
798  PN->addIncoming(Selected, PredBB);
799  }
800  } else {
801  for (unsigned i = 0, e = BBPreds.size(); i != e; ++i) {
802  // Update existing incoming values in PN for this
803  // predecessor of BB.
804  BasicBlock *PredBB = BBPreds[i];
805  Value *Selected = selectIncomingValueForBlock(OldVal, PredBB,
806  IncomingValues);
807 
808  // And add a new incoming value for this predecessor for the
809  // newly retargeted branch.
810  PN->addIncoming(Selected, PredBB);
811  }
812  }
813 
814  replaceUndefValuesInPhi(PN, IncomingValues);
815 }
816 
817 /// TryToSimplifyUncondBranchFromEmptyBlock - BB is known to contain an
818 /// unconditional branch, and contains no instructions other than PHI nodes,
819 /// potential side-effect free intrinsics and the branch. If possible,
820 /// eliminate BB by rewriting all the predecessors to branch to the successor
821 /// block and return true. If we can't transform, return false.
823  assert(BB != &BB->getParent()->getEntryBlock() &&
824  "TryToSimplifyUncondBranchFromEmptyBlock called on entry block!");
825 
826  // We can't eliminate infinite loops.
827  BasicBlock *Succ = cast<BranchInst>(BB->getTerminator())->getSuccessor(0);
828  if (BB == Succ) return false;
829 
830  // Check to see if merging these blocks would cause conflicts for any of the
831  // phi nodes in BB or Succ. If not, we can safely merge.
832  if (!CanPropagatePredecessorsForPHIs(BB, Succ)) return false;
833 
834  // Check for cases where Succ has multiple predecessors and a PHI node in BB
835  // has uses which will not disappear when the PHI nodes are merged. It is
836  // possible to handle such cases, but difficult: it requires checking whether
837  // BB dominates Succ, which is non-trivial to calculate in the case where
838  // Succ has multiple predecessors. Also, it requires checking whether
839  // constructing the necessary self-referential PHI node doesn't introduce any
840  // conflicts; this isn't too difficult, but the previous code for doing this
841  // was incorrect.
842  //
843  // Note that if this check finds a live use, BB dominates Succ, so BB is
844  // something like a loop pre-header (or rarely, a part of an irreducible CFG);
845  // folding the branch isn't profitable in that case anyway.
846  if (!Succ->getSinglePredecessor()) {
847  BasicBlock::iterator BBI = BB->begin();
848  while (isa<PHINode>(*BBI)) {
849  for (Use &U : BBI->uses()) {
850  if (PHINode* PN = dyn_cast<PHINode>(U.getUser())) {
851  if (PN->getIncomingBlock(U) != BB)
852  return false;
853  } else {
854  return false;
855  }
856  }
857  ++BBI;
858  }
859  }
860 
861  DEBUG(dbgs() << "Killing Trivial BB: \n" << *BB);
862 
863  if (isa<PHINode>(Succ->begin())) {
864  // If there is more than one pred of succ, and there are PHI nodes in
865  // the successor, then we need to add incoming edges for the PHI nodes
866  //
867  const PredBlockVector BBPreds(pred_begin(BB), pred_end(BB));
868 
869  // Loop over all of the PHI nodes in the successor of BB.
870  for (BasicBlock::iterator I = Succ->begin(); isa<PHINode>(I); ++I) {
871  PHINode *PN = cast<PHINode>(I);
872 
873  redirectValuesFromPredecessorsToPhi(BB, BBPreds, PN);
874  }
875  }
876 
877  if (Succ->getSinglePredecessor()) {
878  // BB is the only predecessor of Succ, so Succ will end up with exactly
879  // the same predecessors BB had.
880 
881  // Copy over any phi, debug or lifetime instruction.
883  Succ->getInstList().splice(Succ->getFirstNonPHI()->getIterator(),
884  BB->getInstList());
885  } else {
886  while (PHINode *PN = dyn_cast<PHINode>(&BB->front())) {
887  // We explicitly check for such uses in CanPropagatePredecessorsForPHIs.
888  assert(PN->use_empty() && "There shouldn't be any uses here!");
889  PN->eraseFromParent();
890  }
891  }
892 
893  // If the unconditional branch we replaced contains llvm.loop metadata, we
894  // add the metadata to the branch instructions in the predecessors.
895  unsigned LoopMDKind = BB->getContext().getMDKindID("llvm.loop");
896  Instruction *TI = BB->getTerminator();
897  if (TI)
898  if (MDNode *LoopMD = TI->getMetadata(LoopMDKind))
899  for (pred_iterator PI = pred_begin(BB), E = pred_end(BB); PI != E; ++PI) {
900  BasicBlock *Pred = *PI;
901  Pred->getTerminator()->setMetadata(LoopMDKind, LoopMD);
902  }
903 
904  // Everything that jumped to BB now goes to Succ.
905  BB->replaceAllUsesWith(Succ);
906  if (!Succ->hasName()) Succ->takeName(BB);
907  BB->eraseFromParent(); // Delete the old basic block.
908  return true;
909 }
910 
911 /// EliminateDuplicatePHINodes - Check for and eliminate duplicate PHI
912 /// nodes in this block. This doesn't try to be clever about PHI nodes
913 /// which differ only in the order of the incoming values, but instcombine
914 /// orders them so it usually won't matter.
915 ///
917  // This implementation doesn't currently consider undef operands
918  // specially. Theoretically, two phis which are identical except for
919  // one having an undef where the other doesn't could be collapsed.
920 
921  struct PHIDenseMapInfo {
922  static PHINode *getEmptyKey() {
924  }
925  static PHINode *getTombstoneKey() {
927  }
928  static unsigned getHashValue(PHINode *PN) {
929  // Compute a hash value on the operands. Instcombine will likely have
930  // sorted them, which helps expose duplicates, but we have to check all
931  // the operands to be safe in case instcombine hasn't run.
932  return static_cast<unsigned>(hash_combine(
934  hash_combine_range(PN->block_begin(), PN->block_end())));
935  }
936  static bool isEqual(PHINode *LHS, PHINode *RHS) {
937  if (LHS == getEmptyKey() || LHS == getTombstoneKey() ||
938  RHS == getEmptyKey() || RHS == getTombstoneKey())
939  return LHS == RHS;
940  return LHS->isIdenticalTo(RHS);
941  }
942  };
943 
944  // Set of unique PHINodes.
946 
947  // Examine each PHI.
948  bool Changed = false;
949  for (auto I = BB->begin(); PHINode *PN = dyn_cast<PHINode>(I++);) {
950  auto Inserted = PHISet.insert(PN);
951  if (!Inserted.second) {
952  // A duplicate. Replace this PHI with its duplicate.
953  PN->replaceAllUsesWith(*Inserted.first);
954  PN->eraseFromParent();
955  Changed = true;
956 
957  // The RAUW can change PHIs that we already visited. Start over from the
958  // beginning.
959  PHISet.clear();
960  I = BB->begin();
961  }
962  }
963 
964  return Changed;
965 }
966 
967 /// enforceKnownAlignment - If the specified pointer points to an object that
968 /// we control, modify the object's alignment to PrefAlign. This isn't
969 /// often possible though. If alignment is important, a more reliable approach
970 /// is to simply align all global variables and allocation instructions to
971 /// their preferred alignment from the beginning.
972 ///
973 static unsigned enforceKnownAlignment(Value *V, unsigned Align,
974  unsigned PrefAlign,
975  const DataLayout &DL) {
976  assert(PrefAlign > Align);
977 
978  V = V->stripPointerCasts();
979 
980  if (AllocaInst *AI = dyn_cast<AllocaInst>(V)) {
981  // TODO: ideally, computeKnownBits ought to have used
982  // AllocaInst::getAlignment() in its computation already, making
983  // the below max redundant. But, as it turns out,
984  // stripPointerCasts recurses through infinite layers of bitcasts,
985  // while computeKnownBits is not allowed to traverse more than 6
986  // levels.
987  Align = std::max(AI->getAlignment(), Align);
988  if (PrefAlign <= Align)
989  return Align;
990 
991  // If the preferred alignment is greater than the natural stack alignment
992  // then don't round up. This avoids dynamic stack realignment.
993  if (DL.exceedsNaturalStackAlignment(PrefAlign))
994  return Align;
995  AI->setAlignment(PrefAlign);
996  return PrefAlign;
997  }
998 
999  if (auto *GO = dyn_cast<GlobalObject>(V)) {
1000  // TODO: as above, this shouldn't be necessary.
1001  Align = std::max(GO->getAlignment(), Align);
1002  if (PrefAlign <= Align)
1003  return Align;
1004 
1005  // If there is a large requested alignment and we can, bump up the alignment
1006  // of the global. If the memory we set aside for the global may not be the
1007  // memory used by the final program then it is impossible for us to reliably
1008  // enforce the preferred alignment.
1009  if (!GO->canIncreaseAlignment())
1010  return Align;
1011 
1012  GO->setAlignment(PrefAlign);
1013  return PrefAlign;
1014  }
1015 
1016  return Align;
1017 }
1018 
1019 unsigned llvm::getOrEnforceKnownAlignment(Value *V, unsigned PrefAlign,
1020  const DataLayout &DL,
1021  const Instruction *CxtI,
1022  AssumptionCache *AC,
1023  const DominatorTree *DT) {
1024  assert(V->getType()->isPointerTy() &&
1025  "getOrEnforceKnownAlignment expects a pointer!");
1026  unsigned BitWidth = DL.getPointerTypeSizeInBits(V->getType());
1027 
1028  APInt KnownZero(BitWidth, 0), KnownOne(BitWidth, 0);
1029  computeKnownBits(V, KnownZero, KnownOne, DL, 0, AC, CxtI, DT);
1030  unsigned TrailZ = KnownZero.countTrailingOnes();
1031 
1032  // Avoid trouble with ridiculously large TrailZ values, such as
1033  // those computed from a null pointer.
1034  TrailZ = std::min(TrailZ, unsigned(sizeof(unsigned) * CHAR_BIT - 1));
1035 
1036  unsigned Align = 1u << std::min(BitWidth - 1, TrailZ);
1037 
1038  // LLVM doesn't support alignments larger than this currently.
1039  Align = std::min(Align, +Value::MaximumAlignment);
1040 
1041  if (PrefAlign > Align)
1042  Align = enforceKnownAlignment(V, Align, PrefAlign, DL);
1043 
1044  // We don't need to make any adjustment.
1045  return Align;
1046 }
1047 
1048 ///===---------------------------------------------------------------------===//
1049 /// Dbg Intrinsic utilities
1050 ///
1051 
1052 /// See if there is a dbg.value intrinsic for DIVar before I.
1053 static bool LdStHasDebugValue(DILocalVariable *DIVar, DIExpression *DIExpr,
1054  Instruction *I) {
1055  // Since we can't guarantee that the original dbg.declare instrinsic
1056  // is removed by LowerDbgDeclare(), we need to make sure that we are
1057  // not inserting the same dbg.value intrinsic over and over.
1059  if (PrevI != I->getParent()->getInstList().begin()) {
1060  --PrevI;
1061  if (DbgValueInst *DVI = dyn_cast<DbgValueInst>(PrevI))
1062  if (DVI->getValue() == I->getOperand(0) &&
1063  DVI->getOffset() == 0 &&
1064  DVI->getVariable() == DIVar &&
1065  DVI->getExpression() == DIExpr)
1066  return true;
1067  }
1068  return false;
1069 }
1070 
1071 /// See if there is a dbg.value intrinsic for DIVar for the PHI node.
1072 static bool PhiHasDebugValue(DILocalVariable *DIVar,
1073  DIExpression *DIExpr,
1074  PHINode *APN) {
1075  // Since we can't guarantee that the original dbg.declare instrinsic
1076  // is removed by LowerDbgDeclare(), we need to make sure that we are
1077  // not inserting the same dbg.value intrinsic over and over.
1078  DbgValueList DbgValues;
1079  FindAllocaDbgValues(DbgValues, APN);
1080  for (auto DVI : DbgValues) {
1081  assert (DVI->getValue() == APN);
1082  assert (DVI->getOffset() == 0);
1083  if ((DVI->getVariable() == DIVar) && (DVI->getExpression() == DIExpr))
1084  return true;
1085  }
1086  return false;
1087 }
1088 
1089 /// Inserts a llvm.dbg.value intrinsic before a store to an alloca'd value
1090 /// that has an associated llvm.dbg.decl intrinsic.
1092  StoreInst *SI, DIBuilder &Builder) {
1093  auto *DIVar = DDI->getVariable();
1094  auto *DIExpr = DDI->getExpression();
1095  assert(DIVar && "Missing variable");
1096 
1097  // If an argument is zero extended then use argument directly. The ZExt
1098  // may be zapped by an optimization pass in future.
1099  Argument *ExtendedArg = nullptr;
1100  if (ZExtInst *ZExt = dyn_cast<ZExtInst>(SI->getOperand(0)))
1101  ExtendedArg = dyn_cast<Argument>(ZExt->getOperand(0));
1102  if (SExtInst *SExt = dyn_cast<SExtInst>(SI->getOperand(0)))
1103  ExtendedArg = dyn_cast<Argument>(SExt->getOperand(0));
1104  if (ExtendedArg) {
1105  // We're now only describing a subset of the variable. The fragment we're
1106  // describing will always be smaller than the variable size, because
1107  // VariableSize == Size of Alloca described by DDI. Since SI stores
1108  // to the alloca described by DDI, if it's first operand is an extend,
1109  // we're guaranteed that before extension, the value was narrower than
1110  // the size of the alloca, hence the size of the described variable.
1112  unsigned FragmentOffset = 0;
1113  // If this already is a bit fragment, we drop the bit fragment from the
1114  // expression and record the offset.
1115  auto Fragment = DIExpr->getFragmentInfo();
1116  if (Fragment) {
1117  Ops.append(DIExpr->elements_begin(), DIExpr->elements_end()-3);
1118  FragmentOffset = Fragment->OffsetInBits;
1119  } else {
1120  Ops.append(DIExpr->elements_begin(), DIExpr->elements_end());
1121  }
1123  Ops.push_back(FragmentOffset);
1124  const DataLayout &DL = DDI->getModule()->getDataLayout();
1125  Ops.push_back(DL.getTypeSizeInBits(ExtendedArg->getType()));
1126  auto NewDIExpr = Builder.createExpression(Ops);
1127  if (!LdStHasDebugValue(DIVar, NewDIExpr, SI))
1128  Builder.insertDbgValueIntrinsic(ExtendedArg, 0, DIVar, NewDIExpr,
1129  DDI->getDebugLoc(), SI);
1130  } else if (!LdStHasDebugValue(DIVar, DIExpr, SI))
1131  Builder.insertDbgValueIntrinsic(SI->getOperand(0), 0, DIVar, DIExpr,
1132  DDI->getDebugLoc(), SI);
1133 }
1134 
1135 /// Inserts a llvm.dbg.value intrinsic before a load of an alloca'd value
1136 /// that has an associated llvm.dbg.decl intrinsic.
1138  LoadInst *LI, DIBuilder &Builder) {
1139  auto *DIVar = DDI->getVariable();
1140  auto *DIExpr = DDI->getExpression();
1141  assert(DIVar && "Missing variable");
1142 
1143  if (LdStHasDebugValue(DIVar, DIExpr, LI))
1144  return;
1145 
1146  // We are now tracking the loaded value instead of the address. In the
1147  // future if multi-location support is added to the IR, it might be
1148  // preferable to keep tracking both the loaded value and the original
1149  // address in case the alloca can not be elided.
1150  Instruction *DbgValue = Builder.insertDbgValueIntrinsic(
1151  LI, 0, DIVar, DIExpr, DDI->getDebugLoc(), (Instruction *)nullptr);
1152  DbgValue->insertAfter(LI);
1153 }
1154 
1155 /// Inserts a llvm.dbg.value intrinsic after a phi
1156 /// that has an associated llvm.dbg.decl intrinsic.
1158  PHINode *APN, DIBuilder &Builder) {
1159  auto *DIVar = DDI->getVariable();
1160  auto *DIExpr = DDI->getExpression();
1161  assert(DIVar && "Missing variable");
1162 
1163  if (PhiHasDebugValue(DIVar, DIExpr, APN))
1164  return;
1165 
1166  BasicBlock *BB = APN->getParent();
1167  auto InsertionPt = BB->getFirstInsertionPt();
1168 
1169  // The block may be a catchswitch block, which does not have a valid
1170  // insertion point.
1171  // FIXME: Insert dbg.value markers in the successors when appropriate.
1172  if (InsertionPt != BB->end())
1173  Builder.insertDbgValueIntrinsic(APN, 0, DIVar, DIExpr, DDI->getDebugLoc(),
1174  &*InsertionPt);
1175 }
1176 
1177 /// Determine whether this alloca is either a VLA or an array.
1178 static bool isArray(AllocaInst *AI) {
1179  return AI->isArrayAllocation() ||
1180  AI->getType()->getElementType()->isArrayTy();
1181 }
1182 
1183 /// LowerDbgDeclare - Lowers llvm.dbg.declare intrinsics into appropriate set
1184 /// of llvm.dbg.value intrinsics.
1186  DIBuilder DIB(*F.getParent(), /*AllowUnresolved*/ false);
1188  for (auto &FI : F)
1189  for (Instruction &BI : FI)
1190  if (auto DDI = dyn_cast<DbgDeclareInst>(&BI))
1191  Dbgs.push_back(DDI);
1192 
1193  if (Dbgs.empty())
1194  return false;
1195 
1196  for (auto &I : Dbgs) {
1197  DbgDeclareInst *DDI = I;
1198  AllocaInst *AI = dyn_cast_or_null<AllocaInst>(DDI->getAddress());
1199  // If this is an alloca for a scalar variable, insert a dbg.value
1200  // at each load and store to the alloca and erase the dbg.declare.
1201  // The dbg.values allow tracking a variable even if it is not
1202  // stored on the stack, while the dbg.declare can only describe
1203  // the stack slot (and at a lexical-scope granularity). Later
1204  // passes will attempt to elide the stack slot.
1205  if (AI && !isArray(AI)) {
1206  for (auto &AIUse : AI->uses()) {
1207  User *U = AIUse.getUser();
1208  if (StoreInst *SI = dyn_cast<StoreInst>(U)) {
1209  if (AIUse.getOperandNo() == 1)
1211  } else if (LoadInst *LI = dyn_cast<LoadInst>(U)) {
1212  ConvertDebugDeclareToDebugValue(DDI, LI, DIB);
1213  } else if (CallInst *CI = dyn_cast<CallInst>(U)) {
1214  // This is a call by-value or some other instruction that
1215  // takes a pointer to the variable. Insert a *value*
1216  // intrinsic that describes the alloca.
1217  SmallVector<uint64_t, 1> NewDIExpr;
1218  auto *DIExpr = DDI->getExpression();
1219  NewDIExpr.push_back(dwarf::DW_OP_deref);
1220  NewDIExpr.append(DIExpr->elements_begin(), DIExpr->elements_end());
1221  DIB.insertDbgValueIntrinsic(AI, 0, DDI->getVariable(),
1222  DIB.createExpression(NewDIExpr),
1223  DDI->getDebugLoc(), CI);
1224  }
1225  }
1226  DDI->eraseFromParent();
1227  }
1228  }
1229  return true;
1230 }
1231 
1232 /// FindAllocaDbgDeclare - Finds the llvm.dbg.declare intrinsic describing the
1233 /// alloca 'V', if any.
1235  if (auto *L = LocalAsMetadata::getIfExists(V))
1236  if (auto *MDV = MetadataAsValue::getIfExists(V->getContext(), L))
1237  for (User *U : MDV->users())
1238  if (DbgDeclareInst *DDI = dyn_cast<DbgDeclareInst>(U))
1239  return DDI;
1240 
1241  return nullptr;
1242 }
1243 
1244 /// FindAllocaDbgValues - Finds the llvm.dbg.value intrinsics describing the
1245 /// alloca 'V', if any.
1247  if (auto *L = LocalAsMetadata::getIfExists(V))
1248  if (auto *MDV = MetadataAsValue::getIfExists(V->getContext(), L))
1249  for (User *U : MDV->users())
1250  if (DbgValueInst *DVI = dyn_cast<DbgValueInst>(U))
1251  DbgValues.push_back(DVI);
1252 }
1253 
1255  Expr.push_back(dwarf::DW_OP_deref);
1256 }
1257 
1259  if (Offset > 0) {
1260  Expr.push_back(dwarf::DW_OP_plus);
1261  Expr.push_back(Offset);
1262  } else if (Offset < 0) {
1263  Expr.push_back(dwarf::DW_OP_minus);
1264  Expr.push_back(-Offset);
1265  }
1266 }
1267 
1269  DIExpression *DIExpr, bool Deref,
1270  int Offset) {
1271  if (!Deref && !Offset)
1272  return DIExpr;
1273  // Create a copy of the original DIDescriptor for user variable, prepending
1274  // "deref" operation to a list of address elements, as new llvm.dbg.declare
1275  // will take a value storing address of the memory for variable, not
1276  // alloca itself.
1277  SmallVector<uint64_t, 4> NewDIExpr;
1278  if (Deref)
1279  DIExprAddDeref(NewDIExpr);
1280  DIExprAddOffset(NewDIExpr, Offset);
1281  if (DIExpr)
1282  NewDIExpr.append(DIExpr->elements_begin(), DIExpr->elements_end());
1283  return Builder.createExpression(NewDIExpr);
1284 }
1285 
1287  Instruction *InsertBefore, DIBuilder &Builder,
1288  bool Deref, int Offset) {
1289  DbgDeclareInst *DDI = FindAllocaDbgDeclare(Address);
1290  if (!DDI)
1291  return false;
1292  DebugLoc Loc = DDI->getDebugLoc();
1293  auto *DIVar = DDI->getVariable();
1294  auto *DIExpr = DDI->getExpression();
1295  assert(DIVar && "Missing variable");
1296 
1297  DIExpr = BuildReplacementDIExpr(Builder, DIExpr, Deref, Offset);
1298 
1299  // Insert llvm.dbg.declare immediately after the original alloca, and remove
1300  // old llvm.dbg.declare.
1301  Builder.insertDeclare(NewAddress, DIVar, DIExpr, Loc, InsertBefore);
1302  DDI->eraseFromParent();
1303  return true;
1304 }
1305 
1307  DIBuilder &Builder, bool Deref, int Offset) {
1308  return replaceDbgDeclare(AI, NewAllocaAddress, AI->getNextNode(), Builder,
1309  Deref, Offset);
1310 }
1311 
1312 static void replaceOneDbgValueForAlloca(DbgValueInst *DVI, Value *NewAddress,
1313  DIBuilder &Builder, int Offset) {
1314  DebugLoc Loc = DVI->getDebugLoc();
1315  auto *DIVar = DVI->getVariable();
1316  auto *DIExpr = DVI->getExpression();
1317  assert(DIVar && "Missing variable");
1318 
1319  // This is an alloca-based llvm.dbg.value. The first thing it should do with
1320  // the alloca pointer is dereference it. Otherwise we don't know how to handle
1321  // it and give up.
1322  if (!DIExpr || DIExpr->getNumElements() < 1 ||
1323  DIExpr->getElement(0) != dwarf::DW_OP_deref)
1324  return;
1325 
1326  // Insert the offset immediately after the first deref.
1327  // We could just change the offset argument of dbg.value, but it's unsigned...
1328  if (Offset) {
1329  SmallVector<uint64_t, 4> NewDIExpr;
1330  DIExprAddDeref(NewDIExpr);
1331  DIExprAddOffset(NewDIExpr, Offset);
1332  NewDIExpr.append(DIExpr->elements_begin() + 1, DIExpr->elements_end());
1333  DIExpr = Builder.createExpression(NewDIExpr);
1334  }
1335 
1336  Builder.insertDbgValueIntrinsic(NewAddress, DVI->getOffset(), DIVar, DIExpr,
1337  Loc, DVI);
1338  DVI->eraseFromParent();
1339 }
1340 
1342  DIBuilder &Builder, int Offset) {
1343  if (auto *L = LocalAsMetadata::getIfExists(AI))
1344  if (auto *MDV = MetadataAsValue::getIfExists(AI->getContext(), L))
1345  for (auto UI = MDV->use_begin(), UE = MDV->use_end(); UI != UE;) {
1346  Use &U = *UI++;
1347  if (auto *DVI = dyn_cast<DbgValueInst>(U.getUser()))
1348  replaceOneDbgValueForAlloca(DVI, NewAllocaAddress, Builder, Offset);
1349  }
1350 }
1351 
1353  unsigned NumDeadInst = 0;
1354  // Delete the instructions backwards, as it has a reduced likelihood of
1355  // having to update as many def-use and use-def chains.
1356  Instruction *EndInst = BB->getTerminator(); // Last not to be deleted.
1357  while (EndInst != &BB->front()) {
1358  // Delete the next to last instruction.
1359  Instruction *Inst = &*--EndInst->getIterator();
1360  if (!Inst->use_empty() && !Inst->getType()->isTokenTy())
1361  Inst->replaceAllUsesWith(UndefValue::get(Inst->getType()));
1362  if (Inst->isEHPad() || Inst->getType()->isTokenTy()) {
1363  EndInst = Inst;
1364  continue;
1365  }
1366  if (!isa<DbgInfoIntrinsic>(Inst))
1367  ++NumDeadInst;
1368  Inst->eraseFromParent();
1369  }
1370  return NumDeadInst;
1371 }
1372 
1373 unsigned llvm::changeToUnreachable(Instruction *I, bool UseLLVMTrap,
1374  bool PreserveLCSSA) {
1375  BasicBlock *BB = I->getParent();
1376  // Loop over all of the successors, removing BB's entry from any PHI
1377  // nodes.
1378  for (BasicBlock *Successor : successors(BB))
1379  Successor->removePredecessor(BB, PreserveLCSSA);
1380 
1381  // Insert a call to llvm.trap right before this. This turns the undefined
1382  // behavior into a hard fail instead of falling through into random code.
1383  if (UseLLVMTrap) {
1384  Function *TrapFn =
1385  Intrinsic::getDeclaration(BB->getParent()->getParent(), Intrinsic::trap);
1386  CallInst *CallTrap = CallInst::Create(TrapFn, "", I);
1387  CallTrap->setDebugLoc(I->getDebugLoc());
1388  }
1389  new UnreachableInst(I->getContext(), I);
1390 
1391  // All instructions after this are dead.
1392  unsigned NumInstrsRemoved = 0;
1393  BasicBlock::iterator BBI = I->getIterator(), BBE = BB->end();
1394  while (BBI != BBE) {
1395  if (!BBI->use_empty())
1396  BBI->replaceAllUsesWith(UndefValue::get(BBI->getType()));
1397  BB->getInstList().erase(BBI++);
1398  ++NumInstrsRemoved;
1399  }
1400  return NumInstrsRemoved;
1401 }
1402 
1403 /// changeToCall - Convert the specified invoke into a normal call.
1404 static void changeToCall(InvokeInst *II) {
1407  II->getOperandBundlesAsDefs(OpBundles);
1408  CallInst *NewCall = CallInst::Create(II->getCalledValue(), Args, OpBundles,
1409  "", II);
1410  NewCall->takeName(II);
1411  NewCall->setCallingConv(II->getCallingConv());
1412  NewCall->setAttributes(II->getAttributes());
1413  NewCall->setDebugLoc(II->getDebugLoc());
1414  II->replaceAllUsesWith(NewCall);
1415 
1416  // Follow the call by a branch to the normal destination.
1417  BranchInst::Create(II->getNormalDest(), II);
1418 
1419  // Update PHI nodes in the unwind destination
1421  II->eraseFromParent();
1422 }
1423 
1425  BasicBlock *UnwindEdge) {
1426  BasicBlock *BB = CI->getParent();
1427 
1428  // Convert this function call into an invoke instruction. First, split the
1429  // basic block.
1430  BasicBlock *Split =
1431  BB->splitBasicBlock(CI->getIterator(), CI->getName() + ".noexc");
1432 
1433  // Delete the unconditional branch inserted by splitBasicBlock
1434  BB->getInstList().pop_back();
1435 
1436  // Create the new invoke instruction.
1437  SmallVector<Value *, 8> InvokeArgs(CI->arg_begin(), CI->arg_end());
1439 
1440  CI->getOperandBundlesAsDefs(OpBundles);
1441 
1442  // Note: we're round tripping operand bundles through memory here, and that
1443  // can potentially be avoided with a cleverer API design that we do not have
1444  // as of this time.
1445 
1446  InvokeInst *II = InvokeInst::Create(CI->getCalledValue(), Split, UnwindEdge,
1447  InvokeArgs, OpBundles, CI->getName(), BB);
1448  II->setDebugLoc(CI->getDebugLoc());
1449  II->setCallingConv(CI->getCallingConv());
1450  II->setAttributes(CI->getAttributes());
1451 
1452  // Make sure that anything using the call now uses the invoke! This also
1453  // updates the CallGraph if present, because it uses a WeakVH.
1454  CI->replaceAllUsesWith(II);
1455 
1456  // Delete the original call
1457  Split->getInstList().pop_front();
1458  return Split;
1459 }
1460 
1462  SmallPtrSetImpl<BasicBlock*> &Reachable) {
1463 
1465  BasicBlock *BB = &F.front();
1466  Worklist.push_back(BB);
1467  Reachable.insert(BB);
1468  bool Changed = false;
1469  do {
1470  BB = Worklist.pop_back_val();
1471 
1472  // Do a quick scan of the basic block, turning any obviously unreachable
1473  // instructions into LLVM unreachable insts. The instruction combining pass
1474  // canonicalizes unreachable insts into stores to null or undef.
1475  for (Instruction &I : *BB) {
1476  // Assumptions that are known to be false are equivalent to unreachable.
1477  // Also, if the condition is undefined, then we make the choice most
1478  // beneficial to the optimizer, and choose that to also be unreachable.
1479  if (auto *II = dyn_cast<IntrinsicInst>(&I)) {
1480  if (II->getIntrinsicID() == Intrinsic::assume) {
1481  if (match(II->getArgOperand(0), m_CombineOr(m_Zero(), m_Undef()))) {
1482  // Don't insert a call to llvm.trap right before the unreachable.
1483  changeToUnreachable(II, false);
1484  Changed = true;
1485  break;
1486  }
1487  }
1488 
1489  if (II->getIntrinsicID() == Intrinsic::experimental_guard) {
1490  // A call to the guard intrinsic bails out of the current compilation
1491  // unit if the predicate passed to it is false. If the predicate is a
1492  // constant false, then we know the guard will bail out of the current
1493  // compile unconditionally, so all code following it is dead.
1494  //
1495  // Note: unlike in llvm.assume, it is not "obviously profitable" for
1496  // guards to treat `undef` as `false` since a guard on `undef` can
1497  // still be useful for widening.
1498  if (match(II->getArgOperand(0), m_Zero()))
1499  if (!isa<UnreachableInst>(II->getNextNode())) {
1500  changeToUnreachable(II->getNextNode(), /*UseLLVMTrap=*/ false);
1501  Changed = true;
1502  break;
1503  }
1504  }
1505  }
1506 
1507  if (auto *CI = dyn_cast<CallInst>(&I)) {
1508  Value *Callee = CI->getCalledValue();
1509  if (isa<ConstantPointerNull>(Callee) || isa<UndefValue>(Callee)) {
1510  changeToUnreachable(CI, /*UseLLVMTrap=*/false);
1511  Changed = true;
1512  break;
1513  }
1514  if (CI->doesNotReturn()) {
1515  // If we found a call to a no-return function, insert an unreachable
1516  // instruction after it. Make sure there isn't *already* one there
1517  // though.
1518  if (!isa<UnreachableInst>(CI->getNextNode())) {
1519  // Don't insert a call to llvm.trap right before the unreachable.
1520  changeToUnreachable(CI->getNextNode(), false);
1521  Changed = true;
1522  }
1523  break;
1524  }
1525  }
1526 
1527  // Store to undef and store to null are undefined and used to signal that
1528  // they should be changed to unreachable by passes that can't modify the
1529  // CFG.
1530  if (auto *SI = dyn_cast<StoreInst>(&I)) {
1531  // Don't touch volatile stores.
1532  if (SI->isVolatile()) continue;
1533 
1534  Value *Ptr = SI->getOperand(1);
1535 
1536  if (isa<UndefValue>(Ptr) ||
1537  (isa<ConstantPointerNull>(Ptr) &&
1538  SI->getPointerAddressSpace() == 0)) {
1539  changeToUnreachable(SI, true);
1540  Changed = true;
1541  break;
1542  }
1543  }
1544  }
1545 
1546  TerminatorInst *Terminator = BB->getTerminator();
1547  if (auto *II = dyn_cast<InvokeInst>(Terminator)) {
1548  // Turn invokes that call 'nounwind' functions into ordinary calls.
1549  Value *Callee = II->getCalledValue();
1550  if (isa<ConstantPointerNull>(Callee) || isa<UndefValue>(Callee)) {
1551  changeToUnreachable(II, true);
1552  Changed = true;
1553  } else if (II->doesNotThrow() && canSimplifyInvokeNoUnwind(&F)) {
1554  if (II->use_empty() && II->onlyReadsMemory()) {
1555  // jump to the normal destination branch.
1556  BranchInst::Create(II->getNormalDest(), II);
1557  II->getUnwindDest()->removePredecessor(II->getParent());
1558  II->eraseFromParent();
1559  } else
1560  changeToCall(II);
1561  Changed = true;
1562  }
1563  } else if (auto *CatchSwitch = dyn_cast<CatchSwitchInst>(Terminator)) {
1564  // Remove catchpads which cannot be reached.
1565  struct CatchPadDenseMapInfo {
1566  static CatchPadInst *getEmptyKey() {
1568  }
1569  static CatchPadInst *getTombstoneKey() {
1571  }
1572  static unsigned getHashValue(CatchPadInst *CatchPad) {
1573  return static_cast<unsigned>(hash_combine_range(
1574  CatchPad->value_op_begin(), CatchPad->value_op_end()));
1575  }
1576  static bool isEqual(CatchPadInst *LHS, CatchPadInst *RHS) {
1577  if (LHS == getEmptyKey() || LHS == getTombstoneKey() ||
1578  RHS == getEmptyKey() || RHS == getTombstoneKey())
1579  return LHS == RHS;
1580  return LHS->isIdenticalTo(RHS);
1581  }
1582  };
1583 
1584  // Set of unique CatchPads.
1586  CatchPadDenseMapInfo, detail::DenseSetPair<CatchPadInst *>>
1587  HandlerSet;
1588  detail::DenseSetEmpty Empty;
1589  for (CatchSwitchInst::handler_iterator I = CatchSwitch->handler_begin(),
1590  E = CatchSwitch->handler_end();
1591  I != E; ++I) {
1592  BasicBlock *HandlerBB = *I;
1593  auto *CatchPad = cast<CatchPadInst>(HandlerBB->getFirstNonPHI());
1594  if (!HandlerSet.insert({CatchPad, Empty}).second) {
1595  CatchSwitch->removeHandler(I);
1596  --I;
1597  --E;
1598  Changed = true;
1599  }
1600  }
1601  }
1602 
1603  Changed |= ConstantFoldTerminator(BB, true);
1604  for (BasicBlock *Successor : successors(BB))
1605  if (Reachable.insert(Successor).second)
1606  Worklist.push_back(Successor);
1607  } while (!Worklist.empty());
1608  return Changed;
1609 }
1610 
1612  TerminatorInst *TI = BB->getTerminator();
1613 
1614  if (auto *II = dyn_cast<InvokeInst>(TI)) {
1615  changeToCall(II);
1616  return;
1617  }
1618 
1619  TerminatorInst *NewTI;
1620  BasicBlock *UnwindDest;
1621 
1622  if (auto *CRI = dyn_cast<CleanupReturnInst>(TI)) {
1623  NewTI = CleanupReturnInst::Create(CRI->getCleanupPad(), nullptr, CRI);
1624  UnwindDest = CRI->getUnwindDest();
1625  } else if (auto *CatchSwitch = dyn_cast<CatchSwitchInst>(TI)) {
1626  auto *NewCatchSwitch = CatchSwitchInst::Create(
1627  CatchSwitch->getParentPad(), nullptr, CatchSwitch->getNumHandlers(),
1628  CatchSwitch->getName(), CatchSwitch);
1629  for (BasicBlock *PadBB : CatchSwitch->handlers())
1630  NewCatchSwitch->addHandler(PadBB);
1631 
1632  NewTI = NewCatchSwitch;
1633  UnwindDest = CatchSwitch->getUnwindDest();
1634  } else {
1635  llvm_unreachable("Could not find unwind successor");
1636  }
1637 
1638  NewTI->takeName(TI);
1639  NewTI->setDebugLoc(TI->getDebugLoc());
1640  UnwindDest->removePredecessor(BB);
1641  TI->replaceAllUsesWith(NewTI);
1642  TI->eraseFromParent();
1643 }
1644 
1645 /// removeUnreachableBlocksFromFn - Remove blocks that are not reachable, even
1646 /// if they are in a dead cycle. Return true if a change was made, false
1647 /// otherwise.
1649  SmallPtrSet<BasicBlock*, 16> Reachable;
1650  bool Changed = markAliveBlocks(F, Reachable);
1651 
1652  // If there are unreachable blocks in the CFG...
1653  if (Reachable.size() == F.size())
1654  return Changed;
1655 
1656  assert(Reachable.size() < F.size());
1657  NumRemoved += F.size()-Reachable.size();
1658 
1659  // Loop over all of the basic blocks that are not reachable, dropping all of
1660  // their internal references...
1661  for (Function::iterator BB = ++F.begin(), E = F.end(); BB != E; ++BB) {
1662  if (Reachable.count(&*BB))
1663  continue;
1664 
1665  for (BasicBlock *Successor : successors(&*BB))
1666  if (Reachable.count(Successor))
1667  Successor->removePredecessor(&*BB);
1668  if (LVI)
1669  LVI->eraseBlock(&*BB);
1670  BB->dropAllReferences();
1671  }
1672 
1673  for (Function::iterator I = ++F.begin(); I != F.end();)
1674  if (!Reachable.count(&*I))
1675  I = F.getBasicBlockList().erase(I);
1676  else
1677  ++I;
1678 
1679  return true;
1680 }
1681 
1683  ArrayRef<unsigned> KnownIDs) {
1685  K->dropUnknownNonDebugMetadata(KnownIDs);
1686  K->getAllMetadataOtherThanDebugLoc(Metadata);
1687  for (const auto &MD : Metadata) {
1688  unsigned Kind = MD.first;
1689  MDNode *JMD = J->getMetadata(Kind);
1690  MDNode *KMD = MD.second;
1691 
1692  switch (Kind) {
1693  default:
1694  K->setMetadata(Kind, nullptr); // Remove unknown metadata
1695  break;
1696  case LLVMContext::MD_dbg:
1697  llvm_unreachable("getAllMetadataOtherThanDebugLoc returned a MD_dbg");
1698  case LLVMContext::MD_tbaa:
1699  K->setMetadata(Kind, MDNode::getMostGenericTBAA(JMD, KMD));
1700  break;
1702  K->setMetadata(Kind, MDNode::getMostGenericAliasScope(JMD, KMD));
1703  break;
1706  K->setMetadata(Kind, MDNode::intersect(JMD, KMD));
1707  break;
1708  case LLVMContext::MD_range:
1709  K->setMetadata(Kind, MDNode::getMostGenericRange(JMD, KMD));
1710  break;
1712  K->setMetadata(Kind, MDNode::getMostGenericFPMath(JMD, KMD));
1713  break;
1715  // Only set the !invariant.load if it is present in both instructions.
1716  K->setMetadata(Kind, JMD);
1717  break;
1719  // Only set the !nonnull if it is present in both instructions.
1720  K->setMetadata(Kind, JMD);
1721  break;
1723  // Preserve !invariant.group in K.
1724  break;
1725  case LLVMContext::MD_align:
1726  K->setMetadata(Kind,
1728  break;
1731  K->setMetadata(Kind,
1733  break;
1734  }
1735  }
1736  // Set !invariant.group from J if J has it. If both instructions have it
1737  // then we will just pick it from J - even when they are different.
1738  // Also make sure that K is load or store - f.e. combining bitcast with load
1739  // could produce bitcast with invariant.group metadata, which is invalid.
1740  // FIXME: we should try to preserve both invariant.group md if they are
1741  // different, but right now instruction can only have one invariant.group.
1742  if (auto *JMD = J->getMetadata(LLVMContext::MD_invariant_group))
1743  if (isa<LoadInst>(K) || isa<StoreInst>(K))
1745 }
1746 
1748  unsigned KnownIDs[] = {
1755  combineMetadata(K, J, KnownIDs);
1756 }
1757 
1759  DominatorTree &DT,
1760  const BasicBlockEdge &Root) {
1761  assert(From->getType() == To->getType());
1762 
1763  unsigned Count = 0;
1764  for (Value::use_iterator UI = From->use_begin(), UE = From->use_end();
1765  UI != UE; ) {
1766  Use &U = *UI++;
1767  if (DT.dominates(Root, U)) {
1768  U.set(To);
1769  DEBUG(dbgs() << "Replace dominated use of '"
1770  << From->getName() << "' as "
1771  << *To << " in " << *U << "\n");
1772  ++Count;
1773  }
1774  }
1775  return Count;
1776 }
1777 
1779  DominatorTree &DT,
1780  const BasicBlock *BB) {
1781  assert(From->getType() == To->getType());
1782 
1783  unsigned Count = 0;
1784  for (Value::use_iterator UI = From->use_begin(), UE = From->use_end();
1785  UI != UE;) {
1786  Use &U = *UI++;
1787  auto *I = cast<Instruction>(U.getUser());
1788  if (DT.properlyDominates(BB, I->getParent())) {
1789  U.set(To);
1790  DEBUG(dbgs() << "Replace dominated use of '" << From->getName() << "' as "
1791  << *To << " in " << *U << "\n");
1792  ++Count;
1793  }
1794  }
1795  return Count;
1796 }
1797 
1799  // Check if the function is specifically marked as a gc leaf function.
1800  if (CS.hasFnAttr("gc-leaf-function"))
1801  return true;
1802  if (const Function *F = CS.getCalledFunction()) {
1803  if (F->hasFnAttribute("gc-leaf-function"))
1804  return true;
1805 
1806  if (auto IID = F->getIntrinsicID())
1807  // Most LLVM intrinsics do not take safepoints.
1808  return IID != Intrinsic::experimental_gc_statepoint &&
1809  IID != Intrinsic::experimental_deoptimize;
1810  }
1811 
1812  return false;
1813 }
1814 
1815 namespace {
1816 /// A potential constituent of a bitreverse or bswap expression. See
1817 /// collectBitParts for a fuller explanation.
1818 struct BitPart {
1819  BitPart(Value *P, unsigned BW) : Provider(P) {
1820  Provenance.resize(BW);
1821  }
1822 
1823  /// The Value that this is a bitreverse/bswap of.
1824  Value *Provider;
1825  /// The "provenance" of each bit. Provenance[A] = B means that bit A
1826  /// in Provider becomes bit B in the result of this expression.
1827  SmallVector<int8_t, 32> Provenance; // int8_t means max size is i128.
1828 
1829  enum { Unset = -1 };
1830 };
1831 } // end anonymous namespace
1832 
1833 /// Analyze the specified subexpression and see if it is capable of providing
1834 /// pieces of a bswap or bitreverse. The subexpression provides a potential
1835 /// piece of a bswap or bitreverse if it can be proven that each non-zero bit in
1836 /// the output of the expression came from a corresponding bit in some other
1837 /// value. This function is recursive, and the end result is a mapping of
1838 /// bitnumber to bitnumber. It is the caller's responsibility to validate that
1839 /// the bitnumber to bitnumber mapping is correct for a bswap or bitreverse.
1840 ///
1841 /// For example, if the current subexpression if "(shl i32 %X, 24)" then we know
1842 /// that the expression deposits the low byte of %X into the high byte of the
1843 /// result and that all other bits are zero. This expression is accepted and a
1844 /// BitPart is returned with Provider set to %X and Provenance[24-31] set to
1845 /// [0-7].
1846 ///
1847 /// To avoid revisiting values, the BitPart results are memoized into the
1848 /// provided map. To avoid unnecessary copying of BitParts, BitParts are
1849 /// constructed in-place in the \c BPS map. Because of this \c BPS needs to
1850 /// store BitParts objects, not pointers. As we need the concept of a nullptr
1851 /// BitParts (Value has been analyzed and the analysis failed), we an Optional
1852 /// type instead to provide the same functionality.
1853 ///
1854 /// Because we pass around references into \c BPS, we must use a container that
1855 /// does not invalidate internal references (std::map instead of DenseMap).
1856 ///
1857 static const Optional<BitPart> &
1858 collectBitParts(Value *V, bool MatchBSwaps, bool MatchBitReversals,
1859  std::map<Value *, Optional<BitPart>> &BPS) {
1860  auto I = BPS.find(V);
1861  if (I != BPS.end())
1862  return I->second;
1863 
1864  auto &Result = BPS[V] = None;
1865  auto BitWidth = cast<IntegerType>(V->getType())->getBitWidth();
1866 
1867  if (Instruction *I = dyn_cast<Instruction>(V)) {
1868  // If this is an or instruction, it may be an inner node of the bswap.
1869  if (I->getOpcode() == Instruction::Or) {
1870  auto &A = collectBitParts(I->getOperand(0), MatchBSwaps,
1871  MatchBitReversals, BPS);
1872  auto &B = collectBitParts(I->getOperand(1), MatchBSwaps,
1873  MatchBitReversals, BPS);
1874  if (!A || !B)
1875  return Result;
1876 
1877  // Try and merge the two together.
1878  if (!A->Provider || A->Provider != B->Provider)
1879  return Result;
1880 
1881  Result = BitPart(A->Provider, BitWidth);
1882  for (unsigned i = 0; i < A->Provenance.size(); ++i) {
1883  if (A->Provenance[i] != BitPart::Unset &&
1884  B->Provenance[i] != BitPart::Unset &&
1885  A->Provenance[i] != B->Provenance[i])
1886  return Result = None;
1887 
1888  if (A->Provenance[i] == BitPart::Unset)
1889  Result->Provenance[i] = B->Provenance[i];
1890  else
1891  Result->Provenance[i] = A->Provenance[i];
1892  }
1893 
1894  return Result;
1895  }
1896 
1897  // If this is a logical shift by a constant, recurse then shift the result.
1898  if (I->isLogicalShift() && isa<ConstantInt>(I->getOperand(1))) {
1899  unsigned BitShift =
1900  cast<ConstantInt>(I->getOperand(1))->getLimitedValue(~0U);
1901  // Ensure the shift amount is defined.
1902  if (BitShift > BitWidth)
1903  return Result;
1904 
1905  auto &Res = collectBitParts(I->getOperand(0), MatchBSwaps,
1906  MatchBitReversals, BPS);
1907  if (!Res)
1908  return Result;
1909  Result = Res;
1910 
1911  // Perform the "shift" on BitProvenance.
1912  auto &P = Result->Provenance;
1913  if (I->getOpcode() == Instruction::Shl) {
1914  P.erase(std::prev(P.end(), BitShift), P.end());
1915  P.insert(P.begin(), BitShift, BitPart::Unset);
1916  } else {
1917  P.erase(P.begin(), std::next(P.begin(), BitShift));
1918  P.insert(P.end(), BitShift, BitPart::Unset);
1919  }
1920 
1921  return Result;
1922  }
1923 
1924  // If this is a logical 'and' with a mask that clears bits, recurse then
1925  // unset the appropriate bits.
1926  if (I->getOpcode() == Instruction::And &&
1927  isa<ConstantInt>(I->getOperand(1))) {
1928  APInt Bit(I->getType()->getPrimitiveSizeInBits(), 1);
1929  const APInt &AndMask = cast<ConstantInt>(I->getOperand(1))->getValue();
1930 
1931  // Check that the mask allows a multiple of 8 bits for a bswap, for an
1932  // early exit.
1933  unsigned NumMaskedBits = AndMask.countPopulation();
1934  if (!MatchBitReversals && NumMaskedBits % 8 != 0)
1935  return Result;
1936 
1937  auto &Res = collectBitParts(I->getOperand(0), MatchBSwaps,
1938  MatchBitReversals, BPS);
1939  if (!Res)
1940  return Result;
1941  Result = Res;
1942 
1943  for (unsigned i = 0; i < BitWidth; ++i, Bit <<= 1)
1944  // If the AndMask is zero for this bit, clear the bit.
1945  if ((AndMask & Bit) == 0)
1946  Result->Provenance[i] = BitPart::Unset;
1947  return Result;
1948  }
1949 
1950  // If this is a zext instruction zero extend the result.
1951  if (I->getOpcode() == Instruction::ZExt) {
1952  auto &Res = collectBitParts(I->getOperand(0), MatchBSwaps,
1953  MatchBitReversals, BPS);
1954  if (!Res)
1955  return Result;
1956 
1957  Result = BitPart(Res->Provider, BitWidth);
1958  auto NarrowBitWidth =
1959  cast<IntegerType>(cast<ZExtInst>(I)->getSrcTy())->getBitWidth();
1960  for (unsigned i = 0; i < NarrowBitWidth; ++i)
1961  Result->Provenance[i] = Res->Provenance[i];
1962  for (unsigned i = NarrowBitWidth; i < BitWidth; ++i)
1963  Result->Provenance[i] = BitPart::Unset;
1964  return Result;
1965  }
1966  }
1967 
1968  // Okay, we got to something that isn't a shift, 'or' or 'and'. This must be
1969  // the input value to the bswap/bitreverse.
1970  Result = BitPart(V, BitWidth);
1971  for (unsigned i = 0; i < BitWidth; ++i)
1972  Result->Provenance[i] = i;
1973  return Result;
1974 }
1975 
1976 static bool bitTransformIsCorrectForBSwap(unsigned From, unsigned To,
1977  unsigned BitWidth) {
1978  if (From % 8 != To % 8)
1979  return false;
1980  // Convert from bit indices to byte indices and check for a byte reversal.
1981  From >>= 3;
1982  To >>= 3;
1983  BitWidth >>= 3;
1984  return From == BitWidth - To - 1;
1985 }
1986 
1987 static bool bitTransformIsCorrectForBitReverse(unsigned From, unsigned To,
1988  unsigned BitWidth) {
1989  return From == BitWidth - To - 1;
1990 }
1991 
1992 /// Given an OR instruction, check to see if this is a bitreverse
1993 /// idiom. If so, insert the new intrinsic and return true.
1995  Instruction *I, bool MatchBSwaps, bool MatchBitReversals,
1996  SmallVectorImpl<Instruction *> &InsertedInsts) {
1998  return false;
1999  if (!MatchBSwaps && !MatchBitReversals)
2000  return false;
2001  IntegerType *ITy = dyn_cast<IntegerType>(I->getType());
2002  if (!ITy || ITy->getBitWidth() > 128)
2003  return false; // Can't do vectors or integers > 128 bits.
2004  unsigned BW = ITy->getBitWidth();
2005 
2006  unsigned DemandedBW = BW;
2007  IntegerType *DemandedTy = ITy;
2008  if (I->hasOneUse()) {
2009  if (TruncInst *Trunc = dyn_cast<TruncInst>(I->user_back())) {
2010  DemandedTy = cast<IntegerType>(Trunc->getType());
2011  DemandedBW = DemandedTy->getBitWidth();
2012  }
2013  }
2014 
2015  // Try to find all the pieces corresponding to the bswap.
2016  std::map<Value *, Optional<BitPart>> BPS;
2017  auto Res = collectBitParts(I, MatchBSwaps, MatchBitReversals, BPS);
2018  if (!Res)
2019  return false;
2020  auto &BitProvenance = Res->Provenance;
2021 
2022  // Now, is the bit permutation correct for a bswap or a bitreverse? We can
2023  // only byteswap values with an even number of bytes.
2024  bool OKForBSwap = DemandedBW % 16 == 0, OKForBitReverse = true;
2025  for (unsigned i = 0; i < DemandedBW; ++i) {
2026  OKForBSwap &=
2027  bitTransformIsCorrectForBSwap(BitProvenance[i], i, DemandedBW);
2028  OKForBitReverse &=
2029  bitTransformIsCorrectForBitReverse(BitProvenance[i], i, DemandedBW);
2030  }
2031 
2032  Intrinsic::ID Intrin;
2033  if (OKForBSwap && MatchBSwaps)
2034  Intrin = Intrinsic::bswap;
2035  else if (OKForBitReverse && MatchBitReversals)
2036  Intrin = Intrinsic::bitreverse;
2037  else
2038  return false;
2039 
2040  if (ITy != DemandedTy) {
2041  Function *F = Intrinsic::getDeclaration(I->getModule(), Intrin, DemandedTy);
2042  Value *Provider = Res->Provider;
2043  IntegerType *ProviderTy = cast<IntegerType>(Provider->getType());
2044  // We may need to truncate the provider.
2045  if (DemandedTy != ProviderTy) {
2046  auto *Trunc = CastInst::Create(Instruction::Trunc, Provider, DemandedTy,
2047  "trunc", I);
2048  InsertedInsts.push_back(Trunc);
2049  Provider = Trunc;
2050  }
2051  auto *CI = CallInst::Create(F, Provider, "rev", I);
2052  InsertedInsts.push_back(CI);
2053  auto *ExtInst = CastInst::Create(Instruction::ZExt, CI, ITy, "zext", I);
2054  InsertedInsts.push_back(ExtInst);
2055  return true;
2056  }
2057 
2058  Function *F = Intrinsic::getDeclaration(I->getModule(), Intrin, ITy);
2059  InsertedInsts.push_back(CallInst::Create(F, Res->Provider, "rev", I));
2060  return true;
2061 }
2062 
2063 // CodeGen has special handling for some string functions that may replace
2064 // them with target-specific intrinsics. Since that'd skip our interceptors
2065 // in ASan/MSan/TSan/DFSan, and thus make us miss some memory accesses,
2066 // we mark affected calls as NoBuiltin, which will disable optimization
2067 // in CodeGen.
2069  CallInst *CI, const TargetLibraryInfo *TLI) {
2070  Function *F = CI->getCalledFunction();
2072  if (F && !F->hasLocalLinkage() && F->hasName() &&
2073  TLI->getLibFunc(F->getName(), Func) && TLI->hasOptimizedCodeGen(Func) &&
2074  !F->doesNotAccessMemory())
2075  CI->addAttribute(AttributeSet::FunctionIndex, Attribute::NoBuiltin);
2076 }
MachineLoop * L
AttributeSet getAttributes() const
Return the parameter attributes for this call.
static unsigned getBitWidth(Type *Ty, const DataLayout &DL)
Returns the bitwidth of the given scalar or pointer type (if unknown returns 0).
const NoneType None
Definition: None.h:23
const Value * getCalledValue() const
Get a pointer to the function that is invoked by this instruction.
static bool markAliveBlocks(Function &F, SmallPtrSetImpl< BasicBlock * > &Reachable)
Definition: Local.cpp:1461
SymbolTableList< Instruction >::iterator eraseFromParent()
This method unlinks 'this' from the containing basic block and deletes it.
Definition: Instruction.cpp:76
void computeKnownBits(const Value *V, APInt &KnownZero, APInt &KnownOne, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
Determine which bits of V are known to be either zero or one and return them in the KnownZero/KnownOn...
use_iterator use_end()
Definition: Value.h:318
use_iterator_impl< Use > use_iterator
Definition: Value.h:304
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:102
bool replaceDbgDeclareForAlloca(AllocaInst *AI, Value *NewAllocaAddress, DIBuilder &Builder, bool Deref, int Offset=0)
Replaces llvm.dbg.declare instruction when the alloca it describes is replaced with a new value...
Definition: Local.cpp:1306
BranchInst * CreateCondBr(Value *Cond, BasicBlock *True, BasicBlock *False, MDNode *BranchWeights=nullptr, MDNode *Unpredictable=nullptr)
Create a conditional 'br Cond, TrueDest, FalseDest' instruction.
Definition: IRBuilder.h:699
class_match< UndefValue > m_Undef()
Match an arbitrary undef constant.
Definition: PatternMatch.h:80
ConstantIntTy * getCaseValue()
Resolves case value for current case.
bool properlyDominates(const DomTreeNodeBase< NodeT > *A, const DomTreeNodeBase< NodeT > *B) const
properlyDominates - Returns true iff A dominates B and A != B.
iterator_range< use_iterator > uses()
Definition: Value.h:326
void removePredecessor(BasicBlock *Pred, bool DontDeleteUselessPHIs=false)
Notify the BasicBlock that the predecessor Pred is no longer able to reach it.
Definition: BasicBlock.cpp:281
static unsigned enforceKnownAlignment(Value *V, unsigned Align, unsigned PrefAlign, const DataLayout &DL)
enforceKnownAlignment - If the specified pointer points to an object that we control, modify the object's alignment to PrefAlign.
Definition: Local.cpp:973
void addIncoming(Value *V, BasicBlock *BB)
Add an incoming value to the end of the PHI list.
unsigned getOrEnforceKnownAlignment(Value *V, unsigned 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:1019
LLVM Argument representation.
Definition: Argument.h:34
void replaceDbgValueForAlloca(AllocaInst *AI, Value *NewAllocaAddress, DIBuilder &Builder, int Offset=0)
Replaces multiple llvm.dbg.value instructions when the alloca it describes is replaced with a new val...
Definition: Local.cpp:1341
uint64_t getZExtValue() const
Get zero extended value.
Definition: APInt.h:1309
const Instruction & back() const
Definition: BasicBlock.h:242
NodeTy * getNextNode()
Get the next node, or nullptr for the list tail.
Definition: ilist_node.h:274
bool hasName() const
Definition: Value.h:236
STATISTIC(NumFunctions,"Total number of functions")
iterator erase(iterator where)
Definition: ilist.h:280
size_t i
AttributeSet getAttributes() const
Return the parameter attributes for this invoke.
void dropUnknownNonDebugMetadata(ArrayRef< unsigned > KnownIDs)
Drop all unknown metadata except for debug locations.
Definition: Metadata.cpp:1156
static bool CanPropagatePredecessorsForPHIs(BasicBlock *BB, BasicBlock *Succ)
CanPropagatePredecessorsForPHIs - Return true if we can fold BB, an almost-empty BB ending in an unco...
Definition: Local.cpp:629
DbgDeclareInst * FindAllocaDbgDeclare(Value *V)
Finds the llvm.dbg.declare intrinsic corresponding to an alloca, if any.
Definition: Local.cpp:1234
iterator end()
Definition: Function.h:537
match_zero m_Zero()
Match an arbitrary zero/null constant.
Definition: PatternMatch.h:137
Implements a dense probed hash-table based set.
Definition: DenseSet.h:202
This class represents zero extension of integer types.
unsigned getNumOperands() const
Definition: User.h:167
unsigned getNumOperands() const
Return number of MDNode operands.
Definition: Metadata.h:1040
unsigned getPointerTypeSizeInBits(Type *) const
Layout pointer size, in bits, based on the type.
Definition: DataLayout.cpp:617
value_op_iterator value_op_begin()
Definition: User.h:231
static MDNode * getMostGenericAliasScope(MDNode *A, MDNode *B)
Definition: Metadata.cpp:883
This class represents a function call, abstracting a target machine's calling convention.
This file contains the declarations for metadata subclasses.
size_type count(PtrType Ptr) const
count - Return 1 if the specified pointer is in the set, 0 otherwise.
Definition: SmallPtrSet.h:380
void MergeBasicBlockIntoOnlyPred(BasicBlock *BB, DominatorTree *DT=nullptr)
BB is a block with one predecessor and its predecessor is known to have one successor (BB!)...
Definition: Local.cpp:572
bool mayHaveSideEffects() const
Return true if the instruction may have side effects.
Definition: Instruction.h:450
static Constant * getIntToPtr(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1682
A cache of .assume calls within a function.
bool isTokenTy() const
Return true if this is 'token'.
Definition: Type.h:192
value_op_iterator value_op_end()
Definition: User.h:234
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:100
static void replaceUndefValuesInPhi(PHINode *PN, const IncomingValueMap &IncomingValues)
Replace the incoming undef values to a phi with the values from a block-to-value map.
Definition: Local.cpp:740
bool SimplifyInstructionsInBlock(BasicBlock *BB, const TargetLibraryInfo *TLI=nullptr)
Scan the specified basic block and try to simplify any instructions in it and recursively delete dead...
Definition: Local.cpp:489
A debug info location.
Definition: DebugLoc.h:34
const Instruction & front() const
Definition: BasicBlock.h:240
Metadata node.
Definition: Metadata.h:830
This class represents a sign extension of integer types.
An instruction for reading from memory.
Definition: Instructions.h:164
unsigned getBitWidth() const
Get the number of bits in this IntegerType.
Definition: DerivedTypes.h:65
void RemovePredecessorAndSimplify(BasicBlock *BB, BasicBlock *Pred)
Like BasicBlock::removePredecessor, this method is called when we're about to delete Pred as a predec...
Definition: Local.cpp:541
static Value * selectIncomingValueForBlock(Value *OldVal, BasicBlock *BB, IncomingValueMap &IncomingValues)
Determines the value to use as the phi node input for a block.
Definition: Local.cpp:699
Type * getElementType() const
Definition: DerivedTypes.h:462
unsigned changeToUnreachable(Instruction *I, bool UseLLVMTrap, bool PreserveLCSSA=false)
Insert an unreachable instruction before the specified instruction, making it and the rest of the cod...
Definition: Local.cpp:1373
unsigned replaceDominatedUsesWith(Value *From, Value *To, DominatorTree &DT, const BasicBlockEdge &Edge)
Replace each use of 'From' with 'To' if that use is dominated by the given edge.
Definition: Local.cpp:1758
Instruction * insertDbgValueIntrinsic(llvm::Value *Val, uint64_t Offset, DILocalVariable *VarInfo, DIExpression *Expr, const DILocation *DL, BasicBlock *InsertAtEnd)
Insert a new llvm.dbg.value intrinsic call.
Definition: DIBuilder.cpp:836
uint64_t getOffset() const
void setAttributes(AttributeSet Attrs)
Set the parameter attributes for this invoke.
const CallInst * isFreeCall(const Value *I, const TargetLibraryInfo *TLI)
isFreeCall - Returns non-null if the value is a call to the builtin free()
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:191
block_iterator block_end()
A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...
Definition: SmallPtrSet.h:345
iterator begin()
Instruction iterator methods.
Definition: BasicBlock.h:228
void setCallingConv(CallingConv::ID CC)
bool isArrayAllocation() const
Return true if there is an allocation size parameter to the allocation instruction that is not 1...
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Definition: DenseMap.h:172
Value * getAddress() const
Definition: IntrinsicInst.h:91
The address of a basic block.
Definition: Constants.h:822
bool match(Val *V, const Pattern &P)
Definition: PatternMatch.h:41
Value * removeIncomingValue(unsigned Idx, bool DeletePHIIfEmpty=true)
Remove an incoming value.
bool isIdenticalTo(const Instruction *I) const
Return true if the specified instruction is exactly identical to the current one. ...
const APInt & getValue() const
Return the constant as an APInt value reference.
Definition: Constants.h:143
const Module * getModule() const
Return the module owning the function this basic block belongs to, or nullptr it the function does no...
Definition: BasicBlock.cpp:116
Instruction * insertDeclare(llvm::Value *Storage, DILocalVariable *VarInfo, DIExpression *Expr, const DILocation *DL, BasicBlock *InsertAtEnd)
Insert a new llvm.dbg.declare intrinsic call.
Definition: DIBuilder.cpp:789
A Use represents the edge between a Value definition and its users.
Definition: Use.h:56
bool hasOptimizedCodeGen(LibFunc::Func F) const
Tests if the function is both available and a candidate for optimized code generation.
bool ConstantFoldTerminator(BasicBlock *BB, bool DeleteDeadConditions=false, const TargetLibraryInfo *TLI=nullptr)
If a terminator instruction is predicated on a constant value, convert it into an unconditional branc...
Definition: Local.cpp:68
static const Optional< BitPart > & collectBitParts(Value *V, bool MatchBSwaps, bool MatchBitReversals, std::map< Value *, Optional< BitPart >> &BPS)
Analyze the specified subexpression and see if it is capable of providing pieces of a bswap or bitrev...
Definition: Local.cpp:1858
Instruction * getFirstNonPHI()
Returns a pointer to the first instruction in this block that is not a PHINode instruction.
Definition: BasicBlock.cpp:180
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
Definition: IRBuilder.h:588
const Value * getCalledValue() const
Get a pointer to the function that is invoked by this instruction.
bool hasAddressTaken() const
Returns true if there are any uses of this basic block other than direct branches, switches, etc.
Definition: BasicBlock.h:308
bool canSimplifyInvokeNoUnwind(const Function *F)
Only used in LLVM metadata.
Definition: Dwarf.h:112
static const unsigned MaximumAlignment
Definition: Value.h:550
block_iterator block_begin()
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:60
Interval::succ_iterator succ_begin(Interval *I)
succ_begin/succ_end - define methods so that Intervals may be used just like BasicBlocks can with the...
Definition: Interval.h:106
static void replaceOneDbgValueForAlloca(DbgValueInst *DVI, Value *NewAddress, DIBuilder &Builder, int Offset)
Definition: Local.cpp:1312
void addHandler(BasicBlock *Dest)
Add an entry to the switch instruction...
user_iterator_impl< User > user_iterator
Definition: Value.h:340
#define F(x, y, z)
Definition: MD5.cpp:51
bool insert(const value_type &X)
Insert a new element into the SetVector.
Definition: SetVector.h:136
static void changeToCall(InvokeInst *II)
changeToCall - Convert the specified invoke into a normal call.
Definition: Local.cpp:1404
static bool isEqual(const Function &Caller, const Function &Callee)
match_combine_or< LTy, RTy > m_CombineOr(const LTy &L, const RTy &R)
Combine two pattern matchers matching L || R.
Definition: PatternMatch.h:117
op_iterator arg_begin()
Return the iterator pointing to the beginning of the argument list.
Value handle that is nullable, but tries to track the Value.
Definition: ValueHandle.h:134
bool isMathLibCallNoop(CallSite CS, const TargetLibraryInfo *TLI)
Check whether the given call has no side-effects.
static bool areAllUsesEqual(Instruction *I)
areAllUsesEqual - Check whether the uses of a value are all the same.
Definition: Local.cpp:393
static MDNode * intersect(MDNode *A, MDNode *B)
Definition: Metadata.cpp:870
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:949
static GCRegistry::Add< OcamlGC > B("ocaml","ocaml 3.10-compatible GC")
An instruction for storing to memory.
Definition: Instructions.h:300
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
Definition: Value.cpp:401
bool isArrayTy() const
True if this is an instance of ArrayType.
Definition: Type.h:210
bool EliminateDuplicatePHINodes(BasicBlock *BB)
Check for and eliminate duplicate PHI nodes in this block.
Definition: Local.cpp:916
static void gatherIncomingValuesToPhi(PHINode *PN, IncomingValueMap &IncomingValues)
Create a map from block to value for the operands of a given phi.
Definition: Local.cpp:724
element_iterator elements_begin() const
void takeName(Value *V)
Transfer the name from V to this value.
Definition: Value.cpp:263
iterator begin()
Definition: Function.h:535
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree...
Definition: Dominators.h:96
bool doesNotAccessMemory() const
Determine if the function does not access memory.
Definition: Function.h:313
This class represents a truncation of integer types.
BasicBlock * getNormalDest() const
Maximum length of the test input libFuzzer tries to guess a good value based on the corpus and reports it always prefer smaller inputs during the corpus shuffle When libFuzzer itself reports a bug this exit code will be used If indicates the maximal total time in seconds to run the fuzzer minimizes the provided crash input Use with etc Experimental Use value profile to guide fuzzing Number of simultaneous worker processes to run the jobs If min(jobs, NumberOfCpuCores()/2)\" is used.") FUZZER_FLAG_INT(reload
void setAttributes(AttributeSet Attrs)
Set the parameter attributes for this call.
static GCRegistry::Add< CoreCLRGC > E("coreclr","CoreCLR-compatible GC")
unsigned getNumIncomingValues() const
Return the number of incoming edges.
DenseMap< BasicBlock *, Value * > IncomingValueMap
Definition: Local.cpp:685
void getOperandBundlesAsDefs(SmallVectorImpl< OperandBundleDef > &Defs) const
Return the list of operand bundles attached to this instruction as a vector of OperandBundleDefs.
Definition: InstrTypes.h:1441
bool getLibFunc(StringRef funcName, LibFunc::Func &F) const
Searches for a particular function name.
#define P(N)
static MDNode * getMostGenericRange(MDNode *A, MDNode *B)
Definition: Metadata.cpp:938
element_iterator elements_end() const
Subclasses of this class are all able to terminate a basic block.
Definition: InstrTypes.h:52
void setDebugLoc(DebugLoc Loc)
Set the debug location information for this instruction.
Definition: Instruction.h:256
void set(Value *Val)
Definition: Value.h:624
static MetadataAsValue * getIfExists(LLVMContext &Context, Metadata *MD)
Definition: Metadata.cpp:82
LLVM Basic Block Representation.
Definition: BasicBlock.h:51
size_type size() const
Definition: SmallPtrSet.h:99
static bool LdStHasDebugValue(DILocalVariable *DIVar, DIExpression *DIExpr, Instruction *I)
===---------------------------------------------------------------——===// Dbg Intrinsic utilities ...
Definition: Local.cpp:1053
void getAllMetadataOtherThanDebugLoc(SmallVectorImpl< std::pair< unsigned, MDNode * >> &MDs) const
This does the same thing as getAllMetadata, except that it filters out the debug location.
Definition: Instruction.h:198
void eraseNode(NodeT *BB)
eraseNode - Removes a node from the dominator tree.
DIExpression * getExpression() const
Definition: IntrinsicInst.h:97
bool TryToSimplifyUncondBranchFromEmptyBlock(BasicBlock *BB)
BB is known to contain an unconditional branch, and contains no instructions other than PHI nodes...
Definition: Local.cpp:822
Conditional or Unconditional Branch instruction.
void ConvertDebugDeclareToDebugValue(DbgDeclareInst *DDI, StoreInst *SI, DIBuilder &Builder)
===---------------------------------------------------------------——===// Dbg Intrinsic utilities ...
Definition: Local.cpp:1091
static MDNode * getMostGenericAlignmentOrDereferenceable(MDNode *A, MDNode *B)
Definition: Metadata.cpp:1010
static BlockAddress * get(Function *F, BasicBlock *BB)
Return a BlockAddress for the specified function and basic block.
Definition: Constants.cpp:1356
This function has undefined behavior.
This is an important base class in LLVM.
Definition: Constant.h:42
PointerType * getType() const
Overload to return most specific pointer type.
Definition: Instructions.h:97
This file contains the declarations for the subclasses of Constant, which represent the different fla...
Indirect Branch Instruction.
APInt Or(const APInt &LHS, const APInt &RHS)
Bitwise OR function for APInt.
Definition: APInt.h:1947
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:368
Interval::pred_iterator pred_begin(Interval *I)
pred_begin/pred_end - define methods so that Intervals may be used just like BasicBlocks can with the...
Definition: Interval.h:116
const DebugLoc & getDebugLoc() const
Return the debug location for this node as a DebugLoc.
Definition: Instruction.h:259
static bool CanMergeValues(Value *First, Value *Second)
CanMergeValues - Return true if we can choose one of these values to use in place of the other...
Definition: Local.cpp:620
void pop_front()
Definition: ilist.h:327
BasicBlock * getIncomingBlock(unsigned i) const
Return incoming basic block number i.
void splice(iterator where, iplist_impl &L2)
Definition: ilist.h:342
uint32_t Offset
const InstListType & getInstList() const
Return the underlying instruction list container.
Definition: BasicBlock.h:249
size_t size() const
Definition: Function.h:540
User * getUser() const
Returns the User that contains this Use.
Definition: Use.cpp:41
for(unsigned i=0, e=MI->getNumOperands();i!=e;++i)
unsigned getMDKindID(StringRef Name) const
getMDKindID - Return a unique non-zero ID for the specified metadata kind.
Value * getOperand(unsigned i) const
Definition: User.h:145
bool hasFnAttr(Attribute::AttrKind Kind) const
Return true if this function has the given attribute.
Definition: CallSite.h:349
Interval::pred_iterator pred_end(Interval *I)
Definition: Interval.h:119
Value * CreateICmpEQ(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:1466
self_iterator getIterator()
Definition: ilist_node.h:81
op_iterator arg_end()
Return the iterator pointing to the end of the argument list.
Class to represent integer types.
Definition: DerivedTypes.h:39
bool callsGCLeafFunction(ImmutableCallSite CS)
Return true if the CallSite CS calls a gc leaf function.
Definition: Local.cpp:1798
static void DIExprAddOffset(SmallVectorImpl< uint64_t > &Expr, int Offset)
Definition: Local.cpp:1258
op_iterator arg_begin()
Return the iterator pointing to the beginning of the argument list.
static MDNode * getMostGenericTBAA(MDNode *A, MDNode *B)
bool replaceDbgDeclare(Value *Address, Value *NewAddress, Instruction *InsertBefore, DIBuilder &Builder, bool Deref, int Offset)
Replaces llvm.dbg.declare instruction when the address it describes is replaced with a new value...
Definition: Local.cpp:1286
void append(in_iter in_start, in_iter in_end)
Add the specified range to the end of the SmallVector.
Definition: SmallVector.h:392
bool isPointerTy() const
True if this is an instance of PointerType.
Definition: Type.h:213
static UndefValue * get(Type *T)
Static factory methods - Return an 'undef' object of the specified type.
Definition: Constants.cpp:1337
bool RecursivelyDeleteTriviallyDeadInstructions(Value *V, const TargetLibraryInfo *TLI=nullptr)
If the specified value is a trivially dead instruction, delete it.
Definition: Local.cpp:355
static bool bitTransformIsCorrectForBitReverse(unsigned From, unsigned To, unsigned BitWidth)
Definition: Local.cpp:1987
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:654
bool LowerDbgDeclare(Function &F)
Lowers llvm.dbg.declare intrinsics into appropriate set of llvm.dbg.value intrinsics.
Definition: Local.cpp:1185
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
void setMetadata(unsigned KindID, MDNode *Node)
Set the metadata of the specified kind to the specified node.
Definition: Metadata.cpp:1183
CallingConv::ID getCallingConv() const
getCallingConv/setCallingConv - Get or set the calling convention of this function call...
static void redirectValuesFromPredecessorsToPhi(BasicBlock *BB, const PredBlockVector &BBPreds, PHINode *PN)
Replace a value flowing from a block to a phi with potentially multiple instances of that value flowi...
Definition: Local.cpp:762
bool recursivelySimplifyInstruction(Instruction *I, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr)
Recursively attempt to simplify an instruction.
bool dominates(const Instruction *Def, const Use &U) const
Return true if Def dominates a use in User.
Definition: Dominators.cpp:218
static InvokeInst * Create(Value *Func, BasicBlock *IfNormal, BasicBlock *IfException, ArrayRef< Value * > Args, const Twine &NameStr, Instruction *InsertBefore=nullptr)
const MDOperand & getOperand(unsigned I) const
Definition: Metadata.h:1034
DIExpression * getExpression() const
A SetVector that performs no allocations if smaller than a certain size.
Definition: SetVector.h:292
Iterator for intrusive lists based on ilist_node.
void moveAfter(BasicBlock *MovePos)
Unlink this basic block from its current function and insert it right after MovePos in the function M...
Definition: BasicBlock.cpp:110
const BasicBlockListType & getBasicBlockList() const
Definition: Function.h:512
BasicBlock * getUnwindDest() const
This is the shared class of boolean and integer constants.
Definition: Constants.h:88
static CatchSwitchInst * Create(Value *ParentPad, BasicBlock *UnwindDest, unsigned NumHandlers, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Value * getIncomingValue(unsigned i) const
Return incoming value number x.
static bool bitTransformIsCorrectForBSwap(unsigned From, unsigned To, unsigned BitWidth)
Definition: Local.cpp:1976
iterator end()
Definition: BasicBlock.h:230
bool removeUnreachableBlocks(Function &F, LazyValueInfo *LVI=nullptr)
Remove all blocks that can not be reached from the function's entry.
Definition: Local.cpp:1648
const Module * getModule() const
Return the module owning the function this instruction belongs to or nullptr it the function does not...
Definition: Instruction.cpp:58
static CallInst * Create(Value *Func, ArrayRef< Value * > Args, ArrayRef< OperandBundleDef > Bundles=None, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:843
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:230
Instruction * user_back()
Specialize the methods defined in Value, as we know that an instruction can only be used by other ins...
Definition: Instruction.h:59
Provides information about what library functions are available for the current target.
MDNode * getMetadata(unsigned KindID) const
Get the metadata of given kind attached to this Instruction.
Definition: Instruction.h:175
static LocalAsMetadata * getIfExists(Value *Local)
Definition: Metadata.h:422
op_iterator arg_end()
Return the iterator pointing to the end of the argument list.
bool RecursivelyDeleteDeadPHINode(PHINode *PN, const TargetLibraryInfo *TLI=nullptr)
If the specified value is an effectively dead PHI node, due to being a def-use chain of single-use no...
Definition: Local.cpp:412
void FindAllocaDbgValues(DbgValueList &DbgValues, Value *V)
Finds the llvm.dbg.value intrinsics corresponding to an alloca, if any.
Definition: Local.cpp:1246
LLVM_NODISCARD T pop_back_val()
Definition: SmallVector.h:382
BasicBlockTy * getCaseSuccessor()
Resolves successor for current case.
Value * stripPointerCasts()
Strip off pointer casts, all-zero GEPs, and aliases.
Definition: Value.cpp:490
DIExpression * createExpression(ArrayRef< uint64_t > Addr=None)
Create a new descriptor for the specified variable which has a complex address expression for its add...
Definition: DIBuilder.cpp:653
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:558
Function * getCalledFunction() const
Return the function called, or null if this is an indirect function invocation.
static BranchInst * Create(BasicBlock *IfTrue, Instruction *InsertBefore=nullptr)
const BasicBlock & getEntryBlock() const
Definition: Function.h:519
unsigned removeAllNonTerminatorAndEHPadInstructions(BasicBlock *BB)
Remove all instructions from a basic block other than it's terminator and any present EH pad instruct...
Definition: Local.cpp:1352
Value handle that asserts if the Value is deleted.
Definition: ValueHandle.h:182
DWARF expression.
SmallVector< BasicBlock *, 16 > PredBlockVector
Definition: Local.cpp:684
static GCRegistry::Add< ShadowStackGC > C("shadow-stack","Very portable GC for uncooperative code generators")
void setOperand(unsigned i, Value *Val)
Definition: User.h:150
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:132
size_type count(const KeyT &Val) const
Return 1 if the specified key is in the map, 0 otherwise.
Definition: DenseMap.h:122
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
Definition: BitVector.h:586
Class for arbitrary precision integers.
Definition: APInt.h:77
hash_code hash_combine(const Ts &...args)
Combine values into a single hash_code.
Definition: Hashing.h:602
bool exceedsNaturalStackAlignment(unsigned Align) const
Returns true if the given alignment exceeds the natural stack alignment.
Definition: DataLayout.h:252
Value * getIncomingValueForBlock(const BasicBlock *BB) const
static void DIExprAddDeref(SmallVectorImpl< uint64_t > &Expr)
Definition: Local.cpp:1254
iterator_range< user_iterator > users()
Definition: Value.h:370
BasicBlock * getSinglePredecessor()
Return the predecessor of this block if it has a single predecessor block.
Definition: BasicBlock.cpp:226
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last)
Compute a hash_code for a sequence of values.
Definition: Hashing.h:480
void removeUnwindEdge(BasicBlock *BB)
Replace 'BB's terminator with one that does not have an unwind successor block.
Definition: Local.cpp:1611
APInt And(const APInt &LHS, const APInt &RHS)
Bitwise AND function for APInt.
Definition: APInt.h:1942
unsigned getOpcode() const
Return the opcode for this Instruction or ConstantExpr.
Definition: Operator.h:49
bool isEHPad() const
Return true if the instruction is a variety of EH-block.
Definition: Instruction.h:453
use_iterator use_begin()
Definition: Value.h:310
static CastInst * Create(Instruction::CastOps, Value *S, Type *Ty, const Twine &Name="", Instruction *InsertBefore=nullptr)
Provides a way to construct any of the CastInst subclasses using an opcode instead of the subclass's ...
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.cpp:384
static bool simplifyAndDCEInstruction(Instruction *I, SmallSetVector< Instruction *, 16 > &WorkList, const DataLayout &DL, const TargetLibraryInfo *TLI)
Definition: Local.cpp:433
static DIExpression * BuildReplacementDIExpr(DIBuilder &Builder, DIExpression *DIExpr, bool Deref, int Offset)
Definition: Local.cpp:1268
static IntegerType * getInt32Ty(LLVMContext &C)
Definition: Type.cpp:169
This represents the llvm.dbg.value instruction.
ImmutableCallSite - establish a view to a call site for examination.
Definition: CallSite.h:665
void insertAfter(Instruction *InsertPos)
Insert an unlinked instruction into a basic block immediately after the specified instruction...
Definition: Instruction.cpp:88
SymbolTableList< BasicBlock >::iterator eraseFromParent()
Unlink 'this' from the containing function and delete it.
Definition: BasicBlock.cpp:97
#define I(x, y, z)
Definition: MD5.cpp:54
TerminatorInst * getTerminator()
Returns the terminator instruction if the block is well formed or null if the block is not well forme...
Definition: BasicBlock.cpp:124
LLVM_ATTRIBUTE_ALWAYS_INLINE size_type size() const
Definition: SmallVector.h:135
bool hasOneUse() const
Return true if there is exactly one user of this value.
Definition: Value.h:383
bool isAllocLikeFn(const Value *V, const TargetLibraryInfo *TLI, bool LookThroughBitCast=false)
Tests if a value is a call or invoke to a library function that allocates memory (either malloc...
iterator end()
Definition: DenseMap.h:69
iterator find(const KeyT &Val)
Definition: DenseMap.h:127
bool recognizeBSwapOrBitReverseIdiom(Instruction *I, bool MatchBSwaps, bool MatchBitReversals, SmallVectorImpl< Instruction * > &InsertedInsts)
Try and match a bswap or bitreverse idiom.
Definition: Local.cpp:1994
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:287
void destroyConstant()
Called if some element of this constant is no longer valid.
Definition: Constants.cpp:288
void maybeMarkSanitizerLibraryCallNoBuiltin(CallInst *CI, const TargetLibraryInfo *TLI)
Given a CallInst, check if it calls a string function known to CodeGen, and mark it with NoBuiltin if...
Definition: Local.cpp:2068
static bool PhiHasDebugValue(DILocalVariable *DIVar, DIExpression *DIExpr, PHINode *APN)
See if there is a dbg.value intrinsic for DIVar for the PHI node.
Definition: Local.cpp:1072
BasicBlock * splitBasicBlock(iterator I, const Twine &BBName="")
Split the basic block into two basic blocks at the specified instruction.
Definition: BasicBlock.cpp:374
void combineMetadataForCSE(Instruction *K, const Instruction *J)
Combine the metadata of two instructions so that K can replace J.
Definition: Local.cpp:1747
void changeImmediateDominator(DomTreeNodeBase< NodeT > *N, DomTreeNodeBase< NodeT > *NewIDom)
changeImmediateDominator - This method is used to update the dominator tree information when a node's...
void eraseBlock(BasicBlock *BB)
Inform the analysis cache that we have erased a block.
bool hasLocalLinkage() const
Definition: GlobalValue.h:415
const unsigned Kind
Multiway switch.
This pass computes, caches, and vends lazy value constraint information.
Definition: LazyValueInfo.h:32
static bool isArray(AllocaInst *AI)
Determine whether this alloca is either a VLA or an array.
Definition: Local.cpp:1178
bool use_empty() const
Definition: Value.h:299
DILocalVariable * getVariable() const
Definition: IntrinsicInst.h:93
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
user_iterator user_begin()
Definition: Value.h:346
const BasicBlock & front() const
Definition: Function.h:542
LLVMContext & getContext() const
Get the context in which this basic block lives.
Definition: BasicBlock.cpp:33
FunTy * getCalledFunction() const
getCalledFunction - Return the function being called if this is a direct call, otherwise return null ...
Definition: CallSite.h:110
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:537
bool isInstructionTriviallyDead(Instruction *I, const TargetLibraryInfo *TLI=nullptr)
Return true if the result produced by the instruction is not used, and the instruction has no side ef...
Definition: Local.cpp:288
LLVM Value Representation.
Definition: Value.h:71
succ_range successors(BasicBlock *BB)
Definition: IR/CFG.h:143
DILocalVariable * getVariable() const
BranchInst * CreateBr(BasicBlock *Dest)
Create an unconditional 'br label X' instruction.
Definition: IRBuilder.h:693
static CleanupReturnInst * Create(Value *CleanupPad, BasicBlock *UnwindBB=nullptr, Instruction *InsertBefore=nullptr)
static const Function * getParent(const Value *V)
void setCallingConv(CallingConv::ID CC)
uint64_t getTypeSizeInBits(Type *Ty) const
Size examples:
Definition: DataLayout.h:533
BasicBlock * changeToInvokeAndSplitBasicBlock(CallInst *CI, BasicBlock *UnwindEdge)
Convert the CallInst to InvokeInst with the specified unwind edge basic block.
Definition: Local.cpp:1424
Invoke instruction.
#define DEBUG(X)
Definition: Debug.h:100
CallingConv::ID getCallingConv() const
getCallingConv/setCallingConv - Get or set the calling convention of this function call...
Value * SimplifyInstruction(Instruction *I, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr)
See if we can compute a simplified version of this instruction.
void addAttribute(unsigned i, Attribute::AttrKind Kind)
adds the attribute to the list of attributes.
iterator getFirstInsertionPt()
Returns an iterator to the first instruction in this block that is suitable for inserting a non-PHI i...
Definition: BasicBlock.cpp:209
int * Ptr
DomTreeNodeBase< NodeT > * getNode(NodeT *BB) const
getNode - return the (Post)DominatorTree node for the specified basic block.
void setIncomingValue(unsigned i, Value *V)
void pop_back()
Definition: ilist.h:331
static void Split(std::vector< std::string > &V, StringRef S)
Split - Splits a string of comma separated items in to a vector of strings.
static MDNode * getMostGenericFPMath(MDNode *A, MDNode *B)
Definition: Metadata.cpp:890
This represents the llvm.dbg.declare instruction.
Definition: IntrinsicInst.h:89
static GCRegistry::Add< ErlangGC > A("erlang","erlang-compatible garbage collector")
Root of the metadata hierarchy.
Definition: Metadata.h:55
void combineMetadata(Instruction *K, const Instruction *J, ArrayRef< unsigned > KnownIDs)
Combine the metadata of two instructions so that K can replace J.
Definition: Local.cpp:1682
const BasicBlock * getParent() const
Definition: Instruction.h:62
InstListType::iterator iterator
Instruction iterators...
Definition: BasicBlock.h:83
A wrapper class for inspecting calls to intrinsic functions.
Definition: IntrinsicInst.h:44
an instruction to allocate memory on the stack
Definition: Instructions.h:60
user_iterator user_end()
Definition: Value.h:354