[RFC][PATCH] Minor opt to access pointers to globals via pcrel GOT entries

[bruno]

Summary

Global variables marked with "unnamed_addr" have the following property: "...unnamed_addr indicates that the address is not significant, only the content".

One potential use of "unnamed_addr" by front-ends is to emit "unnamed_addr constant" globals holding pointer initialisers to other global variables. For instance, this can be used if the front-end wishes to compute and store information against a location with a symbol pointer but doesn't care about its address. A more concrete example follows:

@foo = global i32 42
@proxy = unnamed_addr constant i32* @foo

@delta = global i32 trunc (i64 sub (i64 ptrtoint (i32** @proxy to i64),

         i64 ptrtoint (i32* @delta to i64))
to i32)

Here, @delta holds a data "PC"-relative offset to a pointer of @foo. The darwin/x86-64 assembly output for this follows:

.globl _foo
_foo:
.long 42

.globl _proxy
_proxy:
.quad _foo

.globl _delta
_delta:
.long _proxy-_delta

I propose a minor optimisation for such cases: given target specific support, replace pc-relative accesses to such unnamed_addr global constants by a PC relative access to the GOT entry of the final symbol instead. Therefore, "delta" would contain a pc relative relocation to foo's GOT entry and we avoid the emission of "proxy", yielding the assembly code below:

.globl _foo
_foo:
.long 42

.globl _delta
_delta:
.long _foo@GOTPCREL+4

There are a couple of advantages of doing this:

• In situations where all that’s required is that there be some way to get the address of an external symbol we save space by not emitting "proxy" globals. Front-ends that need to emit a great deal of data containing pointers could benefit from this.
• As a side effect, such IR constructs combined with the proposed opt opens a way to represent GOT pcrel relocations by solely using the LLVM IR, which is something we currently have no way to express.

Also, this is not MachO specific and can also benefit ELF targets. I've attached a patch implementing this simple feature for x86-64/darwin but mostly changes are target independent.

Thanks,

-Bruno

[bruno]

Ping :-)

[• rafael]

Looking at this now. Sorry for the delay.

[• rafael]

• test.s720 BDownload
• test2.s598 BDownload
• test.ll523 BDownload
• main.c107 BDownload

[• rafael]

This seems to be implemented a bit lower than I was expecting.

The idea is that is is an codegen optimization, right? When given a .s, we should just produce a .o that matches it.

If that is the case, why is this ever looking at symbols and MCExpr? It should be happening at a higher lever (GlobalValues and ConstantExpr).

include/llvm/CodeGen/AsmPrinter.h

105

Proxy seems like a new term.

I would probably go with *GOT*. GOTEquivalent maybe?

260

Start functions with a lowercase.

include/llvm/Target/TargetLoweringObjectFile.h

156

Instead of having a method that always return a fixed bool, make this an actual boolean and set it in the constructor.

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

341

Why do you need to call support* in here? The could will be 0 if it is not supported, no?

893

Why do you need to special case not having any users?

901

You don't need a cast from ConstatExpr to Constant.

905

C can be null in here, no?

912

Don't repeat name in comments.

919

s/Get/compute/ maybe? Get sounds like the function returns them.

929

Why not fold these checks into isGlobalProxyCandidate?

test/MC/X86/cstexpr-gotpcrel.ll

1

Please don't use "llc -filetype=obj". To test the object emission, use llvm-mc.

[bruno]

Hi Rafael, updated the patch after your comments.

As talked on IRC, by dealing directly with MCExpr we gain all folding benefits that lowerConstant computes while getting rid of several layers and indirections of cstexprs contaning lots of getelementptrs, pointers and casts. Also, this patch generates equivalent .s or .o outputs, there's no need to implement this coming from a .s (one can always change the assembly source to use GOTPCREL instead).

Thanks,

[• rafael]

include/llvm/CodeGen/AsmPrinter.h

259

the very minor bit is not particularity relevant.

include/llvm/Target/TargetLoweringObjectFile.h

160

not virtual.

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

908

getNumOperands is redundant with hasInitializer.

This is missing a call to isConstant.

911

Why does FinalGV has to be a GlobalVariable? We can have a got-equivalent of a function.

915

This cast cannot fail. GlobalValue *is* a Constant.

2070

You should just use EvaluateAsRelocatable. It will put the expression in the form Sym_A - Sym_B + C for you.

2121

Why do you need the count?

You only really need to remember that there was at least one user that could not be replaced with the got and therefore the GOT-like GlobalVariable still has to be printed.

[bruno]

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

2070

---

Cool, this makes it a *lot* easier, thanks!

2121

If I do like you suggest, we'd have to still check all MCExpr and its operands for any presence of a global equivalent symbol, even when we know really early that the MCExpr isn't a fit. The case where EvaluateAsRelocatable returns true should be easier to check, but otherwise we'll still need to parse MCExpr once again searching for a GV reference. I believe the current solution is a better approach.

[bruno]

Update patch after Rafael's comments!

[• rafael]

include/llvm/Target/TargetLoweringObjectFile.h

162

Indentation looks funny. Please clang-format before commit.

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

340

Say that emitGlobalGOTEquivs will emit them if needed.

905

All global Variables have pointer type.

906

s/dyn_cast/isa/

919

not sure there is a point is saying it is "(very) minor" :-)

924

High level question: Do we need to do the early pass over all variables?

Couldn't emitGlobalConstantImpl do the check and add "got equivalent candidates"?

2076

I am not sure I understand why the MV.getConstant() != BaseSymOff restriction is necessary.

If we have

.globl _proxy
_proxy:
.quad _foo

.globl _delta
_delta:

.long _proxy-_delta + 42

It can be converted to

.globl _delta
_delta:

.long _foo@GOTPCREL + 42

no? It works on ELF at least.

test/MC/X86/cstexpr-gotpcrel.ll

2

It would be nice to add code coverage on the cases where the optimization fails (use in instructions for example).

[• rafael]

Hi bruno,

This is the complete example for what I mentioned about different
constants in phab.

• test.s728 BDownload
• test2.s604 BDownload
• main.c107 BDownload

[• rafael]

ah, and the patch needs a rebase on current trunk.

[• rafael]

trying to send the previous comments.

[bruno]

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

340

---

OK

905

---

OK

906

---

OK

919

---

Ops, forgot to fix this one :-)

924

---

The problem of not doing an early pass is because we can't rely on the global declaration order - if we hit the 'got equivalent user' before keeping track of the 'global equivalent', we have to find the global variable for 'global equivalent' after its MCSymbol, because at that point we already lost the GlobalVariable reference. One could argue that we can find this GlobalVariable again by scanning the original cstexpr where we got the MCExpr from, but this also would require complex logic to handle all different types of cstexpr that could lead to a relocatable expression. Gonna add a comment about that.

2076

Note that the reason why BaseSymOff exists is to ensure that "." is properly matched, i.e., we need to know that the symbol we are subtracting from is indeed the "PC" location. Take your example:

delta:
  .long (.Lproxy-delta)+42
  .size delta, 4

Here, "." == "delta" and BaseSymOff == 0, since we're emitting the first and only element of delta. Now, if we're emitting the GOTPCREL into, let's say, the second element of an array where each element has 4 bytes, we need "." == "delta+4" and BaseSymOff == 4, since we want to be sure we're dealing with a pc relative location:

delta:
  .long 33
  .long (.Lproxy-(delta+4))+42 ==> .long (.Lproxy-delta)+38
  .size delta, 8

That said, the restriction isn't necessary as long as we have BaseSymOff contained into the final offset value. I didn't think of that use before although it's valid and looks like it could be (?) used by front-end writers to do all sort of black magic.

It's a small change, gonna include that in the patch and write a test for it using a cstexpr that also adds one more constant.

test/MC/X86/cstexpr-gotpcrel.ll

2

---

Ok

[• rafael]

The problem of not doing an early pass is because we can't rely on the global declaration order - if we hit the 'got equivalent user' before keeping track of the 'global equivalent', we have to find the global variable for 'global equivalent' after its MCSymbol, because at that point we already lost the GlobalVariable reference. One could argue that we can find this GlobalVariable again by scanning the original cstexpr where we got the MCExpr from, but this also would require complex logic to handle all different types of cstexpr that could lead to a relocatable expression. Gonna add a comment about that.

I see. Given just the symbol it is not trivial to find about
unnamed_addr for example.

Comment at: lib/CodeGen/AsmPrinter/AsmPrinter.cpp:2081
@@ +2080,3 @@
+ int64_t BaseSymOff = -Offset;
+ if (BaseSym != &MV.getSymB()->getSymbol() || MV.getConstant() != BaseSymOff)

+ return;

rafael wrote:

I am not sure I understand why the MV.getConstant() != BaseSymOff restriction is necessary.

If we have

.globl _proxy
_proxy:
.quad _foo

.globl _delta
_delta:

.long _proxy-_delta + 42

It can be converted to

.globl _delta
_delta:

.long _foo@GOTPCREL + 42

no? It works on ELF at least.

Note that the reason why BaseSymOff exists is to ensure that "." is properly matched, i.e., we need to know that the symbol we are subtracting from is indeed the "PC" location. Take your example:

delta:
  .long (.Lproxy-delta)+42
  .size delta, 4

Here, "." == "delta" and BaseSymOff == 0, since we're emitting the first and only element of delta. Now, if we're emitting the GOTPCREL into, let's say, the second element of an array where each element has 4 bytes, we need "." == "delta+4" and BaseSymOff == 4, since we want to be sure we're dealing with a pc relative location:

delta:
  .long 33
  .long (.Lproxy-(delta+4))+42 ==> .long (.Lproxy-delta)+38
  .size delta, 8

That said, the restriction isn't necessary as long as we have BaseSymOff contained into the final offset value. I didn't think of that use before although it's valid and looks like it could be (?) used by front-end writers to do all sort of black magic.

It's a small change, gonna include that in the patch and write a test for it using a cstexpr that also adds one more constant.

Awesome. It is a case where doing the more general solution is
probably simpler (or at least easier to understand).

Thanks,
Rafael

[bruno]

Updated the patch to reflect the previous discussion and other comments from Rafael. Somes notes:

• A 'Base Constant' was added together with the 'Offset' in emitGlobalConstantImpl in order to keep track of the base symbol for the current emission, example: the Global Variable user on the top of multiple nested constant expressions is the 'Base Constant' for any nested sub-element that is being currently emitted. In the previous patches I used to walk users to find the 'Base Constant', this is wrong since it doesn't consider fact that constant expressions are uniqued, meaning that looking into cstexpr users may lead to different GlobalVariables, yielding the wrong result.
• Add a more robust test.
• Handle general constants to be used with the GOTPCREL relocation while opening the possibility for more complex IR cstexpr to be folded into a GOTPCREL+cst. See the test for concrete examples.

[• rafael]

Just test nits.

test/MC/X86/cstexpr-gotpcrel.ll

11

Please move these comments close to each test.

19

How about redirecting llc to %t and doing tow FileCheck runs? That way you can check in one place that they are never output.

[bruno]

Updated with your last comments and committed in r230264.

Thanks Rafael,

include/llvm/CodeGen/AsmPrinter.h

public:
   ///
   MCSymbol *CurrentFnSym;
 
   /// The symbol used to represent the start of the current function for the
   /// purpose of calculating its size (e.g. using the .size directive). By
   /// default, this is equal to CurrentFnSym.
   MCSymbol *CurrentFnSymForSize;
 
+  /// Map global proxy MCSymbols to GlobalVariables and keep track of its
+  /// number of uses by other globals.
+  typedef std::pair<const GlobalVariable *, unsigned> GblProxyUsePair;
+  DenseMap<const MCSymbol *, GblProxyUsePair> GlobalProxies;
+
 private:
   // The garbage collection metadata printer table.
   void *GCMetadataPrinters; // Really a DenseMap.
 
   /// Emit comments in assembly output if this is true.
   ///
   bool VerboseAsm;
   static char ID;
public:
   void EmitBasicBlockStart(const MachineBasicBlock &MBB) const;
 
   /// Lower the specified LLVM Constant to an MCExpr.
   const MCExpr *lowerConstant(const Constant *CV);
 
   /// \brief Print a general LLVM constant to the .s file.
   void EmitGlobalConstant(const Constant *CV);
 
+  /// \brief Unnamed constant global variables solely contaning a pointet to
+  /// another globals variables are act like a global variable "proxy", i.e.,
+  /// it's only used to hold the address of the latter. One (very) minor
+  /// optimization is to replace accesses to these proxies by using the GOT
+  /// entry for the final global instead. Hence, we select proxy candidates
+  /// among the module global variables, avoid emitting them unnecessarily and
+  /// finally replace references to them by pc relative accesses to GOT entries.
+  void GetGlobalProxies(Module &M);
+
+  /// \brief Constant expressions using global proxies may not be converted to
+  /// PC relative GOT entry references, in this cases we need to emit the
+  /// proxies we previously omitted in EmitGlobalVariable.
+  void EmitGlobalProxies();
+
   //===------------------------------------------------------------------===//
   // Overridable Hooks
   //===------------------------------------------------------------------===//
 
   // Targets can, or in the case of EmitInstruction, must implement these to
   // customize output.
 
   /// This virtual method can be overridden by targets that want to emit

include/llvm/Target/TargetLoweringObjectFile.h

public:
   virtual const MCExpr *getDebugThreadLocalSymbol(const MCSymbol *Sym) const;
 
   virtual const MCExpr *
   getExecutableRelativeSymbol(const ConstantExpr *CE, Mangler &Mang,
                               const TargetMachine &TM) const {
     return nullptr;
   }
 
+  /// \brief Target supports replacing a data "PC"-relative access to a symbol
+  /// through another symbol, by accessing the later via a GOT entry instead?
+  virtual bool supportIndirectSymViaGOTPCRel() const { return false; }
+
+  /// \brief Get the target specific PC relative GOT entry relocation
+  virtual const MCExpr *
+    getIndirectSymViaGOTPCRel(const MCSymbol *Sym,
+                              const MCExpr *DotExpr) const {
+    return nullptr;
+  }
+
 protected:
   virtual const MCSection *
   SelectSectionForGlobal(const GlobalValue *GV, SectionKind Kind,
                          Mangler &Mang, const TargetMachine &TM) const = 0;
 };
 
 } // end namespace llvm
 
 #endif

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

 
 /// EmitGlobalVariable - Emit the specified global variable to the .s file.
 void AsmPrinter::EmitGlobalVariable(const GlobalVariable *GV) {
   if (GV->hasInitializer()) {
     // Check to see if this is a special global used by LLVM, if so, emit it.
     if (EmitSpecialLLVMGlobal(GV))
       return;
 
+    // Skip the emission of global proxies.
+    if (getObjFileLowering().supportIndirectSymViaGOTPCRel() &&
+        GlobalProxies.count(getSymbol(GV)))
+      return;
+
     if (isVerbose()) {
       GV->printAsOperand(OutStreamer.GetCommentOS(),
                      /*PrintType=*/false, GV->getParent());
       OutStreamer.GetCommentOS() << '\n';
     }
   }
 
   MCSymbol *GVSym = getSymbol(GV);
void AsmPrinter::EmitFunctionBody() {
   MMI->EndFunction();
 
   // Print out jump tables referenced by the function.
   EmitJumpTableInfo();
 
   OutStreamer.AddBlankLine();
 }
 
+// isGlobalProxyCandidate - Only consider global proxies if all users are
+// constant expressions inside initializers of other global variables, e.g. we
+// don't handle cstexpr inside instructions. During global variable emission,
+// proxy candidates are skipped and could be emitted later on in case at least
+// one cstexpr isn't replaced by a PC relative GOT entry access.
+static bool isGlobalProxyCandidate(const GlobalVariable *GV) {
+  if (GV->use_empty())
+    return false;
+
+  for (auto *U : GV->users()) {
+    const Constant *CE = dyn_cast<ConstantExpr>(U);
+    if (!CE)
+      return false;
+
+    const Constant *C = cast<Constant>(CE);
+    while (C && C->getNumUses() == 1 && !isa<GlobalVariable>(C))
+      C = dyn_cast<Constant>(C->user_back());
+
+    if (!isa<GlobalVariable>(C))
+      return false;
+  }
+
+  return true;
+}
+
+// GetGlobalProxies - Unnamed constant global variables solely contaning a
+// pointet to another globals variables are act like a global variable "proxy",
+// i.e., it's only used to hold the address of the latter. One (very) minor
+// optimization is to replace accesses to these proxies by using the GOT entry
+// for the final global instead. Hence, we select proxy candidates among the
+// module global variables, avoid emitting them unnecessarily and finally
+// replace references to them by pc relative accesses to GOT entries.
+void AsmPrinter::GetGlobalProxies(Module &M) {
+  if (getObjFileLowering().supportIndirectSymViaGOTPCRel())
+    return;
+
+  for (const auto &G : M.globals()) {
+    // Global proxies are unnamed globals with a constant pointer initializer
+    // to another global symbol
+    if (!G.hasUnnamedAddr() || !G.hasInitializer() || !G.getNumOperands())
+      continue;
+
+    const GlobalVariable *FinalGV = dyn_cast<GlobalVariable>(G.getOperand(0));
+    if (!FinalGV)
+      continue;
+
+    const Constant *C = dyn_cast<Constant>(FinalGV);
+    if (!C & !isa<GlobalValue>(C) || !C->getType()->isPointerTy())
+      continue;
+
+    if (!isGlobalProxyCandidate(&G))
+      continue;
+
+    const MCSymbol *ProxySym = getSymbol(&G);
+    GlobalProxies[ProxySym] = std::make_pair(&G, G.getNumUses());
+  }
+}
+
+// EmitGlobalProxies - Constant expressions using global proxies may not be
+// converted to PC relative GOT entry references, in this cases we need to
+// emit the proxies we previously omitted in EmitGlobalVariable.
+void AsmPrinter::EmitGlobalProxies() {
+  if (getObjFileLowering().supportIndirectSymViaGOTPCRel())
+    return;
+
+  while (!GlobalProxies.empty()) {
+    DenseMap<const MCSymbol *, GblProxyUsePair>::iterator I =
+      GlobalProxies.begin();
+    const MCSymbol *S = I->first;
+    const GlobalVariable *GV = I->second.first;
+    GlobalProxies.erase(S);
+    EmitGlobalVariable(GV);
+  }
+}
+
 bool AsmPrinter::doFinalization(Module &M) {
+  // Gather all global proxies in the module.
+  GetGlobalProxies(M);
+
   // Emit global variables.
   for (const auto &G : M.globals())
     EmitGlobalVariable(&G);
 
+  // Emit remaining global proxies.
+  EmitGlobalProxies();
+
   // Emit visibility info for declarations
   for (const Function &F : M) {
     if (!F.isDeclaration())
       continue;
     GlobalValue::VisibilityTypes V = F.getVisibility();
     if (V == GlobalValue::DefaultVisibility)
       continue;
 
case Instruction::Xor: {
     case Instruction::And: return MCBinaryExpr::CreateAnd(LHS, RHS, Ctx);
     case Instruction::Or:  return MCBinaryExpr::CreateOr (LHS, RHS, Ctx);
     case Instruction::Xor: return MCBinaryExpr::CreateXor(LHS, RHS, Ctx);
     }
   }
   }
 }
 
-static void emitGlobalConstantImpl(const Constant *C, AsmPrinter &AP);
+static void emitGlobalConstantImpl(const Constant *C, AsmPrinter &AP,
+                                   uint64_t Offset = 0);
 
 /// isRepeatedByteSequence - Determine whether the given value is
 /// composed of a repeated sequence of identical bytes and return the
 /// byte value.  If it is not a repeated sequence, return -1.
 static int isRepeatedByteSequence(const ConstantDataSequential *V) {
   StringRef Data = V->getRawDataValues();
   assert(!Data.empty() && "Empty aggregates should be CAZ node");
   char C = Data[0];
static void emitGlobalConstantDataSequential(const ConstantDataSequential *CDS,
   unsigned Size = DL.getTypeAllocSize(CDS->getType());
   unsigned EmittedSize = DL.getTypeAllocSize(CDS->getType()->getElementType()) *
                         CDS->getNumElements();
   if (unsigned Padding = Size - EmittedSize)
     AP.OutStreamer.EmitZeros(Padding);
 
 }
 
-static void emitGlobalConstantArray(const ConstantArray *CA, AsmPrinter &AP) {
+static void emitGlobalConstantArray(const ConstantArray *CA, AsmPrinter &AP,
+                                    uint64_t Offset) {
   // See if we can aggregate some values.  Make sure it can be
   // represented as a series of bytes of the constant value.
   int Value = isRepeatedByteSequence(CA, AP.TM);
+  const DataLayout &DL = *AP.TM.getSubtargetImpl()->getDataLayout();
 
   if (Value != -1) {
-    uint64_t Bytes =
-        AP.TM.getSubtargetImpl()->getDataLayout()->getTypeAllocSize(
-            CA->getType());
+    uint64_t Bytes = DL.getTypeAllocSize(CA->getType());
     AP.OutStreamer.EmitFill(Bytes, Value);
   }
   else {
-    for (unsigned i = 0, e = CA->getNumOperands(); i != e; ++i)
-      emitGlobalConstantImpl(CA->getOperand(i), AP);
+    for (unsigned i = 0, e = CA->getNumOperands(); i != e; ++i) {
+      emitGlobalConstantImpl(CA->getOperand(i), AP, Offset);
+      Offset += DL.getTypeAllocSize(CA->getOperand(i)->getType());
+    }
   }
 }
 
 static void emitGlobalConstantVector(const ConstantVector *CV, AsmPrinter &AP) {
   for (unsigned i = 0, e = CV->getType()->getNumElements(); i != e; ++i)
     emitGlobalConstantImpl(CV->getOperand(i), AP);
 
   const DataLayout &DL = *AP.TM.getSubtargetImpl()->getDataLayout();
   unsigned Size = DL.getTypeAllocSize(CV->getType());
   unsigned EmittedSize = DL.getTypeAllocSize(CV->getType()->getElementType()) *
                          CV->getType()->getNumElements();
   if (unsigned Padding = Size - EmittedSize)
     AP.OutStreamer.EmitZeros(Padding);
 }
 
-static void emitGlobalConstantStruct(const ConstantStruct *CS, AsmPrinter &AP) {
+static void emitGlobalConstantStruct(const ConstantStruct *CS, AsmPrinter &AP,
+                                     uint64_t Offset) {
   // Print the fields in successive locations. Pad to align if needed!
   const DataLayout *DL = AP.TM.getSubtargetImpl()->getDataLayout();
   unsigned Size = DL->getTypeAllocSize(CS->getType());
   const StructLayout *Layout = DL->getStructLayout(CS->getType());
   uint64_t SizeSoFar = 0;
   for (unsigned i = 0, e = CS->getNumOperands(); i != e; ++i) {
     const Constant *Field = CS->getOperand(i);
 
+    // Print the actual field value.
+    emitGlobalConstantImpl(Field, AP, Offset+SizeSoFar);
+
     // Check if padding is needed and insert one or more 0s.
     uint64_t FieldSize = DL->getTypeAllocSize(Field->getType());
     uint64_t PadSize = ((i == e-1 ? Size : Layout->getElementOffset(i+1))
                         - Layout->getElementOffset(i)) - FieldSize;
     SizeSoFar += FieldSize + PadSize;
 
-    // Now print the actual field value.
-    emitGlobalConstantImpl(Field, AP);
-
     // Insert padding - this may include padding to increase the size of the
     // current field up to the ABI size (if the struct is not packed) as well
     // as padding to ensure that the next field starts at the right offset.
     AP.OutStreamer.EmitZeros(PadSize);
   }
   assert(SizeSoFar == Layout->getSizeInBytes() &&
          "Layout of constant struct may be incorrect!");
 }
if (ExtraBitsSize) {
     Size -= (BitWidth / 64) * 8;
     assert(Size && Size * 8 >= ExtraBitsSize &&
            (ExtraBits & (((uint64_t)-1) >> (64 - ExtraBitsSize)))
            == ExtraBits && "Directive too small for extra bits.");
     AP.OutStreamer.EmitIntValue(ExtraBits, Size);
   }
 }
 
-static void emitGlobalConstantImpl(const Constant *CV, AsmPrinter &AP) {
+static void handleIndirectSymViaGOTPCRel(AsmPrinter &AP, uint64_t Offset,
+                                         const MCExpr **ME) {
+  // The symbol we are about to emit needs to be a cstexpr in the form
+  //
+  //  cstexpr := <proxy> - "."
+  //          := <proxy> - <X> + <offset>
+  //
+  // where X is the symbol base of the current emission
+  const MCBinaryExpr *BE = dyn_cast<MCBinaryExpr>(*ME);
+  if (!BE || BE->getOpcode() != MCBinaryExpr::Sub)
+    return;
+
+  const MCSymbolRefExpr *Proxy = dyn_cast<MCSymbolRefExpr>(BE->getLHS());
+  if (!Proxy)
+    return;
+  const MCSymbol *ProxySym = &Proxy->getSymbol();
+  if (!AP.GlobalProxies.count(ProxySym))
+    return;
+
+  // Check the "." expression, that is, make sure X + offset == ".". If the
+  // current emission offset differs from the one in 'offset', this isn't a "PC"
+  // relative delta.
+  if (dyn_cast<MCSymbolRefExpr>(BE->getRHS())) {
+    if (Offset != 0)
+      return;
+  } else if (const MCBinaryExpr *BExpr = dyn_cast<MCBinaryExpr>(BE->getRHS())) {
+    if ((BExpr->getOpcode() != MCBinaryExpr::Add) ||
+        !dyn_cast<MCSymbolRefExpr>(BExpr->getLHS()))
+      return;
+
+    const MCConstantExpr *XOff = dyn_cast<MCConstantExpr>(BExpr->getRHS());
+    if (!XOff || (uint64_t)XOff->getValue() != Offset)
+      return;
+  }
+
+  // Emit the GOT PC relative access to replace the proxy usage, i.e., replace:
+  //
+  // A:
+  //  .long 42
+  // Proxy:
+  //  .quad A
+  // X:
+  //  .long Proxy - "."
+  //
+  // with a target specific equivalent to:
+  //
+  // X:
+  //  .long A@GOTPCREL
+  AsmPrinter::GblProxyUsePair Result = AP.GlobalProxies[ProxySym];
+  const GlobalVariable *GV = Result.first;
+  const GlobalVariable *FinalGV = dyn_cast<GlobalVariable>(GV->getOperand(0));
+  const MCSymbol *FinalSym = AP.getSymbol(FinalGV);
+  unsigned NumUses = Result.second;
+  *ME = AP.getObjFileLowering().getIndirectSymViaGOTPCRel(FinalSym,
+                                                          BE->getRHS());
+
+  // Update proxy usage information
+  --NumUses;
+  if (NumUses)
+    AP.GlobalProxies[ProxySym] = std::make_pair(GV, --NumUses);
+  else
+    AP.GlobalProxies.erase(ProxySym);
+}
+
+static void emitGlobalConstantImpl(const Constant *CV, AsmPrinter &AP,
+                                   uint64_t Offset) {
   const DataLayout *DL = AP.TM.getSubtargetImpl()->getDataLayout();
   uint64_t Size = DL->getTypeAllocSize(CV->getType());
   if (isa<ConstantAggregateZero>(CV) || isa<UndefValue>(CV))
     return AP.OutStreamer.EmitZeros(Size);
 
   if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) {
     switch (Size) {
     case 1:
     case 2:
if (isa<ConstantPointerNull>(CV)) {
     AP.OutStreamer.EmitIntValue(0, Size);
     return;
   }
 
   if (const ConstantDataSequential *CDS = dyn_cast<ConstantDataSequential>(CV))
     return emitGlobalConstantDataSequential(CDS, AP);
 
   if (const ConstantArray *CVA = dyn_cast<ConstantArray>(CV))
-    return emitGlobalConstantArray(CVA, AP);
+    return emitGlobalConstantArray(CVA, AP, Offset);
 
   if (const ConstantStruct *CVS = dyn_cast<ConstantStruct>(CV))
-    return emitGlobalConstantStruct(CVS, AP);
+    return emitGlobalConstantStruct(CVS, AP, Offset);
 
   if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) {
     // Look through bitcasts, which might not be able to be MCExpr'ized (e.g. of
     // vectors).
     if (CE->getOpcode() == Instruction::BitCast)
       return emitGlobalConstantImpl(CE->getOperand(0), AP);
 
     if (Size > 8) {
       // If the constant expression's size is greater than 64-bits, then we have
       // to emit the value in chunks. Try to constant fold the value and emit it
       // that way.
       Constant *New = ConstantFoldConstantExpression(CE, DL);
       if (New && New != CE)
         return emitGlobalConstantImpl(New, AP);
     }
   }
 
   if (const ConstantVector *V = dyn_cast<ConstantVector>(CV))
     return emitGlobalConstantVector(V, AP);
 
   // Otherwise, it must be a ConstantExpr.  Lower it to an MCExpr, then emit it
   // thread the streamer with EmitValue.
-  AP.OutStreamer.EmitValue(AP.lowerConstant(CV), Size);
+  const MCExpr *ME = AP.lowerConstant(CV);
+  if (AP.getObjFileLowering().supportIndirectSymViaGOTPCRel())
+    handleIndirectSymViaGOTPCRel(AP, Offset, &ME);
+
+  AP.OutStreamer.EmitValue(ME, Size);
 }
 
 /// EmitGlobalConstant - Print a general LLVM constant to the .s file.
 void AsmPrinter::EmitGlobalConstant(const Constant *CV) {
   uint64_t Size =
       TM.getSubtargetImpl()->getDataLayout()->getTypeAllocSize(CV->getType());
   if (Size)
     emitGlobalConstantImpl(CV, *this);

lib/Target/X86/X86TargetObjectFile.h

getTTypeGlobalReference(const GlobalValue *GV, unsigned Encoding,
                             MachineModuleInfo *MMI,
                             MCStreamer &Streamer) const override;
 
     // getCFIPersonalitySymbol - The symbol that gets passed to
     // .cfi_personality.
     MCSymbol *getCFIPersonalitySymbol(const GlobalValue *GV, Mangler &Mang,
                                       const TargetMachine &TM,
                                       MachineModuleInfo *MMI) const override;
+
+    bool supportIndirectSymViaGOTPCRel() const override { return true; }
+
+    const MCExpr *
+      getIndirectSymViaGOTPCRel(const MCSymbol *Sym,
+                                const MCExpr *DotExpr) const override;
   };
 
   /// X86LinuxTargetObjectFile - This implementation is used for linux x86
   /// and x86-64.
   class X86LinuxTargetObjectFile : public TargetLoweringObjectFileELF {
     void Initialize(MCContext &Ctx, const TargetMachine &TM) override;
 
     /// \brief Describe a TLS variable address within debug info.

lib/Target/X86/X86TargetObjectFile.cpp

 }
 
 MCSymbol *X86_64MachoTargetObjectFile::getCFIPersonalitySymbol(
     const GlobalValue *GV, Mangler &Mang, const TargetMachine &TM,
     MachineModuleInfo *MMI) const {
   return TM.getSymbol(GV, Mang);
 }
 
+const MCExpr *X86_64MachoTargetObjectFile::getIndirectSymViaGOTPCRel(
+    const MCSymbol *Sym, const MCExpr *DotExpr) const {
+  // On Darwin/X86-64, we can use foo@GOTPCREL+4, which is an indirect
+  // pc-relative reference.
+  const MCExpr *Res =
+    MCSymbolRefExpr::Create(Sym, MCSymbolRefExpr::VK_GOTPCREL, getContext());
+  const MCExpr *Four = MCConstantExpr::Create(4, getContext());
+  return MCBinaryExpr::CreateAdd(Res, Four, getContext());
+}
+
 void
 X86LinuxTargetObjectFile::Initialize(MCContext &Ctx, const TargetMachine &TM) {
   TargetLoweringObjectFileELF::Initialize(Ctx, TM);
   InitializeELF(TM.Options.UseInitArray);
 }
 
 const MCExpr *
 X86LinuxTargetObjectFile::getDebugThreadLocalSymbol(

test/MC/X86/cstexpr-gotpcrel.ll

+; RUN: llc -filetype=obj -mtriple=x86_64-apple-darwin %s -o - | llvm-readobj -r | FileCheck -check-prefix=X86-OBJ %s
+; RUN: llc -mtriple=x86_64-apple-darwin %s -o - | FileCheck -check-prefix=X86 %s
+
+; X86-OBJ: Format: Mach-O 64-bit x86-64
+; X86-OBJ: Arch: x86_64
+; X86-OBJ: AddressSize: 64bit
+; X86-OBJ: Relocations [
+; X86-OBJ:   Section __data {
+%struct.data = type { i32, %struct.anon }
+%struct.anon = type { i32, i32 }
+
+; Offsets in table could be to local or external symbols
+; and must be proxied by another globals - in the final object, the
+; indirection for the external is replaced by the GOT and unnamed_addr
+; isn't emitted.
+
+; X86-NOT: _localproxy
+@localfoo = global i32 42
+@localproxy = unnamed_addr constant i32* @localfoo
+
+; X86-NOT: _extproxy
+@extfoo = external global i32
+@extproxy = unnamed_addr constant i32* @extfoo
+
+@table = global [3 x %struct.data] [
+; X86-LABEL: _table
+  %struct.data { i32 1, %struct.anon { i32 2, i32 3 } },
+; X86: .long   5
+; X86-NOT: .long   _localproxy-(_table+20)
+; X86-NEXT: .long   _localfoo@GOTPCREL+4
+  %struct.data { i32 4, %struct.anon { i32 5,
+    i32 trunc (i64 sub (i64 ptrtoint (i32** @localproxy to i64),
+                        i64 ptrtoint (i32* getelementptr inbounds ([3 x %struct.data]* @table, i32 0, i64 1, i32 1, i32 1) to i64))
+                        to i32)}
+  },
+; X86: .long   5
+; X86-NOT: _extproxy-(_table+32)
+; X86-NEXT: .long   _extfoo@GOTPCREL+4
+  %struct.data { i32 4, %struct.anon { i32 5,
+    i32 trunc (i64 sub (i64 ptrtoint (i32** @extproxy to i64),
+                        i64 ptrtoint (i32* getelementptr inbounds ([3 x %struct.data]* @table, i32 0, i64 2, i32 1, i32 1) to i64))
+                        to i32)}
+  }
+], align 16
+
+; X86-OBJ:    0x30 1 2 1 X86_64_RELOC_GOT 0 _extfoo
+; X86-OBJ-NEXT:    0x24 1 2 1 X86_64_RELOC_GOT 0 _localfoo