diff --git a/llvm/docs/LangRef.rst b/llvm/docs/LangRef.rst --- a/llvm/docs/LangRef.rst +++ b/llvm/docs/LangRef.rst @@ -3753,6 +3753,41 @@ Finally, some targets may provide defined semantics when using the value as the operand to an inline assembly, but that is target specific. +.. _dso_local_equivalent: + +DSO Local Equivalent +-------------------- + +``dso_local_equivalent @global`` + +A '``dso_local_equivalent``' constant represents a global value which is +functionally equivalent to a given global value, but is always defined in the +current linkage unit. The resulting pointer has the same type as the underlying +global. The resulting pointer is permitted, but not required, to be different +from a pointer to the global, and it may have different values in different +translation units. + +The target global may not have ``extern_weak`` linkage. + +``dso_local_equivalent`` can be implemented in several ways: + +- If the global has private or internal linkage, has hidden visibility, or is + ``dso_local``, ``dso_local_equivalent`` can be implemented as simply a pointer + to the global. +- If the global is a function, ifunc, or alias to a function or ifunc, + ``dso_local_equivalent`` can be implemented with + a stub that tail-calls the function. Many targets support relocations that + resolve at link time to either a function or a stub for it, depending on if + the function is defined within the linkage unit; LLVM will use this when + available. (This is commonly called a "PLT stub".) On other targets, the stub + may need to be emitted explicitly. +- If the global is a variable or alias to a variable, this can be implemented + by copying the contents + of the variable into the current linkage unit (as if by `memcpy`). This is + not supported on all targets, and target-specific restrictions may apply. For + example, on ELF this can be implemented as a copy relocation, which requires + that the global has the same size at load time as it did at at link time. + .. _constantexprs: Constant Expressions diff --git a/llvm/include/llvm-c/Core.h b/llvm/include/llvm-c/Core.h --- a/llvm/include/llvm-c/Core.h +++ b/llvm/include/llvm-c/Core.h @@ -263,6 +263,7 @@ LLVMGlobalIFuncValueKind, LLVMGlobalVariableValueKind, LLVMBlockAddressValueKind, + LLVMDSOLocalEquivalentValueKind, LLVMConstantExprValueKind, LLVMConstantArrayValueKind, LLVMConstantStructValueKind, @@ -1549,6 +1550,7 @@ macro(GlobalObject) \ macro(Function) \ macro(GlobalVariable) \ + macro(DSOLocalEquivalent) \ macro(UndefValue) \ macro(Instruction) \ macro(UnaryOperator) \ @@ -2154,6 +2156,7 @@ LLVMValueRef ElementValueConstant, unsigned *IdxList, unsigned NumIdx); LLVMValueRef LLVMBlockAddress(LLVMValueRef F, LLVMBasicBlockRef BB); +LLVMValueRef LLVMDSOLocalEquivalent(LLVMValueRef F); /** Deprecated: Use LLVMGetInlineAsm instead. */ LLVMValueRef LLVMConstInlineAsm(LLVMTypeRef Ty, diff --git a/llvm/include/llvm/CodeGen/Passes.h b/llvm/include/llvm/CodeGen/Passes.h --- a/llvm/include/llvm/CodeGen/Passes.h +++ b/llvm/include/llvm/CodeGen/Passes.h @@ -416,6 +416,10 @@ /// evaluation. ModulePass *createPreISelIntrinsicLoweringPass(); + /// This pass lowers references to dso_local_equivalent to generic IR + /// implementations on targets that don't have a native lowering of them. + ModulePass *createDSOLocalEquivalentLoweringPass(const TargetMachine *TM); + /// GlobalMerge - This pass merges internal (by default) globals into structs /// to enable reuse of a base pointer by indexed addressing modes. /// It can also be configured to focus on size optimizations only. diff --git a/llvm/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h b/llvm/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h --- a/llvm/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h +++ b/llvm/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h @@ -37,7 +37,7 @@ MCSymbolRefExpr::VK_None; public: - TargetLoweringObjectFileELF() = default; + TargetLoweringObjectFileELF(); ~TargetLoweringObjectFileELF() override = default; void Initialize(MCContext &Ctx, const TargetMachine &TM) override; @@ -94,6 +94,9 @@ const GlobalValue *RHS, const TargetMachine &TM) const override; + const MCExpr *lowerDSOLocalEquivalent(const DSOLocalEquivalent *Equiv, + const TargetMachine &TM) const override; + MCSection *getSectionForCommandLines() const override; }; diff --git a/llvm/include/llvm/IR/Constants.h b/llvm/include/llvm/IR/Constants.h --- a/llvm/include/llvm/IR/Constants.h +++ b/llvm/include/llvm/IR/Constants.h @@ -889,6 +889,47 @@ DEFINE_TRANSPARENT_OPERAND_ACCESSORS(BlockAddress, Value) +/// Wrapper for a global constant variable that represents a value that +/// functionally represents the original variable. This can be a function, or +/// any constant global variable. +class DSOLocalEquivalent final : public Constant { + friend class Constant; + + DSOLocalEquivalent(GlobalValue *GV); + + void *operator new(size_t s) { return User::operator new(s, 1); } + + void destroyConstantImpl(); + Value *handleOperandChangeImpl(Value *From, Value *To); + +public: + /// Return a DSOLocalEquivalent for the specified global value. + static DSOLocalEquivalent *get(GlobalValue *GV); + + /// Transparently provide more efficient getOperand methods. + DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); + + GlobalValue *getGlobalValue() const { + return cast(Op<0>().get()); + } + + bool isCallable() const { + // GlobalValues always are a pointer type. + return cast(getType())->getElementType()->isFunctionTy(); + } + + /// Methods for support type inquiry through isa, cast, and dyn_cast: + static bool classof(const Value *V) { + return V->getValueID() == DSOLocalEquivalentVal; + } +}; + +template <> +struct OperandTraits + : public FixedNumOperandTraits {}; + +DEFINE_TRANSPARENT_OPERAND_ACCESSORS(DSOLocalEquivalent, Value) + //===----------------------------------------------------------------------===// /// A constant value that is initialized with an expression using /// other constant values. diff --git a/llvm/include/llvm/IR/Value.def b/llvm/include/llvm/IR/Value.def --- a/llvm/include/llvm/IR/Value.def +++ b/llvm/include/llvm/IR/Value.def @@ -65,6 +65,7 @@ HANDLE_GLOBAL_VALUE(GlobalVariable) HANDLE_CONSTANT(BlockAddress) HANDLE_CONSTANT(ConstantExpr) +HANDLE_CONSTANT(DSOLocalEquivalent) // ConstantAggregate. HANDLE_CONSTANT(ConstantArray) diff --git a/llvm/include/llvm/Target/TargetLoweringObjectFile.h b/llvm/include/llvm/Target/TargetLoweringObjectFile.h --- a/llvm/include/llvm/Target/TargetLoweringObjectFile.h +++ b/llvm/include/llvm/Target/TargetLoweringObjectFile.h @@ -38,6 +38,7 @@ class SectionKind; class StringRef; class TargetMachine; +class DSOLocalEquivalent; class TargetLoweringObjectFile : public MCObjectFileInfo { /// Name-mangler for global names. @@ -47,6 +48,7 @@ bool SupportIndirectSymViaGOTPCRel = false; bool SupportGOTPCRelWithOffset = true; bool SupportDebugThreadLocalLocation = true; + bool SupportDSOLocalEquivalentLowering = false; /// PersonalityEncoding, LSDAEncoding, TTypeEncoding - Some encoding values /// for EH. @@ -181,6 +183,17 @@ return nullptr; } + /// Target supports a native lowering of a dso_local_equivalent constant + /// without needing to replace it with equivalent IR. + bool supportDSOLocalEquivalentLowering() const { + return SupportDSOLocalEquivalentLowering; + } + + virtual const MCExpr *lowerDSOLocalEquivalent(const DSOLocalEquivalent *Equiv, + const TargetMachine &TM) const { + return nullptr; + } + /// Target supports replacing a data "PC"-relative access to a symbol /// through another symbol, by accessing the later via a GOT entry instead? bool supportIndirectSymViaGOTPCRel() const { diff --git a/llvm/lib/Analysis/ConstantFolding.cpp b/llvm/lib/Analysis/ConstantFolding.cpp --- a/llvm/lib/Analysis/ConstantFolding.cpp +++ b/llvm/lib/Analysis/ConstantFolding.cpp @@ -303,6 +303,12 @@ return true; } + if (auto *Equiv = dyn_cast(C)) { + assert(Equiv->isCallable() && "Lowering of dso_local_equivalent of global " + "variables is not yet supported"); + return IsConstantOffsetFromGlobal(Equiv->getGlobalValue(), GV, Offset, DL); + } + // Otherwise, if this isn't a constant expr, bail out. auto *CE = dyn_cast(C); if (!CE) return false; diff --git a/llvm/lib/AsmParser/LLLexer.cpp b/llvm/lib/AsmParser/LLLexer.cpp --- a/llvm/lib/AsmParser/LLLexer.cpp +++ b/llvm/lib/AsmParser/LLLexer.cpp @@ -722,6 +722,7 @@ KEYWORD(vscale); KEYWORD(x); KEYWORD(blockaddress); + KEYWORD(dso_local_equivalent); // Metadata types. KEYWORD(distinct); diff --git a/llvm/lib/AsmParser/LLParser.cpp b/llvm/lib/AsmParser/LLParser.cpp --- a/llvm/lib/AsmParser/LLParser.cpp +++ b/llvm/lib/AsmParser/LLParser.cpp @@ -3420,6 +3420,37 @@ return false; } + case lltok::kw_dso_local_equivalent: { + // ValID ::= 'dso_local_equivalent' @foo + Lex.Lex(); + + ValID Fn; + + if (ParseValID(Fn)) + return true; + + if (Fn.Kind != ValID::t_GlobalID && Fn.Kind != ValID::t_GlobalName) + return Error(Fn.Loc, "expected function name in dso_local_equivalent"); + + // Try to find the function (but skip it if it's forward-referenced). + GlobalValue *GV = nullptr; + if (Fn.Kind == ValID::t_GlobalID) { + if (Fn.UIntVal < NumberedVals.size()) + GV = NumberedVals[Fn.UIntVal]; + } else if (!ForwardRefVals.count(Fn.StrVal)) { + GV = M->getNamedValue(Fn.StrVal); + } + + assert(GV && "Could not find a corresponding global variable"); + if (!isa(GV)) + return Error(Fn.Loc, "expected function name in dso_local_equivalent"); + Function *F = cast(GV); + + ID.ConstantVal = DSOLocalEquivalent::get(F); + ID.Kind = ValID::t_Constant; + return false; + } + case lltok::kw_trunc: case lltok::kw_zext: case lltok::kw_sext: diff --git a/llvm/lib/AsmParser/LLToken.h b/llvm/lib/AsmParser/LLToken.h --- a/llvm/lib/AsmParser/LLToken.h +++ b/llvm/lib/AsmParser/LLToken.h @@ -358,6 +358,7 @@ kw_extractvalue, kw_insertvalue, kw_blockaddress, + kw_dso_local_equivalent, kw_freeze, diff --git a/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp b/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp --- a/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp +++ b/llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp @@ -2285,6 +2285,10 @@ if (const BlockAddress *BA = dyn_cast(CV)) return MCSymbolRefExpr::create(GetBlockAddressSymbol(BA), Ctx); + if (const auto *Equiv = dyn_cast(CV)) { + return getObjFileLowering().lowerDSOLocalEquivalent(Equiv, TM); + } + const ConstantExpr *CE = dyn_cast(CV); if (!CE) { llvm_unreachable("Unknown constant value to lower!"); diff --git a/llvm/lib/CodeGen/CMakeLists.txt b/llvm/lib/CodeGen/CMakeLists.txt --- a/llvm/lib/CodeGen/CMakeLists.txt +++ b/llvm/lib/CodeGen/CMakeLists.txt @@ -20,6 +20,7 @@ DeadMachineInstructionElim.cpp DetectDeadLanes.cpp DFAPacketizer.cpp + DSOLocalEquivalentLowering.cpp DwarfEHPrepare.cpp EarlyIfConversion.cpp EdgeBundles.cpp diff --git a/llvm/lib/CodeGen/DSOLocalEquivalentLowering.cpp b/llvm/lib/CodeGen/DSOLocalEquivalentLowering.cpp new file mode 100644 --- /dev/null +++ b/llvm/lib/CodeGen/DSOLocalEquivalentLowering.cpp @@ -0,0 +1,133 @@ +//===- DSOLocalEquivalentLowering.cpp - dso_local_equivalent lowering pass ===// +// +// 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 +// +//===----------------------------------------------------------------------===// +// +// If this target cannot lower the dso_local_equivalent pass to an MCExpr, the +// expression is lowered with a generic IR implementation. +// +//===----------------------------------------------------------------------===// + +#include "llvm/ADT/Triple.h" +#include "llvm/CodeGen/Passes.h" +#include "llvm/IR/IRBuilder.h" +#include "llvm/Target/TargetLoweringObjectFile.h" +#include "llvm/Target/TargetMachine.h" + +namespace llvm { + +namespace { + +Function *GetOrCreateRelativeStub(llvm::Function *F) { + llvm::SmallString<16> StubName(F->getName()); + StubName.append(".stub"); + + auto &M = *F->getParent(); + llvm::Function *Stub = M.getFunction(StubName); + if (Stub) { + assert(Stub->isDSOLocal() && + "The previous definition of this Stub should've been dso_local."); + return Stub; + } + + Stub = llvm::Function::Create(F->getFunctionType(), F->getLinkage(), StubName, + M); + + // Propogate function attributes. + Stub->setAttributes(F->getAttributes()); + + Stub->setDSOLocal(true); + Stub->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global); + if (!Stub->hasLocalLinkage()) { + Stub->setVisibility(llvm::GlobalValue::HiddenVisibility); + if (Triple(M.getTargetTriple()).supportsCOMDAT()) + Stub->setComdat(M.getOrInsertComdat(StubName)); + } + + // Fill the Stub with a tail call that will be optimized. + llvm::BasicBlock *block = + llvm::BasicBlock::Create(M.getContext(), "entry", Stub); + llvm::IRBuilder<> block_builder(block); + llvm::SmallVector args; + for (auto &arg : Stub->args()) + args.push_back(&arg); + llvm::CallInst *call = block_builder.CreateCall(F, args); + call->setAttributes(F->getAttributes()); + call->setTailCall(); + if (call->getType()->isVoidTy()) + block_builder.CreateRetVoid(); + else + block_builder.CreateRet(call); + + return Stub; +} + +llvm::Function *LowerDSOLocalEquivalent(DSOLocalEquivalent *Equiv) { + assert(Equiv->isCallable() && "Lowering of dso_local_equivalent of global " + "variables is not yet supported"); + GlobalValue *GV = Equiv->getGlobalValue(); + if (GV->hasLocalLinkage() || GV->hasHiddenVisibility()) + return cast(GV); + + return GetOrCreateRelativeStub(cast(GV)); +} + +bool CheckValue(Value *Val) { + if (auto *Equiv = dyn_cast(Val)) { + Value *NewVal = LowerDSOLocalEquivalent(Equiv); + Equiv->replaceAllUsesWith(NewVal); + return true; + } + return false; +} + +bool CheckFunction(Function &F) { + bool Changed = false; + for (BasicBlock &BB : F) { + for (auto BBI = BB.begin(); BBI != BB.end(); ++BBI) { + for (Instruction &I : BB) { + for (auto ValIt = I.value_op_begin(); ValIt != I.value_op_end(); + ++ValIt) + Changed |= CheckValue(*ValIt); + } + } + } + return Changed; +} + +class DSOLocalEquivalentLoweringLegacyPass : public ModulePass { +public: + static char ID; + const TargetMachine *TM; + + DSOLocalEquivalentLoweringLegacyPass(const TargetMachine *TM) + : ModulePass(ID), TM(TM) { + assert(!TM->getObjFileLowering()->supportDSOLocalEquivalentLowering() && + "This pass should not need to be run on targets that can natively " + "lower dso_local_equivalent"); + } + + bool runOnModule(Module &M) override { + bool Changed = false; + for (GlobalVariable &GV : M.globals()) { + if (GV.hasInitializer()) + Changed |= CheckValue(GV.getInitializer()); + } + for (Function &F : M) + Changed |= CheckFunction(F); + return Changed; + } +}; + +} // namespace + +char DSOLocalEquivalentLoweringLegacyPass::ID; + +ModulePass *createDSOLocalEquivalentLoweringPass(const TargetMachine *TM) { + return new DSOLocalEquivalentLoweringLegacyPass(TM); +} + +} // namespace llvm diff --git a/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp b/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp --- a/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp +++ b/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp @@ -1514,6 +1514,9 @@ if (const BlockAddress *BA = dyn_cast(C)) return DAG.getBlockAddress(BA, VT); + if (const auto *Equiv = dyn_cast(C)) + return getValue(Equiv->getGlobalValue()); + VectorType *VecTy = cast(V->getType()); // Now that we know the number and type of the elements, get that number of diff --git a/llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp b/llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp --- a/llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp +++ b/llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp @@ -104,6 +104,11 @@ // ELF //===----------------------------------------------------------------------===// +TargetLoweringObjectFileELF::TargetLoweringObjectFileELF() + : TargetLoweringObjectFile() { + SupportDSOLocalEquivalentLowering = true; +} + void TargetLoweringObjectFileELF::Initialize(MCContext &Ctx, const TargetMachine &TgtM) { TargetLoweringObjectFile::Initialize(Ctx, TgtM); @@ -929,6 +934,15 @@ MCSymbolRefExpr::create(TM.getSymbol(RHS), getContext()), getContext()); } +const MCExpr *TargetLoweringObjectFileELF::lowerDSOLocalEquivalent( + const DSOLocalEquivalent *Equiv, const TargetMachine &TM) const { + assert(supportDSOLocalEquivalentLowering()); + assert(Equiv->isCallable() && "Lowering of dso_local_equivalent of global " + "variables is not yet supported"); + return MCSymbolRefExpr::create(TM.getSymbol(Equiv->getGlobalValue()), + PLTRelativeVariantKind, getContext()); +} + MCSection *TargetLoweringObjectFileELF::getSectionForCommandLines() const { // Use ".GCC.command.line" since this feature is to support clang's // -frecord-gcc-switches which in turn attempts to mimic GCC's switch of the diff --git a/llvm/lib/CodeGen/TargetPassConfig.cpp b/llvm/lib/CodeGen/TargetPassConfig.cpp --- a/llvm/lib/CodeGen/TargetPassConfig.cpp +++ b/llvm/lib/CodeGen/TargetPassConfig.cpp @@ -41,6 +41,7 @@ #include "llvm/Support/ErrorHandling.h" #include "llvm/Support/SaveAndRestore.h" #include "llvm/Support/Threading.h" +#include "llvm/Target/TargetLoweringObjectFile.h" #include "llvm/Target/TargetMachine.h" #include "llvm/Transforms/Scalar.h" #include "llvm/Transforms/Utils.h" @@ -875,6 +876,8 @@ bool TargetPassConfig::addISelPasses() { if (TM->useEmulatedTLS()) addPass(createLowerEmuTLSPass()); + if (!TM->getObjFileLowering()->supportDSOLocalEquivalentLowering()) + addPass(createDSOLocalEquivalentLoweringPass(TM)); addPass(createPreISelIntrinsicLoweringPass()); PM->add(createTargetTransformInfoWrapperPass(TM->getTargetIRAnalysis())); diff --git a/llvm/lib/IR/AsmWriter.cpp b/llvm/lib/IR/AsmWriter.cpp --- a/llvm/lib/IR/AsmWriter.cpp +++ b/llvm/lib/IR/AsmWriter.cpp @@ -1433,6 +1433,13 @@ return; } + if (const auto *Equiv = dyn_cast(CV)) { + Out << "dso_local_equivalent "; + WriteAsOperandInternal(Out, Equiv->getGlobalValue(), &TypePrinter, Machine, + Context); + return; + } + if (const ConstantArray *CA = dyn_cast(CV)) { Type *ETy = CA->getType()->getElementType(); Out << '['; diff --git a/llvm/lib/IR/Constants.cpp b/llvm/lib/IR/Constants.cpp --- a/llvm/lib/IR/Constants.cpp +++ b/llvm/lib/IR/Constants.cpp @@ -509,6 +509,9 @@ case Constant::BlockAddressVal: delete static_cast(C); break; + case Constant::DSOLocalEquivalentVal: + delete static_cast(C); + break; case Constant::UndefValueVal: delete static_cast(C); break; @@ -654,10 +657,17 @@ return false; // Relative pointers do not need to be dynamically relocated. - if (auto *LHSGV = dyn_cast(LHSOp0->stripPointerCasts())) - if (auto *RHSGV = dyn_cast(RHSOp0->stripPointerCasts())) + if (auto *RHSGV = + dyn_cast(RHSOp0->stripInBoundsConstantOffsets())) { + auto *LHS = LHSOp0->stripInBoundsConstantOffsets(); + if (auto *LHSGV = dyn_cast(LHS)) { if (LHSGV->isDSOLocal() && RHSGV->isDSOLocal()) return false; + } else if (isa(LHS)) { + if (RHSGV->isDSOLocal()) + return false; + } + } } } } @@ -1764,6 +1774,65 @@ return nullptr; } +DSOLocalEquivalent *DSOLocalEquivalent::get(GlobalValue *GV) { + DSOLocalEquivalent *&Equiv = GV->getContext().pImpl->DSOLocalEquivalents[GV]; + if (!Equiv) + Equiv = new DSOLocalEquivalent(GV); + + assert(Equiv->getGlobalValue() == GV && + "DSOLocalFunction does not match the expected global value"); + return Equiv; +} + +DSOLocalEquivalent::DSOLocalEquivalent(GlobalValue *GV) + : Constant(GV->getType(), Value::DSOLocalEquivalentVal, &Op<0>(), 1) { + setOperand(0, GV); +} + +/// Remove the constant from the constant table. +void DSOLocalEquivalent::destroyConstantImpl() { + const GlobalValue *GV = getGlobalValue(); + GV->getContext().pImpl->DSOLocalEquivalents.erase(GV); +} + +Value *DSOLocalEquivalent::handleOperandChangeImpl(Value *From, Value *To) { + assert(From == getGlobalValue() && "Changing value does not match operand."); + assert(To->getType() == getType() && "Mismatched types"); + assert(isa(To) && "Can only replace the operands with a constant"); + + // The replacement is with another global value. + if (const auto *ToObj = dyn_cast(To)) { + DSOLocalEquivalent *&NewEquiv = + getContext().pImpl->DSOLocalEquivalents[ToObj]; + if (NewEquiv) + return NewEquiv; + } + + // The replacement could be a bitcast or an alias to another function. We can + // replace it with a bitcast to the dso_local_equivalent of that function. + if (auto *Func = dyn_cast(To->stripPointerCastsAndAliases())) { + DSOLocalEquivalent *&NewEquiv = + getContext().pImpl->DSOLocalEquivalents[Func]; + if (NewEquiv) + return llvm::ConstantExpr::getBitCast(NewEquiv, getType()); + + // Replace this with the new one. + assert(isCallable() && + "Attempting to replace a global variable with a function"); + getContext().pImpl->DSOLocalEquivalents.erase(getGlobalValue()); + NewEquiv = this; + setOperand(0, Func); + return nullptr; + } + + // TODO: Add the remaining handling for global variables. + auto *GV = dyn_cast(To); + (void)GV; + + llvm_unreachable("Unimplemented handling for global variables."); + return nullptr; +} + //---- ConstantExpr::get() implementations. // diff --git a/llvm/lib/IR/LLVMContextImpl.h b/llvm/lib/IR/LLVMContextImpl.h --- a/llvm/lib/IR/LLVMContextImpl.h +++ b/llvm/lib/IR/LLVMContextImpl.h @@ -1364,6 +1364,9 @@ DenseMap, BlockAddress *> BlockAddresses; + + DenseMap DSOLocalEquivalents; + ConstantUniqueMap ExprConstants; ConstantUniqueMap InlineAsms; diff --git a/llvm/test/CodeGen/X86/dso_local_equivalent.ll b/llvm/test/CodeGen/X86/dso_local_equivalent.ll new file mode 100644 --- /dev/null +++ b/llvm/test/CodeGen/X86/dso_local_equivalent.ll @@ -0,0 +1,16 @@ +; RUN: llc -mtriple=x86_64-linux-gnu -relocation-model=pic -data-sections -o - %s | FileCheck %s -check-prefix=PLT +; RUN: llc -mtriple=x86_64-apple-darwin -relocation-model=pic -data-sections -o - %s | FileCheck %s -check-prefix=NO-PLT +; TODO: Add a test for lowering other constant global variables that aren't functions. + +target triple = "x86_64-unknown-linux-gnu" + +declare void @extern_func() + +; PLT: data: +; PLT-NEXT: .quad extern_func@PLT + +; NO-PLT: _extern_func.stub: +; NO-PLT: jmp _extern_func +; NO-PLT: _data: +; NO-PLT-NEXT: .quad _extern_func.stub +@data = constant void ()* dso_local_equivalent @extern_func diff --git a/llvm/test/CodeGen/X86/relptr-rodata.ll b/llvm/test/CodeGen/X86/relptr-rodata.ll --- a/llvm/test/CodeGen/X86/relptr-rodata.ll +++ b/llvm/test/CodeGen/X86/relptr-rodata.ll @@ -19,3 +19,27 @@ ; CHECK: relro2: ; CHECK: .long hidden-relro2 @relro2 = constant i32 trunc (i64 sub (i64 ptrtoint (i8* @hidden to i64), i64 ptrtoint (i32* @relro2 to i64)) to i32) + +; CHECK: .section .rodata.cst8 +; CHECK-NEXT: .globl obj +; CHECK: obj: +; CHECK: .long 0 +; CHECK: .long (hidden_func-obj)-4 + +declare hidden void @hidden_func() + +; Ensure that inbound GEPs with constant offsets are also resolved. +@obj = dso_local unnamed_addr constant { { i32, i32 } } { + { i32, i32 } { + i32 0, + i32 trunc (i64 sub (i64 ptrtoint (void ()* dso_local_equivalent @hidden_func to i64), i64 ptrtoint (i32* getelementptr inbounds ({ { i32, i32 } }, { { i32, i32 } }* @obj, i32 0, i32 0, i32 1) to i64)) to i32) + } }, align 4 + +; CHECK: .section .rodata.rodata2 +; CHECK-NEXT: .globl rodata2 +; CHECK: rodata2: +; CHECK: .long extern_func@PLT-rodata2 + +declare void @extern_func() unnamed_addr + +@rodata2 = hidden constant i32 trunc (i64 sub (i64 ptrtoint (void ()* dso_local_equivalent @extern_func to i64), i64 ptrtoint (i32* @rodata2 to i64)) to i32)