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,44 @@
 
 DEFINE_TRANSPARENT_OPERAND_ACCESSORS(BlockAddress, Value)
 
+/// Wrapper for a function which indicates this may be lowered to the PLT 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);
+
+  /// Return the underlying function this PLT represents. Note that the type may
+  /// not always be a function. It can be a bitcast from another function or a
+  /// GlobalAlias, but the underlying type after stripping casts and aliases
+  /// will always be a function.
+  Constant *getFunction() const { return cast<Constant>(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/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,18 @@
     return;
   }
 
+  if (const PLTEntry *PLT = dyn_cast<PLTEntry>(CV)) {
+    WriteAsOperandInternal(Out, PLT->getFunction(), &TypePrinter, Machine,
+                           Context);
+    return;
+  }
+
+  if (const PLTEntry *PLT = dyn_cast<PLTEntry>(CV)) {
+    WriteAsOperandInternal(Out, PLT->getFunction(), &TypePrinter, Machine,
+                           Context);
+    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,48 @@
   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() {
+  if (const auto *F = dyn_cast<Function>(getFunction()))
+    getContext().pImpl->PLTEntries.erase(F);
+}
+
+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, an alias from another function, or
+  // null.
+  assert(isa<Function>(To->stripPointerCastsAndAliases()));
+  if (const auto *F = dyn_cast<Function>(getFunction()))
+    getContext().pImpl->PLTEntries.erase(F);
+  setOperand(0, To);
+  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 ()* @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 ()* @extern_func to i64), i64 ptrtoint (i32* @rodata2 to i64)) to i32)