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/TargetLoweringObjectFileImpl.h b/llvm/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h
--- a/llvm/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h
+++ b/llvm/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h
@@ -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,48 @@
 
 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(GlobalObject *GO);
+
+  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 function.
+  static DSOLocalEquivalent *get(Function *F);
+
+  /// Return a DSOLocalEquivalent for the specified global variables. This
+  /// global variable must be constant.
+  static DSOLocalEquivalent *get(GlobalVariable *GV);
+
+  /// Transparently provide more efficient getOperand methods.
+  DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
+
+  bool isFunction() const { return isa<Function>(Op<0>().get()); }
+  Function *getFunction() const { return cast<Function>(Op<0>().get()); }
+  GlobalVariable *getGlobalVariable() const {
+    return cast<GlobalVariable>(Op<0>().get());
+  }
+
+  /// Methods for support type inquiry through isa, cast, and dyn_cast:
+  static bool classof(const Value *V) {
+    return V->getValueID() == DSOLocalEquivalentVal;
+  }
+};
+
+template <>
+struct OperandTraits<DSOLocalEquivalent>
+    : public FixedNumOperandTraits<DSOLocalEquivalent, 1> {};
+
+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.
@@ -181,6 +182,11 @@
     return nullptr;
   }
 
+  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<DSOLocalEquivalent>(C)) {
+    assert(Equiv->isFunction() && "Lowering of dso_local_equivalent of global "
+                                  "variables is not yet supported");
+    return IsConstantOffsetFromGlobal(Equiv->getFunction(), GV, Offset, DL);
+  }
+
   // Otherwise, if this isn't a constant expr, bail out.
   auto *CE = dyn_cast<ConstantExpr>(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,41 @@
     return false;
   }
 
+  case lltok::kw_dso_local_equivalent: {
+    // ValID ::= 'dso_local_equivalent' '(' @foo ')'
+    Lex.Lex();
+
+    ValID Fn;
+
+    if (ParseToken(lltok::lparen,
+                   "expected '(' in dso_local_equivalent expression") ||
+        ParseValID(Fn) ||
+        ParseToken(lltok::rparen,
+                   "expected ')' in dso_local_equivalent expression"))
+      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<Function>(GV))
+      return Error(Fn.Loc, "expected function name in dso_local_equivalent");
+    Function *F = cast<Function>(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,9 @@
   if (const BlockAddress *BA = dyn_cast<BlockAddress>(CV))
     return MCSymbolRefExpr::create(GetBlockAddressSymbol(BA), Ctx);
 
+  if (const auto *Equiv = dyn_cast<DSOLocalEquivalent>(CV))
+    return getObjFileLowering().lowerDSOLocalEquivalent(Equiv, TM);
+
   const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV);
   if (!CE) {
     llvm_unreachable("Unknown constant value to lower!");
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,12 @@
     if (const BlockAddress *BA = dyn_cast<BlockAddress>(C))
       return DAG.getBlockAddress(BA, VT);
 
+    if (const auto *Equiv = dyn_cast<DSOLocalEquivalent>(C)) {
+      if (Equiv->isFunction())
+        return getValue(Equiv->getFunction());
+      return getValue(Equiv->getGlobalVariable());
+    }
+
     VectorType *VecTy = cast<VectorType>(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
@@ -929,6 +929,14 @@
       MCSymbolRefExpr::create(TM.getSymbol(RHS), getContext()), getContext());
 }
 
+const MCExpr *TargetLoweringObjectFileELF::lowerDSOLocalEquivalent(
+    const DSOLocalEquivalent *Equiv, const TargetMachine &TM) const {
+  assert(Equiv->isFunction() && "Lowering of dso_local_equivalent of global "
+                                "variables is not yet supported");
+  return MCSymbolRefExpr::create(TM.getSymbol(Equiv->getFunction()),
+                                 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/IR/AsmWriter.cpp b/llvm/lib/IR/AsmWriter.cpp
--- a/llvm/lib/IR/AsmWriter.cpp
+++ b/llvm/lib/IR/AsmWriter.cpp
@@ -1433,6 +1433,18 @@
     return;
   }
 
+  if (const auto *Equiv = dyn_cast<DSOLocalEquivalent>(CV)) {
+    Out << "dso_local_equivalent(";
+    if (Equiv->isFunction())
+      WriteAsOperandInternal(Out, Equiv->getFunction(), &TypePrinter, Machine,
+                             Context);
+    else
+      WriteAsOperandInternal(Out, Equiv->getGlobalVariable(), &TypePrinter,
+                             Machine, Context);
+    Out << ")";
+    return;
+  }
+
   if (const ConstantArray *CA = dyn_cast<ConstantArray>(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<BlockAddress *>(C);
     break;
+  case Constant::DSOLocalEquivalentVal:
+    delete static_cast<DSOLocalEquivalent *>(C);
+    break;
   case Constant::UndefValueVal:
     delete static_cast<UndefValue *>(C);
     break;
@@ -654,10 +657,17 @@
           return false;
 
         // Relative pointers do not need to be dynamically relocated.
-        if (auto *LHSGV = dyn_cast<GlobalValue>(LHSOp0->stripPointerCasts()))
-          if (auto *RHSGV = dyn_cast<GlobalValue>(RHSOp0->stripPointerCasts()))
+        if (auto *RHSGV =
+                dyn_cast<GlobalValue>(RHSOp0->stripInBoundsConstantOffsets())) {
+          auto *LHS = LHSOp0->stripInBoundsConstantOffsets();
+          if (auto *LHSGV = dyn_cast<GlobalValue>(LHS)) {
             if (LHSGV->isDSOLocal() && RHSGV->isDSOLocal())
               return false;
+          } else if (isa<DSOLocalEquivalent>(LHS)) {
+            if (RHSGV->isDSOLocal())
+              return false;
+          }
+        }
       }
     }
   }
@@ -1764,6 +1774,79 @@
   return nullptr;
 }
 
+DSOLocalEquivalent *DSOLocalEquivalent::get(Function *F) {
+  DSOLocalEquivalent *&EquivF = F->getContext().pImpl->DSOLocalEquivalents[F];
+  if (!EquivF)
+    EquivF = new DSOLocalEquivalent(F);
+
+  assert(EquivF->getFunction() == F &&
+         "DSOLocalFunction does not match the expected function");
+  return EquivF;
+}
+
+DSOLocalEquivalent *DSOLocalEquivalent::get(GlobalVariable *GV) {
+  assert(GV->isConstant() &&
+         "The global variable passed to DSOLocalEquivalent must be constant");
+  DSOLocalEquivalent *&EquivGV =
+      GV->getContext().pImpl->DSOLocalEquivalents[GV];
+  if (!EquivGV)
+    EquivGV = new DSOLocalEquivalent(GV);
+
+  assert(EquivGV->getGlobalVariable() == F &&
+         "DSOLocalFunction does not match the expected global variable");
+  return EquivGV;
+}
+
+DSOLocalEquivalent::DSOLocalEquivalent(GlobalObject *GO)
+    : Constant(GO->getType(), Value::DSOLocalEquivalentVal, &Op<0>(), 1) {
+  setOperand(0, GO);
+}
+
+/// Remove the constant from the constant table.
+void DSOLocalEquivalent::destroyConstantImpl() {
+  if (const auto *F = dyn_cast<Function>(getFunction()))
+    F->getContext().pImpl->DSOLocalEquivalents.erase(F);
+  else if (const auto *GV = dyn_cast<GlobalVariable>(getGlobalVariable()))
+    GV->getContext().pImpl->DSOLocalEquivalents.erase(GV);
+}
+
+Value *DSOLocalEquivalent::handleOperandChangeImpl(Value *From, Value *To) {
+  assert((From == getFunction() || From == getGlobalVariable()) &&
+         "Changing value does not match operand.");
+  assert(To->getType() == getType() && "Mismatched types");
+  assert(isa<Constant>(To) && "Can only replace the operands with a constant");
+
+  // The replacement is with another function or constant global variable.
+  if (const auto *ToObj = dyn_cast<GlobalObject>(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<Function>(To->stripPointerCastsAndAliases())) {
+    DSOLocalEquivalent *&NewEquiv =
+        getContext().pImpl->DSOLocalEquivalents[Func];
+    if (NewEquiv)
+      return llvm::ConstantExpr::getBitCast(NewEquiv, getType());
+
+    // Replace this with the new one.
+    getContext().pImpl->DSOLocalEquivalents.erase(getFunction());
+    NewEquiv = this;
+    setOperand(0, Func);
+    return nullptr;
+  }
+
+  // TODO: Add the remaining handling for global variables.
+  auto *GV = dyn_cast<GlobalVariable>(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<std::pair<const Function *, const BasicBlock *>, BlockAddress *>
     BlockAddresses;
+
+  DenseMap<const GlobalObject *, DSOLocalEquivalent *> DSOLocalEquivalents;
+
   ConstantUniqueMap<ConstantExpr> ExprConstants;
 
   ConstantUniqueMap<InlineAsm> 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,12 @@
+; RUN: llc -relocation-model=pic -data-sections -o - %s | FileCheck %s
+; 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()
+
+; CHECK:      data:
+; CHECK-NEXT:   .quad   extern_func@PLT
+@data = constant { void ()* } {
+  void ()* dso_local_equivalent(@extern_func)
+}, align 4
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)