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,
+  LLVMPLTEntryValueKind,
   LLVMConstantExprValueKind,
   LLVMConstantArrayValueKind,
   LLVMConstantStructValueKind,
@@ -1549,6 +1550,7 @@
         macro(GlobalObject)                 \
           macro(Function)                   \
           macro(GlobalVariable)             \
+      macro(PLTEntry)                       \
       macro(UndefValue)                     \
     macro(Instruction)                      \
       macro(UnaryOperator)                  \
@@ -2154,6 +2156,7 @@
                                   LLVMValueRef ElementValueConstant,
                                   unsigned *IdxList, unsigned NumIdx);
 LLVMValueRef LLVMBlockAddress(LLVMValueRef F, LLVMBasicBlockRef BB);
+LLVMValueRef LLVMPLTEntry(LLVMValueRef F);
 
 /** Deprecated: Use LLVMGetInlineAsm instead. */
 LLVMValueRef LLVMConstInlineAsm(LLVMTypeRef Ty,
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,40 @@
 
 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(BlockAddress, Value)
 
+/// Wrapper for a function which indicates this may be lowered to the procedure
+/// linkage table entry for this function rather than a direct reference.
+class PLTEntry final : public Constant {
+  friend class Constant;
+
+  PLTEntry(Function *F);
+
+  void *operator new(size_t s) { return User::operator new(s, 1); }
+
+  void destroyConstantImpl();
+  Value *handleOperandChangeImpl(Value *From, Value *To);
+
+public:
+  /// Return a PLTEntry for the specified function.
+  static PLTEntry *get(Function *F);
+
+  /// Transparently provide more efficient getOperand methods.
+  DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
+
+  Function *getFunction() const { return cast<Function>(Op<0>().get()); }
+
+  /// Methods for support type inquiry through isa, cast, and dyn_cast:
+  static bool classof(const Value *V) {
+    return V->getValueID() == PLTEntryVal;
+  }
+};
+
+template <>
+struct OperandTraits<PLTEntry> :
+  public FixedNumOperandTraits<PLTEntry, 1> {
+};
+
+DEFINE_TRANSPARENT_OPERAND_ACCESSORS(PLTEntry, 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(PLTEntry)
 
 // ConstantAggregate.
 HANDLE_CONSTANT(ConstantArray)
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,9 @@
     return true;
   }
 
+  if (auto *PLT = dyn_cast<PLTEntry>(C))
+    return IsConstantOffsetFromGlobal(PLT->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(pltentry);
 
   // 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,39 @@
     return false;
   }
 
+  case lltok::kw_pltentry: {
+    // ValID ::= 'pltentry' '(' @foo ')'
+    Lex.Lex();
+
+    ValID Fn;
+
+    if (ParseToken(lltok::lparen, "expected '(' in block address expression") ||
+        ParseValID(Fn) ||
+        ParseToken(lltok::rparen, "expected ')' in block address expression"))
+      return true;
+
+    if (Fn.Kind != ValID::t_GlobalID && Fn.Kind != ValID::t_GlobalName)
+      return Error(Fn.Loc, "expected function name in pltentry");
+
+    // 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 pltentry");
+    Function *F = cast<Function>(GV);
+
+    ID.ConstantVal = PLTEntry::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_pltentry,
 
   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
@@ -2288,6 +2288,9 @@
   if (const BlockAddress *BA = dyn_cast<BlockAddress>(CV))
     return MCSymbolRefExpr::create(GetBlockAddressSymbol(BA), Ctx);
 
+  if (const PLTEntry *PLT = dyn_cast<PLTEntry>(CV))
+    return lowerConstant(PLT->getFunction());
+
   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
@@ -1557,6 +1557,9 @@
     if (const BlockAddress *BA = dyn_cast<BlockAddress>(C))
       return DAG.getBlockAddress(BA, VT);
 
+    if (const PLTEntry *PLT = dyn_cast<PLTEntry>(C))
+      return getValue(PLT->getFunction());
+
     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/IR/AsmWriter.cpp b/llvm/lib/IR/AsmWriter.cpp
--- a/llvm/lib/IR/AsmWriter.cpp
+++ b/llvm/lib/IR/AsmWriter.cpp
@@ -1433,6 +1433,14 @@
     return;
   }
 
+  if (const PLTEntry *PLT = dyn_cast<PLTEntry>(CV)) {
+    Out << "pltentry(";
+    WriteAsOperandInternal(Out, PLT->getFunction(), &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
@@ -501,6 +501,9 @@
   case Constant::BlockAddressVal:
     delete static_cast<BlockAddress *>(C);
     break;
+  case Constant::PLTEntryVal:
+    delete static_cast<PLTEntry *>(C);
+    break;
   case Constant::UndefValueVal:
     delete static_cast<UndefValue *>(C);
     break;
@@ -646,10 +649,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 (auto *LHSPLT = dyn_cast<PLTEntry>(LHS)) {
+            if (RHSGV->isDSOLocal())
+              return false;
+          }
+        }
       }
     }
   }
@@ -1754,6 +1764,52 @@
   return nullptr;
 }
 
+PLTEntry *PLTEntry::get(Function *F) {
+  PLTEntry *&PLT = F->getContext().pImpl->PLTEntries[F];
+  if (!PLT)
+    PLT = new PLTEntry(F);
+
+  assert(PLT->getFunction() == F && "PLT entry does not match the expected function");
+  return PLT;
+}
+
+PLTEntry::PLTEntry(Function *F)
+    : Constant(F->getType(), Value::PLTEntryVal, &Op<0>(), 1) {
+  setOperand(0, F);
+}
+
+/// Remove the constant from the constant table.
+void PLTEntry::destroyConstantImpl() {
+  getContext().pImpl->PLTEntries.erase(getFunction());
+}
+
+Value *PLTEntry::handleOperandChangeImpl(Value *From, Value *To) {
+  assert(From == getFunction() && "Changing value does not match operand.");
+  assert(To->getType() == getType() &&
+         "Swapping function with a different type");
+  assert(isa<Constant>(To) && "Expected the replacement to be a constant");
+
+  // The replacement is with another function.
+  if (const auto *ToFunc = dyn_cast<Function>(To)) {
+    PLTEntry *&NewPLT = getContext().pImpl->PLTEntries[ToFunc];
+    if (NewPLT)
+      return NewPLT;
+  }
+
+  // The replacement could be a bitcast or an alias to another function. We can
+  // replace it with a bitcast to the PLT of that function.
+  auto *Func = cast<Function>(To->stripPointerCastsAndAliases());
+  PLTEntry *&NewPLT = getContext().pImpl->PLTEntries[Func];
+  if (NewPLT)
+    return llvm::ConstantExpr::getBitCast(NewPLT, getType());
+
+  // Replace this with the new one.
+  getContext().pImpl->PLTEntries.erase(getFunction());
+  NewPLT = this;
+  setOperand(0, Func);
+  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
@@ -1333,6 +1333,9 @@
 
   DenseMap<std::pair<const Function *, const BasicBlock *>, BlockAddress *>
     BlockAddresses;
+
+  DenseMap<const Function *, PLTEntry *> PLTEntries;
+
   ConstantUniqueMap<ConstantExpr> ExprConstants;
 
   ConstantUniqueMap<InlineAsm> InlineAsms;
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 ()* pltentry(@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 ()* pltentry(@extern_func) to i64), i64 ptrtoint (i32* @rodata2 to i64)) to i32)