FunctionAttrs.cpp revision d04a8d4b33ff316ca4cf961e06c9e312eff8e64f
1//===- FunctionAttrs.cpp - Pass which marks functions readnone or readonly ===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements a simple interprocedural pass which walks the 11// call-graph, looking for functions which do not access or only read 12// non-local memory, and marking them readnone/readonly. In addition, 13// it marks function arguments (of pointer type) 'nocapture' if a call 14// to the function does not create any copies of the pointer value that 15// outlive the call. This more or less means that the pointer is only 16// dereferenced, and not returned from the function or stored in a global. 17// This pass is implemented as a bottom-up traversal of the call-graph. 18// 19//===----------------------------------------------------------------------===// 20 21#define DEBUG_TYPE "functionattrs" 22#include "llvm/Transforms/IPO.h" 23#include "llvm/ADT/SCCIterator.h" 24#include "llvm/ADT/SetVector.h" 25#include "llvm/ADT/SmallSet.h" 26#include "llvm/ADT/Statistic.h" 27#include "llvm/Analysis/AliasAnalysis.h" 28#include "llvm/Analysis/CallGraph.h" 29#include "llvm/Analysis/CaptureTracking.h" 30#include "llvm/CallGraphSCCPass.h" 31#include "llvm/GlobalVariable.h" 32#include "llvm/IntrinsicInst.h" 33#include "llvm/LLVMContext.h" 34#include "llvm/Support/InstIterator.h" 35using namespace llvm; 36 37STATISTIC(NumReadNone, "Number of functions marked readnone"); 38STATISTIC(NumReadOnly, "Number of functions marked readonly"); 39STATISTIC(NumNoCapture, "Number of arguments marked nocapture"); 40STATISTIC(NumNoAlias, "Number of function returns marked noalias"); 41 42namespace { 43 struct FunctionAttrs : public CallGraphSCCPass { 44 static char ID; // Pass identification, replacement for typeid 45 FunctionAttrs() : CallGraphSCCPass(ID), AA(0) { 46 initializeFunctionAttrsPass(*PassRegistry::getPassRegistry()); 47 } 48 49 // runOnSCC - Analyze the SCC, performing the transformation if possible. 50 bool runOnSCC(CallGraphSCC &SCC); 51 52 // AddReadAttrs - Deduce readonly/readnone attributes for the SCC. 53 bool AddReadAttrs(const CallGraphSCC &SCC); 54 55 // AddNoCaptureAttrs - Deduce nocapture attributes for the SCC. 56 bool AddNoCaptureAttrs(const CallGraphSCC &SCC); 57 58 // IsFunctionMallocLike - Does this function allocate new memory? 59 bool IsFunctionMallocLike(Function *F, 60 SmallPtrSet<Function*, 8> &) const; 61 62 // AddNoAliasAttrs - Deduce noalias attributes for the SCC. 63 bool AddNoAliasAttrs(const CallGraphSCC &SCC); 64 65 virtual void getAnalysisUsage(AnalysisUsage &AU) const { 66 AU.setPreservesCFG(); 67 AU.addRequired<AliasAnalysis>(); 68 CallGraphSCCPass::getAnalysisUsage(AU); 69 } 70 71 private: 72 AliasAnalysis *AA; 73 }; 74} 75 76char FunctionAttrs::ID = 0; 77INITIALIZE_PASS_BEGIN(FunctionAttrs, "functionattrs", 78 "Deduce function attributes", false, false) 79INITIALIZE_AG_DEPENDENCY(CallGraph) 80INITIALIZE_PASS_END(FunctionAttrs, "functionattrs", 81 "Deduce function attributes", false, false) 82 83Pass *llvm::createFunctionAttrsPass() { return new FunctionAttrs(); } 84 85 86/// AddReadAttrs - Deduce readonly/readnone attributes for the SCC. 87bool FunctionAttrs::AddReadAttrs(const CallGraphSCC &SCC) { 88 SmallPtrSet<Function*, 8> SCCNodes; 89 90 // Fill SCCNodes with the elements of the SCC. Used for quickly 91 // looking up whether a given CallGraphNode is in this SCC. 92 for (CallGraphSCC::iterator I = SCC.begin(), E = SCC.end(); I != E; ++I) 93 SCCNodes.insert((*I)->getFunction()); 94 95 // Check if any of the functions in the SCC read or write memory. If they 96 // write memory then they can't be marked readnone or readonly. 97 bool ReadsMemory = false; 98 for (CallGraphSCC::iterator I = SCC.begin(), E = SCC.end(); I != E; ++I) { 99 Function *F = (*I)->getFunction(); 100 101 if (F == 0) 102 // External node - may write memory. Just give up. 103 return false; 104 105 AliasAnalysis::ModRefBehavior MRB = AA->getModRefBehavior(F); 106 if (MRB == AliasAnalysis::DoesNotAccessMemory) 107 // Already perfect! 108 continue; 109 110 // Definitions with weak linkage may be overridden at linktime with 111 // something that writes memory, so treat them like declarations. 112 if (F->isDeclaration() || F->mayBeOverridden()) { 113 if (!AliasAnalysis::onlyReadsMemory(MRB)) 114 // May write memory. Just give up. 115 return false; 116 117 ReadsMemory = true; 118 continue; 119 } 120 121 // Scan the function body for instructions that may read or write memory. 122 for (inst_iterator II = inst_begin(F), E = inst_end(F); II != E; ++II) { 123 Instruction *I = &*II; 124 125 // Some instructions can be ignored even if they read or write memory. 126 // Detect these now, skipping to the next instruction if one is found. 127 CallSite CS(cast<Value>(I)); 128 if (CS) { 129 // Ignore calls to functions in the same SCC. 130 if (CS.getCalledFunction() && SCCNodes.count(CS.getCalledFunction())) 131 continue; 132 AliasAnalysis::ModRefBehavior MRB = AA->getModRefBehavior(CS); 133 // If the call doesn't access arbitrary memory, we may be able to 134 // figure out something. 135 if (AliasAnalysis::onlyAccessesArgPointees(MRB)) { 136 // If the call does access argument pointees, check each argument. 137 if (AliasAnalysis::doesAccessArgPointees(MRB)) 138 // Check whether all pointer arguments point to local memory, and 139 // ignore calls that only access local memory. 140 for (CallSite::arg_iterator CI = CS.arg_begin(), CE = CS.arg_end(); 141 CI != CE; ++CI) { 142 Value *Arg = *CI; 143 if (Arg->getType()->isPointerTy()) { 144 AliasAnalysis::Location Loc(Arg, 145 AliasAnalysis::UnknownSize, 146 I->getMetadata(LLVMContext::MD_tbaa)); 147 if (!AA->pointsToConstantMemory(Loc, /*OrLocal=*/true)) { 148 if (MRB & AliasAnalysis::Mod) 149 // Writes non-local memory. Give up. 150 return false; 151 if (MRB & AliasAnalysis::Ref) 152 // Ok, it reads non-local memory. 153 ReadsMemory = true; 154 } 155 } 156 } 157 continue; 158 } 159 // The call could access any memory. If that includes writes, give up. 160 if (MRB & AliasAnalysis::Mod) 161 return false; 162 // If it reads, note it. 163 if (MRB & AliasAnalysis::Ref) 164 ReadsMemory = true; 165 continue; 166 } else if (LoadInst *LI = dyn_cast<LoadInst>(I)) { 167 // Ignore non-volatile loads from local memory. (Atomic is okay here.) 168 if (!LI->isVolatile()) { 169 AliasAnalysis::Location Loc = AA->getLocation(LI); 170 if (AA->pointsToConstantMemory(Loc, /*OrLocal=*/true)) 171 continue; 172 } 173 } else if (StoreInst *SI = dyn_cast<StoreInst>(I)) { 174 // Ignore non-volatile stores to local memory. (Atomic is okay here.) 175 if (!SI->isVolatile()) { 176 AliasAnalysis::Location Loc = AA->getLocation(SI); 177 if (AA->pointsToConstantMemory(Loc, /*OrLocal=*/true)) 178 continue; 179 } 180 } else if (VAArgInst *VI = dyn_cast<VAArgInst>(I)) { 181 // Ignore vaargs on local memory. 182 AliasAnalysis::Location Loc = AA->getLocation(VI); 183 if (AA->pointsToConstantMemory(Loc, /*OrLocal=*/true)) 184 continue; 185 } 186 187 // Any remaining instructions need to be taken seriously! Check if they 188 // read or write memory. 189 if (I->mayWriteToMemory()) 190 // Writes memory. Just give up. 191 return false; 192 193 // If this instruction may read memory, remember that. 194 ReadsMemory |= I->mayReadFromMemory(); 195 } 196 } 197 198 // Success! Functions in this SCC do not access memory, or only read memory. 199 // Give them the appropriate attribute. 200 bool MadeChange = false; 201 for (CallGraphSCC::iterator I = SCC.begin(), E = SCC.end(); I != E; ++I) { 202 Function *F = (*I)->getFunction(); 203 204 if (F->doesNotAccessMemory()) 205 // Already perfect! 206 continue; 207 208 if (F->onlyReadsMemory() && ReadsMemory) 209 // No change. 210 continue; 211 212 MadeChange = true; 213 214 // Clear out any existing attributes. 215 AttrBuilder B; 216 B.addAttribute(Attributes::ReadOnly) 217 .addAttribute(Attributes::ReadNone); 218 F->removeAttribute(AttrListPtr::FunctionIndex, 219 Attributes::get(F->getContext(), B)); 220 221 // Add in the new attribute. 222 B.clear(); 223 B.addAttribute(ReadsMemory ? Attributes::ReadOnly : Attributes::ReadNone); 224 F->addAttribute(AttrListPtr::FunctionIndex, 225 Attributes::get(F->getContext(), B)); 226 227 if (ReadsMemory) 228 ++NumReadOnly; 229 else 230 ++NumReadNone; 231 } 232 233 return MadeChange; 234} 235 236namespace { 237 // For a given pointer Argument, this retains a list of Arguments of functions 238 // in the same SCC that the pointer data flows into. We use this to build an 239 // SCC of the arguments. 240 struct ArgumentGraphNode { 241 Argument *Definition; 242 SmallVector<ArgumentGraphNode*, 4> Uses; 243 }; 244 245 class ArgumentGraph { 246 // We store pointers to ArgumentGraphNode objects, so it's important that 247 // that they not move around upon insert. 248 typedef std::map<Argument*, ArgumentGraphNode> ArgumentMapTy; 249 250 ArgumentMapTy ArgumentMap; 251 252 // There is no root node for the argument graph, in fact: 253 // void f(int *x, int *y) { if (...) f(x, y); } 254 // is an example where the graph is disconnected. The SCCIterator requires a 255 // single entry point, so we maintain a fake ("synthetic") root node that 256 // uses every node. Because the graph is directed and nothing points into 257 // the root, it will not participate in any SCCs (except for its own). 258 ArgumentGraphNode SyntheticRoot; 259 260 public: 261 ArgumentGraph() { SyntheticRoot.Definition = 0; } 262 263 typedef SmallVectorImpl<ArgumentGraphNode*>::iterator iterator; 264 265 iterator begin() { return SyntheticRoot.Uses.begin(); } 266 iterator end() { return SyntheticRoot.Uses.end(); } 267 ArgumentGraphNode *getEntryNode() { return &SyntheticRoot; } 268 269 ArgumentGraphNode *operator[](Argument *A) { 270 ArgumentGraphNode &Node = ArgumentMap[A]; 271 Node.Definition = A; 272 SyntheticRoot.Uses.push_back(&Node); 273 return &Node; 274 } 275 }; 276 277 // This tracker checks whether callees are in the SCC, and if so it does not 278 // consider that a capture, instead adding it to the "Uses" list and 279 // continuing with the analysis. 280 struct ArgumentUsesTracker : public CaptureTracker { 281 ArgumentUsesTracker(const SmallPtrSet<Function*, 8> &SCCNodes) 282 : Captured(false), SCCNodes(SCCNodes) {} 283 284 void tooManyUses() { Captured = true; } 285 286 bool captured(Use *U) { 287 CallSite CS(U->getUser()); 288 if (!CS.getInstruction()) { Captured = true; return true; } 289 290 Function *F = CS.getCalledFunction(); 291 if (!F || !SCCNodes.count(F)) { Captured = true; return true; } 292 293 Function::arg_iterator AI = F->arg_begin(), AE = F->arg_end(); 294 for (CallSite::arg_iterator PI = CS.arg_begin(), PE = CS.arg_end(); 295 PI != PE; ++PI, ++AI) { 296 if (AI == AE) { 297 assert(F->isVarArg() && "More params than args in non-varargs call"); 298 Captured = true; 299 return true; 300 } 301 if (PI == U) { 302 Uses.push_back(AI); 303 break; 304 } 305 } 306 assert(!Uses.empty() && "Capturing call-site captured nothing?"); 307 return false; 308 } 309 310 bool Captured; // True only if certainly captured (used outside our SCC). 311 SmallVector<Argument*, 4> Uses; // Uses within our SCC. 312 313 const SmallPtrSet<Function*, 8> &SCCNodes; 314 }; 315} 316 317namespace llvm { 318 template<> struct GraphTraits<ArgumentGraphNode*> { 319 typedef ArgumentGraphNode NodeType; 320 typedef SmallVectorImpl<ArgumentGraphNode*>::iterator ChildIteratorType; 321 322 static inline NodeType *getEntryNode(NodeType *A) { return A; } 323 static inline ChildIteratorType child_begin(NodeType *N) { 324 return N->Uses.begin(); 325 } 326 static inline ChildIteratorType child_end(NodeType *N) { 327 return N->Uses.end(); 328 } 329 }; 330 template<> struct GraphTraits<ArgumentGraph*> 331 : public GraphTraits<ArgumentGraphNode*> { 332 static NodeType *getEntryNode(ArgumentGraph *AG) { 333 return AG->getEntryNode(); 334 } 335 static ChildIteratorType nodes_begin(ArgumentGraph *AG) { 336 return AG->begin(); 337 } 338 static ChildIteratorType nodes_end(ArgumentGraph *AG) { 339 return AG->end(); 340 } 341 }; 342} 343 344/// AddNoCaptureAttrs - Deduce nocapture attributes for the SCC. 345bool FunctionAttrs::AddNoCaptureAttrs(const CallGraphSCC &SCC) { 346 bool Changed = false; 347 348 SmallPtrSet<Function*, 8> SCCNodes; 349 350 // Fill SCCNodes with the elements of the SCC. Used for quickly 351 // looking up whether a given CallGraphNode is in this SCC. 352 for (CallGraphSCC::iterator I = SCC.begin(), E = SCC.end(); I != E; ++I) { 353 Function *F = (*I)->getFunction(); 354 if (F && !F->isDeclaration() && !F->mayBeOverridden()) 355 SCCNodes.insert(F); 356 } 357 358 ArgumentGraph AG; 359 360 AttrBuilder B; 361 B.addAttribute(Attributes::NoCapture); 362 363 // Check each function in turn, determining which pointer arguments are not 364 // captured. 365 for (CallGraphSCC::iterator I = SCC.begin(), E = SCC.end(); I != E; ++I) { 366 Function *F = (*I)->getFunction(); 367 368 if (F == 0) 369 // External node - only a problem for arguments that we pass to it. 370 continue; 371 372 // Definitions with weak linkage may be overridden at linktime with 373 // something that captures pointers, so treat them like declarations. 374 if (F->isDeclaration() || F->mayBeOverridden()) 375 continue; 376 377 // Functions that are readonly (or readnone) and nounwind and don't return 378 // a value can't capture arguments. Don't analyze them. 379 if (F->onlyReadsMemory() && F->doesNotThrow() && 380 F->getReturnType()->isVoidTy()) { 381 for (Function::arg_iterator A = F->arg_begin(), E = F->arg_end(); 382 A != E; ++A) { 383 if (A->getType()->isPointerTy() && !A->hasNoCaptureAttr()) { 384 A->addAttr(Attributes::get(F->getContext(), B)); 385 ++NumNoCapture; 386 Changed = true; 387 } 388 } 389 continue; 390 } 391 392 for (Function::arg_iterator A = F->arg_begin(), E = F->arg_end(); A!=E; ++A) 393 if (A->getType()->isPointerTy() && !A->hasNoCaptureAttr()) { 394 ArgumentUsesTracker Tracker(SCCNodes); 395 PointerMayBeCaptured(A, &Tracker); 396 if (!Tracker.Captured) { 397 if (Tracker.Uses.empty()) { 398 // If it's trivially not captured, mark it nocapture now. 399 A->addAttr(Attributes::get(F->getContext(), B)); 400 ++NumNoCapture; 401 Changed = true; 402 } else { 403 // If it's not trivially captured and not trivially not captured, 404 // then it must be calling into another function in our SCC. Save 405 // its particulars for Argument-SCC analysis later. 406 ArgumentGraphNode *Node = AG[A]; 407 for (SmallVectorImpl<Argument*>::iterator UI = Tracker.Uses.begin(), 408 UE = Tracker.Uses.end(); UI != UE; ++UI) 409 Node->Uses.push_back(AG[*UI]); 410 } 411 } 412 // Otherwise, it's captured. Don't bother doing SCC analysis on it. 413 } 414 } 415 416 // The graph we've collected is partial because we stopped scanning for 417 // argument uses once we solved the argument trivially. These partial nodes 418 // show up as ArgumentGraphNode objects with an empty Uses list, and for 419 // these nodes the final decision about whether they capture has already been 420 // made. If the definition doesn't have a 'nocapture' attribute by now, it 421 // captures. 422 423 for (scc_iterator<ArgumentGraph*> I = scc_begin(&AG), E = scc_end(&AG); 424 I != E; ++I) { 425 std::vector<ArgumentGraphNode*> &ArgumentSCC = *I; 426 if (ArgumentSCC.size() == 1) { 427 if (!ArgumentSCC[0]->Definition) continue; // synthetic root node 428 429 // eg. "void f(int* x) { if (...) f(x); }" 430 if (ArgumentSCC[0]->Uses.size() == 1 && 431 ArgumentSCC[0]->Uses[0] == ArgumentSCC[0]) { 432 ArgumentSCC[0]-> 433 Definition-> 434 addAttr(Attributes::get(ArgumentSCC[0]->Definition->getContext(), B)); 435 ++NumNoCapture; 436 Changed = true; 437 } 438 continue; 439 } 440 441 bool SCCCaptured = false; 442 for (std::vector<ArgumentGraphNode*>::iterator I = ArgumentSCC.begin(), 443 E = ArgumentSCC.end(); I != E && !SCCCaptured; ++I) { 444 ArgumentGraphNode *Node = *I; 445 if (Node->Uses.empty()) { 446 if (!Node->Definition->hasNoCaptureAttr()) 447 SCCCaptured = true; 448 } 449 } 450 if (SCCCaptured) continue; 451 452 SmallPtrSet<Argument*, 8> ArgumentSCCNodes; 453 // Fill ArgumentSCCNodes with the elements of the ArgumentSCC. Used for 454 // quickly looking up whether a given Argument is in this ArgumentSCC. 455 for (std::vector<ArgumentGraphNode*>::iterator I = ArgumentSCC.begin(), 456 E = ArgumentSCC.end(); I != E; ++I) { 457 ArgumentSCCNodes.insert((*I)->Definition); 458 } 459 460 for (std::vector<ArgumentGraphNode*>::iterator I = ArgumentSCC.begin(), 461 E = ArgumentSCC.end(); I != E && !SCCCaptured; ++I) { 462 ArgumentGraphNode *N = *I; 463 for (SmallVectorImpl<ArgumentGraphNode*>::iterator UI = N->Uses.begin(), 464 UE = N->Uses.end(); UI != UE; ++UI) { 465 Argument *A = (*UI)->Definition; 466 if (A->hasNoCaptureAttr() || ArgumentSCCNodes.count(A)) 467 continue; 468 SCCCaptured = true; 469 break; 470 } 471 } 472 if (SCCCaptured) continue; 473 474 for (unsigned i = 0, e = ArgumentSCC.size(); i != e; ++i) { 475 Argument *A = ArgumentSCC[i]->Definition; 476 A->addAttr(Attributes::get(A->getContext(), B)); 477 ++NumNoCapture; 478 Changed = true; 479 } 480 } 481 482 return Changed; 483} 484 485/// IsFunctionMallocLike - A function is malloc-like if it returns either null 486/// or a pointer that doesn't alias any other pointer visible to the caller. 487bool FunctionAttrs::IsFunctionMallocLike(Function *F, 488 SmallPtrSet<Function*, 8> &SCCNodes) const { 489 SmallSetVector<Value *, 8> FlowsToReturn; 490 for (Function::iterator I = F->begin(), E = F->end(); I != E; ++I) 491 if (ReturnInst *Ret = dyn_cast<ReturnInst>(I->getTerminator())) 492 FlowsToReturn.insert(Ret->getReturnValue()); 493 494 for (unsigned i = 0; i != FlowsToReturn.size(); ++i) { 495 Value *RetVal = FlowsToReturn[i]; 496 497 if (Constant *C = dyn_cast<Constant>(RetVal)) { 498 if (!C->isNullValue() && !isa<UndefValue>(C)) 499 return false; 500 501 continue; 502 } 503 504 if (isa<Argument>(RetVal)) 505 return false; 506 507 if (Instruction *RVI = dyn_cast<Instruction>(RetVal)) 508 switch (RVI->getOpcode()) { 509 // Extend the analysis by looking upwards. 510 case Instruction::BitCast: 511 case Instruction::GetElementPtr: 512 FlowsToReturn.insert(RVI->getOperand(0)); 513 continue; 514 case Instruction::Select: { 515 SelectInst *SI = cast<SelectInst>(RVI); 516 FlowsToReturn.insert(SI->getTrueValue()); 517 FlowsToReturn.insert(SI->getFalseValue()); 518 continue; 519 } 520 case Instruction::PHI: { 521 PHINode *PN = cast<PHINode>(RVI); 522 for (int i = 0, e = PN->getNumIncomingValues(); i != e; ++i) 523 FlowsToReturn.insert(PN->getIncomingValue(i)); 524 continue; 525 } 526 527 // Check whether the pointer came from an allocation. 528 case Instruction::Alloca: 529 break; 530 case Instruction::Call: 531 case Instruction::Invoke: { 532 CallSite CS(RVI); 533 if (CS.paramHasAttr(0, Attributes::NoAlias)) 534 break; 535 if (CS.getCalledFunction() && 536 SCCNodes.count(CS.getCalledFunction())) 537 break; 538 } // fall-through 539 default: 540 return false; // Did not come from an allocation. 541 } 542 543 if (PointerMayBeCaptured(RetVal, false, /*StoreCaptures=*/false)) 544 return false; 545 } 546 547 return true; 548} 549 550/// AddNoAliasAttrs - Deduce noalias attributes for the SCC. 551bool FunctionAttrs::AddNoAliasAttrs(const CallGraphSCC &SCC) { 552 SmallPtrSet<Function*, 8> SCCNodes; 553 554 // Fill SCCNodes with the elements of the SCC. Used for quickly 555 // looking up whether a given CallGraphNode is in this SCC. 556 for (CallGraphSCC::iterator I = SCC.begin(), E = SCC.end(); I != E; ++I) 557 SCCNodes.insert((*I)->getFunction()); 558 559 // Check each function in turn, determining which functions return noalias 560 // pointers. 561 for (CallGraphSCC::iterator I = SCC.begin(), E = SCC.end(); I != E; ++I) { 562 Function *F = (*I)->getFunction(); 563 564 if (F == 0) 565 // External node - skip it; 566 return false; 567 568 // Already noalias. 569 if (F->doesNotAlias(0)) 570 continue; 571 572 // Definitions with weak linkage may be overridden at linktime, so 573 // treat them like declarations. 574 if (F->isDeclaration() || F->mayBeOverridden()) 575 return false; 576 577 // We annotate noalias return values, which are only applicable to 578 // pointer types. 579 if (!F->getReturnType()->isPointerTy()) 580 continue; 581 582 if (!IsFunctionMallocLike(F, SCCNodes)) 583 return false; 584 } 585 586 bool MadeChange = false; 587 for (CallGraphSCC::iterator I = SCC.begin(), E = SCC.end(); I != E; ++I) { 588 Function *F = (*I)->getFunction(); 589 if (F->doesNotAlias(0) || !F->getReturnType()->isPointerTy()) 590 continue; 591 592 F->setDoesNotAlias(0); 593 ++NumNoAlias; 594 MadeChange = true; 595 } 596 597 return MadeChange; 598} 599 600bool FunctionAttrs::runOnSCC(CallGraphSCC &SCC) { 601 AA = &getAnalysis<AliasAnalysis>(); 602 603 bool Changed = AddReadAttrs(SCC); 604 Changed |= AddNoCaptureAttrs(SCC); 605 Changed |= AddNoAliasAttrs(SCC); 606 return Changed; 607} 608