static bool isAddressTaken(Value* V) {
//Find the users for the value to see if it was assigned.
for (Value::const_use_iterator I = V->use_begin(), E = V->use_end(); I != E; ++I) {
User *U = I->getUser();
if(isa<StoreInst>(U))
return true;
if (!isa<CallInst>(U) && !isa<InvokeInst>(U)) {
if(U->use_empty())
continue;
if(isa<GlobalAlias>(U)) {
if(isAddressTaken(U))
return true;
} else {
if (Constant *C = dyn_cast<Constant>(U)) {
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) {
if (CE->getOpcode() == Instruction::BitCast) {
return isAddressTaken(CE);
}
}
}
return true;
}
// FIXME: Can be more robust here for weak aliases that
// are never used
} else {
llvm::CallSite CS(cast<Instruction>(U));
if (!CS.isCallee(&*I))
return true;
}
}
return false;
}
/// SurveyUse - This looks at a single use of an argument or return value
/// and determines if it should be alive or not. Adds this use to MaybeLiveUses
/// if it causes the used value to become MaybeLive.
///
/// RetValNum is the return value number to use when this use is used in a
/// return instruction. This is used in the recursion, you should always leave
/// it at 0.
DAE::Liveness DAE::SurveyUse(Value::const_use_iterator U,
UseVector &MaybeLiveUses, unsigned RetValNum) {
const User *V = *U;
if (const ReturnInst *RI = dyn_cast<ReturnInst>(V)) {
// The value is returned from a function. It's only live when the
// function's return value is live. We use RetValNum here, for the case
// that U is really a use of an insertvalue instruction that uses the
// original Use.
RetOrArg Use = CreateRet(RI->getParent()->getParent(), RetValNum);
// We might be live, depending on the liveness of Use.
return MarkIfNotLive(Use, MaybeLiveUses);
}
if (const InsertValueInst *IV = dyn_cast<InsertValueInst>(V)) {
if (U.getOperandNo() != InsertValueInst::getAggregateOperandIndex()
&& IV->hasIndices())
// The use we are examining is inserted into an aggregate. Our liveness
// depends on all uses of that aggregate, but if it is used as a return
// value, only index at which we were inserted counts.
RetValNum = *IV->idx_begin();
// Note that if we are used as the aggregate operand to the insertvalue,
// we don't change RetValNum, but do survey all our uses.
Liveness Result = MaybeLive;
for (Value::const_use_iterator I = IV->use_begin(),
E = V->use_end(); I != E; ++I) {
Result = SurveyUse(I, MaybeLiveUses, RetValNum);
if (Result == Live)
break;
}
return Result;
}
if (ImmutableCallSite CS = V) {
const Function *F = CS.getCalledFunction();
if (F) {
// Used in a direct call.
// Find the argument number. We know for sure that this use is an
// argument, since if it was the function argument this would be an
// indirect call and the we know can't be looking at a value of the
// label type (for the invoke instruction).
unsigned ArgNo = CS.getArgumentNo(U);
if (ArgNo >= F->getFunctionType()->getNumParams())
// The value is passed in through a vararg! Must be live.
return Live;
assert(CS.getArgument(ArgNo)
== CS->getOperand(U.getOperandNo())
&& "Argument is not where we expected it");
// Value passed to a normal call. It's only live when the corresponding
// argument to the called function turns out live.
RetOrArg Use = CreateArg(F, ArgNo);
return MarkIfNotLive(Use, MaybeLiveUses);
}
}
// Used in any other way? Value must be live.
return Live;
}
void llvm::PointerMayBeCaptured(const Value *V, CaptureTracker *Tracker) {
assert(V->getType()->isPointerTy() && "Capture is for pointers only!");
SmallVector<Use*, Threshold> Worklist;
SmallSet<Use*, Threshold> Visited;
int Count = 0;
for (Value::const_use_iterator UI = V->use_begin(), UE = V->use_end();
UI != UE; ++UI) {
// If there are lots of uses, conservatively say that the value
// is captured to avoid taking too much compile time.
if (Count++ >= Threshold)
return Tracker->tooManyUses();
Use *U = &UI.getUse();
if (!Tracker->shouldExplore(U)) continue;
Visited.insert(U);
Worklist.push_back(U);
}
while (!Worklist.empty()) {
Use *U = Worklist.pop_back_val();
Instruction *I = cast<Instruction>(U->getUser());
V = U->get();
switch (I->getOpcode()) {
case Instruction::Call:
case Instruction::Invoke: {
CallSite CS(I);
// Not captured if the callee is readonly, doesn't return a copy through
// its return value and doesn't unwind (a readonly function can leak bits
// by throwing an exception or not depending on the input value).
if (CS.onlyReadsMemory() && CS.doesNotThrow() && I->getType()->isVoidTy())
break;
// Not captured if only passed via 'nocapture' arguments. Note that
// calling a function pointer does not in itself cause the pointer to
// be captured. This is a subtle point considering that (for example)
// the callee might return its own address. It is analogous to saying
// that loading a value from a pointer does not cause the pointer to be
// captured, even though the loaded value might be the pointer itself
// (think of self-referential objects).
CallSite::arg_iterator B = CS.arg_begin(), E = CS.arg_end();
for (CallSite::arg_iterator A = B; A != E; ++A)
if (A->get() == V && !CS.doesNotCapture(A - B))
// The parameter is not marked 'nocapture' - captured.
if (Tracker->captured(U))
return;
break;
}
case Instruction::Load:
// Loading from a pointer does not cause it to be captured.
break;
case Instruction::VAArg:
// "va-arg" from a pointer does not cause it to be captured.
break;
case Instruction::Store:
if (V == I->getOperand(0))
// Stored the pointer - conservatively assume it may be captured.
if (Tracker->captured(U))
return;
// Storing to the pointee does not cause the pointer to be captured.
break;
case Instruction::BitCast:
case Instruction::GetElementPtr:
case Instruction::PHI:
case Instruction::Select:
// The original value is not captured via this if the new value isn't.
for (Instruction::use_iterator UI = I->use_begin(), UE = I->use_end();
UI != UE; ++UI) {
Use *U = &UI.getUse();
if (Visited.insert(U))
if (Tracker->shouldExplore(U))
Worklist.push_back(U);
}
break;
case Instruction::ICmp:
// Don't count comparisons of a no-alias return value against null as
// captures. This allows us to ignore comparisons of malloc results
// with null, for example.
if (ConstantPointerNull *CPN =
dyn_cast<ConstantPointerNull>(I->getOperand(1)))
if (CPN->getType()->getAddressSpace() == 0)
if (isNoAliasCall(V->stripPointerCastsSafe()))
break;
// Otherwise, be conservative. There are crazy ways to capture pointers
// using comparisons.
if (Tracker->captured(U))
return;
break;
default:
// Something else - be conservative and say it is captured.
if (Tracker->captured(U))
return;
break;
}
}
// All uses examined.
}
bool ObjCARCContract::runOnFunction(Function &F) {
if (!EnableARCOpts)
return false;
// If nothing in the Module uses ARC, don't do anything.
if (!Run)
return false;
Changed = false;
AA = &getAnalysis<AliasAnalysis>();
DT = &getAnalysis<DominatorTree>();
PA.setAA(&getAnalysis<AliasAnalysis>());
// Track whether it's ok to mark objc_storeStrong calls with the "tail"
// keyword. Be conservative if the function has variadic arguments.
// It seems that functions which "return twice" are also unsafe for the
// "tail" argument, because they are setjmp, which could need to
// return to an earlier stack state.
bool TailOkForStoreStrongs = !F.isVarArg() &&
!F.callsFunctionThatReturnsTwice();
// For ObjC library calls which return their argument, replace uses of the
// argument with uses of the call return value, if it dominates the use. This
// reduces register pressure.
SmallPtrSet<Instruction *, 4> DependingInstructions;
SmallPtrSet<const BasicBlock *, 4> Visited;
for (inst_iterator I = inst_begin(&F), E = inst_end(&F); I != E; ) {
Instruction *Inst = &*I++;
DEBUG(dbgs() << "ObjCARCContract: Visiting: " << *Inst << "\n");
// Only these library routines return their argument. In particular,
// objc_retainBlock does not necessarily return its argument.
InstructionClass Class = GetBasicInstructionClass(Inst);
switch (Class) {
case IC_Retain:
case IC_FusedRetainAutorelease:
case IC_FusedRetainAutoreleaseRV:
break;
case IC_Autorelease:
case IC_AutoreleaseRV:
if (ContractAutorelease(F, Inst, Class, DependingInstructions, Visited))
continue;
break;
case IC_RetainRV: {
// If we're compiling for a target which needs a special inline-asm
// marker to do the retainAutoreleasedReturnValue optimization,
// insert it now.
if (!RetainRVMarker)
break;
BasicBlock::iterator BBI = Inst;
BasicBlock *InstParent = Inst->getParent();
// Step up to see if the call immediately precedes the RetainRV call.
// If it's an invoke, we have to cross a block boundary. And we have
// to carefully dodge no-op instructions.
do {
if (&*BBI == InstParent->begin()) {
BasicBlock *Pred = InstParent->getSinglePredecessor();
if (!Pred)
goto decline_rv_optimization;
BBI = Pred->getTerminator();
break;
}
--BBI;
} while (IsNoopInstruction(BBI));
if (&*BBI == GetObjCArg(Inst)) {
DEBUG(dbgs() << "ObjCARCContract: Adding inline asm marker for "
"retainAutoreleasedReturnValue optimization.\n");
Changed = true;
InlineAsm *IA =
InlineAsm::get(FunctionType::get(Type::getVoidTy(Inst->getContext()),
/*isVarArg=*/false),
RetainRVMarker->getString(),
/*Constraints=*/"", /*hasSideEffects=*/true);
CallInst::Create(IA, "", Inst);
}
decline_rv_optimization:
break;
}
case IC_InitWeak: {
// objc_initWeak(p, null) => *p = null
CallInst *CI = cast<CallInst>(Inst);
if (IsNullOrUndef(CI->getArgOperand(1))) {
Value *Null =
ConstantPointerNull::get(cast<PointerType>(CI->getType()));
Changed = true;
new StoreInst(Null, CI->getArgOperand(0), CI);
DEBUG(dbgs() << "OBJCARCContract: Old = " << *CI << "\n"
<< " New = " << *Null << "\n");
CI->replaceAllUsesWith(Null);
CI->eraseFromParent();
}
continue;
}
case IC_Release:
ContractRelease(Inst, I);
continue;
case IC_User:
// Be conservative if the function has any alloca instructions.
// Technically we only care about escaping alloca instructions,
// but this is sufficient to handle some interesting cases.
if (isa<AllocaInst>(Inst))
TailOkForStoreStrongs = false;
continue;
case IC_IntrinsicUser:
// Remove calls to @clang.arc.use(...).
Inst->eraseFromParent();
continue;
default:
continue;
}
DEBUG(dbgs() << "ObjCARCContract: Finished List.\n\n");
// Don't use GetObjCArg because we don't want to look through bitcasts
// and such; to do the replacement, the argument must have type i8*.
const Value *Arg = cast<CallInst>(Inst)->getArgOperand(0);
for (;;) {
// If we're compiling bugpointed code, don't get in trouble.
if (!isa<Instruction>(Arg) && !isa<Argument>(Arg))
break;
// Look through the uses of the pointer.
for (Value::const_use_iterator UI = Arg->use_begin(), UE = Arg->use_end();
UI != UE; ) {
Use &U = UI.getUse();
unsigned OperandNo = UI.getOperandNo();
++UI; // Increment UI now, because we may unlink its element.
// If the call's return value dominates a use of the call's argument
// value, rewrite the use to use the return value. We check for
// reachability here because an unreachable call is considered to
// trivially dominate itself, which would lead us to rewriting its
// argument in terms of its return value, which would lead to
// infinite loops in GetObjCArg.
if (DT->isReachableFromEntry(U) && DT->dominates(Inst, U)) {
Changed = true;
Instruction *Replacement = Inst;
Type *UseTy = U.get()->getType();
if (PHINode *PHI = dyn_cast<PHINode>(U.getUser())) {
// For PHI nodes, insert the bitcast in the predecessor block.
unsigned ValNo = PHINode::getIncomingValueNumForOperand(OperandNo);
BasicBlock *BB = PHI->getIncomingBlock(ValNo);
if (Replacement->getType() != UseTy)
Replacement = new BitCastInst(Replacement, UseTy, "",
&BB->back());
// While we're here, rewrite all edges for this PHI, rather
// than just one use at a time, to minimize the number of
// bitcasts we emit.
for (unsigned i = 0, e = PHI->getNumIncomingValues(); i != e; ++i)
if (PHI->getIncomingBlock(i) == BB) {
// Keep the UI iterator valid.
if (&PHI->getOperandUse(
PHINode::getOperandNumForIncomingValue(i)) ==
&UI.getUse())
++UI;
PHI->setIncomingValue(i, Replacement);
}
} else {
if (Replacement->getType() != UseTy)
Replacement = new BitCastInst(Replacement, UseTy, "",
cast<Instruction>(U.getUser()));
U.set(Replacement);
}
}
}
// If Arg is a no-op casted pointer, strip one level of casts and iterate.
if (const BitCastInst *BI = dyn_cast<BitCastInst>(Arg))
Arg = BI->getOperand(0);
else if (isa<GEPOperator>(Arg) &&
cast<GEPOperator>(Arg)->hasAllZeroIndices())
Arg = cast<GEPOperator>(Arg)->getPointerOperand();
else if (isa<GlobalAlias>(Arg) &&
!cast<GlobalAlias>(Arg)->mayBeOverridden())
Arg = cast<GlobalAlias>(Arg)->getAliasee();
else
break;
}
}
// If this function has no escaping allocas or suspicious vararg usage,
// objc_storeStrong calls can be marked with the "tail" keyword.
if (TailOkForStoreStrongs)
for (SmallPtrSet<CallInst *, 8>::iterator I = StoreStrongCalls.begin(),
E = StoreStrongCalls.end(); I != E; ++I)
(*I)->setTailCall();
StoreStrongCalls.clear();
return Changed;
}
/// compute - Compute a new Memo for the given value.
///
LiveValues::Memo &LiveValues::compute(const Value *V) {
Memo &M = Memos[V];
// Determine the block containing the definition.
const BasicBlock *DefBB;
// Instructions define values with meaningful live ranges.
if (const Instruction *I = dyn_cast<Instruction>(V))
DefBB = I->getParent();
// Arguments can be analyzed as values defined in the entry block.
else if (const Argument *A = dyn_cast<Argument>(V))
DefBB = &A->getParent()->getEntryBlock();
// Constants and other things aren't meaningful here, so just
// return having computed an empty Memo so that we don't come
// here again. The assumption here is that client code won't
// be asking about such values very often.
else
return M;
// Determine if the value is defined inside a loop. This is used
// to track whether the value is ever used outside the loop, so
// it'll be set to null if the value is either not defined in a
// loop or used outside the loop in which it is defined.
const Loop *L = LI->getLoopFor(DefBB);
// Track whether the value is used anywhere outside of the block
// in which it is defined.
bool LiveOutOfDefBB = false;
// Examine each use of the value.
for (Value::const_use_iterator I = V->use_begin(), E = V->use_end();
I != E; ++I) {
const User *U = *I;
const BasicBlock *UseBB = cast<Instruction>(U)->getParent();
// Note the block in which this use occurs.
M.Used.insert(UseBB);
// If the use block doesn't have successors, the value can be
// considered killed.
if (succ_begin(UseBB) == succ_end(UseBB))
M.Killed.insert(UseBB);
// Observe whether the value is used outside of the loop in which
// it is defined. Switch to an enclosing loop if necessary.
for (; L; L = L->getParentLoop())
if (L->contains(UseBB))
break;
// Search for live-through blocks.
const BasicBlock *BB;
if (const PHINode *PHI = dyn_cast<PHINode>(U)) {
// For PHI nodes, start the search at the incoming block paired with the
// incoming value, which must be dominated by the definition.
unsigned Num = PHI->getIncomingValueNumForOperand(I.getOperandNo());
BB = PHI->getIncomingBlock(Num);
// A PHI-node use means the value is live-out of it's defining block
// even if that block also contains the only use.
LiveOutOfDefBB = true;
} else {
// Otherwise just start the search at the use.
BB = UseBB;
// Note if the use is outside the defining block.
LiveOutOfDefBB |= UseBB != DefBB;
}
// Climb the immediate dominator tree from the use to the definition
// and mark all intermediate blocks as live-through.
for (; BB != DefBB; BB = getImmediateDominator(BB, DT)) {
if (BB != UseBB && !M.LiveThrough.insert(BB))
break;
}
}
// If the value is defined inside a loop and is not live outside
// the loop, then each exit block of the loop in which the value
// is used is a kill block.
if (L) {
SmallVector<BasicBlock *, 4> ExitingBlocks;
L->getExitingBlocks(ExitingBlocks);
for (unsigned i = 0, e = ExitingBlocks.size(); i != e; ++i) {
const BasicBlock *ExitingBlock = ExitingBlocks[i];
if (M.Used.count(ExitingBlock))
M.Killed.insert(ExitingBlock);
}
}
// If the value was never used outside the block in which it was
// defined, it's killed in that block.
if (!LiveOutOfDefBB)
M.Killed.insert(DefBB);
return M;
}
bool
SPEscapes(Function &F, const Argument *sp_arg) {
// We monotonically accumulate the set of values that hold a pointer based on Sp
// INVARIANT: an Instruction in the work list never defines a Value that is already in SpPointers
std::set<const Value*> SpPointers;
SpPointers.insert(sp_arg);
// Initialize the worklist to all of the instructions using the Sp
std::set<const Instruction*> WorkList;
for (Value::const_use_iterator UI = sp_arg->use_begin(), UE = sp_arg->use_end(); UI != UE; ++UI)
WorkList.insert(cast<Instruction>(UI->getUser()));
while (!WorkList.empty()) {
// Get an element from the worklist
const Instruction *I = *WorkList.begin();
WorkList.erase(WorkList.begin());
// Switch on the kind of instruction to decide whether this instruction should add to SpPointers
//
// NB: it is safe to say "load" never adds to SpPointers, since we terminate the
// fixed point process immediately if we ever detect that a SpPointer escapes.
//
// NB: The only calls we see in GHC-generated code will be unsafe foreign calls
// or tail calls. In either case we can safely assume no escape.
if (const StoreInst *SI = dyn_cast<StoreInst>(I)) {
// Check for escape:
if (SpPointers.find(SI->getValueOperand()) != SpPointers.end()) {
return true;
}
continue;
#if 0
} else if (AtomicCmpXchgInst *ACXI = dyn_cast<AtomicCmpXchgInst>(I)) {
// Check for escape:
if (SpPointers.find(ACXI->getNewValOperand()) != SpPointers.end()) {
return true;
}
continue;
} else if (AtomicRMWInst *ARMWI = dyn_cast<AtomicRMWInst>(I)) {
// Check for escape:
if (SpPointers.find(ARMWI->getValOperand()) != SpPointers.end()) {
return true;
}
continue;
#endif
} else if (const GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(I)) {
if (SpPointers.find(GEPI->getPointerOperand()) == SpPointers.end()) {
continue;
}
} else if (const SelectInst *SI = dyn_cast<SelectInst>(I)) {
if ((SpPointers.find(SI->getTrueValue()) == SpPointers.end()) &&
(SpPointers.find(SI->getFalseValue()) == SpPointers.end())) {
continue;
}
} else if (isa<PHINode>(I)) {
if (!SomeOperandIsSPPointer(SpPointers, I)) continue;
} else if (isa<BinaryOperator>(I)) {
if (!SomeOperandIsSPPointer(SpPointers, I)) continue;
} else if (isa<CastInst>(I)) {
if (!SomeOperandIsSPPointer(SpPointers, I)) continue;
} else {
// Assume all other instructions do not define new SpPointers or avenues for escape.
continue;
}
// We fall through to here if this instruction defines a new SpPointer:
// add all the use sites to the work list.
SpPointers.insert(I);
for (Value::const_use_iterator UI = I->use_begin(), UE = I->use_end(); UI != UE; ++UI) {
// There is nothing more to do if we have already decided that this defines a SpPointer
if (SpPointers.find(*UI) == SpPointers.end()) {
WorkList.insert(cast<Instruction>(*UI));
}
}
}
return false;
}
