1//===- SimplifyCFG.cpp - Code to perform CFG simplification ---------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// Peephole optimize the CFG.
10//
11//===----------------------------------------------------------------------===//
12
13#include "llvm/ADT/APInt.h"
14#include "llvm/ADT/ArrayRef.h"
15#include "llvm/ADT/DenseMap.h"
16#include "llvm/ADT/MapVector.h"
17#include "llvm/ADT/STLExtras.h"
18#include "llvm/ADT/Sequence.h"
19#include "llvm/ADT/SetOperations.h"
20#include "llvm/ADT/SetVector.h"
21#include "llvm/ADT/SmallPtrSet.h"
22#include "llvm/ADT/SmallVector.h"
23#include "llvm/ADT/Statistic.h"
24#include "llvm/ADT/StringRef.h"
25#include "llvm/Analysis/AssumptionCache.h"
26#include "llvm/Analysis/CaptureTracking.h"
27#include "llvm/Analysis/ConstantFolding.h"
28#include "llvm/Analysis/DomTreeUpdater.h"
29#include "llvm/Analysis/GuardUtils.h"
30#include "llvm/Analysis/InstructionSimplify.h"
31#include "llvm/Analysis/Loads.h"
32#include "llvm/Analysis/MemorySSA.h"
33#include "llvm/Analysis/MemorySSAUpdater.h"
34#include "llvm/Analysis/TargetTransformInfo.h"
35#include "llvm/Analysis/ValueTracking.h"
36#include "llvm/IR/Attributes.h"
37#include "llvm/IR/BasicBlock.h"
38#include "llvm/IR/CFG.h"
39#include "llvm/IR/Constant.h"
40#include "llvm/IR/ConstantRange.h"
41#include "llvm/IR/Constants.h"
42#include "llvm/IR/DataLayout.h"
43#include "llvm/IR/DebugInfo.h"
44#include "llvm/IR/DerivedTypes.h"
45#include "llvm/IR/Function.h"
46#include "llvm/IR/GlobalValue.h"
47#include "llvm/IR/GlobalVariable.h"
48#include "llvm/IR/IRBuilder.h"
49#include "llvm/IR/InstrTypes.h"
50#include "llvm/IR/Instruction.h"
51#include "llvm/IR/Instructions.h"
52#include "llvm/IR/IntrinsicInst.h"
53#include "llvm/IR/LLVMContext.h"
54#include "llvm/IR/MDBuilder.h"
55#include "llvm/IR/MemoryModelRelaxationAnnotations.h"
56#include "llvm/IR/Metadata.h"
57#include "llvm/IR/Module.h"
58#include "llvm/IR/NoFolder.h"
59#include "llvm/IR/Operator.h"
60#include "llvm/IR/PatternMatch.h"
61#include "llvm/IR/ProfDataUtils.h"
62#include "llvm/IR/Type.h"
63#include "llvm/IR/Use.h"
64#include "llvm/IR/User.h"
65#include "llvm/IR/Value.h"
66#include "llvm/IR/ValueHandle.h"
67#include "llvm/Support/BranchProbability.h"
68#include "llvm/Support/Casting.h"
69#include "llvm/Support/CommandLine.h"
70#include "llvm/Support/Debug.h"
71#include "llvm/Support/ErrorHandling.h"
72#include "llvm/Support/KnownBits.h"
73#include "llvm/Support/MathExtras.h"
74#include "llvm/Support/raw_ostream.h"
75#include "llvm/Transforms/Utils/BasicBlockUtils.h"
76#include "llvm/Transforms/Utils/Cloning.h"
77#include "llvm/Transforms/Utils/Local.h"
78#include "llvm/Transforms/Utils/LockstepReverseIterator.h"
79#include "llvm/Transforms/Utils/ValueMapper.h"
80#include <algorithm>
81#include <cassert>
82#include <climits>
83#include <cstddef>
84#include <cstdint>
85#include <iterator>
86#include <map>
87#include <optional>
88#include <set>
89#include <tuple>
90#include <utility>
91#include <vector>
92
93using namespace llvm;
94using namespace PatternMatch;
95
96#define DEBUG_TYPE "simplifycfg"
97
98namespace llvm {
99
100cl::opt<bool> RequireAndPreserveDomTree(
101 "simplifycfg-require-and-preserve-domtree", cl::Hidden,
102
103 cl::desc(
104 "Temporary development switch used to gradually uplift SimplifyCFG "
105 "into preserving DomTree,"));
106
107// Chosen as 2 so as to be cheap, but still to have enough power to fold
108// a select, so the "clamp" idiom (of a min followed by a max) will be caught.
109// To catch this, we need to fold a compare and a select, hence '2' being the
110// minimum reasonable default.
111static cl::opt<unsigned> PHINodeFoldingThreshold(
112 "phi-node-folding-threshold", cl::Hidden, cl::init(Val: 2),
113 cl::desc(
114 "Control the amount of phi node folding to perform (default = 2)"));
115
116static cl::opt<unsigned> TwoEntryPHINodeFoldingThreshold(
117 "two-entry-phi-node-folding-threshold", cl::Hidden, cl::init(Val: 4),
118 cl::desc("Control the maximal total instruction cost that we are willing "
119 "to speculatively execute to fold a 2-entry PHI node into a "
120 "select (default = 4)"));
121
122static cl::opt<bool>
123 HoistCommon("simplifycfg-hoist-common", cl::Hidden, cl::init(Val: true),
124 cl::desc("Hoist common instructions up to the parent block"));
125
126static cl::opt<bool> HoistLoadsWithCondFaulting(
127 "simplifycfg-hoist-loads-with-cond-faulting", cl::Hidden, cl::init(Val: true),
128 cl::desc("Hoist loads if the target supports conditional faulting"));
129
130static cl::opt<bool> HoistStoresWithCondFaulting(
131 "simplifycfg-hoist-stores-with-cond-faulting", cl::Hidden, cl::init(Val: true),
132 cl::desc("Hoist stores if the target supports conditional faulting"));
133
134static cl::opt<unsigned> HoistLoadsStoresWithCondFaultingThreshold(
135 "hoist-loads-stores-with-cond-faulting-threshold", cl::Hidden, cl::init(Val: 6),
136 cl::desc("Control the maximal conditional load/store that we are willing "
137 "to speculatively execute to eliminate conditional branch "
138 "(default = 6)"));
139
140static cl::opt<unsigned>
141 HoistCommonSkipLimit("simplifycfg-hoist-common-skip-limit", cl::Hidden,
142 cl::init(Val: 20),
143 cl::desc("Allow reordering across at most this many "
144 "instructions when hoisting"));
145
146static cl::opt<bool>
147 SinkCommon("simplifycfg-sink-common", cl::Hidden, cl::init(Val: true),
148 cl::desc("Sink common instructions down to the end block"));
149
150static cl::opt<bool> HoistCondStores(
151 "simplifycfg-hoist-cond-stores", cl::Hidden, cl::init(Val: true),
152 cl::desc("Hoist conditional stores if an unconditional store precedes"));
153
154static cl::opt<bool> MergeCondStores(
155 "simplifycfg-merge-cond-stores", cl::Hidden, cl::init(Val: true),
156 cl::desc("Hoist conditional stores even if an unconditional store does not "
157 "precede - hoist multiple conditional stores into a single "
158 "predicated store"));
159
160static cl::opt<bool> MergeCondStoresAggressively(
161 "simplifycfg-merge-cond-stores-aggressively", cl::Hidden, cl::init(Val: false),
162 cl::desc("When merging conditional stores, do so even if the resultant "
163 "basic blocks are unlikely to be if-converted as a result"));
164
165static cl::opt<bool> SpeculateOneExpensiveInst(
166 "speculate-one-expensive-inst", cl::Hidden, cl::init(Val: true),
167 cl::desc("Allow exactly one expensive instruction to be speculatively "
168 "executed"));
169
170static cl::opt<unsigned> MaxSpeculationDepth(
171 "max-speculation-depth", cl::Hidden, cl::init(Val: 10),
172 cl::desc("Limit maximum recursion depth when calculating costs of "
173 "speculatively executed instructions"));
174
175static cl::opt<int>
176 MaxSmallBlockSize("simplifycfg-max-small-block-size", cl::Hidden,
177 cl::init(Val: 10),
178 cl::desc("Max size of a block which is still considered "
179 "small enough to thread through"));
180
181// Two is chosen to allow one negation and a logical combine.
182static cl::opt<unsigned>
183 BranchFoldThreshold("simplifycfg-branch-fold-threshold", cl::Hidden,
184 cl::init(Val: 2),
185 cl::desc("Maximum cost of combining conditions when "
186 "folding branches"));
187
188static cl::opt<unsigned> BranchFoldToCommonDestVectorMultiplier(
189 "simplifycfg-branch-fold-common-dest-vector-multiplier", cl::Hidden,
190 cl::init(Val: 2),
191 cl::desc("Multiplier to apply to threshold when determining whether or not "
192 "to fold branch to common destination when vector operations are "
193 "present"));
194
195static cl::opt<bool> EnableMergeCompatibleInvokes(
196 "simplifycfg-merge-compatible-invokes", cl::Hidden, cl::init(Val: true),
197 cl::desc("Allow SimplifyCFG to merge invokes together when appropriate"));
198
199static cl::opt<unsigned> MaxSwitchCasesPerResult(
200 "max-switch-cases-per-result", cl::Hidden, cl::init(Val: 16),
201 cl::desc("Limit cases to analyze when converting a switch to select"));
202
203static cl::opt<unsigned> MaxJumpThreadingLiveBlocks(
204 "max-jump-threading-live-blocks", cl::Hidden, cl::init(Val: 24),
205 cl::desc("Limit number of blocks a define in a threaded block is allowed "
206 "to be live in"));
207
208extern cl::opt<bool> ProfcheckDisableMetadataFixes;
209
210} // end namespace llvm
211
212STATISTIC(NumBitMaps, "Number of switch instructions turned into bitmaps");
213STATISTIC(NumLinearMaps,
214 "Number of switch instructions turned into linear mapping");
215STATISTIC(NumLookupTables,
216 "Number of switch instructions turned into lookup tables");
217STATISTIC(
218 NumLookupTablesHoles,
219 "Number of switch instructions turned into lookup tables (holes checked)");
220STATISTIC(NumTableCmpReuses, "Number of reused switch table lookup compares");
221STATISTIC(NumFoldValueComparisonIntoPredecessors,
222 "Number of value comparisons folded into predecessor basic blocks");
223STATISTIC(NumFoldBranchToCommonDest,
224 "Number of branches folded into predecessor basic block");
225STATISTIC(
226 NumHoistCommonCode,
227 "Number of common instruction 'blocks' hoisted up to the begin block");
228STATISTIC(NumHoistCommonInstrs,
229 "Number of common instructions hoisted up to the begin block");
230STATISTIC(NumSinkCommonCode,
231 "Number of common instruction 'blocks' sunk down to the end block");
232STATISTIC(NumSinkCommonInstrs,
233 "Number of common instructions sunk down to the end block");
234STATISTIC(NumSpeculations, "Number of speculative executed instructions");
235STATISTIC(NumInvokes,
236 "Number of invokes with empty resume blocks simplified into calls");
237STATISTIC(NumInvokesMerged, "Number of invokes that were merged together");
238STATISTIC(NumInvokeSetsFormed, "Number of invoke sets that were formed");
239
240namespace {
241
242// The first field contains the value that the switch produces when a certain
243// case group is selected, and the second field is a vector containing the
244// cases composing the case group.
245using SwitchCaseResultVectorTy =
246 SmallVector<std::pair<Constant *, SmallVector<ConstantInt *, 4>>, 2>;
247
248// The first field contains the phi node that generates a result of the switch
249// and the second field contains the value generated for a certain case in the
250// switch for that PHI.
251using SwitchCaseResultsTy = SmallVector<std::pair<PHINode *, Constant *>, 4>;
252
253/// ValueEqualityComparisonCase - Represents a case of a switch.
254struct ValueEqualityComparisonCase {
255 ConstantInt *Value;
256 BasicBlock *Dest;
257
258 ValueEqualityComparisonCase(ConstantInt *Value, BasicBlock *Dest)
259 : Value(Value), Dest(Dest) {}
260
261 bool operator<(ValueEqualityComparisonCase RHS) const {
262 // Comparing pointers is ok as we only rely on the order for uniquing.
263 return Value < RHS.Value;
264 }
265
266 bool operator==(BasicBlock *RHSDest) const { return Dest == RHSDest; }
267};
268
269class SimplifyCFGOpt {
270 const TargetTransformInfo &TTI;
271 DomTreeUpdater *DTU;
272 const DataLayout &DL;
273 ArrayRef<WeakVH> LoopHeaders;
274 const SimplifyCFGOptions &Options;
275 bool Resimplify;
276
277 Value *isValueEqualityComparison(Instruction *TI);
278 BasicBlock *getValueEqualityComparisonCases(
279 Instruction *TI, std::vector<ValueEqualityComparisonCase> &Cases);
280 bool simplifyEqualityComparisonWithOnlyPredecessor(Instruction *TI,
281 BasicBlock *Pred,
282 IRBuilder<> &Builder);
283 bool performValueComparisonIntoPredecessorFolding(Instruction *TI, Value *&CV,
284 Instruction *PTI,
285 IRBuilder<> &Builder);
286 bool foldValueComparisonIntoPredecessors(Instruction *TI,
287 IRBuilder<> &Builder);
288
289 bool simplifyResume(ResumeInst *RI, IRBuilder<> &Builder);
290 bool simplifySingleResume(ResumeInst *RI);
291 bool simplifyCommonResume(ResumeInst *RI);
292 bool simplifyCleanupReturn(CleanupReturnInst *RI);
293 bool simplifyUnreachable(UnreachableInst *UI);
294 bool simplifySwitch(SwitchInst *SI, IRBuilder<> &Builder);
295 bool simplifyDuplicateSwitchArms(SwitchInst *SI, DomTreeUpdater *DTU);
296 bool simplifyIndirectBr(IndirectBrInst *IBI);
297 bool simplifyUncondBranch(UncondBrInst *BI, IRBuilder<> &Builder);
298 bool simplifyCondBranch(CondBrInst *BI, IRBuilder<> &Builder);
299 bool foldCondBranchOnValueKnownInPredecessor(CondBrInst *BI);
300
301 bool tryToSimplifyUncondBranchWithICmpInIt(ICmpInst *ICI,
302 IRBuilder<> &Builder);
303 bool tryToSimplifyUncondBranchWithICmpSelectInIt(ICmpInst *ICI,
304 SelectInst *Select,
305 IRBuilder<> &Builder);
306 bool hoistCommonCodeFromSuccessors(Instruction *TI, bool AllInstsEqOnly);
307 bool hoistSuccIdenticalTerminatorToSwitchOrIf(
308 Instruction *TI, Instruction *I1,
309 SmallVectorImpl<Instruction *> &OtherSuccTIs,
310 ArrayRef<BasicBlock *> UniqueSuccessors);
311 bool speculativelyExecuteBB(CondBrInst *BI, BasicBlock *ThenBB);
312 bool simplifyTerminatorOnSelect(Instruction *OldTerm, Value *Cond,
313 BasicBlock *TrueBB, BasicBlock *FalseBB,
314 uint32_t TrueWeight, uint32_t FalseWeight);
315 bool simplifyBranchOnICmpChain(CondBrInst *BI, IRBuilder<> &Builder,
316 const DataLayout &DL);
317 bool simplifySwitchOnSelect(SwitchInst *SI, SelectInst *Select);
318 bool simplifySwitchOnSelectRemap(SwitchInst *SI, SelectInst *Select, Value *X,
319 ConstantInt *C, bool Negate);
320 bool simplifyIndirectBrOnSelect(IndirectBrInst *IBI, SelectInst *SI);
321 bool turnSwitchRangeIntoICmp(SwitchInst *SI, IRBuilder<> &Builder);
322 bool simplifyDuplicatePredecessors(BasicBlock *Succ, DomTreeUpdater *DTU);
323
324public:
325 SimplifyCFGOpt(const TargetTransformInfo &TTI, DomTreeUpdater *DTU,
326 const DataLayout &DL, ArrayRef<WeakVH> LoopHeaders,
327 const SimplifyCFGOptions &Opts)
328 : TTI(TTI), DTU(DTU), DL(DL), LoopHeaders(LoopHeaders), Options(Opts) {
329 assert((!DTU || !DTU->hasPostDomTree()) &&
330 "SimplifyCFG is not yet capable of maintaining validity of a "
331 "PostDomTree, so don't ask for it.");
332 }
333
334 bool simplifyOnce(BasicBlock *BB);
335 bool run(BasicBlock *BB);
336
337 // Helper to set Resimplify and return change indication.
338 bool requestResimplify() {
339 Resimplify = true;
340 return true;
341 }
342};
343
344// we synthesize a || b as select a, true, b
345// we synthesize a && b as select a, b, false
346// this function determines if SI is playing one of those roles.
347[[maybe_unused]] bool
348isSelectInRoleOfConjunctionOrDisjunction(const SelectInst *SI) {
349 return ((isa<ConstantInt>(Val: SI->getTrueValue()) &&
350 (dyn_cast<ConstantInt>(Val: SI->getTrueValue())->isOne())) ||
351 (isa<ConstantInt>(Val: SI->getFalseValue()) &&
352 (dyn_cast<ConstantInt>(Val: SI->getFalseValue())->isNullValue())));
353}
354
355} // end anonymous namespace
356
357/// Return true if all the PHI nodes in the basic block \p BB
358/// receive compatible (identical) incoming values when coming from
359/// all of the predecessor blocks that are specified in \p IncomingBlocks.
360///
361/// Note that if the values aren't exactly identical, but \p EquivalenceSet
362/// is provided, and *both* of the values are present in the set,
363/// then they are considered equal.
364static bool incomingValuesAreCompatible(
365 BasicBlock *BB, ArrayRef<BasicBlock *> IncomingBlocks,
366 SmallPtrSetImpl<Value *> *EquivalenceSet = nullptr) {
367 assert(IncomingBlocks.size() == 2 &&
368 "Only for a pair of incoming blocks at the time!");
369
370 // FIXME: it is okay if one of the incoming values is an `undef` value,
371 // iff the other incoming value is guaranteed to be a non-poison value.
372 // FIXME: it is okay if one of the incoming values is a `poison` value.
373 return all_of(Range: BB->phis(), P: [IncomingBlocks, EquivalenceSet](PHINode &PN) {
374 Value *IV0 = PN.getIncomingValueForBlock(BB: IncomingBlocks[0]);
375 Value *IV1 = PN.getIncomingValueForBlock(BB: IncomingBlocks[1]);
376 if (IV0 == IV1)
377 return true;
378 if (EquivalenceSet && EquivalenceSet->contains(Ptr: IV0) &&
379 EquivalenceSet->contains(Ptr: IV1))
380 return true;
381 return false;
382 });
383}
384
385/// Return true if it is safe to merge these two
386/// terminator instructions together.
387static bool
388safeToMergeTerminators(Instruction *SI1, Instruction *SI2,
389 SmallSetVector<BasicBlock *, 4> *FailBlocks = nullptr) {
390 if (SI1 == SI2)
391 return false; // Can't merge with self!
392
393 // It is not safe to merge these two switch instructions if they have a common
394 // successor, and if that successor has a PHI node, and if *that* PHI node has
395 // conflicting incoming values from the two switch blocks.
396 BasicBlock *SI1BB = SI1->getParent();
397 BasicBlock *SI2BB = SI2->getParent();
398
399 SmallPtrSet<BasicBlock *, 16> SI1Succs(llvm::from_range, successors(BB: SI1BB));
400 bool Fail = false;
401 for (BasicBlock *Succ : successors(BB: SI2BB)) {
402 if (!SI1Succs.count(Ptr: Succ))
403 continue;
404 if (incomingValuesAreCompatible(BB: Succ, IncomingBlocks: {SI1BB, SI2BB}))
405 continue;
406 Fail = true;
407 if (FailBlocks)
408 FailBlocks->insert(X: Succ);
409 else
410 break;
411 }
412
413 return !Fail;
414}
415
416/// Update PHI nodes in Succ to indicate that there will now be entries in it
417/// from the 'NewPred' block. The values that will be flowing into the PHI nodes
418/// will be the same as those coming in from ExistPred, an existing predecessor
419/// of Succ.
420static void addPredecessorToBlock(BasicBlock *Succ, BasicBlock *NewPred,
421 BasicBlock *ExistPred,
422 MemorySSAUpdater *MSSAU = nullptr) {
423 for (PHINode &PN : Succ->phis())
424 PN.addIncoming(V: PN.getIncomingValueForBlock(BB: ExistPred), BB: NewPred);
425 if (MSSAU)
426 if (auto *MPhi = MSSAU->getMemorySSA()->getMemoryAccess(BB: Succ))
427 MPhi->addIncoming(V: MPhi->getIncomingValueForBlock(BB: ExistPred), BB: NewPred);
428}
429
430/// Compute an abstract "cost" of speculating the given instruction,
431/// which is assumed to be safe to speculate. TCC_Free means cheap,
432/// TCC_Basic means less cheap, and TCC_Expensive means prohibitively
433/// expensive.
434static InstructionCost computeSpeculationCost(const User *I,
435 const TargetTransformInfo &TTI) {
436 return TTI.getInstructionCost(U: I, CostKind: TargetTransformInfo::TCK_SizeAndLatency);
437}
438
439/// If we have a merge point of an "if condition" as accepted above,
440/// return true if the specified value dominates the block. We don't handle
441/// the true generality of domination here, just a special case which works
442/// well enough for us.
443///
444/// If AggressiveInsts is non-null, and if V does not dominate BB, we check to
445/// see if V (which must be an instruction) and its recursive operands
446/// that do not dominate BB have a combined cost lower than Budget and
447/// are non-trapping. If both are true, the instruction is inserted into the
448/// set and true is returned.
449///
450/// The cost for most non-trapping instructions is defined as 1 except for
451/// Select whose cost is 2.
452///
453/// After this function returns, Cost is increased by the cost of
454/// V plus its non-dominating operands. If that cost is greater than
455/// Budget, false is returned and Cost is undefined.
456static bool dominatesMergePoint(
457 Value *V, BasicBlock *BB, Instruction *InsertPt,
458 SmallPtrSetImpl<Instruction *> &AggressiveInsts, InstructionCost &Cost,
459 InstructionCost Budget, const TargetTransformInfo &TTI, AssumptionCache *AC,
460 SmallPtrSetImpl<Instruction *> &ZeroCostInstructions, unsigned Depth = 0) {
461 // It is possible to hit a zero-cost cycle (phi/gep instructions for example),
462 // so limit the recursion depth.
463 // TODO: While this recursion limit does prevent pathological behavior, it
464 // would be better to track visited instructions to avoid cycles.
465 if (Depth == MaxSpeculationDepth)
466 return false;
467
468 Instruction *I = dyn_cast<Instruction>(Val: V);
469 if (!I) {
470 // Non-instructions dominate all instructions and can be executed
471 // unconditionally.
472 return true;
473 }
474 BasicBlock *PBB = I->getParent();
475
476 // We don't want to allow weird loops that might have the "if condition" in
477 // the bottom of this block.
478 if (PBB == BB)
479 return false;
480
481 // If this instruction is defined in a block that contains an unconditional
482 // branch to BB, then it must be in the 'conditional' part of the "if
483 // statement". If not, it definitely dominates the region.
484 UncondBrInst *BI = dyn_cast<UncondBrInst>(Val: PBB->getTerminator());
485 if (!BI || BI->getSuccessor() != BB)
486 return true;
487
488 // If we have seen this instruction before, don't count it again.
489 if (AggressiveInsts.count(Ptr: I))
490 return true;
491
492 // Okay, it looks like the instruction IS in the "condition". Check to
493 // see if it's a cheap instruction to unconditionally compute, and if it
494 // only uses stuff defined outside of the condition. If so, hoist it out.
495 if (!isSafeToSpeculativelyExecute(I, CtxI: InsertPt, AC))
496 return false;
497
498 // Overflow arithmetic instruction plus extract value are usually generated
499 // when a division is being replaced. But, in this case, the zero check may
500 // still be kept in the code. In that case it would be worth to hoist these
501 // two instruction out of the basic block. Let's treat this pattern as one
502 // single cheap instruction here!
503 WithOverflowInst *OverflowInst;
504 if (match(V: I, P: m_ExtractValue<1>(V: m_OneUse(SubPattern: m_WithOverflowInst(I&: OverflowInst))))) {
505 ZeroCostInstructions.insert(Ptr: OverflowInst);
506 Cost += 1;
507 } else if (!ZeroCostInstructions.contains(Ptr: I))
508 Cost += computeSpeculationCost(I, TTI);
509
510 // Allow exactly one instruction to be speculated regardless of its cost
511 // (as long as it is safe to do so).
512 // This is intended to flatten the CFG even if the instruction is a division
513 // or other expensive operation. The speculation of an expensive instruction
514 // is expected to be undone in CodeGenPrepare if the speculation has not
515 // enabled further IR optimizations.
516 if (Cost > Budget &&
517 (!SpeculateOneExpensiveInst || !AggressiveInsts.empty() || Depth > 0 ||
518 !Cost.isValid()))
519 return false;
520
521 // Okay, we can only really hoist these out if their operands do
522 // not take us over the cost threshold.
523 for (Use &Op : I->operands())
524 if (!dominatesMergePoint(V: Op, BB, InsertPt, AggressiveInsts, Cost, Budget,
525 TTI, AC, ZeroCostInstructions, Depth: Depth + 1))
526 return false;
527 // Okay, it's safe to do this! Remember this instruction.
528 AggressiveInsts.insert(Ptr: I);
529 return true;
530}
531
532/// Extract ConstantInt from value, looking through IntToPtr
533/// and PointerNullValue. Return NULL if value is not a constant int.
534static ConstantInt *getConstantInt(Value *V, const DataLayout &DL) {
535 // Normal constant int.
536 ConstantInt *CI = dyn_cast<ConstantInt>(Val: V);
537 if (CI || !isa<Constant>(Val: V) || !V->getType()->isPointerTy())
538 return CI;
539
540 // It is not safe to look through inttoptr or ptrtoint when using unstable
541 // pointer types.
542 if (DL.hasUnstableRepresentation(Ty: V->getType()))
543 return nullptr;
544
545 // This is some kind of pointer constant. Turn it into a pointer-sized
546 // ConstantInt if possible.
547 IntegerType *IntPtrTy = cast<IntegerType>(Val: DL.getIntPtrType(V->getType()));
548
549 // Null pointer means 0, see SelectionDAGBuilder::getValue(const Value*).
550 if (isa<ConstantPointerNull>(Val: V))
551 return ConstantInt::get(Ty: IntPtrTy, V: 0);
552
553 // IntToPtr const int, we can look through this if the semantics of
554 // inttoptr for this address space are a simple (truncating) bitcast.
555 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Val: V))
556 if (CE->getOpcode() == Instruction::IntToPtr)
557 if (ConstantInt *CI = dyn_cast<ConstantInt>(Val: CE->getOperand(i_nocapture: 0))) {
558 // The constant is very likely to have the right type already.
559 if (CI->getType() == IntPtrTy)
560 return CI;
561 else
562 return cast<ConstantInt>(
563 Val: ConstantFoldIntegerCast(C: CI, DestTy: IntPtrTy, /*isSigned=*/IsSigned: false, DL));
564 }
565 return nullptr;
566}
567
568namespace {
569
570/// Given a chain of or (||) or and (&&) comparison of a value against a
571/// constant, this will try to recover the information required for a switch
572/// structure.
573/// It will depth-first traverse the chain of comparison, seeking for patterns
574/// like %a == 12 or %a < 4 and combine them to produce a set of integer
575/// representing the different cases for the switch.
576/// Note that if the chain is composed of '||' it will build the set of elements
577/// that matches the comparisons (i.e. any of this value validate the chain)
578/// while for a chain of '&&' it will build the set elements that make the test
579/// fail.
580struct ConstantComparesGatherer {
581 const DataLayout &DL;
582
583 /// Value found for the switch comparison
584 Value *CompValue = nullptr;
585
586 /// Extra clause to be checked before the switch
587 Value *Extra = nullptr;
588
589 /// Set of integers to match in switch
590 SmallVector<ConstantInt *, 8> Vals;
591
592 /// Number of comparisons matched in the and/or chain
593 unsigned UsedICmps = 0;
594
595 /// If the elements in Vals matches the comparisons
596 bool IsEq = false;
597
598 // Used to check if the first matched CompValue shall be the Extra check.
599 bool IgnoreFirstMatch = false;
600 bool MultipleMatches = false;
601
602 /// Construct and compute the result for the comparison instruction Cond
603 ConstantComparesGatherer(Instruction *Cond, const DataLayout &DL) : DL(DL) {
604 gather(V: Cond);
605 if (CompValue || !MultipleMatches)
606 return;
607 Extra = nullptr;
608 Vals.clear();
609 UsedICmps = 0;
610 IgnoreFirstMatch = true;
611 gather(V: Cond);
612 }
613
614 ConstantComparesGatherer(const ConstantComparesGatherer &) = delete;
615 ConstantComparesGatherer &
616 operator=(const ConstantComparesGatherer &) = delete;
617
618private:
619 /// Try to set the current value used for the comparison, it succeeds only if
620 /// it wasn't set before or if the new value is the same as the old one
621 bool setValueOnce(Value *NewVal) {
622 if (IgnoreFirstMatch) {
623 IgnoreFirstMatch = false;
624 return false;
625 }
626 if (CompValue && CompValue != NewVal) {
627 MultipleMatches = true;
628 return false;
629 }
630 CompValue = NewVal;
631 return true;
632 }
633
634 /// Try to match Instruction "I" as a comparison against a constant and
635 /// populates the array Vals with the set of values that match (or do not
636 /// match depending on isEQ).
637 /// Return false on failure. On success, the Value the comparison matched
638 /// against is placed in CompValue.
639 /// If CompValue is already set, the function is expected to fail if a match
640 /// is found but the value compared to is different.
641 bool matchInstruction(Instruction *I, bool isEQ) {
642 if (match(V: I, P: m_Not(V: m_Instruction(I))))
643 isEQ = !isEQ;
644
645 Value *Val;
646 if (match(V: I, P: m_NUWTrunc(Op: m_Value(V&: Val)))) {
647 // If we already have a value for the switch, it has to match!
648 if (!setValueOnce(Val))
649 return false;
650 UsedICmps++;
651 Vals.push_back(Elt: ConstantInt::get(Ty: cast<IntegerType>(Val: Val->getType()), V: isEQ));
652 return true;
653 }
654 // If this is an icmp against a constant, handle this as one of the cases.
655 ICmpInst *ICI;
656 ConstantInt *C;
657 if (!((ICI = dyn_cast<ICmpInst>(Val: I)) &&
658 (C = getConstantInt(V: I->getOperand(i: 1), DL)))) {
659 return false;
660 }
661
662 Value *RHSVal;
663 const APInt *RHSC;
664
665 // Pattern match a special case
666 // (x & ~2^z) == y --> x == y || x == y|2^z
667 // This undoes a transformation done by instcombine to fuse 2 compares.
668 if (ICI->getPredicate() == (isEQ ? ICmpInst::ICMP_EQ : ICmpInst::ICMP_NE)) {
669 // It's a little bit hard to see why the following transformations are
670 // correct. Here is a CVC3 program to verify them for 64-bit values:
671
672 /*
673 ONE : BITVECTOR(64) = BVZEROEXTEND(0bin1, 63);
674 x : BITVECTOR(64);
675 y : BITVECTOR(64);
676 z : BITVECTOR(64);
677 mask : BITVECTOR(64) = BVSHL(ONE, z);
678 QUERY( (y & ~mask = y) =>
679 ((x & ~mask = y) <=> (x = y OR x = (y | mask)))
680 );
681 QUERY( (y | mask = y) =>
682 ((x | mask = y) <=> (x = y OR x = (y & ~mask)))
683 );
684 */
685
686 // Please note that each pattern must be a dual implication (<--> or
687 // iff). One directional implication can create spurious matches. If the
688 // implication is only one-way, an unsatisfiable condition on the left
689 // side can imply a satisfiable condition on the right side. Dual
690 // implication ensures that satisfiable conditions are transformed to
691 // other satisfiable conditions and unsatisfiable conditions are
692 // transformed to other unsatisfiable conditions.
693
694 // Here is a concrete example of a unsatisfiable condition on the left
695 // implying a satisfiable condition on the right:
696 //
697 // mask = (1 << z)
698 // (x & ~mask) == y --> (x == y || x == (y | mask))
699 //
700 // Substituting y = 3, z = 0 yields:
701 // (x & -2) == 3 --> (x == 3 || x == 2)
702
703 // Pattern match a special case:
704 /*
705 QUERY( (y & ~mask = y) =>
706 ((x & ~mask = y) <=> (x = y OR x = (y | mask)))
707 );
708 */
709 if (match(V: ICI->getOperand(i_nocapture: 0),
710 P: m_And(L: m_Value(V&: RHSVal), R: m_APInt(Res&: RHSC)))) {
711 APInt Mask = ~*RHSC;
712 if (Mask.isPowerOf2() && (C->getValue() & ~Mask) == C->getValue()) {
713 // If we already have a value for the switch, it has to match!
714 if (!setValueOnce(RHSVal))
715 return false;
716
717 Vals.push_back(Elt: C);
718 Vals.push_back(
719 Elt: ConstantInt::get(Context&: C->getContext(),
720 V: C->getValue() | Mask));
721 UsedICmps++;
722 return true;
723 }
724 }
725
726 // Pattern match a special case:
727 /*
728 QUERY( (y | mask = y) =>
729 ((x | mask = y) <=> (x = y OR x = (y & ~mask)))
730 );
731 */
732 if (match(V: ICI->getOperand(i_nocapture: 0),
733 P: m_Or(L: m_Value(V&: RHSVal), R: m_APInt(Res&: RHSC)))) {
734 APInt Mask = *RHSC;
735 if (Mask.isPowerOf2() && (C->getValue() | Mask) == C->getValue()) {
736 // If we already have a value for the switch, it has to match!
737 if (!setValueOnce(RHSVal))
738 return false;
739
740 Vals.push_back(Elt: C);
741 Vals.push_back(Elt: ConstantInt::get(Context&: C->getContext(),
742 V: C->getValue() & ~Mask));
743 UsedICmps++;
744 return true;
745 }
746 }
747
748 // If we already have a value for the switch, it has to match!
749 if (!setValueOnce(ICI->getOperand(i_nocapture: 0)))
750 return false;
751
752 UsedICmps++;
753 Vals.push_back(Elt: C);
754 return true;
755 }
756
757 // If we have "x ult 3", for example, then we can add 0,1,2 to the set.
758 ConstantRange Span =
759 ConstantRange::makeExactICmpRegion(Pred: ICI->getPredicate(), Other: C->getValue());
760
761 // Shift the range if the compare is fed by an add. This is the range
762 // compare idiom as emitted by instcombine.
763 Value *CandidateVal = I->getOperand(i: 0);
764 if (match(V: I->getOperand(i: 0), P: m_Add(L: m_Value(V&: RHSVal), R: m_APInt(Res&: RHSC)))) {
765 Span = Span.subtract(CI: *RHSC);
766 CandidateVal = RHSVal;
767 }
768
769 // If this is an and/!= check, then we are looking to build the set of
770 // value that *don't* pass the and chain. I.e. to turn "x ugt 2" into
771 // x != 0 && x != 1.
772 if (!isEQ)
773 Span = Span.inverse();
774
775 // If there are a ton of values, we don't want to make a ginormous switch.
776 if (Span.isSizeLargerThan(MaxSize: 8) || Span.isEmptySet()) {
777 return false;
778 }
779
780 // If we already have a value for the switch, it has to match!
781 if (!setValueOnce(CandidateVal))
782 return false;
783
784 // Add all values from the range to the set
785 APInt Tmp = Span.getLower();
786 do
787 Vals.push_back(Elt: ConstantInt::get(Context&: I->getContext(), V: Tmp));
788 while (++Tmp != Span.getUpper());
789
790 UsedICmps++;
791 return true;
792 }
793
794 /// Given a potentially 'or'd or 'and'd together collection of icmp
795 /// eq/ne/lt/gt instructions that compare a value against a constant, extract
796 /// the value being compared, and stick the list constants into the Vals
797 /// vector.
798 /// One "Extra" case is allowed to differ from the other.
799 void gather(Value *V) {
800 Value *Op0, *Op1;
801 if (match(V, P: m_LogicalOr(L: m_Value(V&: Op0), R: m_Value(V&: Op1))))
802 IsEq = true;
803 else if (match(V, P: m_LogicalAnd(L: m_Value(V&: Op0), R: m_Value(V&: Op1))))
804 IsEq = false;
805 else
806 return;
807 // Keep a stack (SmallVector for efficiency) for depth-first traversal
808 SmallVector<Value *, 8> DFT{Op0, Op1};
809 SmallPtrSet<Value *, 8> Visited{V, Op0, Op1};
810
811 while (!DFT.empty()) {
812 V = DFT.pop_back_val();
813
814 if (Instruction *I = dyn_cast<Instruction>(Val: V)) {
815 // If it is a || (or && depending on isEQ), process the operands.
816 if (IsEq ? match(V: I, P: m_LogicalOr(L: m_Value(V&: Op0), R: m_Value(V&: Op1)))
817 : match(V: I, P: m_LogicalAnd(L: m_Value(V&: Op0), R: m_Value(V&: Op1)))) {
818 if (Visited.insert(Ptr: Op1).second)
819 DFT.push_back(Elt: Op1);
820 if (Visited.insert(Ptr: Op0).second)
821 DFT.push_back(Elt: Op0);
822
823 continue;
824 }
825
826 // Try to match the current instruction
827 if (matchInstruction(I, isEQ: IsEq))
828 // Match succeed, continue the loop
829 continue;
830 }
831
832 // One element of the sequence of || (or &&) could not be match as a
833 // comparison against the same value as the others.
834 // We allow only one "Extra" case to be checked before the switch
835 if (!Extra) {
836 Extra = V;
837 continue;
838 }
839 // Failed to parse a proper sequence, abort now
840 CompValue = nullptr;
841 break;
842 }
843 }
844};
845
846} // end anonymous namespace
847
848static void eraseTerminatorAndDCECond(Instruction *TI,
849 MemorySSAUpdater *MSSAU = nullptr) {
850 Instruction *Cond = nullptr;
851 if (SwitchInst *SI = dyn_cast<SwitchInst>(Val: TI)) {
852 Cond = dyn_cast<Instruction>(Val: SI->getCondition());
853 } else if (CondBrInst *BI = dyn_cast<CondBrInst>(Val: TI)) {
854 Cond = dyn_cast<Instruction>(Val: BI->getCondition());
855 } else if (IndirectBrInst *IBI = dyn_cast<IndirectBrInst>(Val: TI)) {
856 Cond = dyn_cast<Instruction>(Val: IBI->getAddress());
857 }
858
859 TI->eraseFromParent();
860 if (Cond)
861 RecursivelyDeleteTriviallyDeadInstructions(V: Cond, TLI: nullptr, MSSAU);
862}
863
864/// Return true if the specified terminator checks
865/// to see if a value is equal to constant integer value.
866Value *SimplifyCFGOpt::isValueEqualityComparison(Instruction *TI) {
867 Value *CV = nullptr;
868 if (SwitchInst *SI = dyn_cast<SwitchInst>(Val: TI)) {
869 // Do not permit merging of large switch instructions into their
870 // predecessors unless there is only one predecessor.
871 if (!SI->getParent()->hasNPredecessorsOrMore(N: 128 / SI->getNumSuccessors()))
872 CV = SI->getCondition();
873 } else if (CondBrInst *BI = dyn_cast<CondBrInst>(Val: TI))
874 if (BI->getCondition()->hasOneUse()) {
875 if (ICmpInst *ICI = dyn_cast<ICmpInst>(Val: BI->getCondition())) {
876 if (ICI->isEquality() && getConstantInt(V: ICI->getOperand(i_nocapture: 1), DL))
877 CV = ICI->getOperand(i_nocapture: 0);
878 } else if (auto *Trunc = dyn_cast<TruncInst>(Val: BI->getCondition())) {
879 if (Trunc->hasNoUnsignedWrap())
880 CV = Trunc->getOperand(i_nocapture: 0);
881 }
882 }
883
884 // Unwrap any lossless ptrtoint cast (except for unstable pointers).
885 if (CV) {
886 if (PtrToIntInst *PTII = dyn_cast<PtrToIntInst>(Val: CV)) {
887 Value *Ptr = PTII->getPointerOperand();
888 if (DL.hasUnstableRepresentation(Ty: Ptr->getType()))
889 return CV;
890 if (PTII->getType() == DL.getIntPtrType(Ptr->getType()))
891 CV = Ptr;
892 }
893 }
894 return CV;
895}
896
897/// Given a value comparison instruction,
898/// decode all of the 'cases' that it represents and return the 'default' block.
899BasicBlock *SimplifyCFGOpt::getValueEqualityComparisonCases(
900 Instruction *TI, std::vector<ValueEqualityComparisonCase> &Cases) {
901 if (SwitchInst *SI = dyn_cast<SwitchInst>(Val: TI)) {
902 Cases.reserve(n: SI->getNumCases());
903 for (auto Case : SI->cases())
904 Cases.push_back(x: ValueEqualityComparisonCase(Case.getCaseValue(),
905 Case.getCaseSuccessor()));
906 return SI->getDefaultDest();
907 }
908
909 CondBrInst *BI = cast<CondBrInst>(Val: TI);
910 Value *Cond = BI->getCondition();
911 ICmpInst::Predicate Pred;
912 ConstantInt *C;
913 if (auto *ICI = dyn_cast<ICmpInst>(Val: Cond)) {
914 Pred = ICI->getPredicate();
915 C = getConstantInt(V: ICI->getOperand(i_nocapture: 1), DL);
916 } else {
917 Pred = ICmpInst::ICMP_NE;
918 auto *Trunc = cast<TruncInst>(Val: Cond);
919 C = ConstantInt::get(Ty: cast<IntegerType>(Val: Trunc->getOperand(i_nocapture: 0)->getType()), V: 0);
920 }
921 BasicBlock *Succ = BI->getSuccessor(i: Pred == ICmpInst::ICMP_NE);
922 Cases.push_back(x: ValueEqualityComparisonCase(C, Succ));
923 return BI->getSuccessor(i: Pred == ICmpInst::ICMP_EQ);
924}
925
926/// Given a vector of bb/value pairs, remove any entries
927/// in the list that match the specified block.
928static void
929eliminateBlockCases(BasicBlock *BB,
930 std::vector<ValueEqualityComparisonCase> &Cases) {
931 llvm::erase(C&: Cases, V: BB);
932}
933
934/// Return true if there are any keys in C1 that exist in C2 as well.
935static bool valuesOverlap(std::vector<ValueEqualityComparisonCase> &C1,
936 std::vector<ValueEqualityComparisonCase> &C2) {
937 std::vector<ValueEqualityComparisonCase> *V1 = &C1, *V2 = &C2;
938
939 // Make V1 be smaller than V2.
940 if (V1->size() > V2->size())
941 std::swap(a&: V1, b&: V2);
942
943 if (V1->empty())
944 return false;
945 if (V1->size() == 1) {
946 // Just scan V2.
947 ConstantInt *TheVal = (*V1)[0].Value;
948 for (const ValueEqualityComparisonCase &VECC : *V2)
949 if (TheVal == VECC.Value)
950 return true;
951 }
952
953 // Otherwise, just sort both lists and compare element by element.
954 array_pod_sort(Start: V1->begin(), End: V1->end());
955 array_pod_sort(Start: V2->begin(), End: V2->end());
956 unsigned i1 = 0, i2 = 0, e1 = V1->size(), e2 = V2->size();
957 while (i1 != e1 && i2 != e2) {
958 if ((*V1)[i1].Value == (*V2)[i2].Value)
959 return true;
960 if ((*V1)[i1].Value < (*V2)[i2].Value)
961 ++i1;
962 else
963 ++i2;
964 }
965 return false;
966}
967
968/// If TI is known to be a terminator instruction and its block is known to
969/// only have a single predecessor block, check to see if that predecessor is
970/// also a value comparison with the same value, and if that comparison
971/// determines the outcome of this comparison. If so, simplify TI. This does a
972/// very limited form of jump threading.
973bool SimplifyCFGOpt::simplifyEqualityComparisonWithOnlyPredecessor(
974 Instruction *TI, BasicBlock *Pred, IRBuilder<> &Builder) {
975 Value *PredVal = isValueEqualityComparison(TI: Pred->getTerminator());
976 if (!PredVal)
977 return false; // Not a value comparison in predecessor.
978
979 Value *ThisVal = isValueEqualityComparison(TI);
980 assert(ThisVal && "This isn't a value comparison!!");
981 if (ThisVal != PredVal)
982 return false; // Different predicates.
983
984 // TODO: Preserve branch weight metadata, similarly to how
985 // foldValueComparisonIntoPredecessors preserves it.
986
987 // Find out information about when control will move from Pred to TI's block.
988 std::vector<ValueEqualityComparisonCase> PredCases;
989 BasicBlock *PredDef =
990 getValueEqualityComparisonCases(TI: Pred->getTerminator(), Cases&: PredCases);
991 eliminateBlockCases(BB: PredDef, Cases&: PredCases); // Remove default from cases.
992
993 // Find information about how control leaves this block.
994 std::vector<ValueEqualityComparisonCase> ThisCases;
995 BasicBlock *ThisDef = getValueEqualityComparisonCases(TI, Cases&: ThisCases);
996 eliminateBlockCases(BB: ThisDef, Cases&: ThisCases); // Remove default from cases.
997
998 // If TI's block is the default block from Pred's comparison, potentially
999 // simplify TI based on this knowledge.
1000 if (PredDef == TI->getParent()) {
1001 // If we are here, we know that the value is none of those cases listed in
1002 // PredCases. If there are any cases in ThisCases that are in PredCases, we
1003 // can simplify TI.
1004 if (!valuesOverlap(C1&: PredCases, C2&: ThisCases))
1005 return false;
1006
1007 if (isa<CondBrInst>(Val: TI)) {
1008 // Okay, one of the successors of this condbr is dead. Convert it to a
1009 // uncond br.
1010 assert(ThisCases.size() == 1 && "Branch can only have one case!");
1011 // Insert the new branch.
1012 Instruction *NI = Builder.CreateBr(Dest: ThisDef);
1013 (void)NI;
1014
1015 // Remove PHI node entries for the dead edge.
1016 ThisCases[0].Dest->removePredecessor(Pred: PredDef);
1017
1018 LLVM_DEBUG(dbgs() << "Threading pred instr: " << *Pred->getTerminator()
1019 << "Through successor TI: " << *TI << "Leaving: " << *NI
1020 << "\n");
1021
1022 eraseTerminatorAndDCECond(TI);
1023
1024 if (DTU)
1025 DTU->applyUpdates(
1026 Updates: {{DominatorTree::Delete, PredDef, ThisCases[0].Dest}});
1027
1028 return true;
1029 }
1030
1031 SwitchInstProfUpdateWrapper SI = *cast<SwitchInst>(Val: TI);
1032 // Okay, TI has cases that are statically dead, prune them away.
1033 SmallPtrSet<Constant *, 16> DeadCases;
1034 for (const ValueEqualityComparisonCase &Case : PredCases)
1035 DeadCases.insert(Ptr: Case.Value);
1036
1037 LLVM_DEBUG(dbgs() << "Threading pred instr: " << *Pred->getTerminator()
1038 << "Through successor TI: " << *TI);
1039
1040 SmallDenseMap<BasicBlock *, int, 8> NumPerSuccessorCases;
1041 for (SwitchInst::CaseIt i = SI->case_end(), e = SI->case_begin(); i != e;) {
1042 --i;
1043 auto *Successor = i->getCaseSuccessor();
1044 if (DTU)
1045 ++NumPerSuccessorCases[Successor];
1046 if (DeadCases.count(Ptr: i->getCaseValue())) {
1047 Successor->removePredecessor(Pred: PredDef);
1048 SI.removeCase(I: i);
1049 if (DTU)
1050 --NumPerSuccessorCases[Successor];
1051 }
1052 }
1053
1054 if (DTU) {
1055 std::vector<DominatorTree::UpdateType> Updates;
1056 for (const auto &I : NumPerSuccessorCases)
1057 if (I.second == 0)
1058 Updates.push_back(x: {DominatorTree::Delete, PredDef, I.first});
1059 DTU->applyUpdates(Updates);
1060 }
1061
1062 LLVM_DEBUG(dbgs() << "Leaving: " << *TI << "\n");
1063 return true;
1064 }
1065
1066 // Otherwise, TI's block must correspond to some matched value. Find out
1067 // which value (or set of values) this is.
1068 ConstantInt *TIV = nullptr;
1069 BasicBlock *TIBB = TI->getParent();
1070 for (const auto &[Value, Dest] : PredCases)
1071 if (Dest == TIBB) {
1072 if (TIV)
1073 return false; // Cannot handle multiple values coming to this block.
1074 TIV = Value;
1075 }
1076 assert(TIV && "No edge from pred to succ?");
1077
1078 // Okay, we found the one constant that our value can be if we get into TI's
1079 // BB. Find out which successor will unconditionally be branched to.
1080 BasicBlock *TheRealDest = nullptr;
1081 for (const auto &[Value, Dest] : ThisCases)
1082 if (Value == TIV) {
1083 TheRealDest = Dest;
1084 break;
1085 }
1086
1087 // If not handled by any explicit cases, it is handled by the default case.
1088 if (!TheRealDest)
1089 TheRealDest = ThisDef;
1090
1091 SmallPtrSet<BasicBlock *, 2> RemovedSuccs;
1092
1093 // Remove PHI node entries for dead edges.
1094 BasicBlock *CheckEdge = TheRealDest;
1095 for (BasicBlock *Succ : successors(BB: TIBB))
1096 if (Succ != CheckEdge) {
1097 if (Succ != TheRealDest)
1098 RemovedSuccs.insert(Ptr: Succ);
1099 Succ->removePredecessor(Pred: TIBB);
1100 } else
1101 CheckEdge = nullptr;
1102
1103 // Insert the new branch.
1104 Instruction *NI = Builder.CreateBr(Dest: TheRealDest);
1105 (void)NI;
1106
1107 LLVM_DEBUG(dbgs() << "Threading pred instr: " << *Pred->getTerminator()
1108 << "Through successor TI: " << *TI << "Leaving: " << *NI
1109 << "\n");
1110
1111 eraseTerminatorAndDCECond(TI);
1112 if (DTU) {
1113 SmallVector<DominatorTree::UpdateType, 2> Updates;
1114 Updates.reserve(N: RemovedSuccs.size());
1115 for (auto *RemovedSucc : RemovedSuccs)
1116 Updates.push_back(Elt: {DominatorTree::Delete, TIBB, RemovedSucc});
1117 DTU->applyUpdates(Updates);
1118 }
1119 return true;
1120}
1121
1122namespace {
1123
1124/// This class implements a stable ordering of constant
1125/// integers that does not depend on their address. This is important for
1126/// applications that sort ConstantInt's to ensure uniqueness.
1127struct ConstantIntOrdering {
1128 bool operator()(const ConstantInt *LHS, const ConstantInt *RHS) const {
1129 return LHS->getValue().ult(RHS: RHS->getValue());
1130 }
1131};
1132
1133} // end anonymous namespace
1134
1135static int constantIntSortPredicate(ConstantInt *const *P1,
1136 ConstantInt *const *P2) {
1137 const ConstantInt *LHS = *P1;
1138 const ConstantInt *RHS = *P2;
1139 if (LHS == RHS)
1140 return 0;
1141 return LHS->getValue().ult(RHS: RHS->getValue()) ? 1 : -1;
1142}
1143
1144/// Get Weights of a given terminator, the default weight is at the front
1145/// of the vector. If TI is a conditional eq, we need to swap the branch-weight
1146/// metadata.
1147static void getBranchWeights(Instruction *TI,
1148 SmallVectorImpl<uint64_t> &Weights) {
1149 MDNode *MD = TI->getMetadata(KindID: LLVMContext::MD_prof);
1150 assert(MD && "Invalid branch-weight metadata");
1151 extractFromBranchWeightMD64(ProfileData: MD, Weights);
1152
1153 // If TI is a conditional eq, the default case is the false case,
1154 // and the corresponding branch-weight data is at index 2. We swap the
1155 // default weight to be the first entry.
1156 if (CondBrInst *BI = dyn_cast<CondBrInst>(Val: TI)) {
1157 assert(Weights.size() == 2);
1158 auto *ICI = dyn_cast<ICmpInst>(Val: BI->getCondition());
1159 if (!ICI)
1160 return;
1161
1162 if (ICI->getPredicate() == ICmpInst::ICMP_EQ)
1163 std::swap(a&: Weights.front(), b&: Weights.back());
1164 }
1165}
1166
1167static void cloneInstructionsIntoPredecessorBlockAndUpdateSSAUses(
1168 BasicBlock *BB, BasicBlock *PredBlock, ValueToValueMapTy &VMap) {
1169 Instruction *PTI = PredBlock->getTerminator();
1170
1171 // If we have bonus instructions, clone them into the predecessor block.
1172 // Note that there may be multiple predecessor blocks, so we cannot move
1173 // bonus instructions to a predecessor block.
1174 for (Instruction &BonusInst : *BB) {
1175 if (BonusInst.isTerminator())
1176 continue;
1177
1178 // Skip cloning pseudo probes into the predecessor, as it would overcount
1179 // otherwise.
1180 if (isa<PseudoProbeInst>(Val: BonusInst))
1181 continue;
1182
1183 Instruction *NewBonusInst = BonusInst.clone();
1184 NewBonusInst->insertInto(ParentBB: PredBlock, It: PTI->getIterator());
1185
1186 if (!NewBonusInst->getDebugLoc().isSameSourceLocation(Other: PTI->getDebugLoc())) {
1187 // Unless the instruction has the same !dbg location as the original
1188 // branch, drop it. When we fold the bonus instructions we want to make
1189 // sure we reset their debug locations in order to avoid stepping on
1190 // dead code caused by folding dead branches.
1191 NewBonusInst->dropLocation();
1192 } else if (const DebugLoc &DL = NewBonusInst->getDebugLoc()) {
1193 mapAtomInstance(DL, VMap);
1194 }
1195
1196 RemapInstruction(I: NewBonusInst, VM&: VMap,
1197 Flags: RF_NoModuleLevelChanges | RF_IgnoreMissingLocals);
1198
1199 // If we speculated an instruction, we need to drop any metadata that may
1200 // result in undefined behavior, as the metadata might have been valid
1201 // only given the branch precondition.
1202 // Similarly strip attributes on call parameters that may cause UB in
1203 // location the call is moved to.
1204 NewBonusInst->dropUBImplyingAttrsAndMetadata();
1205
1206 auto Range = NewBonusInst->cloneDebugInfoFrom(From: &BonusInst);
1207 RemapDbgRecordRange(M: NewBonusInst->getModule(), Range, VM&: VMap,
1208 Flags: RF_NoModuleLevelChanges | RF_IgnoreMissingLocals);
1209
1210 NewBonusInst->takeName(V: &BonusInst);
1211 BonusInst.setName(NewBonusInst->getName() + ".old");
1212 VMap[&BonusInst] = NewBonusInst;
1213
1214 // Update (liveout) uses of bonus instructions,
1215 // now that the bonus instruction has been cloned into predecessor.
1216 // Note that we expect to be in a block-closed SSA form for this to work!
1217 for (Use &U : make_early_inc_range(Range: BonusInst.uses())) {
1218 auto *UI = cast<Instruction>(Val: U.getUser());
1219 auto *PN = dyn_cast<PHINode>(Val: UI);
1220 if (!PN) {
1221 assert(UI->getParent() == BB && BonusInst.comesBefore(UI) &&
1222 "If the user is not a PHI node, then it should be in the same "
1223 "block as, and come after, the original bonus instruction.");
1224 continue; // Keep using the original bonus instruction.
1225 }
1226 // Is this the block-closed SSA form PHI node?
1227 if (PN->getIncomingBlock(U) == BB)
1228 continue; // Great, keep using the original bonus instruction.
1229 // The only other alternative is an "use" when coming from
1230 // the predecessor block - here we should refer to the cloned bonus instr.
1231 assert(PN->getIncomingBlock(U) == PredBlock &&
1232 "Not in block-closed SSA form?");
1233 U.set(NewBonusInst);
1234 }
1235 }
1236
1237 // Key Instructions: We may have propagated atom info into the pred. If the
1238 // pred's terminator already has atom info do nothing as merging would drop
1239 // one atom group anyway. If it doesn't, propagte the remapped atom group
1240 // from BB's terminator.
1241 if (auto &PredDL = PTI->getDebugLoc()) {
1242 auto &DL = BB->getTerminator()->getDebugLoc();
1243 if (!PredDL->getAtomGroup() && DL && DL->getAtomGroup() &&
1244 PredDL.isSameSourceLocation(Other: DL)) {
1245 PTI->setDebugLoc(DL);
1246 RemapSourceAtom(I: PTI, VM&: VMap);
1247 }
1248 }
1249}
1250
1251bool SimplifyCFGOpt::performValueComparisonIntoPredecessorFolding(
1252 Instruction *TI, Value *&CV, Instruction *PTI, IRBuilder<> &Builder) {
1253 BasicBlock *BB = TI->getParent();
1254 BasicBlock *Pred = PTI->getParent();
1255
1256 SmallVector<DominatorTree::UpdateType, 32> Updates;
1257
1258 // Figure out which 'cases' to copy from SI to PSI.
1259 std::vector<ValueEqualityComparisonCase> BBCases;
1260 BasicBlock *BBDefault = getValueEqualityComparisonCases(TI, Cases&: BBCases);
1261
1262 std::vector<ValueEqualityComparisonCase> PredCases;
1263 BasicBlock *PredDefault = getValueEqualityComparisonCases(TI: PTI, Cases&: PredCases);
1264
1265 // Based on whether the default edge from PTI goes to BB or not, fill in
1266 // PredCases and PredDefault with the new switch cases we would like to
1267 // build.
1268 SmallMapVector<BasicBlock *, int, 8> NewSuccessors;
1269
1270 // Update the branch weight metadata along the way
1271 SmallVector<uint64_t, 8> Weights;
1272 bool PredHasWeights = hasBranchWeightMD(I: *PTI);
1273 bool SuccHasWeights = hasBranchWeightMD(I: *TI);
1274
1275 if (PredHasWeights) {
1276 getBranchWeights(TI: PTI, Weights);
1277 // branch-weight metadata is inconsistent here.
1278 if (Weights.size() != 1 + PredCases.size())
1279 PredHasWeights = SuccHasWeights = false;
1280 } else if (SuccHasWeights)
1281 // If there are no predecessor weights but there are successor weights,
1282 // populate Weights with 1, which will later be scaled to the sum of
1283 // successor's weights
1284 Weights.assign(NumElts: 1 + PredCases.size(), Elt: 1);
1285
1286 SmallVector<uint64_t, 8> SuccWeights;
1287 if (SuccHasWeights) {
1288 getBranchWeights(TI, Weights&: SuccWeights);
1289 // branch-weight metadata is inconsistent here.
1290 if (SuccWeights.size() != 1 + BBCases.size())
1291 PredHasWeights = SuccHasWeights = false;
1292 } else if (PredHasWeights)
1293 SuccWeights.assign(NumElts: 1 + BBCases.size(), Elt: 1);
1294
1295 if (PredDefault == BB) {
1296 // If this is the default destination from PTI, only the edges in TI
1297 // that don't occur in PTI, or that branch to BB will be activated.
1298 std::set<ConstantInt *, ConstantIntOrdering> PTIHandled;
1299 for (unsigned i = 0, e = PredCases.size(); i != e; ++i)
1300 if (PredCases[i].Dest != BB)
1301 PTIHandled.insert(x: PredCases[i].Value);
1302 else {
1303 // The default destination is BB, we don't need explicit targets.
1304 std::swap(a&: PredCases[i], b&: PredCases.back());
1305
1306 if (PredHasWeights || SuccHasWeights) {
1307 // Increase weight for the default case.
1308 Weights[0] += Weights[i + 1];
1309 std::swap(a&: Weights[i + 1], b&: Weights.back());
1310 Weights.pop_back();
1311 }
1312
1313 PredCases.pop_back();
1314 --i;
1315 --e;
1316 }
1317
1318 // Reconstruct the new switch statement we will be building.
1319 if (PredDefault != BBDefault) {
1320 PredDefault->removePredecessor(Pred);
1321 if (DTU && PredDefault != BB)
1322 Updates.push_back(Elt: {DominatorTree::Delete, Pred, PredDefault});
1323 PredDefault = BBDefault;
1324 ++NewSuccessors[BBDefault];
1325 }
1326
1327 unsigned CasesFromPred = Weights.size();
1328 uint64_t ValidTotalSuccWeight = 0;
1329 for (unsigned i = 0, e = BBCases.size(); i != e; ++i)
1330 if (!PTIHandled.count(x: BBCases[i].Value) && BBCases[i].Dest != BBDefault) {
1331 PredCases.push_back(x: BBCases[i]);
1332 ++NewSuccessors[BBCases[i].Dest];
1333 if (SuccHasWeights || PredHasWeights) {
1334 // The default weight is at index 0, so weight for the ith case
1335 // should be at index i+1. Scale the cases from successor by
1336 // PredDefaultWeight (Weights[0]).
1337 Weights.push_back(Elt: Weights[0] * SuccWeights[i + 1]);
1338 ValidTotalSuccWeight += SuccWeights[i + 1];
1339 }
1340 }
1341
1342 if (SuccHasWeights || PredHasWeights) {
1343 ValidTotalSuccWeight += SuccWeights[0];
1344 // Scale the cases from predecessor by ValidTotalSuccWeight.
1345 for (unsigned i = 1; i < CasesFromPred; ++i)
1346 Weights[i] *= ValidTotalSuccWeight;
1347 // Scale the default weight by SuccDefaultWeight (SuccWeights[0]).
1348 Weights[0] *= SuccWeights[0];
1349 }
1350 } else {
1351 // If this is not the default destination from PSI, only the edges
1352 // in SI that occur in PSI with a destination of BB will be
1353 // activated.
1354 std::set<ConstantInt *, ConstantIntOrdering> PTIHandled;
1355 std::map<ConstantInt *, uint64_t> WeightsForHandled;
1356 for (unsigned i = 0, e = PredCases.size(); i != e; ++i)
1357 if (PredCases[i].Dest == BB) {
1358 PTIHandled.insert(x: PredCases[i].Value);
1359
1360 if (PredHasWeights || SuccHasWeights) {
1361 WeightsForHandled[PredCases[i].Value] = Weights[i + 1];
1362 std::swap(a&: Weights[i + 1], b&: Weights.back());
1363 Weights.pop_back();
1364 }
1365
1366 std::swap(a&: PredCases[i], b&: PredCases.back());
1367 PredCases.pop_back();
1368 --i;
1369 --e;
1370 }
1371
1372 // Okay, now we know which constants were sent to BB from the
1373 // predecessor. Figure out where they will all go now.
1374 for (const ValueEqualityComparisonCase &Case : BBCases)
1375 if (PTIHandled.count(x: Case.Value)) {
1376 // If this is one we are capable of getting...
1377 if (PredHasWeights || SuccHasWeights)
1378 Weights.push_back(Elt: WeightsForHandled[Case.Value]);
1379 PredCases.push_back(x: Case);
1380 ++NewSuccessors[Case.Dest];
1381 PTIHandled.erase(x: Case.Value); // This constant is taken care of
1382 }
1383
1384 // If there are any constants vectored to BB that TI doesn't handle,
1385 // they must go to the default destination of TI.
1386 for (ConstantInt *I : PTIHandled) {
1387 if (PredHasWeights || SuccHasWeights)
1388 Weights.push_back(Elt: WeightsForHandled[I]);
1389 PredCases.push_back(x: ValueEqualityComparisonCase(I, BBDefault));
1390 ++NewSuccessors[BBDefault];
1391 }
1392 }
1393
1394 // Okay, at this point, we know which new successor Pred will get. Make
1395 // sure we update the number of entries in the PHI nodes for these
1396 // successors.
1397 SmallPtrSet<BasicBlock *, 2> SuccsOfPred;
1398 if (DTU) {
1399 SuccsOfPred = {llvm::from_range, successors(BB: Pred)};
1400 Updates.reserve(N: Updates.size() + NewSuccessors.size());
1401 }
1402 for (const std::pair<BasicBlock *, int /*Num*/> &NewSuccessor :
1403 NewSuccessors) {
1404 for (auto I : seq(Size: NewSuccessor.second)) {
1405 (void)I;
1406 addPredecessorToBlock(Succ: NewSuccessor.first, NewPred: Pred, ExistPred: BB);
1407 }
1408 if (DTU && !SuccsOfPred.contains(Ptr: NewSuccessor.first))
1409 Updates.push_back(Elt: {DominatorTree::Insert, Pred, NewSuccessor.first});
1410 }
1411
1412 Builder.SetInsertPoint(PTI);
1413 // Convert pointer to int before we switch.
1414 if (CV->getType()->isPointerTy()) {
1415 assert(!DL.hasUnstableRepresentation(CV->getType()) &&
1416 "Should not end up here with unstable pointers");
1417 CV =
1418 Builder.CreatePtrToInt(V: CV, DestTy: DL.getIntPtrType(CV->getType()), Name: "magicptr");
1419 }
1420
1421 // Now that the successors are updated, create the new Switch instruction.
1422 SwitchInst *NewSI = Builder.CreateSwitch(V: CV, Dest: PredDefault, NumCases: PredCases.size());
1423 NewSI->setDebugLoc(PTI->getDebugLoc());
1424 for (ValueEqualityComparisonCase &V : PredCases)
1425 NewSI->addCase(OnVal: V.Value, Dest: V.Dest);
1426
1427 if (PredHasWeights || SuccHasWeights)
1428 setFittedBranchWeights(I&: *NewSI, Weights, /*IsExpected=*/false,
1429 /*ElideAllZero=*/true);
1430
1431 // The new switch is only known to be unpredictable if both of the comparisons
1432 // it was built from were unpredictable.
1433 if (MDNode *Unpredictable = PTI->getMetadata(KindID: LLVMContext::MD_unpredictable))
1434 if (TI->hasMetadata(KindID: LLVMContext::MD_unpredictable))
1435 NewSI->setMetadata(KindID: LLVMContext::MD_unpredictable, Node: Unpredictable);
1436
1437 eraseTerminatorAndDCECond(TI: PTI);
1438
1439 // Okay, last check. If BB is still a successor of PSI, then we must
1440 // have an infinite loop case. If so, add an infinitely looping block
1441 // to handle the case to preserve the behavior of the code.
1442 BasicBlock *InfLoopBlock = nullptr;
1443 for (unsigned i = 0, e = NewSI->getNumSuccessors(); i != e; ++i)
1444 if (NewSI->getSuccessor(idx: i) == BB) {
1445 if (!InfLoopBlock) {
1446 // Insert it at the end of the function, because it's either code,
1447 // or it won't matter if it's hot. :)
1448 InfLoopBlock =
1449 BasicBlock::Create(Context&: BB->getContext(), Name: "infloop", Parent: BB->getParent());
1450 UncondBrInst::Create(Target: InfLoopBlock, InsertBefore: InfLoopBlock);
1451 if (DTU)
1452 Updates.push_back(
1453 Elt: {DominatorTree::Insert, InfLoopBlock, InfLoopBlock});
1454 }
1455 NewSI->setSuccessor(idx: i, NewSucc: InfLoopBlock);
1456 }
1457
1458 if (DTU) {
1459 if (InfLoopBlock)
1460 Updates.push_back(Elt: {DominatorTree::Insert, Pred, InfLoopBlock});
1461
1462 Updates.push_back(Elt: {DominatorTree::Delete, Pred, BB});
1463
1464 DTU->applyUpdates(Updates);
1465 }
1466
1467 ++NumFoldValueComparisonIntoPredecessors;
1468 return true;
1469}
1470
1471/// The specified terminator is a value equality comparison instruction
1472/// (either a switch or a branch on "X == c").
1473/// See if any of the predecessors of the terminator block are value comparisons
1474/// on the same value. If so, and if safe to do so, fold them together.
1475bool SimplifyCFGOpt::foldValueComparisonIntoPredecessors(Instruction *TI,
1476 IRBuilder<> &Builder) {
1477 BasicBlock *BB = TI->getParent();
1478 Value *CV = isValueEqualityComparison(TI); // CondVal
1479 assert(CV && "Not a comparison?");
1480
1481 bool Changed = false;
1482
1483 SmallSetVector<BasicBlock *, 16> Preds(pred_begin(BB), pred_end(BB));
1484 while (!Preds.empty()) {
1485 BasicBlock *Pred = Preds.pop_back_val();
1486 Instruction *PTI = Pred->getTerminator();
1487
1488 // Don't try to fold into itself.
1489 if (Pred == BB)
1490 continue;
1491
1492 // See if the predecessor is a comparison with the same value.
1493 Value *PCV = isValueEqualityComparison(TI: PTI); // PredCondVal
1494 if (PCV != CV)
1495 continue;
1496
1497 SmallSetVector<BasicBlock *, 4> FailBlocks;
1498 if (!safeToMergeTerminators(SI1: TI, SI2: PTI, FailBlocks: &FailBlocks)) {
1499 for (auto *Succ : FailBlocks) {
1500 if (!SplitBlockPredecessors(BB: Succ, Preds: TI->getParent(), Suffix: ".fold.split", DTU))
1501 return false;
1502 }
1503 }
1504
1505 performValueComparisonIntoPredecessorFolding(TI, CV, PTI, Builder);
1506 Changed = true;
1507 }
1508 return Changed;
1509}
1510
1511// If we would need to insert a select that uses the value of this invoke
1512// (comments in hoistSuccIdenticalTerminatorToSwitchOrIf explain why we would
1513// need to do this), we can't hoist the invoke, as there is nowhere to put the
1514// select in this case.
1515static bool isSafeToHoistInvoke(BasicBlock *BB1, BasicBlock *BB2,
1516 Instruction *I1, Instruction *I2) {
1517 for (BasicBlock *Succ : successors(BB: BB1)) {
1518 for (const PHINode &PN : Succ->phis()) {
1519 Value *BB1V = PN.getIncomingValueForBlock(BB: BB1);
1520 Value *BB2V = PN.getIncomingValueForBlock(BB: BB2);
1521 if (BB1V != BB2V && (BB1V == I1 || BB2V == I2)) {
1522 return false;
1523 }
1524 }
1525 }
1526 return true;
1527}
1528
1529// Get interesting characteristics of instructions that
1530// `hoistCommonCodeFromSuccessors` didn't hoist. They restrict what kind of
1531// instructions can be reordered across.
1532enum SkipFlags {
1533 SkipReadMem = 1,
1534 SkipSideEffect = 2,
1535 SkipImplicitControlFlow = 4
1536};
1537
1538static unsigned skippedInstrFlags(Instruction *I) {
1539 // Pseudo probes don't constrain reordering of other instructions.
1540 if (isa<PseudoProbeInst>(Val: I))
1541 return 0;
1542 unsigned Flags = 0;
1543 if (I->mayReadFromMemory())
1544 Flags |= SkipReadMem;
1545 // We can't arbitrarily move around allocas, e.g. moving allocas (especially
1546 // inalloca) across stacksave/stackrestore boundaries.
1547 if (I->mayHaveSideEffects() || isa<AllocaInst>(Val: I))
1548 Flags |= SkipSideEffect;
1549 if (!isGuaranteedToTransferExecutionToSuccessor(I))
1550 Flags |= SkipImplicitControlFlow;
1551 return Flags;
1552}
1553
1554// Returns true if it is safe to reorder an instruction across preceding
1555// instructions in a basic block.
1556static bool isSafeToHoistInstr(Instruction *I, unsigned Flags) {
1557 // Don't reorder a store over a load.
1558 if ((Flags & SkipReadMem) && I->mayWriteToMemory())
1559 return false;
1560
1561 // If we have seen an instruction with side effects, it's unsafe to reorder an
1562 // instruction which reads memory or itself has side effects.
1563 if ((Flags & SkipSideEffect) &&
1564 (I->mayReadFromMemory() || I->mayHaveSideEffects() || isa<AllocaInst>(Val: I)))
1565 return false;
1566
1567 // Reordering across an instruction which does not necessarily transfer
1568 // control to the next instruction is speculation.
1569 if ((Flags & SkipImplicitControlFlow) && !isSafeToSpeculativelyExecute(I))
1570 return false;
1571
1572 // Hoisting of llvm.deoptimize is only legal together with the next return
1573 // instruction, which this pass is not always able to do.
1574 if (auto *CB = dyn_cast<CallBase>(Val: I))
1575 if (CB->getIntrinsicID() == Intrinsic::experimental_deoptimize)
1576 return false;
1577
1578 // It's also unsafe/illegal to hoist an instruction above its instruction
1579 // operands
1580 BasicBlock *BB = I->getParent();
1581 for (Value *Op : I->operands()) {
1582 if (auto *J = dyn_cast<Instruction>(Val: Op))
1583 if (J->getParent() == BB)
1584 return false;
1585 }
1586
1587 return true;
1588}
1589
1590static bool passingValueIsAlwaysUndefined(Value *V, Instruction *I, bool PtrValueMayBeModified = false);
1591
1592/// Helper function for hoistCommonCodeFromSuccessors. Return true if identical
1593/// instructions \p I1 and \p I2 can and should be hoisted.
1594static bool shouldHoistCommonInstructions(Instruction *I1, Instruction *I2,
1595 const TargetTransformInfo &TTI) {
1596 // If we're going to hoist a call, make sure that the two instructions
1597 // we're commoning/hoisting are both marked with musttail, or neither of
1598 // them is marked as such. Otherwise, we might end up in a situation where
1599 // we hoist from a block where the terminator is a `ret` to a block where
1600 // the terminator is a `br`, and `musttail` calls expect to be followed by
1601 // a return.
1602 auto *C1 = dyn_cast<CallInst>(Val: I1);
1603 auto *C2 = dyn_cast<CallInst>(Val: I2);
1604 if (C1 && C2)
1605 if (C1->isMustTailCall() != C2->isMustTailCall())
1606 return false;
1607
1608 if (!TTI.isProfitableToHoist(I: I1) || !TTI.isProfitableToHoist(I: I2))
1609 return false;
1610
1611 // If any of the two call sites has nomerge or convergent attribute, stop
1612 // hoisting.
1613 if (const auto *CB1 = dyn_cast<CallBase>(Val: I1))
1614 if (CB1->cannotMerge() || CB1->isConvergent())
1615 return false;
1616 if (const auto *CB2 = dyn_cast<CallBase>(Val: I2))
1617 if (CB2->cannotMerge() || CB2->isConvergent())
1618 return false;
1619
1620 return true;
1621}
1622
1623/// Hoists DbgVariableRecords from \p I1 and \p OtherInstrs that are identical
1624/// in lock-step to \p TI. This matches how dbg.* intrinsics are hoisting in
1625/// hoistCommonCodeFromSuccessors. e.g. The input:
1626/// I1 DVRs: { x, z },
1627/// OtherInsts: { I2 DVRs: { x, y, z } }
1628/// would result in hoisting only DbgVariableRecord x.
1629static void hoistLockstepIdenticalDbgVariableRecords(
1630 Instruction *TI, Instruction *I1,
1631 SmallVectorImpl<Instruction *> &OtherInsts) {
1632 if (!I1->hasDbgRecords())
1633 return;
1634 using CurrentAndEndIt =
1635 std::pair<DbgRecord::self_iterator, DbgRecord::self_iterator>;
1636 // Vector of {Current, End} iterators.
1637 SmallVector<CurrentAndEndIt> Itrs;
1638 Itrs.reserve(N: OtherInsts.size() + 1);
1639 // Helper lambdas for lock-step checks:
1640 // Return true if this Current == End.
1641 auto atEnd = [](const CurrentAndEndIt &Pair) {
1642 return Pair.first == Pair.second;
1643 };
1644 // Return true if all Current are identical.
1645 auto allIdentical = [](const SmallVector<CurrentAndEndIt> &Itrs) {
1646 return all_of(Range: make_first_range(c: ArrayRef(Itrs).drop_front()),
1647 P: [&](DbgRecord::self_iterator I) {
1648 return Itrs[0].first->isIdenticalToWhenDefined(R: *I);
1649 });
1650 };
1651
1652 // Collect the iterators.
1653 Itrs.push_back(
1654 Elt: {I1->getDbgRecordRange().begin(), I1->getDbgRecordRange().end()});
1655 for (Instruction *Other : OtherInsts) {
1656 if (!Other->hasDbgRecords())
1657 return;
1658 Itrs.push_back(
1659 Elt: {Other->getDbgRecordRange().begin(), Other->getDbgRecordRange().end()});
1660 }
1661
1662 // Iterate in lock-step until any of the DbgRecord lists are exausted. If
1663 // the lock-step DbgRecord are identical, hoist all of them to TI.
1664 // This replicates the dbg.* intrinsic behaviour in
1665 // hoistCommonCodeFromSuccessors.
1666 while (none_of(Range&: Itrs, P: atEnd)) {
1667 bool HoistDVRs = allIdentical(Itrs);
1668 for (CurrentAndEndIt &Pair : Itrs) {
1669 // Increment Current iterator now as we may be about to move the
1670 // DbgRecord.
1671 DbgRecord &DR = *Pair.first++;
1672 if (HoistDVRs) {
1673 DR.removeFromParent();
1674 TI->getParent()->insertDbgRecordBefore(DR: &DR, Here: TI->getIterator());
1675 }
1676 }
1677 }
1678}
1679
1680static bool areIdenticalUpToCommutativity(const Instruction *I1,
1681 const Instruction *I2) {
1682 if (I1->isIdenticalToWhenDefined(I: I2, /*IntersectAttrs=*/true))
1683 return true;
1684
1685 if (auto *Cmp1 = dyn_cast<CmpInst>(Val: I1))
1686 if (auto *Cmp2 = dyn_cast<CmpInst>(Val: I2))
1687 return Cmp1->getPredicate() == Cmp2->getSwappedPredicate() &&
1688 Cmp1->getOperand(i_nocapture: 0) == Cmp2->getOperand(i_nocapture: 1) &&
1689 Cmp1->getOperand(i_nocapture: 1) == Cmp2->getOperand(i_nocapture: 0);
1690
1691 if (I1->isCommutative() && I1->isSameOperationAs(I: I2)) {
1692 return I1->getOperand(i: 0) == I2->getOperand(i: 1) &&
1693 I1->getOperand(i: 1) == I2->getOperand(i: 0) &&
1694 equal(LRange: drop_begin(RangeOrContainer: I1->operands(), N: 2), RRange: drop_begin(RangeOrContainer: I2->operands(), N: 2));
1695 }
1696
1697 return false;
1698}
1699
1700/// If the target supports conditional faulting,
1701/// we look for the following pattern:
1702/// \code
1703/// BB:
1704/// ...
1705/// %cond = icmp ult %x, %y
1706/// br i1 %cond, label %TrueBB, label %FalseBB
1707/// FalseBB:
1708/// store i32 1, ptr %q, align 4
1709/// ...
1710/// TrueBB:
1711/// %maskedloadstore = load i32, ptr %b, align 4
1712/// store i32 %maskedloadstore, ptr %p, align 4
1713/// ...
1714/// \endcode
1715///
1716/// and transform it into:
1717///
1718/// \code
1719/// BB:
1720/// ...
1721/// %cond = icmp ult %x, %y
1722/// %maskedloadstore = cload i32, ptr %b, %cond
1723/// cstore i32 %maskedloadstore, ptr %p, %cond
1724/// cstore i32 1, ptr %q, ~%cond
1725/// br i1 %cond, label %TrueBB, label %FalseBB
1726/// FalseBB:
1727/// ...
1728/// TrueBB:
1729/// ...
1730/// \endcode
1731///
1732/// where cload/cstore are represented by llvm.masked.load/store intrinsics,
1733/// e.g.
1734///
1735/// \code
1736/// %vcond = bitcast i1 %cond to <1 x i1>
1737/// %v0 = call <1 x i32> @llvm.masked.load.v1i32.p0
1738/// (ptr %b, i32 4, <1 x i1> %vcond, <1 x i32> poison)
1739/// %maskedloadstore = bitcast <1 x i32> %v0 to i32
1740/// call void @llvm.masked.store.v1i32.p0
1741/// (<1 x i32> %v0, ptr %p, i32 4, <1 x i1> %vcond)
1742/// %cond.not = xor i1 %cond, true
1743/// %vcond.not = bitcast i1 %cond.not to <1 x i>
1744/// call void @llvm.masked.store.v1i32.p0
1745/// (<1 x i32> <i32 1>, ptr %q, i32 4, <1x i1> %vcond.not)
1746/// \endcode
1747///
1748/// So we need to turn hoisted load/store into cload/cstore.
1749///
1750/// \param BI The branch instruction.
1751/// \param SpeculatedConditionalLoadsStores The load/store instructions that
1752/// will be speculated.
1753/// \param Invert indicates if speculates FalseBB. Only used in triangle CFG.
1754static void hoistConditionalLoadsStores(
1755 CondBrInst *BI,
1756 SmallVectorImpl<Instruction *> &SpeculatedConditionalLoadsStores,
1757 std::optional<bool> Invert, Instruction *Sel) {
1758 auto &Context = BI->getParent()->getContext();
1759 auto *VCondTy = FixedVectorType::get(ElementType: Type::getInt1Ty(C&: Context), NumElts: 1);
1760 auto *Cond = BI->getCondition();
1761 // Construct the condition if needed.
1762 BasicBlock *BB = BI->getParent();
1763 Value *Mask = nullptr;
1764 Value *MaskFalse = nullptr;
1765 Value *MaskTrue = nullptr;
1766 if (Invert.has_value()) {
1767 IRBuilder<> Builder(Sel ? Sel : SpeculatedConditionalLoadsStores.back());
1768 Mask = Builder.CreateBitCast(
1769 V: *Invert ? Builder.CreateXor(LHS: Cond, RHS: ConstantInt::getTrue(Context)) : Cond,
1770 DestTy: VCondTy);
1771 } else {
1772 IRBuilder<> Builder(BI);
1773 MaskFalse = Builder.CreateBitCast(
1774 V: Builder.CreateXor(LHS: Cond, RHS: ConstantInt::getTrue(Context)), DestTy: VCondTy);
1775 MaskTrue = Builder.CreateBitCast(V: Cond, DestTy: VCondTy);
1776 }
1777 auto PeekThroughBitcasts = [](Value *V) {
1778 while (auto *BitCast = dyn_cast<BitCastInst>(Val: V))
1779 V = BitCast->getOperand(i_nocapture: 0);
1780 return V;
1781 };
1782 for (auto *I : SpeculatedConditionalLoadsStores) {
1783 IRBuilder<> Builder(Invert.has_value() ? I : BI);
1784 if (!Invert.has_value())
1785 Mask = I->getParent() == BI->getSuccessor(i: 0) ? MaskTrue : MaskFalse;
1786 // We currently assume conditional faulting load/store is supported for
1787 // scalar types only when creating new instructions. This can be easily
1788 // extended for vector types in the future.
1789 assert(!getLoadStoreType(I)->isVectorTy() && "not implemented");
1790 auto *Op0 = I->getOperand(i: 0);
1791 CallInst *MaskedLoadStore = nullptr;
1792 if (auto *LI = dyn_cast<LoadInst>(Val: I)) {
1793 // Handle Load.
1794 auto *Ty = I->getType();
1795 PHINode *PN = nullptr;
1796 Value *PassThru = nullptr;
1797 if (Invert.has_value())
1798 for (User *U : I->users()) {
1799 if ((PN = dyn_cast<PHINode>(Val: U))) {
1800 PassThru = Builder.CreateBitCast(
1801 V: PeekThroughBitcasts(PN->getIncomingValueForBlock(BB)),
1802 DestTy: FixedVectorType::get(ElementType: Ty, NumElts: 1));
1803 } else if (auto *Ins = cast<Instruction>(Val: U);
1804 Sel && Ins->getParent() == BB) {
1805 // This happens when store or/and a speculative instruction between
1806 // load and store were hoisted to the BB. Make sure the masked load
1807 // inserted before its use.
1808 // We assume there's one of such use.
1809 Builder.SetInsertPoint(Ins);
1810 }
1811 }
1812 MaskedLoadStore = Builder.CreateMaskedLoad(
1813 Ty: FixedVectorType::get(ElementType: Ty, NumElts: 1), Ptr: Op0, Alignment: LI->getAlign(), Mask, PassThru);
1814 if (const MDNode *Ranges = I->getMetadata(KindID: LLVMContext::MD_range)) {
1815 ConstantRange CR = getConstantRangeFromMetadata(RangeMD: *Ranges);
1816 if (PassThru && !isa<PoisonValue>(Val: PassThru)) {
1817 auto *C = dyn_cast<Constant>(Val: PassThru);
1818 CR = C ? CR.unionWith(CR: C->toConstantRange())
1819 : ConstantRange::getFull(BitWidth: CR.getBitWidth());
1820 }
1821 MaskedLoadStore->addRangeRetAttr(CR);
1822 }
1823 Value *NewLoadStore = Builder.CreateBitCast(V: MaskedLoadStore, DestTy: Ty);
1824 if (PN)
1825 PN->setIncomingValue(i: PN->getBasicBlockIndex(BB), V: NewLoadStore);
1826 I->replaceAllUsesWith(V: NewLoadStore);
1827 } else {
1828 // Handle Store.
1829 auto *StoredVal = Builder.CreateBitCast(
1830 V: PeekThroughBitcasts(Op0), DestTy: FixedVectorType::get(ElementType: Op0->getType(), NumElts: 1));
1831 MaskedLoadStore = Builder.CreateMaskedStore(
1832 Val: StoredVal, Ptr: I->getOperand(i: 1), Alignment: cast<StoreInst>(Val: I)->getAlign(), Mask);
1833 }
1834 // For non-debug metadata, only !annotation, !range, !nonnull and !align are
1835 // kept when hoisting (see Instruction::dropUBImplyingAttrsAndMetadata).
1836 //
1837 // !nonnull, !align : Not support pointer type, no need to keep.
1838 // !range: Kept as a return attribute, widened over PassThru (see above).
1839 // !annotation: Not impact semantics. Keep it.
1840 I->dropUBImplyingAttrsAndUnknownMetadata(KnownIDs: {LLVMContext::MD_annotation});
1841 // FIXME: DIAssignID is not supported for masked store yet.
1842 // (Verifier::visitDIAssignIDMetadata)
1843 at::deleteAssignmentMarkers(Inst: I);
1844 I->eraseMetadataIf(Pred: [](unsigned MDKind, MDNode *Node) {
1845 return Node->getMetadataID() == Metadata::DIAssignIDKind;
1846 });
1847 MaskedLoadStore->copyMetadata(SrcInst: *I);
1848 I->eraseFromParent();
1849 }
1850}
1851
1852static bool isSafeCheapLoadStore(const Instruction *I,
1853 const TargetTransformInfo &TTI) {
1854 // Not handle volatile or atomic.
1855 bool IsStore = false;
1856 if (auto *L = dyn_cast<LoadInst>(Val: I)) {
1857 if (!L->isSimple() || !HoistLoadsWithCondFaulting)
1858 return false;
1859 } else if (auto *S = dyn_cast<StoreInst>(Val: I)) {
1860 if (!S->isSimple() || !HoistStoresWithCondFaulting)
1861 return false;
1862 IsStore = true;
1863 } else
1864 return false;
1865
1866 // llvm.masked.load/store use i32 for alignment while load/store use i64.
1867 // That's why we have the alignment limitation.
1868 // FIXME: Update the prototype of the intrinsics?
1869 return TTI.hasConditionalLoadStoreForType(Ty: getLoadStoreType(I), IsStore) &&
1870 getLoadStoreAlignment(I) < Value::MaximumAlignment;
1871}
1872
1873/// Hoist any common code in the successor blocks up into the block. This
1874/// function guarantees that BB dominates all successors. If AllInstsEqOnly is
1875/// given, only perform hoisting in case all successors blocks contain matching
1876/// instructions only. In that case, all instructions can be hoisted and the
1877/// original branch will be replaced and selects for PHIs are added.
1878bool SimplifyCFGOpt::hoistCommonCodeFromSuccessors(Instruction *TI,
1879 bool AllInstsEqOnly) {
1880 // This does very trivial matching, with limited scanning, to find identical
1881 // instructions in the two blocks. In particular, we don't want to get into
1882 // O(N1*N2*...) situations here where Ni are the sizes of these successors. As
1883 // such, we currently just scan for obviously identical instructions in an
1884 // identical order, possibly separated by the same number of non-identical
1885 // instructions.
1886 BasicBlock *BB = TI->getParent();
1887 unsigned int SuccSize = succ_size(BB);
1888 if (SuccSize < 2)
1889 return false;
1890
1891 // If either of the blocks has it's address taken, then we can't do this fold,
1892 // because the code we'd hoist would no longer run when we jump into the block
1893 // by it's address.
1894 SmallSetVector<BasicBlock *, 4> UniqueSuccessors(from_range, successors(BB));
1895 for (auto *Succ : UniqueSuccessors) {
1896 if (Succ->hasAddressTaken())
1897 return false;
1898 // Use getUniquePredecessor instead of getSinglePredecessor to support
1899 // multi-cases successors in switch.
1900 if (Succ->getUniquePredecessor())
1901 continue;
1902 // If Succ has >1 predecessors, continue to check if the Succ contains only
1903 // one `unreachable` inst. Since executing `unreachable` inst is an UB, we
1904 // can relax the condition based on the assumptiom that the program would
1905 // never enter Succ and trigger such an UB.
1906 if (isa<UnreachableInst>(Val: *Succ->begin()))
1907 continue;
1908 return false;
1909 }
1910 // The second of pair is a SkipFlags bitmask.
1911 using SuccIterPair = std::pair<BasicBlock::iterator, unsigned>;
1912 SmallVector<SuccIterPair, 8> SuccIterPairs;
1913 for (auto *Succ : UniqueSuccessors) {
1914 BasicBlock::iterator SuccItr = Succ->begin();
1915 if (isa<PHINode>(Val: *SuccItr))
1916 return false;
1917 SuccIterPairs.push_back(Elt: SuccIterPair(SuccItr, 0));
1918 }
1919
1920 if (AllInstsEqOnly) {
1921 // Check if all instructions in the successor blocks match. This allows
1922 // hoisting all instructions and removing the blocks we are hoisting from,
1923 // so does not add any new instructions.
1924
1925 // Check if sizes and terminators of all successors match.
1926 unsigned Size0 = UniqueSuccessors[0]->size();
1927 Instruction *Term0 = UniqueSuccessors[0]->getTerminator();
1928 bool AllSame =
1929 all_of(Range: drop_begin(RangeOrContainer&: UniqueSuccessors), P: [Term0, Size0](BasicBlock *Succ) {
1930 return Succ->getTerminator()->isIdenticalTo(I: Term0) &&
1931 Succ->size() == Size0;
1932 });
1933 if (!AllSame)
1934 return false;
1935 LockstepReverseIterator<true> LRI(UniqueSuccessors.getArrayRef());
1936 while (LRI.isValid()) {
1937 Instruction *I0 = (*LRI)[0];
1938 if (any_of(Range: *LRI, P: [I0](Instruction *I) {
1939 return !areIdenticalUpToCommutativity(I1: I0, I2: I);
1940 })) {
1941 return false;
1942 }
1943 --LRI;
1944 }
1945 // Now we know that all instructions in all successors can be hoisted. Let
1946 // the loop below handle the hoisting.
1947 }
1948
1949 // Count how many instructions were not hoisted so far. There's a limit on how
1950 // many instructions we skip, serving as a compilation time control as well as
1951 // preventing excessive increase of life ranges.
1952 unsigned NumSkipped = 0;
1953 // If we find an unreachable instruction at the beginning of a basic block, we
1954 // can still hoist instructions from the rest of the basic blocks.
1955 if (SuccIterPairs.size() > 2) {
1956 erase_if(C&: SuccIterPairs,
1957 P: [](const auto &Pair) { return isa<UnreachableInst>(Pair.first); });
1958 if (SuccIterPairs.size() < 2)
1959 return false;
1960 }
1961
1962 bool Changed = false;
1963
1964 for (;;) {
1965 auto *SuccIterPairBegin = SuccIterPairs.begin();
1966 auto &BB1ItrPair = *SuccIterPairBegin++;
1967 auto OtherSuccIterPairRange =
1968 iterator_range(SuccIterPairBegin, SuccIterPairs.end());
1969 auto OtherSuccIterRange = make_first_range(c&: OtherSuccIterPairRange);
1970
1971 Instruction *I1 = &*BB1ItrPair.first;
1972
1973 bool AllInstsAreIdentical = true;
1974 bool HasTerminator = I1->isTerminator();
1975 for (auto &SuccIter : OtherSuccIterRange) {
1976 Instruction *I2 = &*SuccIter;
1977 HasTerminator |= I2->isTerminator();
1978 if (AllInstsAreIdentical && (!areIdenticalUpToCommutativity(I1, I2) ||
1979 MMRAMetadata(*I1) != MMRAMetadata(*I2)))
1980 AllInstsAreIdentical = false;
1981 }
1982
1983 SmallVector<Instruction *, 8> OtherInsts;
1984 for (auto &SuccIter : OtherSuccIterRange)
1985 OtherInsts.push_back(Elt: &*SuccIter);
1986
1987 // If we are hoisting the terminator instruction, don't move one (making a
1988 // broken BB), instead clone it, and remove BI.
1989 if (HasTerminator) {
1990 // Even if BB, which contains only one unreachable instruction, is ignored
1991 // at the beginning of the loop, we can hoist the terminator instruction.
1992 // If any instructions remain in the block, we cannot hoist terminators.
1993 if (NumSkipped || !AllInstsAreIdentical) {
1994 hoistLockstepIdenticalDbgVariableRecords(TI, I1, OtherInsts);
1995 return Changed;
1996 }
1997
1998 return hoistSuccIdenticalTerminatorToSwitchOrIf(
1999 TI, I1, OtherSuccTIs&: OtherInsts, UniqueSuccessors: UniqueSuccessors.getArrayRef()) ||
2000 Changed;
2001 }
2002
2003 if (AllInstsAreIdentical) {
2004 unsigned SkipFlagsBB1 = BB1ItrPair.second;
2005 AllInstsAreIdentical =
2006 isSafeToHoistInstr(I: I1, Flags: SkipFlagsBB1) &&
2007 all_of(Range&: OtherSuccIterPairRange, P: [=](const auto &Pair) {
2008 Instruction *I2 = &*Pair.first;
2009 unsigned SkipFlagsBB2 = Pair.second;
2010 // Even if the instructions are identical, it may not
2011 // be safe to hoist them if we have skipped over
2012 // instructions with side effects or their operands
2013 // weren't hoisted.
2014 return isSafeToHoistInstr(I: I2, Flags: SkipFlagsBB2) &&
2015 shouldHoistCommonInstructions(I1, I2, TTI);
2016 });
2017 }
2018
2019 // A musttail call must be immediately followed by a ret, so hoisting is
2020 // only legal if its ret is hoisted with it on the next iteration. That is,
2021 // no instruction has been skipped (the entire successor can be hoisted into
2022 // the predecessor) and the call is directly followed by a ret.
2023 if (auto *CI = dyn_cast<CallInst>(Val: I1);
2024 AllInstsAreIdentical && CI && CI->isMustTailCall()) {
2025 AllInstsAreIdentical =
2026 NumSkipped == 0 && all_of(Range&: SuccIterPairs, P: [](const SuccIterPair &P) {
2027 return isa<ReturnInst>(Val: *std::next(x: P.first));
2028 });
2029 }
2030
2031 if (AllInstsAreIdentical) {
2032 BB1ItrPair.first++;
2033 // For a normal instruction, we just move one to right before the
2034 // branch, then replace all uses of the other with the first. Finally,
2035 // we remove the now redundant second instruction.
2036 hoistLockstepIdenticalDbgVariableRecords(TI, I1, OtherInsts);
2037 // We've just hoisted DbgVariableRecords; move I1 after them (before TI)
2038 // and leave any that were not hoisted behind (by calling moveBefore
2039 // rather than moveBeforePreserving).
2040 I1->moveBefore(InsertPos: TI->getIterator());
2041 for (auto &SuccIter : OtherSuccIterRange) {
2042 Instruction *I2 = &*SuccIter++;
2043 assert(I2 != I1);
2044 if (!I2->use_empty())
2045 I2->replaceAllUsesWith(V: I1);
2046 I1->andIRFlags(V: I2);
2047 if (auto *CB = dyn_cast<CallBase>(Val: I1)) {
2048 bool Success = CB->tryIntersectAttributes(Other: cast<CallBase>(Val: I2));
2049 assert(Success && "We should not be trying to hoist callbases "
2050 "with non-intersectable attributes");
2051 // For NDEBUG Compile.
2052 (void)Success;
2053 }
2054
2055 combineMetadataForCSE(K: I1, J: I2, DoesKMove: true);
2056 // I1 and I2 are being combined into a single instruction. Its debug
2057 // location is the merged locations of the original instructions.
2058 I1->applyMergedLocation(LocA: I1->getDebugLoc(), LocB: I2->getDebugLoc());
2059 I2->eraseFromParent();
2060 }
2061 // I1 now executes before the instructions we skipped.
2062 unsigned SkippedFlags = 0;
2063 for (const SuccIterPair &P : SuccIterPairs)
2064 SkippedFlags |= P.second;
2065 if (SkippedFlags & SkipImplicitControlFlow) {
2066 // One of them may throw or not return, so I1 is speculated.
2067 I1->dropUBImplyingAttrsAndMetadata();
2068 }
2069 if (!Changed)
2070 NumHoistCommonCode += SuccIterPairs.size();
2071 Changed = true;
2072 NumHoistCommonInstrs += SuccIterPairs.size();
2073 } else {
2074 if (NumSkipped >= HoistCommonSkipLimit) {
2075 hoistLockstepIdenticalDbgVariableRecords(TI, I1, OtherInsts);
2076 return Changed;
2077 }
2078 // We are about to skip over a pair of non-identical instructions. Record
2079 // if any have characteristics that would prevent reordering instructions
2080 // across them.
2081 for (auto &SuccIterPair : SuccIterPairs) {
2082 Instruction *I = &*SuccIterPair.first++;
2083 SuccIterPair.second |= skippedInstrFlags(I);
2084 }
2085 ++NumSkipped;
2086 }
2087 }
2088}
2089
2090bool SimplifyCFGOpt::hoistSuccIdenticalTerminatorToSwitchOrIf(
2091 Instruction *TI, Instruction *I1,
2092 SmallVectorImpl<Instruction *> &OtherSuccTIs,
2093 ArrayRef<BasicBlock *> UniqueSuccessors) {
2094
2095 auto *BI = dyn_cast<CondBrInst>(Val: TI);
2096
2097 bool Changed = false;
2098 BasicBlock *TIParent = TI->getParent();
2099 BasicBlock *BB1 = I1->getParent();
2100
2101 // Use only for an if statement.
2102 auto *I2 = *OtherSuccTIs.begin();
2103 auto *BB2 = I2->getParent();
2104 if (BI) {
2105 assert(OtherSuccTIs.size() == 1);
2106 assert(BI->getSuccessor(0) == I1->getParent());
2107 assert(BI->getSuccessor(1) == I2->getParent());
2108 }
2109
2110 // In the case of an if statement, we try to hoist an invoke.
2111 // FIXME: Can we define a safety predicate for CallBr?
2112 // FIXME: Test case llvm/test/Transforms/SimplifyCFG/2009-06-15-InvokeCrash.ll
2113 // removed in 4c923b3b3fd0ac1edebf0603265ca3ba51724937 commit?
2114 if (isa<InvokeInst>(Val: I1) && (!BI || !isSafeToHoistInvoke(BB1, BB2, I1, I2)))
2115 return false;
2116
2117 // TODO: callbr hoisting currently disabled pending further study.
2118 if (isa<CallBrInst>(Val: I1))
2119 return false;
2120
2121 for (BasicBlock *Succ : successors(BB: BB1)) {
2122 for (PHINode &PN : Succ->phis()) {
2123 Value *BB1V = PN.getIncomingValueForBlock(BB: BB1);
2124 for (Instruction *OtherSuccTI : OtherSuccTIs) {
2125 Value *BB2V = PN.getIncomingValueForBlock(BB: OtherSuccTI->getParent());
2126 if (BB1V == BB2V)
2127 continue;
2128
2129 // In the case of an if statement, check for
2130 // passingValueIsAlwaysUndefined here because we would rather eliminate
2131 // undefined control flow then converting it to a select.
2132 if (!BI || passingValueIsAlwaysUndefined(V: BB1V, I: &PN) ||
2133 passingValueIsAlwaysUndefined(V: BB2V, I: &PN))
2134 return false;
2135 }
2136 }
2137 }
2138
2139 // Hoist DbgVariableRecords attached to the terminator to match dbg.*
2140 // intrinsic hoisting behaviour in hoistCommonCodeFromSuccessors.
2141 hoistLockstepIdenticalDbgVariableRecords(TI, I1, OtherInsts&: OtherSuccTIs);
2142 // Clone the terminator and hoist it into the pred, without any debug info.
2143 Instruction *NT = I1->clone();
2144 NT->insertInto(ParentBB: TIParent, It: TI->getIterator());
2145 if (!NT->getType()->isVoidTy()) {
2146 I1->replaceAllUsesWith(V: NT);
2147 for (Instruction *OtherSuccTI : OtherSuccTIs)
2148 OtherSuccTI->replaceAllUsesWith(V: NT);
2149 NT->takeName(V: I1);
2150 }
2151 Changed = true;
2152 NumHoistCommonInstrs += OtherSuccTIs.size() + 1;
2153
2154 // Ensure terminator gets a debug location, even an unknown one, in case
2155 // it involves inlinable calls.
2156 SmallVector<DebugLoc, 4> Locs;
2157 Locs.push_back(Elt: I1->getDebugLoc());
2158 for (auto *OtherSuccTI : OtherSuccTIs)
2159 Locs.push_back(Elt: OtherSuccTI->getDebugLoc());
2160 NT->setDebugLoc(DebugLoc::getMergedLocations(Locs));
2161
2162 // PHIs created below will adopt NT's merged DebugLoc.
2163 IRBuilder<NoFolder> Builder(NT);
2164
2165 // In the case of an if statement, hoisting one of the terminators from our
2166 // successor is a great thing. Unfortunately, the successors of the if/else
2167 // blocks may have PHI nodes in them. If they do, all PHI entries for BB1/BB2
2168 // must agree for all PHI nodes, so we insert select instruction to compute
2169 // the final result.
2170 if (BI) {
2171 std::map<std::pair<Value *, Value *>, SelectInst *> InsertedSelects;
2172 for (BasicBlock *Succ : successors(BB: BB1)) {
2173 for (PHINode &PN : Succ->phis()) {
2174 Value *BB1V = PN.getIncomingValueForBlock(BB: BB1);
2175 Value *BB2V = PN.getIncomingValueForBlock(BB: BB2);
2176 if (BB1V == BB2V)
2177 continue;
2178
2179 // These values do not agree. Insert a select instruction before NT
2180 // that determines the right value.
2181 SelectInst *&SI = InsertedSelects[std::make_pair(x&: BB1V, y&: BB2V)];
2182 if (!SI) {
2183 // Propagate fast-math-flags from phi node to its replacement select.
2184 SI = cast<SelectInst>(Val: Builder.CreateSelectFMF(
2185 C: BI->getCondition(), True: BB1V, False: BB2V,
2186 FMFSource: isa<FPMathOperator>(Val: PN) ? &PN : nullptr,
2187 Name: BB1V->getName() + "." + BB2V->getName(), MDFrom: BI));
2188 }
2189
2190 // Make the PHI node use the select for all incoming values for BB1/BB2
2191 for (unsigned i = 0, e = PN.getNumIncomingValues(); i != e; ++i)
2192 if (PN.getIncomingBlock(i) == BB1 || PN.getIncomingBlock(i) == BB2)
2193 PN.setIncomingValue(i, V: SI);
2194 }
2195 }
2196 }
2197
2198 SmallVector<DominatorTree::UpdateType, 4> Updates;
2199
2200 // Update any PHI nodes in our new successors.
2201 SmallPtrSet<BasicBlock *, 8> VisitedSuccs;
2202 for (BasicBlock *Succ : successors(BB: BB1)) {
2203 addPredecessorToBlock(Succ, NewPred: TIParent, ExistPred: BB1);
2204
2205 if (DTU && VisitedSuccs.insert(Ptr: Succ).second)
2206 Updates.push_back(Elt: {DominatorTree::Insert, TIParent, Succ});
2207 }
2208
2209 if (DTU) {
2210 // TI might be a switch with multi-cases destination, so we need to care for
2211 // the duplication of successors.
2212 for (BasicBlock *Succ : UniqueSuccessors)
2213 Updates.push_back(Elt: {DominatorTree::Delete, TIParent, Succ});
2214 }
2215
2216 eraseTerminatorAndDCECond(TI);
2217 if (DTU)
2218 DTU->applyUpdates(Updates);
2219 return Changed;
2220}
2221
2222// TODO: Refine this. This should avoid cases like turning constant memcpy sizes
2223// into variables.
2224static bool replacingOperandWithVariableIsCheap(const Instruction *I,
2225 int OpIdx) {
2226 // Divide/Remainder by constant is typically much cheaper than by variable.
2227 if (I->isIntDivRem())
2228 return OpIdx != 1;
2229 return !isa<IntrinsicInst>(Val: I);
2230}
2231
2232// All instructions in Insts belong to different blocks that all unconditionally
2233// branch to a common successor. Analyze each instruction and return true if it
2234// would be possible to sink them into their successor, creating one common
2235// instruction instead. For every value that would be required to be provided by
2236// PHI node (because an operand varies in each input block), add to PHIOperands.
2237static bool canSinkInstructions(
2238 ArrayRef<Instruction *> Insts,
2239 DenseMap<const Use *, SmallVector<Value *, 4>> &PHIOperands) {
2240 // Prune out obviously bad instructions to move. Each instruction must have
2241 // the same number of uses, and we check later that the uses are consistent.
2242 std::optional<unsigned> NumUses;
2243 for (auto *I : Insts) {
2244 // These instructions may change or break semantics if moved.
2245 if (isa<PHINode>(Val: I) || I->isEHPad() || isa<AllocaInst>(Val: I) ||
2246 I->getType()->isTokenTy())
2247 return false;
2248
2249 // Do not try to sink an instruction in an infinite loop - it can cause
2250 // this algorithm to infinite loop.
2251 if (I->getParent()->getSingleSuccessor() == I->getParent())
2252 return false;
2253
2254 // Conservatively return false if I is an inline-asm instruction. Sinking
2255 // and merging inline-asm instructions can potentially create arguments
2256 // that cannot satisfy the inline-asm constraints.
2257 // If the instruction has nomerge or convergent attribute, return false.
2258 if (const auto *C = dyn_cast<CallBase>(Val: I))
2259 if (C->isInlineAsm() || C->cannotMerge() || C->isConvergent())
2260 return false;
2261
2262 if (!NumUses)
2263 NumUses = I->getNumUses();
2264 else if (NumUses != I->getNumUses())
2265 return false;
2266 }
2267
2268 const Instruction *I0 = Insts.front();
2269 const auto I0MMRA = MMRAMetadata(*I0);
2270 for (auto *I : Insts) {
2271 if (!I->isSameOperationAs(I: I0, flags: Instruction::CompareUsingIntersectedAttrs))
2272 return false;
2273
2274 // Treat MMRAs conservatively. This pass can be quite aggressive and
2275 // could drop a lot of MMRAs otherwise.
2276 if (MMRAMetadata(*I) != I0MMRA)
2277 return false;
2278 }
2279
2280 // Uses must be consistent: If I0 is used in a phi node in the sink target,
2281 // then the other phi operands must match the instructions from Insts. This
2282 // also has to hold true for any phi nodes that would be created as a result
2283 // of sinking. Both of these cases are represented by PhiOperands.
2284 for (const Use &U : I0->uses()) {
2285 auto It = PHIOperands.find(Val: &U);
2286 if (It == PHIOperands.end())
2287 // There may be uses in other blocks when sinking into a loop header.
2288 return false;
2289 if (!equal(LRange&: Insts, RRange&: It->second))
2290 return false;
2291 }
2292
2293 // For calls to be sinkable, they must all be indirect, or have same callee.
2294 // I.e. if we have two direct calls to different callees, we don't want to
2295 // turn that into an indirect call. Likewise, if we have an indirect call,
2296 // and a direct call, we don't actually want to have a single indirect call.
2297 if (isa<CallBase>(Val: I0)) {
2298 auto IsIndirectCall = [](const Instruction *I) {
2299 return cast<CallBase>(Val: I)->isIndirectCall();
2300 };
2301 bool HaveIndirectCalls = any_of(Range&: Insts, P: IsIndirectCall);
2302 bool AllCallsAreIndirect = all_of(Range&: Insts, P: IsIndirectCall);
2303 if (HaveIndirectCalls) {
2304 if (!AllCallsAreIndirect)
2305 return false;
2306 } else {
2307 // All callees must be identical.
2308 Value *Callee = nullptr;
2309 for (const Instruction *I : Insts) {
2310 Value *CurrCallee = cast<CallBase>(Val: I)->getCalledOperand();
2311 if (!Callee)
2312 Callee = CurrCallee;
2313 else if (Callee != CurrCallee)
2314 return false;
2315 }
2316 }
2317 }
2318
2319 for (unsigned OI = 0, OE = I0->getNumOperands(); OI != OE; ++OI) {
2320 Value *Op = I0->getOperand(i: OI);
2321 auto SameAsI0 = [&I0, OI](const Instruction *I) {
2322 assert(I->getNumOperands() == I0->getNumOperands());
2323 return I->getOperand(i: OI) == I0->getOperand(i: OI);
2324 };
2325 if (!all_of(Range&: Insts, P: SameAsI0)) {
2326 auto CanReplaceOperand = [OI](const Instruction *I) {
2327 return canReplaceOperandWithVariable(I, OpIdx: OI);
2328 };
2329 if ((isa<Constant>(Val: Op) && !replacingOperandWithVariableIsCheap(I: I0, OpIdx: OI)) ||
2330 !all_of(Range&: Insts, P: CanReplaceOperand))
2331 // We can't create a PHI from this operand.
2332 return false;
2333 auto &Ops = PHIOperands[&I0->getOperandUse(i: OI)];
2334 for (auto *I : Insts)
2335 Ops.push_back(Elt: I->getOperand(i: OI));
2336 }
2337 }
2338 return true;
2339}
2340
2341// Assuming canSinkInstructions(Blocks) has returned true, sink the last
2342// instruction of every block in Blocks to their common successor, commoning
2343// into one instruction.
2344static void sinkLastInstruction(ArrayRef<BasicBlock*> Blocks) {
2345 auto *BBEnd = Blocks[0]->getTerminator()->getSuccessor(Idx: 0);
2346
2347 // canSinkInstructions returning true guarantees that every block has at
2348 // least one non-terminator instruction.
2349 SmallVector<Instruction*,4> Insts;
2350 for (auto *BB : Blocks) {
2351 Instruction *I = BB->getTerminator();
2352 I = I->getPrevNode();
2353 Insts.push_back(Elt: I);
2354 }
2355
2356 // We don't need to do any more checking here; canSinkInstructions should
2357 // have done it all for us.
2358 SmallVector<Value*, 4> NewOperands;
2359 Instruction *I0 = Insts.front();
2360 for (unsigned O = 0, E = I0->getNumOperands(); O != E; ++O) {
2361 // This check is different to that in canSinkInstructions. There, we
2362 // cared about the global view once simplifycfg (and instcombine) have
2363 // completed - it takes into account PHIs that become trivially
2364 // simplifiable. However here we need a more local view; if an operand
2365 // differs we create a PHI and rely on instcombine to clean up the very
2366 // small mess we may make.
2367 bool NeedPHI = any_of(Range&: Insts, P: [&I0, O](const Instruction *I) {
2368 return I->getOperand(i: O) != I0->getOperand(i: O);
2369 });
2370 if (!NeedPHI) {
2371 NewOperands.push_back(Elt: I0->getOperand(i: O));
2372 continue;
2373 }
2374
2375 // Create a new PHI in the successor block and populate it.
2376 auto *Op = I0->getOperand(i: O);
2377 assert(!Op->getType()->isTokenTy() && "Can't PHI tokens!");
2378 auto *PN =
2379 PHINode::Create(Ty: Op->getType(), NumReservedValues: Insts.size(), NameStr: Op->getName() + ".sink");
2380 PN->insertBefore(InsertPos: BBEnd->begin());
2381 for (auto *I : Insts)
2382 PN->addIncoming(V: I->getOperand(i: O), BB: I->getParent());
2383 NewOperands.push_back(Elt: PN);
2384 }
2385
2386 // Arbitrarily use I0 as the new "common" instruction; remap its operands
2387 // and move it to the start of the successor block.
2388 for (unsigned O = 0, E = I0->getNumOperands(); O != E; ++O)
2389 I0->getOperandUse(i: O).set(NewOperands[O]);
2390
2391 I0->moveBefore(BB&: *BBEnd, I: BBEnd->getFirstInsertionPt());
2392
2393 // Update metadata and IR flags, and merge debug locations.
2394 for (auto *I : Insts)
2395 if (I != I0) {
2396 // The debug location for the "common" instruction is the merged locations
2397 // of all the commoned instructions. We start with the original location
2398 // of the "common" instruction and iteratively merge each location in the
2399 // loop below.
2400 // This is an N-way merge, which will be inefficient if I0 is a CallInst.
2401 // However, as N-way merge for CallInst is rare, so we use simplified API
2402 // instead of using complex API for N-way merge.
2403 I0->applyMergedLocation(LocA: I0->getDebugLoc(), LocB: I->getDebugLoc());
2404 combineMetadataForCSE(K: I0, J: I, DoesKMove: true);
2405 I0->andIRFlags(V: I);
2406 if (auto *CB = dyn_cast<CallBase>(Val: I0)) {
2407 bool Success = CB->tryIntersectAttributes(Other: cast<CallBase>(Val: I));
2408 assert(Success && "We should not be trying to sink callbases "
2409 "with non-intersectable attributes");
2410 // For NDEBUG Compile.
2411 (void)Success;
2412 }
2413 }
2414
2415 for (User *U : make_early_inc_range(Range: I0->users())) {
2416 // canSinkLastInstruction checked that all instructions are only used by
2417 // phi nodes in a way that allows replacing the phi node with the common
2418 // instruction.
2419 auto *PN = cast<PHINode>(Val: U);
2420 PN->replaceAllUsesWith(V: I0);
2421 PN->eraseFromParent();
2422 }
2423
2424 // Finally nuke all instructions apart from the common instruction.
2425 for (auto *I : Insts) {
2426 if (I == I0)
2427 continue;
2428 // The remaining uses are debug users, replace those with the common inst.
2429 // In most (all?) cases this just introduces a use-before-def.
2430 assert(I->user_empty() && "Inst unexpectedly still has non-dbg users");
2431 I->replaceAllUsesWith(V: I0);
2432 I->eraseFromParent();
2433 }
2434}
2435
2436/// Check whether BB's predecessors end with unconditional branches. If it is
2437/// true, sink any common code from the predecessors to BB.
2438static bool sinkCommonCodeFromPredecessors(BasicBlock *BB,
2439 DomTreeUpdater *DTU) {
2440 // We support two situations:
2441 // (1) all incoming arcs are unconditional
2442 // (2) there are non-unconditional incoming arcs
2443 //
2444 // (2) is very common in switch defaults and
2445 // else-if patterns;
2446 //
2447 // if (a) f(1);
2448 // else if (b) f(2);
2449 //
2450 // produces:
2451 //
2452 // [if]
2453 // / \
2454 // [f(1)] [if]
2455 // | | \
2456 // | | |
2457 // | [f(2)]|
2458 // \ | /
2459 // [ end ]
2460 //
2461 // [end] has two unconditional predecessor arcs and one conditional. The
2462 // conditional refers to the implicit empty 'else' arc. This conditional
2463 // arc can also be caused by an empty default block in a switch.
2464 //
2465 // In this case, we attempt to sink code from all *unconditional* arcs.
2466 // If we can sink instructions from these arcs (determined during the scan
2467 // phase below) we insert a common successor for all unconditional arcs and
2468 // connect that to [end], to enable sinking:
2469 //
2470 // [if]
2471 // / \
2472 // [x(1)] [if]
2473 // | | \
2474 // | | \
2475 // | [x(2)] |
2476 // \ / |
2477 // [sink.split] |
2478 // \ /
2479 // [ end ]
2480 //
2481 SmallVector<BasicBlock*,4> UnconditionalPreds;
2482 bool HaveNonUnconditionalPredecessors = false;
2483 for (auto *PredBB : predecessors(BB)) {
2484 auto *PredBr = dyn_cast<UncondBrInst>(Val: PredBB->getTerminator());
2485 if (PredBr)
2486 UnconditionalPreds.push_back(Elt: PredBB);
2487 else
2488 HaveNonUnconditionalPredecessors = true;
2489 }
2490 if (UnconditionalPreds.size() < 2)
2491 return false;
2492
2493 // We take a two-step approach to tail sinking. First we scan from the end of
2494 // each block upwards in lockstep. If the n'th instruction from the end of each
2495 // block can be sunk, those instructions are added to ValuesToSink and we
2496 // carry on. If we can sink an instruction but need to PHI-merge some operands
2497 // (because they're not identical in each instruction) we add these to
2498 // PHIOperands.
2499 // We prepopulate PHIOperands with the phis that already exist in BB.
2500 DenseMap<const Use *, SmallVector<Value *, 4>> PHIOperands;
2501 for (PHINode &PN : BB->phis()) {
2502 SmallDenseMap<BasicBlock *, const Use *, 4> IncomingVals;
2503 for (const Use &U : PN.incoming_values())
2504 IncomingVals.insert(KV: {PN.getIncomingBlock(U), &U});
2505 auto &Ops = PHIOperands[IncomingVals[UnconditionalPreds[0]]];
2506 for (BasicBlock *Pred : UnconditionalPreds)
2507 Ops.push_back(Elt: *IncomingVals[Pred]);
2508 }
2509
2510 int ScanIdx = 0;
2511 SmallPtrSet<Value*,4> InstructionsToSink;
2512 LockstepReverseIterator<true> LRI(UnconditionalPreds);
2513 while (LRI.isValid() &&
2514 canSinkInstructions(Insts: *LRI, PHIOperands)) {
2515 LLVM_DEBUG(dbgs() << "SINK: instruction can be sunk: " << *(*LRI)[0]
2516 << "\n");
2517 InstructionsToSink.insert_range(R: *LRI);
2518 ++ScanIdx;
2519 --LRI;
2520 }
2521
2522 // If no instructions can be sunk, early-return.
2523 if (ScanIdx == 0)
2524 return false;
2525
2526 bool followedByDeoptOrUnreachable = IsBlockFollowedByDeoptOrUnreachable(BB);
2527
2528 if (!followedByDeoptOrUnreachable) {
2529 // Check whether this is the pointer operand of a load/store.
2530 auto IsMemOperand = [](Use &U) {
2531 auto *I = cast<Instruction>(Val: U.getUser());
2532 if (isa<LoadInst>(Val: I))
2533 return U.getOperandNo() == LoadInst::getPointerOperandIndex();
2534 if (isa<StoreInst>(Val: I))
2535 return U.getOperandNo() == StoreInst::getPointerOperandIndex();
2536 return false;
2537 };
2538
2539 // Okay, we *could* sink last ScanIdx instructions. But how many can we
2540 // actually sink before encountering instruction that is unprofitable to
2541 // sink?
2542 auto ProfitableToSinkInstruction = [&](LockstepReverseIterator<true> &LRI) {
2543 unsigned NumPHIInsts = 0;
2544 for (Use &U : (*LRI)[0]->operands()) {
2545 auto It = PHIOperands.find(Val: &U);
2546 if (It != PHIOperands.end() && !all_of(Range&: It->second, P: [&](Value *V) {
2547 return InstructionsToSink.contains(Ptr: V);
2548 })) {
2549 ++NumPHIInsts;
2550 // Do not separate a load/store from the gep producing the address.
2551 // The gep can likely be folded into the load/store as an addressing
2552 // mode. Additionally, a load of a gep is easier to analyze than a
2553 // load of a phi.
2554 if (IsMemOperand(U) &&
2555 any_of(Range&: It->second, P: [](Value *V) { return isa<GEPOperator>(Val: V); }))
2556 return false;
2557 // FIXME: this check is overly optimistic. We may end up not sinking
2558 // said instruction, due to the very same profitability check.
2559 // See @creating_too_many_phis in sink-common-code.ll.
2560 }
2561 }
2562 LLVM_DEBUG(dbgs() << "SINK: #phi insts: " << NumPHIInsts << "\n");
2563 return NumPHIInsts <= 1;
2564 };
2565
2566 // We've determined that we are going to sink last ScanIdx instructions,
2567 // and recorded them in InstructionsToSink. Now, some instructions may be
2568 // unprofitable to sink. But that determination depends on the instructions
2569 // that we are going to sink.
2570
2571 // First, forward scan: find the first instruction unprofitable to sink,
2572 // recording all the ones that are profitable to sink.
2573 // FIXME: would it be better, after we detect that not all are profitable.
2574 // to either record the profitable ones, or erase the unprofitable ones?
2575 // Maybe we need to choose (at runtime) the one that will touch least
2576 // instrs?
2577 LRI.reset();
2578 int Idx = 0;
2579 SmallPtrSet<Value *, 4> InstructionsProfitableToSink;
2580 while (Idx < ScanIdx) {
2581 if (!ProfitableToSinkInstruction(LRI)) {
2582 // Too many PHIs would be created.
2583 LLVM_DEBUG(
2584 dbgs() << "SINK: stopping here, too many PHIs would be created!\n");
2585 break;
2586 }
2587 InstructionsProfitableToSink.insert_range(R: *LRI);
2588 --LRI;
2589 ++Idx;
2590 }
2591
2592 // If no instructions can be sunk, early-return.
2593 if (Idx == 0)
2594 return false;
2595
2596 // Did we determine that (only) some instructions are unprofitable to sink?
2597 if (Idx < ScanIdx) {
2598 // Okay, some instructions are unprofitable.
2599 ScanIdx = Idx;
2600 InstructionsToSink = InstructionsProfitableToSink;
2601
2602 // But, that may make other instructions unprofitable, too.
2603 // So, do a backward scan, do any earlier instructions become
2604 // unprofitable?
2605 assert(
2606 !ProfitableToSinkInstruction(LRI) &&
2607 "We already know that the last instruction is unprofitable to sink");
2608 ++LRI;
2609 --Idx;
2610 while (Idx >= 0) {
2611 // If we detect that an instruction becomes unprofitable to sink,
2612 // all earlier instructions won't be sunk either,
2613 // so preemptively keep InstructionsProfitableToSink in sync.
2614 // FIXME: is this the most performant approach?
2615 for (auto *I : *LRI)
2616 InstructionsProfitableToSink.erase(Ptr: I);
2617 if (!ProfitableToSinkInstruction(LRI)) {
2618 // Everything starting with this instruction won't be sunk.
2619 ScanIdx = Idx;
2620 InstructionsToSink = InstructionsProfitableToSink;
2621 }
2622 ++LRI;
2623 --Idx;
2624 }
2625 }
2626
2627 // If no instructions can be sunk, early-return.
2628 if (ScanIdx == 0)
2629 return false;
2630 }
2631
2632 bool Changed = false;
2633
2634 if (HaveNonUnconditionalPredecessors) {
2635 if (!followedByDeoptOrUnreachable) {
2636 // It is always legal to sink common instructions from unconditional
2637 // predecessors. However, if not all predecessors are unconditional,
2638 // this transformation might be pessimizing. So as a rule of thumb,
2639 // don't do it unless we'd sink at least one non-speculatable instruction.
2640 // See https://bugs.llvm.org/show_bug.cgi?id=30244
2641 LRI.reset();
2642 int Idx = 0;
2643 bool Profitable = false;
2644 while (Idx < ScanIdx) {
2645 if (!isSafeToSpeculativelyExecute(I: (*LRI)[0])) {
2646 Profitable = true;
2647 break;
2648 }
2649 --LRI;
2650 ++Idx;
2651 }
2652 if (!Profitable)
2653 return false;
2654 }
2655
2656 LLVM_DEBUG(dbgs() << "SINK: Splitting edge\n");
2657 // We have a conditional edge and we're going to sink some instructions.
2658 // Insert a new block postdominating all blocks we're going to sink from.
2659 if (!SplitBlockPredecessors(BB, Preds: UnconditionalPreds, Suffix: ".sink.split", DTU))
2660 // Edges couldn't be split.
2661 return false;
2662 Changed = true;
2663 }
2664
2665 // Now that we've analyzed all potential sinking candidates, perform the
2666 // actual sink. We iteratively sink the last non-terminator of the source
2667 // blocks into their common successor unless doing so would require too
2668 // many PHI instructions to be generated (currently only one PHI is allowed
2669 // per sunk instruction).
2670 //
2671 // We can use InstructionsToSink to discount values needing PHI-merging that will
2672 // actually be sunk in a later iteration. This allows us to be more
2673 // aggressive in what we sink. This does allow a false positive where we
2674 // sink presuming a later value will also be sunk, but stop half way through
2675 // and never actually sink it which means we produce more PHIs than intended.
2676 // This is unlikely in practice though.
2677 int SinkIdx = 0;
2678 for (; SinkIdx != ScanIdx; ++SinkIdx) {
2679 LLVM_DEBUG(dbgs() << "SINK: Sink: "
2680 << *UnconditionalPreds[0]->getTerminator()->getPrevNode()
2681 << "\n");
2682
2683 // Because we've sunk every instruction in turn, the current instruction to
2684 // sink is always at index 0.
2685 LRI.reset();
2686
2687 sinkLastInstruction(Blocks: UnconditionalPreds);
2688 NumSinkCommonInstrs++;
2689 Changed = true;
2690 }
2691 if (SinkIdx != 0)
2692 ++NumSinkCommonCode;
2693 return Changed;
2694}
2695
2696namespace {
2697
2698struct CompatibleSets {
2699 using SetTy = SmallVector<InvokeInst *, 2>;
2700
2701 SmallVector<SetTy, 1> Sets;
2702
2703 static bool shouldBelongToSameSet(ArrayRef<InvokeInst *> Invokes);
2704
2705 SetTy &getCompatibleSet(InvokeInst *II);
2706
2707 void insert(InvokeInst *II);
2708};
2709
2710CompatibleSets::SetTy &CompatibleSets::getCompatibleSet(InvokeInst *II) {
2711 // Perform a linear scan over all the existing sets, see if the new `invoke`
2712 // is compatible with any particular set. Since we know that all the `invokes`
2713 // within a set are compatible, only check the first `invoke` in each set.
2714 // WARNING: at worst, this has quadratic complexity.
2715 for (CompatibleSets::SetTy &Set : Sets) {
2716 if (CompatibleSets::shouldBelongToSameSet(Invokes: {Set.front(), II}))
2717 return Set;
2718 }
2719
2720 // Otherwise, we either had no sets yet, or this invoke forms a new set.
2721 return Sets.emplace_back();
2722}
2723
2724void CompatibleSets::insert(InvokeInst *II) {
2725 getCompatibleSet(II).emplace_back(Args&: II);
2726}
2727
2728bool CompatibleSets::shouldBelongToSameSet(ArrayRef<InvokeInst *> Invokes) {
2729 assert(Invokes.size() == 2 && "Always called with exactly two candidates.");
2730
2731 // Can we theoretically merge these `invoke`s?
2732 auto IsIllegalToMerge = [](InvokeInst *II) {
2733 return II->cannotMerge() || II->isInlineAsm();
2734 };
2735 if (any_of(Range&: Invokes, P: IsIllegalToMerge))
2736 return false;
2737
2738 // Either both `invoke`s must be direct,
2739 // or both `invoke`s must be indirect.
2740 auto IsIndirectCall = [](InvokeInst *II) { return II->isIndirectCall(); };
2741 bool HaveIndirectCalls = any_of(Range&: Invokes, P: IsIndirectCall);
2742 bool AllCallsAreIndirect = all_of(Range&: Invokes, P: IsIndirectCall);
2743 if (HaveIndirectCalls) {
2744 if (!AllCallsAreIndirect)
2745 return false;
2746 } else {
2747 // All callees must be identical.
2748 Value *Callee = nullptr;
2749 for (InvokeInst *II : Invokes) {
2750 Value *CurrCallee = II->getCalledOperand();
2751 assert(CurrCallee && "There is always a called operand.");
2752 if (!Callee)
2753 Callee = CurrCallee;
2754 else if (Callee != CurrCallee)
2755 return false;
2756 }
2757 }
2758
2759 // Either both `invoke`s must not have a normal destination,
2760 // or both `invoke`s must have a normal destination,
2761 auto HasNormalDest = [](InvokeInst *II) {
2762 return !isa<UnreachableInst>(Val: II->getNormalDest()->getFirstNonPHIOrDbg());
2763 };
2764 if (any_of(Range&: Invokes, P: HasNormalDest)) {
2765 // Do not merge `invoke` that does not have a normal destination with one
2766 // that does have a normal destination, even though doing so would be legal.
2767 if (!all_of(Range&: Invokes, P: HasNormalDest))
2768 return false;
2769
2770 // All normal destinations must be identical.
2771 BasicBlock *NormalBB = nullptr;
2772 for (InvokeInst *II : Invokes) {
2773 BasicBlock *CurrNormalBB = II->getNormalDest();
2774 assert(CurrNormalBB && "There is always a 'continue to' basic block.");
2775 if (!NormalBB)
2776 NormalBB = CurrNormalBB;
2777 else if (NormalBB != CurrNormalBB)
2778 return false;
2779 }
2780
2781 // In the normal destination, the incoming values for these two `invoke`s
2782 // must be compatible.
2783 SmallPtrSet<Value *, 16> EquivalenceSet(llvm::from_range, Invokes);
2784 if (!incomingValuesAreCompatible(
2785 BB: NormalBB, IncomingBlocks: {Invokes[0]->getParent(), Invokes[1]->getParent()},
2786 EquivalenceSet: &EquivalenceSet))
2787 return false;
2788 }
2789
2790#ifndef NDEBUG
2791 // All unwind destinations must be identical.
2792 // We know that because we have started from said unwind destination.
2793 BasicBlock *UnwindBB = nullptr;
2794 for (InvokeInst *II : Invokes) {
2795 BasicBlock *CurrUnwindBB = II->getUnwindDest();
2796 assert(CurrUnwindBB && "There is always an 'unwind to' basic block.");
2797 if (!UnwindBB)
2798 UnwindBB = CurrUnwindBB;
2799 else
2800 assert(UnwindBB == CurrUnwindBB && "Unexpected unwind destination.");
2801 }
2802#endif
2803
2804 // In the unwind destination, the incoming values for these two `invoke`s
2805 // must be compatible.
2806 if (!incomingValuesAreCompatible(
2807 BB: Invokes.front()->getUnwindDest(),
2808 IncomingBlocks: {Invokes[0]->getParent(), Invokes[1]->getParent()}))
2809 return false;
2810
2811 // Ignoring arguments, these `invoke`s must be identical,
2812 // including operand bundles.
2813 const InvokeInst *II0 = Invokes.front();
2814 for (auto *II : Invokes.drop_front())
2815 if (!II->isSameOperationAs(I: II0, flags: Instruction::CompareUsingIntersectedAttrs))
2816 return false;
2817
2818 // Can we theoretically form the data operands for the merged `invoke`?
2819 auto IsIllegalToMergeArguments = [](auto Ops) {
2820 Use &U0 = std::get<0>(Ops);
2821 Use &U1 = std::get<1>(Ops);
2822 if (U0 == U1)
2823 return false;
2824 return !canReplaceOperandWithVariable(I: cast<Instruction>(Val: U0.getUser()),
2825 OpIdx: U0.getOperandNo());
2826 };
2827 assert(Invokes.size() == 2 && "Always called with exactly two candidates.");
2828 if (any_of(Range: zip(t: Invokes[0]->data_ops(), u: Invokes[1]->data_ops()),
2829 P: IsIllegalToMergeArguments))
2830 return false;
2831
2832 return true;
2833}
2834
2835} // namespace
2836
2837// Merge all invokes in the provided set, all of which are compatible
2838// as per the `CompatibleSets::shouldBelongToSameSet()`.
2839static void mergeCompatibleInvokesImpl(ArrayRef<InvokeInst *> Invokes,
2840 DomTreeUpdater *DTU) {
2841 assert(Invokes.size() >= 2 && "Must have at least two invokes to merge.");
2842
2843 SmallVector<DominatorTree::UpdateType, 8> Updates;
2844 if (DTU)
2845 Updates.reserve(N: 2 + 3 * Invokes.size());
2846
2847 bool HasNormalDest =
2848 !isa<UnreachableInst>(Val: Invokes[0]->getNormalDest()->getFirstNonPHIOrDbg());
2849
2850 // Clone one of the invokes into a new basic block.
2851 // Since they are all compatible, it doesn't matter which invoke is cloned.
2852 InvokeInst *MergedInvoke = [&Invokes, HasNormalDest]() {
2853 InvokeInst *II0 = Invokes.front();
2854 BasicBlock *II0BB = II0->getParent();
2855 BasicBlock *InsertBeforeBlock =
2856 II0->getParent()->getIterator()->getNextNode();
2857 Function *Func = II0BB->getParent();
2858 LLVMContext &Ctx = II0->getContext();
2859
2860 BasicBlock *MergedInvokeBB = BasicBlock::Create(
2861 Context&: Ctx, Name: II0BB->getName() + ".invoke", Parent: Func, InsertBefore: InsertBeforeBlock);
2862
2863 auto *MergedInvoke = cast<InvokeInst>(Val: II0->clone());
2864 // NOTE: all invokes have the same attributes, so no handling needed.
2865 MergedInvoke->insertInto(ParentBB: MergedInvokeBB, It: MergedInvokeBB->end());
2866
2867 if (!HasNormalDest) {
2868 // This set does not have a normal destination,
2869 // so just form a new block with unreachable terminator.
2870 BasicBlock *MergedNormalDest = BasicBlock::Create(
2871 Context&: Ctx, Name: II0BB->getName() + ".cont", Parent: Func, InsertBefore: InsertBeforeBlock);
2872 auto *UI = new UnreachableInst(Ctx, MergedNormalDest);
2873 UI->setDebugLoc(DebugLoc::getTemporary());
2874 MergedInvoke->setNormalDest(MergedNormalDest);
2875 }
2876
2877 // The unwind destination, however, remainds identical for all invokes here.
2878
2879 return MergedInvoke;
2880 }();
2881
2882 if (DTU) {
2883 // Predecessor blocks that contained these invokes will now branch to
2884 // the new block that contains the merged invoke, ...
2885 for (InvokeInst *II : Invokes)
2886 Updates.push_back(
2887 Elt: {DominatorTree::Insert, II->getParent(), MergedInvoke->getParent()});
2888
2889 // ... which has the new `unreachable` block as normal destination,
2890 // or unwinds to the (same for all `invoke`s in this set) `landingpad`,
2891 for (BasicBlock *SuccBBOfMergedInvoke : successors(I: MergedInvoke))
2892 Updates.push_back(Elt: {DominatorTree::Insert, MergedInvoke->getParent(),
2893 SuccBBOfMergedInvoke});
2894
2895 // Since predecessor blocks now unconditionally branch to a new block,
2896 // they no longer branch to their original successors.
2897 for (InvokeInst *II : Invokes)
2898 for (BasicBlock *SuccOfPredBB : successors(BB: II->getParent()))
2899 Updates.push_back(
2900 Elt: {DominatorTree::Delete, II->getParent(), SuccOfPredBB});
2901 }
2902
2903 bool IsIndirectCall = Invokes[0]->isIndirectCall();
2904
2905 // Form the merged operands for the merged invoke.
2906 for (Use &U : MergedInvoke->operands()) {
2907 // Only PHI together the indirect callees and data operands.
2908 if (MergedInvoke->isCallee(U: &U)) {
2909 if (!IsIndirectCall)
2910 continue;
2911 } else if (!MergedInvoke->isDataOperand(U: &U))
2912 continue;
2913
2914 // Don't create trivial PHI's with all-identical incoming values.
2915 bool NeedPHI = any_of(Range&: Invokes, P: [&U](InvokeInst *II) {
2916 return II->getOperand(i_nocapture: U.getOperandNo()) != U.get();
2917 });
2918 if (!NeedPHI)
2919 continue;
2920
2921 // Form a PHI out of all the data ops under this index.
2922 PHINode *PN = PHINode::Create(
2923 Ty: U->getType(), /*NumReservedValues=*/Invokes.size(), NameStr: "", InsertBefore: MergedInvoke->getIterator());
2924 for (InvokeInst *II : Invokes)
2925 PN->addIncoming(V: II->getOperand(i_nocapture: U.getOperandNo()), BB: II->getParent());
2926
2927 U.set(PN);
2928 }
2929
2930 // We've ensured that each PHI node has compatible (identical) incoming values
2931 // when coming from each of the `invoke`s in the current merge set,
2932 // so update the PHI nodes accordingly.
2933 for (BasicBlock *Succ : successors(I: MergedInvoke))
2934 addPredecessorToBlock(Succ, /*NewPred=*/MergedInvoke->getParent(),
2935 /*ExistPred=*/Invokes.front()->getParent());
2936
2937 // And finally, replace the original `invoke`s with an unconditional branch
2938 // to the block with the merged `invoke`. Also, give that merged `invoke`
2939 // the merged debugloc of all the original `invoke`s.
2940 DILocation *MergedDebugLoc = nullptr;
2941 for (InvokeInst *II : Invokes) {
2942 // Compute the debug location common to all the original `invoke`s.
2943 if (!MergedDebugLoc)
2944 MergedDebugLoc = II->getDebugLoc();
2945 else
2946 MergedDebugLoc =
2947 DebugLoc::getMergedLocation(LocA: MergedDebugLoc, LocB: II->getDebugLoc());
2948
2949 // And replace the old `invoke` with an unconditionally branch
2950 // to the block with the merged `invoke`.
2951 for (BasicBlock *OrigSuccBB : successors(BB: II->getParent()))
2952 OrigSuccBB->removePredecessor(Pred: II->getParent());
2953 auto *BI = UncondBrInst::Create(Target: MergedInvoke->getParent(), InsertBefore: II->getParent());
2954 // The unconditional branch is part of the replacement for the original
2955 // invoke, so should use its DebugLoc.
2956 BI->setDebugLoc(II->getDebugLoc());
2957 bool Success = MergedInvoke->tryIntersectAttributes(Other: II);
2958 assert(Success && "Merged invokes with incompatible attributes");
2959 // For NDEBUG Compile
2960 (void)Success;
2961 II->replaceAllUsesWith(V: MergedInvoke);
2962 II->eraseFromParent();
2963 ++NumInvokesMerged;
2964 }
2965 MergedInvoke->setDebugLoc(MergedDebugLoc);
2966 ++NumInvokeSetsFormed;
2967
2968 if (DTU)
2969 DTU->applyUpdates(Updates);
2970}
2971
2972/// If this block is a `landingpad` exception handling block, categorize all
2973/// the predecessor `invoke`s into sets, with all `invoke`s in each set
2974/// being "mergeable" together, and then merge invokes in each set together.
2975///
2976/// This is a weird mix of hoisting and sinking. Visually, it goes from:
2977/// [...] [...]
2978/// | |
2979/// [invoke0] [invoke1]
2980/// / \ / \
2981/// [cont0] [landingpad] [cont1]
2982/// to:
2983/// [...] [...]
2984/// \ /
2985/// [invoke]
2986/// / \
2987/// [cont] [landingpad]
2988///
2989/// But of course we can only do that if the invokes share the `landingpad`,
2990/// edges invoke0->cont0 and invoke1->cont1 are "compatible",
2991/// and the invoked functions are "compatible".
2992static bool mergeCompatibleInvokes(BasicBlock *BB, DomTreeUpdater *DTU) {
2993 if (!EnableMergeCompatibleInvokes)
2994 return false;
2995
2996 bool Changed = false;
2997
2998 // FIXME: generalize to all exception handling blocks?
2999 if (!BB->isLandingPad())
3000 return Changed;
3001
3002 CompatibleSets Grouper;
3003
3004 // Record all the predecessors of this `landingpad`. As per verifier,
3005 // the only allowed predecessor is the unwind edge of an `invoke`.
3006 // We want to group "compatible" `invokes` into the same set to be merged.
3007 for (BasicBlock *PredBB : predecessors(BB))
3008 Grouper.insert(II: cast<InvokeInst>(Val: PredBB->getTerminator()));
3009
3010 // And now, merge `invoke`s that were grouped togeter.
3011 for (ArrayRef<InvokeInst *> Invokes : Grouper.Sets) {
3012 if (Invokes.size() < 2)
3013 continue;
3014 Changed = true;
3015 mergeCompatibleInvokesImpl(Invokes, DTU);
3016 }
3017
3018 return Changed;
3019}
3020
3021namespace {
3022/// Track ephemeral values, which should be ignored for cost-modelling
3023/// purposes. Requires walking instructions in reverse order.
3024class EphemeralValueTracker {
3025 SmallPtrSet<const Instruction *, 32> EphValues;
3026
3027 bool isEphemeral(const Instruction *I) {
3028 if (isa<AssumeInst>(Val: I))
3029 return true;
3030 return !I->mayHaveSideEffects() && !I->isTerminator() &&
3031 all_of(Range: I->users(), P: [&](const User *U) {
3032 return EphValues.count(Ptr: cast<Instruction>(Val: U));
3033 });
3034 }
3035
3036public:
3037 bool track(const Instruction *I) {
3038 if (isEphemeral(I)) {
3039 EphValues.insert(Ptr: I);
3040 return true;
3041 }
3042 return false;
3043 }
3044
3045 bool contains(const Instruction *I) const { return EphValues.contains(Ptr: I); }
3046};
3047} // namespace
3048
3049/// Determine if we can hoist sink a sole store instruction out of a
3050/// conditional block.
3051///
3052/// We are looking for code like the following:
3053/// BrBB:
3054/// store i32 %add, i32* %arrayidx2
3055/// ... // No other stores or function calls (we could be calling a memory
3056/// ... // function).
3057/// %cmp = icmp ult %x, %y
3058/// br i1 %cmp, label %EndBB, label %ThenBB
3059/// ThenBB:
3060/// store i32 %add5, i32* %arrayidx2
3061/// br label EndBB
3062/// EndBB:
3063/// ...
3064/// We are going to transform this into:
3065/// BrBB:
3066/// store i32 %add, i32* %arrayidx2
3067/// ... //
3068/// %cmp = icmp ult %x, %y
3069/// %add.add5 = select i1 %cmp, i32 %add, %add5
3070/// store i32 %add.add5, i32* %arrayidx2
3071/// ...
3072///
3073/// \return The value from the previous access if the store can be hoisted into
3074/// the predecessor block. PreviousAccess is set to that access. Return
3075/// null otherwise.
3076static Value *isSafeToSpeculateStore(Instruction *I, BasicBlock *BrBB,
3077 BasicBlock *StoreBB, BasicBlock *EndBB,
3078 Instruction *&PreviousAccess) {
3079 StoreInst *StoreToHoist = dyn_cast<StoreInst>(Val: I);
3080 if (!StoreToHoist)
3081 return nullptr;
3082
3083 // Volatile or atomic.
3084 if (!StoreToHoist->isSimple())
3085 return nullptr;
3086
3087 Value *StorePtr = StoreToHoist->getPointerOperand();
3088 Type *StoreTy = StoreToHoist->getValueOperand()->getType();
3089
3090 // Look for a store to the same pointer in BrBB.
3091 unsigned MaxNumInstToLookAt = 9;
3092 // Skip pseudo probe intrinsic calls which are not really killing any memory
3093 // accesses.
3094 for (Instruction &CurI : reverse(C&: *BrBB)) {
3095 if (!MaxNumInstToLookAt)
3096 break;
3097 --MaxNumInstToLookAt;
3098
3099 if (isa<PseudoProbeInst>(Val: CurI))
3100 continue;
3101
3102 // Could be calling an instruction that affects memory like free().
3103 if (CurI.mayWriteToMemory() && !isa<StoreInst>(Val: CurI))
3104 return nullptr;
3105
3106 if (auto *SI = dyn_cast<StoreInst>(Val: &CurI)) {
3107 // Found the previous store to same location and type. Make sure it is
3108 // simple, to avoid introducing a spurious non-atomic write after an
3109 // atomic write.
3110 if (SI->getPointerOperand() == StorePtr &&
3111 SI->getValueOperand()->getType() == StoreTy && SI->isSimple() &&
3112 SI->getAlign() >= StoreToHoist->getAlign()) {
3113 // Found the previous store, return its value operand.
3114 PreviousAccess = SI;
3115 return SI->getValueOperand();
3116 }
3117 return nullptr; // Unknown store.
3118 }
3119
3120 if (auto *LI = dyn_cast<LoadInst>(Val: &CurI)) {
3121 if (LI->getPointerOperand() == StorePtr && LI->getType() == StoreTy &&
3122 LI->isSimple() && LI->getAlign() >= StoreToHoist->getAlign()) {
3123 Value *Obj = getUnderlyingObject(V: StorePtr);
3124 bool ExplicitlyDereferenceableOnly;
3125 // The dereferenceability query here is only required to satisfy the
3126 // writable contract, actual dereferenceability is proven by the
3127 // presence of an access. As such, we can ignore frees.
3128 if (isWritableObject(Object: Obj, ExplicitlyDereferenceableOnly) &&
3129 capturesNothing(
3130 CC: PointerMayBeCaptured(V: Obj, Mask: CaptureComponents::Provenance)
3131 .WithoutRet) &&
3132 (!ExplicitlyDereferenceableOnly ||
3133 isDereferenceablePointer(V: StorePtr, Ty: StoreTy, Q: LI->getDataLayout(),
3134 /*IgnoreFree=*/true))) {
3135 // Found a previous load, return it.
3136 PreviousAccess = LI;
3137 return LI;
3138 }
3139 }
3140 // The load didn't work out, but we may still find a store.
3141 }
3142 }
3143
3144 return nullptr;
3145}
3146
3147/// Estimate the cost of the insertion(s) and check that the PHI nodes can be
3148/// converted to selects.
3149static bool validateAndCostRequiredSelects(BasicBlock *BB, BasicBlock *ThenBB,
3150 BasicBlock *EndBB,
3151 unsigned &SpeculatedInstructions,
3152 InstructionCost &Cost,
3153 const TargetTransformInfo &TTI) {
3154 TargetTransformInfo::TargetCostKind CostKind =
3155 BB->getParent()->hasMinSize()
3156 ? TargetTransformInfo::TCK_CodeSize
3157 : TargetTransformInfo::TCK_SizeAndLatency;
3158
3159 bool HaveRewritablePHIs = false;
3160 for (PHINode &PN : EndBB->phis()) {
3161 Value *OrigV = PN.getIncomingValueForBlock(BB);
3162 Value *ThenV = PN.getIncomingValueForBlock(BB: ThenBB);
3163
3164 // FIXME: Try to remove some of the duplication with
3165 // hoistCommonCodeFromSuccessors. Skip PHIs which are trivial.
3166 if (ThenV == OrigV)
3167 continue;
3168
3169 Cost += TTI.getCmpSelInstrCost(Opcode: Instruction::Select, ValTy: PN.getType(),
3170 CondTy: Type::getInt1Ty(C&: PN.getContext()),
3171 VecPred: CmpInst::BAD_ICMP_PREDICATE, CostKind);
3172
3173 // Don't convert to selects if we could remove undefined behavior instead.
3174 if (passingValueIsAlwaysUndefined(V: OrigV, I: &PN) ||
3175 passingValueIsAlwaysUndefined(V: ThenV, I: &PN))
3176 return false;
3177
3178 HaveRewritablePHIs = true;
3179 ConstantExpr *OrigCE = dyn_cast<ConstantExpr>(Val: OrigV);
3180 ConstantExpr *ThenCE = dyn_cast<ConstantExpr>(Val: ThenV);
3181 if (!OrigCE && !ThenCE)
3182 continue; // Known cheap (FIXME: Maybe not true for aggregates).
3183
3184 InstructionCost OrigCost = OrigCE ? computeSpeculationCost(I: OrigCE, TTI) : 0;
3185 InstructionCost ThenCost = ThenCE ? computeSpeculationCost(I: ThenCE, TTI) : 0;
3186 InstructionCost MaxCost =
3187 2 * PHINodeFoldingThreshold * TargetTransformInfo::TCC_Basic;
3188 if (OrigCost + ThenCost > MaxCost)
3189 return false;
3190
3191 // Account for the cost of an unfolded ConstantExpr which could end up
3192 // getting expanded into Instructions.
3193 // FIXME: This doesn't account for how many operations are combined in the
3194 // constant expression.
3195 ++SpeculatedInstructions;
3196 if (SpeculatedInstructions > 1)
3197 return false;
3198 }
3199
3200 return HaveRewritablePHIs;
3201}
3202
3203static bool isProfitableToSpeculate(const CondBrInst *BI,
3204 std::optional<bool> Invert,
3205 const TargetTransformInfo &TTI) {
3206 // If the branch is non-unpredictable, and is predicted to *not* branch to
3207 // the `then` block, then avoid speculating it.
3208 if (BI->getMetadata(KindID: LLVMContext::MD_unpredictable))
3209 return true;
3210
3211 uint64_t TWeight, FWeight;
3212 if (!extractBranchWeights(I: *BI, TrueVal&: TWeight, FalseVal&: FWeight) || (TWeight + FWeight) == 0)
3213 return true;
3214
3215 if (!Invert.has_value())
3216 return false;
3217
3218 uint64_t EndWeight = *Invert ? TWeight : FWeight;
3219 BranchProbability BIEndProb =
3220 BranchProbability::getBranchProbability(Numerator: EndWeight, Denominator: TWeight + FWeight);
3221 BranchProbability Likely = TTI.getPredictableBranchThreshold();
3222 return BIEndProb < Likely;
3223}
3224
3225/// Speculate a conditional basic block flattening the CFG.
3226///
3227/// Note that this is a very risky transform currently. Speculating
3228/// instructions like this is most often not desirable. Instead, there is an MI
3229/// pass which can do it with full awareness of the resource constraints.
3230/// However, some cases are "obvious" and we should do directly. An example of
3231/// this is speculating a single, reasonably cheap instruction.
3232///
3233/// There is only one distinct advantage to flattening the CFG at the IR level:
3234/// it makes very common but simplistic optimizations such as are common in
3235/// instcombine and the DAG combiner more powerful by removing CFG edges and
3236/// modeling their effects with easier to reason about SSA value graphs.
3237///
3238///
3239/// An illustration of this transform is turning this IR:
3240/// \code
3241/// BB:
3242/// %cmp = icmp ult %x, %y
3243/// br i1 %cmp, label %EndBB, label %ThenBB
3244/// ThenBB:
3245/// %sub = sub %x, %y
3246/// br label BB2
3247/// EndBB:
3248/// %phi = phi [ %sub, %ThenBB ], [ 0, %BB ]
3249/// ...
3250/// \endcode
3251///
3252/// Into this IR:
3253/// \code
3254/// BB:
3255/// %cmp = icmp ult %x, %y
3256/// %sub = sub %x, %y
3257/// %cond = select i1 %cmp, 0, %sub
3258/// ...
3259/// \endcode
3260///
3261/// \returns true if the conditional block is removed.
3262bool SimplifyCFGOpt::speculativelyExecuteBB(CondBrInst *BI,
3263 BasicBlock *ThenBB) {
3264 if (!Options.SpeculateBlocks)
3265 return false;
3266
3267 BasicBlock *BB = BI->getParent();
3268 BasicBlock *EndBB = ThenBB->getTerminator()->getSuccessor(Idx: 0);
3269 InstructionCost Budget =
3270 PHINodeFoldingThreshold * TargetTransformInfo::TCC_Basic;
3271
3272 // If ThenBB is actually on the false edge of the conditional branch, remember
3273 // to swap the select operands later.
3274 bool Invert = false;
3275 if (ThenBB != BI->getSuccessor(i: 0)) {
3276 assert(ThenBB == BI->getSuccessor(1) && "No edge from 'if' block?");
3277 Invert = true;
3278 }
3279 assert(EndBB == BI->getSuccessor(!Invert) && "No edge from to end block");
3280
3281 if (!isProfitableToSpeculate(BI, Invert, TTI))
3282 return false;
3283
3284 // Keep a count of how many times instructions are used within ThenBB when
3285 // they are candidates for sinking into ThenBB. Specifically:
3286 // - They are defined in BB, and
3287 // - They have no side effects, and
3288 // - All of their uses are in ThenBB.
3289 SmallDenseMap<Instruction *, unsigned, 4> SinkCandidateUseCounts;
3290
3291 SmallVector<Instruction *, 4> SpeculatedPseudoProbes;
3292
3293 unsigned SpeculatedInstructions = 0;
3294 bool HoistLoadsStores = Options.HoistLoadsStoresWithCondFaulting;
3295 SmallVector<Instruction *, 2> SpeculatedConditionalLoadsStores;
3296 Value *SpeculatedStoreValue = nullptr;
3297 StoreInst *SpeculatedStore = nullptr;
3298 Instruction *PreviousStoreAccess = nullptr;
3299 EphemeralValueTracker EphTracker;
3300 for (Instruction &I : reverse(C: drop_end(RangeOrContainer&: *ThenBB))) {
3301 // Skip pseudo probes. The consequence is we lose track of the branch
3302 // probability for ThenBB, which is fine since the optimization here takes
3303 // place regardless of the branch probability.
3304 if (isa<PseudoProbeInst>(Val: I)) {
3305 // The probe should be deleted so that it will not be over-counted when
3306 // the samples collected on the non-conditional path are counted towards
3307 // the conditional path. We leave it for the counts inference algorithm to
3308 // figure out a proper count for an unknown probe.
3309 SpeculatedPseudoProbes.push_back(Elt: &I);
3310 continue;
3311 }
3312
3313 // Ignore ephemeral values, they will be dropped by the transform.
3314 if (EphTracker.track(I: &I))
3315 continue;
3316
3317 // Only speculatively execute a single instruction (not counting the
3318 // terminator) for now.
3319 bool IsSafeCheapLoadStore = HoistLoadsStores &&
3320 isSafeCheapLoadStore(I: &I, TTI) &&
3321 SpeculatedConditionalLoadsStores.size() <
3322 HoistLoadsStoresWithCondFaultingThreshold;
3323 // Not count load/store into cost if target supports conditional faulting
3324 // b/c it's cheap to speculate it.
3325 if (IsSafeCheapLoadStore)
3326 SpeculatedConditionalLoadsStores.push_back(Elt: &I);
3327 else
3328 ++SpeculatedInstructions;
3329
3330 if (SpeculatedInstructions > 1)
3331 return false;
3332
3333 // Don't hoist the instruction if it's unsafe or expensive.
3334 if (!IsSafeCheapLoadStore &&
3335 !isSafeToSpeculativelyExecute(I: &I, CtxI: BI, AC: Options.AC) &&
3336 !(HoistCondStores && !SpeculatedStoreValue &&
3337 (SpeculatedStoreValue = isSafeToSpeculateStore(I: &I, BrBB: BB, StoreBB: ThenBB, EndBB,
3338 PreviousAccess&: PreviousStoreAccess))))
3339 return false;
3340 if (!IsSafeCheapLoadStore && !SpeculatedStoreValue &&
3341 computeSpeculationCost(I: &I, TTI) >
3342 PHINodeFoldingThreshold * TargetTransformInfo::TCC_Basic)
3343 return false;
3344
3345 // Store the store speculation candidate.
3346 if (!SpeculatedStore && SpeculatedStoreValue)
3347 SpeculatedStore = cast<StoreInst>(Val: &I);
3348
3349 // Do not hoist the instruction if any of its operands are defined but not
3350 // used in BB. The transformation will prevent the operand from
3351 // being sunk into the use block.
3352 for (Use &Op : I.operands()) {
3353 Instruction *OpI = dyn_cast<Instruction>(Val&: Op);
3354 if (!OpI || OpI->getParent() != BB || OpI->mayHaveSideEffects())
3355 continue; // Not a candidate for sinking.
3356
3357 ++SinkCandidateUseCounts[OpI];
3358 }
3359 }
3360
3361 // Consider any sink candidates which are only used in ThenBB as costs for
3362 // speculation. Note, while we iterate over a DenseMap here, we are summing
3363 // and so iteration order isn't significant.
3364 for (const auto &[Inst, Count] : SinkCandidateUseCounts)
3365 if (Inst->hasNUses(N: Count)) {
3366 ++SpeculatedInstructions;
3367 if (SpeculatedInstructions > 1)
3368 return false;
3369 }
3370
3371 // Check that we can insert the selects and that it's not too expensive to do
3372 // so.
3373 bool Convert =
3374 SpeculatedStore != nullptr || !SpeculatedConditionalLoadsStores.empty();
3375 InstructionCost Cost = 0;
3376 Convert |= validateAndCostRequiredSelects(BB, ThenBB, EndBB,
3377 SpeculatedInstructions, Cost, TTI);
3378 if (!Convert || Cost > Budget)
3379 return false;
3380
3381 // If we get here, we can hoist the instruction and if-convert.
3382 LLVM_DEBUG(dbgs() << "SPECULATIVELY EXECUTING BB" << *ThenBB << "\n";);
3383
3384 Instruction *Sel = nullptr;
3385 Value *BrCond = BI->getCondition();
3386 // Insert a select of the value of the speculated store.
3387 if (SpeculatedStoreValue) {
3388 IRBuilder<NoFolder> Builder(BI);
3389 Value *OrigV = SpeculatedStore->getValueOperand();
3390 Value *TrueV = SpeculatedStore->getValueOperand();
3391 Value *FalseV = SpeculatedStoreValue;
3392 if (Invert)
3393 std::swap(a&: TrueV, b&: FalseV);
3394 Value *S = Builder.CreateSelect(
3395 C: BrCond, True: TrueV, False: FalseV, Name: "spec.store.select", MDFrom: BI);
3396 Sel = cast<Instruction>(Val: S);
3397 SpeculatedStore->setOperand(i_nocapture: 0, Val_nocapture: S);
3398 SpeculatedStore->applyMergedLocation(LocA: BI->getDebugLoc(),
3399 LocB: SpeculatedStore->getDebugLoc());
3400 // The value stored is still conditional, but the store itself is now
3401 // unconditionally executed, so we must be sure that any linked dbg.assign
3402 // intrinsics are tracking the new stored value (the result of the
3403 // select). If we don't, and the store were to be removed by another pass
3404 // (e.g. DSE), then we'd eventually end up emitting a location describing
3405 // the conditional value, unconditionally.
3406 //
3407 // === Before this transformation ===
3408 // pred:
3409 // store %one, %x.dest, !DIAssignID !1
3410 // dbg.assign %one, "x", ..., !1, ...
3411 // br %cond if.then
3412 //
3413 // if.then:
3414 // store %two, %x.dest, !DIAssignID !2
3415 // dbg.assign %two, "x", ..., !2, ...
3416 //
3417 // === After this transformation ===
3418 // pred:
3419 // store %one, %x.dest, !DIAssignID !1
3420 // dbg.assign %one, "x", ..., !1
3421 /// ...
3422 // %merge = select %cond, %two, %one
3423 // store %merge, %x.dest, !DIAssignID !2
3424 // dbg.assign %merge, "x", ..., !2
3425 for (DbgVariableRecord *DbgAssign :
3426 at::getDVRAssignmentMarkers(Inst: SpeculatedStore))
3427 if (llvm::is_contained(Range: DbgAssign->location_ops(), Element: OrigV))
3428 DbgAssign->replaceVariableLocationOp(OldValue: OrigV, NewValue: S);
3429 }
3430
3431 // Metadata can be dependent on the condition we are hoisting above.
3432 // Strip all UB-implying metadata on the instruction. Drop the debug loc
3433 // to avoid making it appear as if the condition is a constant, which would
3434 // be misleading while debugging.
3435 // Similarly strip attributes that maybe dependent on condition we are
3436 // hoisting above.
3437 for (auto &I : make_early_inc_range(Range&: *ThenBB)) {
3438 if (!SpeculatedStoreValue || &I != SpeculatedStore) {
3439 I.dropLocation();
3440 I.dropUBImplyingAttrsAndMetadata();
3441 } else {
3442 assert(PreviousStoreAccess && "Missing previous store access");
3443 AAMDNodes MergedAA = SpeculatedStore->getAAMetadata().merge(
3444 Other: PreviousStoreAccess->getAAMetadata());
3445 I.dropUBImplyingAttrsAndMetadata();
3446 I.setAAMetadata(MergedAA);
3447 }
3448
3449 // Drop ephemeral values.
3450 if (EphTracker.contains(I: &I)) {
3451 I.replaceAllUsesWith(V: PoisonValue::get(T: I.getType()));
3452 I.eraseFromParent();
3453 }
3454 }
3455
3456 // Hoist the instructions.
3457 // Drop DbgVariableRecords attached to these instructions.
3458 for (auto &It : *ThenBB)
3459 for (DbgRecord &DR : make_early_inc_range(Range: It.getDbgRecordRange()))
3460 // Drop all records except assign-kind DbgVariableRecords (dbg.assign
3461 // equivalent).
3462 if (DbgVariableRecord *DVR = dyn_cast<DbgVariableRecord>(Val: &DR);
3463 !DVR || !DVR->isDbgAssign())
3464 It.dropOneDbgRecord(I: &DR);
3465 BB->splice(ToIt: BI->getIterator(), FromBB: ThenBB, FromBeginIt: ThenBB->begin(),
3466 FromEndIt: std::prev(x: ThenBB->end()));
3467
3468 if (!SpeculatedConditionalLoadsStores.empty())
3469 hoistConditionalLoadsStores(BI, SpeculatedConditionalLoadsStores, Invert,
3470 Sel);
3471
3472 // Insert selects and rewrite the PHI operands.
3473 IRBuilder<NoFolder> Builder(BI);
3474 for (PHINode &PN : EndBB->phis()) {
3475 unsigned OrigI = PN.getBasicBlockIndex(BB);
3476 unsigned ThenI = PN.getBasicBlockIndex(BB: ThenBB);
3477 Value *OrigV = PN.getIncomingValue(i: OrigI);
3478 Value *ThenV = PN.getIncomingValue(i: ThenI);
3479
3480 // Skip PHIs which are trivial.
3481 if (OrigV == ThenV)
3482 continue;
3483
3484 // Create a select whose true value is the speculatively executed value and
3485 // false value is the pre-existing value. Swap them if the branch
3486 // destinations were inverted.
3487 Value *TrueV = ThenV, *FalseV = OrigV;
3488 if (Invert)
3489 std::swap(a&: TrueV, b&: FalseV);
3490 // Propagate fast-math flags from the phi node to the replacement select.
3491 Value *V = Builder.CreateSelectFMF(
3492 C: BrCond, True: TrueV, False: FalseV, FMFSource: PN.getFastMathFlagsOrNone(), Name: "spec.select", MDFrom: BI);
3493 PN.setIncomingValue(i: OrigI, V);
3494 PN.setIncomingValue(i: ThenI, V);
3495 }
3496
3497 // Remove speculated pseudo probes.
3498 for (Instruction *I : SpeculatedPseudoProbes)
3499 I->eraseFromParent();
3500
3501 ++NumSpeculations;
3502 return true;
3503}
3504
3505using BlocksSet = SmallPtrSet<BasicBlock *, 8>;
3506
3507// Return false if number of blocks searched is too much.
3508static bool findReaching(BasicBlock *BB, BasicBlock *DefBB,
3509 BlocksSet &ReachesNonLocalUses) {
3510 if (BB == DefBB)
3511 return true;
3512 if (!ReachesNonLocalUses.insert(Ptr: BB).second)
3513 return true;
3514
3515 if (ReachesNonLocalUses.size() > MaxJumpThreadingLiveBlocks)
3516 return false;
3517 for (BasicBlock *Pred : predecessors(BB))
3518 if (!findReaching(BB: Pred, DefBB, ReachesNonLocalUses))
3519 return false;
3520 return true;
3521}
3522
3523/// Return true if we can thread a branch across this block.
3524static bool blockIsSimpleEnoughToThreadThrough(BasicBlock *BB,
3525 BlocksSet &NonLocalUseBlocks) {
3526 int Size = 0;
3527 EphemeralValueTracker EphTracker;
3528
3529 // Walk the loop in reverse so that we can identify ephemeral values properly
3530 // (values only feeding assumes).
3531 for (Instruction &I : reverse(C&: *BB)) {
3532 // Can't fold blocks that contain noduplicate or convergent calls.
3533 if (CallInst *CI = dyn_cast<CallInst>(Val: &I))
3534 if (CI->cannotDuplicate() || CI->isConvergent())
3535 return false;
3536
3537 // Ignore ephemeral values which are deleted during codegen.
3538 // We will delete Phis while threading, so Phis should not be accounted in
3539 // block's size.
3540 if (!EphTracker.track(I: &I) && !isa<PHINode>(Val: I)) {
3541 if (Size++ > MaxSmallBlockSize)
3542 return false; // Don't clone large BB's.
3543 }
3544
3545 // Record blocks with non-local uses of values defined in the current basic
3546 // block.
3547 for (User *U : I.users()) {
3548 Instruction *UI = cast<Instruction>(Val: U);
3549 BasicBlock *UsedInBB = UI->getParent();
3550 if (UsedInBB == BB) {
3551 if (isa<PHINode>(Val: UI))
3552 return false;
3553 } else
3554 NonLocalUseBlocks.insert(Ptr: UsedInBB);
3555 }
3556
3557 // Looks ok, continue checking.
3558 }
3559
3560 return true;
3561}
3562
3563static ConstantInt *getKnownValueOnEdge(Value *V, BasicBlock *From,
3564 BasicBlock *To) {
3565 // Don't look past the block defining the value, we might get the value from
3566 // a previous loop iteration.
3567 auto *I = dyn_cast<Instruction>(Val: V);
3568 if (I && I->getParent() == To)
3569 return nullptr;
3570
3571 // We know the value if the From block branches on it.
3572 auto *BI = dyn_cast<CondBrInst>(Val: From->getTerminator());
3573 if (BI && BI->getCondition() == V &&
3574 BI->getSuccessor(i: 0) != BI->getSuccessor(i: 1))
3575 return BI->getSuccessor(i: 0) == To ? ConstantInt::getTrue(Context&: BI->getContext())
3576 : ConstantInt::getFalse(Context&: BI->getContext());
3577
3578 return nullptr;
3579}
3580
3581static bool isUncontrolledConvergentCall(CallBase *CB) {
3582 return CB->isConvergent() && !isa<ConvergenceControlInst>(Val: CB) &&
3583 !CB->getConvergenceControlToken();
3584}
3585
3586static bool reachesUncontrolledConvergentCallBeforeBlock(BasicBlock *From,
3587 BasicBlock *StopBB) {
3588 static constexpr unsigned MaxInstructionsToScan = 512;
3589
3590 // Walk predecessors of StopBB to find blocks that can reach it. Only
3591 // convergent calls on a cycle with StopBB matter - a convergent call on a
3592 // path to function exit cannot have its dynamic instance changed by
3593 // threading.
3594 SmallPtrSet<BasicBlock *, 8> CanReachStop;
3595 SmallPtrSet<BasicBlock *, 8> BlocksWithUncontrolledConvergentCalls;
3596 SmallVector<BasicBlock *, 8> Worklist;
3597 for (BasicBlock *Pred : predecessors(BB: StopBB))
3598 Worklist.push_back(Elt: Pred);
3599
3600 // Cache blocks with relevant calls while building CanReachStop. This keeps
3601 // the instruction scan bounded without a separate block limit.
3602 unsigned NumScannedInstructions = 0;
3603 while (!Worklist.empty()) {
3604 BasicBlock *BB = Worklist.pop_back_val();
3605 if (BB == StopBB)
3606 continue;
3607 if (!CanReachStop.insert(Ptr: BB).second)
3608 continue;
3609
3610 for (Instruction &I : *BB) {
3611 if (++NumScannedInstructions > MaxInstructionsToScan)
3612 return true;
3613 auto *CB = dyn_cast<CallBase>(Val: &I);
3614 if (CB && isUncontrolledConvergentCall(CB)) {
3615 BlocksWithUncontrolledConvergentCalls.insert(Ptr: BB);
3616 break;
3617 }
3618 }
3619
3620 append_range(C&: Worklist, R: predecessors(BB));
3621 }
3622
3623 if (!CanReachStop.contains(Ptr: From))
3624 return false;
3625
3626 SmallPtrSet<BasicBlock *, 8> Visited;
3627 Worklist.push_back(Elt: From);
3628
3629 while (!Worklist.empty()) {
3630 BasicBlock *BB = Worklist.pop_back_val();
3631 if (BB == StopBB || !CanReachStop.contains(Ptr: BB))
3632 continue;
3633
3634 if (!Visited.insert(Ptr: BB).second)
3635 continue;
3636
3637 if (BlocksWithUncontrolledConvergentCalls.contains(Ptr: BB))
3638 return true;
3639
3640 append_range(C&: Worklist, R: successors(BB));
3641 }
3642
3643 return false;
3644}
3645
3646/// If we have a conditional branch on something for which we know the constant
3647/// value in predecessors (e.g. a phi node in the current block), thread edges
3648/// from the predecessor to their ultimate destination.
3649static std::optional<bool> foldCondBranchOnValueKnownInPredecessorImpl(
3650 CondBrInst *BI, const TargetTransformInfo &TTI, DomTreeUpdater *DTU,
3651 AssumptionCache *AC, const DataLayout &DL) {
3652 SmallMapVector<ConstantInt *, SmallSetVector<BasicBlock *, 2>, 2> KnownValues;
3653 BasicBlock *BB = BI->getParent();
3654 Value *Cond = BI->getCondition();
3655 PHINode *PN = dyn_cast<PHINode>(Val: Cond);
3656 if (PN && PN->getParent() == BB) {
3657 // Degenerate case of a single entry PHI.
3658 if (PN->getNumIncomingValues() == 1) {
3659 FoldSingleEntryPHINodes(BB: PN->getParent());
3660 return true;
3661 }
3662
3663 for (Use &U : PN->incoming_values())
3664 if (auto *CB = dyn_cast<ConstantInt>(Val&: U))
3665 KnownValues[CB].insert(X: PN->getIncomingBlock(U));
3666 } else {
3667 for (BasicBlock *Pred : predecessors(BB)) {
3668 if (ConstantInt *CB = getKnownValueOnEdge(V: Cond, From: Pred, To: BB))
3669 KnownValues[CB].insert(X: Pred);
3670 }
3671 }
3672
3673 if (KnownValues.empty())
3674 return false;
3675
3676 // Now we know that this block has multiple preds and two succs.
3677 // Check that the block is small enough and record which non-local blocks use
3678 // values defined in the block.
3679
3680 BlocksSet NonLocalUseBlocks;
3681 BlocksSet ReachesNonLocalUseBlocks;
3682 if (!blockIsSimpleEnoughToThreadThrough(BB, NonLocalUseBlocks))
3683 return false;
3684
3685 // Jump-threading can only be done to destinations where no values defined
3686 // in BB are live.
3687
3688 // Quickly check if both destinations have uses. If so, jump-threading cannot
3689 // be done.
3690 if (NonLocalUseBlocks.contains(Ptr: BI->getSuccessor(i: 0)) &&
3691 NonLocalUseBlocks.contains(Ptr: BI->getSuccessor(i: 1)))
3692 return false;
3693
3694 // Search backward from NonLocalUseBlocks to find which blocks
3695 // reach non-local uses.
3696 for (BasicBlock *UseBB : NonLocalUseBlocks)
3697 // Give up if too many blocks are searched.
3698 if (!findReaching(BB: UseBB, DefBB: BB, ReachesNonLocalUses&: ReachesNonLocalUseBlocks))
3699 return false;
3700
3701 for (const auto &Pair : KnownValues) {
3702 ConstantInt *CB = Pair.first;
3703 ArrayRef<BasicBlock *> PredBBs = Pair.second.getArrayRef();
3704 BasicBlock *RealDest = BI->getSuccessor(i: !CB->getZExtValue());
3705
3706 // Okay, we now know that all edges from PredBB should be revectored to
3707 // branch to RealDest.
3708 if (RealDest == BB)
3709 continue; // Skip self loops.
3710
3711 // Skip if the predecessor's terminator is an indirect branch.
3712 if (any_of(Range&: PredBBs, P: [](BasicBlock *PredBB) {
3713 return isa<IndirectBrInst>(Val: PredBB->getTerminator());
3714 }))
3715 continue;
3716
3717 // Only revector to RealDest if no values defined in BB are live.
3718 if (ReachesNonLocalUseBlocks.contains(Ptr: RealDest))
3719 continue;
3720
3721 // Threading through a branch can bypass a reconvergence point. If the
3722 // destination can execute an uncontrolled convergent operation before
3723 // returning to this block, this may change the dynamic instance of that
3724 // operation.
3725 if (TTI.hasBranchDivergence(F: BB->getParent()) &&
3726 reachesUncontrolledConvergentCallBeforeBlock(From: RealDest, StopBB: BB))
3727 continue;
3728
3729 LLVM_DEBUG({
3730 dbgs() << "Condition " << *Cond << " in " << BB->getName()
3731 << " has value " << *Pair.first << " in predecessors:\n";
3732 for (const BasicBlock *PredBB : Pair.second)
3733 dbgs() << " " << PredBB->getName() << "\n";
3734 dbgs() << "Threading to destination " << RealDest->getName() << ".\n";
3735 });
3736
3737 // Split the predecessors we are threading into a new edge block. We'll
3738 // clone the instructions into this block, and then redirect it to RealDest.
3739 BasicBlock *EdgeBB = SplitBlockPredecessors(BB, Preds: PredBBs, Suffix: ".critedge", DTU);
3740 if (!EdgeBB)
3741 continue;
3742
3743 // TODO: These just exist to reduce test diff, we can drop them if we like.
3744 EdgeBB->setName(RealDest->getName() + ".critedge");
3745 EdgeBB->moveBefore(MovePos: RealDest);
3746
3747 // Update PHI nodes.
3748 addPredecessorToBlock(Succ: RealDest, NewPred: EdgeBB, ExistPred: BB);
3749
3750 // BB may have instructions that are being threaded over. Clone these
3751 // instructions into EdgeBB. We know that there will be no uses of the
3752 // cloned instructions outside of EdgeBB.
3753 BasicBlock::iterator InsertPt = EdgeBB->getFirstInsertionPt();
3754 ValueToValueMapTy TranslateMap; // Track translated values.
3755 TranslateMap[Cond] = CB;
3756
3757 // RemoveDIs: track instructions that we optimise away while folding, so
3758 // that we can copy DbgVariableRecords from them later.
3759 BasicBlock::iterator SrcDbgCursor = BB->begin();
3760 for (BasicBlock::iterator BBI = BB->begin(); &*BBI != BI; ++BBI) {
3761 if (PHINode *PN = dyn_cast<PHINode>(Val&: BBI)) {
3762 TranslateMap[PN] = PN->getIncomingValueForBlock(BB: EdgeBB);
3763 continue;
3764 }
3765 // Clone the instruction.
3766 Instruction *N = BBI->clone();
3767 // Insert the new instruction into its new home.
3768 N->insertInto(ParentBB: EdgeBB, It: InsertPt);
3769
3770 if (BBI->hasName())
3771 N->setName(BBI->getName() + ".c");
3772
3773 // Update operands due to translation.
3774 // Key Instructions: Remap all the atom groups.
3775 if (const DebugLoc &DL = BBI->getDebugLoc())
3776 mapAtomInstance(DL, VMap&: TranslateMap);
3777 RemapInstruction(I: N, VM&: TranslateMap,
3778 Flags: RF_IgnoreMissingLocals | RF_NoModuleLevelChanges);
3779
3780 // Check for trivial simplification.
3781 if (Value *V = simplifyInstruction(I: N, Q: {DL, nullptr, nullptr, AC})) {
3782 if (!BBI->use_empty())
3783 TranslateMap[&*BBI] = V;
3784 if (!N->mayHaveSideEffects()) {
3785 N->eraseFromParent(); // Instruction folded away, don't need actual
3786 // inst
3787 N = nullptr;
3788 }
3789 } else {
3790 if (!BBI->use_empty())
3791 TranslateMap[&*BBI] = N;
3792 }
3793 if (N) {
3794 // Copy all debug-info attached to instructions from the last we
3795 // successfully clone, up to this instruction (they might have been
3796 // folded away).
3797 for (; SrcDbgCursor != BBI; ++SrcDbgCursor)
3798 N->cloneDebugInfoFrom(From: &*SrcDbgCursor);
3799 SrcDbgCursor = std::next(x: BBI);
3800 // Clone debug-info on this instruction too.
3801 N->cloneDebugInfoFrom(From: &*BBI);
3802
3803 // Register the new instruction with the assumption cache if necessary.
3804 if (auto *Assume = dyn_cast<AssumeInst>(Val: N))
3805 if (AC)
3806 AC->registerAssumption(CI: Assume);
3807 }
3808 }
3809
3810 for (; &*SrcDbgCursor != BI; ++SrcDbgCursor)
3811 InsertPt->cloneDebugInfoFrom(From: &*SrcDbgCursor);
3812 InsertPt->cloneDebugInfoFrom(From: BI);
3813
3814 BB->removePredecessor(Pred: EdgeBB);
3815 UncondBrInst *EdgeBI = cast<UncondBrInst>(Val: EdgeBB->getTerminator());
3816 EdgeBI->setSuccessor(idx: 0, NewSucc: RealDest);
3817 EdgeBI->setDebugLoc(BI->getDebugLoc());
3818
3819 if (DTU) {
3820 SmallVector<DominatorTree::UpdateType, 2> Updates;
3821 Updates.push_back(Elt: {DominatorTree::Delete, EdgeBB, BB});
3822 Updates.push_back(Elt: {DominatorTree::Insert, EdgeBB, RealDest});
3823 DTU->applyUpdates(Updates);
3824 }
3825
3826 // For simplicity, we created a separate basic block for the edge. Merge
3827 // it back into the predecessor if possible. This not only avoids
3828 // unnecessary SimplifyCFG iterations, but also makes sure that we don't
3829 // bypass the check for trivial cycles above.
3830 MergeBlockIntoPredecessor(BB: EdgeBB, DTU);
3831
3832 // Signal repeat, simplifying any other constants.
3833 return std::nullopt;
3834 }
3835
3836 return false;
3837}
3838
3839bool SimplifyCFGOpt::foldCondBranchOnValueKnownInPredecessor(CondBrInst *BI) {
3840 // Note: If BB is a loop header then there is a risk that threading introduces
3841 // a non-canonical loop by moving a back edge. So we avoid this optimization
3842 // for loop headers if NeedCanonicalLoop is set.
3843 if (Options.NeedCanonicalLoop && is_contained(Range&: LoopHeaders, Element: BI->getParent()))
3844 return false;
3845
3846 std::optional<bool> Result;
3847 bool EverChanged = false;
3848 do {
3849 // Note that None means "we changed things, but recurse further."
3850 Result = foldCondBranchOnValueKnownInPredecessorImpl(BI, TTI, DTU,
3851 AC: Options.AC, DL);
3852 EverChanged |= Result == std::nullopt || *Result;
3853 } while (Result == std::nullopt);
3854 return EverChanged;
3855}
3856
3857/// Given a BB that starts with the specified two-entry PHI node,
3858/// see if we can eliminate it.
3859static bool foldTwoEntryPHINode(PHINode *PN, const TargetTransformInfo &TTI,
3860 DomTreeUpdater *DTU, AssumptionCache *AC,
3861 const DataLayout &DL,
3862 bool SpeculateUnpredictables) {
3863 // Ok, this is a two entry PHI node. Check to see if this is a simple "if
3864 // statement", which has a very simple dominance structure. Basically, we
3865 // are trying to find the condition that is being branched on, which
3866 // subsequently causes this merge to happen. We really want control
3867 // dependence information for this check, but simplifycfg can't keep it up
3868 // to date, and this catches most of the cases we care about anyway.
3869 BasicBlock *BB = PN->getParent();
3870
3871 BasicBlock *IfTrue, *IfFalse;
3872 CondBrInst *DomBI = GetIfCondition(BB, IfTrue, IfFalse);
3873 if (!DomBI)
3874 return false;
3875 Value *IfCond = DomBI->getCondition();
3876 // Don't bother if the branch will be constant folded trivially.
3877 if (isa<ConstantInt>(Val: IfCond))
3878 return false;
3879
3880 BasicBlock *DomBlock = DomBI->getParent();
3881 SmallVector<BasicBlock *, 2> IfBlocks;
3882 llvm::copy_if(Range: PN->blocks(), Out: std::back_inserter(x&: IfBlocks),
3883 P: [](BasicBlock *IfBlock) {
3884 return isa<UncondBrInst>(Val: IfBlock->getTerminator());
3885 });
3886 assert((IfBlocks.size() == 1 || IfBlocks.size() == 2) &&
3887 "Will have either one or two blocks to speculate.");
3888
3889 // If the branch is non-unpredictable, see if we either predictably jump to
3890 // the merge bb (if we have only a single 'then' block), or if we predictably
3891 // jump to one specific 'then' block (if we have two of them).
3892 // It isn't beneficial to speculatively execute the code
3893 // from the block that we know is predictably not entered.
3894 bool IsUnpredictable = DomBI->getMetadata(KindID: LLVMContext::MD_unpredictable);
3895 if (!IsUnpredictable) {
3896 uint64_t TWeight, FWeight;
3897 if (extractBranchWeights(I: *DomBI, TrueVal&: TWeight, FalseVal&: FWeight) &&
3898 (TWeight + FWeight) != 0) {
3899 BranchProbability BITrueProb =
3900 BranchProbability::getBranchProbability(Numerator: TWeight, Denominator: TWeight + FWeight);
3901 BranchProbability Likely = TTI.getPredictableBranchThreshold();
3902 BranchProbability BIFalseProb = BITrueProb.getCompl();
3903 if (IfBlocks.size() == 1) {
3904 BranchProbability BIBBProb =
3905 DomBI->getSuccessor(i: 0) == BB ? BITrueProb : BIFalseProb;
3906 if (BIBBProb >= Likely)
3907 return false;
3908 } else {
3909 if (BITrueProb >= Likely || BIFalseProb >= Likely)
3910 return false;
3911 }
3912 }
3913 }
3914
3915 // Don't try to fold an unreachable block. For example, the phi node itself
3916 // can't be the candidate if-condition for a select that we want to form.
3917 if (auto *IfCondPhiInst = dyn_cast<PHINode>(Val: IfCond))
3918 if (IfCondPhiInst->getParent() == BB)
3919 return false;
3920
3921 // Okay, we found that we can merge this two-entry phi node into a select.
3922 // Doing so would require us to fold *all* two entry phi nodes in this block.
3923 // At some point this becomes non-profitable (particularly if the target
3924 // doesn't support cmov's). Only do this transformation if there are two or
3925 // fewer PHI nodes in this block.
3926 unsigned NumPhis = 0;
3927 for (BasicBlock::iterator I = BB->begin(); isa<PHINode>(Val: I); ++NumPhis, ++I)
3928 if (NumPhis > 2)
3929 return false;
3930
3931 // Loop over the PHI's seeing if we can promote them all to select
3932 // instructions. While we are at it, keep track of the instructions
3933 // that need to be moved to the dominating block.
3934 SmallPtrSet<Instruction *, 4> AggressiveInsts;
3935 SmallPtrSet<Instruction *, 2> ZeroCostInstructions;
3936 InstructionCost Cost = 0;
3937 InstructionCost Budget =
3938 TwoEntryPHINodeFoldingThreshold * TargetTransformInfo::TCC_Basic;
3939 if (SpeculateUnpredictables && IsUnpredictable)
3940 Budget += TTI.getBranchMispredictPenalty();
3941
3942 bool Changed = false;
3943 for (BasicBlock::iterator II = BB->begin(); isa<PHINode>(Val: II);) {
3944 PHINode *PN = cast<PHINode>(Val: II++);
3945 if (Value *V = simplifyInstruction(I: PN, Q: {DL, PN})) {
3946 PN->replaceAllUsesWith(V);
3947 PN->eraseFromParent();
3948 Changed = true;
3949 continue;
3950 }
3951
3952 if (!dominatesMergePoint(V: PN->getIncomingValue(i: 0), BB, InsertPt: DomBI,
3953 AggressiveInsts, Cost, Budget, TTI, AC,
3954 ZeroCostInstructions) ||
3955 !dominatesMergePoint(V: PN->getIncomingValue(i: 1), BB, InsertPt: DomBI,
3956 AggressiveInsts, Cost, Budget, TTI, AC,
3957 ZeroCostInstructions))
3958 return Changed;
3959 }
3960
3961 // If we folded the first phi, PN dangles at this point. Refresh it. If
3962 // we ran out of PHIs then we simplified them all.
3963 PN = dyn_cast<PHINode>(Val: BB->begin());
3964 if (!PN)
3965 return true;
3966
3967 // Don't fold i1 branches on PHIs which contain binary operators or
3968 // (possibly inverted) select form of or/ands if their parameters are
3969 // an equality test.
3970 auto IsBinOpOrAndEq = [](Value *V) {
3971 CmpPredicate Pred;
3972 if (match(V, P: m_CombineOr(
3973 Ps: m_CombineOr(
3974 Ps: m_BinOp(L: m_Cmp(Pred, L: m_Value(), R: m_Value()), R: m_Value()),
3975 Ps: m_BinOp(L: m_Value(), R: m_Cmp(Pred, L: m_Value(), R: m_Value()))),
3976 Ps: m_c_Select(L: m_ImmConstant(),
3977 R: m_Cmp(Pred, L: m_Value(), R: m_Value()))))) {
3978 return CmpInst::isEquality(pred: Pred);
3979 }
3980 return false;
3981 };
3982 if (PN->getType()->isIntegerTy(BitWidth: 1) &&
3983 (IsBinOpOrAndEq(PN->getIncomingValue(i: 0)) ||
3984 IsBinOpOrAndEq(PN->getIncomingValue(i: 1)) || IsBinOpOrAndEq(IfCond)))
3985 return Changed;
3986
3987 // If all PHI nodes are promotable, check to make sure that all instructions
3988 // in the predecessor blocks can be promoted as well. If not, we won't be able
3989 // to get rid of the control flow, so it's not worth promoting to select
3990 // instructions.
3991 for (BasicBlock *IfBlock : IfBlocks)
3992 for (BasicBlock::iterator I = IfBlock->begin(); !I->isTerminator(); ++I)
3993 if (!AggressiveInsts.count(Ptr: &*I) && !I->isDebugOrPseudoInst()) {
3994 // This is not an aggressive instruction that we can promote.
3995 // Because of this, we won't be able to get rid of the control flow, so
3996 // the xform is not worth it.
3997 return Changed;
3998 }
3999
4000 // If either of the blocks has it's address taken, we can't do this fold.
4001 if (any_of(Range&: IfBlocks,
4002 P: [](BasicBlock *IfBlock) { return IfBlock->hasAddressTaken(); }))
4003 return Changed;
4004
4005 LLVM_DEBUG(dbgs() << "FOUND IF CONDITION! " << *IfCond;
4006 if (IsUnpredictable) dbgs() << " (unpredictable)";
4007 dbgs() << " T: " << IfTrue->getName()
4008 << " F: " << IfFalse->getName() << "\n");
4009
4010 // If we can still promote the PHI nodes after this gauntlet of tests,
4011 // do all of the PHI's now.
4012
4013 // Move all 'aggressive' instructions, which are defined in the
4014 // conditional parts of the if's up to the dominating block.
4015 for (BasicBlock *IfBlock : IfBlocks)
4016 hoistAllInstructionsInto(DomBlock, InsertPt: DomBI, BB: IfBlock);
4017
4018 IRBuilder<NoFolder> Builder(DomBI);
4019 // Propagate fast-math-flags from phi nodes to replacement selects.
4020 while (PHINode *PN = dyn_cast<PHINode>(Val: BB->begin())) {
4021 // Change the PHI node into a select instruction.
4022 Value *TrueVal = PN->getIncomingValueForBlock(BB: IfTrue);
4023 Value *FalseVal = PN->getIncomingValueForBlock(BB: IfFalse);
4024
4025 Value *Sel = Builder.CreateSelectFMF(C: IfCond, True: TrueVal, False: FalseVal,
4026 FMFSource: isa<FPMathOperator>(Val: PN) ? PN : nullptr,
4027 Name: "", MDFrom: DomBI);
4028 PN->replaceAllUsesWith(V: Sel);
4029 Sel->takeName(V: PN);
4030 PN->eraseFromParent();
4031 }
4032
4033 // At this point, all IfBlocks are empty, so our if statement
4034 // has been flattened. Change DomBlock to jump directly to our new block to
4035 // avoid other simplifycfg's kicking in on the diamond.
4036 Builder.CreateBr(Dest: BB);
4037
4038 SmallVector<DominatorTree::UpdateType, 3> Updates;
4039 if (DTU) {
4040 Updates.push_back(Elt: {DominatorTree::Insert, DomBlock, BB});
4041 for (auto *Successor : successors(BB: DomBlock))
4042 Updates.push_back(Elt: {DominatorTree::Delete, DomBlock, Successor});
4043 }
4044
4045 DomBI->eraseFromParent();
4046 if (DTU)
4047 DTU->applyUpdates(Updates);
4048
4049 return true;
4050}
4051
4052static Value *createLogicalOp(IRBuilderBase &Builder,
4053 Instruction::BinaryOps Opc, Value *LHS,
4054 Value *RHS, const Twine &Name = "") {
4055 // Try to relax logical op to binary op.
4056 if (impliesPoison(ValAssumedPoison: RHS, V: LHS))
4057 return Builder.CreateBinOp(Opc, LHS, RHS, Name);
4058 if (Opc == Instruction::And)
4059 return Builder.CreateLogicalAnd(Cond1: LHS, Cond2: RHS, Name);
4060 if (Opc == Instruction::Or)
4061 return Builder.CreateLogicalOr(Cond1: LHS, Cond2: RHS, Name);
4062 llvm_unreachable("Invalid logical opcode");
4063}
4064
4065/// Return true if either PBI or BI has branch weight available, and store
4066/// the weights in {Pred|Succ}{True|False}Weight. If one of PBI and BI does
4067/// not have branch weight, use 1:1 as its weight.
4068static bool extractPredSuccWeights(CondBrInst *PBI, CondBrInst *BI,
4069 uint64_t &PredTrueWeight,
4070 uint64_t &PredFalseWeight,
4071 uint64_t &SuccTrueWeight,
4072 uint64_t &SuccFalseWeight) {
4073 bool PredHasWeights =
4074 extractBranchWeights(I: *PBI, TrueVal&: PredTrueWeight, FalseVal&: PredFalseWeight);
4075 bool SuccHasWeights =
4076 extractBranchWeights(I: *BI, TrueVal&: SuccTrueWeight, FalseVal&: SuccFalseWeight);
4077 if (PredHasWeights || SuccHasWeights) {
4078 if (!PredHasWeights)
4079 PredTrueWeight = PredFalseWeight = 1;
4080 if (!SuccHasWeights)
4081 SuccTrueWeight = SuccFalseWeight = 1;
4082 return true;
4083 } else {
4084 return false;
4085 }
4086}
4087
4088/// Determine if the two branches share a common destination and deduce a glue
4089/// that joins the branches' conditions to arrive at the common destination if
4090/// that would be profitable.
4091static std::optional<std::tuple<BasicBlock *, Instruction::BinaryOps, bool>>
4092shouldFoldCondBranchesToCommonDestination(CondBrInst *BI, CondBrInst *PBI,
4093 const TargetTransformInfo *TTI) {
4094 assert(BI && PBI && "Both blocks must end with a conditional branches.");
4095 assert(is_contained(predecessors(BI->getParent()), PBI->getParent()) &&
4096 "PredBB must be a predecessor of BB.");
4097
4098 // We have the potential to fold the conditions together, but if the
4099 // predecessor branch is predictable, we may not want to merge them.
4100 uint64_t PTWeight, PFWeight;
4101 BranchProbability PBITrueProb, Likely;
4102 if (TTI && !PBI->getMetadata(KindID: LLVMContext::MD_unpredictable) &&
4103 extractBranchWeights(I: *PBI, TrueVal&: PTWeight, FalseVal&: PFWeight) &&
4104 (PTWeight + PFWeight) != 0) {
4105 PBITrueProb =
4106 BranchProbability::getBranchProbability(Numerator: PTWeight, Denominator: PTWeight + PFWeight);
4107 Likely = TTI->getPredictableBranchThreshold();
4108 }
4109
4110 if (PBI->getSuccessor(i: 0) == BI->getSuccessor(i: 0)) {
4111 // Speculate the 2nd condition unless the 1st is probably true.
4112 if (PBITrueProb.isUnknown() || PBITrueProb < Likely)
4113 return {{BI->getSuccessor(i: 0), Instruction::Or, false}};
4114 } else if (PBI->getSuccessor(i: 1) == BI->getSuccessor(i: 1)) {
4115 // Speculate the 2nd condition unless the 1st is probably false.
4116 if (PBITrueProb.isUnknown() || PBITrueProb.getCompl() < Likely)
4117 return {{BI->getSuccessor(i: 1), Instruction::And, false}};
4118 } else if (PBI->getSuccessor(i: 0) == BI->getSuccessor(i: 1)) {
4119 // Speculate the 2nd condition unless the 1st is probably true.
4120 if (PBITrueProb.isUnknown() || PBITrueProb < Likely)
4121 return {{BI->getSuccessor(i: 1), Instruction::And, true}};
4122 } else if (PBI->getSuccessor(i: 1) == BI->getSuccessor(i: 0)) {
4123 // Speculate the 2nd condition unless the 1st is probably false.
4124 if (PBITrueProb.isUnknown() || PBITrueProb.getCompl() < Likely)
4125 return {{BI->getSuccessor(i: 0), Instruction::Or, true}};
4126 }
4127 return std::nullopt;
4128}
4129
4130static bool performBranchToCommonDestFolding(CondBrInst *BI, CondBrInst *PBI,
4131 DomTreeUpdater *DTU,
4132 MemorySSAUpdater *MSSAU,
4133 const TargetTransformInfo *TTI) {
4134 BasicBlock *BB = BI->getParent();
4135 BasicBlock *PredBlock = PBI->getParent();
4136
4137 // Determine if the two branches share a common destination.
4138 BasicBlock *CommonSucc;
4139 Instruction::BinaryOps Opc;
4140 bool InvertPredCond;
4141 std::tie(args&: CommonSucc, args&: Opc, args&: InvertPredCond) =
4142 *shouldFoldCondBranchesToCommonDestination(BI, PBI, TTI);
4143
4144 LLVM_DEBUG(dbgs() << "FOLDING BRANCH TO COMMON DEST:\n" << *PBI << *BB);
4145
4146 IRBuilder<ConstantFolder, IRBuilderCallbackInserter> Builder(
4147 *BB->getModule(), ConstantFolder{},
4148 IRBuilderCallbackInserter([&BB](Instruction *I) {
4149 // The builder is used to create instructions to eliminate the branch in
4150 // BB. If BB's terminator has !annotation metadata, add it to the new
4151 // instructions.
4152 I->copyMetadata(SrcInst: *BB->getTerminator(), WL: LLVMContext::MD_annotation);
4153 }));
4154 Builder.SetInsertPoint(PBI);
4155
4156 // If we need to invert the condition in the pred block to match, do so now.
4157 if (InvertPredCond) {
4158 InvertBranch(PBI, Builder);
4159 }
4160
4161 BasicBlock *UniqueSucc =
4162 PBI->getSuccessor(i: 0) == BB ? BI->getSuccessor(i: 0) : BI->getSuccessor(i: 1);
4163
4164 // Before cloning instructions, notify the successor basic block that it
4165 // is about to have a new predecessor. This will update PHI nodes,
4166 // which will allow us to update live-out uses of bonus instructions.
4167 addPredecessorToBlock(Succ: UniqueSucc, NewPred: PredBlock, ExistPred: BB, MSSAU);
4168
4169 // Try to update branch weights.
4170 uint64_t PredTrueWeight, PredFalseWeight, SuccTrueWeight, SuccFalseWeight;
4171 SmallVector<uint64_t, 2> MDWeights;
4172 if (extractPredSuccWeights(PBI, BI, PredTrueWeight, PredFalseWeight,
4173 SuccTrueWeight, SuccFalseWeight)) {
4174
4175 if (PBI->getSuccessor(i: 0) == BB) {
4176 // PBI: br i1 %x, BB, FalseDest
4177 // BI: br i1 %y, UniqueSucc, FalseDest
4178 // TrueWeight is TrueWeight for PBI * TrueWeight for BI.
4179 MDWeights.push_back(Elt: PredTrueWeight * SuccTrueWeight);
4180 // FalseWeight is FalseWeight for PBI * TotalWeight for BI +
4181 // TrueWeight for PBI * FalseWeight for BI.
4182 // We assume that total weights of a CondBrInst can fit into 32 bits.
4183 // Therefore, we will not have overflow using 64-bit arithmetic.
4184 MDWeights.push_back(Elt: PredFalseWeight * (SuccFalseWeight + SuccTrueWeight) +
4185 PredTrueWeight * SuccFalseWeight);
4186 } else {
4187 // PBI: br i1 %x, TrueDest, BB
4188 // BI: br i1 %y, TrueDest, UniqueSucc
4189 // TrueWeight is TrueWeight for PBI * TotalWeight for BI +
4190 // FalseWeight for PBI * TrueWeight for BI.
4191 MDWeights.push_back(Elt: PredTrueWeight * (SuccFalseWeight + SuccTrueWeight) +
4192 PredFalseWeight * SuccTrueWeight);
4193 // FalseWeight is FalseWeight for PBI * FalseWeight for BI.
4194 MDWeights.push_back(Elt: PredFalseWeight * SuccFalseWeight);
4195 }
4196
4197 setFittedBranchWeights(I&: *PBI, Weights: MDWeights, /*IsExpected=*/false,
4198 /*ElideAllZero=*/true);
4199
4200 // TODO: If BB is reachable from all paths through PredBlock, then we
4201 // could replace PBI's branch probabilities with BI's.
4202 } else
4203 PBI->setMetadata(KindID: LLVMContext::MD_prof, Node: nullptr);
4204
4205 // Now, update the CFG.
4206 PBI->setSuccessor(idx: PBI->getSuccessor(i: 0) != BB, NewSucc: UniqueSucc);
4207
4208 if (DTU)
4209 DTU->applyUpdates(Updates: {{DominatorTree::Insert, PredBlock, UniqueSucc},
4210 {DominatorTree::Delete, PredBlock, BB}});
4211
4212 // If BI was a loop latch, it may have had associated loop metadata.
4213 // We need to copy it to the new latch, that is, PBI.
4214 if (MDNode *LoopMD = BI->getMetadata(KindID: LLVMContext::MD_loop))
4215 PBI->setMetadata(KindID: LLVMContext::MD_loop, Node: LoopMD);
4216
4217 ValueToValueMapTy VMap; // maps original values to cloned values
4218 cloneInstructionsIntoPredecessorBlockAndUpdateSSAUses(BB, PredBlock, VMap);
4219
4220 Module *M = BB->getModule();
4221
4222 PredBlock->getTerminator()->cloneDebugInfoFrom(From: BB->getTerminator());
4223 for (DbgVariableRecord &DVR :
4224 filterDbgVars(R: PredBlock->getTerminator()->getDbgRecordRange())) {
4225 RemapDbgRecord(M, DR: &DVR, VM&: VMap,
4226 Flags: RF_NoModuleLevelChanges | RF_IgnoreMissingLocals);
4227 }
4228
4229 // Now that the Cond was cloned into the predecessor basic block,
4230 // or/and the two conditions together.
4231 Value *BICond = VMap[BI->getCondition()];
4232 PBI->setCondition(
4233 createLogicalOp(Builder, Opc, LHS: PBI->getCondition(), RHS: BICond, Name: "or.cond"));
4234 if (auto *SI = dyn_cast<SelectInst>(Val: PBI->getCondition()))
4235 if (!MDWeights.empty()) {
4236 assert(isSelectInRoleOfConjunctionOrDisjunction(SI));
4237 setFittedBranchWeights(I&: *SI, Weights: {MDWeights[0], MDWeights[1]},
4238 /*IsExpected=*/false, /*ElideAllZero=*/true);
4239 }
4240
4241 ++NumFoldBranchToCommonDest;
4242 return true;
4243}
4244
4245/// Return if an instruction's type or any of its operands' types are a vector
4246/// type.
4247static bool isVectorOp(Instruction &I) {
4248 return I.getType()->isVectorTy() || any_of(Range: I.operands(), P: [](Use &U) {
4249 return U->getType()->isVectorTy();
4250 });
4251}
4252
4253/// If this basic block is simple enough, and if a predecessor branches to us
4254/// and one of our successors, fold the block into the predecessor and use
4255/// logical operations to pick the right destination.
4256bool llvm::foldBranchToCommonDest(CondBrInst *BI, DomTreeUpdater *DTU,
4257 MemorySSAUpdater *MSSAU,
4258 const TargetTransformInfo *TTI,
4259 AssumptionCache *AC,
4260 unsigned BonusInstThreshold) {
4261 BasicBlock *BB = BI->getParent();
4262 TargetTransformInfo::TargetCostKind CostKind =
4263 BB->getParent()->hasMinSize() ? TargetTransformInfo::TCK_CodeSize
4264 : TargetTransformInfo::TCK_SizeAndLatency;
4265
4266 Instruction *Cond = dyn_cast<Instruction>(Val: BI->getCondition());
4267
4268 if (!Cond || !isa<CmpInst, BinaryOperator, SelectInst, TruncInst>(Val: Cond) ||
4269 Cond->getParent() != BB || !Cond->hasOneUse())
4270 return false;
4271
4272 // Finally, don't infinitely unroll conditional loops.
4273 if (is_contained(Range: successors(BB), Element: BB))
4274 return false;
4275
4276 // With which predecessors will we want to deal with?
4277 SmallVector<BasicBlock *, 8> Preds;
4278 for (BasicBlock *PredBlock : predecessors(BB)) {
4279 CondBrInst *PBI = dyn_cast<CondBrInst>(Val: PredBlock->getTerminator());
4280
4281 // Check that we have two conditional branches. If there is a PHI node in
4282 // the common successor, verify that the same value flows in from both
4283 // blocks.
4284 if (!PBI || !safeToMergeTerminators(SI1: BI, SI2: PBI))
4285 continue;
4286
4287 // Determine if the two branches share a common destination.
4288 BasicBlock *CommonSucc;
4289 Instruction::BinaryOps Opc;
4290 bool InvertPredCond;
4291 if (auto Recipe = shouldFoldCondBranchesToCommonDestination(BI, PBI, TTI))
4292 std::tie(args&: CommonSucc, args&: Opc, args&: InvertPredCond) = *Recipe;
4293 else
4294 continue;
4295
4296 // Check the cost of inserting the necessary logic before performing the
4297 // transformation.
4298 if (TTI) {
4299 Type *Ty = BI->getCondition()->getType();
4300 InstructionCost Cost = TTI->getArithmeticInstrCost(Opcode: Opc, Ty, CostKind);
4301 if (InvertPredCond && (!PBI->getCondition()->hasOneUse() ||
4302 !isa<CmpInst>(Val: PBI->getCondition())))
4303 Cost += TTI->getArithmeticInstrCost(Opcode: Instruction::Xor, Ty, CostKind);
4304
4305 if (Cost > BranchFoldThreshold)
4306 continue;
4307 }
4308
4309 // Ok, we do want to deal with this predecessor. Record it.
4310 Preds.emplace_back(Args&: PredBlock);
4311 }
4312
4313 // If there aren't any predecessors into which we can fold,
4314 // don't bother checking the cost.
4315 if (Preds.empty())
4316 return false;
4317
4318 // Only allow this transformation if computing the condition doesn't involve
4319 // too many instructions and these involved instructions can be executed
4320 // unconditionally. We denote all involved instructions except the condition
4321 // as "bonus instructions", and only allow this transformation when the
4322 // number of the bonus instructions we'll need to create when cloning into
4323 // each predecessor does not exceed a certain threshold.
4324 unsigned NumBonusInsts = 0;
4325 bool SawVectorOp = false;
4326 const unsigned PredCount = Preds.size();
4327 // Speculated instructions will be inserted before the terminator of the
4328 // predecessor. Only handle the simple case of one predecessor.
4329 const Instruction *CtxI =
4330 PredCount == 1 ? Preds[0]->getTerminator() : nullptr;
4331 for (Instruction &I : *BB) {
4332 // Don't check the branch condition comparison itself.
4333 if (&I == Cond)
4334 continue;
4335 // Ignore the terminator.
4336 if (isa<UncondBrInst, CondBrInst>(Val: I))
4337 continue;
4338 // Pseudo probes aren't speculatable but can be dropped on fold.
4339 if (isa<PseudoProbeInst>(Val: I))
4340 continue;
4341 // I must be safe to execute unconditionally.
4342 if (!isSafeToSpeculativelyExecute(I: &I, CtxI, AC))
4343 return false;
4344 SawVectorOp |= isVectorOp(I);
4345
4346 // Account for the cost of duplicating this instruction into each
4347 // predecessor. Ignore free instructions.
4348 if (!TTI || TTI->getInstructionCost(U: &I, CostKind) !=
4349 TargetTransformInfo::TCC_Free) {
4350 NumBonusInsts += PredCount;
4351
4352 // Early exits once we reach the limit.
4353 if (NumBonusInsts >
4354 BonusInstThreshold * BranchFoldToCommonDestVectorMultiplier)
4355 return false;
4356 }
4357
4358 auto IsBCSSAUse = [BB, &I](Use &U) {
4359 auto *UI = cast<Instruction>(Val: U.getUser());
4360 if (auto *PN = dyn_cast<PHINode>(Val: UI))
4361 return PN->getIncomingBlock(U) == BB;
4362 return UI->getParent() == BB && I.comesBefore(Other: UI);
4363 };
4364
4365 // Does this instruction require rewriting of uses?
4366 if (!all_of(Range: I.uses(), P: IsBCSSAUse))
4367 return false;
4368 }
4369 if (NumBonusInsts >
4370 BonusInstThreshold *
4371 (SawVectorOp ? BranchFoldToCommonDestVectorMultiplier : 1))
4372 return false;
4373
4374 // Ok, we have the budget. Perform the transformation.
4375 for (BasicBlock *PredBlock : Preds) {
4376 auto *PBI = cast<CondBrInst>(Val: PredBlock->getTerminator());
4377 return performBranchToCommonDestFolding(BI, PBI, DTU, MSSAU, TTI);
4378 }
4379 return false;
4380}
4381
4382// If there is only one store in BB1 and BB2, return it, otherwise return
4383// nullptr.
4384static StoreInst *findUniqueStoreInBlocks(BasicBlock *BB1, BasicBlock *BB2) {
4385 StoreInst *S = nullptr;
4386 for (auto *BB : {BB1, BB2}) {
4387 if (!BB)
4388 continue;
4389 for (auto &I : *BB)
4390 if (auto *SI = dyn_cast<StoreInst>(Val: &I)) {
4391 if (S)
4392 // Multiple stores seen.
4393 return nullptr;
4394 else
4395 S = SI;
4396 }
4397 }
4398 return S;
4399}
4400
4401static Value *ensureValueAvailableInSuccessor(Value *V, BasicBlock *BB,
4402 Value *AlternativeV = nullptr) {
4403 // PHI is going to be a PHI node that allows the value V that is defined in
4404 // BB to be referenced in BB's only successor.
4405 //
4406 // If AlternativeV is nullptr, the only value we care about in PHI is V. It
4407 // doesn't matter to us what the other operand is (it'll never get used). We
4408 // could just create a new PHI with an undef incoming value, but that could
4409 // increase register pressure if EarlyCSE/InstCombine can't fold it with some
4410 // other PHI. So here we directly look for some PHI in BB's successor with V
4411 // as an incoming operand. If we find one, we use it, else we create a new
4412 // one.
4413 //
4414 // If AlternativeV is not nullptr, we care about both incoming values in PHI.
4415 // PHI must be exactly: phi <ty> [ %BB, %V ], [ %OtherBB, %AlternativeV]
4416 // where OtherBB is the single other predecessor of BB's only successor.
4417 PHINode *PHI = nullptr;
4418 BasicBlock *Succ = BB->getSingleSuccessor();
4419
4420 for (auto I = Succ->begin(); isa<PHINode>(Val: I); ++I)
4421 if (cast<PHINode>(Val&: I)->getIncomingValueForBlock(BB) == V) {
4422 PHI = cast<PHINode>(Val&: I);
4423 if (!AlternativeV)
4424 break;
4425
4426 assert(Succ->hasNPredecessors(2));
4427 auto PredI = pred_begin(BB: Succ);
4428 BasicBlock *OtherPredBB = *PredI == BB ? *++PredI : *PredI;
4429 if (PHI->getIncomingValueForBlock(BB: OtherPredBB) == AlternativeV)
4430 break;
4431 PHI = nullptr;
4432 }
4433 if (PHI)
4434 return PHI;
4435
4436 // If V is not an instruction defined in BB, just return it.
4437 if (!AlternativeV &&
4438 (!isa<Instruction>(Val: V) || cast<Instruction>(Val: V)->getParent() != BB))
4439 return V;
4440
4441 PHI = PHINode::Create(Ty: V->getType(), NumReservedValues: 2, NameStr: "simplifycfg.merge");
4442 PHI->insertBefore(InsertPos: Succ->begin());
4443 PHI->addIncoming(V, BB);
4444 for (BasicBlock *PredBB : predecessors(BB: Succ))
4445 if (PredBB != BB)
4446 PHI->addIncoming(
4447 V: AlternativeV ? AlternativeV : PoisonValue::get(T: V->getType()), BB: PredBB);
4448 return PHI;
4449}
4450
4451static bool mergeConditionalStoreToAddress(
4452 BasicBlock *PTB, BasicBlock *PFB, BasicBlock *QTB, BasicBlock *QFB,
4453 BasicBlock *PostBB, Value *Address, bool InvertPCond, bool InvertQCond,
4454 DomTreeUpdater *DTU, const DataLayout &DL, const TargetTransformInfo &TTI) {
4455 // For every pointer, there must be exactly two stores, one coming from
4456 // PTB or PFB, and the other from QTB or QFB. We don't support more than one
4457 // store (to any address) in PTB,PFB or QTB,QFB.
4458 // FIXME: We could relax this restriction with a bit more work and performance
4459 // testing.
4460 StoreInst *PStore = findUniqueStoreInBlocks(BB1: PTB, BB2: PFB);
4461 StoreInst *QStore = findUniqueStoreInBlocks(BB1: QTB, BB2: QFB);
4462 if (!PStore || !QStore)
4463 return false;
4464
4465 // Now check the stores are compatible.
4466 if (!QStore->isUnordered() || !PStore->isUnordered() ||
4467 PStore->getOrdering() != QStore->getOrdering() ||
4468 PStore->getSyncScopeID() != QStore->getSyncScopeID() ||
4469 PStore->getValueOperand()->getType() !=
4470 QStore->getValueOperand()->getType())
4471 return false;
4472
4473 // Check that sinking the store won't cause program behavior changes. Sinking
4474 // the store out of the Q blocks won't change any behavior as we're sinking
4475 // from a block to its unconditional successor. But we're moving a store from
4476 // the P blocks down through the middle block (QBI) and past both QFB and QTB.
4477 // So we need to check that there are no aliasing loads or stores in
4478 // QBI, QTB and QFB. We also need to check there are no conflicting memory
4479 // operations between PStore and the end of its parent block.
4480 //
4481 // The ideal way to do this is to query AliasAnalysis, but we don't
4482 // preserve AA currently so that is dangerous. Be super safe and just
4483 // check there are no other memory operations at all.
4484 for (auto &I : *QFB->getSinglePredecessor())
4485 if (I.mayReadOrWriteMemory())
4486 return false;
4487 for (auto &I : *QFB)
4488 if (&I != QStore && I.mayReadOrWriteMemory())
4489 return false;
4490 if (QTB)
4491 for (auto &I : *QTB)
4492 if (&I != QStore && I.mayReadOrWriteMemory())
4493 return false;
4494 for (auto I = BasicBlock::iterator(PStore), E = PStore->getParent()->end();
4495 I != E; ++I)
4496 if (&*I != PStore && I->mayReadOrWriteMemory())
4497 return false;
4498
4499 // If we're not in aggressive mode, we only optimize if we have some
4500 // confidence that by optimizing we'll allow P and/or Q to be if-converted.
4501 auto IsWorthwhile = [&](BasicBlock *BB, ArrayRef<StoreInst *> FreeStores) {
4502 if (!BB)
4503 return true;
4504 // Heuristic: if the block can be if-converted/phi-folded and the
4505 // instructions inside are all cheap (arithmetic/GEPs), it's worthwhile to
4506 // thread this store.
4507 InstructionCost Cost = 0;
4508 InstructionCost Budget =
4509 PHINodeFoldingThreshold * TargetTransformInfo::TCC_Basic;
4510 for (auto &I : *BB) {
4511 // Consider terminator instruction to be free.
4512 if (I.isTerminator())
4513 continue;
4514 // If this is one the stores that we want to speculate out of this BB,
4515 // then don't count it's cost, consider it to be free.
4516 if (auto *S = dyn_cast<StoreInst>(Val: &I))
4517 if (llvm::find(Range&: FreeStores, Val: S))
4518 continue;
4519 // Else, we have a white-list of instructions that we are ak speculating.
4520 if (!isa<BinaryOperator>(Val: I) && !isa<GetElementPtrInst>(Val: I))
4521 return false; // Not in white-list - not worthwhile folding.
4522 // And finally, if this is a non-free instruction that we are okay
4523 // speculating, ensure that we consider the speculation budget.
4524 Cost +=
4525 TTI.getInstructionCost(U: &I, CostKind: TargetTransformInfo::TCK_SizeAndLatency);
4526 if (Cost > Budget)
4527 return false; // Eagerly refuse to fold as soon as we're out of budget.
4528 }
4529 assert(Cost <= Budget &&
4530 "When we run out of budget we will eagerly return from within the "
4531 "per-instruction loop.");
4532 return true;
4533 };
4534
4535 const std::array<StoreInst *, 2> FreeStores = {PStore, QStore};
4536 if (!MergeCondStoresAggressively &&
4537 (!IsWorthwhile(PTB, FreeStores) || !IsWorthwhile(PFB, FreeStores) ||
4538 !IsWorthwhile(QTB, FreeStores) || !IsWorthwhile(QFB, FreeStores)))
4539 return false;
4540
4541 // If PostBB has more than two predecessors, we need to split it so we can
4542 // sink the store.
4543 if (std::next(x: pred_begin(BB: PostBB), n: 2) != pred_end(BB: PostBB)) {
4544 // We know that QFB's only successor is PostBB. And QFB has a single
4545 // predecessor. If QTB exists, then its only successor is also PostBB.
4546 // If QTB does not exist, then QFB's only predecessor has a conditional
4547 // branch to QFB and PostBB.
4548 BasicBlock *TruePred = QTB ? QTB : QFB->getSinglePredecessor();
4549 BasicBlock *NewBB =
4550 SplitBlockPredecessors(BB: PostBB, Preds: {QFB, TruePred}, Suffix: "condstore.split", DTU);
4551 if (!NewBB)
4552 return false;
4553 PostBB = NewBB;
4554 }
4555
4556 // OK, we're going to sink the stores to PostBB. The store has to be
4557 // conditional though, so first create the predicate.
4558 CondBrInst *PBranch =
4559 cast<CondBrInst>(Val: PFB->getSinglePredecessor()->getTerminator());
4560 CondBrInst *QBranch =
4561 cast<CondBrInst>(Val: QFB->getSinglePredecessor()->getTerminator());
4562 Value *PCond = PBranch->getCondition();
4563 Value *QCond = QBranch->getCondition();
4564
4565 Value *PPHI = ensureValueAvailableInSuccessor(V: PStore->getValueOperand(),
4566 BB: PStore->getParent());
4567 Value *QPHI = ensureValueAvailableInSuccessor(V: QStore->getValueOperand(),
4568 BB: QStore->getParent(), AlternativeV: PPHI);
4569
4570 IRBuilder<> QB(PostBB->getFirstInsertionPt());
4571
4572 InvertPCond ^= (PStore->getParent() != PTB);
4573 InvertQCond ^= (QStore->getParent() != QTB);
4574 Value *PPred = InvertPCond ? QB.CreateNot(V: PCond) : PCond;
4575 Value *QPred = InvertQCond ? QB.CreateNot(V: QCond) : QCond;
4576
4577 Value *CombinedPred = QB.CreateOr(LHS: PPred, RHS: QPred);
4578
4579 BasicBlock::iterator InsertPt = QB.GetInsertPoint();
4580 auto *T = SplitBlockAndInsertIfThen(Cond: CombinedPred, SplitBefore: InsertPt,
4581 /*Unreachable=*/false,
4582 /*BranchWeights=*/nullptr, DTU);
4583 if (hasBranchWeightMD(I: *PBranch) && hasBranchWeightMD(I: *QBranch)) {
4584 SmallVector<uint32_t, 2> PWeights, QWeights;
4585 extractBranchWeights(I: *PBranch, Weights&: PWeights);
4586 extractBranchWeights(I: *QBranch, Weights&: QWeights);
4587 if (InvertPCond)
4588 std::swap(a&: PWeights[0], b&: PWeights[1]);
4589 if (InvertQCond)
4590 std::swap(a&: QWeights[0], b&: QWeights[1]);
4591 auto CombinedWeights = getDisjunctionWeights(B1: PWeights, B2: QWeights);
4592 setFittedBranchWeights(I&: *PostBB->getTerminator(),
4593 Weights: {CombinedWeights[0], CombinedWeights[1]},
4594 /*IsExpected=*/false, /*ElideAllZero=*/true);
4595 }
4596
4597 QB.SetInsertPoint(T);
4598 StoreInst *SI = cast<StoreInst>(Val: QB.CreateStore(Val: QPHI, Ptr: Address));
4599 combineMetadataForCSE(K: QStore, J: PStore, DoesKMove: true);
4600 SI->copyMetadata(SrcInst: *QStore);
4601 // Update any dbg.assign intrinsics to track the merged value (QPHI) instead
4602 // of the original constant values, likely making these identical.
4603 for (auto *DbgAssign : at::getDVRAssignmentMarkers(Inst: SI)) {
4604 if (llvm::is_contained(Range: DbgAssign->location_ops(),
4605 Element: PStore->getValueOperand()))
4606 DbgAssign->replaceVariableLocationOp(OldValue: PStore->getValueOperand(), NewValue: QPHI);
4607 if (llvm::is_contained(Range: DbgAssign->location_ops(),
4608 Element: QStore->getValueOperand()))
4609 DbgAssign->replaceVariableLocationOp(OldValue: QStore->getValueOperand(), NewValue: QPHI);
4610 }
4611
4612 // Choose the minimum alignment. If we could prove both stores execute, we
4613 // could use biggest one. In this case, though, we only know that one of the
4614 // stores executes. And we don't know it's safe to take the alignment from a
4615 // store that doesn't execute.
4616 SI->setAlignment(std::min(a: PStore->getAlign(), b: QStore->getAlign()));
4617
4618 if (QStore->isAtomic())
4619 SI->setAtomic(Ordering: QStore->getOrdering(), SSID: QStore->getSyncScopeID());
4620
4621 QStore->eraseFromParent();
4622 PStore->eraseFromParent();
4623
4624 return true;
4625}
4626
4627static bool mergeConditionalStores(CondBrInst *PBI, CondBrInst *QBI,
4628 DomTreeUpdater *DTU, const DataLayout &DL,
4629 const TargetTransformInfo &TTI) {
4630 // The intention here is to find diamonds or triangles (see below) where each
4631 // conditional block contains a store to the same address. Both of these
4632 // stores are conditional, so they can't be unconditionally sunk. But it may
4633 // be profitable to speculatively sink the stores into one merged store at the
4634 // end, and predicate the merged store on the union of the two conditions of
4635 // PBI and QBI.
4636 //
4637 // This can reduce the number of stores executed if both of the conditions are
4638 // true, and can allow the blocks to become small enough to be if-converted.
4639 // This optimization will also chain, so that ladders of test-and-set
4640 // sequences can be if-converted away.
4641 //
4642 // We only deal with simple diamonds or triangles:
4643 //
4644 // PBI or PBI or a combination of the two
4645 // / \ | \
4646 // PTB PFB | PFB
4647 // \ / | /
4648 // QBI QBI
4649 // / \ | \
4650 // QTB QFB | QFB
4651 // \ / | /
4652 // PostBB PostBB
4653 //
4654 // We model triangles as a type of diamond with a nullptr "true" block.
4655 // Triangles are canonicalized so that the fallthrough edge is represented by
4656 // a true condition, as in the diagram above.
4657 BasicBlock *PTB = PBI->getSuccessor(i: 0);
4658 BasicBlock *PFB = PBI->getSuccessor(i: 1);
4659 BasicBlock *QTB = QBI->getSuccessor(i: 0);
4660 BasicBlock *QFB = QBI->getSuccessor(i: 1);
4661 BasicBlock *PostBB = QFB->getSingleSuccessor();
4662
4663 // Make sure we have a good guess for PostBB. If QTB's only successor is
4664 // QFB, then QFB is a better PostBB.
4665 if (QTB->getSingleSuccessor() == QFB)
4666 PostBB = QFB;
4667
4668 // If we couldn't find a good PostBB, stop.
4669 if (!PostBB)
4670 return false;
4671
4672 bool InvertPCond = false, InvertQCond = false;
4673 // Canonicalize fallthroughs to the true branches.
4674 if (PFB == QBI->getParent()) {
4675 std::swap(a&: PFB, b&: PTB);
4676 InvertPCond = true;
4677 }
4678 if (QFB == PostBB) {
4679 std::swap(a&: QFB, b&: QTB);
4680 InvertQCond = true;
4681 }
4682
4683 // From this point on we can assume PTB or QTB may be fallthroughs but PFB
4684 // and QFB may not. Model fallthroughs as a nullptr block.
4685 if (PTB == QBI->getParent())
4686 PTB = nullptr;
4687 if (QTB == PostBB)
4688 QTB = nullptr;
4689
4690 // Legality bailouts. We must have at least the non-fallthrough blocks and
4691 // the post-dominating block, and the non-fallthroughs must only have one
4692 // predecessor.
4693 auto HasOnePredAndOneSucc = [](BasicBlock *BB, BasicBlock *P, BasicBlock *S) {
4694 return BB->getSinglePredecessor() == P && BB->getSingleSuccessor() == S;
4695 };
4696 if (!HasOnePredAndOneSucc(PFB, PBI->getParent(), QBI->getParent()) ||
4697 !HasOnePredAndOneSucc(QFB, QBI->getParent(), PostBB))
4698 return false;
4699 if ((PTB && !HasOnePredAndOneSucc(PTB, PBI->getParent(), QBI->getParent())) ||
4700 (QTB && !HasOnePredAndOneSucc(QTB, QBI->getParent(), PostBB)))
4701 return false;
4702 if (!QBI->getParent()->hasNUses(N: 2))
4703 return false;
4704
4705 // OK, this is a sequence of two diamonds or triangles.
4706 // Check if there are stores in PTB or PFB that are repeated in QTB or QFB.
4707 SmallPtrSet<Value *, 4> PStoreAddresses, QStoreAddresses;
4708 for (auto *BB : {PTB, PFB}) {
4709 if (!BB)
4710 continue;
4711 for (auto &I : *BB)
4712 if (StoreInst *SI = dyn_cast<StoreInst>(Val: &I))
4713 PStoreAddresses.insert(Ptr: SI->getPointerOperand());
4714 }
4715 for (auto *BB : {QTB, QFB}) {
4716 if (!BB)
4717 continue;
4718 for (auto &I : *BB)
4719 if (StoreInst *SI = dyn_cast<StoreInst>(Val: &I))
4720 QStoreAddresses.insert(Ptr: SI->getPointerOperand());
4721 }
4722
4723 set_intersect(S1&: PStoreAddresses, S2: QStoreAddresses);
4724 // set_intersect mutates PStoreAddresses in place. Rename it here to make it
4725 // clear what it contains.
4726 auto &CommonAddresses = PStoreAddresses;
4727
4728 bool Changed = false;
4729 for (auto *Address : CommonAddresses)
4730 Changed |=
4731 mergeConditionalStoreToAddress(PTB, PFB, QTB, QFB, PostBB, Address,
4732 InvertPCond, InvertQCond, DTU, DL, TTI);
4733 return Changed;
4734}
4735
4736/// If the previous block ended with a widenable branch, determine if reusing
4737/// the target block is profitable and legal. This will have the effect of
4738/// "widening" PBI, but doesn't require us to reason about hosting safety.
4739static bool tryWidenCondBranchToCondBranch(CondBrInst *PBI, CondBrInst *BI,
4740 DomTreeUpdater *DTU) {
4741 // TODO: This can be generalized in two important ways:
4742 // 1) We can allow phi nodes in IfFalseBB and simply reuse all the input
4743 // values from the PBI edge.
4744 // 2) We can sink side effecting instructions into BI's fallthrough
4745 // successor provided they doesn't contribute to computation of
4746 // BI's condition.
4747 BasicBlock *IfTrueBB = PBI->getSuccessor(i: 0);
4748 BasicBlock *IfFalseBB = PBI->getSuccessor(i: 1);
4749 if (!isWidenableBranch(U: PBI) || IfTrueBB != BI->getParent() ||
4750 !BI->getParent()->getSinglePredecessor())
4751 return false;
4752 if (!IfFalseBB->phis().empty())
4753 return false; // TODO
4754 // This helps avoid infinite loop with SimplifyCondBranchToCondBranch which
4755 // may undo the transform done here.
4756 // TODO: There might be a more fine-grained solution to this.
4757 if (!llvm::succ_empty(BB: IfFalseBB))
4758 return false;
4759 // Use lambda to lazily compute expensive condition after cheap ones.
4760 auto NoSideEffects = [](BasicBlock &BB) {
4761 return llvm::none_of(Range&: BB, P: [](const Instruction &I) {
4762 return I.mayWriteToMemory() || I.mayHaveSideEffects();
4763 });
4764 };
4765 if (BI->getSuccessor(i: 1) != IfFalseBB && // no inf looping
4766 BI->getSuccessor(i: 1)->getTerminatingDeoptimizeCall() && // profitability
4767 NoSideEffects(*BI->getParent())) {
4768 auto *OldSuccessor = BI->getSuccessor(i: 1);
4769 OldSuccessor->removePredecessor(Pred: BI->getParent());
4770 BI->setSuccessor(idx: 1, NewSucc: IfFalseBB);
4771 if (DTU)
4772 DTU->applyUpdates(
4773 Updates: {{DominatorTree::Insert, BI->getParent(), IfFalseBB},
4774 {DominatorTree::Delete, BI->getParent(), OldSuccessor}});
4775 return true;
4776 }
4777 if (BI->getSuccessor(i: 0) != IfFalseBB && // no inf looping
4778 BI->getSuccessor(i: 0)->getTerminatingDeoptimizeCall() && // profitability
4779 NoSideEffects(*BI->getParent())) {
4780 auto *OldSuccessor = BI->getSuccessor(i: 0);
4781 OldSuccessor->removePredecessor(Pred: BI->getParent());
4782 BI->setSuccessor(idx: 0, NewSucc: IfFalseBB);
4783 if (DTU)
4784 DTU->applyUpdates(
4785 Updates: {{DominatorTree::Insert, BI->getParent(), IfFalseBB},
4786 {DominatorTree::Delete, BI->getParent(), OldSuccessor}});
4787 return true;
4788 }
4789 return false;
4790}
4791
4792/// If we have a conditional branch as a predecessor of another block,
4793/// this function tries to simplify it. We know
4794/// that PBI and BI are both conditional branches, and BI is in one of the
4795/// successor blocks of PBI - PBI branches to BI.
4796static bool SimplifyCondBranchToCondBranch(CondBrInst *PBI, CondBrInst *BI,
4797 DomTreeUpdater *DTU,
4798 const DataLayout &DL,
4799 const TargetTransformInfo &TTI) {
4800 BasicBlock *BB = BI->getParent();
4801
4802 // If this block ends with a branch instruction, and if there is a
4803 // predecessor that ends on a branch of the same condition, make
4804 // this conditional branch redundant.
4805 if (PBI->getCondition() == BI->getCondition() &&
4806 PBI->getSuccessor(i: 0) != PBI->getSuccessor(i: 1)) {
4807 // Okay, the outcome of this conditional branch is statically
4808 // knowable. If this block had a single pred, handle specially, otherwise
4809 // foldCondBranchOnValueKnownInPredecessor() will handle it.
4810 if (BB->getSinglePredecessor()) {
4811 // Turn this into a branch on constant.
4812 bool CondIsTrue = PBI->getSuccessor(i: 0) == BB;
4813 BI->setCondition(
4814 ConstantInt::get(Ty: Type::getInt1Ty(C&: BB->getContext()), V: CondIsTrue));
4815 return true; // Nuke the branch on constant.
4816 }
4817 }
4818
4819 // If the previous block ended with a widenable branch, determine if reusing
4820 // the target block is profitable and legal. This will have the effect of
4821 // "widening" PBI, but doesn't require us to reason about hosting safety.
4822 if (tryWidenCondBranchToCondBranch(PBI, BI, DTU))
4823 return true;
4824
4825 // If both branches are conditional and both contain stores to the same
4826 // address, remove the stores from the conditionals and create a conditional
4827 // merged store at the end.
4828 if (MergeCondStores && mergeConditionalStores(PBI, QBI: BI, DTU, DL, TTI))
4829 return true;
4830
4831 // If this is a conditional branch in an empty block, and if any
4832 // predecessors are a conditional branch to one of our destinations,
4833 // fold the conditions into logical ops and one cond br.
4834
4835 // Ignore dbg intrinsics.
4836 if (&*BB->begin() != BI)
4837 return false;
4838
4839 int PBIOp, BIOp;
4840 if (PBI->getSuccessor(i: 0) == BI->getSuccessor(i: 0)) {
4841 PBIOp = 0;
4842 BIOp = 0;
4843 } else if (PBI->getSuccessor(i: 0) == BI->getSuccessor(i: 1)) {
4844 PBIOp = 0;
4845 BIOp = 1;
4846 } else if (PBI->getSuccessor(i: 1) == BI->getSuccessor(i: 0)) {
4847 PBIOp = 1;
4848 BIOp = 0;
4849 } else if (PBI->getSuccessor(i: 1) == BI->getSuccessor(i: 1)) {
4850 PBIOp = 1;
4851 BIOp = 1;
4852 } else {
4853 return false;
4854 }
4855
4856 // Check to make sure that the other destination of this branch
4857 // isn't BB itself. If so, this is an infinite loop that will
4858 // keep getting unwound.
4859 if (PBI->getSuccessor(i: PBIOp) == BB)
4860 return false;
4861
4862 // If predecessor's branch probability to BB is too low don't merge branches.
4863 SmallVector<uint32_t, 2> PredWeights;
4864 if (!PBI->getMetadata(KindID: LLVMContext::MD_unpredictable) &&
4865 extractBranchWeights(I: *PBI, Weights&: PredWeights) &&
4866 (static_cast<uint64_t>(PredWeights[0]) + PredWeights[1]) != 0) {
4867
4868 BranchProbability CommonDestProb = BranchProbability::getBranchProbability(
4869 Numerator: PredWeights[PBIOp],
4870 Denominator: static_cast<uint64_t>(PredWeights[0]) + PredWeights[1]);
4871
4872 BranchProbability Likely = TTI.getPredictableBranchThreshold();
4873 if (CommonDestProb >= Likely)
4874 return false;
4875 }
4876
4877 // Do not perform this transformation if it would require
4878 // insertion of a large number of select instructions. For targets
4879 // without predication/cmovs, this is a big pessimization.
4880
4881 BasicBlock *CommonDest = PBI->getSuccessor(i: PBIOp);
4882 BasicBlock *RemovedDest = PBI->getSuccessor(i: PBIOp ^ 1);
4883 unsigned NumPhis = 0;
4884 for (BasicBlock::iterator II = CommonDest->begin(); isa<PHINode>(Val: II);
4885 ++II, ++NumPhis) {
4886 if (NumPhis > 2) // Disable this xform.
4887 return false;
4888 }
4889
4890 // Finally, if everything is ok, fold the branches to logical ops.
4891 BasicBlock *OtherDest = BI->getSuccessor(i: BIOp ^ 1);
4892
4893 LLVM_DEBUG(dbgs() << "FOLDING BRs:" << *PBI->getParent()
4894 << "AND: " << *BI->getParent());
4895
4896 SmallVector<DominatorTree::UpdateType, 5> Updates;
4897
4898 // If OtherDest *is* BB, then BB is a basic block with a single conditional
4899 // branch in it, where one edge (OtherDest) goes back to itself but the other
4900 // exits. We don't *know* that the program avoids the infinite loop
4901 // (even though that seems likely). If we do this xform naively, we'll end up
4902 // recursively unpeeling the loop. Since we know that (after the xform is
4903 // done) that the block *is* infinite if reached, we just make it an obviously
4904 // infinite loop with no cond branch.
4905 if (OtherDest == BB) {
4906 // Insert it at the end of the function, because it's either code,
4907 // or it won't matter if it's hot. :)
4908 BasicBlock *InfLoopBlock =
4909 BasicBlock::Create(Context&: BB->getContext(), Name: "infloop", Parent: BB->getParent());
4910 UncondBrInst::Create(Target: InfLoopBlock, InsertBefore: InfLoopBlock);
4911 if (DTU)
4912 Updates.push_back(Elt: {DominatorTree::Insert, InfLoopBlock, InfLoopBlock});
4913 OtherDest = InfLoopBlock;
4914 }
4915
4916 LLVM_DEBUG(dbgs() << *PBI->getParent()->getParent());
4917
4918 // BI may have other predecessors. Because of this, we leave
4919 // it alone, but modify PBI.
4920
4921 // Make sure we get to CommonDest on True&True directions.
4922 Value *PBICond = PBI->getCondition();
4923 IRBuilder<NoFolder> Builder(PBI);
4924 if (PBIOp)
4925 PBICond = Builder.CreateNot(V: PBICond, Name: PBICond->getName() + ".not");
4926
4927 Value *BICond = BI->getCondition();
4928 if (BIOp)
4929 BICond = Builder.CreateNot(V: BICond, Name: BICond->getName() + ".not");
4930
4931 // Merge the conditions.
4932 Value *Cond =
4933 createLogicalOp(Builder, Opc: Instruction::Or, LHS: PBICond, RHS: BICond, Name: "brmerge");
4934
4935 // Modify PBI to branch on the new condition to the new dests.
4936 PBI->setCondition(Cond);
4937 PBI->setSuccessor(idx: 0, NewSucc: CommonDest);
4938 PBI->setSuccessor(idx: 1, NewSucc: OtherDest);
4939
4940 if (DTU) {
4941 Updates.push_back(Elt: {DominatorTree::Insert, PBI->getParent(), OtherDest});
4942 Updates.push_back(Elt: {DominatorTree::Delete, PBI->getParent(), RemovedDest});
4943
4944 DTU->applyUpdates(Updates);
4945 }
4946
4947 // Update branch weight for PBI.
4948 uint64_t PredTrueWeight, PredFalseWeight, SuccTrueWeight, SuccFalseWeight;
4949 uint64_t PredCommon, PredOther, SuccCommon, SuccOther;
4950 bool HasWeights =
4951 extractPredSuccWeights(PBI, BI, PredTrueWeight, PredFalseWeight,
4952 SuccTrueWeight, SuccFalseWeight);
4953 if (HasWeights) {
4954 PredCommon = PBIOp ? PredFalseWeight : PredTrueWeight;
4955 PredOther = PBIOp ? PredTrueWeight : PredFalseWeight;
4956 SuccCommon = BIOp ? SuccFalseWeight : SuccTrueWeight;
4957 SuccOther = BIOp ? SuccTrueWeight : SuccFalseWeight;
4958 // The weight to CommonDest should be PredCommon * SuccTotal +
4959 // PredOther * SuccCommon.
4960 // The weight to OtherDest should be PredOther * SuccOther.
4961 uint64_t NewWeights[2] = {PredCommon * (SuccCommon + SuccOther) +
4962 PredOther * SuccCommon,
4963 PredOther * SuccOther};
4964
4965 setFittedBranchWeights(I&: *PBI, Weights: NewWeights, /*IsExpected=*/false,
4966 /*ElideAllZero=*/true);
4967 // Cond may be a select instruction with the first operand set to "true", or
4968 // the second to "false" (see how createLogicalOp works for `and` and `or`)
4969 if (auto *SI = dyn_cast<SelectInst>(Val: Cond)) {
4970 assert(isSelectInRoleOfConjunctionOrDisjunction(SI));
4971 // The select is predicated on PBICond
4972 assert(SI->getCondition() == PBICond);
4973 // The corresponding probabilities are what was referred to above as
4974 // PredCommon and PredOther.
4975 setFittedBranchWeights(I&: *SI, Weights: {PredCommon, PredOther},
4976 /*IsExpected=*/false, /*ElideAllZero=*/true);
4977 }
4978 }
4979
4980 // OtherDest may have phi nodes. If so, add an entry from PBI's
4981 // block that are identical to the entries for BI's block.
4982 addPredecessorToBlock(Succ: OtherDest, NewPred: PBI->getParent(), ExistPred: BB);
4983
4984 // We know that the CommonDest already had an edge from PBI to
4985 // it. If it has PHIs though, the PHIs may have different
4986 // entries for BB and PBI's BB. If so, insert a select to make
4987 // them agree.
4988 for (PHINode &PN : CommonDest->phis()) {
4989 Value *BIV = PN.getIncomingValueForBlock(BB);
4990 unsigned PBBIdx = PN.getBasicBlockIndex(BB: PBI->getParent());
4991 Value *PBIV = PN.getIncomingValue(i: PBBIdx);
4992 if (BIV != PBIV) {
4993 // Insert a select in PBI to pick the right value.
4994 SelectInst *NV = cast<SelectInst>(
4995 Val: Builder.CreateSelect(C: PBICond, True: PBIV, False: BIV, Name: PBIV->getName() + ".mux"));
4996 PN.setIncomingValue(i: PBBIdx, V: NV);
4997 // The select has the same condition as PBI, in the same BB. The
4998 // probabilities don't change.
4999 if (HasWeights) {
5000 uint64_t TrueWeight = PBIOp ? PredFalseWeight : PredTrueWeight;
5001 uint64_t FalseWeight = PBIOp ? PredTrueWeight : PredFalseWeight;
5002 setFittedBranchWeights(I&: *NV, Weights: {TrueWeight, FalseWeight},
5003 /*IsExpected=*/false, /*ElideAllZero=*/true);
5004 }
5005 }
5006 }
5007
5008 LLVM_DEBUG(dbgs() << "INTO: " << *PBI->getParent());
5009 LLVM_DEBUG(dbgs() << *PBI->getParent()->getParent());
5010
5011 // This basic block is probably dead. We know it has at least
5012 // one fewer predecessor.
5013 return true;
5014}
5015
5016// Simplifies a terminator by replacing it with a branch to TrueBB if Cond is
5017// true or to FalseBB if Cond is false.
5018// Takes care of updating the successors and removing the old terminator.
5019// Also makes sure not to introduce new successors by assuming that edges to
5020// non-successor TrueBBs and FalseBBs aren't reachable.
5021bool SimplifyCFGOpt::simplifyTerminatorOnSelect(Instruction *OldTerm,
5022 Value *Cond, BasicBlock *TrueBB,
5023 BasicBlock *FalseBB,
5024 uint32_t TrueWeight,
5025 uint32_t FalseWeight) {
5026 auto *BB = OldTerm->getParent();
5027 // Remove any superfluous successor edges from the CFG.
5028 // First, figure out which successors to preserve.
5029 // If TrueBB and FalseBB are equal, only try to preserve one copy of that
5030 // successor.
5031 BasicBlock *KeepEdge1 = TrueBB;
5032 BasicBlock *KeepEdge2 = TrueBB != FalseBB ? FalseBB : nullptr;
5033
5034 SmallSetVector<BasicBlock *, 2> RemovedSuccessors;
5035
5036 // Then remove the rest.
5037 for (BasicBlock *Succ : successors(I: OldTerm)) {
5038 // Make sure only to keep exactly one copy of each edge.
5039 if (Succ == KeepEdge1)
5040 KeepEdge1 = nullptr;
5041 else if (Succ == KeepEdge2)
5042 KeepEdge2 = nullptr;
5043 else {
5044 Succ->removePredecessor(Pred: BB,
5045 /*KeepOneInputPHIs=*/true);
5046
5047 if (Succ != TrueBB && Succ != FalseBB)
5048 RemovedSuccessors.insert(X: Succ);
5049 }
5050 }
5051
5052 IRBuilder<> Builder(OldTerm);
5053 Builder.SetCurrentDebugLocation(OldTerm->getDebugLoc());
5054
5055 // Insert an appropriate new terminator.
5056 if (!KeepEdge1 && !KeepEdge2) {
5057 if (TrueBB == FalseBB) {
5058 // We were only looking for one successor, and it was present.
5059 // Create an unconditional branch to it.
5060 Builder.CreateBr(Dest: TrueBB);
5061 } else {
5062 // We found both of the successors we were looking for.
5063 // Create a conditional branch sharing the condition of the select.
5064 CondBrInst *NewBI = Builder.CreateCondBr(Cond, True: TrueBB, False: FalseBB);
5065 setBranchWeights(I&: *NewBI, Weights: {TrueWeight, FalseWeight},
5066 /*IsExpected=*/false, /*ElideAllZero=*/true);
5067 }
5068 } else if (KeepEdge1 && (KeepEdge2 || TrueBB == FalseBB)) {
5069 // Neither of the selected blocks were successors, so this
5070 // terminator must be unreachable.
5071 new UnreachableInst(OldTerm->getContext(), OldTerm->getIterator());
5072 } else {
5073 // One of the selected values was a successor, but the other wasn't.
5074 // Insert an unconditional branch to the one that was found;
5075 // the edge to the one that wasn't must be unreachable.
5076 if (!KeepEdge1) {
5077 // Only TrueBB was found.
5078 Builder.CreateBr(Dest: TrueBB);
5079 } else {
5080 // Only FalseBB was found.
5081 Builder.CreateBr(Dest: FalseBB);
5082 }
5083 }
5084
5085 eraseTerminatorAndDCECond(TI: OldTerm);
5086
5087 if (DTU) {
5088 SmallVector<DominatorTree::UpdateType, 2> Updates;
5089 Updates.reserve(N: RemovedSuccessors.size());
5090 for (auto *RemovedSuccessor : RemovedSuccessors)
5091 Updates.push_back(Elt: {DominatorTree::Delete, BB, RemovedSuccessor});
5092 DTU->applyUpdates(Updates);
5093 }
5094
5095 return true;
5096}
5097
5098// Folds switch(select(icmp eq X, C, K, X)) into switch(X), retargeting
5099// (or adding) the case for C to wherever K currently dispatches to:
5100// %cmp = icmp eq T %x, C
5101// %key = select i1 %cmp, T K, T %x
5102// switch T %key, label %default [ T K, label %case_k ... ]
5103// becomes
5104// switch T %x, label %default [ T C, label %case_k
5105// T K, label %case_k ... ]
5106bool SimplifyCFGOpt::simplifySwitchOnSelectRemap(SwitchInst *SI,
5107 SelectInst *Select, Value *X,
5108 ConstantInt *C, bool Negate) {
5109 Value *TrueVal = Select->getTrueValue();
5110 Value *FalseVal = Select->getFalseValue();
5111 if (Negate)
5112 std::swap(a&: TrueVal, b&: FalseVal);
5113 if (FalseVal != X)
5114 return false;
5115 auto *K = dyn_cast<ConstantInt>(Val: TrueVal);
5116 if (!K)
5117 return false;
5118
5119 BasicBlock *DestFork = SI->findCaseValue(C: K)->getCaseSuccessor();
5120 auto CaseC = SI->findCaseValue(C);
5121 bool IsDefault = CaseC == SI->case_default();
5122 // Save before setSuccessor()/addCase() change it.
5123 BasicBlock *OldDest = CaseC->getCaseSuccessor();
5124 BasicBlock *BB = SI->getParent();
5125
5126 // Switch on X first: removePredecessor() below may fold X away if it is a
5127 // PHI in OldDest, and the RAUW must update the switch condition too.
5128 SI->setCondition(X);
5129
5130 if (OldDest != DestFork) {
5131 if (!IsDefault)
5132 OldDest->removePredecessor(Pred: BB);
5133 if (IsDefault)
5134 SI->addCase(OnVal: C, Dest: DestFork);
5135 else
5136 CaseC->setSuccessor(DestFork);
5137 // Not a new edge (BB->DestFork exists via K), just adding the PHI
5138 // entry.
5139 addPredecessorToBlock(Succ: DestFork, NewPred: BB, ExistPred: BB);
5140
5141 if (!IsDefault) {
5142 // Edge to OldDest is gone only if nothing else still uses it.
5143 bool OldDestStillTargeted = any_of(
5144 Range: successors(I: SI), P: [&](BasicBlock *Succ) { return Succ == OldDest; });
5145 if (DTU && !OldDestStillTargeted)
5146 DTU->applyUpdates(Updates: {{DominatorTree::Delete, BB, OldDest}});
5147 }
5148
5149 // Update the profile information on the switch if we had a profile
5150 // for both it and the select instruction.
5151 SmallVector<uint32_t> SwitchWeights;
5152 bool SwitchHasBranchWeights = extractBranchWeights(I: *SI, Weights&: SwitchWeights);
5153 // If we add a case, ensure the length of the branch weights list matches
5154 // to make iterating over them easier later.
5155 if (IsDefault)
5156 SwitchWeights.push_back(Elt: 0);
5157 uint64_t SelectTrueWeight;
5158 uint64_t SelectFalseWeight;
5159 bool SelectHasBranchWeights =
5160 extractBranchWeights(I: *Select, TrueVal&: SelectTrueWeight, FalseVal&: SelectFalseWeight);
5161 uint64_t SelectTotalWeight = SelectTrueWeight + SelectFalseWeight;
5162 if (Negate)
5163 std::swap(a&: SelectTrueWeight, b&: SelectFalseWeight);
5164 if (SwitchHasBranchWeights && SelectHasBranchWeights &&
5165 !ProfcheckDisableMetadataFixes) {
5166 // We update the branch weights by subtracting P(x=C) from the probability
5167 // of case K in the switch (what C redirect to before the transformation),
5168 // plugging the probability for case C into the switch (which we derive
5169 // from the select), and ensuring everything is scaled to have a common
5170 // denominator.
5171 uint64_t SwitchTotalWeight = sum_of(Range&: SwitchWeights, Init: uint64_t{0});
5172 SmallVector<uint64_t> NewSwitchWeights;
5173 NewSwitchWeights.reserve(N: SwitchWeights.size());
5174 NewSwitchWeights.push_back(Elt: SwitchWeights[0] * SelectTotalWeight);
5175 for (const auto &[SwitchCase, SwitchWeight] :
5176 zip(t: SI->cases(), u: drop_begin(RangeOrContainer&: SwitchWeights))) {
5177 if (SwitchCase.getCaseValue() == C) {
5178 NewSwitchWeights.push_back(Elt: SwitchTotalWeight * SelectTrueWeight);
5179 } else if (SwitchCase.getCaseValue() == K) {
5180 // In reality, P(key=K) > P(x=C) should always hold, but explicitly
5181 // guard against bad profiles here to prevent underflow by saturating
5182 // to zero.
5183 uint64_t ProbabilityKeyEqualsK = SwitchWeight * SelectTotalWeight;
5184 uint64_t ProbabilityXEqualsC = SelectTrueWeight * SwitchTotalWeight;
5185 uint64_t ProbabilityXEqualsK =
5186 ProbabilityKeyEqualsK > ProbabilityXEqualsC
5187 ? ProbabilityKeyEqualsK - ProbabilityXEqualsC
5188 : 0;
5189 NewSwitchWeights.push_back(Elt: ProbabilityXEqualsK);
5190 } else {
5191 NewSwitchWeights.push_back(Elt: SwitchWeight * SelectTotalWeight);
5192 }
5193 }
5194 setFittedBranchWeights(I&: *SI, Weights: NewSwitchWeights, /*IsExpected=*/false);
5195 } else if (SwitchHasBranchWeights) {
5196 // If we only have branch weights on the switch, we cannot reconstruct
5197 // branch weights correctly, so mark them as unknown if the function has
5198 // a profile count. Reset the branch weights first to ensure we remove
5199 // the now invalid branch weights if the function is not otherwise
5200 // profiled.
5201 SI->setMetadata(KindID: LLVMContext::MD_prof, Node: nullptr);
5202 setExplicitlyUnknownBranchWeightsIfProfiled(I&: *SI, DEBUG_TYPE);
5203 }
5204 }
5205
5206 // The compare/select are now dead.
5207 RecursivelyDeleteTriviallyDeadInstructions(V: Select);
5208 return true;
5209}
5210
5211// Replaces
5212// (switch (select cond, X, Y)) on constant X, Y
5213// with a branch - conditional if X and Y lead to distinct BBs,
5214// unconditional otherwise.
5215bool SimplifyCFGOpt::simplifySwitchOnSelect(SwitchInst *SI,
5216 SelectInst *Select) {
5217 CmpPredicate Pred;
5218 Value *X;
5219 ConstantInt *C;
5220 if (Select->hasOneUse() &&
5221 match(V: Select->getCondition(),
5222 P: m_ICmp(Pred, L: m_Value(V&: X), R: m_ConstantInt(CI&: C))) &&
5223 ICmpInst::isEquality(P: Pred) &&
5224 simplifySwitchOnSelectRemap(SI, Select, X, C, Negate: Pred == ICmpInst::ICMP_NE))
5225 return true;
5226
5227 // Check for constant integer values in the select.
5228 ConstantInt *TrueVal = dyn_cast<ConstantInt>(Val: Select->getTrueValue());
5229 ConstantInt *FalseVal = dyn_cast<ConstantInt>(Val: Select->getFalseValue());
5230 if (!TrueVal || !FalseVal)
5231 return false;
5232
5233 // Find the relevant condition and destinations.
5234 Value *Condition = Select->getCondition();
5235 BasicBlock *TrueBB = SI->findCaseValue(C: TrueVal)->getCaseSuccessor();
5236 BasicBlock *FalseBB = SI->findCaseValue(C: FalseVal)->getCaseSuccessor();
5237
5238 // Get weight for TrueBB and FalseBB.
5239 uint32_t TrueWeight = 0, FalseWeight = 0;
5240 SmallVector<uint64_t, 8> Weights;
5241 bool HasWeights = hasBranchWeightMD(I: *SI);
5242 if (HasWeights) {
5243 getBranchWeights(TI: SI, Weights);
5244 if (Weights.size() == 1 + SI->getNumCases()) {
5245 TrueWeight =
5246 (uint32_t)Weights[SI->findCaseValue(C: TrueVal)->getSuccessorIndex()];
5247 FalseWeight =
5248 (uint32_t)Weights[SI->findCaseValue(C: FalseVal)->getSuccessorIndex()];
5249 }
5250 }
5251
5252 // Perform the actual simplification.
5253 return simplifyTerminatorOnSelect(OldTerm: SI, Cond: Condition, TrueBB, FalseBB, TrueWeight,
5254 FalseWeight);
5255}
5256
5257// Replaces
5258// (indirectbr (select cond, blockaddress(@fn, BlockA),
5259// blockaddress(@fn, BlockB)))
5260// with
5261// (br cond, BlockA, BlockB).
5262bool SimplifyCFGOpt::simplifyIndirectBrOnSelect(IndirectBrInst *IBI,
5263 SelectInst *SI) {
5264 // Check that both operands of the select are block addresses.
5265 BlockAddress *TBA = dyn_cast<BlockAddress>(Val: SI->getTrueValue());
5266 BlockAddress *FBA = dyn_cast<BlockAddress>(Val: SI->getFalseValue());
5267 if (!TBA || !FBA)
5268 return false;
5269
5270 // Extract the actual blocks.
5271 BasicBlock *TrueBB = TBA->getBasicBlock();
5272 BasicBlock *FalseBB = FBA->getBasicBlock();
5273
5274 // The select's profile becomes the profile of the conditional branch that
5275 // replaces the indirect branch.
5276 SmallVector<uint32_t> SelectBranchWeights(2);
5277 extractBranchWeights(I: *SI, Weights&: SelectBranchWeights);
5278 // Perform the actual simplification.
5279 return simplifyTerminatorOnSelect(OldTerm: IBI, Cond: SI->getCondition(), TrueBB, FalseBB,
5280 TrueWeight: SelectBranchWeights[0],
5281 FalseWeight: SelectBranchWeights[1]);
5282}
5283
5284/// This is called when we find an icmp instruction
5285/// (a seteq/setne with a constant) as the only instruction in a
5286/// block that ends with an uncond branch. We are looking for a very specific
5287/// pattern that occurs when "A == 1 || A == 2 || A == 3" gets simplified. In
5288/// this case, we merge the first two "or's of icmp" into a switch, but then the
5289/// default value goes to an uncond block with a seteq in it, we get something
5290/// like:
5291///
5292/// switch i8 %A, label %DEFAULT [ i8 1, label %end i8 2, label %end ]
5293/// DEFAULT:
5294/// %tmp = icmp eq i8 %A, 92
5295/// br label %end
5296/// end:
5297/// ... = phi i1 [ true, %entry ], [ %tmp, %DEFAULT ], [ true, %entry ]
5298///
5299/// We prefer to split the edge to 'end' so that there is a true/false entry to
5300/// the PHI, merging the third icmp into the switch.
5301bool SimplifyCFGOpt::tryToSimplifyUncondBranchWithICmpInIt(
5302 ICmpInst *ICI, IRBuilder<> &Builder) {
5303 // Select == nullptr means we assume that there is a hidden no-op select
5304 // instruction of `_ = select %icmp, true, false` after `%icmp = icmp ...`
5305 return tryToSimplifyUncondBranchWithICmpSelectInIt(ICI, Select: nullptr, Builder);
5306}
5307
5308/// Similar to tryToSimplifyUncondBranchWithICmpInIt, but handle a more generic
5309/// case. This is called when we find an icmp instruction (a seteq/setne with a
5310/// constant) and its following select instruction as the only TWO instructions
5311/// in a block that ends with an uncond branch. We are looking for a very
5312/// specific pattern that occurs when "
5313/// if (A == 1) return C1;
5314/// if (A == 2) return C2;
5315/// if (A < 3) return C3;
5316/// return C4;
5317/// " gets simplified. In this case, we merge the first two "branches of icmp"
5318/// into a switch, but then the default value goes to an uncond block with a lt
5319/// icmp and select in it, as InstCombine can not simplify "A < 3" as "A == 2".
5320/// After SimplifyCFG and other subsequent optimizations (e.g., SCCP), we might
5321/// get something like:
5322///
5323/// case1:
5324/// switch i8 %A, label %DEFAULT [ i8 0, label %end i8 1, label %case2 ]
5325/// case2:
5326/// br label %end
5327/// DEFAULT:
5328/// %tmp = icmp eq i8 %A, 2
5329/// %val = select i1 %tmp, i8 C3, i8 C4
5330/// br label %end
5331/// end:
5332/// _ = phi i8 [ C1, %case1 ], [ C2, %case2 ], [ %val, %DEFAULT ]
5333///
5334/// We prefer to split the edge to 'end' so that there are TWO entries of V3/V4
5335/// to the PHI, merging the icmp & select into the switch, as follows:
5336///
5337/// case1:
5338/// switch i8 %A, label %DEFAULT [
5339/// i8 0, label %end
5340/// i8 1, label %case2
5341/// i8 2, label %case3
5342/// ]
5343/// case2:
5344/// br label %end
5345/// case3:
5346/// br label %end
5347/// DEFAULT:
5348/// br label %end
5349/// end:
5350/// _ = phi i8 [ C1, %case1 ], [ C2, %case2 ], [ C3, %case2 ], [ C4, %DEFAULT]
5351bool SimplifyCFGOpt::tryToSimplifyUncondBranchWithICmpSelectInIt(
5352 ICmpInst *ICI, SelectInst *Select, IRBuilder<> &Builder) {
5353 BasicBlock *BB = ICI->getParent();
5354
5355 // If the block has any PHIs in it or the icmp/select has multiple uses, it is
5356 // too complex.
5357 /// TODO: support multi-phis in succ BB of select's BB.
5358 if (isa<PHINode>(Val: BB->begin()) || !ICI->hasOneUse() ||
5359 (Select && !Select->hasOneUse()))
5360 return false;
5361
5362 // The pattern we're looking for is where our only predecessor is a switch on
5363 // 'V' and this block is the default case for the switch. In this case we can
5364 // fold the compared value into the switch to simplify things.
5365 BasicBlock *Pred = BB->getSinglePredecessor();
5366 if (!Pred || !isa<SwitchInst>(Val: Pred->getTerminator()))
5367 return false;
5368
5369 Value *IcmpCond;
5370 ConstantInt *NewCaseVal;
5371 CmpPredicate Predicate;
5372
5373 // Match icmp X, C
5374 if (!match(V: ICI,
5375 P: m_ICmp(Pred&: Predicate, L: m_Value(V&: IcmpCond), R: m_ConstantInt(CI&: NewCaseVal))))
5376 return false;
5377
5378 Value *SelectCond, *SelectTrueVal, *SelectFalseVal;
5379 Instruction *User;
5380 if (!Select) {
5381 // If Select == nullptr, we can assume that there is a hidden no-op select
5382 // just after icmp
5383 SelectCond = ICI;
5384 SelectTrueVal = Builder.getTrue();
5385 SelectFalseVal = Builder.getFalse();
5386 User = ICI->user_back();
5387 } else {
5388 SelectCond = Select->getCondition();
5389 // Check if the select condition is the same as the icmp condition.
5390 if (SelectCond != ICI)
5391 return false;
5392 SelectTrueVal = Select->getTrueValue();
5393 SelectFalseVal = Select->getFalseValue();
5394 User = Select->user_back();
5395 }
5396
5397 SwitchInst *SI = cast<SwitchInst>(Val: Pred->getTerminator());
5398 if (SI->getCondition() != IcmpCond)
5399 return false;
5400
5401 // If BB is reachable on a non-default case, then we simply know the value of
5402 // V in this block. Substitute it and constant fold the icmp instruction
5403 // away.
5404 if (SI->getDefaultDest() != BB) {
5405 ConstantInt *VVal = SI->findCaseDest(BB);
5406 assert(VVal && "Should have a unique destination value");
5407 ICI->setOperand(i_nocapture: 0, Val_nocapture: VVal);
5408
5409 if (Value *V = simplifyInstruction(I: ICI, Q: {DL, ICI})) {
5410 ICI->replaceAllUsesWith(V);
5411 ICI->eraseFromParent();
5412 }
5413 // BB is now empty, so it is likely to simplify away.
5414 return requestResimplify();
5415 }
5416
5417 // Ok, the block is reachable from the default dest. If the constant we're
5418 // comparing exists in one of the other edges, then we can constant fold ICI
5419 // and zap it.
5420 if (SI->findCaseValue(C: NewCaseVal) != SI->case_default()) {
5421 Value *V;
5422 if (Predicate == ICmpInst::ICMP_EQ)
5423 V = ConstantInt::getFalse(Context&: BB->getContext());
5424 else
5425 V = ConstantInt::getTrue(Context&: BB->getContext());
5426
5427 ICI->replaceAllUsesWith(V);
5428 ICI->eraseFromParent();
5429 // BB is now empty, so it is likely to simplify away.
5430 return requestResimplify();
5431 }
5432
5433 // The use of the select has to be in the 'end' block, by the only PHI node in
5434 // the block.
5435 BasicBlock *SuccBlock = BB->getTerminator()->getSuccessor(Idx: 0);
5436 PHINode *PHIUse = dyn_cast<PHINode>(Val: User);
5437 if (PHIUse == nullptr || PHIUse != &SuccBlock->front() ||
5438 isa<PHINode>(Val: ++BasicBlock::iterator(PHIUse)))
5439 return false;
5440
5441 // If the icmp is a SETEQ, then the default dest gets SelectFalseVal, the new
5442 // edge gets SelectTrueVal in the PHI.
5443 Value *DefaultCst = SelectFalseVal;
5444 Value *NewCst = SelectTrueVal;
5445
5446 if (ICI->getPredicate() == ICmpInst::ICMP_NE)
5447 std::swap(a&: DefaultCst, b&: NewCst);
5448
5449 // Replace Select (which is used by the PHI for the default value) with
5450 // SelectFalseVal or SelectTrueVal depending on if ICI is EQ or NE.
5451 if (Select) {
5452 Select->replaceAllUsesWith(V: DefaultCst);
5453 Select->eraseFromParent();
5454 } else {
5455 ICI->replaceAllUsesWith(V: DefaultCst);
5456 }
5457 ICI->eraseFromParent();
5458
5459 SmallVector<DominatorTree::UpdateType, 2> Updates;
5460
5461 // Okay, the switch goes to this block on a default value. Add an edge from
5462 // the switch to the merge point on the compared value.
5463 BasicBlock *NewBB =
5464 BasicBlock::Create(Context&: BB->getContext(), Name: "switch.edge", Parent: BB->getParent(), InsertBefore: BB);
5465 {
5466 SwitchInstProfUpdateWrapper SIW(*SI);
5467 auto W0 = SIW.getSuccessorWeight(idx: 0);
5468 SwitchInstProfUpdateWrapper::CaseWeightOpt NewW;
5469 if (W0) {
5470 NewW = ((uint64_t(*W0) + 1) >> 1);
5471 SIW.setSuccessorWeight(idx: 0, W: *NewW);
5472 }
5473 SIW.addCase(OnVal: NewCaseVal, Dest: NewBB, W: NewW);
5474 if (DTU)
5475 Updates.push_back(Elt: {DominatorTree::Insert, Pred, NewBB});
5476 }
5477
5478 // NewBB branches to the phi block, add the uncond branch and the phi entry.
5479 Builder.SetInsertPoint(NewBB);
5480 Builder.SetCurrentDebugLocation(SI->getDebugLoc());
5481 Builder.CreateBr(Dest: SuccBlock);
5482 PHIUse->addIncoming(V: NewCst, BB: NewBB);
5483 if (DTU) {
5484 Updates.push_back(Elt: {DominatorTree::Insert, NewBB, SuccBlock});
5485 DTU->applyUpdates(Updates);
5486 }
5487 return true;
5488}
5489
5490/// Check to see if it is branching on an or/and chain of icmp instructions, and
5491/// fold it into a switch instruction if so.
5492bool SimplifyCFGOpt::simplifyBranchOnICmpChain(CondBrInst *BI,
5493 IRBuilder<> &Builder,
5494 const DataLayout &DL) {
5495 Instruction *Cond = dyn_cast<Instruction>(Val: BI->getCondition());
5496 if (!Cond)
5497 return false;
5498
5499 // Change br (X == 0 | X == 1), T, F into a switch instruction.
5500 // If this is a bunch of seteq's or'd together, or if it's a bunch of
5501 // 'setne's and'ed together, collect them.
5502
5503 // Try to gather values from a chain of and/or to be turned into a switch
5504 ConstantComparesGatherer ConstantCompare(Cond, DL);
5505 // Unpack the result
5506 SmallVectorImpl<ConstantInt *> &Values = ConstantCompare.Vals;
5507 Value *CompVal = ConstantCompare.CompValue;
5508 unsigned UsedICmps = ConstantCompare.UsedICmps;
5509 Value *ExtraCase = ConstantCompare.Extra;
5510 bool TrueWhenEqual = ConstantCompare.IsEq;
5511
5512 // If we didn't have a multiply compared value, fail.
5513 if (!CompVal)
5514 return false;
5515
5516 // Avoid turning single icmps into a switch.
5517 if (UsedICmps <= 1)
5518 return false;
5519
5520 // There might be duplicate constants in the list, which the switch
5521 // instruction can't handle, remove them now.
5522 array_pod_sort(Start: Values.begin(), End: Values.end(), Compare: constantIntSortPredicate);
5523 Values.erase(CS: llvm::unique(R&: Values), CE: Values.end());
5524
5525 // If Extra was used, we require at least two switch values to do the
5526 // transformation. A switch with one value is just a conditional branch.
5527 if (ExtraCase && Values.size() < 2)
5528 return false;
5529
5530 SmallVector<uint32_t> BranchWeights;
5531 const bool HasProfile = extractBranchWeights(I: *BI, Weights&: BranchWeights);
5532
5533 // Figure out which block is which destination.
5534 BasicBlock *DefaultBB = BI->getSuccessor(i: 1);
5535 BasicBlock *EdgeBB = BI->getSuccessor(i: 0);
5536 if (!TrueWhenEqual) {
5537 std::swap(a&: DefaultBB, b&: EdgeBB);
5538 if (HasProfile)
5539 std::swap(a&: BranchWeights[0], b&: BranchWeights[1]);
5540 }
5541
5542 BasicBlock *BB = BI->getParent();
5543
5544 LLVM_DEBUG(dbgs() << "Converting 'icmp' chain with " << Values.size()
5545 << " cases into SWITCH. BB is:\n"
5546 << *BB);
5547
5548 SmallVector<DominatorTree::UpdateType, 2> Updates;
5549
5550 // If there are any extra values that couldn't be folded into the switch
5551 // then we evaluate them with an explicit branch first. Split the block
5552 // right before the condbr to handle it.
5553 if (ExtraCase) {
5554 BasicBlock *NewBB = SplitBlock(Old: BB, SplitPt: BI, DTU, /*LI=*/nullptr,
5555 /*MSSAU=*/nullptr, BBName: "switch.early.test");
5556
5557 // Remove the uncond branch added to the old block.
5558 Instruction *OldTI = BB->getTerminator();
5559 Builder.SetInsertPoint(OldTI);
5560
5561 // There can be an unintended UB if extra values are Poison. Before the
5562 // transformation, extra values may not be evaluated according to the
5563 // condition, and it will not raise UB. But after transformation, we are
5564 // evaluating extra values before checking the condition, and it will raise
5565 // UB. It can be solved by adding freeze instruction to extra values.
5566 AssumptionCache *AC = Options.AC;
5567
5568 if (!isGuaranteedNotToBeUndefOrPoison(V: ExtraCase, AC, CtxI: BI, DT: nullptr))
5569 ExtraCase = Builder.CreateFreeze(V: ExtraCase);
5570
5571 // We don't have any info about this condition.
5572 auto *Br = TrueWhenEqual ? Builder.CreateCondBr(Cond: ExtraCase, True: EdgeBB, False: NewBB)
5573 : Builder.CreateCondBr(Cond: ExtraCase, True: NewBB, False: EdgeBB);
5574 setExplicitlyUnknownBranchWeightsIfProfiled(I&: *Br, DEBUG_TYPE);
5575
5576 OldTI->eraseFromParent();
5577
5578 if (DTU)
5579 Updates.push_back(Elt: {DominatorTree::Insert, BB, EdgeBB});
5580
5581 // If there are PHI nodes in EdgeBB, then we need to add a new entry to them
5582 // for the edge we just added.
5583 addPredecessorToBlock(Succ: EdgeBB, NewPred: BB, ExistPred: NewBB);
5584
5585 LLVM_DEBUG(dbgs() << " ** 'icmp' chain unhandled condition: " << *ExtraCase
5586 << "\nEXTRABB = " << *BB);
5587 BB = NewBB;
5588 }
5589
5590 Builder.SetInsertPoint(BI);
5591 // Convert pointer to int before we switch.
5592 if (CompVal->getType()->isPointerTy()) {
5593 assert(!DL.hasUnstableRepresentation(CompVal->getType()) &&
5594 "Should not end up here with unstable pointers");
5595 CompVal = Builder.CreatePtrToInt(
5596 V: CompVal, DestTy: DL.getIntPtrType(CompVal->getType()), Name: "magicptr");
5597 }
5598
5599 // Check if we can represent the values as a contiguous range. If so, we use a
5600 // range check + conditional branch instead of a switch.
5601 if (Values.front()->getValue() - Values.back()->getValue() ==
5602 Values.size() - 1) {
5603 ConstantRange RangeToCheck = ConstantRange::getNonEmpty(
5604 Lower: Values.back()->getValue(), Upper: Values.front()->getValue() + 1);
5605 APInt Offset, RHS;
5606 ICmpInst::Predicate Pred;
5607 RangeToCheck.getEquivalentICmp(Pred, RHS, Offset);
5608 Value *X = CompVal;
5609 if (!Offset.isZero())
5610 X = Builder.CreateAdd(LHS: X, RHS: ConstantInt::get(Ty: CompVal->getType(), V: Offset));
5611 Value *Cond =
5612 Builder.CreateICmp(P: Pred, LHS: X, RHS: ConstantInt::get(Ty: CompVal->getType(), V: RHS));
5613 CondBrInst *NewBI = Builder.CreateCondBr(Cond, True: EdgeBB, False: DefaultBB);
5614 if (HasProfile)
5615 setBranchWeights(I&: *NewBI, Weights: BranchWeights, /*IsExpected=*/false);
5616 if (MDNode *Unpredictable = BI->getMetadata(KindID: LLVMContext::MD_unpredictable))
5617 NewBI->setMetadata(KindID: LLVMContext::MD_unpredictable, Node: Unpredictable);
5618 // We don't need to update PHI nodes since we don't add any new edges.
5619 } else {
5620 // Create the new switch instruction now.
5621 SwitchInst *New = Builder.CreateSwitch(V: CompVal, Dest: DefaultBB, NumCases: Values.size());
5622 if (MDNode *Unpredictable = BI->getMetadata(KindID: LLVMContext::MD_unpredictable))
5623 New->setMetadata(KindID: LLVMContext::MD_unpredictable, Node: Unpredictable);
5624 if (HasProfile) {
5625 // We know the weight of the default case. We don't know the weight of the
5626 // other cases, but rather than completely lose profiling info, we split
5627 // the remaining probability equally over them.
5628 SmallVector<uint32_t> NewWeights(Values.size() + 1);
5629 NewWeights[0] = BranchWeights[1]; // this is the default, and we swapped
5630 // if TrueWhenEqual.
5631 for (auto &V : drop_begin(RangeOrContainer&: NewWeights))
5632 V = BranchWeights[0] / Values.size();
5633 setBranchWeights(I&: *New, Weights: NewWeights, /*IsExpected=*/false);
5634 }
5635
5636 // Add all of the 'cases' to the switch instruction.
5637 for (ConstantInt *Val : Values)
5638 New->addCase(OnVal: Val, Dest: EdgeBB);
5639
5640 // We added edges from PI to the EdgeBB. As such, if there were any
5641 // PHI nodes in EdgeBB, they need entries to be added corresponding to
5642 // the number of edges added.
5643 for (BasicBlock::iterator BBI = EdgeBB->begin(); isa<PHINode>(Val: BBI); ++BBI) {
5644 PHINode *PN = cast<PHINode>(Val&: BBI);
5645 Value *InVal = PN->getIncomingValueForBlock(BB);
5646 for (unsigned i = 0, e = Values.size() - 1; i != e; ++i)
5647 PN->addIncoming(V: InVal, BB);
5648 }
5649 }
5650
5651 // Erase the old branch instruction.
5652 eraseTerminatorAndDCECond(TI: BI);
5653 if (DTU)
5654 DTU->applyUpdates(Updates);
5655
5656 LLVM_DEBUG(dbgs() << " ** 'icmp' chain result is:\n" << *BB << '\n');
5657 return true;
5658}
5659
5660bool SimplifyCFGOpt::simplifyResume(ResumeInst *RI, IRBuilder<> &Builder) {
5661 if (isa<PHINode>(Val: RI->getValue()))
5662 return simplifyCommonResume(RI);
5663 else if (isa<LandingPadInst>(Val: RI->getParent()->getFirstNonPHIIt()) &&
5664 RI->getValue() == &*RI->getParent()->getFirstNonPHIIt())
5665 // The resume must unwind the exception that caused control to branch here.
5666 return simplifySingleResume(RI);
5667
5668 return false;
5669}
5670
5671// Check if cleanup block is empty
5672static bool isCleanupBlockEmpty(iterator_range<BasicBlock::iterator> R) {
5673 for (Instruction &I : R) {
5674 auto *II = dyn_cast<IntrinsicInst>(Val: &I);
5675 if (!II)
5676 return false;
5677
5678 Intrinsic::ID IntrinsicID = II->getIntrinsicID();
5679 switch (IntrinsicID) {
5680 case Intrinsic::dbg_declare:
5681 case Intrinsic::dbg_value:
5682 case Intrinsic::dbg_label:
5683 case Intrinsic::lifetime_end:
5684 break;
5685 default:
5686 return false;
5687 }
5688 }
5689 return true;
5690}
5691
5692// Simplify resume that is shared by several landing pads (phi of landing pad).
5693bool SimplifyCFGOpt::simplifyCommonResume(ResumeInst *RI) {
5694 BasicBlock *BB = RI->getParent();
5695
5696 // Check that there are no other instructions except for debug and lifetime
5697 // intrinsics between the phi's and resume instruction.
5698 if (!isCleanupBlockEmpty(R: make_range(x: RI->getParent()->getFirstNonPHIIt(),
5699 y: BB->getTerminator()->getIterator())))
5700 return false;
5701
5702 SmallSetVector<BasicBlock *, 4> TrivialUnwindBlocks;
5703 auto *PhiLPInst = cast<PHINode>(Val: RI->getValue());
5704
5705 // Check incoming blocks to see if any of them are trivial.
5706 for (unsigned Idx = 0, End = PhiLPInst->getNumIncomingValues(); Idx != End;
5707 Idx++) {
5708 auto *IncomingBB = PhiLPInst->getIncomingBlock(i: Idx);
5709 auto *IncomingValue = PhiLPInst->getIncomingValue(i: Idx);
5710
5711 // If the block has other successors, we can not delete it because
5712 // it has other dependents.
5713 if (IncomingBB->getUniqueSuccessor() != BB)
5714 continue;
5715
5716 auto *LandingPad = dyn_cast<LandingPadInst>(Val: IncomingBB->getFirstNonPHIIt());
5717 // Not the landing pad that caused the control to branch here.
5718 if (IncomingValue != LandingPad)
5719 continue;
5720
5721 if (isCleanupBlockEmpty(
5722 R: make_range(x: LandingPad->getNextNode(), y: IncomingBB->getTerminator())))
5723 TrivialUnwindBlocks.insert(X: IncomingBB);
5724 }
5725
5726 // If no trivial unwind blocks, don't do any simplifications.
5727 if (TrivialUnwindBlocks.empty())
5728 return false;
5729
5730 // Turn all invokes that unwind here into calls.
5731 for (auto *TrivialBB : TrivialUnwindBlocks) {
5732 // Blocks that will be simplified should be removed from the phi node.
5733 // Note there could be multiple edges to the resume block, and we need
5734 // to remove them all.
5735 while (PhiLPInst->getBasicBlockIndex(BB: TrivialBB) != -1)
5736 BB->removePredecessor(Pred: TrivialBB, KeepOneInputPHIs: true);
5737
5738 for (BasicBlock *Pred :
5739 llvm::make_early_inc_range(Range: predecessors(BB: TrivialBB))) {
5740 removeUnwindEdge(BB: Pred, DTU);
5741 ++NumInvokes;
5742 }
5743
5744 // In each SimplifyCFG run, only the current processed block can be erased.
5745 // Otherwise, it will break the iteration of SimplifyCFG pass. So instead
5746 // of erasing TrivialBB, we only remove the branch to the common resume
5747 // block so that we can later erase the resume block since it has no
5748 // predecessors.
5749 TrivialBB->getTerminator()->eraseFromParent();
5750 new UnreachableInst(RI->getContext(), TrivialBB);
5751 if (DTU)
5752 DTU->applyUpdates(Updates: {{DominatorTree::Delete, TrivialBB, BB}});
5753 }
5754
5755 // Delete the resume block if all its predecessors have been removed.
5756 if (pred_empty(BB))
5757 DeleteDeadBlock(BB, DTU);
5758
5759 return !TrivialUnwindBlocks.empty();
5760}
5761
5762// Simplify resume that is only used by a single (non-phi) landing pad.
5763bool SimplifyCFGOpt::simplifySingleResume(ResumeInst *RI) {
5764 BasicBlock *BB = RI->getParent();
5765 auto *LPInst = cast<LandingPadInst>(Val: BB->getFirstNonPHIIt());
5766 assert(RI->getValue() == LPInst &&
5767 "Resume must unwind the exception that caused control to here");
5768
5769 // Check that there are no other instructions except for debug intrinsics.
5770 if (!isCleanupBlockEmpty(
5771 R: make_range<Instruction *>(x: LPInst->getNextNode(), y: RI)))
5772 return false;
5773
5774 // Turn all invokes that unwind here into calls and delete the basic block.
5775 for (BasicBlock *Pred : llvm::make_early_inc_range(Range: predecessors(BB))) {
5776 removeUnwindEdge(BB: Pred, DTU);
5777 ++NumInvokes;
5778 }
5779
5780 // The landingpad is now unreachable. Zap it.
5781 DeleteDeadBlock(BB, DTU);
5782 return true;
5783}
5784
5785static bool removeEmptyCleanup(CleanupReturnInst *RI, DomTreeUpdater *DTU) {
5786 // If this is a trivial cleanup pad that executes no instructions, it can be
5787 // eliminated. If the cleanup pad continues to the caller, any predecessor
5788 // that is an EH pad will be updated to continue to the caller and any
5789 // predecessor that terminates with an invoke instruction will have its invoke
5790 // instruction converted to a call instruction. If the cleanup pad being
5791 // simplified does not continue to the caller, each predecessor will be
5792 // updated to continue to the unwind destination of the cleanup pad being
5793 // simplified.
5794 BasicBlock *BB = RI->getParent();
5795 CleanupPadInst *CPInst = RI->getCleanupPad();
5796 if (CPInst->getParent() != BB)
5797 // This isn't an empty cleanup.
5798 return false;
5799
5800 // We cannot kill the pad if it has multiple uses. This typically arises
5801 // from unreachable basic blocks.
5802 if (!CPInst->hasOneUse())
5803 return false;
5804
5805 // Check that there are no other instructions except for benign intrinsics.
5806 if (!isCleanupBlockEmpty(
5807 R: make_range<Instruction *>(x: CPInst->getNextNode(), y: RI)))
5808 return false;
5809
5810 // If the cleanup return we are simplifying unwinds to the caller, this will
5811 // set UnwindDest to nullptr.
5812 BasicBlock *UnwindDest = RI->getUnwindDest();
5813
5814 // We're about to remove BB from the control flow. Before we do, sink any
5815 // PHINodes into the unwind destination. Doing this before changing the
5816 // control flow avoids some potentially slow checks, since we can currently
5817 // be certain that UnwindDest and BB have no common predecessors (since they
5818 // are both EH pads).
5819 if (UnwindDest) {
5820 // First, go through the PHI nodes in UnwindDest and update any nodes that
5821 // reference the block we are removing
5822 for (PHINode &DestPN : UnwindDest->phis()) {
5823 int Idx = DestPN.getBasicBlockIndex(BB);
5824 // Since BB unwinds to UnwindDest, it has to be in the PHI node.
5825 assert(Idx != -1);
5826 // This PHI node has an incoming value that corresponds to a control
5827 // path through the cleanup pad we are removing. If the incoming
5828 // value is in the cleanup pad, it must be a PHINode (because we
5829 // verified above that the block is otherwise empty). Otherwise, the
5830 // value is either a constant or a value that dominates the cleanup
5831 // pad being removed.
5832 //
5833 // Because BB and UnwindDest are both EH pads, all of their
5834 // predecessors must unwind to these blocks, and since no instruction
5835 // can have multiple unwind destinations, there will be no overlap in
5836 // incoming blocks between SrcPN and DestPN.
5837 Value *SrcVal = DestPN.getIncomingValue(i: Idx);
5838 PHINode *SrcPN = dyn_cast<PHINode>(Val: SrcVal);
5839
5840 bool NeedPHITranslation = SrcPN && SrcPN->getParent() == BB;
5841 for (auto *Pred : predecessors(BB)) {
5842 Value *Incoming =
5843 NeedPHITranslation ? SrcPN->getIncomingValueForBlock(BB: Pred) : SrcVal;
5844 DestPN.addIncoming(V: Incoming, BB: Pred);
5845 }
5846 }
5847
5848 // Sink any remaining PHI nodes directly into UnwindDest.
5849 BasicBlock::iterator InsertPt = UnwindDest->getFirstNonPHIIt();
5850 for (PHINode &PN : make_early_inc_range(Range: BB->phis())) {
5851 if (PN.use_empty() || !PN.isUsedOutsideOfBlock(BB))
5852 // If the PHI node has no uses or all of its uses are in this basic
5853 // block (meaning they are debug or lifetime intrinsics), just leave
5854 // it. It will be erased when we erase BB below.
5855 continue;
5856
5857 // Otherwise, sink this PHI node into UnwindDest.
5858 // Any predecessors to UnwindDest which are not already represented
5859 // must be back edges which inherit the value from the path through
5860 // BB. In this case, the PHI value must reference itself.
5861 for (auto *pred : predecessors(BB: UnwindDest))
5862 if (pred != BB)
5863 PN.addIncoming(V: &PN, BB: pred);
5864 PN.moveBefore(InsertPos: InsertPt);
5865 // Also, add a dummy incoming value for the original BB itself,
5866 // so that the PHI is well-formed until we drop said predecessor.
5867 PN.addIncoming(V: PoisonValue::get(T: PN.getType()), BB);
5868 }
5869 }
5870
5871 std::vector<DominatorTree::UpdateType> Updates;
5872
5873 // We use make_early_inc_range here because we will remove all predecessors.
5874 for (BasicBlock *PredBB : llvm::make_early_inc_range(Range: predecessors(BB))) {
5875 if (UnwindDest == nullptr) {
5876 if (DTU) {
5877 DTU->applyUpdates(Updates);
5878 Updates.clear();
5879 }
5880 removeUnwindEdge(BB: PredBB, DTU);
5881 ++NumInvokes;
5882 } else {
5883 BB->removePredecessor(Pred: PredBB);
5884 Instruction *TI = PredBB->getTerminator();
5885 TI->replaceUsesOfWith(From: BB, To: UnwindDest);
5886 if (DTU) {
5887 Updates.push_back(x: {DominatorTree::Insert, PredBB, UnwindDest});
5888 Updates.push_back(x: {DominatorTree::Delete, PredBB, BB});
5889 }
5890 }
5891 }
5892
5893 if (DTU)
5894 DTU->applyUpdates(Updates);
5895
5896 DeleteDeadBlock(BB, DTU);
5897
5898 return true;
5899}
5900
5901// Try to merge two cleanuppads together.
5902static bool mergeCleanupPad(CleanupReturnInst *RI) {
5903 // Skip any cleanuprets which unwind to caller, there is nothing to merge
5904 // with.
5905 BasicBlock *UnwindDest = RI->getUnwindDest();
5906 if (!UnwindDest)
5907 return false;
5908
5909 // This cleanupret isn't the only predecessor of this cleanuppad, it wouldn't
5910 // be safe to merge without code duplication.
5911 if (UnwindDest->getSinglePredecessor() != RI->getParent())
5912 return false;
5913
5914 // Verify that our cleanuppad's unwind destination is another cleanuppad.
5915 auto *SuccessorCleanupPad = dyn_cast<CleanupPadInst>(Val: &UnwindDest->front());
5916 if (!SuccessorCleanupPad)
5917 return false;
5918
5919 CleanupPadInst *PredecessorCleanupPad = RI->getCleanupPad();
5920 // Replace any uses of the successor cleanupad with the predecessor pad
5921 // The only cleanuppad uses should be this cleanupret, it's cleanupret and
5922 // funclet bundle operands.
5923 SuccessorCleanupPad->replaceAllUsesWith(V: PredecessorCleanupPad);
5924 // Remove the old cleanuppad.
5925 SuccessorCleanupPad->eraseFromParent();
5926 // Now, we simply replace the cleanupret with a branch to the unwind
5927 // destination.
5928 UncondBrInst::Create(Target: UnwindDest, InsertBefore: RI->getParent());
5929 RI->eraseFromParent();
5930
5931 return true;
5932}
5933
5934bool SimplifyCFGOpt::simplifyCleanupReturn(CleanupReturnInst *RI) {
5935 // It is possible to transiantly have an undef cleanuppad operand because we
5936 // have deleted some, but not all, dead blocks.
5937 // Eventually, this block will be deleted.
5938 if (isa<UndefValue>(Val: RI->getOperand(i_nocapture: 0)))
5939 return false;
5940
5941 if (mergeCleanupPad(RI))
5942 return true;
5943
5944 if (removeEmptyCleanup(RI, DTU))
5945 return true;
5946
5947 return false;
5948}
5949
5950// WARNING: keep in sync with InstCombinerImpl::visitUnreachableInst()!
5951bool SimplifyCFGOpt::simplifyUnreachable(UnreachableInst *UI) {
5952 BasicBlock *BB = UI->getParent();
5953
5954 bool Changed = false;
5955
5956 // Ensure that any debug-info records that used to occur after the Unreachable
5957 // are moved to in front of it -- otherwise they'll "dangle" at the end of
5958 // the block.
5959 BB->flushTerminatorDbgRecords();
5960
5961 // Debug-info records on the unreachable inst itself should be deleted, as
5962 // below we delete everything past the final executable instruction.
5963 UI->dropDbgRecords();
5964
5965 // If there are any instructions immediately before the unreachable that can
5966 // be removed, do so.
5967 while (UI->getIterator() != BB->begin()) {
5968 BasicBlock::iterator BBI = UI->getIterator();
5969 --BBI;
5970
5971 if (!isGuaranteedToTransferExecutionToSuccessor(I: &*BBI))
5972 break; // Can not drop any more instructions. We're done here.
5973 // Otherwise, this instruction can be freely erased,
5974 // even if it is not side-effect free.
5975
5976 // Note that deleting EH's here is in fact okay, although it involves a bit
5977 // of subtle reasoning. If this inst is an EH, all the predecessors of this
5978 // block will be the unwind edges of Invoke/CatchSwitch/CleanupReturn,
5979 // and we can therefore guarantee this block will be erased.
5980
5981 // If we're deleting this, we're deleting any subsequent debug info, so
5982 // delete DbgRecords.
5983 BBI->dropDbgRecords();
5984
5985 // Delete this instruction (any uses are guaranteed to be dead)
5986 BBI->replaceAllUsesWith(V: PoisonValue::get(T: BBI->getType()));
5987 BBI->eraseFromParent();
5988 Changed = true;
5989 }
5990
5991 // If the unreachable instruction is the first in the block, take a gander
5992 // at all of the predecessors of this instruction, and simplify them.
5993 if (&BB->front() != UI)
5994 return Changed;
5995
5996 std::vector<DominatorTree::UpdateType> Updates;
5997
5998 SmallSetVector<BasicBlock *, 8> Preds(pred_begin(BB), pred_end(BB));
5999 for (BasicBlock *Predecessor : Preds) {
6000 Instruction *TI = Predecessor->getTerminator();
6001 IRBuilder<> Builder(TI);
6002 if (isa<UncondBrInst>(Val: TI)) {
6003 new UnreachableInst(TI->getContext(), TI->getIterator());
6004 TI->eraseFromParent();
6005 Changed = true;
6006 if (DTU)
6007 Updates.push_back(x: {DominatorTree::Delete, Predecessor, BB});
6008 } else if (auto *BI = dyn_cast<CondBrInst>(Val: TI)) {
6009 // We could either have a proper unconditional branch,
6010 // or a degenerate conditional branch with matching destinations.
6011 if (BI->getSuccessor(i: 0) == BI->getSuccessor(i: 1)) {
6012 new UnreachableInst(TI->getContext(), TI->getIterator());
6013 TI->eraseFromParent();
6014 Changed = true;
6015 } else {
6016 Value* Cond = BI->getCondition();
6017 assert(BI->getSuccessor(0) != BI->getSuccessor(1) &&
6018 "The destinations are guaranteed to be different here.");
6019 CallInst *Assumption;
6020 if (BI->getSuccessor(i: 0) == BB) {
6021 Assumption = Builder.CreateAssumption(Cond: Builder.CreateNot(V: Cond));
6022 Builder.CreateBr(Dest: BI->getSuccessor(i: 1));
6023 } else {
6024 assert(BI->getSuccessor(1) == BB && "Incorrect CFG");
6025 Assumption = Builder.CreateAssumption(Cond);
6026 Builder.CreateBr(Dest: BI->getSuccessor(i: 0));
6027 }
6028 if (Options.AC)
6029 Options.AC->registerAssumption(CI: cast<AssumeInst>(Val: Assumption));
6030
6031 eraseTerminatorAndDCECond(TI: BI);
6032 Changed = true;
6033 }
6034 if (DTU)
6035 Updates.push_back(x: {DominatorTree::Delete, Predecessor, BB});
6036 } else if (auto *SI = dyn_cast<SwitchInst>(Val: TI)) {
6037 SwitchInstProfUpdateWrapper SU(*SI);
6038 for (auto i = SU->case_begin(), e = SU->case_end(); i != e;) {
6039 if (i->getCaseSuccessor() != BB) {
6040 ++i;
6041 continue;
6042 }
6043 BB->removePredecessor(Pred: SU->getParent());
6044 i = SU.removeCase(I: i);
6045 e = SU->case_end();
6046 Changed = true;
6047 }
6048 // Note that the default destination can't be removed!
6049 if (DTU && SI->getDefaultDest() != BB)
6050 Updates.push_back(x: {DominatorTree::Delete, Predecessor, BB});
6051 } else if (auto *II = dyn_cast<InvokeInst>(Val: TI)) {
6052 if (II->getUnwindDest() == BB) {
6053 if (DTU) {
6054 DTU->applyUpdates(Updates);
6055 Updates.clear();
6056 }
6057 auto *CI = cast<CallInst>(Val: removeUnwindEdge(BB: TI->getParent(), DTU));
6058 if (!CI->doesNotThrow())
6059 CI->setDoesNotThrow();
6060 Changed = true;
6061 }
6062 } else if (auto *CSI = dyn_cast<CatchSwitchInst>(Val: TI)) {
6063 if (CSI->getUnwindDest() == BB) {
6064 if (DTU) {
6065 DTU->applyUpdates(Updates);
6066 Updates.clear();
6067 }
6068 removeUnwindEdge(BB: TI->getParent(), DTU);
6069 Changed = true;
6070 continue;
6071 }
6072
6073 for (CatchSwitchInst::handler_iterator I = CSI->handler_begin(),
6074 E = CSI->handler_end();
6075 I != E; ++I) {
6076 if (*I == BB) {
6077 CSI->removeHandler(HI: I);
6078 --I;
6079 --E;
6080 Changed = true;
6081 }
6082 }
6083 if (DTU)
6084 Updates.push_back(x: {DominatorTree::Delete, Predecessor, BB});
6085 if (CSI->getNumHandlers() == 0) {
6086 if (CSI->hasUnwindDest()) {
6087 // Redirect all predecessors of the block containing CatchSwitchInst
6088 // to instead branch to the CatchSwitchInst's unwind destination.
6089 if (DTU) {
6090 for (auto *PredecessorOfPredecessor : predecessors(BB: Predecessor)) {
6091 Updates.push_back(x: {DominatorTree::Insert,
6092 PredecessorOfPredecessor,
6093 CSI->getUnwindDest()});
6094 Updates.push_back(x: {DominatorTree::Delete,
6095 PredecessorOfPredecessor, Predecessor});
6096 }
6097 }
6098 Predecessor->replaceAllUsesWith(V: CSI->getUnwindDest());
6099 } else {
6100 // Rewrite all preds to unwind to caller (or from invoke to call).
6101 if (DTU) {
6102 DTU->applyUpdates(Updates);
6103 Updates.clear();
6104 }
6105 SmallVector<BasicBlock *, 8> EHPreds(predecessors(BB: Predecessor));
6106 for (BasicBlock *EHPred : EHPreds)
6107 removeUnwindEdge(BB: EHPred, DTU);
6108 }
6109 // The catchswitch is no longer reachable.
6110 new UnreachableInst(CSI->getContext(), CSI->getIterator());
6111 CSI->eraseFromParent();
6112 Changed = true;
6113 }
6114 } else if (auto *CRI = dyn_cast<CleanupReturnInst>(Val: TI)) {
6115 (void)CRI;
6116 assert(CRI->hasUnwindDest() && CRI->getUnwindDest() == BB &&
6117 "Expected to always have an unwind to BB.");
6118 if (DTU)
6119 Updates.push_back(x: {DominatorTree::Delete, Predecessor, BB});
6120 new UnreachableInst(TI->getContext(), TI->getIterator());
6121 TI->eraseFromParent();
6122 Changed = true;
6123 }
6124 }
6125
6126 if (DTU)
6127 DTU->applyUpdates(Updates);
6128
6129 // If this block is now dead, remove it.
6130 if (pred_empty(BB) && BB != &BB->getParent()->getEntryBlock()) {
6131 DeleteDeadBlock(BB, DTU);
6132 return true;
6133 }
6134
6135 return Changed;
6136}
6137
6138struct ContiguousCasesResult {
6139 ConstantInt *Min;
6140 ConstantInt *Max;
6141 BasicBlock *Dest;
6142 BasicBlock *OtherDest;
6143 SmallVectorImpl<ConstantInt *> *Cases;
6144 SmallVectorImpl<ConstantInt *> *OtherCases;
6145};
6146
6147static std::optional<ContiguousCasesResult>
6148findContiguousCases(Value *Condition, SmallVectorImpl<ConstantInt *> &Cases,
6149 SmallVectorImpl<ConstantInt *> &OtherCases,
6150 BasicBlock *Dest, BasicBlock *OtherDest) {
6151 assert(Cases.size() >= 1);
6152
6153 array_pod_sort(Start: Cases.begin(), End: Cases.end(), Compare: constantIntSortPredicate);
6154 const APInt &Min = Cases.back()->getValue();
6155 const APInt &Max = Cases.front()->getValue();
6156 APInt Offset = Max - Min;
6157 size_t ContiguousOffset = Cases.size() - 1;
6158 if (Offset == ContiguousOffset) {
6159 return ContiguousCasesResult{
6160 /*Min=*/Cases.back(),
6161 /*Max=*/Cases.front(),
6162 /*Dest=*/Dest,
6163 /*OtherDest=*/OtherDest,
6164 /*Cases=*/&Cases,
6165 /*OtherCases=*/&OtherCases,
6166 };
6167 }
6168 ConstantRange CR = computeConstantRange(V: Condition, /*ForSigned=*/false,
6169 SQ: SimplifyQuery(Dest->getDataLayout()));
6170 // If this is a wrapping contiguous range, that is, [Min, OtherMin] +
6171 // [OtherMax, Max] (also [OtherMax, OtherMin]), [OtherMin+1, OtherMax-1] is a
6172 // contiguous range for the other destination. N.B. If CR is not a full range,
6173 // Max+1 is not equal to Min. It's not continuous in arithmetic.
6174 if (Max == CR.getUnsignedMax() && Min == CR.getUnsignedMin()) {
6175 assert(Cases.size() >= 2);
6176 auto *It =
6177 std::adjacent_find(first: Cases.begin(), last: Cases.end(), binary_pred: [](auto L, auto R) {
6178 return L->getValue() != R->getValue() + 1;
6179 });
6180 if (It == Cases.end())
6181 return std::nullopt;
6182 auto [OtherMax, OtherMin] = std::make_pair(x&: *It, y&: *std::next(x: It));
6183 if ((Max - OtherMax->getValue()) + (OtherMin->getValue() - Min) ==
6184 Cases.size() - 2) {
6185 return ContiguousCasesResult{
6186 /*Min=*/cast<ConstantInt>(
6187 Val: ConstantInt::get(Ty: OtherMin->getType(), V: OtherMin->getValue() + 1)),
6188 /*Max=*/
6189 cast<ConstantInt>(
6190 Val: ConstantInt::get(Ty: OtherMax->getType(), V: OtherMax->getValue() - 1)),
6191 /*Dest=*/OtherDest,
6192 /*OtherDest=*/Dest,
6193 /*Cases=*/&OtherCases,
6194 /*OtherCases=*/&Cases,
6195 };
6196 }
6197 }
6198 return std::nullopt;
6199}
6200
6201static void createUnreachableSwitchDefault(SwitchInst *Switch,
6202 DomTreeUpdater *DTU,
6203 bool RemoveOrigDefaultBlock = true) {
6204 LLVM_DEBUG(dbgs() << "SimplifyCFG: switch default is dead.\n");
6205 auto *BB = Switch->getParent();
6206 auto *OrigDefaultBlock = Switch->getDefaultDest();
6207 if (RemoveOrigDefaultBlock)
6208 OrigDefaultBlock->removePredecessor(Pred: BB);
6209 BasicBlock *NewDefaultBlock = BasicBlock::Create(
6210 Context&: BB->getContext(), Name: BB->getName() + ".unreachabledefault", Parent: BB->getParent(),
6211 InsertBefore: OrigDefaultBlock);
6212 auto *UI = new UnreachableInst(Switch->getContext(), NewDefaultBlock);
6213 UI->setDebugLoc(DebugLoc::getTemporary());
6214 Switch->setDefaultDest(&*NewDefaultBlock);
6215 if (DTU) {
6216 SmallVector<DominatorTree::UpdateType, 2> Updates;
6217 Updates.push_back(Elt: {DominatorTree::Insert, BB, &*NewDefaultBlock});
6218 if (RemoveOrigDefaultBlock &&
6219 !is_contained(Range: successors(BB), Element: OrigDefaultBlock))
6220 Updates.push_back(Elt: {DominatorTree::Delete, BB, &*OrigDefaultBlock});
6221 DTU->applyUpdates(Updates);
6222 }
6223}
6224
6225/// Turn a switch into an integer range comparison and branch.
6226/// Switches with more than 2 destinations are ignored.
6227/// Switches with 1 destination are also ignored.
6228bool SimplifyCFGOpt::turnSwitchRangeIntoICmp(SwitchInst *SI,
6229 IRBuilder<> &Builder) {
6230 assert(SI->getNumCases() > 1 && "Degenerate switch?");
6231
6232 bool HasDefault = !SI->defaultDestUnreachable();
6233
6234 auto *BB = SI->getParent();
6235 // Partition the cases into two sets with different destinations.
6236 BasicBlock *DestA = HasDefault ? SI->getDefaultDest() : nullptr;
6237 BasicBlock *DestB = nullptr;
6238 SmallVector<ConstantInt *, 16> CasesA;
6239 SmallVector<ConstantInt *, 16> CasesB;
6240
6241 for (auto Case : SI->cases()) {
6242 BasicBlock *Dest = Case.getCaseSuccessor();
6243 if (!DestA)
6244 DestA = Dest;
6245 if (Dest == DestA) {
6246 CasesA.push_back(Elt: Case.getCaseValue());
6247 continue;
6248 }
6249 if (!DestB)
6250 DestB = Dest;
6251 if (Dest == DestB) {
6252 CasesB.push_back(Elt: Case.getCaseValue());
6253 continue;
6254 }
6255 return false; // More than two destinations.
6256 }
6257 if (!DestB)
6258 return false; // All destinations are the same and the default is unreachable
6259
6260 assert(DestA && DestB &&
6261 "Single-destination switch should have been folded.");
6262 assert(DestA != DestB);
6263 assert(DestB != SI->getDefaultDest());
6264 assert(!CasesB.empty() && "There must be non-default cases.");
6265 assert(!CasesA.empty() || HasDefault);
6266
6267 // Figure out if one of the sets of cases form a contiguous range.
6268 std::optional<ContiguousCasesResult> ContiguousCases;
6269
6270 // Only one icmp is needed when there is only one case.
6271 if (!HasDefault && CasesA.size() == 1)
6272 ContiguousCases = ContiguousCasesResult{
6273 /*Min=*/CasesA[0],
6274 /*Max=*/CasesA[0],
6275 /*Dest=*/DestA,
6276 /*OtherDest=*/DestB,
6277 /*Cases=*/&CasesA,
6278 /*OtherCases=*/&CasesB,
6279 };
6280 else if (CasesB.size() == 1)
6281 ContiguousCases = ContiguousCasesResult{
6282 /*Min=*/CasesB[0],
6283 /*Max=*/CasesB[0],
6284 /*Dest=*/DestB,
6285 /*OtherDest=*/DestA,
6286 /*Cases=*/&CasesB,
6287 /*OtherCases=*/&CasesA,
6288 };
6289 // Correctness: Cases to the default destination cannot be contiguous cases.
6290 else if (!HasDefault)
6291 ContiguousCases =
6292 findContiguousCases(Condition: SI->getCondition(), Cases&: CasesA, OtherCases&: CasesB, Dest: DestA, OtherDest: DestB);
6293
6294 if (!ContiguousCases)
6295 ContiguousCases =
6296 findContiguousCases(Condition: SI->getCondition(), Cases&: CasesB, OtherCases&: CasesA, Dest: DestB, OtherDest: DestA);
6297
6298 if (!ContiguousCases)
6299 return false;
6300
6301 auto [Min, Max, Dest, OtherDest, Cases, OtherCases] = *ContiguousCases;
6302
6303 // Start building the compare and branch.
6304
6305 Constant *Offset = ConstantExpr::getNeg(C: Min);
6306 Constant *NumCases = ConstantInt::get(Ty: Offset->getType(),
6307 V: Max->getValue() - Min->getValue() + 1);
6308 Instruction *NewBI;
6309 if (NumCases->isOneValue()) {
6310 assert(Max->getValue() == Min->getValue());
6311 Value *Cmp = Builder.CreateICmpEQ(LHS: SI->getCondition(), RHS: Min);
6312 NewBI = Builder.CreateCondBr(Cond: Cmp, True: Dest, False: OtherDest);
6313 }
6314 // If NumCases overflowed, then all possible values jump to the successor.
6315 else if (NumCases->isNullValue() && !Cases->empty()) {
6316 NewBI = Builder.CreateBr(Dest);
6317 } else {
6318 Value *Sub = SI->getCondition();
6319 if (!Offset->isNullValue())
6320 Sub = Builder.CreateAdd(LHS: Sub, RHS: Offset, Name: Sub->getName() + ".off");
6321 Value *Cmp = Builder.CreateICmpULT(LHS: Sub, RHS: NumCases, Name: "switch");
6322 NewBI = Builder.CreateCondBr(Cond: Cmp, True: Dest, False: OtherDest);
6323 }
6324
6325 // Update weight for the newly-created conditional branch.
6326 if (hasBranchWeightMD(I: *SI) && isa<CondBrInst>(Val: NewBI)) {
6327 SmallVector<uint64_t, 8> Weights;
6328 getBranchWeights(TI: SI, Weights);
6329 if (Weights.size() == 1 + SI->getNumCases()) {
6330 uint64_t TrueWeight = 0;
6331 uint64_t FalseWeight = 0;
6332 for (size_t I = 0, E = Weights.size(); I != E; ++I) {
6333 if (SI->getSuccessor(idx: I) == Dest)
6334 TrueWeight += Weights[I];
6335 else
6336 FalseWeight += Weights[I];
6337 }
6338 while (TrueWeight > UINT32_MAX || FalseWeight > UINT32_MAX) {
6339 TrueWeight /= 2;
6340 FalseWeight /= 2;
6341 }
6342 setFittedBranchWeights(I&: *NewBI, Weights: {TrueWeight, FalseWeight},
6343 /*IsExpected=*/false, /*ElideAllZero=*/true);
6344 }
6345 }
6346
6347 // Prune obsolete incoming values off the successors' PHI nodes.
6348 for (auto &PHI : make_early_inc_range(Range: Dest->phis())) {
6349 unsigned PreviousEdges = Cases->size();
6350 if (Dest == SI->getDefaultDest())
6351 ++PreviousEdges;
6352 for (unsigned I = 0, E = PreviousEdges - 1; I != E; ++I)
6353 PHI.removeIncomingValue(BB: SI->getParent());
6354 }
6355 for (auto &PHI : make_early_inc_range(Range: OtherDest->phis())) {
6356 unsigned PreviousEdges = OtherCases->size();
6357 if (OtherDest == SI->getDefaultDest())
6358 ++PreviousEdges;
6359 unsigned E = PreviousEdges - 1;
6360 // Remove all incoming values from OtherDest if OtherDest is unreachable.
6361 if (isa<UncondBrInst>(Val: NewBI))
6362 ++E;
6363 for (unsigned I = 0; I != E; ++I)
6364 PHI.removeIncomingValue(BB: SI->getParent());
6365 }
6366
6367 // Clean up the default block.
6368 SmallVector<DominatorTree::UpdateType, 2> Updates;
6369 if (!HasDefault) {
6370 BasicBlock *OrigDefaultBlock = SI->getDefaultDest();
6371 OrigDefaultBlock->removePredecessor(Pred: BB);
6372 Updates.push_back(Elt: {DominatorTree::Delete, BB, OrigDefaultBlock});
6373 }
6374
6375 // Drop the switch.
6376 SI->eraseFromParent();
6377
6378 if (isa<UncondBrInst>(Val: NewBI))
6379 Updates.push_back(Elt: {DominatorTree::Delete, BB, OtherDest});
6380
6381 if (DTU)
6382 DTU->applyUpdates(Updates);
6383 return true;
6384}
6385
6386/// Compute masked bits for the condition of a switch
6387/// and use it to remove dead cases.
6388static bool eliminateDeadSwitchCases(SwitchInst *SI, DomTreeUpdater *DTU,
6389 AssumptionCache *AC,
6390 const DataLayout &DL) {
6391 Value *Cond = SI->getCondition();
6392 KnownBits Known = computeKnownBits(V: Cond, DL, AC, CtxI: SI);
6393 SmallPtrSet<const Constant *, 4> KnownValues;
6394 bool IsKnownValuesValid = collectPossibleValues(V: Cond, Constants&: KnownValues, MaxCount: 4);
6395
6396 // We can also eliminate cases by determining that their values are outside of
6397 // the limited range of the condition based on how many significant (non-sign)
6398 // bits are in the condition value.
6399 unsigned MaxSignificantBitsInCond =
6400 ComputeMaxSignificantBits(Op: Cond, DL, AC, CtxI: SI);
6401
6402 // Gather dead cases.
6403 SmallVector<ConstantInt *, 8> DeadCases;
6404 SmallDenseMap<BasicBlock *, int, 8> NumPerSuccessorCases;
6405 SmallVector<BasicBlock *, 8> UniqueSuccessors;
6406 for (const auto &Case : SI->cases()) {
6407 auto *Successor = Case.getCaseSuccessor();
6408 if (DTU) {
6409 auto [It, Inserted] = NumPerSuccessorCases.try_emplace(Key: Successor);
6410 if (Inserted)
6411 UniqueSuccessors.push_back(Elt: Successor);
6412 ++It->second;
6413 }
6414 ConstantInt *CaseC = Case.getCaseValue();
6415 const APInt &CaseVal = CaseC->getValue();
6416 if (Known.Zero.intersects(RHS: CaseVal) || !Known.One.isSubsetOf(RHS: CaseVal) ||
6417 (CaseVal.getSignificantBits() > MaxSignificantBitsInCond) ||
6418 (IsKnownValuesValid && !KnownValues.contains(Ptr: CaseC))) {
6419 DeadCases.push_back(Elt: CaseC);
6420 if (DTU)
6421 --NumPerSuccessorCases[Successor];
6422 LLVM_DEBUG(dbgs() << "SimplifyCFG: switch case " << CaseVal
6423 << " is dead.\n");
6424 } else if (IsKnownValuesValid)
6425 KnownValues.erase(Ptr: CaseC);
6426 }
6427
6428 // If we can prove that the cases must cover all possible values, the
6429 // default destination becomes dead and we can remove it. If we know some
6430 // of the bits in the value, we can use that to more precisely compute the
6431 // number of possible unique case values.
6432 bool HasDefault = !SI->defaultDestUnreachable();
6433 const unsigned NumUnknownBits =
6434 Known.getBitWidth() - (Known.Zero | Known.One).popcount();
6435 assert(NumUnknownBits <= Known.getBitWidth());
6436 if (HasDefault && DeadCases.empty()) {
6437 if (IsKnownValuesValid && all_of(Range&: KnownValues, P: IsaPred<UndefValue>)) {
6438 createUnreachableSwitchDefault(Switch: SI, DTU);
6439 return true;
6440 }
6441
6442 if (NumUnknownBits < 64 /* avoid overflow */) {
6443 uint64_t AllNumCases = 1ULL << NumUnknownBits;
6444 if (SI->getNumCases() == AllNumCases) {
6445 createUnreachableSwitchDefault(Switch: SI, DTU);
6446 return true;
6447 }
6448 // When only one case value is missing, replace default with that case.
6449 // Eliminating the default branch will provide more opportunities for
6450 // optimization, such as lookup tables.
6451 if (SI->getNumCases() == AllNumCases - 1) {
6452 assert(NumUnknownBits > 1 && "Should be canonicalized to a branch");
6453 IntegerType *CondTy = cast<IntegerType>(Val: Cond->getType());
6454 if (CondTy->getIntegerBitWidth() > 64 ||
6455 !DL.fitsInLegalInteger(Width: CondTy->getIntegerBitWidth()))
6456 return false;
6457
6458 uint64_t MissingCaseVal = 0;
6459 for (const auto &Case : SI->cases())
6460 MissingCaseVal ^= Case.getCaseValue()->getValue().getLimitedValue();
6461 auto *MissingCase = cast<ConstantInt>(
6462 Val: ConstantInt::get(Ty: Cond->getType(), V: MissingCaseVal));
6463 SwitchInstProfUpdateWrapper SIW(*SI);
6464 SIW.addCase(OnVal: MissingCase, Dest: SI->getDefaultDest(),
6465 W: SIW.getSuccessorWeight(idx: 0));
6466 createUnreachableSwitchDefault(Switch: SI, DTU,
6467 /*RemoveOrigDefaultBlock*/ false);
6468 SIW.setSuccessorWeight(idx: 0, W: 0);
6469 return true;
6470 }
6471 }
6472 }
6473
6474 if (DeadCases.empty())
6475 return false;
6476
6477 SwitchInstProfUpdateWrapper SIW(*SI);
6478 for (ConstantInt *DeadCase : DeadCases) {
6479 SwitchInst::CaseIt CaseI = SI->findCaseValue(C: DeadCase);
6480 assert(CaseI != SI->case_default() &&
6481 "Case was not found. Probably mistake in DeadCases forming.");
6482 // Prune unused values from PHI nodes.
6483 CaseI->getCaseSuccessor()->removePredecessor(Pred: SI->getParent());
6484 SIW.removeCase(I: CaseI);
6485 }
6486
6487 if (DTU) {
6488 std::vector<DominatorTree::UpdateType> Updates;
6489 for (auto *Successor : UniqueSuccessors)
6490 if (NumPerSuccessorCases[Successor] == 0)
6491 Updates.push_back(x: {DominatorTree::Delete, SI->getParent(), Successor});
6492 DTU->applyUpdates(Updates);
6493 }
6494
6495 return true;
6496}
6497
6498/// If BB would be eligible for simplification by
6499/// TryToSimplifyUncondBranchFromEmptyBlock (i.e. it is empty and terminated
6500/// by an unconditional branch), look at the phi node for BB in the successor
6501/// block and see if the incoming value is equal to CaseValue. If so, return
6502/// the phi node, and set PhiIndex to BB's index in the phi node.
6503static PHINode *findPHIForConditionForwarding(ConstantInt *CaseValue,
6504 BasicBlock *BB, int *PhiIndex) {
6505 if (&*BB->getFirstNonPHIIt() != BB->getTerminator())
6506 return nullptr; // BB must be empty to be a candidate for simplification.
6507 if (!BB->getSinglePredecessor())
6508 return nullptr; // BB must be dominated by the switch.
6509
6510 UncondBrInst *Branch = dyn_cast<UncondBrInst>(Val: BB->getTerminator());
6511 if (!Branch)
6512 return nullptr; // Terminator must be unconditional branch.
6513
6514 BasicBlock *Succ = Branch->getSuccessor();
6515
6516 for (PHINode &PHI : Succ->phis()) {
6517 int Idx = PHI.getBasicBlockIndex(BB);
6518 assert(Idx >= 0 && "PHI has no entry for predecessor?");
6519
6520 Value *InValue = PHI.getIncomingValue(i: Idx);
6521 if (InValue != CaseValue)
6522 continue;
6523
6524 *PhiIndex = Idx;
6525 return &PHI;
6526 }
6527
6528 return nullptr;
6529}
6530
6531/// Try to forward the condition of a switch instruction to a phi node
6532/// dominated by the switch, if that would mean that some of the destination
6533/// blocks of the switch can be folded away. Return true if a change is made.
6534static bool forwardSwitchConditionToPHI(SwitchInst *SI) {
6535 using ForwardingNodesMap = DenseMap<PHINode *, SmallVector<int, 4>>;
6536
6537 ForwardingNodesMap ForwardingNodes;
6538 BasicBlock *SwitchBlock = SI->getParent();
6539 bool Changed = false;
6540 for (const auto &Case : SI->cases()) {
6541 ConstantInt *CaseValue = Case.getCaseValue();
6542 BasicBlock *CaseDest = Case.getCaseSuccessor();
6543
6544 // Replace phi operands in successor blocks that are using the constant case
6545 // value rather than the switch condition variable:
6546 // switchbb:
6547 // switch i32 %x, label %default [
6548 // i32 17, label %succ
6549 // ...
6550 // succ:
6551 // %r = phi i32 ... [ 17, %switchbb ] ...
6552 // -->
6553 // %r = phi i32 ... [ %x, %switchbb ] ...
6554
6555 for (PHINode &Phi : CaseDest->phis()) {
6556 // This only works if there is exactly 1 incoming edge from the switch to
6557 // a phi. If there is >1, that means multiple cases of the switch map to 1
6558 // value in the phi, and that phi value is not the switch condition. Thus,
6559 // this transform would not make sense (the phi would be invalid because
6560 // a phi can't have different incoming values from the same block).
6561 int SwitchBBIdx = Phi.getBasicBlockIndex(BB: SwitchBlock);
6562 if (Phi.getIncomingValue(i: SwitchBBIdx) == CaseValue &&
6563 count(Range: Phi.blocks(), Element: SwitchBlock) == 1) {
6564 Phi.setIncomingValue(i: SwitchBBIdx, V: SI->getCondition());
6565 Changed = true;
6566 }
6567 }
6568
6569 // Collect phi nodes that are indirectly using this switch's case constants.
6570 int PhiIdx;
6571 if (auto *Phi = findPHIForConditionForwarding(CaseValue, BB: CaseDest, PhiIndex: &PhiIdx))
6572 ForwardingNodes[Phi].push_back(Elt: PhiIdx);
6573 }
6574
6575 for (auto &ForwardingNode : ForwardingNodes) {
6576 PHINode *Phi = ForwardingNode.first;
6577 SmallVectorImpl<int> &Indexes = ForwardingNode.second;
6578 // Check if it helps to fold PHI.
6579 if (Indexes.size() < 2 && !llvm::is_contained(Range: Phi->incoming_values(), Element: SI->getCondition()))
6580 continue;
6581
6582 for (int Index : Indexes)
6583 Phi->setIncomingValue(i: Index, V: SI->getCondition());
6584 Changed = true;
6585 }
6586
6587 return Changed;
6588}
6589
6590/// Return true if the backend will be able to handle
6591/// initializing an array of constants like C.
6592static bool validLookupTableConstant(Constant *C, const TargetTransformInfo &TTI) {
6593 if (C->isThreadDependent())
6594 return false;
6595 if (C->isDLLImportDependent())
6596 return false;
6597
6598 if (!isa<ConstantDataVector, ConstantExpr, ConstantFP, ConstantInt,
6599 ConstantPointerNull, GlobalValue, UndefValue>(Val: C))
6600 return false;
6601
6602 // Globals cannot contain scalable types.
6603 if (C->getType()->isScalableTy())
6604 return false;
6605
6606 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Val: C)) {
6607 // Pointer casts and in-bounds GEPs will not prohibit the backend from
6608 // materializing the array of constants.
6609 Constant *StrippedC = cast<Constant>(Val: CE->stripInBoundsConstantOffsets());
6610 if (StrippedC == C || !validLookupTableConstant(C: StrippedC, TTI))
6611 return false;
6612 }
6613
6614 if (!TTI.shouldBuildLookupTablesForConstant(C))
6615 return false;
6616
6617 return true;
6618}
6619
6620/// If V is a Constant, return it. Otherwise, try to look up
6621/// its constant value in ConstantPool, returning 0 if it's not there.
6622static Constant *
6623lookupConstant(Value *V,
6624 const SmallDenseMap<Value *, Constant *> &ConstantPool) {
6625 if (Constant *C = dyn_cast<Constant>(Val: V))
6626 return C;
6627 return ConstantPool.lookup(Val: V);
6628}
6629
6630/// Try to fold instruction I into a constant. This works for
6631/// simple instructions such as binary operations where both operands are
6632/// constant or can be replaced by constants from the ConstantPool. Returns the
6633/// resulting constant on success, 0 otherwise.
6634static Constant *
6635constantFold(Instruction *I, const DataLayout &DL,
6636 const SmallDenseMap<Value *, Constant *> &ConstantPool) {
6637 if (SelectInst *Select = dyn_cast<SelectInst>(Val: I)) {
6638 Constant *A = lookupConstant(V: Select->getCondition(), ConstantPool);
6639 if (!A)
6640 return nullptr;
6641 if (A->isAllOnesValue())
6642 return lookupConstant(V: Select->getTrueValue(), ConstantPool);
6643 if (A->isNullValue())
6644 return lookupConstant(V: Select->getFalseValue(), ConstantPool);
6645 return nullptr;
6646 }
6647
6648 SmallVector<Constant *, 4> COps;
6649 for (unsigned N = 0, E = I->getNumOperands(); N != E; ++N) {
6650 if (Constant *A = lookupConstant(V: I->getOperand(i: N), ConstantPool))
6651 COps.push_back(Elt: A);
6652 else
6653 return nullptr;
6654 }
6655
6656 return ConstantFoldInstOperands(I, Ops: COps, DL);
6657}
6658
6659/// Try to determine the resulting constant values in phi nodes
6660/// at the common destination basic block, *CommonDest, for one of the case
6661/// destinations CaseDest corresponding to value CaseVal (nullptr for the
6662/// default case), of a switch instruction SI.
6663static bool
6664getCaseResults(SwitchInst *SI, ConstantInt *CaseVal, BasicBlock *CaseDest,
6665 BasicBlock **CommonDest,
6666 SmallVectorImpl<std::pair<PHINode *, Constant *>> &Res,
6667 const DataLayout &DL) {
6668 // The block from which we enter the common destination.
6669 BasicBlock *Pred = SI->getParent();
6670
6671 // If CaseDest is empty except for some side-effect free instructions through
6672 // which we can constant-propagate the CaseVal, continue to its successor.
6673 SmallDenseMap<Value *, Constant *> ConstantPool;
6674 ConstantPool.insert(KV: std::make_pair(x: SI->getCondition(), y&: CaseVal));
6675 for (Instruction &I : *CaseDest) {
6676 if (I.isTerminator()) {
6677 // If the terminator is a simple branch, continue to the next block.
6678 if (I.getNumSuccessors() != 1 || I.isSpecialTerminator())
6679 return false;
6680 Pred = CaseDest;
6681 CaseDest = I.getSuccessor(Idx: 0);
6682 } else if (Constant *C = constantFold(I: &I, DL, ConstantPool)) {
6683 // Instruction is side-effect free and constant.
6684
6685 // If the instruction has uses outside this block or a phi node slot for
6686 // the block, it is not safe to bypass the instruction since it would then
6687 // no longer dominate all its uses.
6688 for (auto &Use : I.uses()) {
6689 User *User = Use.getUser();
6690 if (Instruction *I = dyn_cast<Instruction>(Val: User))
6691 if (I->getParent() == CaseDest)
6692 continue;
6693 if (PHINode *Phi = dyn_cast<PHINode>(Val: User))
6694 if (Phi->getIncomingBlock(U: Use) == CaseDest)
6695 continue;
6696 return false;
6697 }
6698
6699 ConstantPool.insert(KV: std::make_pair(x: &I, y&: C));
6700 } else {
6701 break;
6702 }
6703 }
6704
6705 // If we did not have a CommonDest before, use the current one.
6706 if (!*CommonDest)
6707 *CommonDest = CaseDest;
6708 // If the destination isn't the common one, abort.
6709 if (CaseDest != *CommonDest)
6710 return false;
6711
6712 // Get the values for this case from phi nodes in the destination block.
6713 for (PHINode &PHI : (*CommonDest)->phis()) {
6714 int Idx = PHI.getBasicBlockIndex(BB: Pred);
6715 if (Idx == -1)
6716 continue;
6717
6718 Constant *ConstVal =
6719 lookupConstant(V: PHI.getIncomingValue(i: Idx), ConstantPool);
6720 if (!ConstVal)
6721 return false;
6722
6723 Res.push_back(Elt: std::make_pair(x: &PHI, y&: ConstVal));
6724 }
6725
6726 return Res.size() > 0;
6727}
6728
6729// Helper function used to add CaseVal to the list of cases that generate
6730// Result. Returns the updated number of cases that generate this result.
6731static size_t mapCaseToResult(ConstantInt *CaseVal,
6732 SwitchCaseResultVectorTy &UniqueResults,
6733 Constant *Result) {
6734 for (auto &I : UniqueResults) {
6735 if (I.first == Result) {
6736 I.second.push_back(Elt: CaseVal);
6737 return I.second.size();
6738 }
6739 }
6740 UniqueResults.push_back(
6741 Elt: std::make_pair(x&: Result, y: SmallVector<ConstantInt *, 4>(1, CaseVal)));
6742 return 1;
6743}
6744
6745// Helper function that initializes a map containing
6746// results for the PHI node of the common destination block for a switch
6747// instruction. Returns false if multiple PHI nodes have been found or if
6748// there is not a common destination block for the switch.
6749static bool initializeUniqueCases(SwitchInst *SI, PHINode *&PHI,
6750 BasicBlock *&CommonDest,
6751 SwitchCaseResultVectorTy &UniqueResults,
6752 Constant *&DefaultResult,
6753 const DataLayout &DL,
6754 uintptr_t MaxUniqueResults) {
6755 for (const auto &I : SI->cases()) {
6756 ConstantInt *CaseVal = I.getCaseValue();
6757
6758 // Resulting value at phi nodes for this case value.
6759 SwitchCaseResultsTy Results;
6760 if (!getCaseResults(SI, CaseVal, CaseDest: I.getCaseSuccessor(), CommonDest: &CommonDest, Res&: Results,
6761 DL))
6762 return false;
6763
6764 // Only one value per case is permitted.
6765 if (Results.size() > 1)
6766 return false;
6767
6768 // Add the case->result mapping to UniqueResults.
6769 const size_t NumCasesForResult =
6770 mapCaseToResult(CaseVal, UniqueResults, Result: Results.begin()->second);
6771
6772 // Early out if there are too many cases for this result.
6773 if (NumCasesForResult > MaxSwitchCasesPerResult)
6774 return false;
6775
6776 // Early out if there are too many unique results.
6777 if (UniqueResults.size() > MaxUniqueResults)
6778 return false;
6779
6780 // Check the PHI consistency.
6781 if (!PHI)
6782 PHI = Results[0].first;
6783 else if (PHI != Results[0].first)
6784 return false;
6785 }
6786 // Find the default result value.
6787 SmallVector<std::pair<PHINode *, Constant *>, 1> DefaultResults;
6788 getCaseResults(SI, CaseVal: nullptr, CaseDest: SI->getDefaultDest(), CommonDest: &CommonDest, Res&: DefaultResults,
6789 DL);
6790 // If the default value is not found abort unless the default destination
6791 // is unreachable.
6792 DefaultResult =
6793 DefaultResults.size() == 1 ? DefaultResults.begin()->second : nullptr;
6794
6795 return DefaultResult || SI->defaultDestUnreachable();
6796}
6797
6798// Helper function that checks if it is possible to transform a switch with only
6799// two cases (or two cases + default) that produces a result into a select.
6800// TODO: Handle switches with more than 2 cases that map to the same result.
6801// The branch weights correspond to the provided Condition (i.e. if Condition is
6802// modified from the original SwitchInst, the caller must adjust the weights)
6803static Value *foldSwitchToSelect(const SwitchCaseResultVectorTy &ResultVector,
6804 Constant *DefaultResult, Value *Condition,
6805 IRBuilder<> &Builder, const DataLayout &DL,
6806 ArrayRef<uint32_t> BranchWeights) {
6807 // If we are selecting between only two cases transform into a simple
6808 // select or a two-way select if default is possible.
6809 // Example:
6810 // switch (a) { %0 = icmp eq i32 %a, 10
6811 // case 10: return 42; %1 = select i1 %0, i32 42, i32 4
6812 // case 20: return 2; ----> %2 = icmp eq i32 %a, 20
6813 // default: return 4; %3 = select i1 %2, i32 2, i32 %1
6814 // }
6815
6816 const bool HasBranchWeights = !BranchWeights.empty();
6817
6818 if (ResultVector.size() == 2 && ResultVector[0].second.size() == 1 &&
6819 ResultVector[1].second.size() == 1) {
6820 ConstantInt *FirstCase = ResultVector[0].second[0];
6821 ConstantInt *SecondCase = ResultVector[1].second[0];
6822 Value *SelectValue = ResultVector[1].first;
6823 if (DefaultResult) {
6824 Value *ValueCompare =
6825 Builder.CreateICmpEQ(LHS: Condition, RHS: SecondCase, Name: "switch.selectcmp");
6826 SelectValue = Builder.CreateSelect(C: ValueCompare, True: ResultVector[1].first,
6827 False: DefaultResult, Name: "switch.select");
6828 if (auto *SI = dyn_cast<SelectInst>(Val: SelectValue);
6829 SI && HasBranchWeights) {
6830 // We start with 3 probabilities, where the numerator is the
6831 // corresponding BranchWeights[i], and the denominator is the sum over
6832 // BranchWeights. We want the probability and negative probability of
6833 // Condition == SecondCase.
6834 assert(BranchWeights.size() == 3);
6835 setBranchWeights(
6836 I&: *SI, Weights: {BranchWeights[2], BranchWeights[0] + BranchWeights[1]},
6837 /*IsExpected=*/false, /*ElideAllZero=*/true);
6838 }
6839 }
6840 Value *ValueCompare =
6841 Builder.CreateICmpEQ(LHS: Condition, RHS: FirstCase, Name: "switch.selectcmp");
6842 Value *Ret = Builder.CreateSelect(C: ValueCompare, True: ResultVector[0].first,
6843 False: SelectValue, Name: "switch.select");
6844 if (auto *SI = dyn_cast<SelectInst>(Val: Ret); SI && HasBranchWeights) {
6845 // We may have had a DefaultResult. Base the position of the first and
6846 // second's branch weights accordingly. Also the proability that Condition
6847 // != FirstCase needs to take that into account.
6848 assert(BranchWeights.size() >= 2);
6849 size_t FirstCasePos = (Condition != nullptr);
6850 size_t SecondCasePos = FirstCasePos + 1;
6851 uint32_t DefaultCase = (Condition != nullptr) ? BranchWeights[0] : 0;
6852 setBranchWeights(I&: *SI,
6853 Weights: {BranchWeights[FirstCasePos],
6854 DefaultCase + BranchWeights[SecondCasePos]},
6855 /*IsExpected=*/false, /*ElideAllZero=*/true);
6856 }
6857 return Ret;
6858 }
6859
6860 // Handle the degenerate case where two cases have the same result value.
6861 if (ResultVector.size() == 1 && DefaultResult) {
6862 ArrayRef<ConstantInt *> CaseValues = ResultVector[0].second;
6863 unsigned CaseCount = CaseValues.size();
6864 // n bits group cases map to the same result:
6865 // case 0,4 -> Cond & 0b1..1011 == 0 ? result : default
6866 // case 0,2,4,6 -> Cond & 0b1..1001 == 0 ? result : default
6867 // case 0,2,8,10 -> Cond & 0b1..0101 == 0 ? result : default
6868 if (isPowerOf2_32(Value: CaseCount)) {
6869 ConstantInt *MinCaseVal = CaseValues[0];
6870 // If there are bits that are set exclusively by CaseValues, we
6871 // can transform the switch into a select if the conjunction of
6872 // all the values uniquely identify CaseValues.
6873 APInt AndMask = APInt::getAllOnes(numBits: MinCaseVal->getBitWidth());
6874
6875 // Find the minimum value and compute the and of all the case values.
6876 for (auto *Case : CaseValues) {
6877 if (Case->getValue().slt(RHS: MinCaseVal->getValue()))
6878 MinCaseVal = Case;
6879 AndMask &= Case->getValue();
6880 }
6881 KnownBits Known = computeKnownBits(V: Condition, DL);
6882
6883 if (!AndMask.isZero() && Known.getMaxValue().uge(RHS: AndMask)) {
6884 // Compute the number of bits that are free to vary.
6885 unsigned FreeBits = Known.countMaxActiveBits() - AndMask.popcount();
6886
6887 // Check if the number of values covered by the mask is equal
6888 // to the number of cases.
6889 if (FreeBits == Log2_32(Value: CaseCount)) {
6890 Value *And = Builder.CreateAnd(LHS: Condition, RHS: AndMask);
6891 Value *Cmp = Builder.CreateICmpEQ(
6892 LHS: And, RHS: Constant::getIntegerValue(Ty: And->getType(), V: AndMask));
6893 Value *Ret =
6894 Builder.CreateSelect(C: Cmp, True: ResultVector[0].first, False: DefaultResult);
6895 if (auto *SI = dyn_cast<SelectInst>(Val: Ret); SI && HasBranchWeights) {
6896 // We know there's a Default case. We base the resulting branch
6897 // weights off its probability.
6898 assert(BranchWeights.size() >= 2);
6899 setBranchWeights(
6900 I&: *SI,
6901 Weights: {accumulate(Range: drop_begin(RangeOrContainer&: BranchWeights), Init: 0U), BranchWeights[0]},
6902 /*IsExpected=*/false, /*ElideAllZero=*/true);
6903 }
6904 return Ret;
6905 }
6906 }
6907
6908 // Mark the bits case number touched.
6909 APInt BitMask = APInt::getZero(numBits: MinCaseVal->getBitWidth());
6910 for (auto *Case : CaseValues)
6911 BitMask |= (Case->getValue() - MinCaseVal->getValue());
6912
6913 // Check if cases with the same result can cover all number
6914 // in touched bits.
6915 if (BitMask.popcount() == Log2_32(Value: CaseCount)) {
6916 if (!MinCaseVal->isNullValue())
6917 Condition = Builder.CreateSub(LHS: Condition, RHS: MinCaseVal);
6918 Value *And = Builder.CreateAnd(LHS: Condition, RHS: ~BitMask, Name: "switch.and");
6919 Value *Cmp = Builder.CreateICmpEQ(
6920 LHS: And, RHS: Constant::getNullValue(Ty: And->getType()), Name: "switch.selectcmp");
6921 Value *Ret =
6922 Builder.CreateSelect(C: Cmp, True: ResultVector[0].first, False: DefaultResult);
6923 if (auto *SI = dyn_cast<SelectInst>(Val: Ret); SI && HasBranchWeights) {
6924 assert(BranchWeights.size() >= 2);
6925 setBranchWeights(
6926 I&: *SI,
6927 Weights: {accumulate(Range: drop_begin(RangeOrContainer&: BranchWeights), Init: 0U), BranchWeights[0]},
6928 /*IsExpected=*/false, /*ElideAllZero=*/true);
6929 }
6930 return Ret;
6931 }
6932 }
6933
6934 // Handle the degenerate case where two cases have the same value.
6935 if (CaseValues.size() == 2) {
6936 Value *Cmp1 = Builder.CreateICmpEQ(LHS: Condition, RHS: CaseValues[0],
6937 Name: "switch.selectcmp.case1");
6938 Value *Cmp2 = Builder.CreateICmpEQ(LHS: Condition, RHS: CaseValues[1],
6939 Name: "switch.selectcmp.case2");
6940 Value *Cmp = Builder.CreateOr(LHS: Cmp1, RHS: Cmp2, Name: "switch.selectcmp");
6941 Value *Ret =
6942 Builder.CreateSelect(C: Cmp, True: ResultVector[0].first, False: DefaultResult);
6943 if (auto *SI = dyn_cast<SelectInst>(Val: Ret); SI && HasBranchWeights) {
6944 assert(BranchWeights.size() >= 2);
6945 setBranchWeights(
6946 I&: *SI, Weights: {accumulate(Range: drop_begin(RangeOrContainer&: BranchWeights), Init: 0U), BranchWeights[0]},
6947 /*IsExpected=*/false, /*ElideAllZero=*/true);
6948 }
6949 return Ret;
6950 }
6951 }
6952
6953 return nullptr;
6954}
6955
6956// Helper function to cleanup a switch instruction that has been converted into
6957// a select, fixing up PHI nodes and basic blocks.
6958static void removeSwitchAfterSelectFold(SwitchInst *SI, PHINode *PHI,
6959 Value *SelectValue,
6960 IRBuilder<> &Builder,
6961 DomTreeUpdater *DTU) {
6962 std::vector<DominatorTree::UpdateType> Updates;
6963
6964 BasicBlock *SelectBB = SI->getParent();
6965 BasicBlock *DestBB = PHI->getParent();
6966
6967 if (DTU && !is_contained(Range: predecessors(BB: DestBB), Element: SelectBB))
6968 Updates.push_back(x: {DominatorTree::Insert, SelectBB, DestBB});
6969 Builder.CreateBr(Dest: DestBB);
6970
6971 // Remove the switch.
6972
6973 PHI->removeIncomingValueIf(
6974 Predicate: [&](unsigned Idx) { return PHI->getIncomingBlock(i: Idx) == SelectBB; });
6975 PHI->addIncoming(V: SelectValue, BB: SelectBB);
6976
6977 SmallPtrSet<BasicBlock *, 4> RemovedSuccessors;
6978 for (unsigned i = 0, e = SI->getNumSuccessors(); i < e; ++i) {
6979 BasicBlock *Succ = SI->getSuccessor(idx: i);
6980
6981 if (Succ == DestBB)
6982 continue;
6983 Succ->removePredecessor(Pred: SelectBB);
6984 if (DTU && RemovedSuccessors.insert(Ptr: Succ).second)
6985 Updates.push_back(x: {DominatorTree::Delete, SelectBB, Succ});
6986 }
6987 SI->eraseFromParent();
6988 if (DTU)
6989 DTU->applyUpdates(Updates);
6990}
6991
6992/// If a switch is only used to initialize one or more phi nodes in a common
6993/// successor block with only two different constant values, try to replace the
6994/// switch with a select. Returns true if the fold was made.
6995static bool trySwitchToSelect(SwitchInst *SI, IRBuilder<> &Builder,
6996 DomTreeUpdater *DTU, const DataLayout &DL) {
6997 Value *const Cond = SI->getCondition();
6998 PHINode *PHI = nullptr;
6999 BasicBlock *CommonDest = nullptr;
7000 Constant *DefaultResult;
7001 SwitchCaseResultVectorTy UniqueResults;
7002 // Collect all the cases that will deliver the same value from the switch.
7003 if (!initializeUniqueCases(SI, PHI, CommonDest, UniqueResults, DefaultResult,
7004 DL, /*MaxUniqueResults*/ 2))
7005 return false;
7006
7007 assert(PHI != nullptr && "PHI for value select not found");
7008 Builder.SetInsertPoint(SI);
7009 SmallVector<uint32_t, 4> BranchWeights;
7010 [[maybe_unused]] auto HasWeights =
7011 extractBranchWeights(ProfileData: getBranchWeightMDNode(I: *SI), Weights&: BranchWeights);
7012 assert(!HasWeights == (BranchWeights.empty()));
7013 assert(BranchWeights.empty() ||
7014 (BranchWeights.size() >=
7015 UniqueResults.size() + (DefaultResult != nullptr)));
7016
7017 Value *SelectValue = foldSwitchToSelect(ResultVector: UniqueResults, DefaultResult, Condition: Cond,
7018 Builder, DL, BranchWeights);
7019 if (!SelectValue)
7020 return false;
7021
7022 removeSwitchAfterSelectFold(SI, PHI, SelectValue, Builder, DTU);
7023 return true;
7024}
7025
7026namespace {
7027
7028/// This class finds alternatives for switches to ultimately
7029/// replace the switch.
7030class SwitchReplacement {
7031public:
7032 /// Create a helper for optimizations to use as a switch replacement.
7033 /// Find a better representation for the content of Values,
7034 /// using DefaultValue to fill any holes in the table.
7035 /// If no representation is possible, isValid() returns false.
7036 SwitchReplacement(
7037 Module &M, uint64_t TableSize, ConstantInt *Offset,
7038 const SmallVectorImpl<std::pair<ConstantInt *, Constant *>> &Values,
7039 Constant *DefaultValue, const DataLayout &DL,
7040 const TargetTransformInfo &TTI, const StringRef &FuncName);
7041
7042 /// Build instructions with Builder to retrieve values using Index
7043 /// and replace the switch.
7044 Value *replaceSwitch(Value *Index, IRBuilder<> &Builder, const DataLayout &DL,
7045 Function *Func);
7046
7047 /// Return true if a table with TableSize elements of
7048 /// type ElementType would fit in a target-legal register.
7049 static bool wouldFitInRegister(const DataLayout &DL, uint64_t TableSize,
7050 Type *ElementType);
7051
7052 /// Return the default value of the switch.
7053 Constant *getDefaultValue();
7054
7055 /// Return true if the replacement is a lookup table.
7056 bool isLookupTable();
7057
7058 /// Return true if the replacement is a bit map.
7059 bool isBitMap();
7060
7061 /// Return true if a suitable switch replacement was found.
7062 bool isValid() const { return Kind != InvalidKind; }
7063
7064private:
7065 // Depending on the switch, there are different alternatives.
7066 enum {
7067 // No suitable replacement was found.
7068 InvalidKind,
7069
7070 // For switches where each case contains the same value, we just have to
7071 // store that single value and return it for each lookup.
7072 SingleValueKind,
7073
7074 // For switches where there is a linear relationship between table index
7075 // and values. We calculate the result with a simple multiplication
7076 // and addition instead of a table lookup.
7077 LinearMapKind,
7078
7079 // For small tables with integer elements, we can pack them into a bitmap
7080 // that fits into a target-legal register. Values are retrieved by
7081 // shift and mask operations.
7082 BitMapKind,
7083
7084 // The table is stored as an array of values. Values are retrieved by load
7085 // instructions from the table.
7086 LookupTableKind
7087 } Kind;
7088
7089 // The default value of the switch.
7090 Constant *DefaultValue;
7091
7092 // The type of the output values.
7093 Type *ValueType;
7094
7095 // For SingleValueKind, this is the single value.
7096 Constant *SingleValue = nullptr;
7097
7098 // For BitMapKind, this is the bitmap.
7099 ConstantInt *BitMap = nullptr;
7100 IntegerType *BitMapElementTy = nullptr;
7101
7102 // For LinearMapKind, these are the constants used to derive the value.
7103 ConstantInt *LinearOffset = nullptr;
7104 ConstantInt *LinearMultiplier = nullptr;
7105 bool LinearMapValWrapped = false;
7106
7107 // For LookupTableKind, this is the table.
7108 Constant *Initializer = nullptr;
7109};
7110
7111} // end anonymous namespace
7112
7113SwitchReplacement::SwitchReplacement(
7114 Module &M, uint64_t TableSize, ConstantInt *Offset,
7115 const SmallVectorImpl<std::pair<ConstantInt *, Constant *>> &Values,
7116 Constant *DefaultValue, const DataLayout &DL,
7117 const TargetTransformInfo &TTI, const StringRef &FuncName)
7118 : DefaultValue(DefaultValue) {
7119 assert(Values.size() && "Can't build lookup table without values!");
7120 assert(TableSize >= Values.size() && "Can't fit values in table!");
7121
7122 // If all values in the table are equal, this is that value.
7123 SingleValue = Values.begin()->second;
7124
7125 ValueType = Values.begin()->second->getType();
7126
7127 // Build up the table contents.
7128 SmallVector<Constant *, 64> TableContents(TableSize);
7129 for (const auto &[CaseVal, CaseRes] : Values) {
7130 assert(CaseRes->getType() == ValueType);
7131
7132 uint64_t Idx = (CaseVal->getValue() - Offset->getValue()).getLimitedValue();
7133 TableContents[Idx] = CaseRes;
7134
7135 if (SingleValue && !isa<PoisonValue>(Val: CaseRes) && CaseRes != SingleValue)
7136 SingleValue = isa<PoisonValue>(Val: SingleValue) ? CaseRes : nullptr;
7137 }
7138
7139 // Fill in any holes in the table with the default result.
7140 if (Values.size() < TableSize) {
7141 assert(DefaultValue &&
7142 "Need a default value to fill the lookup table holes.");
7143 assert(DefaultValue->getType() == ValueType);
7144 for (uint64_t I = 0; I < TableSize; ++I) {
7145 if (!TableContents[I])
7146 TableContents[I] = DefaultValue;
7147 }
7148
7149 // If the default value is poison, all the holes are poison.
7150 bool DefaultValueIsPoison = isa<PoisonValue>(Val: DefaultValue);
7151
7152 if (DefaultValue != SingleValue && !DefaultValueIsPoison)
7153 SingleValue = nullptr;
7154 }
7155
7156 // If each element in the table contains the same value, we only need to store
7157 // that single value.
7158 if (SingleValue) {
7159 Kind = SingleValueKind;
7160 return;
7161 }
7162
7163 // Check if we can derive the value with a linear transformation from the
7164 // table index.
7165 if (isa<IntegerType>(Val: ValueType)) {
7166 bool LinearMappingPossible = true;
7167 APInt PrevVal;
7168 APInt DistToPrev;
7169 // When linear map is monotonic and signed overflow doesn't happen on
7170 // maximum index, we can attach nsw on Add and Mul.
7171 bool NonMonotonic = false;
7172 assert(TableSize >= 2 && "Should be a SingleValue table.");
7173 // Check if there is the same distance between two consecutive values.
7174 for (uint64_t I = 0; I < TableSize; ++I) {
7175 ConstantInt *ConstVal = dyn_cast<ConstantInt>(Val: TableContents[I]);
7176
7177 if (!ConstVal && isa<PoisonValue>(Val: TableContents[I])) {
7178 // This is an poison, so it's (probably) a lookup table hole.
7179 // To prevent any regressions from before we switched to using poison as
7180 // the default value, holes will fall back to using the first value.
7181 // This can be removed once we add proper handling for poisons in lookup
7182 // tables.
7183 ConstVal = dyn_cast<ConstantInt>(Val: Values[0].second);
7184 }
7185
7186 if (!ConstVal) {
7187 // We only handle literal integers when checking for a linear mapping.
7188 LinearMappingPossible = false;
7189 break;
7190 }
7191 const APInt &Val = ConstVal->getValue();
7192 if (I != 0) {
7193 APInt Dist = Val - PrevVal;
7194 if (I == 1) {
7195 DistToPrev = Dist;
7196 } else if (Dist != DistToPrev) {
7197 LinearMappingPossible = false;
7198 break;
7199 }
7200 NonMonotonic |=
7201 Dist.isStrictlyPositive() ? Val.sle(RHS: PrevVal) : Val.sgt(RHS: PrevVal);
7202 }
7203 PrevVal = Val;
7204 }
7205 if (LinearMappingPossible) {
7206 LinearOffset = cast<ConstantInt>(Val: TableContents[0]);
7207 LinearMultiplier = ConstantInt::get(Context&: M.getContext(), V: DistToPrev);
7208 APInt M = LinearMultiplier->getValue();
7209 bool MayWrap = true;
7210 if (isIntN(N: M.getBitWidth(), x: TableSize - 1))
7211 (void)M.smul_ov(RHS: APInt(M.getBitWidth(), TableSize - 1), Overflow&: MayWrap);
7212 LinearMapValWrapped = NonMonotonic || MayWrap;
7213 Kind = LinearMapKind;
7214 return;
7215 }
7216 }
7217
7218 // If the values are integer constants and the table fits in a register,
7219 // build a bitmap.
7220 if (wouldFitInRegister(DL, TableSize, ElementType: ValueType) &&
7221 all_of(Range&: TableContents, P: IsaPred<ConstantInt, UndefValue>)) {
7222 IntegerType *IT = cast<IntegerType>(Val: ValueType);
7223 APInt TableInt(TableSize * IT->getBitWidth(), 0);
7224 for (uint64_t I = TableSize; I > 0; --I) {
7225 TableInt <<= IT->getBitWidth();
7226 // Insert values into the bitmap. Undef values are set to zero.
7227 if (!isa<UndefValue>(Val: TableContents[I - 1])) {
7228 ConstantInt *Val = cast<ConstantInt>(Val: TableContents[I - 1]);
7229 TableInt |= Val->getValue().zext(width: TableInt.getBitWidth());
7230 }
7231 }
7232 BitMap = ConstantInt::get(Context&: M.getContext(), V: TableInt);
7233 BitMapElementTy = IT;
7234 Kind = BitMapKind;
7235 return;
7236 }
7237
7238 // The remaining representation needs a global initializer.
7239 if (!all_of(Range&: TableContents,
7240 P: [&](Constant *C) { return validLookupTableConstant(C, TTI); })) {
7241 Kind = InvalidKind;
7242 return;
7243 }
7244
7245 if (auto *IT = dyn_cast<IntegerType>(Val: ValueType)) {
7246 ConstantRange Range(IT->getBitWidth(), false);
7247 for (Constant *Value : TableContents)
7248 if (!isa<UndefValue>(Val: Value))
7249 Range = Range.unionWith(CR: cast<ConstantInt>(Val: Value)->getValue());
7250 // TODO: handle sign extension as well?
7251 unsigned NeededBitWidth =
7252 std::max(a: TTI.getMinimumLookupTableEntryBitWidth(),
7253 b: unsigned(PowerOf2Ceil(A: Range.getActiveBits())));
7254 if (NeededBitWidth < IT->getBitWidth()) {
7255 IntegerType *DstTy = IntegerType::get(C&: IT->getContext(), NumBits: NeededBitWidth);
7256 for (Constant *&Value : TableContents)
7257 Value = ConstantFoldCastInstruction(opcode: Instruction::Trunc, V: Value, DestTy: DstTy);
7258 }
7259 }
7260
7261 // Store the table in an array.
7262 auto *TableTy = ArrayType::get(ElementType: TableContents[0]->getType(), NumElements: TableSize);
7263 Initializer = ConstantArray::get(T: TableTy, V: TableContents);
7264
7265 Kind = LookupTableKind;
7266}
7267
7268Value *SwitchReplacement::replaceSwitch(Value *Index, IRBuilder<> &Builder,
7269 const DataLayout &DL, Function *Func) {
7270 switch (Kind) {
7271 case InvalidKind:
7272 llvm_unreachable("Cannot use an invalid switch replacement");
7273 case SingleValueKind:
7274 return SingleValue;
7275 case LinearMapKind: {
7276 ++NumLinearMaps;
7277 // Derive the result value from the input value.
7278 Value *Result = Builder.CreateIntCast(V: Index, DestTy: LinearMultiplier->getType(),
7279 isSigned: false, Name: "switch.idx.cast");
7280 if (!LinearMultiplier->isOne())
7281 Result = Builder.CreateMul(LHS: Result, RHS: LinearMultiplier, Name: "switch.idx.mult",
7282 /*HasNUW = */ false,
7283 /*HasNSW = */ !LinearMapValWrapped);
7284
7285 if (!LinearOffset->isZero())
7286 Result = Builder.CreateAdd(LHS: Result, RHS: LinearOffset, Name: "switch.offset",
7287 /*HasNUW = */ false,
7288 /*HasNSW = */ !LinearMapValWrapped);
7289 return Result;
7290 }
7291 case BitMapKind: {
7292 ++NumBitMaps;
7293 // Type of the bitmap (e.g. i59).
7294 IntegerType *MapTy = BitMap->getIntegerType();
7295
7296 // Cast Index to the same type as the bitmap.
7297 // Note: The Index is <= the number of elements in the table, so
7298 // truncating it to the width of the bitmask is safe.
7299 Value *ShiftAmt = Builder.CreateZExtOrTrunc(V: Index, DestTy: MapTy, Name: "switch.cast");
7300
7301 // Multiply the shift amount by the element width. NUW/NSW can always be
7302 // set, because wouldFitInRegister guarantees Index * ShiftAmt is in
7303 // BitMap's bit width.
7304 ShiftAmt = Builder.CreateMul(
7305 LHS: ShiftAmt, RHS: ConstantInt::get(Ty: MapTy, V: BitMapElementTy->getBitWidth()),
7306 Name: "switch.shiftamt",/*HasNUW =*/true,/*HasNSW =*/true);
7307
7308 // Shift down.
7309 Value *DownShifted =
7310 Builder.CreateLShr(LHS: BitMap, RHS: ShiftAmt, Name: "switch.downshift");
7311 // Mask off.
7312 return Builder.CreateTrunc(V: DownShifted, DestTy: BitMapElementTy, Name: "switch.masked");
7313 }
7314 case LookupTableKind: {
7315 ++NumLookupTables;
7316 auto *Table =
7317 new GlobalVariable(*Func->getParent(), Initializer->getType(),
7318 /*isConstant=*/true, GlobalVariable::PrivateLinkage,
7319 Initializer, "switch.table." + Func->getName());
7320 Table->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
7321 // Set the alignment to that of an array items. We will be only loading one
7322 // value out of it.
7323 Table->setAlignment(DL.getPrefTypeAlign(Ty: ValueType));
7324 Type *IndexTy = DL.getIndexType(PtrTy: Table->getType());
7325 auto *ArrayTy = cast<ArrayType>(Val: Table->getValueType());
7326
7327 if (Index->getType() != IndexTy) {
7328 unsigned OldBitWidth = Index->getType()->getIntegerBitWidth();
7329 Index = Builder.CreateZExtOrTrunc(V: Index, DestTy: IndexTy);
7330 if (auto *Zext = dyn_cast<ZExtInst>(Val: Index))
7331 Zext->setNonNeg(
7332 isUIntN(N: OldBitWidth - 1, x: ArrayTy->getNumElements() - 1));
7333 }
7334
7335 Value *GEPIndices[] = {ConstantInt::get(Ty: IndexTy, V: 0), Index};
7336 Value *GEP =
7337 Builder.CreateInBoundsGEP(Ty: ArrayTy, Ptr: Table, IdxList: GEPIndices, Name: "switch.gep");
7338 Value *Load =
7339 Builder.CreateLoad(Ty: ArrayTy->getElementType(), Ptr: GEP, Name: "switch.load");
7340 if (Load->getType() == ValueType)
7341 return Load;
7342 return Builder.CreateZExt(V: Load, DestTy: ValueType, Name: "switch.ext");
7343 }
7344 }
7345 llvm_unreachable("Unknown helper kind!");
7346}
7347
7348bool SwitchReplacement::wouldFitInRegister(const DataLayout &DL,
7349 uint64_t TableSize,
7350 Type *ElementType) {
7351 auto *IT = dyn_cast<IntegerType>(Val: ElementType);
7352 if (!IT)
7353 return false;
7354 // FIXME: If the type is wider than it needs to be, e.g. i8 but all values
7355 // are <= 15, we could try to narrow the type.
7356
7357 // Avoid overflow, fitsInLegalInteger uses unsigned int for the width.
7358 if (TableSize >= UINT_MAX / IT->getBitWidth())
7359 return false;
7360 return DL.fitsInLegalInteger(Width: TableSize * IT->getBitWidth());
7361}
7362
7363static bool isTypeLegalForLookupTable(Type *Ty, const TargetTransformInfo &TTI,
7364 const DataLayout &DL) {
7365 // Allow any legal type.
7366 if (TTI.isTypeLegal(Ty))
7367 return true;
7368
7369 auto *IT = dyn_cast<IntegerType>(Val: Ty);
7370 if (!IT)
7371 return false;
7372
7373 // Also allow power of 2 integer types that have at least 8 bits and fit in
7374 // a register. These types are common in frontend languages and targets
7375 // usually support loads of these types.
7376 // TODO: We could relax this to any integer that fits in a register and rely
7377 // on ABI alignment and padding in the table to allow the load to be widened.
7378 // Or we could widen the constants and truncate the load.
7379 unsigned BitWidth = IT->getBitWidth();
7380 return BitWidth >= 8 && isPowerOf2_32(Value: BitWidth) &&
7381 DL.fitsInLegalInteger(Width: IT->getBitWidth());
7382}
7383
7384Constant *SwitchReplacement::getDefaultValue() { return DefaultValue; }
7385
7386bool SwitchReplacement::isLookupTable() { return Kind == LookupTableKind; }
7387
7388bool SwitchReplacement::isBitMap() { return Kind == BitMapKind; }
7389
7390static bool isSwitchDense(uint64_t NumCases, uint64_t CaseRange, bool OptSize) {
7391 // 40% is the default density for building a jump table in optsize/minsize
7392 // mode, 10% is the default density for jump tables. See also
7393 // TargetLoweringBase::isSuitableForJumpTable(), which this function was based
7394 // on.
7395 const uint64_t MinDensity = OptSize ? 40 : 10;
7396
7397 if (CaseRange >= UINT64_MAX / 100)
7398 return false; // Avoid multiplication overflows below.
7399
7400 return NumCases * 100 >= CaseRange * MinDensity;
7401}
7402
7403static bool isSwitchDense(ArrayRef<int64_t> Values, bool OptSize) {
7404 uint64_t Diff = (uint64_t)Values.back() - (uint64_t)Values.front();
7405 uint64_t Range = Diff + 1;
7406 if (Range < Diff)
7407 return false; // Overflow.
7408
7409 return isSwitchDense(NumCases: Values.size(), CaseRange: Range, OptSize);
7410}
7411
7412static std::optional<unsigned>
7413getDenseSwitchRangeReductionShift(ArrayRef<int64_t> Values, int64_t Base,
7414 bool OptSize) {
7415 assert(Values.size() > 1 && "expected multiple switch cases");
7416 if (!llvm::all_of(Range&: Values, P: [Base](int64_t V) { return V >= Base; }))
7417 return std::nullopt;
7418
7419 // First, transform the values by subtracting Base.
7420 SmallVector<int64_t, 4> ReducedValues(Values);
7421 uint64_t ReducedValuesOr = 0;
7422 for (auto &V : ReducedValues) {
7423 uint64_t Reduced = (uint64_t)V - (uint64_t)Base;
7424 ReducedValuesOr |= Reduced;
7425 V = (int64_t)Reduced;
7426 }
7427
7428 // Conceptually, the reduced values are non-negative distances from Base.
7429 // Since the rest of the transform is bitwise only, treat them as unsigned
7430 // bit patterns from here.
7431
7432 // countr_zero(0) returns 64. As Values is guaranteed to have more than
7433 // one element and LLVM disallows duplicate cases, ReducedValuesOr will
7434 // have at least one bit set, so Shift will be less than 64.
7435 unsigned Shift = llvm::countr_zero(Val: ReducedValuesOr);
7436 assert(Shift < 64);
7437 if (Shift > 0)
7438 for (auto &V : ReducedValues)
7439 V = (int64_t)((uint64_t)V >> Shift);
7440
7441 if (!isSwitchDense(Values: ReducedValues, OptSize))
7442 return std::nullopt;
7443
7444 return Shift;
7445}
7446
7447/// Determine whether a lookup table should be built for this switch, based on
7448/// the number of cases, size of the table, and the types of the results.
7449// TODO: We could support larger than legal types by limiting based on the
7450// number of loads required and/or table size. If the constants are small we
7451// could use smaller table entries and extend after the load.
7452static bool shouldBuildLookupTable(SwitchInst *SI, uint64_t TableSize,
7453 const TargetTransformInfo &TTI,
7454 const DataLayout &DL,
7455 const SmallVector<Type *> &ResultTypes) {
7456 if (SI->getNumCases() > TableSize)
7457 return false; // TableSize overflowed.
7458
7459 bool AllTablesFitInRegister = true;
7460 bool HasIllegalType = false;
7461 for (const auto &Ty : ResultTypes) {
7462 // Saturate this flag to true.
7463 HasIllegalType = HasIllegalType || !isTypeLegalForLookupTable(Ty, TTI, DL);
7464
7465 // Saturate this flag to false.
7466 AllTablesFitInRegister =
7467 AllTablesFitInRegister &&
7468 SwitchReplacement::wouldFitInRegister(DL, TableSize, ElementType: Ty);
7469
7470 // If both flags saturate, we're done. NOTE: This *only* works with
7471 // saturating flags, and all flags have to saturate first due to the
7472 // non-deterministic behavior of iterating over a dense map.
7473 if (HasIllegalType && !AllTablesFitInRegister)
7474 break;
7475 }
7476
7477 // If each table would fit in a register, we should build it anyway.
7478 if (AllTablesFitInRegister)
7479 return true;
7480
7481 // Don't build a table that doesn't fit in-register if it has illegal types.
7482 if (HasIllegalType)
7483 return false;
7484
7485 return isSwitchDense(NumCases: SI->getNumCases(), CaseRange: TableSize,
7486 OptSize: SI->getFunction()->hasOptSize());
7487}
7488
7489static bool shouldUseSwitchConditionAsTableIndex(
7490 ConstantInt &MinCaseVal, const ConstantInt &MaxCaseVal,
7491 bool HasDefaultResults, const SmallVector<Type *> &ResultTypes,
7492 const DataLayout &DL, const TargetTransformInfo &TTI) {
7493 if (MinCaseVal.isNullValue())
7494 return true;
7495 if (MinCaseVal.isNegative() ||
7496 MaxCaseVal.getLimitedValue() == std::numeric_limits<uint64_t>::max() ||
7497 !HasDefaultResults)
7498 return false;
7499 return all_of(Range: ResultTypes, P: [&](const auto &ResultType) {
7500 return SwitchReplacement::wouldFitInRegister(
7501 DL, TableSize: MaxCaseVal.getLimitedValue() + 1 /* TableSize */, ElementType: ResultType);
7502 });
7503}
7504
7505/// Try to reuse the switch table index compare. Following pattern:
7506/// \code
7507/// if (idx < tablesize)
7508/// r = table[idx]; // table does not contain default_value
7509/// else
7510/// r = default_value;
7511/// if (r != default_value)
7512/// ...
7513/// \endcode
7514/// Is optimized to:
7515/// \code
7516/// cond = idx < tablesize;
7517/// if (cond)
7518/// r = table[idx];
7519/// else
7520/// r = default_value;
7521/// if (cond)
7522/// ...
7523/// \endcode
7524/// Jump threading will then eliminate the second if(cond).
7525static void reuseTableCompare(
7526 User *PhiUser, BasicBlock *PhiBlock, CondBrInst *RangeCheckBranch,
7527 Constant *DefaultValue,
7528 const SmallVectorImpl<std::pair<ConstantInt *, Constant *>> &Values) {
7529 ICmpInst *CmpInst = dyn_cast<ICmpInst>(Val: PhiUser);
7530 if (!CmpInst)
7531 return;
7532
7533 // We require that the compare is in the same block as the phi so that jump
7534 // threading can do its work afterwards.
7535 if (CmpInst->getParent() != PhiBlock)
7536 return;
7537
7538 Constant *CmpOp1 = dyn_cast<Constant>(Val: CmpInst->getOperand(i_nocapture: 1));
7539 if (!CmpOp1)
7540 return;
7541
7542 Value *RangeCmp = RangeCheckBranch->getCondition();
7543 Constant *TrueConst = ConstantInt::getTrue(Ty: RangeCmp->getType());
7544 Constant *FalseConst = ConstantInt::getFalse(Ty: RangeCmp->getType());
7545
7546 // Check if the compare with the default value is constant true or false.
7547 const DataLayout &DL = PhiBlock->getDataLayout();
7548 Constant *DefaultConst = ConstantFoldCompareInstOperands(
7549 Predicate: CmpInst->getPredicate(), LHS: DefaultValue, RHS: CmpOp1, DL);
7550 if (DefaultConst != TrueConst && DefaultConst != FalseConst)
7551 return;
7552
7553 // Check if the compare with the case values is distinct from the default
7554 // compare result.
7555 for (auto ValuePair : Values) {
7556 Constant *CaseConst = ConstantFoldCompareInstOperands(
7557 Predicate: CmpInst->getPredicate(), LHS: ValuePair.second, RHS: CmpOp1, DL);
7558 if (!CaseConst || CaseConst == DefaultConst ||
7559 (CaseConst != TrueConst && CaseConst != FalseConst))
7560 return;
7561 }
7562
7563 // Check if the branch instruction dominates the phi node. It's a simple
7564 // dominance check, but sufficient for our needs.
7565 // Although this check is invariant in the calling loops, it's better to do it
7566 // at this late stage. Practically we do it at most once for a switch.
7567 BasicBlock *BranchBlock = RangeCheckBranch->getParent();
7568 for (BasicBlock *Pred : predecessors(BB: PhiBlock)) {
7569 if (Pred != BranchBlock && Pred->getUniquePredecessor() != BranchBlock)
7570 return;
7571 }
7572
7573 if (DefaultConst == FalseConst) {
7574 // The compare yields the same result. We can replace it.
7575 CmpInst->replaceAllUsesWith(V: RangeCmp);
7576 ++NumTableCmpReuses;
7577 } else {
7578 // The compare yields the same result, just inverted. We can replace it.
7579 Value *InvertedTableCmp = BinaryOperator::CreateXor(
7580 V1: RangeCmp, V2: ConstantInt::get(Ty: RangeCmp->getType(), V: 1), Name: "inverted.cmp",
7581 InsertBefore: RangeCheckBranch->getIterator());
7582 CmpInst->replaceAllUsesWith(V: InvertedTableCmp);
7583 ++NumTableCmpReuses;
7584 }
7585}
7586
7587/// If the switch is only used to initialize one or more phi nodes in a common
7588/// successor block with different constant values, replace the switch with
7589/// lookup tables.
7590static bool simplifySwitchLookup(SwitchInst *SI, IRBuilder<> &Builder,
7591 DomTreeUpdater *DTU, const DataLayout &DL,
7592 const TargetTransformInfo &TTI,
7593 bool ConvertSwitchToLookupTable) {
7594 assert(SI->getNumCases() > 1 && "Degenerate switch?");
7595
7596 BasicBlock *BB = SI->getParent();
7597 Function *Fn = BB->getParent();
7598
7599 // FIXME: If the switch is too sparse for a lookup table, perhaps we could
7600 // split off a dense part and build a lookup table for that.
7601
7602 // FIXME: This creates arrays of GEPs to constant strings, which means each
7603 // GEP needs a runtime relocation in PIC code. We should just build one big
7604 // string and lookup indices into that.
7605
7606 // Ignore switches with less than three cases. Lookup tables will not make
7607 // them faster, so we don't analyze them.
7608 if (SI->getNumCases() < 3)
7609 return false;
7610
7611 // Figure out the corresponding result for each case value and phi node in the
7612 // common destination, as well as the min and max case values.
7613 assert(!SI->cases().empty());
7614 SwitchInst::CaseIt CI = SI->case_begin();
7615 ConstantInt *MinCaseVal = CI->getCaseValue();
7616 ConstantInt *MaxCaseVal = CI->getCaseValue();
7617
7618 BasicBlock *CommonDest = nullptr;
7619
7620 using ResultListTy = SmallVector<std::pair<ConstantInt *, Constant *>, 4>;
7621 SmallDenseMap<PHINode *, ResultListTy> ResultLists;
7622
7623 SmallDenseMap<PHINode *, Constant *> DefaultResults;
7624 SmallVector<Type *> ResultTypes;
7625 SmallVector<PHINode *, 4> PHIs;
7626
7627 for (SwitchInst::CaseIt E = SI->case_end(); CI != E; ++CI) {
7628 ConstantInt *CaseVal = CI->getCaseValue();
7629 if (CaseVal->getValue().slt(RHS: MinCaseVal->getValue()))
7630 MinCaseVal = CaseVal;
7631 if (CaseVal->getValue().sgt(RHS: MaxCaseVal->getValue()))
7632 MaxCaseVal = CaseVal;
7633
7634 // Resulting value at phi nodes for this case value.
7635 using ResultsTy = SmallVector<std::pair<PHINode *, Constant *>, 4>;
7636 ResultsTy Results;
7637 if (!getCaseResults(SI, CaseVal, CaseDest: CI->getCaseSuccessor(), CommonDest: &CommonDest,
7638 Res&: Results, DL))
7639 return false;
7640
7641 // Append the result and result types from this case to the list for each
7642 // phi.
7643 for (const auto &I : Results) {
7644 PHINode *PHI = I.first;
7645 Constant *Value = I.second;
7646 auto [It, Inserted] = ResultLists.try_emplace(Key: PHI);
7647 if (Inserted)
7648 PHIs.push_back(Elt: PHI);
7649 It->second.push_back(Elt: std::make_pair(x&: CaseVal, y&: Value));
7650 ResultTypes.push_back(Elt: PHI->getType());
7651 }
7652 }
7653
7654 // If the table has holes, we need a constant result for the default case
7655 // or a bitmask that fits in a register.
7656 SmallVector<std::pair<PHINode *, Constant *>, 4> DefaultResultsList;
7657 bool HasDefaultResults = getCaseResults(SI, CaseVal: nullptr, CaseDest: SI->getDefaultDest(),
7658 CommonDest: &CommonDest, Res&: DefaultResultsList, DL);
7659 for (const auto &I : DefaultResultsList) {
7660 PHINode *PHI = I.first;
7661 Constant *Result = I.second;
7662 DefaultResults[PHI] = Result;
7663 }
7664
7665 bool UseSwitchConditionAsTableIndex = shouldUseSwitchConditionAsTableIndex(
7666 MinCaseVal&: *MinCaseVal, MaxCaseVal: *MaxCaseVal, HasDefaultResults, ResultTypes, DL, TTI);
7667 uint64_t TableSize;
7668 ConstantInt *TableIndexOffset;
7669 if (UseSwitchConditionAsTableIndex) {
7670 TableSize = MaxCaseVal->getLimitedValue() + 1;
7671 TableIndexOffset = ConstantInt::get(Ty: MaxCaseVal->getIntegerType(), V: 0);
7672 } else {
7673 TableSize =
7674 (MaxCaseVal->getValue() - MinCaseVal->getValue()).getLimitedValue() + 1;
7675
7676 TableIndexOffset = MinCaseVal;
7677 }
7678
7679 // If the default destination is unreachable, or if the lookup table covers
7680 // all values of the conditional variable, branch directly to the lookup table
7681 // BB. Otherwise, check that the condition is within the case range.
7682 uint64_t NumResults = ResultLists[PHIs[0]].size();
7683 bool DefaultIsReachable = !SI->defaultDestUnreachable();
7684
7685 bool TableHasHoles = (NumResults < TableSize);
7686
7687 // If the table has holes but the default destination doesn't produce any
7688 // constant results, the lookup table entries corresponding to the holes will
7689 // contain poison.
7690 bool AllHolesArePoison = TableHasHoles && !HasDefaultResults;
7691
7692 // If the default destination doesn't produce a constant result but is still
7693 // reachable, and the lookup table has holes, we need to use a mask to
7694 // determine if the current index should load from the lookup table or jump
7695 // to the default case.
7696 // The mask is unnecessary if the table has holes but the default destination
7697 // is unreachable, as in that case the holes must also be unreachable.
7698 bool NeedMask = AllHolesArePoison && DefaultIsReachable;
7699 if (NeedMask) {
7700 // As an extra penalty for the validity test we require more cases.
7701 if (SI->getNumCases() < 4) // FIXME: Find best threshold value (benchmark).
7702 return false;
7703 if (!DL.fitsInLegalInteger(Width: TableSize))
7704 return false;
7705 }
7706
7707 if (!shouldBuildLookupTable(SI, TableSize, TTI, DL, ResultTypes))
7708 return false;
7709
7710 // Compute the table index value.
7711 Value *TableIndex;
7712 if (UseSwitchConditionAsTableIndex) {
7713 TableIndex = SI->getCondition();
7714 if (HasDefaultResults) {
7715 // Grow the table to cover all possible index values to avoid the range
7716 // check. It will use the default result to fill in the table hole later,
7717 // so make sure it exist.
7718 ConstantRange CR = computeConstantRange(V: TableIndex, /*ForSigned=*/false,
7719 SQ: SimplifyQuery(DL));
7720 // Grow the table shouldn't have any size impact by checking
7721 // wouldFitInRegister.
7722 // TODO: Consider growing the table also when it doesn't fit in a register
7723 // if no optsize is specified.
7724 const uint64_t UpperBound = CR.getUpper().getLimitedValue();
7725 if (!CR.isUpperWrapped() &&
7726 all_of(Range&: ResultTypes, P: [&](const auto &ResultType) {
7727 return SwitchReplacement::wouldFitInRegister(DL, TableSize: UpperBound,
7728 ElementType: ResultType);
7729 })) {
7730 // There may be some case index larger than the UpperBound (unreachable
7731 // case), so make sure the table size does not get smaller.
7732 TableSize = std::max(a: UpperBound, b: TableSize);
7733 // The default branch is unreachable after we enlarge the lookup table.
7734 // Adjust DefaultIsReachable to reuse code path.
7735 DefaultIsReachable = false;
7736 }
7737 }
7738 }
7739
7740 // Keep track of the switch replacement for each phi
7741 SmallDenseMap<PHINode *, SwitchReplacement> PhiToReplacementMap;
7742 for (PHINode *PHI : PHIs) {
7743 const auto &ResultList = ResultLists[PHI];
7744
7745 Type *ResultType = ResultList.begin()->second->getType();
7746 // Use any value to fill the lookup table holes.
7747 Constant *DefaultVal =
7748 AllHolesArePoison ? PoisonValue::get(T: ResultType) : DefaultResults[PHI];
7749 StringRef FuncName = Fn->getName();
7750 SwitchReplacement Replacement(*Fn->getParent(), TableSize, TableIndexOffset,
7751 ResultList, DefaultVal, DL, TTI, FuncName);
7752 if (!Replacement.isValid())
7753 return false;
7754 PhiToReplacementMap.insert(KV: {PHI, Replacement});
7755 }
7756
7757 bool AnyLookupTables = any_of(
7758 Range&: PhiToReplacementMap, P: [](auto &KV) { return KV.second.isLookupTable(); });
7759 bool AnyBitMaps = any_of(Range&: PhiToReplacementMap,
7760 P: [](auto &KV) { return KV.second.isBitMap(); });
7761
7762 // A few conditions prevent the generation of lookup tables:
7763 // 1. The target does not support lookup tables.
7764 // 2. The "no-jump-tables" function attribute is set.
7765 // However, these objections do not apply to other switch replacements, like
7766 // the bitmap, so we only stop here if any of these conditions are met and we
7767 // want to create a LUT. Otherwise, continue with the switch replacement.
7768 if (AnyLookupTables &&
7769 (!TTI.shouldBuildLookupTables() ||
7770 Fn->getFnAttribute(Kind: "no-jump-tables").getValueAsBool()))
7771 return false;
7772
7773 // In the early optimization pipeline, disable formation of lookup tables,
7774 // bit maps and mask checks, as they may inhibit further optimization.
7775 if (!ConvertSwitchToLookupTable &&
7776 (AnyLookupTables || AnyBitMaps || NeedMask))
7777 return false;
7778
7779 Builder.SetInsertPoint(SI);
7780 // TableIndex is the switch condition - TableIndexOffset if we don't
7781 // use the condition directly
7782 if (!UseSwitchConditionAsTableIndex) {
7783 // If the default is unreachable, all case values are s>= MinCaseVal. Then
7784 // we can try to attach nsw.
7785 bool MayWrap = true;
7786 if (!DefaultIsReachable) {
7787 APInt Res =
7788 MaxCaseVal->getValue().ssub_ov(RHS: MinCaseVal->getValue(), Overflow&: MayWrap);
7789 (void)Res;
7790 }
7791 TableIndex = Builder.CreateSub(LHS: SI->getCondition(), RHS: TableIndexOffset,
7792 Name: "switch.tableidx", /*HasNUW =*/false,
7793 /*HasNSW =*/!MayWrap);
7794 }
7795
7796 std::vector<DominatorTree::UpdateType> Updates;
7797
7798 // Compute the maximum table size representable by the integer type we are
7799 // switching upon.
7800 unsigned CaseSize = MinCaseVal->getType()->getPrimitiveSizeInBits();
7801 uint64_t MaxTableSize = CaseSize > 63 ? UINT64_MAX : 1ULL << CaseSize;
7802 assert(MaxTableSize >= TableSize &&
7803 "It is impossible for a switch to have more entries than the max "
7804 "representable value of its input integer type's size.");
7805
7806 // Create the BB that does the lookups.
7807 Module &Mod = *CommonDest->getParent()->getParent();
7808 BasicBlock *LookupBB = BasicBlock::Create(
7809 Context&: Mod.getContext(), Name: "switch.lookup", Parent: CommonDest->getParent(), InsertBefore: CommonDest);
7810
7811 CondBrInst *RangeCheckBranch = nullptr;
7812 CondBrInst *CondBranch = nullptr;
7813
7814 Builder.SetInsertPoint(SI);
7815 const bool GeneratingCoveredLookupTable = (MaxTableSize == TableSize);
7816 if (!DefaultIsReachable || GeneratingCoveredLookupTable) {
7817 Builder.CreateBr(Dest: LookupBB);
7818 if (DTU)
7819 Updates.push_back(x: {DominatorTree::Insert, BB, LookupBB});
7820 // Note: We call removeProdecessor later since we need to be able to get the
7821 // PHI value for the default case in case we're using a bit mask.
7822 } else {
7823 Value *Cmp = Builder.CreateICmpULT(
7824 LHS: TableIndex, RHS: ConstantInt::get(Ty: MinCaseVal->getType(), V: TableSize));
7825 RangeCheckBranch =
7826 Builder.CreateCondBr(Cond: Cmp, True: LookupBB, False: SI->getDefaultDest());
7827 CondBranch = RangeCheckBranch;
7828 if (DTU)
7829 Updates.push_back(x: {DominatorTree::Insert, BB, LookupBB});
7830 }
7831
7832 // Populate the BB that does the lookups.
7833 Builder.SetInsertPoint(LookupBB);
7834
7835 if (NeedMask) {
7836 // Before doing the lookup, we do the hole check. The LookupBB is therefore
7837 // re-purposed to do the hole check, and we create a new LookupBB.
7838 BasicBlock *MaskBB = LookupBB;
7839 MaskBB->setName("switch.hole_check");
7840 LookupBB = BasicBlock::Create(Context&: Mod.getContext(), Name: "switch.lookup",
7841 Parent: CommonDest->getParent(), InsertBefore: CommonDest);
7842
7843 // Make the mask's bitwidth at least 8-bit and a power-of-2 to avoid
7844 // unnecessary illegal types.
7845 uint64_t TableSizePowOf2 = NextPowerOf2(A: std::max(a: 7ULL, b: TableSize - 1ULL));
7846 APInt MaskInt(TableSizePowOf2, 0);
7847 APInt One(TableSizePowOf2, 1);
7848 // Build bitmask; fill in a 1 bit for every case.
7849 const ResultListTy &ResultList = ResultLists[PHIs[0]];
7850 for (const auto &Result : ResultList) {
7851 uint64_t Idx = (Result.first->getValue() - TableIndexOffset->getValue())
7852 .getLimitedValue();
7853 MaskInt |= One << Idx;
7854 }
7855 ConstantInt *TableMask = ConstantInt::get(Context&: Mod.getContext(), V: MaskInt);
7856
7857 // Get the TableIndex'th bit of the bitmask.
7858 // If this bit is 0 (meaning hole) jump to the default destination,
7859 // else continue with table lookup.
7860 IntegerType *MapTy = TableMask->getIntegerType();
7861 Value *MaskIndex =
7862 Builder.CreateZExtOrTrunc(V: TableIndex, DestTy: MapTy, Name: "switch.maskindex");
7863 Value *Shifted = Builder.CreateLShr(LHS: TableMask, RHS: MaskIndex, Name: "switch.shifted");
7864 Value *LoBit = Builder.CreateTrunc(
7865 V: Shifted, DestTy: Type::getInt1Ty(C&: Mod.getContext()), Name: "switch.lobit");
7866 CondBranch = Builder.CreateCondBr(Cond: LoBit, True: LookupBB, False: SI->getDefaultDest());
7867 if (DTU) {
7868 Updates.push_back(x: {DominatorTree::Insert, MaskBB, LookupBB});
7869 Updates.push_back(x: {DominatorTree::Insert, MaskBB, SI->getDefaultDest()});
7870 }
7871 Builder.SetInsertPoint(LookupBB);
7872 addPredecessorToBlock(Succ: SI->getDefaultDest(), NewPred: MaskBB, ExistPred: BB);
7873 }
7874
7875 if (!DefaultIsReachable || GeneratingCoveredLookupTable) {
7876 // We cached PHINodes in PHIs. To avoid accessing deleted PHINodes later,
7877 // do not delete PHINodes here.
7878 SI->getDefaultDest()->removePredecessor(Pred: BB,
7879 /*KeepOneInputPHIs=*/true);
7880 if (DTU)
7881 Updates.push_back(x: {DominatorTree::Delete, BB, SI->getDefaultDest()});
7882 }
7883
7884 for (PHINode *PHI : PHIs) {
7885 const ResultListTy &ResultList = ResultLists[PHI];
7886 auto Replacement = PhiToReplacementMap.at(Val: PHI);
7887 auto *Result = Replacement.replaceSwitch(Index: TableIndex, Builder, DL, Func: Fn);
7888 // Do a small peephole optimization: re-use the switch table compare if
7889 // possible.
7890 if (!TableHasHoles && HasDefaultResults && RangeCheckBranch) {
7891 BasicBlock *PhiBlock = PHI->getParent();
7892 // Search for compare instructions which use the phi.
7893 for (auto *User : PHI->users()) {
7894 reuseTableCompare(PhiUser: User, PhiBlock, RangeCheckBranch,
7895 DefaultValue: Replacement.getDefaultValue(), Values: ResultList);
7896 }
7897 }
7898
7899 PHI->addIncoming(V: Result, BB: LookupBB);
7900 }
7901
7902 Builder.CreateBr(Dest: CommonDest);
7903 if (DTU)
7904 Updates.push_back(x: {DominatorTree::Insert, LookupBB, CommonDest});
7905
7906 SmallVector<uint32_t> BranchWeights;
7907 const bool HasBranchWeights =
7908 CondBranch && extractBranchWeights(I: *SI, Weights&: BranchWeights);
7909 uint64_t ToLookupWeight = 0;
7910 uint64_t ToDefaultWeight = 0;
7911
7912 // Remove the switch.
7913 SmallPtrSet<BasicBlock *, 8> RemovedSuccessors;
7914 for (unsigned I = 0, E = SI->getNumSuccessors(); I < E; ++I) {
7915 BasicBlock *Succ = SI->getSuccessor(idx: I);
7916
7917 if (Succ == SI->getDefaultDest()) {
7918 if (HasBranchWeights)
7919 ToDefaultWeight += BranchWeights[I];
7920 continue;
7921 }
7922 Succ->removePredecessor(Pred: BB);
7923 if (DTU && RemovedSuccessors.insert(Ptr: Succ).second)
7924 Updates.push_back(x: {DominatorTree::Delete, BB, Succ});
7925 if (HasBranchWeights)
7926 ToLookupWeight += BranchWeights[I];
7927 }
7928 SI->eraseFromParent();
7929 if (HasBranchWeights)
7930 setFittedBranchWeights(I&: *CondBranch, Weights: {ToLookupWeight, ToDefaultWeight},
7931 /*IsExpected=*/false);
7932 if (DTU)
7933 DTU->applyUpdates(Updates);
7934
7935 if (NeedMask)
7936 ++NumLookupTablesHoles;
7937 return true;
7938}
7939
7940/// Try to transform a switch that has "holes" in it to a contiguous sequence
7941/// of cases.
7942///
7943/// A switch such as: switch(i) {case 5: case 9: case 13: case 17:} can be
7944/// range-reduced to: switch ((i-5) / 4) {case 0: case 1: case 2: case 3:}.
7945///
7946/// This converts a sparse switch into a dense switch which allows better
7947/// lowering and could also allow transforming into a lookup table.
7948static bool reduceSwitchRange(SwitchInst *SI, IRBuilder<> &Builder,
7949 const DataLayout &DL,
7950 const TargetTransformInfo &TTI) {
7951 auto *CondTy = cast<IntegerType>(Val: SI->getCondition()->getType());
7952 if (CondTy->getIntegerBitWidth() > 64 ||
7953 !DL.fitsInLegalInteger(Width: CondTy->getIntegerBitWidth()))
7954 return false;
7955 // Only bother with this optimization if there are more than 3 switch cases;
7956 // SDAG will only bother creating jump tables for 4 or more cases.
7957 if (SI->getNumCases() < 4)
7958 return false;
7959
7960 // This transform is agnostic to the signedness of the input or case values. We
7961 // can treat the case values as signed or unsigned. We can optimize more common
7962 // cases such as a sequence crossing zero {-4,0,4,8} if we interpret case values
7963 // as signed.
7964 SmallVector<int64_t,4> Values;
7965 for (const auto &C : SI->cases())
7966 Values.push_back(Elt: C.getCaseValue()->getValue().getSExtValue());
7967 llvm::sort(C&: Values);
7968
7969 // If the switch is already dense, there's nothing useful to do here.
7970 bool OptSize = SI->getFunction()->hasOptSize();
7971 if (isSwitchDense(Values, OptSize))
7972 return false;
7973
7974 // Find a Base and corresponding Shift that results in a dense switch range.
7975 // Values[0] is the local minimum.
7976 int64_t Base = Values[0];
7977 std::optional<unsigned> Shift;
7978 // Prefer Base=0 when shifting out common low zero bits still produces a dense
7979 // range, as this avoids an unnecessary `(condition - local_min)` expression.
7980 // However, avoiding the subtract can leave a wider reduced range than using
7981 // the local minimum, so require Base=0 to satisfy the stricter optsize
7982 // density threshold before falling back to the normal density policy for
7983 // local-min.
7984 if ((Shift = getDenseSwitchRangeReductionShift(Values, /*Base=*/0,
7985 /*OptSize=*/true)))
7986 Base = 0;
7987 else if (Base != 0)
7988 Shift = getDenseSwitchRangeReductionShift(Values, Base, OptSize);
7989
7990 if (!Shift)
7991 return false;
7992
7993 // The obvious transform is to shift the switch condition right and emit a
7994 // check that the condition actually cleanly divided by GCD, i.e.
7995 // C & (1 << Shift - 1) == 0
7996 // inserting a new CFG edge to handle the case where it didn't divide cleanly.
7997 //
7998 // A cheaper way of doing this is a simple ROTR(C, Shift). This performs the
7999 // shift and puts the shifted-off bits in the uppermost bits. If any of these
8000 // are nonzero then the switch condition will be very large and will hit the
8001 // default case.
8002 //
8003 // This transform can be done speculatively because it is so cheap - it
8004 // results in a single rotate operation being inserted.
8005
8006 auto *Ty = cast<IntegerType>(Val: SI->getCondition()->getType());
8007 Builder.SetInsertPoint(SI);
8008 Value *Sub = SI->getCondition();
8009 if (Base != 0)
8010 Sub = Builder.CreateSub(LHS: Sub, RHS: ConstantInt::getSigned(Ty, V: Base));
8011 Value *Rot = Builder.CreateIntrinsic(
8012 RetTy: Ty, ID: Intrinsic::fshl,
8013 Args: {Sub, Sub, ConstantInt::get(Ty, V: Ty->getBitWidth() - *Shift)});
8014 SI->replaceUsesOfWith(From: SI->getCondition(), To: Rot);
8015
8016 for (auto Case : SI->cases()) {
8017 auto *Orig = Case.getCaseValue();
8018 auto Sub = Orig->getValue() - APInt(Ty->getBitWidth(), Base, true);
8019 Case.setValue(cast<ConstantInt>(Val: ConstantInt::get(Ty, V: Sub.lshr(shiftAmt: *Shift))));
8020 }
8021 return true;
8022}
8023
8024/// Tries to transform the switch when the condition is umin with a constant.
8025/// In that case, the default branch can be replaced by the constant's branch.
8026/// This method also removes dead cases when the simplification cannot replace
8027/// the default branch.
8028///
8029/// For example:
8030/// switch(umin(a, 3)) {
8031/// case 0:
8032/// case 1:
8033/// case 2:
8034/// case 3:
8035/// case 4:
8036/// // ...
8037/// default:
8038/// unreachable
8039/// }
8040///
8041/// Transforms into:
8042///
8043/// switch(a) {
8044/// case 0:
8045/// case 1:
8046/// case 2:
8047/// default:
8048/// // This is case 3
8049/// }
8050static bool simplifySwitchWhenUMin(SwitchInst *SI, DomTreeUpdater *DTU) {
8051 Value *A;
8052 ConstantInt *Constant;
8053
8054 if (!match(V: SI->getCondition(), P: m_UMin(Op0: m_Value(V&: A), Op1: m_ConstantInt(CI&: Constant))))
8055 return false;
8056
8057 SmallVector<DominatorTree::UpdateType> Updates;
8058 SwitchInstProfUpdateWrapper SIW(*SI);
8059 BasicBlock *BB = SIW->getParent();
8060
8061 // Dead cases are removed even when the simplification fails.
8062 // A case is dead when its value is higher than the Constant.
8063 for (auto I = SI->case_begin(), E = SI->case_end(); I != E;) {
8064 if (!I->getCaseValue()->getValue().ugt(RHS: Constant->getValue())) {
8065 ++I;
8066 continue;
8067 }
8068 BasicBlock *DeadCaseBB = I->getCaseSuccessor();
8069 DeadCaseBB->removePredecessor(Pred: BB);
8070 I = SIW.removeCase(I);
8071 E = SIW->case_end();
8072 if (!is_contained(Range: successors(BB), Element: DeadCaseBB))
8073 Updates.push_back(Elt: {DominatorTree::Delete, BB, DeadCaseBB});
8074 }
8075
8076 auto Case = SI->findCaseValue(C: Constant);
8077 // If the case value is not found, `findCaseValue` returns the default case.
8078 // In this scenario, since there is no explicit `case 3:`, the simplification
8079 // fails. The simplification also fails when the switch’s default destination
8080 // is reachable.
8081 if (!SI->defaultDestUnreachable() || Case == SI->case_default()) {
8082 if (DTU)
8083 DTU->applyUpdates(Updates);
8084 return !Updates.empty();
8085 }
8086
8087 BasicBlock *Unreachable = SI->getDefaultDest();
8088 SIW.replaceDefaultDest(I: Case);
8089 SIW.removeCase(I: Case);
8090 SIW->setCondition(A);
8091
8092 Updates.push_back(Elt: {DominatorTree::Delete, BB, Unreachable});
8093
8094 if (DTU)
8095 DTU->applyUpdates(Updates);
8096
8097 return true;
8098}
8099
8100static bool simplifySwitchDefaultBranch(SwitchInst *SI, DomTreeUpdater *DTU,
8101 const DataLayout &DL,
8102 AssumptionCache *AC) {
8103 assert(SI);
8104 if (SI->defaultDestUnreachable())
8105 return false;
8106
8107 // If it can be proved that the switch condition takes some concrete value
8108 // in the default block, we can make some nice simplifications to the
8109 // switch.
8110 BasicBlock *Default = SI->getDefaultDest();
8111 const Instruction *CtxI = &*Default->getFirstNonPHIIt();
8112 const KnownBits Known = computeKnownBits(
8113 V: SI->getCondition(),
8114 Q: SimplifyQuery(DL, /*DT=*/nullptr, AC, CtxI).allowEphemerals(AllowEphemerals: true));
8115 if (!Known.isConstant())
8116 return false;
8117
8118 // At this point, we know that only one value can be mapped to the
8119 // default block. So, if a case doesn't exist for it already, we
8120 // can create one pointing to the default block.
8121 ConstantInt *CaseVal =
8122 ConstantInt::get(Context&: SI->getContext(), V: Known.getConstant());
8123 const llvm::SwitchInst::CaseIt CaseIt = SI->findCaseValue(C: CaseVal);
8124 if (CaseIt == SI->case_default()) {
8125 SwitchInstProfUpdateWrapper SIW(*SI);
8126 SIW.addCase(OnVal: CaseVal, Dest: Default, W: SIW.getSuccessorWeight(idx: 0));
8127 SIW.setSuccessorWeight(idx: 0, W: 0);
8128 }
8129 // If there is a pre-existing case for the constant, the default branch
8130 // will be removed rather than being moved. Thus, we are removing an edge
8131 // in the CFG, and need to update any PHIs in the default block.
8132 createUnreachableSwitchDefault(Switch: SI, DTU, /*RemoveOrigDefaultBlock=*/CaseIt !=
8133 SI->case_default());
8134
8135 assert(SI->getNumCases() > 0 && "Switch should have at least one case");
8136 assert(SI->findCaseValue(CaseVal) != SI->case_default() &&
8137 "Proven value should have a dedicated case");
8138 assert(SI->defaultDestUnreachable());
8139 return true;
8140}
8141
8142/// Tries to transform switch of powers of two to reduce switch range.
8143/// For example, switch like:
8144/// switch (C) { case 1: case 2: case 64: case 128: }
8145/// will be transformed to:
8146/// switch (count_trailing_zeros(C)) { case 0: case 1: case 6: case 7: }
8147///
8148/// This transformation allows better lowering and may transform the switch
8149/// instruction into a sequence of bit manipulation and a smaller
8150/// log2(C)-indexed value table (instead of traditionally emitting a load of the
8151/// address of the jump target, and indirectly jump to it).
8152static bool simplifySwitchOfPowersOfTwo(SwitchInst *SI, IRBuilder<> &Builder,
8153 DomTreeUpdater *DTU,
8154 const DataLayout &DL,
8155 const TargetTransformInfo &TTI) {
8156 Value *Condition = SI->getCondition();
8157 LLVMContext &Context = SI->getContext();
8158 auto *CondTy = cast<IntegerType>(Val: Condition->getType());
8159
8160 if (CondTy->getIntegerBitWidth() > 64 ||
8161 !DL.fitsInLegalInteger(Width: CondTy->getIntegerBitWidth()))
8162 return false;
8163
8164 // Ensure trailing zeroes count intrinsic emission is not too expensive.
8165 IntrinsicCostAttributes Attrs(Intrinsic::cttz, CondTy,
8166 {Condition, ConstantInt::getTrue(Context)});
8167 if (TTI.getIntrinsicInstrCost(ICA: Attrs, CostKind: TTI::TCK_SizeAndLatency) >
8168 TTI::TCC_Basic * 2)
8169 return false;
8170
8171 // Only bother with this optimization if there are more than 3 switch cases.
8172 // SDAG will start emitting jump tables for 4 or more cases.
8173 if (SI->getNumCases() < 4)
8174 return false;
8175
8176 // Check that switch cases are powers of two.
8177 SmallVector<uint64_t, 4> Values;
8178 for (const auto &Case : SI->cases()) {
8179 uint64_t CaseValue = Case.getCaseValue()->getValue().getZExtValue();
8180 if (llvm::has_single_bit(Value: CaseValue))
8181 Values.push_back(Elt: CaseValue);
8182 else
8183 return false;
8184 }
8185
8186 // isSwichDense requires case values to be sorted.
8187 llvm::sort(C&: Values);
8188 if (!isSwitchDense(NumCases: Values.size(),
8189 CaseRange: llvm::countr_zero(Val: Values.back()) -
8190 llvm::countr_zero(Val: Values.front()) + 1,
8191 OptSize: SI->getFunction()->hasOptSize()))
8192 // Transform is unable to generate dense switch.
8193 return false;
8194
8195 Builder.SetInsertPoint(SI);
8196
8197 if (!SI->defaultDestUnreachable()) {
8198 // Let non-power-of-two inputs jump to the default case, when the latter is
8199 // reachable.
8200 auto *PopC = Builder.CreateUnaryIntrinsic(ID: Intrinsic::ctpop, Op: Condition);
8201 auto *IsPow2 = Builder.CreateICmpEQ(LHS: PopC, RHS: ConstantInt::get(Ty: CondTy, V: 1));
8202
8203 auto *OrigBB = SI->getParent();
8204 auto *DefaultCaseBB = SI->getDefaultDest();
8205 BasicBlock *SplitBB = SplitBlock(Old: OrigBB, SplitPt: SI, DTU);
8206 auto It = OrigBB->getTerminator()->getIterator();
8207 SmallVector<uint32_t> Weights;
8208 auto HasWeights = extractBranchWeights(I: *SI, Weights);
8209 auto *BI = CondBrInst::Create(Cond: IsPow2, IfTrue: SplitBB, IfFalse: DefaultCaseBB, InsertBefore: It);
8210 if (HasWeights && any_of(Range&: Weights, P: not_equal_to(Arg: 0))) {
8211 // IsPow2 covers a subset of the cases in which we'd go to the default
8212 // label. The other is those powers of 2 that don't appear in the case
8213 // statement. We don't know the distribution of the values coming in, so
8214 // the safest is to split 50-50 the original probability to `default`.
8215 uint64_t OrigDenominator =
8216 sum_of(Range: map_range(C&: Weights, F: StaticCastTo<uint64_t>));
8217 SmallVector<uint64_t> NewWeights(2);
8218 NewWeights[1] = Weights[0] / 2;
8219 NewWeights[0] = OrigDenominator - NewWeights[1];
8220 setFittedBranchWeights(I&: *BI, Weights: NewWeights, /*IsExpected=*/false);
8221 // The probability of executing the default block stays constant. It was
8222 // p_d = Weights[0] / OrigDenominator
8223 // we rewrite as W/D
8224 // We want to find the probability of the default branch of the switch
8225 // statement. Let's call it X. We have W/D = W/2D + X * (1-W/2D)
8226 // i.e. the original probability is the probability we go to the default
8227 // branch from the BI branch, or we take the default branch on the SI.
8228 // Meaning X = W / (2D - W), or (W/2) / (D - W/2)
8229 // This matches using W/2 for the default branch probability numerator and
8230 // D-W/2 as the denominator.
8231 Weights[0] = NewWeights[1];
8232 uint64_t CasesDenominator = OrigDenominator - Weights[0];
8233 for (auto &W : drop_begin(RangeOrContainer&: Weights))
8234 W = NewWeights[0] * static_cast<double>(W) / CasesDenominator;
8235
8236 setBranchWeights(I&: *SI, Weights, /*IsExpected=*/false);
8237 }
8238 // BI is handling the default case for SI, and so should share its DebugLoc.
8239 BI->setDebugLoc(SI->getDebugLoc());
8240 It->eraseFromParent();
8241
8242 addPredecessorToBlock(Succ: DefaultCaseBB, NewPred: OrigBB, ExistPred: SplitBB);
8243 if (DTU)
8244 DTU->applyUpdates(Updates: {{DominatorTree::Insert, OrigBB, DefaultCaseBB}});
8245 }
8246
8247 // Replace each case with its trailing zeros number.
8248 for (auto &Case : SI->cases()) {
8249 auto *OrigValue = Case.getCaseValue();
8250 Case.setValue(ConstantInt::get(Ty: OrigValue->getIntegerType(),
8251 V: OrigValue->getValue().countr_zero()));
8252 }
8253
8254 // Replace condition with its trailing zeros number.
8255 auto *ConditionTrailingZeros = Builder.CreateIntrinsic(
8256 ID: Intrinsic::cttz, OverloadTypes: {CondTy}, Args: {Condition, ConstantInt::getTrue(Context)});
8257
8258 SI->setCondition(ConditionTrailingZeros);
8259
8260 return true;
8261}
8262
8263/// Fold switch over ucmp/scmp intrinsic to br if two of the switch arms have
8264/// the same destination.
8265static bool simplifySwitchOfCmpIntrinsic(SwitchInst *SI, IRBuilderBase &Builder,
8266 DomTreeUpdater *DTU) {
8267 auto *Cmp = dyn_cast<CmpIntrinsic>(Val: SI->getCondition());
8268 if (!Cmp || !Cmp->hasOneUse())
8269 return false;
8270
8271 SmallVector<uint32_t, 4> Weights;
8272 bool HasWeights = extractBranchWeights(ProfileData: getBranchWeightMDNode(I: *SI), Weights);
8273 if (!HasWeights)
8274 Weights.resize(N: 4); // Avoid checking HasWeights everywhere.
8275
8276 // Normalize to [us]cmp == Res ? Succ : OtherSucc.
8277 int64_t Res;
8278 BasicBlock *Succ, *OtherSucc;
8279 uint32_t SuccWeight = 0, OtherSuccWeight = 0;
8280 BasicBlock *Unreachable = nullptr;
8281
8282 if (SI->getNumCases() == 2) {
8283 // Find which of 1, 0 or -1 is missing (handled by default dest).
8284 SmallSet<int64_t, 3> Missing;
8285 Missing.insert(V: 1);
8286 Missing.insert(V: 0);
8287 Missing.insert(V: -1);
8288
8289 Succ = SI->getDefaultDest();
8290 SuccWeight = Weights[0];
8291 OtherSucc = nullptr;
8292 for (auto &Case : SI->cases()) {
8293 std::optional<int64_t> Val =
8294 Case.getCaseValue()->getValue().trySExtValue();
8295 if (!Val)
8296 return false;
8297 if (!Missing.erase(V: *Val))
8298 return false;
8299 if (OtherSucc && OtherSucc != Case.getCaseSuccessor())
8300 return false;
8301 OtherSucc = Case.getCaseSuccessor();
8302 OtherSuccWeight += Weights[Case.getSuccessorIndex()];
8303 }
8304
8305 assert(Missing.size() == 1 && "Should have one case left");
8306 Res = *Missing.begin();
8307 } else if (SI->getNumCases() == 3 && SI->defaultDestUnreachable()) {
8308 // Normalize so that Succ is taken once and OtherSucc twice.
8309 Unreachable = SI->getDefaultDest();
8310 Succ = OtherSucc = nullptr;
8311 for (auto &Case : SI->cases()) {
8312 BasicBlock *NewSucc = Case.getCaseSuccessor();
8313 uint32_t Weight = Weights[Case.getSuccessorIndex()];
8314 if (!OtherSucc || OtherSucc == NewSucc) {
8315 OtherSucc = NewSucc;
8316 OtherSuccWeight += Weight;
8317 } else if (!Succ) {
8318 Succ = NewSucc;
8319 SuccWeight = Weight;
8320 } else if (Succ == NewSucc) {
8321 std::swap(a&: Succ, b&: OtherSucc);
8322 std::swap(a&: SuccWeight, b&: OtherSuccWeight);
8323 } else
8324 return false;
8325 }
8326 for (auto &Case : SI->cases()) {
8327 std::optional<int64_t> Val =
8328 Case.getCaseValue()->getValue().trySExtValue();
8329 if (!Val || (Val != 1 && Val != 0 && Val != -1))
8330 return false;
8331 if (Case.getCaseSuccessor() == Succ) {
8332 Res = *Val;
8333 break;
8334 }
8335 }
8336 } else {
8337 return false;
8338 }
8339
8340 // Determine predicate for the missing case.
8341 ICmpInst::Predicate Pred;
8342 switch (Res) {
8343 case 1:
8344 Pred = ICmpInst::ICMP_UGT;
8345 break;
8346 case 0:
8347 Pred = ICmpInst::ICMP_EQ;
8348 break;
8349 case -1:
8350 Pred = ICmpInst::ICMP_ULT;
8351 break;
8352 }
8353 if (Cmp->isSigned())
8354 Pred = ICmpInst::getSignedPredicate(Pred);
8355
8356 MDNode *NewWeights = nullptr;
8357 if (HasWeights)
8358 NewWeights = MDBuilder(SI->getContext())
8359 .createBranchWeights(TrueWeight: SuccWeight, FalseWeight: OtherSuccWeight);
8360
8361 BasicBlock *BB = SI->getParent();
8362 Builder.SetInsertPoint(SI->getIterator());
8363 Value *ICmp = Builder.CreateICmp(P: Pred, LHS: Cmp->getLHS(), RHS: Cmp->getRHS());
8364 Builder.CreateCondBr(Cond: ICmp, True: Succ, False: OtherSucc, BranchWeights: NewWeights,
8365 Unpredictable: SI->getMetadata(KindID: LLVMContext::MD_unpredictable));
8366 OtherSucc->removePredecessor(Pred: BB);
8367 if (Unreachable)
8368 Unreachable->removePredecessor(Pred: BB);
8369 SI->eraseFromParent();
8370 Cmp->eraseFromParent();
8371 if (DTU && Unreachable)
8372 DTU->applyUpdates(Updates: {{DominatorTree::Delete, BB, Unreachable}});
8373 return true;
8374}
8375
8376/// Checking whether two BBs are equal depends on the contents of the
8377/// BasicBlock and the incoming values of their successor PHINodes.
8378/// PHINode::getIncomingValueForBlock is O(|Preds|), so we'd like to avoid
8379/// calling this function on each BasicBlock every time isEqual is called,
8380/// especially since the same BasicBlock may be passed as an argument multiple
8381/// times. To do this, we can precompute a map of PHINode -> Pred BasicBlock ->
8382/// IncomingValue and add it in the Wrapper so isEqual can do O(1) checking
8383/// of the incoming values.
8384struct EqualBBWrapper {
8385 BasicBlock *BB;
8386
8387 // One Phi usually has < 8 incoming values.
8388 using BB2ValueMap = SmallDenseMap<BasicBlock *, Value *, 8>;
8389 using Phi2IVsMap = DenseMap<PHINode *, BB2ValueMap>;
8390 Phi2IVsMap *PhiPredIVs;
8391
8392 // We only merge the identical non-entry BBs with
8393 // - terminator unconditional br to Succ (pending relaxation),
8394 // - does not have address taken / weird control.
8395 static bool canBeMerged(const BasicBlock *BB) {
8396 assert(BB && "Expected non-null BB");
8397 // Entry block cannot be eliminated or have predecessors.
8398 if (BB->isEntryBlock())
8399 return false;
8400
8401 // Single successor and must be Succ.
8402 // FIXME: Relax that the terminator is a BranchInst by checking for equality
8403 // on other kinds of terminators. We decide to only support unconditional
8404 // branches for now for compile time reasons.
8405 auto *BI = dyn_cast<UncondBrInst>(Val: BB->getTerminator());
8406 if (!BI)
8407 return false;
8408
8409 // Avoid blocks that are "address-taken" (blockaddress) or have unusual
8410 // uses.
8411 if (BB->hasAddressTaken() || BB->isEHPad())
8412 return false;
8413
8414 // TODO: relax this condition to merge equal blocks with >1 instructions?
8415 // Here, we use a O(1) form of the O(n) comparison of `size() != 1`.
8416 if (&BB->front() != &BB->back())
8417 return false;
8418
8419 // The BB must have at least one predecessor.
8420 if (pred_empty(BB))
8421 return false;
8422
8423 return true;
8424 }
8425};
8426
8427template <> struct llvm::DenseMapInfo<const EqualBBWrapper *> {
8428 static unsigned getHashValue(const EqualBBWrapper *EBW) {
8429 BasicBlock *BB = EBW->BB;
8430 UncondBrInst *BI = cast<UncondBrInst>(Val: BB->getTerminator());
8431 assert(BB->size() == 1 && "Expected just a single branch in the BB");
8432
8433 // Since we assume the BB is just a single UncondBrInst with a single
8434 // successor, we hash as the BB and the incoming Values of its successor
8435 // PHIs. Initially, we tried to just use the successor BB as the hash, but
8436 // including the incoming PHI values leads to better performance.
8437 // We also tried to build a map from BB -> Succs.IncomingValues ahead of
8438 // time and passing it in EqualBBWrapper, but this slowed down the average
8439 // compile time without having any impact on the worst case compile time.
8440 BasicBlock *Succ = BI->getSuccessor();
8441 auto PhiValsForBB = map_range(C: Succ->phis(), F: [&](PHINode &Phi) {
8442 return (*EBW->PhiPredIVs)[&Phi][BB];
8443 });
8444 return hash_combine(args: Succ, args: hash_combine_range(R&: PhiValsForBB));
8445 }
8446 static bool isEqual(const EqualBBWrapper *LHS, const EqualBBWrapper *RHS) {
8447 BasicBlock *A = LHS->BB;
8448 BasicBlock *B = RHS->BB;
8449
8450 // FIXME: we checked that the size of A and B are both 1 in
8451 // mergeIdenticalUncondBBs to make the Case list smaller to
8452 // improve performance. If we decide to support BasicBlocks with more
8453 // than just a single instruction, we need to check that A.size() ==
8454 // B.size() here, and we need to check more than just the BranchInsts
8455 // for equality.
8456
8457 UncondBrInst *ABI = cast<UncondBrInst>(Val: A->getTerminator());
8458 UncondBrInst *BBI = cast<UncondBrInst>(Val: B->getTerminator());
8459 if (ABI->getSuccessor() != BBI->getSuccessor())
8460 return false;
8461
8462 // Need to check that PHIs in successor have matching values.
8463 BasicBlock *Succ = ABI->getSuccessor();
8464 auto IfPhiIVMatch = [&](PHINode &Phi) {
8465 // Replace O(|Pred|) Phi.getIncomingValueForBlock with this O(1) hashmap
8466 // query.
8467 auto &PredIVs = (*LHS->PhiPredIVs)[&Phi];
8468 return PredIVs[A] == PredIVs[B];
8469 };
8470 return all_of(Range: Succ->phis(), P: IfPhiIVMatch);
8471 }
8472};
8473
8474// Merge identical BBs into one of them.
8475static bool mergeIdenticalBBs(ArrayRef<BasicBlock *> Candidates,
8476 DomTreeUpdater *DTU) {
8477 if (Candidates.size() < 2)
8478 return false;
8479
8480 // Build Cases. Skip BBs that are not candidates for simplification. Mark
8481 // PHINodes which need to be processed into PhiPredIVs. We decide to process
8482 // an entire PHI at once after the loop, opposed to calling
8483 // getIncomingValueForBlock inside this loop, since each call to
8484 // getIncomingValueForBlock is O(|Preds|).
8485 EqualBBWrapper::Phi2IVsMap PhiPredIVs;
8486 SmallVector<EqualBBWrapper> BBs2Merge;
8487 BBs2Merge.reserve(N: Candidates.size());
8488 SmallSetVector<PHINode *, 8> Phis;
8489
8490 for (BasicBlock *BB : Candidates) {
8491 BasicBlock *Succ = BB->getSingleSuccessor();
8492 assert(Succ && "Expected unconditional BB");
8493 BBs2Merge.emplace_back(Args: EqualBBWrapper{.BB: BB, .PhiPredIVs: &PhiPredIVs});
8494 Phis.insert_range(R: make_pointer_range(Range: Succ->phis()));
8495 }
8496
8497 // Precompute a data structure to improve performance of isEqual for
8498 // EqualBBWrapper.
8499 PhiPredIVs.reserve(NumEntries: Phis.size());
8500 for (PHINode *Phi : Phis) {
8501 auto &IVs =
8502 PhiPredIVs.try_emplace(Key: Phi, Args: Phi->getNumIncomingValues()).first->second;
8503 // Pre-fill all incoming for O(1) lookup as Phi.getIncomingValueForBlock is
8504 // O(|Pred|).
8505 for (auto &IV : Phi->incoming_values())
8506 IVs.insert(KV: {Phi->getIncomingBlock(U: IV), IV.get()});
8507 }
8508
8509 // Group duplicates using DenseSet with custom equality/hashing.
8510 // Build a set such that if the EqualBBWrapper exists in the set and another
8511 // EqualBBWrapper isEqual, then the equivalent EqualBBWrapper which is not in
8512 // the set should be replaced with the one in the set. If the EqualBBWrapper
8513 // is not in the set, then it should be added to the set so other
8514 // EqualBBWrapper can check against it in the same manner. We use
8515 // EqualBBWrapper instead of just BasicBlock because we'd like to pass around
8516 // information to isEquality, getHashValue, and when doing the replacement
8517 // with better performance.
8518 DenseSet<const EqualBBWrapper *> Keep;
8519 Keep.reserve(Size: BBs2Merge.size());
8520
8521 SmallVector<DominatorTree::UpdateType> Updates;
8522 Updates.reserve(N: BBs2Merge.size() * 2);
8523
8524 bool MadeChange = false;
8525
8526 // Helper: redirect all edges X -> DeadPred to X -> LivePred.
8527 auto RedirectIncomingEdges = [&](BasicBlock *Dead, BasicBlock *Live) {
8528 SmallSetVector<BasicBlock *, 8> DeadPreds(llvm::from_range,
8529 predecessors(BB: Dead));
8530 if (DTU) {
8531 // All predecessors of DeadPred (except the common predecessor) will be
8532 // moved to LivePred.
8533 Updates.reserve(N: Updates.size() + DeadPreds.size() * 2);
8534 SmallPtrSet<BasicBlock *, 16> LivePreds(llvm::from_range,
8535 predecessors(BB: Live));
8536 for (BasicBlock *PredOfDead : DeadPreds) {
8537 // Do not modify those common predecessors of DeadPred and LivePred.
8538 if (!LivePreds.contains(Ptr: PredOfDead))
8539 Updates.push_back(Elt: {DominatorTree::Insert, PredOfDead, Live});
8540 Updates.push_back(Elt: {DominatorTree::Delete, PredOfDead, Dead});
8541 }
8542 }
8543 LLVM_DEBUG(dbgs() << "Replacing duplicate pred BB ";
8544 Dead->printAsOperand(dbgs()); dbgs() << " with pred ";
8545 Live->printAsOperand(dbgs()); dbgs() << " for ";
8546 Live->getSingleSuccessor()->printAsOperand(dbgs());
8547 dbgs() << "\n");
8548 // Replace successors in all predecessors of DeadPred.
8549 for (BasicBlock *PredOfDead : DeadPreds) {
8550 Instruction *T = PredOfDead->getTerminator();
8551 T->replaceSuccessorWith(OldBB: Dead, NewBB: Live);
8552 }
8553 };
8554
8555 // Try to eliminate duplicate predecessors.
8556 for (const auto &EBW : BBs2Merge) {
8557 // EBW is a candidate for simplification. If we find a duplicate BB,
8558 // replace it.
8559 const auto &[It, Inserted] = Keep.insert(V: &EBW);
8560 if (Inserted)
8561 continue;
8562
8563 // Found duplicate: merge P into canonical predecessor It->Pred.
8564 BasicBlock *KeepBB = (*It)->BB;
8565 BasicBlock *DeadBB = EBW.BB;
8566
8567 // Avoid merging a BB with itself.
8568 if (KeepBB == DeadBB)
8569 continue;
8570
8571 // Redirect all edges into DeadPred to KeepPred.
8572 RedirectIncomingEdges(DeadBB, KeepBB);
8573
8574 // Now DeadBB should become unreachable; leave DCE to later,
8575 // but we can try to simplify it if it only branches to Succ.
8576 // (We won't erase here to keep the routine simple and DT-safe.)
8577 assert(pred_empty(DeadBB) && "DeadBB should be unreachable.");
8578 MadeChange = true;
8579 }
8580
8581 if (DTU && !Updates.empty())
8582 DTU->applyUpdates(Updates);
8583
8584 return MadeChange;
8585}
8586
8587bool SimplifyCFGOpt::simplifyDuplicateSwitchArms(SwitchInst *SI,
8588 DomTreeUpdater *DTU) {
8589 // Collect candidate switch-arms top-down.
8590 SmallSetVector<BasicBlock *, 16> FilteredArms(
8591 llvm::from_range,
8592 make_filter_range(Range: successors(I: SI), Pred: EqualBBWrapper::canBeMerged));
8593 return mergeIdenticalBBs(Candidates: FilteredArms.getArrayRef(), DTU);
8594}
8595
8596bool SimplifyCFGOpt::simplifyDuplicatePredecessors(BasicBlock *BB,
8597 DomTreeUpdater *DTU) {
8598 // Need at least 2 predecessors to do anything.
8599 if (!BB || !BB->hasNPredecessorsOrMore(N: 2))
8600 return false;
8601
8602 // Compilation time consideration: retain the canonical loop, otherwise, we
8603 // require more time in the later loop canonicalization.
8604 if (Options.NeedCanonicalLoop && is_contained(Range&: LoopHeaders, Element: BB))
8605 return false;
8606
8607 // Collect candidate predecessors bottom-up.
8608 SmallSetVector<BasicBlock *, 8> FilteredPreds(
8609 llvm::from_range,
8610 make_filter_range(Range: predecessors(BB), Pred: EqualBBWrapper::canBeMerged));
8611 return mergeIdenticalBBs(Candidates: FilteredPreds.getArrayRef(), DTU);
8612}
8613
8614bool SimplifyCFGOpt::simplifySwitch(SwitchInst *SI, IRBuilder<> &Builder) {
8615 BasicBlock *BB = SI->getParent();
8616
8617 if (isValueEqualityComparison(TI: SI)) {
8618 // If we only have one predecessor, and if it is a branch on this value,
8619 // see if that predecessor totally determines the outcome of this switch.
8620 if (BasicBlock *OnlyPred = BB->getSinglePredecessor())
8621 if (simplifyEqualityComparisonWithOnlyPredecessor(TI: SI, Pred: OnlyPred, Builder))
8622 return requestResimplify();
8623
8624 Value *Cond = SI->getCondition();
8625 if (SelectInst *Select = dyn_cast<SelectInst>(Val: Cond))
8626 if (simplifySwitchOnSelect(SI, Select))
8627 return requestResimplify();
8628
8629 // If the block only contains the switch, see if we can fold the block
8630 // away into any preds.
8631 if (SI == &*BB->begin())
8632 if (foldValueComparisonIntoPredecessors(TI: SI, Builder))
8633 return requestResimplify();
8634 }
8635
8636 // Try to transform the switch into an icmp and a branch.
8637 // The conversion from switch to comparison may lose information on
8638 // impossible switch values, so disable it early in the pipeline.
8639 if (Options.ConvertSwitchRangeToICmp && turnSwitchRangeIntoICmp(SI, Builder))
8640 return requestResimplify();
8641
8642 // Remove unreachable cases.
8643 if (eliminateDeadSwitchCases(SI, DTU, AC: Options.AC, DL))
8644 return requestResimplify();
8645
8646 if (simplifySwitchOfCmpIntrinsic(SI, Builder, DTU))
8647 return requestResimplify();
8648
8649 if (trySwitchToSelect(SI, Builder, DTU, DL))
8650 return requestResimplify();
8651
8652 if (Options.ForwardSwitchCondToPhi && forwardSwitchConditionToPHI(SI))
8653 return requestResimplify();
8654
8655 // The conversion of switches to arithmetic or lookup table is disabled in
8656 // the early optimization pipeline, as it may lose information or make the
8657 // resulting code harder to analyze.
8658 if (Options.ConvertSwitchToArithmetic || Options.ConvertSwitchToLookupTable)
8659 if (simplifySwitchLookup(SI, Builder, DTU, DL, TTI,
8660 ConvertSwitchToLookupTable: Options.ConvertSwitchToLookupTable))
8661 return requestResimplify();
8662
8663 if (simplifySwitchOfPowersOfTwo(SI, Builder, DTU, DL, TTI))
8664 return requestResimplify();
8665
8666 if (reduceSwitchRange(SI, Builder, DL, TTI))
8667 return requestResimplify();
8668
8669 if (HoistCommon &&
8670 hoistCommonCodeFromSuccessors(TI: SI, AllInstsEqOnly: !Options.HoistCommonInsts))
8671 return requestResimplify();
8672
8673 // We can merge identical switch arms early to enhance more aggressive
8674 // optimization on switch.
8675 if (simplifyDuplicateSwitchArms(SI, DTU))
8676 return requestResimplify();
8677
8678 if (simplifySwitchWhenUMin(SI, DTU))
8679 return requestResimplify();
8680
8681 if (simplifySwitchDefaultBranch(SI, DTU, DL, AC: Options.AC))
8682 return requestResimplify();
8683
8684 return false;
8685}
8686
8687bool SimplifyCFGOpt::simplifyIndirectBr(IndirectBrInst *IBI) {
8688 BasicBlock *BB = IBI->getParent();
8689 bool Changed = false;
8690 SmallVector<uint32_t> BranchWeights;
8691 const bool HasBranchWeights = extractBranchWeights(I: *IBI, Weights&: BranchWeights);
8692
8693 DenseMap<const BasicBlock *, uint64_t> TargetWeight;
8694 if (HasBranchWeights)
8695 for (size_t I = 0, E = IBI->getNumDestinations(); I < E; ++I)
8696 TargetWeight[IBI->getDestination(i: I)] += BranchWeights[I];
8697
8698 // Eliminate redundant destinations.
8699 SmallPtrSet<Value *, 8> Succs;
8700 SmallSetVector<BasicBlock *, 8> RemovedSuccs;
8701 for (unsigned I = 0, E = IBI->getNumDestinations(); I != E; ++I) {
8702 BasicBlock *Dest = IBI->getDestination(i: I);
8703 if (!Dest->hasAddressTaken() || !Succs.insert(Ptr: Dest).second) {
8704 if (!Dest->hasAddressTaken())
8705 RemovedSuccs.insert(X: Dest);
8706 Dest->removePredecessor(Pred: BB);
8707 IBI->removeDestination(i: I);
8708 --I;
8709 --E;
8710 Changed = true;
8711 }
8712 }
8713
8714 if (DTU) {
8715 std::vector<DominatorTree::UpdateType> Updates;
8716 Updates.reserve(n: RemovedSuccs.size());
8717 for (auto *RemovedSucc : RemovedSuccs)
8718 Updates.push_back(x: {DominatorTree::Delete, BB, RemovedSucc});
8719 DTU->applyUpdates(Updates);
8720 }
8721
8722 if (IBI->getNumDestinations() == 0) {
8723 // If the indirectbr has no successors, change it to unreachable.
8724 new UnreachableInst(IBI->getContext(), IBI->getIterator());
8725 eraseTerminatorAndDCECond(TI: IBI);
8726 return true;
8727 }
8728
8729 if (IBI->getNumDestinations() == 1) {
8730 // If the indirectbr has one successor, change it to a direct branch.
8731 UncondBrInst::Create(Target: IBI->getDestination(i: 0), InsertBefore: IBI->getIterator());
8732 eraseTerminatorAndDCECond(TI: IBI);
8733 return true;
8734 }
8735 if (HasBranchWeights) {
8736 SmallVector<uint64_t> NewBranchWeights(IBI->getNumDestinations());
8737 for (size_t I = 0, E = IBI->getNumDestinations(); I < E; ++I)
8738 NewBranchWeights[I] += TargetWeight.find(Val: IBI->getDestination(i: I))->second;
8739 setFittedBranchWeights(I&: *IBI, Weights: NewBranchWeights, /*IsExpected=*/false);
8740 }
8741 if (SelectInst *SI = dyn_cast<SelectInst>(Val: IBI->getAddress())) {
8742 if (simplifyIndirectBrOnSelect(IBI, SI))
8743 return requestResimplify();
8744 }
8745 return Changed;
8746}
8747
8748/// Given an block with only a single landing pad and a unconditional branch
8749/// try to find another basic block which this one can be merged with. This
8750/// handles cases where we have multiple invokes with unique landing pads, but
8751/// a shared handler.
8752///
8753/// We specifically choose to not worry about merging non-empty blocks
8754/// here. That is a PRE/scheduling problem and is best solved elsewhere. In
8755/// practice, the optimizer produces empty landing pad blocks quite frequently
8756/// when dealing with exception dense code. (see: instcombine, gvn, if-else
8757/// sinking in this file)
8758///
8759/// This is primarily a code size optimization. We need to avoid performing
8760/// any transform which might inhibit optimization (such as our ability to
8761/// specialize a particular handler via tail commoning). We do this by not
8762/// merging any blocks which require us to introduce a phi. Since the same
8763/// values are flowing through both blocks, we don't lose any ability to
8764/// specialize. If anything, we make such specialization more likely.
8765///
8766/// TODO - This transformation could remove entries from a phi in the target
8767/// block when the inputs in the phi are the same for the two blocks being
8768/// merged. In some cases, this could result in removal of the PHI entirely.
8769static bool tryToMergeLandingPad(LandingPadInst *LPad, UncondBrInst *BI,
8770 BasicBlock *BB, DomTreeUpdater *DTU) {
8771 auto Succ = BB->getUniqueSuccessor();
8772 assert(Succ);
8773 // If there's a phi in the successor block, we'd likely have to introduce
8774 // a phi into the merged landing pad block.
8775 if (isa<PHINode>(Val: *Succ->begin()))
8776 return false;
8777
8778 for (BasicBlock *OtherPred : predecessors(BB: Succ)) {
8779 if (BB == OtherPred)
8780 continue;
8781 BasicBlock::iterator I = OtherPred->begin();
8782 LandingPadInst *LPad2 = dyn_cast<LandingPadInst>(Val&: I);
8783 if (!LPad2 || !LPad2->isIdenticalTo(I: LPad))
8784 continue;
8785 ++I;
8786 UncondBrInst *BI2 = dyn_cast<UncondBrInst>(Val&: I);
8787 if (!BI2 || !BI2->isIdenticalTo(I: BI))
8788 continue;
8789
8790 std::vector<DominatorTree::UpdateType> Updates;
8791
8792 // We've found an identical block. Update our predecessors to take that
8793 // path instead and make ourselves dead.
8794 SmallSetVector<BasicBlock *, 16> UniquePreds(pred_begin(BB), pred_end(BB));
8795 for (BasicBlock *Pred : UniquePreds) {
8796 InvokeInst *II = cast<InvokeInst>(Val: Pred->getTerminator());
8797 assert(II->getNormalDest() != BB && II->getUnwindDest() == BB &&
8798 "unexpected successor");
8799 II->setUnwindDest(OtherPred);
8800 if (DTU) {
8801 Updates.push_back(x: {DominatorTree::Insert, Pred, OtherPred});
8802 Updates.push_back(x: {DominatorTree::Delete, Pred, BB});
8803 }
8804 }
8805
8806 SmallSetVector<BasicBlock *, 16> UniqueSuccs(succ_begin(BB), succ_end(BB));
8807 for (BasicBlock *Succ : UniqueSuccs) {
8808 Succ->removePredecessor(Pred: BB);
8809 if (DTU)
8810 Updates.push_back(x: {DominatorTree::Delete, BB, Succ});
8811 }
8812
8813 IRBuilder<> Builder(BI);
8814 Builder.CreateUnreachable();
8815 BI->eraseFromParent();
8816 if (DTU)
8817 DTU->applyUpdates(Updates);
8818 return true;
8819 }
8820 return false;
8821}
8822
8823bool SimplifyCFGOpt::simplifyUncondBranch(UncondBrInst *BI,
8824 IRBuilder<> &Builder) {
8825 BasicBlock *BB = BI->getParent();
8826 BasicBlock *Succ = BI->getSuccessor(i: 0);
8827
8828 // If the Terminator is the only non-phi instruction, simplify the block.
8829 // If LoopHeader is provided, check if the block or its successor is a loop
8830 // header. (This is for early invocations before loop simplify and
8831 // vectorization to keep canonical loop forms for nested loops. These blocks
8832 // can be eliminated when the pass is invoked later in the back-end.)
8833 // Note that if BB has only one predecessor then we do not introduce new
8834 // backedge, so we can eliminate BB.
8835 bool NeedCanonicalLoop =
8836 Options.NeedCanonicalLoop &&
8837 (!LoopHeaders.empty() && BB->hasNPredecessorsOrMore(N: 2) &&
8838 (is_contained(Range&: LoopHeaders, Element: BB) || is_contained(Range&: LoopHeaders, Element: Succ)));
8839 BasicBlock::iterator I = BB->getFirstNonPHIOrDbg();
8840 if (I->isTerminator() && BB != &BB->getParent()->getEntryBlock() &&
8841 !NeedCanonicalLoop && TryToSimplifyUncondBranchFromEmptyBlock(BB, DTU))
8842 return true;
8843
8844 // If the only instruction in the block is a seteq/setne comparison against a
8845 // constant, try to simplify the block.
8846 if (ICmpInst *ICI = dyn_cast<ICmpInst>(Val&: I)) {
8847 if (ICI->isEquality() && isa<ConstantInt>(Val: ICI->getOperand(i_nocapture: 1))) {
8848 ++I;
8849 if (I->isTerminator() &&
8850 tryToSimplifyUncondBranchWithICmpInIt(ICI, Builder))
8851 return true;
8852 if (isa<SelectInst>(Val: I) && I->getNextNode()->isTerminator() &&
8853 tryToSimplifyUncondBranchWithICmpSelectInIt(ICI, Select: cast<SelectInst>(Val&: I),
8854 Builder))
8855 return true;
8856 }
8857 }
8858
8859 // See if we can merge an empty landing pad block with another which is
8860 // equivalent.
8861 if (LandingPadInst *LPad = dyn_cast<LandingPadInst>(Val&: I)) {
8862 ++I;
8863 if (I->isTerminator() && tryToMergeLandingPad(LPad, BI, BB, DTU))
8864 return true;
8865 }
8866
8867 return false;
8868}
8869
8870static BasicBlock *allPredecessorsComeFromSameSource(BasicBlock *BB) {
8871 BasicBlock *PredPred = nullptr;
8872 for (auto *P : predecessors(BB)) {
8873 BasicBlock *PPred = P->getSinglePredecessor();
8874 if (!PPred || (PredPred && PredPred != PPred))
8875 return nullptr;
8876 PredPred = PPred;
8877 }
8878 return PredPred;
8879}
8880
8881/// Fold the following pattern:
8882/// bb0:
8883/// br i1 %cond1, label %bb1, label %bb2
8884/// bb1:
8885/// br i1 %cond2, label %bb3, label %bb4
8886/// bb2:
8887/// br i1 %cond2, label %bb4, label %bb3
8888/// bb3:
8889/// ...
8890/// bb4:
8891/// ...
8892/// into
8893/// bb0:
8894/// %cond = xor i1 %cond1, %cond2
8895/// br i1 %cond, label %bb4, label %bb3
8896/// bb3:
8897/// ...
8898/// bb4:
8899/// ...
8900/// NOTE: %cond2 always dominates the terminator of bb0.
8901static bool mergeNestedCondBranch(CondBrInst *BI, DomTreeUpdater *DTU) {
8902 BasicBlock *BB = BI->getParent();
8903 BasicBlock *BB1 = BI->getSuccessor(i: 0);
8904 BasicBlock *BB2 = BI->getSuccessor(i: 1);
8905 auto IsSimpleSuccessor = [BB](BasicBlock *Succ, CondBrInst *&SuccBI) {
8906 if (Succ == BB)
8907 return false;
8908 if (&Succ->front() != Succ->getTerminator())
8909 return false;
8910 SuccBI = dyn_cast<CondBrInst>(Val: Succ->getTerminator());
8911 if (!SuccBI)
8912 return false;
8913 BasicBlock *Succ1 = SuccBI->getSuccessor(i: 0);
8914 BasicBlock *Succ2 = SuccBI->getSuccessor(i: 1);
8915 return Succ1 != Succ && Succ2 != Succ && Succ1 != BB && Succ2 != BB &&
8916 !isa<PHINode>(Val: Succ1->front()) && !isa<PHINode>(Val: Succ2->front());
8917 };
8918 CondBrInst *BB1BI, *BB2BI;
8919 if (!IsSimpleSuccessor(BB1, BB1BI) || !IsSimpleSuccessor(BB2, BB2BI))
8920 return false;
8921
8922 if (BB1BI->getCondition() != BB2BI->getCondition() ||
8923 BB1BI->getSuccessor(i: 0) != BB2BI->getSuccessor(i: 1) ||
8924 BB1BI->getSuccessor(i: 1) != BB2BI->getSuccessor(i: 0))
8925 return false;
8926
8927 BasicBlock *BB3 = BB1BI->getSuccessor(i: 0);
8928 BasicBlock *BB4 = BB1BI->getSuccessor(i: 1);
8929 // Bail out on trivial cases to avoid bothering to handle the special case in
8930 // the code below.
8931 if (BB3 == BB4)
8932 return false;
8933 IRBuilder<> Builder(BI);
8934 BI->setCondition(
8935 Builder.CreateXor(LHS: BI->getCondition(), RHS: BB1BI->getCondition()));
8936 BB1->removePredecessor(Pred: BB);
8937 BI->setSuccessor(idx: 0, NewSucc: BB4);
8938 BB2->removePredecessor(Pred: BB);
8939 BI->setSuccessor(idx: 1, NewSucc: BB3);
8940 if (DTU) {
8941 SmallVector<DominatorTree::UpdateType, 4> Updates;
8942 Updates.push_back(Elt: {DominatorTree::Delete, BB, BB1});
8943 Updates.push_back(Elt: {DominatorTree::Insert, BB, BB4});
8944 Updates.push_back(Elt: {DominatorTree::Delete, BB, BB2});
8945 Updates.push_back(Elt: {DominatorTree::Insert, BB, BB3});
8946
8947 DTU->applyUpdates(Updates);
8948 }
8949 bool HasWeight = false;
8950 uint64_t BBTWeight, BBFWeight;
8951 if (extractBranchWeights(I: *BI, TrueVal&: BBTWeight, FalseVal&: BBFWeight))
8952 HasWeight = true;
8953 else
8954 BBTWeight = BBFWeight = 1;
8955 uint64_t BB1TWeight, BB1FWeight;
8956 if (extractBranchWeights(I: *BB1BI, TrueVal&: BB1TWeight, FalseVal&: BB1FWeight))
8957 HasWeight = true;
8958 else
8959 BB1TWeight = BB1FWeight = 1;
8960 uint64_t BB2TWeight, BB2FWeight;
8961 if (extractBranchWeights(I: *BB2BI, TrueVal&: BB2TWeight, FalseVal&: BB2FWeight))
8962 HasWeight = true;
8963 else
8964 BB2TWeight = BB2FWeight = 1;
8965 if (HasWeight) {
8966 uint64_t Weights[2] = {BBTWeight * BB1FWeight + BBFWeight * BB2TWeight,
8967 BBTWeight * BB1TWeight + BBFWeight * BB2FWeight};
8968 setFittedBranchWeights(I&: *BI, Weights, /*IsExpected=*/false,
8969 /*ElideAllZero=*/true);
8970 }
8971 return true;
8972}
8973
8974bool SimplifyCFGOpt::simplifyCondBranch(CondBrInst *BI, IRBuilder<> &Builder) {
8975 assert(
8976 !isa<ConstantInt>(BI->getCondition()) &&
8977 BI->getSuccessor(0) != BI->getSuccessor(1) &&
8978 "Tautological conditional branch should have been eliminated already.");
8979
8980 BasicBlock *BB = BI->getParent();
8981 if (!Options.SimplifyCondBranch ||
8982 BI->getFunction()->hasFnAttribute(Kind: Attribute::OptForFuzzing))
8983 return false;
8984
8985 // Conditional branch
8986 if (isValueEqualityComparison(TI: BI)) {
8987 // If we only have one predecessor, and if it is a branch on this value,
8988 // see if that predecessor totally determines the outcome of this
8989 // switch.
8990 if (BasicBlock *OnlyPred = BB->getSinglePredecessor())
8991 if (simplifyEqualityComparisonWithOnlyPredecessor(TI: BI, Pred: OnlyPred, Builder))
8992 return requestResimplify();
8993
8994 // This block must be empty, except for the setcond inst, if it exists.
8995 // Ignore pseudo intrinsics.
8996 for (auto &I : *BB) {
8997 if (isa<PseudoProbeInst>(Val: I) ||
8998 &I == cast<Instruction>(Val: BI->getCondition()))
8999 continue;
9000 if (&I == BI)
9001 if (foldValueComparisonIntoPredecessors(TI: BI, Builder))
9002 return requestResimplify();
9003 break;
9004 }
9005 }
9006
9007 // Try to turn "br (X == 0 | X == 1), T, F" into a switch instruction.
9008 if (simplifyBranchOnICmpChain(BI, Builder, DL))
9009 return true;
9010
9011 // If this basic block has dominating predecessor blocks and the dominating
9012 // blocks' conditions imply BI's condition, we know the direction of BI.
9013 std::optional<bool> Imp = isImpliedByDomCondition(Cond: BI->getCondition(), ContextI: BI, DL);
9014 if (Imp) {
9015 // Turn this into a branch on constant.
9016 auto *OldCond = BI->getCondition();
9017 ConstantInt *TorF = *Imp ? ConstantInt::getTrue(Context&: BB->getContext())
9018 : ConstantInt::getFalse(Context&: BB->getContext());
9019 BI->setCondition(TorF);
9020 RecursivelyDeleteTriviallyDeadInstructions(V: OldCond);
9021 return requestResimplify();
9022 }
9023
9024 // If this basic block is ONLY a compare and a branch, and if a predecessor
9025 // branches to us and one of our successors, fold the comparison into the
9026 // predecessor and use logical operations to pick the right destination.
9027 if (Options.SpeculateBlocks &&
9028 foldBranchToCommonDest(BI, DTU, /*MSSAU=*/nullptr, TTI: &TTI, AC: Options.AC,
9029 BonusInstThreshold: Options.BonusInstThreshold))
9030 return requestResimplify();
9031
9032 // We have a conditional branch to two blocks that are only reachable
9033 // from BI. We know that the condbr dominates the two blocks, so see if
9034 // there is any identical code in the "then" and "else" blocks. If so, we
9035 // can hoist it up to the branching block.
9036 if (BI->getSuccessor(i: 0)->getSinglePredecessor()) {
9037 if (BI->getSuccessor(i: 1)->getSinglePredecessor()) {
9038 if (HoistCommon &&
9039 hoistCommonCodeFromSuccessors(TI: BI, AllInstsEqOnly: !Options.HoistCommonInsts))
9040 return requestResimplify();
9041
9042 if (BI && Options.HoistLoadsStoresWithCondFaulting &&
9043 isProfitableToSpeculate(BI, Invert: std::nullopt, TTI)) {
9044 SmallVector<Instruction *, 2> SpeculatedConditionalLoadsStores;
9045 auto CanSpeculateConditionalLoadsStores = [&]() {
9046 for (auto *Succ : successors(BB)) {
9047 for (Instruction &I : *Succ) {
9048 if (I.isTerminator()) {
9049 if (I.getNumSuccessors() > 1)
9050 return false;
9051 continue;
9052 } else if (!isSafeCheapLoadStore(I: &I, TTI) ||
9053 SpeculatedConditionalLoadsStores.size() ==
9054 HoistLoadsStoresWithCondFaultingThreshold) {
9055 return false;
9056 }
9057 SpeculatedConditionalLoadsStores.push_back(Elt: &I);
9058 }
9059 }
9060 return !SpeculatedConditionalLoadsStores.empty();
9061 };
9062
9063 if (CanSpeculateConditionalLoadsStores()) {
9064 hoistConditionalLoadsStores(BI, SpeculatedConditionalLoadsStores,
9065 Invert: std::nullopt, Sel: nullptr);
9066 return requestResimplify();
9067 }
9068 }
9069 } else {
9070 // If Successor #1 has multiple preds, we may be able to conditionally
9071 // execute Successor #0 if it branches to Successor #1.
9072 Instruction *Succ0TI = BI->getSuccessor(i: 0)->getTerminator();
9073 if (Succ0TI->getNumSuccessors() == 1 &&
9074 Succ0TI->getSuccessor(Idx: 0) == BI->getSuccessor(i: 1))
9075 if (speculativelyExecuteBB(BI, ThenBB: BI->getSuccessor(i: 0)))
9076 return requestResimplify();
9077 }
9078 } else if (BI->getSuccessor(i: 1)->getSinglePredecessor()) {
9079 // If Successor #0 has multiple preds, we may be able to conditionally
9080 // execute Successor #1 if it branches to Successor #0.
9081 Instruction *Succ1TI = BI->getSuccessor(i: 1)->getTerminator();
9082 if (Succ1TI->getNumSuccessors() == 1 &&
9083 Succ1TI->getSuccessor(Idx: 0) == BI->getSuccessor(i: 0))
9084 if (speculativelyExecuteBB(BI, ThenBB: BI->getSuccessor(i: 1)))
9085 return requestResimplify();
9086 }
9087
9088 // If this is a branch on something for which we know the constant value in
9089 // predecessors (e.g. a phi node in the current block), thread control
9090 // through this block.
9091 if (foldCondBranchOnValueKnownInPredecessor(BI))
9092 return requestResimplify();
9093
9094 // Scan predecessor blocks for conditional branches.
9095 for (BasicBlock *Pred : predecessors(BB))
9096 if (CondBrInst *PBI = dyn_cast<CondBrInst>(Val: Pred->getTerminator()))
9097 if (PBI != BI)
9098 if (SimplifyCondBranchToCondBranch(PBI, BI, DTU, DL, TTI))
9099 return requestResimplify();
9100
9101 // Look for diamond patterns.
9102 if (MergeCondStores)
9103 if (BasicBlock *PrevBB = allPredecessorsComeFromSameSource(BB))
9104 if (CondBrInst *PBI = dyn_cast<CondBrInst>(Val: PrevBB->getTerminator()))
9105 if (PBI != BI)
9106 if (mergeConditionalStores(PBI, QBI: BI, DTU, DL, TTI))
9107 return requestResimplify();
9108
9109 // Look for nested conditional branches.
9110 if (mergeNestedCondBranch(BI, DTU))
9111 return requestResimplify();
9112
9113 return false;
9114}
9115
9116/// Check if passing a value to an instruction will cause undefined behavior.
9117static bool passingValueIsAlwaysUndefined(Value *V, Instruction *I, bool PtrValueMayBeModified) {
9118 assert(V->getType() == I->getType() && "Mismatched types");
9119 Constant *C = dyn_cast<Constant>(Val: V);
9120 if (!C)
9121 return false;
9122
9123 if (I->use_empty())
9124 return false;
9125
9126 if (C->isNullValue() || isa<UndefValue>(Val: C)) {
9127 // Find the first same-block use with a UB-triggering opcode, skipping
9128 // cross-block or before-I uses.
9129 auto FindUse = llvm::find_if(Range: I->uses(), P: [I](auto &U) {
9130 auto *Use = cast<Instruction>(U.getUser());
9131 // Only same-block uses after I can witness UB at I's program point.
9132 // Self-uses and before-I uses can occur when I is a PHI node.
9133 if (Use->getParent() != I->getParent() || Use == I || Use->comesBefore(I))
9134 return false;
9135 // Change this list when we want to add new instructions.
9136 switch (Use->getOpcode()) {
9137 default:
9138 return false;
9139 case Instruction::GetElementPtr:
9140 case Instruction::Ret:
9141 case Instruction::BitCast:
9142 case Instruction::Load:
9143 case Instruction::Store:
9144 case Instruction::Call:
9145 case Instruction::CallBr:
9146 case Instruction::Invoke:
9147 case Instruction::UDiv:
9148 case Instruction::URem:
9149 // Note: signed div/rem of INT_MIN / -1 is also immediate UB, not
9150 // implemented to avoid code complexity as it is unclear how useful such
9151 // logic is.
9152 case Instruction::SDiv:
9153 case Instruction::SRem:
9154 return true;
9155 }
9156 });
9157 if (FindUse == I->use_end())
9158 return false;
9159 auto &Use = *FindUse;
9160 auto *User = cast<Instruction>(Val: Use.getUser());
9161
9162 // Now make sure that there are no instructions in between that can alter
9163 // control flow (eg. calls)
9164 auto InstrRange =
9165 make_range(x: std::next(x: I->getIterator()), y: User->getIterator());
9166 if (any_of(Range&: InstrRange, P: [](Instruction &I) {
9167 return !isGuaranteedToTransferExecutionToSuccessor(I: &I);
9168 }))
9169 return false;
9170
9171 // Look through GEPs. A load from a GEP derived from NULL is still undefined
9172 if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(Val: User))
9173 if (GEP->getPointerOperand() == I) {
9174 // The type of GEP may differ from the type of base pointer.
9175 // Bail out on vector GEPs, as they are not handled by other checks.
9176 if (GEP->getType()->isVectorTy())
9177 return false;
9178 // The current base address is null, there are four cases to consider:
9179 // getelementptr (TY, null, 0) -> null
9180 // getelementptr (TY, null, not zero) -> may be modified
9181 // getelementptr inbounds (TY, null, 0) -> null
9182 // getelementptr inbounds (TY, null, not zero) -> poison iff null is
9183 // undefined?
9184 if (!GEP->hasAllZeroIndices() &&
9185 (!GEP->isInBounds() ||
9186 NullPointerIsDefined(F: GEP->getFunction(),
9187 AS: GEP->getPointerAddressSpace())))
9188 PtrValueMayBeModified = true;
9189 return passingValueIsAlwaysUndefined(V, I: GEP, PtrValueMayBeModified);
9190 }
9191
9192 // Look through return.
9193 if (ReturnInst *Ret = dyn_cast<ReturnInst>(Val: User)) {
9194 bool HasNoUndefAttr =
9195 Ret->getFunction()->hasRetAttribute(Kind: Attribute::NoUndef);
9196 // Return undefined to a noundef return value is undefined.
9197 if (isa<UndefValue>(Val: C) && HasNoUndefAttr)
9198 return true;
9199 // Return null to a nonnull+noundef return value is undefined.
9200 if (C->isNullValue() && HasNoUndefAttr &&
9201 Ret->getFunction()->hasRetAttribute(Kind: Attribute::NonNull)) {
9202 return !PtrValueMayBeModified;
9203 }
9204 }
9205
9206 // Load from null is undefined.
9207 if (LoadInst *LI = dyn_cast<LoadInst>(Val: User))
9208 if (!LI->isVolatile())
9209 return !NullPointerIsDefined(F: LI->getFunction(),
9210 AS: LI->getPointerAddressSpace());
9211
9212 // Store to null is undefined.
9213 if (StoreInst *SI = dyn_cast<StoreInst>(Val: User))
9214 if (!SI->isVolatile())
9215 return (!NullPointerIsDefined(F: SI->getFunction(),
9216 AS: SI->getPointerAddressSpace())) &&
9217 SI->getPointerOperand() == I;
9218
9219 // llvm.assume(false/undef) always triggers immediate UB.
9220 if (auto *Assume = dyn_cast<AssumeInst>(Val: User)) {
9221 // Ignore assume operand bundles.
9222 if (I == Assume->getArgOperand(i: 0))
9223 return true;
9224 }
9225
9226 if (auto *CB = dyn_cast<CallBase>(Val: User)) {
9227 if (C->isNullValue() && NullPointerIsDefined(F: CB->getFunction()))
9228 return false;
9229 // A call to null is undefined.
9230 if (CB->getCalledOperand() == I)
9231 return true;
9232
9233 if (CB->isArgOperand(U: &Use)) {
9234 unsigned ArgIdx = CB->getArgOperandNo(U: &Use);
9235 // Passing null to a nonnnull+noundef argument is undefined.
9236 if (isa<ConstantPointerNull>(Val: C) && C->getType()->isPointerTy() &&
9237 CB->paramHasNonNullAttr(ArgNo: ArgIdx, /*AllowUndefOrPoison=*/false))
9238 return !PtrValueMayBeModified;
9239 // Passing undef to a noundef argument is undefined.
9240 if (isa<UndefValue>(Val: C) && CB->isPassingUndefUB(ArgNo: ArgIdx))
9241 return true;
9242 }
9243 }
9244 // Div/Rem by zero is immediate UB
9245 if (match(V: User, P: m_BinOp(L: m_Value(), R: m_Specific(V: I))) && User->isIntDivRem())
9246 return true;
9247 }
9248 return false;
9249}
9250
9251/// If BB has an incoming value that will always trigger undefined behavior
9252/// (eg. null pointer dereference), remove the branch leading here.
9253static bool removeUndefIntroducingPredecessor(BasicBlock *BB,
9254 DomTreeUpdater *DTU,
9255 AssumptionCache *AC) {
9256 for (PHINode &PHI : BB->phis())
9257 for (unsigned i = 0, e = PHI.getNumIncomingValues(); i != e; ++i)
9258 if (passingValueIsAlwaysUndefined(V: PHI.getIncomingValue(i), I: &PHI)) {
9259 BasicBlock *Predecessor = PHI.getIncomingBlock(i);
9260 Instruction *T = Predecessor->getTerminator();
9261 IRBuilder<> Builder(T);
9262 if (isa<UncondBrInst>(Val: T)) {
9263 BB->removePredecessor(Pred: Predecessor);
9264 // Turn unconditional branches into unreachables.
9265 Builder.CreateUnreachable();
9266 T->eraseFromParent();
9267 if (DTU)
9268 DTU->applyUpdates(Updates: {{DominatorTree::Delete, Predecessor, BB}});
9269 return true;
9270 } else if (CondBrInst *BI = dyn_cast<CondBrInst>(Val: T)) {
9271 BB->removePredecessor(Pred: Predecessor);
9272 // Handle degenerate conditional branches.
9273 if (BI->getSuccessor(i: 0) == BI->getSuccessor(i: 1)) {
9274 // The only difference from the UncondBrInst path above is that it
9275 // has two edges in CFG.
9276 BB->removePredecessor(Pred: Predecessor);
9277 // Turn unconditional branches into unreachables.
9278 Builder.CreateUnreachable();
9279 } else {
9280 // Preserve guarding condition in assume, because it might not be
9281 // inferrable from any dominating condition.
9282 Value *Cond = BI->getCondition();
9283 CallInst *Assumption;
9284 if (BI->getSuccessor(i: 0) == BB)
9285 Assumption = Builder.CreateAssumption(Cond: Builder.CreateNot(V: Cond));
9286 else
9287 Assumption = Builder.CreateAssumption(Cond);
9288 if (AC)
9289 AC->registerAssumption(CI: cast<AssumeInst>(Val: Assumption));
9290 Builder.CreateBr(Dest: BI->getSuccessor(i: 0) == BB ? BI->getSuccessor(i: 1)
9291 : BI->getSuccessor(i: 0));
9292 }
9293 BI->eraseFromParent();
9294 if (DTU)
9295 DTU->applyUpdates(Updates: {{DominatorTree::Delete, Predecessor, BB}});
9296 return true;
9297 } else if (SwitchInst *SI = dyn_cast<SwitchInst>(Val: T)) {
9298 // Redirect all branches leading to UB into
9299 // a newly created unreachable block.
9300 BasicBlock *Unreachable = BasicBlock::Create(
9301 Context&: Predecessor->getContext(), Name: "unreachable", Parent: BB->getParent(), InsertBefore: BB);
9302 Builder.SetInsertPoint(Unreachable);
9303 // The new block contains only one instruction: Unreachable
9304 Builder.CreateUnreachable();
9305 for (const auto &Case : SI->cases())
9306 if (Case.getCaseSuccessor() == BB) {
9307 BB->removePredecessor(Pred: Predecessor);
9308 Case.setSuccessor(Unreachable);
9309 }
9310 if (SI->getDefaultDest() == BB) {
9311 BB->removePredecessor(Pred: Predecessor);
9312 SI->setDefaultDest(Unreachable);
9313 }
9314
9315 if (DTU)
9316 DTU->applyUpdates(
9317 Updates: { { DominatorTree::Insert, Predecessor, Unreachable },
9318 { DominatorTree::Delete, Predecessor, BB } });
9319 return true;
9320 }
9321 }
9322
9323 return false;
9324}
9325
9326bool SimplifyCFGOpt::simplifyOnce(BasicBlock *BB) {
9327 bool Changed = false;
9328
9329 assert(BB && BB->getParent() && "Block not embedded in function!");
9330 assert(BB->getTerminator() && "Degenerate basic block encountered!");
9331
9332 // Remove basic blocks that have no predecessors (except the entry block)...
9333 // or that just have themself as a predecessor. These are unreachable.
9334 if ((pred_empty(BB) && BB != &BB->getParent()->getEntryBlock()) ||
9335 BB->getSinglePredecessor() == BB) {
9336 LLVM_DEBUG(dbgs() << "Removing BB: \n" << *BB);
9337 DeleteDeadBlock(BB, DTU);
9338 return true;
9339 }
9340
9341 // Check to see if we can constant propagate this terminator instruction
9342 // away...
9343 Changed |= ConstantFoldTerminator(BB, /*DeleteDeadConditions=*/true,
9344 /*TLI=*/nullptr, DTU);
9345
9346 // Check for and eliminate duplicate PHI nodes in this block.
9347 Changed |= EliminateDuplicatePHINodes(BB);
9348
9349 // Check for and remove branches that will always cause undefined behavior.
9350 if (removeUndefIntroducingPredecessor(BB, DTU, AC: Options.AC))
9351 return requestResimplify();
9352
9353 // Merge basic blocks into their predecessor if there is only one distinct
9354 // pred, and if there is only one distinct successor of the predecessor, and
9355 // if there are no PHI nodes.
9356 if (MergeBlockIntoPredecessor(BB, DTU))
9357 return true;
9358
9359 if (SinkCommon && Options.SinkCommonInsts) {
9360 if (sinkCommonCodeFromPredecessors(BB, DTU) ||
9361 mergeCompatibleInvokes(BB, DTU)) {
9362 // sinkCommonCodeFromPredecessors() does not automatically CSE PHI's,
9363 // so we may now how duplicate PHI's.
9364 // Let's rerun EliminateDuplicatePHINodes() first,
9365 // before foldTwoEntryPHINode() potentially converts them into select's,
9366 // after which we'd need a whole EarlyCSE pass run to cleanup them.
9367 return true;
9368 }
9369 // Merge identical predecessors of this block.
9370 if (simplifyDuplicatePredecessors(BB, DTU))
9371 return true;
9372 }
9373
9374 if (Options.SpeculateBlocks &&
9375 !BB->getParent()->hasFnAttribute(Kind: Attribute::OptForFuzzing)) {
9376 // If there is a trivial two-entry PHI node in this basic block, and we can
9377 // eliminate it, do so now.
9378 if (auto *PN = dyn_cast<PHINode>(Val: BB->begin()))
9379 if (PN->getNumIncomingValues() == 2)
9380 if (foldTwoEntryPHINode(PN, TTI, DTU, AC: Options.AC, DL,
9381 SpeculateUnpredictables: Options.SpeculateUnpredictables))
9382 return true;
9383 }
9384
9385 IRBuilder<> Builder(BB);
9386 Instruction *Terminator = BB->getTerminator();
9387 Builder.SetInsertPoint(Terminator);
9388 switch (Terminator->getOpcode()) {
9389 case Instruction::UncondBr:
9390 Changed |= simplifyUncondBranch(BI: cast<UncondBrInst>(Val: Terminator), Builder);
9391 break;
9392 case Instruction::CondBr:
9393 Changed |= simplifyCondBranch(BI: cast<CondBrInst>(Val: Terminator), Builder);
9394 break;
9395 case Instruction::Resume:
9396 Changed |= simplifyResume(RI: cast<ResumeInst>(Val: Terminator), Builder);
9397 break;
9398 case Instruction::CleanupRet:
9399 Changed |= simplifyCleanupReturn(RI: cast<CleanupReturnInst>(Val: Terminator));
9400 break;
9401 case Instruction::Switch:
9402 Changed |= simplifySwitch(SI: cast<SwitchInst>(Val: Terminator), Builder);
9403 break;
9404 case Instruction::Unreachable:
9405 Changed |= simplifyUnreachable(UI: cast<UnreachableInst>(Val: Terminator));
9406 break;
9407 case Instruction::IndirectBr:
9408 Changed |= simplifyIndirectBr(IBI: cast<IndirectBrInst>(Val: Terminator));
9409 break;
9410 }
9411
9412 return Changed;
9413}
9414
9415bool SimplifyCFGOpt::run(BasicBlock *BB) {
9416 bool Changed = false;
9417
9418 // Repeated simplify BB as long as resimplification is requested.
9419 do {
9420 Resimplify = false;
9421
9422 // Perform one round of simplifcation. Resimplify flag will be set if
9423 // another iteration is requested.
9424 Changed |= simplifyOnce(BB);
9425 } while (Resimplify);
9426
9427 return Changed;
9428}
9429
9430bool llvm::simplifyCFG(BasicBlock *BB, const TargetTransformInfo &TTI,
9431 DomTreeUpdater *DTU, const SimplifyCFGOptions &Options,
9432 ArrayRef<WeakVH> LoopHeaders) {
9433 return SimplifyCFGOpt(TTI, DTU, BB->getDataLayout(), LoopHeaders,
9434 Options)
9435 .run(BB);
9436}
9437