forked from OSchip/llvm-project
169 lines
5.9 KiB
C++
169 lines
5.9 KiB
C++
//===- ObjCARCAliasAnalysis.cpp - ObjC ARC Optimization -------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
/// \file
|
|
/// This file defines a simple ARC-aware AliasAnalysis using special knowledge
|
|
/// of Objective C to enhance other optimization passes which rely on the Alias
|
|
/// Analysis infrastructure.
|
|
///
|
|
/// WARNING: This file knows about certain library functions. It recognizes them
|
|
/// by name, and hardwires knowledge of their semantics.
|
|
///
|
|
/// WARNING: This file knows about how certain Objective-C library functions are
|
|
/// used. Naive LLVM IR transformations which would otherwise be
|
|
/// behavior-preserving may break these assumptions.
|
|
///
|
|
/// TODO: Theoretically we could check for dependencies between objc_* calls
|
|
/// and FMRB_OnlyAccessesArgumentPointees calls or other well-behaved calls.
|
|
///
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/Analysis/ObjCARCAliasAnalysis.h"
|
|
#include "llvm/Analysis/ObjCARCAnalysisUtils.h"
|
|
#include "llvm/Analysis/Passes.h"
|
|
#include "llvm/IR/Function.h"
|
|
#include "llvm/IR/Instruction.h"
|
|
#include "llvm/IR/Value.h"
|
|
#include "llvm/InitializePasses.h"
|
|
#include "llvm/Pass.h"
|
|
|
|
#define DEBUG_TYPE "objc-arc-aa"
|
|
|
|
using namespace llvm;
|
|
using namespace llvm::objcarc;
|
|
|
|
AliasResult ObjCARCAAResult::alias(const MemoryLocation &LocA,
|
|
const MemoryLocation &LocB,
|
|
AAQueryInfo &AAQI) {
|
|
if (!EnableARCOpts)
|
|
return AAResultBase::alias(LocA, LocB, AAQI);
|
|
|
|
// First, strip off no-ops, including ObjC-specific no-ops, and try making a
|
|
// precise alias query.
|
|
const Value *SA = GetRCIdentityRoot(LocA.Ptr);
|
|
const Value *SB = GetRCIdentityRoot(LocB.Ptr);
|
|
AliasResult Result =
|
|
AAResultBase::alias(MemoryLocation(SA, LocA.Size, LocA.AATags),
|
|
MemoryLocation(SB, LocB.Size, LocB.AATags), AAQI);
|
|
if (Result != MayAlias)
|
|
return Result;
|
|
|
|
// If that failed, climb to the underlying object, including climbing through
|
|
// ObjC-specific no-ops, and try making an imprecise alias query.
|
|
const Value *UA = GetUnderlyingObjCPtr(SA);
|
|
const Value *UB = GetUnderlyingObjCPtr(SB);
|
|
if (UA != SA || UB != SB) {
|
|
Result = AAResultBase::alias(
|
|
MemoryLocation(UA, LocationSize::unknown()),
|
|
MemoryLocation(UB, LocationSize::unknown()), AAQI);
|
|
// We can't use MustAlias or PartialAlias results here because
|
|
// GetUnderlyingObjCPtr may return an offsetted pointer value.
|
|
if (Result == NoAlias)
|
|
return NoAlias;
|
|
}
|
|
|
|
// If that failed, fail. We don't need to chain here, since that's covered
|
|
// by the earlier precise query.
|
|
return MayAlias;
|
|
}
|
|
|
|
bool ObjCARCAAResult::pointsToConstantMemory(const MemoryLocation &Loc,
|
|
AAQueryInfo &AAQI, bool OrLocal) {
|
|
if (!EnableARCOpts)
|
|
return AAResultBase::pointsToConstantMemory(Loc, AAQI, OrLocal);
|
|
|
|
// First, strip off no-ops, including ObjC-specific no-ops, and try making
|
|
// a precise alias query.
|
|
const Value *S = GetRCIdentityRoot(Loc.Ptr);
|
|
if (AAResultBase::pointsToConstantMemory(
|
|
MemoryLocation(S, Loc.Size, Loc.AATags), AAQI, OrLocal))
|
|
return true;
|
|
|
|
// If that failed, climb to the underlying object, including climbing through
|
|
// ObjC-specific no-ops, and try making an imprecise alias query.
|
|
const Value *U = GetUnderlyingObjCPtr(S);
|
|
if (U != S)
|
|
return AAResultBase::pointsToConstantMemory(
|
|
MemoryLocation(U, LocationSize::unknown()), AAQI, OrLocal);
|
|
|
|
// If that failed, fail. We don't need to chain here, since that's covered
|
|
// by the earlier precise query.
|
|
return false;
|
|
}
|
|
|
|
FunctionModRefBehavior ObjCARCAAResult::getModRefBehavior(const Function *F) {
|
|
if (!EnableARCOpts)
|
|
return AAResultBase::getModRefBehavior(F);
|
|
|
|
switch (GetFunctionClass(F)) {
|
|
case ARCInstKind::NoopCast:
|
|
return FMRB_DoesNotAccessMemory;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return AAResultBase::getModRefBehavior(F);
|
|
}
|
|
|
|
ModRefInfo ObjCARCAAResult::getModRefInfo(const CallBase *Call,
|
|
const MemoryLocation &Loc,
|
|
AAQueryInfo &AAQI) {
|
|
if (!EnableARCOpts)
|
|
return AAResultBase::getModRefInfo(Call, Loc, AAQI);
|
|
|
|
switch (GetBasicARCInstKind(Call)) {
|
|
case ARCInstKind::Retain:
|
|
case ARCInstKind::RetainRV:
|
|
case ARCInstKind::Autorelease:
|
|
case ARCInstKind::AutoreleaseRV:
|
|
case ARCInstKind::NoopCast:
|
|
case ARCInstKind::AutoreleasepoolPush:
|
|
case ARCInstKind::FusedRetainAutorelease:
|
|
case ARCInstKind::FusedRetainAutoreleaseRV:
|
|
// These functions don't access any memory visible to the compiler.
|
|
// Note that this doesn't include objc_retainBlock, because it updates
|
|
// pointers when it copies block data.
|
|
return ModRefInfo::NoModRef;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return AAResultBase::getModRefInfo(Call, Loc, AAQI);
|
|
}
|
|
|
|
AnalysisKey ObjCARCAA::Key;
|
|
|
|
ObjCARCAAResult ObjCARCAA::run(Function &F, FunctionAnalysisManager &AM) {
|
|
return ObjCARCAAResult(F.getParent()->getDataLayout());
|
|
}
|
|
|
|
char ObjCARCAAWrapperPass::ID = 0;
|
|
INITIALIZE_PASS(ObjCARCAAWrapperPass, "objc-arc-aa",
|
|
"ObjC-ARC-Based Alias Analysis", false, true)
|
|
|
|
ImmutablePass *llvm::createObjCARCAAWrapperPass() {
|
|
return new ObjCARCAAWrapperPass();
|
|
}
|
|
|
|
ObjCARCAAWrapperPass::ObjCARCAAWrapperPass() : ImmutablePass(ID) {
|
|
initializeObjCARCAAWrapperPassPass(*PassRegistry::getPassRegistry());
|
|
}
|
|
|
|
bool ObjCARCAAWrapperPass::doInitialization(Module &M) {
|
|
Result.reset(new ObjCARCAAResult(M.getDataLayout()));
|
|
return false;
|
|
}
|
|
|
|
bool ObjCARCAAWrapperPass::doFinalization(Module &M) {
|
|
Result.reset();
|
|
return false;
|
|
}
|
|
|
|
void ObjCARCAAWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
|
|
AU.setPreservesAll();
|
|
}
|