LLVM 19.0.0git
ArgumentPromotion.cpp
Go to the documentation of this file.
1//===- ArgumentPromotion.cpp - Promote by-reference arguments -------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This pass promotes "by reference" arguments to be "by value" arguments. In
10// practice, this means looking for internal functions that have pointer
11// arguments. If it can prove, through the use of alias analysis, that an
12// argument is *only* loaded, then it can pass the value into the function
13// instead of the address of the value. This can cause recursive simplification
14// of code and lead to the elimination of allocas (especially in C++ template
15// code like the STL).
16//
17// This pass also handles aggregate arguments that are passed into a function,
18// scalarizing them if the elements of the aggregate are only loaded. Note that
19// by default it refuses to scalarize aggregates which would require passing in
20// more than three operands to the function, because passing thousands of
21// operands for a large array or structure is unprofitable! This limit can be
22// configured or disabled, however.
23//
24// Note that this transformation could also be done for arguments that are only
25// stored to (returning the value instead), but does not currently. This case
26// would be best handled when and if LLVM begins supporting multiple return
27// values from functions.
28//
29//===----------------------------------------------------------------------===//
30
32
34#include "llvm/ADT/STLExtras.h"
35#include "llvm/ADT/ScopeExit.h"
38#include "llvm/ADT/Statistic.h"
39#include "llvm/ADT/Twine.h"
43#include "llvm/Analysis/Loads.h"
47#include "llvm/IR/Argument.h"
48#include "llvm/IR/Attributes.h"
49#include "llvm/IR/BasicBlock.h"
50#include "llvm/IR/CFG.h"
51#include "llvm/IR/Constants.h"
52#include "llvm/IR/DataLayout.h"
54#include "llvm/IR/Dominators.h"
55#include "llvm/IR/Function.h"
56#include "llvm/IR/IRBuilder.h"
57#include "llvm/IR/InstrTypes.h"
58#include "llvm/IR/Instruction.h"
60#include "llvm/IR/Metadata.h"
61#include "llvm/IR/NoFolder.h"
62#include "llvm/IR/PassManager.h"
63#include "llvm/IR/Type.h"
64#include "llvm/IR/Use.h"
65#include "llvm/IR/User.h"
66#include "llvm/IR/Value.h"
68#include "llvm/Support/Debug.h"
72#include <algorithm>
73#include <cassert>
74#include <cstdint>
75#include <utility>
76#include <vector>
77
78using namespace llvm;
79
80#define DEBUG_TYPE "argpromotion"
81
82STATISTIC(NumArgumentsPromoted, "Number of pointer arguments promoted");
83STATISTIC(NumArgumentsDead, "Number of dead pointer args eliminated");
84
85namespace {
86
87struct ArgPart {
88 Type *Ty;
89 Align Alignment;
90 /// A representative guaranteed-executed load or store instruction for use by
91 /// metadata transfer.
92 Instruction *MustExecInstr;
93};
94
95using OffsetAndArgPart = std::pair<int64_t, ArgPart>;
96
97} // end anonymous namespace
98
100 Value *Ptr, Type *ResElemTy, int64_t Offset) {
101 if (Offset != 0) {
102 APInt APOffset(DL.getIndexTypeSizeInBits(Ptr->getType()), Offset);
103 Ptr = IRB.CreatePtrAdd(Ptr, IRB.getInt(APOffset));
104 }
105 return Ptr;
106}
107
108/// DoPromotion - This method actually performs the promotion of the specified
109/// arguments, and returns the new function. At this point, we know that it's
110/// safe to do so.
111static Function *
114 &ArgsToPromote) {
115 // Start by computing a new prototype for the function, which is the same as
116 // the old function, but has modified arguments.
117 FunctionType *FTy = F->getFunctionType();
118 std::vector<Type *> Params;
119
120 // Attribute - Keep track of the parameter attributes for the arguments
121 // that we are *not* promoting. For the ones that we do promote, the parameter
122 // attributes are lost
124 // Mapping from old to new argument indices. -1 for promoted or removed
125 // arguments.
126 SmallVector<unsigned> NewArgIndices;
127 AttributeList PAL = F->getAttributes();
128
129 // First, determine the new argument list
130 unsigned ArgNo = 0, NewArgNo = 0;
131 for (Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E;
132 ++I, ++ArgNo) {
133 if (!ArgsToPromote.count(&*I)) {
134 // Unchanged argument
135 Params.push_back(I->getType());
136 ArgAttrVec.push_back(PAL.getParamAttrs(ArgNo));
137 NewArgIndices.push_back(NewArgNo++);
138 } else if (I->use_empty()) {
139 // Dead argument (which are always marked as promotable)
140 ++NumArgumentsDead;
141 NewArgIndices.push_back((unsigned)-1);
142 } else {
143 const auto &ArgParts = ArgsToPromote.find(&*I)->second;
144 for (const auto &Pair : ArgParts) {
145 Params.push_back(Pair.second.Ty);
146 ArgAttrVec.push_back(AttributeSet());
147 }
148 ++NumArgumentsPromoted;
149 NewArgIndices.push_back((unsigned)-1);
150 NewArgNo += ArgParts.size();
151 }
152 }
153
154 Type *RetTy = FTy->getReturnType();
155
156 // Construct the new function type using the new arguments.
157 FunctionType *NFTy = FunctionType::get(RetTy, Params, FTy->isVarArg());
158
159 // Create the new function body and insert it into the module.
160 Function *NF = Function::Create(NFTy, F->getLinkage(), F->getAddressSpace(),
161 F->getName());
163 NF->copyMetadata(F, 0);
164 NF->setIsNewDbgInfoFormat(F->IsNewDbgInfoFormat);
165
166 // The new function will have the !dbg metadata copied from the original
167 // function. The original function may not be deleted, and dbg metadata need
168 // to be unique, so we need to drop it.
169 F->setSubprogram(nullptr);
170
171 LLVM_DEBUG(dbgs() << "ARG PROMOTION: Promoting to:" << *NF << "\n"
172 << "From: " << *F);
173
174 uint64_t LargestVectorWidth = 0;
175 for (auto *I : Params)
176 if (auto *VT = dyn_cast<llvm::VectorType>(I))
177 LargestVectorWidth = std::max(
178 LargestVectorWidth, VT->getPrimitiveSizeInBits().getKnownMinValue());
179
180 // Recompute the parameter attributes list based on the new arguments for
181 // the function.
182 NF->setAttributes(AttributeList::get(F->getContext(), PAL.getFnAttrs(),
183 PAL.getRetAttrs(), ArgAttrVec));
184
185 // Remap argument indices in allocsize attribute.
186 if (auto AllocSize = NF->getAttributes().getFnAttrs().getAllocSizeArgs()) {
187 unsigned Arg1 = NewArgIndices[AllocSize->first];
188 assert(Arg1 != (unsigned)-1 && "allocsize cannot be promoted argument");
189 std::optional<unsigned> Arg2;
190 if (AllocSize->second) {
191 Arg2 = NewArgIndices[*AllocSize->second];
192 assert(Arg2 != (unsigned)-1 && "allocsize cannot be promoted argument");
193 }
194 NF->addFnAttr(Attribute::getWithAllocSizeArgs(F->getContext(), Arg1, Arg2));
195 }
196
197 AttributeFuncs::updateMinLegalVectorWidthAttr(*NF, LargestVectorWidth);
198 ArgAttrVec.clear();
199
200 F->getParent()->getFunctionList().insert(F->getIterator(), NF);
201 NF->takeName(F);
202
203 // Loop over all the callers of the function, transforming the call sites to
204 // pass in the loaded pointers.
206 const DataLayout &DL = F->getParent()->getDataLayout();
208
209 while (!F->use_empty()) {
210 CallBase &CB = cast<CallBase>(*F->user_back());
211 assert(CB.getCalledFunction() == F);
212 const AttributeList &CallPAL = CB.getAttributes();
213 IRBuilder<NoFolder> IRB(&CB);
214
215 // Loop over the operands, inserting GEP and loads in the caller as
216 // appropriate.
217 auto *AI = CB.arg_begin();
218 ArgNo = 0;
219 for (Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E;
220 ++I, ++AI, ++ArgNo) {
221 if (!ArgsToPromote.count(&*I)) {
222 Args.push_back(*AI); // Unmodified argument
223 ArgAttrVec.push_back(CallPAL.getParamAttrs(ArgNo));
224 } else if (!I->use_empty()) {
225 Value *V = *AI;
226 const auto &ArgParts = ArgsToPromote.find(&*I)->second;
227 for (const auto &Pair : ArgParts) {
228 LoadInst *LI = IRB.CreateAlignedLoad(
229 Pair.second.Ty,
230 createByteGEP(IRB, DL, V, Pair.second.Ty, Pair.first),
231 Pair.second.Alignment, V->getName() + ".val");
232 if (Pair.second.MustExecInstr) {
233 LI->setAAMetadata(Pair.second.MustExecInstr->getAAMetadata());
234 LI->copyMetadata(*Pair.second.MustExecInstr,
235 {LLVMContext::MD_dereferenceable,
236 LLVMContext::MD_dereferenceable_or_null,
237 LLVMContext::MD_noundef,
238 LLVMContext::MD_nontemporal});
239 // Only transfer poison-generating metadata if we also have
240 // !noundef.
241 // TODO: Without !noundef, we could merge this metadata across
242 // all promoted loads.
243 if (LI->hasMetadata(LLVMContext::MD_noundef))
244 LI->copyMetadata(*Pair.second.MustExecInstr,
245 {LLVMContext::MD_range, LLVMContext::MD_nonnull,
246 LLVMContext::MD_align});
247 }
248 Args.push_back(LI);
249 ArgAttrVec.push_back(AttributeSet());
250 }
251 } else {
252 assert(ArgsToPromote.count(&*I) && I->use_empty());
253 DeadArgs.emplace_back(AI->get());
254 }
255 }
256
257 // Push any varargs arguments on the list.
258 for (; AI != CB.arg_end(); ++AI, ++ArgNo) {
259 Args.push_back(*AI);
260 ArgAttrVec.push_back(CallPAL.getParamAttrs(ArgNo));
261 }
262
264 CB.getOperandBundlesAsDefs(OpBundles);
265
266 CallBase *NewCS = nullptr;
267 if (InvokeInst *II = dyn_cast<InvokeInst>(&CB)) {
268 NewCS = InvokeInst::Create(NF, II->getNormalDest(), II->getUnwindDest(),
269 Args, OpBundles, "", &CB);
270 } else {
271 auto *NewCall = CallInst::Create(NF, Args, OpBundles, "", &CB);
272 NewCall->setTailCallKind(cast<CallInst>(&CB)->getTailCallKind());
273 NewCS = NewCall;
274 }
275 NewCS->setCallingConv(CB.getCallingConv());
276 NewCS->setAttributes(AttributeList::get(F->getContext(),
277 CallPAL.getFnAttrs(),
278 CallPAL.getRetAttrs(), ArgAttrVec));
279 NewCS->copyMetadata(CB, {LLVMContext::MD_prof, LLVMContext::MD_dbg});
280 Args.clear();
281 ArgAttrVec.clear();
282
284 LargestVectorWidth);
285
286 if (!CB.use_empty()) {
287 CB.replaceAllUsesWith(NewCS);
288 NewCS->takeName(&CB);
289 }
290
291 // Finally, remove the old call from the program, reducing the use-count of
292 // F.
293 CB.eraseFromParent();
294 }
295
297
298 // Since we have now created the new function, splice the body of the old
299 // function right into the new function, leaving the old rotting hulk of the
300 // function empty.
301 NF->splice(NF->begin(), F);
302
303 // We will collect all the new created allocas to promote them into registers
304 // after the following loop
306
307 // Loop over the argument list, transferring uses of the old arguments over to
308 // the new arguments, also transferring over the names as well.
310 for (Argument &Arg : F->args()) {
311 if (!ArgsToPromote.count(&Arg)) {
312 // If this is an unmodified argument, move the name and users over to the
313 // new version.
314 Arg.replaceAllUsesWith(&*I2);
315 I2->takeName(&Arg);
316 ++I2;
317 continue;
318 }
319
320 // There potentially are metadata uses for things like llvm.dbg.value.
321 // Replace them with undef, after handling the other regular uses.
322 auto RauwUndefMetadata = make_scope_exit(
323 [&]() { Arg.replaceAllUsesWith(UndefValue::get(Arg.getType())); });
324
325 if (Arg.use_empty())
326 continue;
327
328 // Otherwise, if we promoted this argument, we have to create an alloca in
329 // the callee for every promotable part and store each of the new incoming
330 // arguments into the corresponding alloca, what lets the old code (the
331 // store instructions if they are allowed especially) a chance to work as
332 // before.
333 assert(Arg.getType()->isPointerTy() &&
334 "Only arguments with a pointer type are promotable");
335
336 IRBuilder<NoFolder> IRB(&NF->begin()->front());
337
338 // Add only the promoted elements, so parts from ArgsToPromote
340 for (const auto &Pair : ArgsToPromote.find(&Arg)->second) {
341 int64_t Offset = Pair.first;
342 const ArgPart &Part = Pair.second;
343
344 Argument *NewArg = I2++;
345 NewArg->setName(Arg.getName() + "." + Twine(Offset) + ".val");
346
347 AllocaInst *NewAlloca = IRB.CreateAlloca(
348 Part.Ty, nullptr, Arg.getName() + "." + Twine(Offset) + ".allc");
349 NewAlloca->setAlignment(Pair.second.Alignment);
350 IRB.CreateAlignedStore(NewArg, NewAlloca, Pair.second.Alignment);
351
352 // Collect the alloca to retarget the users to
353 OffsetToAlloca.insert({Offset, NewAlloca});
354 }
355
356 auto GetAlloca = [&](Value *Ptr) {
357 APInt Offset(DL.getIndexTypeSizeInBits(Ptr->getType()), 0);
358 Ptr = Ptr->stripAndAccumulateConstantOffsets(DL, Offset,
359 /* AllowNonInbounds */ true);
360 assert(Ptr == &Arg && "Not constant offset from arg?");
361 return OffsetToAlloca.lookup(Offset.getSExtValue());
362 };
363
364 // Cleanup the code from the dead instructions: GEPs and BitCasts in between
365 // the original argument and its users: loads and stores. Retarget every
366 // user to the new created alloca.
369 append_range(Worklist, Arg.users());
370 while (!Worklist.empty()) {
371 Value *V = Worklist.pop_back_val();
372 if (isa<BitCastInst>(V) || isa<GetElementPtrInst>(V)) {
373 DeadInsts.push_back(cast<Instruction>(V));
374 append_range(Worklist, V->users());
375 continue;
376 }
377
378 if (auto *LI = dyn_cast<LoadInst>(V)) {
379 Value *Ptr = LI->getPointerOperand();
380 LI->setOperand(LoadInst::getPointerOperandIndex(), GetAlloca(Ptr));
381 continue;
382 }
383
384 if (auto *SI = dyn_cast<StoreInst>(V)) {
385 assert(!SI->isVolatile() && "Volatile operations can't be promoted.");
386 Value *Ptr = SI->getPointerOperand();
387 SI->setOperand(StoreInst::getPointerOperandIndex(), GetAlloca(Ptr));
388 continue;
389 }
390
391 llvm_unreachable("Unexpected user");
392 }
393
394 for (Instruction *I : DeadInsts) {
395 I->replaceAllUsesWith(PoisonValue::get(I->getType()));
396 I->eraseFromParent();
397 }
398
399 // Collect the allocas for promotion
400 for (const auto &Pair : OffsetToAlloca) {
401 assert(isAllocaPromotable(Pair.second) &&
402 "By design, only promotable allocas should be produced.");
403 Allocas.push_back(Pair.second);
404 }
405 }
406
407 LLVM_DEBUG(dbgs() << "ARG PROMOTION: " << Allocas.size()
408 << " alloca(s) are promotable by Mem2Reg\n");
409
410 if (!Allocas.empty()) {
411 // And we are able to call the `promoteMemoryToRegister()` function.
412 // Our earlier checks have ensured that PromoteMemToReg() will
413 // succeed.
414 auto &DT = FAM.getResult<DominatorTreeAnalysis>(*NF);
415 auto &AC = FAM.getResult<AssumptionAnalysis>(*NF);
416 PromoteMemToReg(Allocas, DT, &AC);
417 }
418
419 return NF;
420}
421
422/// Return true if we can prove that all callees pass in a valid pointer for the
423/// specified function argument.
425 Align NeededAlign,
426 uint64_t NeededDerefBytes) {
427 Function *Callee = Arg->getParent();
428 const DataLayout &DL = Callee->getParent()->getDataLayout();
429 APInt Bytes(64, NeededDerefBytes);
430
431 // Check if the argument itself is marked dereferenceable and aligned.
432 if (isDereferenceableAndAlignedPointer(Arg, NeededAlign, Bytes, DL))
433 return true;
434
435 // Look at all call sites of the function. At this point we know we only have
436 // direct callees.
437 return all_of(Callee->users(), [&](User *U) {
438 CallBase &CB = cast<CallBase>(*U);
439 return isDereferenceableAndAlignedPointer(CB.getArgOperand(Arg->getArgNo()),
440 NeededAlign, Bytes, DL);
441 });
442}
443
444/// Determine that this argument is safe to promote, and find the argument
445/// parts it can be promoted into.
446static bool findArgParts(Argument *Arg, const DataLayout &DL, AAResults &AAR,
447 unsigned MaxElements, bool IsRecursive,
449 // Quick exit for unused arguments
450 if (Arg->use_empty())
451 return true;
452
453 // We can only promote this argument if all the uses are loads at known
454 // offsets.
455 //
456 // Promoting the argument causes it to be loaded in the caller
457 // unconditionally. This is only safe if we can prove that either the load
458 // would have happened in the callee anyway (ie, there is a load in the entry
459 // block) or the pointer passed in at every call site is guaranteed to be
460 // valid.
461 // In the former case, invalid loads can happen, but would have happened
462 // anyway, in the latter case, invalid loads won't happen. This prevents us
463 // from introducing an invalid load that wouldn't have happened in the
464 // original code.
465
467 Align NeededAlign(1);
468 uint64_t NeededDerefBytes = 0;
469
470 // And if this is a byval argument we also allow to have store instructions.
471 // Only handle in such way arguments with specified alignment;
472 // if it's unspecified, the actual alignment of the argument is
473 // target-specific.
474 bool AreStoresAllowed = Arg->getParamByValType() && Arg->getParamAlign();
475
476 // An end user of a pointer argument is a load or store instruction.
477 // Returns std::nullopt if this load or store is not based on the argument.
478 // Return true if we can promote the instruction, false otherwise.
479 auto HandleEndUser = [&](auto *I, Type *Ty,
480 bool GuaranteedToExecute) -> std::optional<bool> {
481 // Don't promote volatile or atomic instructions.
482 if (!I->isSimple())
483 return false;
484
485 Value *Ptr = I->getPointerOperand();
486 APInt Offset(DL.getIndexTypeSizeInBits(Ptr->getType()), 0);
487 Ptr = Ptr->stripAndAccumulateConstantOffsets(DL, Offset,
488 /* AllowNonInbounds */ true);
489 if (Ptr != Arg)
490 return std::nullopt;
491
492 if (Offset.getSignificantBits() >= 64)
493 return false;
494
495 TypeSize Size = DL.getTypeStoreSize(Ty);
496 // Don't try to promote scalable types.
497 if (Size.isScalable())
498 return false;
499
500 // If this is a recursive function and one of the types is a pointer,
501 // then promoting it might lead to recursive promotion.
502 if (IsRecursive && Ty->isPointerTy())
503 return false;
504
505 int64_t Off = Offset.getSExtValue();
506 auto Pair = ArgParts.try_emplace(
507 Off, ArgPart{Ty, I->getAlign(), GuaranteedToExecute ? I : nullptr});
508 ArgPart &Part = Pair.first->second;
509 bool OffsetNotSeenBefore = Pair.second;
510
511 // We limit promotion to only promoting up to a fixed number of elements of
512 // the aggregate.
513 if (MaxElements > 0 && ArgParts.size() > MaxElements) {
514 LLVM_DEBUG(dbgs() << "ArgPromotion of " << *Arg << " failed: "
515 << "more than " << MaxElements << " parts\n");
516 return false;
517 }
518
519 // For now, we only support loading/storing one specific type at a given
520 // offset.
521 if (Part.Ty != Ty) {
522 LLVM_DEBUG(dbgs() << "ArgPromotion of " << *Arg << " failed: "
523 << "accessed as both " << *Part.Ty << " and " << *Ty
524 << " at offset " << Off << "\n");
525 return false;
526 }
527
528 // If this instruction is not guaranteed to execute, and we haven't seen a
529 // load or store at this offset before (or it had lower alignment), then we
530 // need to remember that requirement.
531 // Note that skipping instructions of previously seen offsets is only
532 // correct because we only allow a single type for a given offset, which
533 // also means that the number of accessed bytes will be the same.
534 if (!GuaranteedToExecute &&
535 (OffsetNotSeenBefore || Part.Alignment < I->getAlign())) {
536 // We won't be able to prove dereferenceability for negative offsets.
537 if (Off < 0)
538 return false;
539
540 // If the offset is not aligned, an aligned base pointer won't help.
541 if (!isAligned(I->getAlign(), Off))
542 return false;
543
544 NeededDerefBytes = std::max(NeededDerefBytes, Off + Size.getFixedValue());
545 NeededAlign = std::max(NeededAlign, I->getAlign());
546 }
547
548 Part.Alignment = std::max(Part.Alignment, I->getAlign());
549 return true;
550 };
551
552 // Look for loads and stores that are guaranteed to execute on entry.
553 for (Instruction &I : Arg->getParent()->getEntryBlock()) {
554 std::optional<bool> Res{};
555 if (LoadInst *LI = dyn_cast<LoadInst>(&I))
556 Res = HandleEndUser(LI, LI->getType(), /* GuaranteedToExecute */ true);
557 else if (StoreInst *SI = dyn_cast<StoreInst>(&I))
558 Res = HandleEndUser(SI, SI->getValueOperand()->getType(),
559 /* GuaranteedToExecute */ true);
560 if (Res && !*Res)
561 return false;
562
564 break;
565 }
566
567 // Now look at all loads of the argument. Remember the load instructions
568 // for the aliasing check below.
572 auto AppendUses = [&](const Value *V) {
573 for (const Use &U : V->uses())
574 if (Visited.insert(&U).second)
575 Worklist.push_back(&U);
576 };
577 AppendUses(Arg);
578 while (!Worklist.empty()) {
579 const Use *U = Worklist.pop_back_val();
580 Value *V = U->getUser();
581 if (isa<BitCastInst>(V)) {
582 AppendUses(V);
583 continue;
584 }
585
586 if (auto *GEP = dyn_cast<GetElementPtrInst>(V)) {
587 if (!GEP->hasAllConstantIndices())
588 return false;
589 AppendUses(V);
590 continue;
591 }
592
593 if (auto *LI = dyn_cast<LoadInst>(V)) {
594 if (!*HandleEndUser(LI, LI->getType(), /* GuaranteedToExecute */ false))
595 return false;
596 Loads.push_back(LI);
597 continue;
598 }
599
600 // Stores are allowed for byval arguments
601 auto *SI = dyn_cast<StoreInst>(V);
602 if (AreStoresAllowed && SI &&
603 U->getOperandNo() == StoreInst::getPointerOperandIndex()) {
604 if (!*HandleEndUser(SI, SI->getValueOperand()->getType(),
605 /* GuaranteedToExecute */ false))
606 return false;
607 continue;
608 // Only stores TO the argument is allowed, all the other stores are
609 // unknown users
610 }
611
612 // Unknown user.
613 LLVM_DEBUG(dbgs() << "ArgPromotion of " << *Arg << " failed: "
614 << "unknown user " << *V << "\n");
615 return false;
616 }
617
618 if (NeededDerefBytes || NeededAlign > 1) {
619 // Try to prove a required deref / aligned requirement.
620 if (!allCallersPassValidPointerForArgument(Arg, NeededAlign,
621 NeededDerefBytes)) {
622 LLVM_DEBUG(dbgs() << "ArgPromotion of " << *Arg << " failed: "
623 << "not dereferenceable or aligned\n");
624 return false;
625 }
626 }
627
628 if (ArgParts.empty())
629 return true; // No users, this is a dead argument.
630
631 // Sort parts by offset.
632 append_range(ArgPartsVec, ArgParts);
633 sort(ArgPartsVec, llvm::less_first());
634
635 // Make sure the parts are non-overlapping.
636 int64_t Offset = ArgPartsVec[0].first;
637 for (const auto &Pair : ArgPartsVec) {
638 if (Pair.first < Offset)
639 return false; // Overlap with previous part.
640
641 Offset = Pair.first + DL.getTypeStoreSize(Pair.second.Ty);
642 }
643
644 // If store instructions are allowed, the path from the entry of the function
645 // to each load may be not free of instructions that potentially invalidate
646 // the load, and this is an admissible situation.
647 if (AreStoresAllowed)
648 return true;
649
650 // Okay, now we know that the argument is only used by load instructions, and
651 // it is safe to unconditionally perform all of them. Use alias analysis to
652 // check to see if the pointer is guaranteed to not be modified from entry of
653 // the function to each of the load instructions.
654
655 // Because there could be several/many load instructions, remember which
656 // blocks we know to be transparent to the load.
658
659 for (LoadInst *Load : Loads) {
660 // Check to see if the load is invalidated from the start of the block to
661 // the load itself.
662 BasicBlock *BB = Load->getParent();
663
665 if (AAR.canInstructionRangeModRef(BB->front(), *Load, Loc, ModRefInfo::Mod))
666 return false; // Pointer is invalidated!
667
668 // Now check every path from the entry block to the load for transparency.
669 // To do this, we perform a depth first search on the inverse CFG from the
670 // loading block.
671 for (BasicBlock *P : predecessors(BB)) {
672 for (BasicBlock *TranspBB : inverse_depth_first_ext(P, TranspBlocks))
673 if (AAR.canBasicBlockModify(*TranspBB, Loc))
674 return false;
675 }
676 }
677
678 // If the path from the entry of the function to each load is free of
679 // instructions that potentially invalidate the load, we can make the
680 // transformation!
681 return true;
682}
683
684/// Check if callers and callee agree on how promoted arguments would be
685/// passed.
687 const TargetTransformInfo &TTI) {
688 return all_of(F.uses(), [&](const Use &U) {
689 CallBase *CB = dyn_cast<CallBase>(U.getUser());
690 if (!CB)
691 return false;
692
693 const Function *Caller = CB->getCaller();
694 const Function *Callee = CB->getCalledFunction();
695 return TTI.areTypesABICompatible(Caller, Callee, Types);
696 });
697}
698
699/// PromoteArguments - This method checks the specified function to see if there
700/// are any promotable arguments and if it is safe to promote the function (for
701/// example, all callers are direct). If safe to promote some arguments, it
702/// calls the DoPromotion method.
704 unsigned MaxElements, bool IsRecursive) {
705 // Don't perform argument promotion for naked functions; otherwise we can end
706 // up removing parameters that are seemingly 'not used' as they are referred
707 // to in the assembly.
708 if (F->hasFnAttribute(Attribute::Naked))
709 return nullptr;
710
711 // Make sure that it is local to this module.
712 if (!F->hasLocalLinkage())
713 return nullptr;
714
715 // Don't promote arguments for variadic functions. Adding, removing, or
716 // changing non-pack parameters can change the classification of pack
717 // parameters. Frontends encode that classification at the call site in the
718 // IR, while in the callee the classification is determined dynamically based
719 // on the number of registers consumed so far.
720 if (F->isVarArg())
721 return nullptr;
722
723 // Don't transform functions that receive inallocas, as the transformation may
724 // not be safe depending on calling convention.
725 if (F->getAttributes().hasAttrSomewhere(Attribute::InAlloca))
726 return nullptr;
727
728 // First check: see if there are any pointer arguments! If not, quick exit.
729 SmallVector<Argument *, 16> PointerArgs;
730 for (Argument &I : F->args())
731 if (I.getType()->isPointerTy())
732 PointerArgs.push_back(&I);
733 if (PointerArgs.empty())
734 return nullptr;
735
736 // Second check: make sure that all callers are direct callers. We can't
737 // transform functions that have indirect callers. Also see if the function
738 // is self-recursive.
739 for (Use &U : F->uses()) {
740 CallBase *CB = dyn_cast<CallBase>(U.getUser());
741 // Must be a direct call.
742 if (CB == nullptr || !CB->isCallee(&U) ||
743 CB->getFunctionType() != F->getFunctionType())
744 return nullptr;
745
746 // Can't change signature of musttail callee
747 if (CB->isMustTailCall())
748 return nullptr;
749
750 if (CB->getFunction() == F)
751 IsRecursive = true;
752 }
753
754 // Can't change signature of musttail caller
755 // FIXME: Support promoting whole chain of musttail functions
756 for (BasicBlock &BB : *F)
757 if (BB.getTerminatingMustTailCall())
758 return nullptr;
759
760 const DataLayout &DL = F->getParent()->getDataLayout();
761 auto &AAR = FAM.getResult<AAManager>(*F);
762 const auto &TTI = FAM.getResult<TargetIRAnalysis>(*F);
763
764 // Check to see which arguments are promotable. If an argument is promotable,
765 // add it to ArgsToPromote.
767 unsigned NumArgsAfterPromote = F->getFunctionType()->getNumParams();
768 for (Argument *PtrArg : PointerArgs) {
769 // Replace sret attribute with noalias. This reduces register pressure by
770 // avoiding a register copy.
771 if (PtrArg->hasStructRetAttr()) {
772 unsigned ArgNo = PtrArg->getArgNo();
773 F->removeParamAttr(ArgNo, Attribute::StructRet);
774 F->addParamAttr(ArgNo, Attribute::NoAlias);
775 for (Use &U : F->uses()) {
776 CallBase &CB = cast<CallBase>(*U.getUser());
777 CB.removeParamAttr(ArgNo, Attribute::StructRet);
778 CB.addParamAttr(ArgNo, Attribute::NoAlias);
779 }
780 }
781
782 // If we can promote the pointer to its value.
784
785 if (findArgParts(PtrArg, DL, AAR, MaxElements, IsRecursive, ArgParts)) {
787 for (const auto &Pair : ArgParts)
788 Types.push_back(Pair.second.Ty);
789
790 if (areTypesABICompatible(Types, *F, TTI)) {
791 NumArgsAfterPromote += ArgParts.size() - 1;
792 ArgsToPromote.insert({PtrArg, std::move(ArgParts)});
793 }
794 }
795 }
796
797 // No promotable pointer arguments.
798 if (ArgsToPromote.empty())
799 return nullptr;
800
801 if (NumArgsAfterPromote > TTI.getMaxNumArgs())
802 return nullptr;
803
804 return doPromotion(F, FAM, ArgsToPromote);
805}
806
809 LazyCallGraph &CG,
810 CGSCCUpdateResult &UR) {
811 bool Changed = false, LocalChange;
812
813 // Iterate until we stop promoting from this SCC.
814 do {
815 LocalChange = false;
816
818 AM.getResult<FunctionAnalysisManagerCGSCCProxy>(C, CG).getManager();
819
820 bool IsRecursive = C.size() > 1;
821 for (LazyCallGraph::Node &N : C) {
822 Function &OldF = N.getFunction();
823 Function *NewF = promoteArguments(&OldF, FAM, MaxElements, IsRecursive);
824 if (!NewF)
825 continue;
826 LocalChange = true;
827
828 // Directly substitute the functions in the call graph. Note that this
829 // requires the old function to be completely dead and completely
830 // replaced by the new function. It does no call graph updates, it merely
831 // swaps out the particular function mapped to a particular node in the
832 // graph.
833 C.getOuterRefSCC().replaceNodeFunction(N, *NewF);
834 FAM.clear(OldF, OldF.getName());
835 OldF.eraseFromParent();
836
837 PreservedAnalyses FuncPA;
838 FuncPA.preserveSet<CFGAnalyses>();
839 for (auto *U : NewF->users()) {
840 auto *UserF = cast<CallBase>(U)->getFunction();
841 FAM.invalidate(*UserF, FuncPA);
842 }
843 }
844
845 Changed |= LocalChange;
846 } while (LocalChange);
847
848 if (!Changed)
849 return PreservedAnalyses::all();
850
852 // We've cleared out analyses for deleted functions.
854 // We've manually invalidated analyses for functions we've modified.
856 return PA;
857}
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
static bool areTypesABICompatible(ArrayRef< Type * > Types, const Function &F, const TargetTransformInfo &TTI)
Check if callers and callee agree on how promoted arguments would be passed.
static Function * doPromotion(Function *F, FunctionAnalysisManager &FAM, const DenseMap< Argument *, SmallVector< OffsetAndArgPart, 4 > > &ArgsToPromote)
DoPromotion - This method actually performs the promotion of the specified arguments,...
static Function * promoteArguments(Function *F, FunctionAnalysisManager &FAM, unsigned MaxElements, bool IsRecursive)
PromoteArguments - This method checks the specified function to see if there are any promotable argum...
static bool allCallersPassValidPointerForArgument(Argument *Arg, Align NeededAlign, uint64_t NeededDerefBytes)
Return true if we can prove that all callees pass in a valid pointer for the specified function argum...
static Value * createByteGEP(IRBuilderBase &IRB, const DataLayout &DL, Value *Ptr, Type *ResElemTy, int64_t Offset)
static bool findArgParts(Argument *Arg, const DataLayout &DL, AAResults &AAR, unsigned MaxElements, bool IsRecursive, SmallVectorImpl< OffsetAndArgPart > &ArgPartsVec)
Determine that this argument is safe to promote, and find the argument parts it can be promoted into.
This file contains the simple types necessary to represent the attributes associated with functions a...
This is the interface for LLVM's primary stateless and local alias analysis.
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This file provides interfaces used to build and manipulate a call graph, which is a very useful tool ...
This file contains the declarations for the subclasses of Constant, which represent the different fla...
return RetTy
#define LLVM_DEBUG(X)
Definition: Debug.h:101
This file builds on the ADT/GraphTraits.h file to build generic depth first graph iterator.
uint64_t Size
Hexagon Common GEP
This file provides various utilities for inspecting and working with the control flow graph in LLVM I...
#define F(x, y, z)
Definition: MD5.cpp:55
#define I(x, y, z)
Definition: MD5.cpp:58
This file provides utility analysis objects describing memory locations.
This file contains the declarations for metadata subclasses.
#define P(N)
FunctionAnalysisManager FAM
This header defines various interfaces for pass management in LLVM.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file contains some templates that are useful if you are working with the STL at all.
This file defines the make_scope_exit function, which executes user-defined cleanup logic at scope ex...
This file defines the SmallPtrSet class.
This file defines the SmallVector class.
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
#define STATISTIC(VARNAME, DESC)
Definition: Statistic.h:167
This pass exposes codegen information to IR-level passes.
This defines the Use class.
A manager for alias analyses.
bool canInstructionRangeModRef(const Instruction &I1, const Instruction &I2, const MemoryLocation &Loc, const ModRefInfo Mode)
Check if it is possible for the execution of the specified instructions to mod(according to the mode)...
bool canBasicBlockModify(const BasicBlock &BB, const MemoryLocation &Loc)
Check if it is possible for execution of the specified basic block to modify the location Loc.
Class for arbitrary precision integers.
Definition: APInt.h:76
This templated class represents "all analyses that operate over <a particular IR unit>" (e....
Definition: Analysis.h:47
an instruction to allocate memory on the stack
Definition: Instructions.h:59
void setAlignment(Align Align)
Definition: Instructions.h:130
A container for analyses that lazily runs them and caches their results.
Definition: PassManager.h:348
void clear(IRUnitT &IR, llvm::StringRef Name)
Clear any cached analysis results for a single unit of IR.
void invalidate(IRUnitT &IR, const PreservedAnalyses &PA)
Invalidate cached analyses for an IR unit.
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Definition: PassManager.h:500
PreservedAnalyses run(LazyCallGraph::SCC &C, CGSCCAnalysisManager &AM, LazyCallGraph &CG, CGSCCUpdateResult &UR)
This class represents an incoming formal argument to a Function.
Definition: Argument.h:28
const Function * getParent() const
Definition: Argument.h:40
Type * getParamByValType() const
If this is a byval argument, return its type.
Definition: Function.cpp:223
MaybeAlign getParamAlign() const
If this is a byval or inalloca argument, return its alignment.
Definition: Function.cpp:214
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
A function analysis which provides an AssumptionCache.
AttributeSet getFnAttrs() const
The function attributes are returned.
static AttributeList get(LLVMContext &C, ArrayRef< std::pair< unsigned, Attribute > > Attrs)
Create an AttributeList with the specified parameters in it.
AttributeSet getRetAttrs() const
The attributes for the ret value are returned.
AttributeSet getParamAttrs(unsigned ArgNo) const
The attributes for the argument or parameter at the given index are returned.
std::optional< std::pair< unsigned, std::optional< unsigned > > > getAllocSizeArgs() const
Definition: Attributes.cpp:836
static Attribute getWithAllocSizeArgs(LLVMContext &Context, unsigned ElemSizeArg, const std::optional< unsigned > &NumElemsArg)
Definition: Attributes.cpp:226
LLVM Basic Block Representation.
Definition: BasicBlock.h:60
const Instruction & front() const
Definition: BasicBlock.h:461
Represents analyses that only rely on functions' control flow.
Definition: Analysis.h:70
Base class for all callable instructions (InvokeInst and CallInst) Holds everything related to callin...
Definition: InstrTypes.h:1259
void setCallingConv(CallingConv::ID CC)
Definition: InstrTypes.h:1543
void getOperandBundlesAsDefs(SmallVectorImpl< OperandBundleDef > &Defs) const
Return the list of operand bundles attached to this instruction as a vector of OperandBundleDefs.
void removeParamAttr(unsigned ArgNo, Attribute::AttrKind Kind)
Removes the attribute from the given argument.
Definition: InstrTypes.h:1657
Function * getCalledFunction() const
Returns the function called, or null if this is an indirect function invocation or the function signa...
Definition: InstrTypes.h:1481
CallingConv::ID getCallingConv() const
Definition: InstrTypes.h:1539
User::op_iterator arg_begin()
Return the iterator pointing to the beginning of the argument list.
Definition: InstrTypes.h:1401
bool isMustTailCall() const
Tests if this call site must be tail call optimized.
bool isCallee(Value::const_user_iterator UI) const
Determine whether the passed iterator points to the callee operand's Use.
Definition: InstrTypes.h:1492
void setAttributes(AttributeList A)
Set the parameter attributes for this call.
Definition: InstrTypes.h:1562
User::op_iterator arg_end()
Return the iterator pointing to the end of the argument list.
Definition: InstrTypes.h:1407
FunctionType * getFunctionType() const
Definition: InstrTypes.h:1339
AttributeList getAttributes() const
Return the parameter attributes for this call.
Definition: InstrTypes.h:1558
void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind)
Adds the attribute to the indicated argument.
Definition: InstrTypes.h:1610
Function * getCaller()
Helper to get the caller (the parent function).
static CallInst * Create(FunctionType *Ty, Value *F, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:110
ValueT lookup(const_arg_type_t< KeyT > Val) const
lookup - Return the entry for the specified key, or a default constructed value if no such entry exis...
Definition: DenseMap.h:202
std::pair< iterator, bool > try_emplace(KeyT &&Key, Ts &&... Args)
Definition: DenseMap.h:235
unsigned size() const
Definition: DenseMap.h:99
bool empty() const
Definition: DenseMap.h:98
std::pair< iterator, bool > insert(const std::pair< KeyT, ValueT > &KV)
Definition: DenseMap.h:220
Analysis pass which computes a DominatorTree.
Definition: Dominators.h:275
A proxy from a FunctionAnalysisManager to an SCC.
void addFnAttr(Attribute::AttrKind Kind)
Add function attributes to this function.
Definition: Function.cpp:579
static Function * Create(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace, const Twine &N="", Module *M=nullptr)
Definition: Function.h:162
void splice(Function::iterator ToIt, Function *FromF)
Transfer all blocks from FromF to this function at ToIt.
Definition: Function.h:731
const BasicBlock & getEntryBlock() const
Definition: Function.h:779
AttributeList getAttributes() const
Return the attribute list for this Function.
Definition: Function.h:338
iterator begin()
Definition: Function.h:795
void eraseFromParent()
eraseFromParent - This method unlinks 'this' from the containing module and deletes it.
Definition: Function.cpp:389
arg_iterator arg_begin()
Definition: Function.h:810
void setAttributes(AttributeList Attrs)
Set the attribute list for this Function.
Definition: Function.h:341
void setIsNewDbgInfoFormat(bool NewVal)
Definition: Function.cpp:99
void copyAttributesFrom(const Function *Src)
copyAttributesFrom - copy all additional attributes (those not needed to create a Function) from the ...
Definition: Function.cpp:781
void copyMetadata(const GlobalObject *Src, unsigned Offset)
Copy metadata from Src, adjusting offsets by Offset.
Definition: Metadata.cpp:1753
Common base class shared among various IRBuilders.
Definition: IRBuilder.h:94
AllocaInst * CreateAlloca(Type *Ty, unsigned AddrSpace, Value *ArraySize=nullptr, const Twine &Name="")
Definition: IRBuilder.h:1772
Value * CreatePtrAdd(Value *Ptr, Value *Offset, const Twine &Name="", bool IsInBounds=false)
Definition: IRBuilder.h:1977
LoadInst * CreateAlignedLoad(Type *Ty, Value *Ptr, MaybeAlign Align, const char *Name)
Definition: IRBuilder.h:1806
StoreInst * CreateAlignedStore(Value *Val, Value *Ptr, MaybeAlign Align, bool isVolatile=false)
Definition: IRBuilder.h:1825
ConstantInt * getInt(const APInt &AI)
Get a constant integer value.
Definition: IRBuilder.h:496
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
Definition: IRBuilder.h:2649
void setAAMetadata(const AAMDNodes &N)
Sets the AA metadata on this instruction from the AAMDNodes structure.
Definition: Metadata.cpp:1718
bool hasMetadata() const
Return true if this instruction has any metadata attached to it.
Definition: Instruction.h:339
InstListType::iterator eraseFromParent()
This method unlinks 'this' from the containing basic block and deletes it.
Definition: Instruction.cpp:93
const Function * getFunction() const
Return the function this instruction belongs to.
Definition: Instruction.cpp:75
void copyMetadata(const Instruction &SrcInst, ArrayRef< unsigned > WL=ArrayRef< unsigned >())
Copy metadata from SrcInst to this instruction.
Invoke instruction.
static InvokeInst * Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal, BasicBlock *IfException, ArrayRef< Value * > Args, const Twine &NameStr, Instruction *InsertBefore=nullptr)
A node in the call graph.
An SCC of the call graph.
A lazily constructed view of the call graph of a module.
An instruction for reading from memory.
Definition: Instructions.h:178
static unsigned getPointerOperandIndex()
Definition: Instructions.h:267
Representation for a specific memory location.
static MemoryLocation get(const LoadInst *LI)
Return a location with information about the memory reference by the given instruction.
static PoisonValue * get(Type *T)
Static factory methods - Return an 'poison' object of the specified type.
Definition: Constants.cpp:1743
A set of analyses that are preserved following a run of a transformation pass.
Definition: Analysis.h:109
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: Analysis.h:115
void preserveSet()
Mark an analysis set as preserved.
Definition: Analysis.h:144
void preserve()
Mark an analysis as preserved.
Definition: Analysis.h:129
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
Definition: SmallPtrSet.h:342
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
Definition: SmallPtrSet.h:427
bool empty() const
Definition: SmallVector.h:94
size_t size() const
Definition: SmallVector.h:91
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: SmallVector.h:586
reference emplace_back(ArgTypes &&... Args)
Definition: SmallVector.h:950
void push_back(const T &Elt)
Definition: SmallVector.h:426
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209
An instruction for storing to memory.
Definition: Instructions.h:302
static unsigned getPointerOperandIndex()
Definition: Instructions.h:404
Analysis pass providing the TargetTransformInfo.
This pass provides access to the codegen interfaces that are needed for IR-level transformations.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
static UndefValue * get(Type *T)
Static factory methods - Return an 'undef' object of the specified type.
Definition: Constants.cpp:1724
A Use represents the edge between a Value definition and its users.
Definition: Use.h:43
LLVM Value Representation.
Definition: Value.h:74
void setName(const Twine &Name)
Change the name of the value.
Definition: Value.cpp:377
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
Definition: Value.cpp:534
iterator_range< user_iterator > users()
Definition: Value.h:421
bool use_empty() const
Definition: Value.h:344
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:309
void takeName(Value *V)
Transfer the name from V to this value.
Definition: Value.cpp:383
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
void updateMinLegalVectorWidthAttr(Function &Fn, uint64_t Width)
Update min-legal-vector-width if it is in Attribute and less than Width.
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
@ Offset
Definition: DWP.cpp:456
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1731
void PromoteMemToReg(ArrayRef< AllocaInst * > Allocas, DominatorTree &DT, AssumptionCache *AC=nullptr)
Promote the specified list of alloca instructions into scalar registers, inserting PHI nodes as appro...
detail::scope_exit< std::decay_t< Callable > > make_scope_exit(Callable &&F)
Definition: ScopeExit.h:59
bool isAligned(Align Lhs, uint64_t SizeInBytes)
Checks that SizeInBytes is a multiple of the alignment.
Definition: Alignment.h:145
bool isDereferenceableAndAlignedPointer(const Value *V, Type *Ty, Align Alignment, const DataLayout &DL, const Instruction *CtxI=nullptr, AssumptionCache *AC=nullptr, const DominatorTree *DT=nullptr, const TargetLibraryInfo *TLI=nullptr)
Returns true if V is always a dereferenceable pointer with alignment greater or equal than requested.
Definition: Loads.cpp:199
void append_range(Container &C, Range &&R)
Wrapper function to append range R to container C.
Definition: STLExtras.h:2053
bool isAllocaPromotable(const AllocaInst *AI)
Return true if this alloca is legal for promotion.
void sort(IteratorTy Start, IteratorTy End)
Definition: STLExtras.h:1656
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
iterator_range< idf_ext_iterator< T, SetTy > > inverse_depth_first_ext(const T &G, SetTy &S)
bool RecursivelyDeleteTriviallyDeadInstructionsPermissive(SmallVectorImpl< WeakTrackingVH > &DeadInsts, const TargetLibraryInfo *TLI=nullptr, MemorySSAUpdater *MSSAU=nullptr, std::function< void(Value *)> AboutToDeleteCallback=std::function< void(Value *)>())
Same functionality as RecursivelyDeleteTriviallyDeadInstructions, but allow instructions that are not...
Definition: Local.cpp:548
bool isGuaranteedToTransferExecutionToSuccessor(const Instruction *I)
Return true if this function can prove that the instruction I will always transfer execution to one o...
auto predecessors(const MachineBasicBlock *BB)
#define N
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
Support structure for SCC passes to communicate updates the call graph back to the CGSCC pass manager...
Function object to check whether the first component of a container supported by std::get (like std::...
Definition: STLExtras.h:1459