// or we are in LTO.
bool canBeOmittedFromSymbolTable(const GlobalValue *GV);
-bool shouldAssumeDSOLocal(Reloc::Model RM, const Triple &TT, const Module &M,
- const GlobalValue *GV);
-
DenseMap<const MachineBasicBlock *, int>
getFuncletMembership(const MachineFunction &MF);
bool isPositionIndependent() const;
+ bool shouldAssumeDSOLocal(const Module &M, const GlobalValue *GV) const;
+
/// Returns the TLS model which should be used for the given global variable.
TLSModel::Model getTLSModel(const GlobalValue *GV) const;
return GV->hasAtLeastLocalUnnamedAddr();
}
-// FIXME: make this a proper option
-static bool CanUseCopyRelocWithPIE = false;
-
-bool llvm::shouldAssumeDSOLocal(Reloc::Model RM, const Triple &TT,
- const Module &M, const GlobalValue *GV) {
- // DLLImport explicitly marks the GV as external.
- if (GV && GV->hasDLLImportStorageClass())
- return false;
-
- // Every other GV is local on COFF
- if (TT.isOSBinFormatCOFF())
- return true;
-
- if (GV && (GV->hasLocalLinkage() || !GV->hasDefaultVisibility()))
- return true;
-
- if (TT.isOSBinFormatMachO()) {
- if (RM == Reloc::Static)
- return true;
- return GV && GV->isStrongDefinitionForLinker();
- }
-
- assert(TT.isOSBinFormatELF());
- assert(RM != Reloc::DynamicNoPIC);
-
- bool IsExecutable =
- RM == Reloc::Static || M.getPIELevel() != PIELevel::Default;
- if (IsExecutable) {
- // If the symbol is defined, it cannot be preempted.
- if (GV && !GV->isDeclarationForLinker())
- return true;
-
- bool IsTLS = GV && GV->isThreadLocal();
- // Check if we can use copy relocations.
- if (!IsTLS && (RM == Reloc::Static || CanUseCopyRelocWithPIE))
- return true;
- }
-
- // ELF supports preemption of other symbols.
- return false;
-}
-
static void collectFuncletMembers(
DenseMap<const MachineBasicBlock *, int> &FuncletMembership, int Funclet,
const MachineBasicBlock *MBB) {
bool
TargetLowering::isOffsetFoldingLegal(const GlobalAddressSDNode *GA) const {
const TargetMachine &TM = getTargetMachine();
- Reloc::Model RM = TM.getRelocationModel();
const GlobalValue *GV = GA->getGlobal();
- const Triple &TargetTriple = TM.getTargetTriple();
// If the address is not even local to this DSO we will have to load it from
// a got and then add the offset.
- if (!shouldAssumeDSOLocal(RM, TargetTriple, *GV->getParent(), GV))
+ if (!TM.shouldAssumeDSOLocal(*GV->getParent(), GV))
return false;
// If the code is position independent we will have to add a base register.
if (TM.getCodeModel() == CodeModel::Large && isTargetMachO())
return AArch64II::MO_GOT;
- Reloc::Model RM = TM.getRelocationModel();
- if (!shouldAssumeDSOLocal(RM, TargetTriple, *GV->getParent(), GV))
+ if (!TM.shouldAssumeDSOLocal(*GV->getParent(), GV))
return AArch64II::MO_GOT;
// The small code mode's direct accesses use ADRP, which cannot necessarily
unsigned ARMFastISel::ARMLowerPICELF(const GlobalValue *GV,
unsigned Align, MVT VT) {
- Reloc::Model RM = TM.getRelocationModel();
- const Triple &TargetTriple = TM.getTargetTriple();
- bool UseGOT_PREL =
- !shouldAssumeDSOLocal(RM, TargetTriple, *GV->getParent(), GV);
+ bool UseGOT_PREL = !TM.shouldAssumeDSOLocal(*GV->getParent(), GV);
LLVMContext *Context = &MF->getFunction()->getContext();
unsigned ARMPCLabelIndex = AFI->createPICLabelUId();
bool isDirect = false;
const TargetMachine &TM = getTargetMachine();
- Reloc::Model RM = TM.getRelocationModel();
- const Triple &TargetTriple = TM.getTargetTriple();
const Module *Mod = MF.getFunction()->getParent();
const GlobalValue *GV = nullptr;
if (GlobalAddressSDNode *G = dyn_cast<GlobalAddressSDNode>(Callee))
GV = G->getGlobal();
bool isStub =
- !shouldAssumeDSOLocal(RM, TargetTriple, *Mod, GV) &&
- Subtarget->isTargetMachO();
+ !TM.shouldAssumeDSOLocal(*Mod, GV) && Subtarget->isTargetMachO();
bool isARMFunc = !Subtarget->isThumb() || (isStub && !Subtarget->isMClass());
bool isLocalARMFunc = false;
SDLoc dl(Op);
const GlobalValue *GV = cast<GlobalAddressSDNode>(Op)->getGlobal();
const TargetMachine &TM = getTargetMachine();
- Reloc::Model RM = TM.getRelocationModel();
- const Triple &TargetTriple = TM.getTargetTriple();
if (isPositionIndependent()) {
- bool UseGOT_PREL =
- !shouldAssumeDSOLocal(RM, TargetTriple, *GV->getParent(), GV);
+ bool UseGOT_PREL = !TM.shouldAssumeDSOLocal(*GV->getParent(), GV);
MachineFunction &MF = DAG.getMachineFunction();
ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
bool
ARMSubtarget::GVIsIndirectSymbol(const GlobalValue *GV,
Reloc::Model RelocM) const {
- if (!shouldAssumeDSOLocal(RelocM, TargetTriple, *GV->getParent(), GV))
+ if (!TM.shouldAssumeDSOLocal(*GV->getParent(), GV))
return true;
// 32 bit macho has no relocation for a-b if a is undefined, even if b is in
return DAG.getNode(HexagonISD::CONST32, dl, PtrVT, GA);
}
- const Triple &TargetTriple = HTM.getTargetTriple();
- bool UsePCRel = shouldAssumeDSOLocal(RM, TargetTriple, *GV->getParent(), GV);
+ bool UsePCRel = getTargetMachine().shouldAssumeDSOLocal(*GV->getParent(), GV);
if (UsePCRel) {
SDValue GA = DAG.getTargetGlobalAddress(GV, dl, PtrVT, Offset,
HexagonII::MO_PCREL);
// PC-relative references to external symbols should go through $stub, unless
// we're building with the leopard linker or later, which automatically
// synthesizes these stubs.
- Reloc::Model RM = DAG.getTarget().getRelocationModel();
+ const TargetMachine &TM = DAG.getTarget();
const Triple &TargetTriple = Subtarget.getTargetTriple();
bool OldMachOLinker =
TargetTriple.isMacOSX() && TargetTriple.isMacOSXVersionLT(10, 5);
const GlobalValue *GV = nullptr;
if (auto *G = dyn_cast<GlobalAddressSDNode>(Callee))
GV = G->getGlobal();
- bool Local = shouldAssumeDSOLocal(RM, TargetTriple, *Mod, GV);
+ bool Local = TM.shouldAssumeDSOLocal(*Mod, GV);
bool UsePlt =
!Local && (OldMachOLinker || (Subtarget.isTargetELF() && !isPPC64));
bool PPCSubtarget::hasLazyResolverStub(const GlobalValue *GV) const {
if (!HasLazyResolverStubs)
return false;
- if (!shouldAssumeDSOLocal(TM.getRelocationModel(), TM.getTargetTriple(),
- *GV->getParent(), GV))
+ if (!TM.shouldAssumeDSOLocal(*GV->getParent(), GV))
return true;
// 32 bit macho has no relocation for a-b if a is undefined, even if b is in
// the section that is being relocated. This means we have to use o load even
const GlobalValue *GV = Node->getGlobal();
int64_t Offset = Node->getOffset();
EVT PtrVT = getPointerTy(DAG.getDataLayout());
- Reloc::Model RM = DAG.getTarget().getRelocationModel();
CodeModel::Model CM = DAG.getTarget().getCodeModel();
SDValue Result;
- if (Subtarget.isPC32DBLSymbol(GV, RM, CM)) {
+ if (Subtarget.isPC32DBLSymbol(GV, CM)) {
// Assign anchors at 1<<12 byte boundaries.
uint64_t Anchor = Offset & ~uint64_t(0xfff);
Result = DAG.getTargetGlobalAddress(GV, DL, PtrVT, Anchor);
TSInfo(), FrameLowering() {}
bool SystemZSubtarget::isPC32DBLSymbol(const GlobalValue *GV,
- Reloc::Model RM,
CodeModel::Model CM) const {
// PC32DBL accesses require the low bit to be clear. Note that a zero
// value selects the default alignment and is therefore OK.
// For the small model, all locally-binding symbols are in range.
if (CM == CodeModel::Small)
- return shouldAssumeDSOLocal(RM, TargetTriple, *GV->getParent(), GV);
+ return TLInfo.getTargetMachine().shouldAssumeDSOLocal(*GV->getParent(), GV);
// For Medium and above, assume that the symbol is not within the 4GB range.
// Taking the address of locally-defined text would be OK, but that
// Return true if GV can be accessed using LARL for reloc model RM
// and code model CM.
- bool isPC32DBLSymbol(const GlobalValue *GV, Reloc::Model RM,
- CodeModel::Model CM) const;
+ bool isPC32DBLSymbol(const GlobalValue *GV, CodeModel::Model CM) const;
bool isTargetELF() const { return TargetTriple.isOSBinFormatELF(); }
};
llvm_unreachable("invalid TLS model");
}
+// FIXME: make this a proper option
+static bool CanUseCopyRelocWithPIE = false;
+
+bool TargetMachine::shouldAssumeDSOLocal(const Module &M,
+ const GlobalValue *GV) const {
+ Reloc::Model RM = getRelocationModel();
+ const Triple &TT = getTargetTriple();
+
+ // DLLImport explicitly marks the GV as external.
+ if (GV && GV->hasDLLImportStorageClass())
+ return false;
+
+ // Every other GV is local on COFF
+ if (TT.isOSBinFormatCOFF())
+ return true;
+
+ if (GV && (GV->hasLocalLinkage() || !GV->hasDefaultVisibility()))
+ return true;
+
+ if (TT.isOSBinFormatMachO()) {
+ if (RM == Reloc::Static)
+ return true;
+ return GV && GV->isStrongDefinitionForLinker();
+ }
+
+ assert(TT.isOSBinFormatELF());
+ assert(RM != Reloc::DynamicNoPIC);
+
+ bool IsExecutable =
+ RM == Reloc::Static || M.getPIELevel() != PIELevel::Default;
+ if (IsExecutable) {
+ // If the symbol is defined, it cannot be preempted.
+ if (GV && !GV->isDeclarationForLinker())
+ return true;
+
+ bool IsTLS = GV && GV->isThreadLocal();
+ // Check if we can use copy relocations.
+ if (!IsTLS && (RM == Reloc::Static || CanUseCopyRelocWithPIE))
+ return true;
+ }
+
+ // ELF supports preemption of other symbols.
+ return false;
+}
+
TLSModel::Model TargetMachine::getTLSModel(const GlobalValue *GV) const {
bool IsPIE = GV->getParent()->getPIELevel() != PIELevel::Default;
Reloc::Model RM = getRelocationModel();
bool IsSharedLibrary = RM == Reloc::PIC_ && !IsPIE;
- bool IsLocal = shouldAssumeDSOLocal(RM, TargetTriple, *GV->getParent(), GV);
+ bool IsLocal = shouldAssumeDSOLocal(*GV->getParent(), GV);
TLSModel::Model Model;
if (IsSharedLibrary) {
if (TM.getCodeModel() == CodeModel::Large)
return X86II::MO_NO_FLAG;
- Reloc::Model RM = TM.getRelocationModel();
- if (shouldAssumeDSOLocal(RM, TargetTriple, M, GV))
+ if (TM.shouldAssumeDSOLocal(M, GV))
return classifyLocalReference(GV);
if (isTargetCOFF())
unsigned char
X86Subtarget::classifyGlobalFunctionReference(const GlobalValue *GV,
const Module &M) const {
- if (shouldAssumeDSOLocal(TM.getRelocationModel(), TargetTriple, M, GV))
+ if (TM.shouldAssumeDSOLocal(M, GV))
return X86II::MO_NO_FLAG;
assert(!isTargetCOFF());