[AIX] Emit TOC entries for ASM printing

[daltenty]

Summary

Emit the correct .toc psuedo op when we change to the TOC and emit
TC entries. Make sure TOC psuedos get the right symbols via overriding
getMCSymbolForTOCPseudoMO on AIX. Add a test for TOC assembly writing
and update tests to include TOC entries.

Also make sure external globals have a csect set and handle external function descriptor (originally authored by Jason Liu) so we can emit TOC entries for them.

[jasonliu]

llvm/include/llvm/MC/MCSymbolXCOFF.h

57

I think we have an exception here -> TOC[TC0]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1850

TC entry itself is a csect. Do we need to create that csect(MCSectionXCOFF) and do a SwitchSection for every TC entry?
Otherwise, I will need some help on understanding how to implement object file generation for TC entry.

1867

If we are going to call EmitGlobalVariable for every GV, do we need to ValidateGV twice here? Or are there situations that we would call getMCSymbolForTOCPseudoMO for a particular GV that is not going to be checked in EmitGlobalVariable?

1897

Nit: Could we further reduce the nestness of this function by using early returns?

if (MO.getType() != MachineOperand::MO_GlobalAddress)
  return PPCAsmPrinter::getMCSymbolForTOCPseudoMO(MO);

llvm/lib/Target/PowerPC/PPCMCInstLower.cpp

62

A thought here:
We are going to see this again in getMCSymbolForTOCPseudoMO anyway. Would it be better if we move the logic here to the getMCSymbolForTOCPseudoMO?
We would be able to combine the logic with undefined symbol there, and the only difference is that if we should put XCOFF::XMC_DS or XCOFF::XMC_UA into the MCSection.

[daltenty]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1850

I agree, this needs to be revised.

1867

The problem is that this will be called before EmitGlobalVariable, so we need to filter them here so we don't try to handle unsupported cases like thread locals, etc. But fatal erroring them here will not necessarily cover all the cases where we might emit them, since this will only cover those we have TOC references for, thus I believe we should cover both.

[Xiangling_L]

Just a reminder, since I landed the patch: https://reviews.llvm.org/D70243. You may need to update three testcases there.

[DiggerLin]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1881

instead of PPCAsmPrinter::getMCSymbolForTOCPseudoMO(MO)->getName(),
why not use getSymbol(MO.getGlobal())->getName() directory here ?

1882

we create a MCSectionXCOFF which has symbol type "XCOFF::XTY_ER", You have a test case which the external symbol, I just wonder it not hit the assert in the function MCSectionXCOFF construction?

assert((ST == XCOFF::XTY_SD || ST == XCOFF::XTY_CM) &&

"Invalid or unhandled type for csect.");

[daltenty]

Address review comments, including:

• Changing the way we do spliting for unqualified names
• Refactoring external FunDesc into getMCSymbolForTOCPseudoMO
• Updating tests for presence of TC entries

[daltenty]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1882

I believe that is handled in the parent revision D70443

[jasonliu]

llvm/include/llvm/MC/MCAsmInfo.h

337

nit: Do we need to capitalize Commons and Storage Mapping Class? I find them all in small letters in AIX assembler guide.

llvm/lib/Target/PowerPC/MCTargetDesc/PPCMCTargetDesc.cpp

33

If we intend to keep this interface change:
emitTCEntry(const MCSymbol &, const MCSymbol &)

We could remove this include directive.

111

I'm on the fence of this interface change.
I could see this interface change makes emitTCEntry a bit cleaner, and it models the TC entry a bit better: a symbol represent the real TC, and a symbol represent the item that TC is trying to store.
But on the other hand, I don't think we are ever getting ".tc A[TC], B", and we always have ".tc A[TC], A" (at least for now). Using the new interface would kinda make that implicit connection lost.

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

169

Could be a static member function?

1910

Could we use this structure for the function? I think it's easier to read and understand.

if (MO.getType() != MachineOperand::MO_GlobalAddress)
  return PPCAsmPrinter::getMCSymbolForTOCPseudoMO(MO);

const GlobalVariable *GV = MO.getGlobal();
ValidateGV(GV)
if (GV->isDeclaration()) {
  if (!Xsym->hasContainingCsect()) {
    // Set up csect for external symbol, use isa<Function> to figure out what SMC we should use for the csect. 
  }
  return Csect->getQualNameSymbol();
}

SectionKind GVKind = getObjFileLowering().getKindForGlobal(GV, TM);
if (GVKind.isCommon() || GVKind.isBSSLocal()) {
  return Csect->getQualNameSymbol();
}

return getSymbol(GV);

Some remark on some implication on this change:

!(GO = dyn_cast<const GlobalObject>(MO.getGlobal())

I'm not sure why we need this dyn_cast on the first if, so I removed it.

const GlobalVariable *GV = dyn_cast<const GlobalVariable>(GO);
  if (GV) {
    ValidateGV(GV);

This is a upcast, it's definitely going to succeed. So we don't need dyn_cast, and we will get a GV for sure.

3. On your current function, it will return a qual name for a defined function. And this structure will not return a qual name for the defined function. I think the qual name for the defined function is unnecessary, and use label to refer to that function will succeed. And it's easier on the mental model for when we should use a qual name for TC entry: when the symbol is undefined, or when it's common.

[daltenty]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1910

I have a few issues with the specifics of this, as outlined bellow, but I think I can generally adopt this direction. I agree some of the GlobalVariable && Function case can just be folded so I'll try to follow that.

First on the remarks:

1. MO.getGlobal() returns a GlobalValue, but we only want to handle GlobalObject cases (i.e. GlobalVariable & Function), so some kind of cast is required

2. This is not an upcast, GO is a GlobalObject.

3. Hmm, I actually found it easier to reason about referring to the CSects directly when appropriate, which is why I included that case.

Essentially, it boils down to "If you're talking about something that is a whole CSect in it's own right (i.e. Function Descriptors), refer to by it's QualNameSymbol". Why refer to all these extra middle-men label symbols when they aren't needed?

That said, if we prefer to keep this minimal and use the existing label, I can add in the checks to pass it by.

[jasonliu]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1910

1. MO.getGlobal() returns a GlobalValue, but we only want to handle GlobalObject cases (i.e. GlobalVariable & Function), so some kind of cast is required

I see. I think the behavior is still correct because it would fall back to the last "return getSymbol(GV);", which is what PPCAsmPrinter::getMCSymbolForTOCPseudoMO(MO) do anyway. But I agree we could just do the early return.

2. This is not an upcast, GO is a GlobalObject.

You are right. I think I mis-read the GV as GlobalValue. (I need to be careful when I see "GV" because it could mean GlobalValue or GlobalVariable.)

3. Essentially, it boils down to "If you're talking about something that is a whole CSect in it's own right (i.e. Function Descriptors), refer to by it's QualNameSymbol".

Okk, I'm Okay with the mental model as "If we could refer to it as a csect, then let's refer to it as a csect.".

[daltenty]

llvm/lib/Target/PowerPC/MCTargetDesc/PPCMCTargetDesc.cpp

111

If that relationship is something we want to preserve, we could add an assert of the form:

assert(Entry.getName().equals(MAI->getSymbolsHaveSMC() ? Target.getUnqualifiedName()  : Target.getName()) && "TOC entries should normally have the same name as their targets")

[jasonliu]

llvm/lib/Target/PowerPC/MCTargetDesc/PPCMCTargetDesc.cpp

111

Then do we really need two MCSymbol as parameters? I feel like it just complicates the relationship. And one MCSymbol is enough, even on AIX.

[daltenty]

llvm/lib/Target/PowerPC/MCTargetDesc/PPCMCTargetDesc.cpp

111

I think it make sense that we need both, it models the actual TC entry better as you said. And using one also presents difficulties in the AIX case.

We can't the qualname symbol, because this will not work for the object writing case as we need the value. But if we proceed with just the target symbol we end up rebuilding the same string we already had in the qualname symbol to begin with, since it's the same as the TC CSect (as we would expect).

If we want to maintain the old interface, for the PPC LE target where they are the same symbol, we just create a wrapper where duplicate the argument?

[jasonliu]

llvm/lib/Target/PowerPC/MCTargetDesc/PPCMCTargetDesc.cpp

111

Maybe calling getUnqualifiedName() again is not that bad. But I'm Okay with what we have right now in the patch. The assert and wrapper does not really make things better.

[DiggerLin]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1893

it need to GV->isDeclaration(), otherwise a test case which as
int g=0;
will has storage mapping class XMC_UA.

[DiggerLin]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

45

file llvm/IR/GlobalVariable.h already include the GlobalObject.h.

the #include "llvm/IR/GlobalObject.h" do not need.

1464

I agree with jason, since we always have ".tc A[TC], A", we do not need to change the interface of function emitTCEntry()

[daltenty]

llvm/lib/Target/PowerPC/MCTargetDesc/PPCMCTargetDesc.cpp

111

Taking another look, I agree. I will update it to just call getUnqualifiedName() again.

[daltenty]

Address review comments round 2 including:

• Minor edits
• Don't change the emitTCEntry interface
• Refactor getMCSymbolForTOCPseudoMO

[daltenty]

• Remove unneeded header

[jasonliu]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1766

"Handle ... later" sounds confusing for an early return.
It's more like, we don't need to do anything for external global variables.
And this early return could be just after "ValidateGV(GV);", I think we already set storage class for the symbol in getMCSymbolForTOCPseudoMO. Is that right?

1850

nit: Csect -> csect

1864

Assign a nullptr to it?

1874

We used *GV again below, we could avoid dyn_cast the second time below if we make it a local variable.
And could *GV be const?

1880

nit: the global value -> the GlobalObject

1881

nit: "then MCSymbol XSym represents an external" -> "then XSym is an external referenced symbol."

1883

nit: it's -> its

1898

inialized globals-> initialized global variables

1908

We could add a comment here about other global variables, something like:
Other global variables are stored as labels inside of data/text section, we could not refer to them by qualname.

1912

nit: refer to the descriptor -> refer to the function descriptor csect.

[daltenty]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1766

Yes, that's correct. We end up covering this coincidentally.

[daltenty]

• Move early return.
• Address other comments.

[jasonliu]

Minor nit that could be address while landing.
Otherwise LGTM.

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1864

nit: Add some spaces here.

1874

Could GV be const here?

1883

... for it so that we...

llvm/include/llvm/MC/MCAsmInfo.h

protected:
   /// This attribute, if not MCSA_Invalid, is used to declare an undefined
   /// symbol as having hidden visibility. Defaults to MCSA_Hidden.
   MCSymbolAttr HiddenDeclarationVisibilityAttr = MCSA_Hidden;
 
   /// This attribute, if not MCSA_Invalid, is used to declare a symbol as having
   /// protected visibility.  Defaults to MCSA_Protected
   MCSymbolAttr ProtectedVisibilityAttr = MCSA_Protected;
 
+  // This attribute is used to indicate symbols such as Commons on AIX may have
+  // a Storage Mapping Class embedded in the name.
+  bool SymbolsHaveSMC = false;
+
   //===--- Dwarf Emission Directives -----------------------------------===//
 
   /// True if target supports emission of debugging information.  Defaults to
   /// false.
   bool SupportsDebugInformation = false;
 
   /// Exception handling format for the target.  Defaults to None.
   ExceptionHandling ExceptionsType = ExceptionHandling::None;
public:
   MCSymbolAttr getHiddenDeclarationVisibilityAttr() const {
     return HiddenDeclarationVisibilityAttr;
   }
 
   MCSymbolAttr getProtectedVisibilityAttr() const {
     return ProtectedVisibilityAttr;
   }
 
+  bool getSymbolsHaveSMC() const { return SymbolsHaveSMC; }
+
   bool doesSupportDebugInformation() const { return SupportsDebugInformation; }
 
   bool doesSupportExceptionHandling() const {
     return ExceptionsType != ExceptionHandling::None;
   }
 
   ExceptionHandling getExceptionHandlingType() const { return ExceptionsType; }
   WinEH::EncodingType getWinEHEncodingType() const { return WinEHEncodingType; }

llvm/include/llvm/MC/MCSymbolXCOFF.h

 //===- MCSymbolXCOFF.h -  ----------------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 #ifndef LLVM_MC_MCSYMBOLXCOFF_H
 #define LLVM_MC_MCSYMBOLXCOFF_H
 
 #include "llvm/ADT/Optional.h"
+#include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/XCOFF.h"
 #include "llvm/MC/MCSymbol.h"
 
 namespace llvm {
 
 class MCSectionXCOFF;
 
 class MCSymbolXCOFF : public MCSymbol {
public:
   MCSectionXCOFF *getContainingCsect() const {
     assert(ContainingCsect &&
            "Trying to get containing csect but none was set.");
     return ContainingCsect;
   }
 
   bool hasContainingCsect() const { return ContainingCsect != nullptr; }
 
+  StringRef getUnqualifiedName() const {
+    const StringRef name = getName();
+    if (name.back() == ']') {
+      StringRef lhs, rhs;
+      std::tie(lhs, rhs) = name.rsplit('[');
+      assert(!rhs.empty() && "Invalid SMC format in XCOFF symbol.");
+      return lhs;
+    }
+    return name;
+  }
+
 private:
   Optional<XCOFF::StorageClass> StorageClass;
   MCSectionXCOFF *ContainingCsect = nullptr;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_MC_MCSYMBOLXCOFF_H

llvm/lib/BinaryFormat/XCOFF.cpp

StringRef XCOFF::getMappingClassString(XCOFF::StorageMappingClass SMC) {
   case XCOFF::XMC_PR:
     return "PR";
   case XCOFF::XMC_TC0:
     return "TC0";
   case XCOFF::XMC_BS:
     return "BS";
   case XCOFF::XMC_RO:
     return "RO";
+  case XCOFF::XMC_UA:
+    return "UA";
+  case XCOFF::XMC_TC:
+    return "TC";
   default:
     report_fatal_error("Unhandled storage-mapping class.");
   }
 }

llvm/lib/MC/MCSectionXCOFF.cpp

void MCSectionXCOFF::PrintSwitchToSection(const MCAsmInfo &MAI, const Triple &T,
   }
 
   if (getKind().isData()) {
     switch (getMappingClass()) {
     case XCOFF::XMC_RW:
     case XCOFF::XMC_DS:
       OS << "\t.csect " << QualName->getName() << '\n';
       break;
+    case XCOFF::XMC_TC:
+      break;
     case XCOFF::XMC_TC0:
       OS << "\t.toc\n";
       break;
     default:
       report_fatal_error(
           "Unhandled storage-mapping class for .data csect.");
     }
     return;

llvm/lib/Target/PowerPC/MCTargetDesc/PPCMCAsmInfo.cpp

 }
 
 void PPCXCOFFMCAsmInfo::anchor() {}
 
 PPCXCOFFMCAsmInfo::PPCXCOFFMCAsmInfo(bool Is64Bit, const Triple &T) {
   assert(!IsLittleEndian && "Little-endian XCOFF not supported.");
   CodePointerSize = CalleeSaveStackSlotSize = Is64Bit ? 8 : 4;
   ZeroDirective = "\t.space\t";
+  SymbolsHaveSMC = true;
 }

llvm/lib/Target/PowerPC/MCTargetDesc/PPCMCTargetDesc.cpp

 #include "llvm/MC/MCELFStreamer.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCSymbolELF.h"
+#include "llvm/MC/MCSymbolXCOFF.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/FormattedStream.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;

 
 class PPCTargetAsmStreamer : public PPCTargetStreamer {
   formatted_raw_ostream &OS;
 
 public:
   PPCTargetAsmStreamer(MCStreamer &S, formatted_raw_ostream &OS)
       : PPCTargetStreamer(S), OS(OS) {}
 
-  void emitTCEntry(const MCSymbol &S) override {
+  void emitTCEntry(const MCSymbol &Entry, const MCSymbol &Target) override {
+    const MCAsmInfo *MAI = Streamer.getContext().getAsmInfo();
     OS << "\t.tc ";
-    OS << S.getName();
-    OS << "[TC],";
-    OS << S.getName();
+    OS << Entry.getName();
+    OS << (MAI->getSymbolsHaveSMC()? "," : "[TC],");
+    OS << Target.getName();
     OS << '\n';
   }
 
   void emitMachine(StringRef CPU) override {
     OS << "\t.machine " << CPU << '\n';
   }
 
   void emitAbiVersion(int AbiVersion) override {

 class PPCTargetELFStreamer : public PPCTargetStreamer {
 public:
   PPCTargetELFStreamer(MCStreamer &S) : PPCTargetStreamer(S) {}
 
   MCELFStreamer &getStreamer() {
     return static_cast<MCELFStreamer &>(Streamer);
   }
 
-  void emitTCEntry(const MCSymbol &S) override {
+  void emitTCEntry(const MCSymbol &Entry, const MCSymbol &Target) override {
     // Creates a R_PPC64_TOC relocation
     Streamer.EmitValueToAlignment(8);
-    Streamer.EmitSymbolValue(&S, 8);
+    Streamer.EmitSymbolValue(&Target, 8);
   }
 
   void emitMachine(StringRef CPU) override {
     // FIXME: Is there anything to do in here or does this directive only
     // limit the parser?
   }
 
   void emitAbiVersion(int AbiVersion) override {
bool copyLocalEntry(MCSymbolELF *D, const MCExpr *S) {
     return true;
   }
 };
 
 class PPCTargetMachOStreamer : public PPCTargetStreamer {
 public:
   PPCTargetMachOStreamer(MCStreamer &S) : PPCTargetStreamer(S) {}
 
-  void emitTCEntry(const MCSymbol &S) override {
+  void emitTCEntry(const MCSymbol &Entry, const MCSymbol &Target) override {
     llvm_unreachable("Unknown pseudo-op: .tc");
   }
 
   void emitMachine(StringRef CPU) override {
     // FIXME: We should update the CPUType, CPUSubType in the Object file if
     // the new values are different from the defaults.
   }
 
   void emitAbiVersion(int AbiVersion) override {
     llvm_unreachable("Unknown pseudo-op: .abiversion");
   }
 
   void emitLocalEntry(MCSymbolELF *S, const MCExpr *LocalOffset) override {
     llvm_unreachable("Unknown pseudo-op: .localentry");
   }
 };
 
 class PPCTargetXCOFFStreamer : public PPCTargetStreamer {
 public:
   PPCTargetXCOFFStreamer(MCStreamer &S) : PPCTargetStreamer(S) {}
 
-  void emitTCEntry(const MCSymbol &S) override {
-    report_fatal_error("TOC entries not supported yet.");
+  void emitTCEntry(const MCSymbol &Entry, const MCSymbol &Target) override {
+    // Object writing TOC entries not supported yet.
   }
 
   void emitMachine(StringRef CPU) override {
     llvm_unreachable("Machine pseudo-ops are invalid for XCOFF.");
   }
 
   void emitAbiVersion(int AbiVersion) override {
     llvm_unreachable("ABI-version pseudo-ops are invalid for XCOFF.");

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/CodeGen/MachineInstr.h"
 #include "llvm/CodeGen/MachineModuleInfoImpls.h"
 #include "llvm/CodeGen/MachineOperand.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
 #include "llvm/CodeGen/StackMaps.h"
 #include "llvm/CodeGen/TargetLoweringObjectFileImpl.h"
 #include "llvm/IR/DataLayout.h"
+#include "llvm/IR/GlobalObject.h"
 #include "llvm/IR/GlobalValue.h"
+#include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/Module.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstBuilder.h"
 #include "llvm/MC/MCSectionELF.h"
 #include "llvm/MC/MCSectionMachO.h"

 namespace {
 
 class PPCAsmPrinter : public AsmPrinter {
 protected:
   MapVector<const MCSymbol *, MCSymbol *> TOC;
   const PPCSubtarget *Subtarget = nullptr;
   StackMaps SM;
 
+  virtual MCSymbol *getMCSymbolForTOCPseudoMO(const MachineOperand &MO);
+
 public:
   explicit PPCAsmPrinter(TargetMachine &TM,
                          std::unique_ptr<MCStreamer> Streamer)
       : AsmPrinter(TM, std::move(Streamer)), SM(*this) {}
 
   StringRef getPassName() const override { return "PowerPC Assembly Printer"; }
 
   MCSymbol *lookUpOrCreateTOCEntry(const MCSymbol *Sym);
StringRef getPassName() const override {
     return "Darwin PPC Assembly Printer";
   }
 
   bool doFinalization(Module &M) override;
   void EmitStartOfAsmFile(Module &M) override;
 };
 
 class PPCAIXAsmPrinter : public PPCAsmPrinter {
+private:
+  void ValidateGV(const GlobalVariable *GV);
+protected:
+  MCSymbol *getMCSymbolForTOCPseudoMO(const MachineOperand &MO) override;
+
 public:
   PPCAIXAsmPrinter(TargetMachine &TM, std::unique_ptr<MCStreamer> Streamer)
       : PPCAsmPrinter(TM, std::move(Streamer)) {}
 
   StringRef getPassName() const override { return "AIX PPC Assembly Printer"; }
 
   void SetupMachineFunction(MachineFunction &MF) override;
 
EmitToStreamer(*OutStreamer,
                  MCInstBuilder(Subtarget->isPPC64() ?
                                PPC::BL8_NOP_TLS : PPC::BL_TLS)
                  .addExpr(TlsRef)
                  .addExpr(SymVar));
 }
 
 /// Map a machine operand for a TOC pseudo-machine instruction to its
 /// corresponding MCSymbol.
-static MCSymbol *getMCSymbolForTOCPseudoMO(const MachineOperand &MO,
-                                           AsmPrinter &AP) {
+MCSymbol *PPCAsmPrinter::getMCSymbolForTOCPseudoMO(const MachineOperand &MO) {
   switch (MO.getType()) {
   case MachineOperand::MO_GlobalAddress:
-    return AP.getSymbol(MO.getGlobal());
+    return getSymbol(MO.getGlobal());
   case MachineOperand::MO_ConstantPoolIndex:
-    return AP.GetCPISymbol(MO.getIndex());
+    return GetCPISymbol(MO.getIndex());
   case MachineOperand::MO_JumpTableIndex:
-    return AP.GetJTISymbol(MO.getIndex());
+    return GetJTISymbol(MO.getIndex());
   case MachineOperand::MO_BlockAddress:
-    return AP.GetBlockAddressSymbol(MO.getBlockAddress());
+    return GetBlockAddressSymbol(MO.getBlockAddress());
   default:
     llvm_unreachable("Unexpected operand type to get symbol.");
   }
 }
 
 /// EmitInstruction -- Print out a single PowerPC MI in Darwin syntax to
 /// the current output stream.
 ///
case PPC::LWZtoc: {
     // Change the opcode to LWZ.
     TmpInst.setOpcode(PPC::LWZ);
 
     const MachineOperand &MO = MI->getOperand(1);
     assert((MO.isGlobal() || MO.isCPI() || MO.isJTI() || MO.isBlockAddress()) &&
            "Invalid operand for LWZtoc.");
 
     // Map the operand to its corresponding MCSymbol.
-    const MCSymbol *const MOSymbol = getMCSymbolForTOCPseudoMO(MO, *this);
+    const MCSymbol *const MOSymbol = getMCSymbolForTOCPseudoMO(MO);
 
     // Create a reference to the GOT entry for the symbol. The GOT entry will be
     // synthesized later.
     if (PL == PICLevel::SmallPIC && !IsAIX) {
       const MCExpr *Exp =
         MCSymbolRefExpr::create(MOSymbol, MCSymbolRefExpr::VK_GOT,
                                 OutContext);
       TmpInst.getOperand(1) = MCOperand::createExpr(Exp);
case PPC::LDtoc: {
     const MachineOperand &MO = MI->getOperand(1);
     assert((MO.isGlobal() || MO.isCPI() || MO.isJTI() || MO.isBlockAddress()) &&
            "Invalid operand!");
 
     // Map the machine operand to its corresponding MCSymbol, then map the
     // global address operand to be a reference to the TOC entry we will
     // synthesize later.
     MCSymbol *TOCEntry =
-        lookUpOrCreateTOCEntry(getMCSymbolForTOCPseudoMO(MO, *this));
+        lookUpOrCreateTOCEntry(getMCSymbolForTOCPseudoMO(MO));
 
     const MCSymbolRefExpr::VariantKind VK =
         IsAIX ? MCSymbolRefExpr::VK_None : MCSymbolRefExpr::VK_PPC_TOC;
     const MCExpr *Exp =
         MCSymbolRefExpr::create(TOCEntry, VK, OutContext);
     TmpInst.getOperand(1) = MCOperand::createExpr(Exp);
     EmitToStreamer(*OutStreamer, TmpInst);
     return;
case PPC::ADDIStocHA: {
     // Change the opcode to ADDIS.
     TmpInst.setOpcode(PPC::ADDIS);
 
     const MachineOperand &MO = MI->getOperand(2);
     assert((MO.isGlobal() || MO.isCPI() || MO.isJTI() || MO.isBlockAddress()) &&
            "Invalid operand for ADDIStocHA.");
 
     // Map the machine operand to its corresponding MCSymbol.
-    MCSymbol *MOSymbol = getMCSymbolForTOCPseudoMO(MO, *this);
+    MCSymbol *MOSymbol = getMCSymbolForTOCPseudoMO(MO);
 
     // Always use TOC on AIX. Map the global address operand to be a reference
     // to the TOC entry we will synthesize later. 'TOCEntry' is a label used to
     // reference the storage allocated in the TOC which contains the address of
     // 'MOSymbol'.
     MCSymbol *TOCEntry = lookUpOrCreateTOCEntry(MOSymbol);
     const MCExpr *Exp = MCSymbolRefExpr::create(TOCEntry,
                                                 MCSymbolRefExpr::VK_PPC_U,
case PPC::LWZtocL: {
     // Change the opcode to lwz.
     TmpInst.setOpcode(PPC::LWZ);
 
     const MachineOperand &MO = MI->getOperand(1);
     assert((MO.isGlobal() || MO.isCPI() || MO.isJTI() || MO.isBlockAddress()) &&
            "Invalid operand for LWZtocL.");
 
     // Map the machine operand to its corresponding MCSymbol.
-    MCSymbol *MOSymbol = getMCSymbolForTOCPseudoMO(MO, *this);
+    MCSymbol *MOSymbol = getMCSymbolForTOCPseudoMO(MO);
 
     // Always use TOC on AIX. Map the global address operand to be a reference
     // to the TOC entry we will synthesize later. 'TOCEntry' is a label used to
     // reference the storage allocated in the TOC which contains the address of
     // 'MOSymbol'.
     MCSymbol *TOCEntry = lookUpOrCreateTOCEntry(MOSymbol);
     const MCExpr *Exp = MCSymbolRefExpr::create(TOCEntry,
                                                 MCSymbolRefExpr::VK_PPC_L,
case PPC::ADDIStocHA8: {
     // constant pool index with large code model enabled, then generate a TOC
     // entry and reference that. Otherwise, reference the symbol directly.
     TmpInst.setOpcode(PPC::ADDIS8);
 
     const MachineOperand &MO = MI->getOperand(2);
     assert((MO.isGlobal() || MO.isCPI() || MO.isJTI() || MO.isBlockAddress()) &&
            "Invalid operand for ADDIStocHA8!");
 
-    const MCSymbol *MOSymbol = getMCSymbolForTOCPseudoMO(MO, *this);
+    const MCSymbol *MOSymbol = getMCSymbolForTOCPseudoMO(MO);
 
     const bool GlobalToc =
         MO.isGlobal() && Subtarget->isGVIndirectSymbol(MO.getGlobal());
     if (GlobalToc || MO.isJTI() || MO.isBlockAddress() ||
         (MO.isCPI() && TM.getCodeModel() == CodeModel::Large))
       MOSymbol = lookUpOrCreateTOCEntry(MOSymbol);
 
     const MCSymbolRefExpr::VariantKind VK =
assert((MO.isGlobal() || MO.isCPI() || MO.isJTI() ||
             MO.isBlockAddress()) &&
            "Invalid operand for LDtocL!");
 
     LLVM_DEBUG(assert(
         (!MO.isGlobal() || Subtarget->isGVIndirectSymbol(MO.getGlobal())) &&
         "LDtocL used on symbol that could be accessed directly is "
         "invalid. Must match ADDIStocHA8."));
 
-    const MCSymbol *MOSymbol = getMCSymbolForTOCPseudoMO(MO, *this);
+    const MCSymbol *MOSymbol = getMCSymbolForTOCPseudoMO(MO);
 
     if (!MO.isCPI() || TM.getCodeModel() == CodeModel::Large)
       MOSymbol = lookUpOrCreateTOCEntry(MOSymbol);
 
     const MCSymbolRefExpr::VariantKind VK =
         IsAIX ? MCSymbolRefExpr::VK_PPC_L : MCSymbolRefExpr::VK_PPC_TOC_LO;
     const MCExpr *Exp =
         MCSymbolRefExpr::create(MOSymbol, VK, OutContext);
case PPC::ADDItocL: {
     const MachineOperand &MO = MI->getOperand(2);
     assert((MO.isGlobal() || MO.isCPI()) && "Invalid operand for ADDItocL.");
 
     LLVM_DEBUG(assert(
         !(MO.isGlobal() && Subtarget->isGVIndirectSymbol(MO.getGlobal())) &&
         "Interposable definitions must use indirect access."));
 
     const MCExpr *Exp =
-        MCSymbolRefExpr::create(getMCSymbolForTOCPseudoMO(MO, *this),
+        MCSymbolRefExpr::create(getMCSymbolForTOCPseudoMO(MO),
                                 MCSymbolRefExpr::VK_PPC_TOC_LO, OutContext);
     TmpInst.getOperand(2) = MCOperand::createExpr(Exp);
     EmitToStreamer(*OutStreamer, TmpInst);
     return;
   }
   case PPC::ADDISgotTprelHA: {
     // Transform: %xd = ADDISgotTprelHA %x2, @sym
     // Into:      %xd = ADDIS8 %x2, sym@got@tlsgd@ha
if (!TOC.empty()) {
     OutStreamer->SwitchSection(Section);
 
     for (const auto &TOCMapPair : TOC) {
       const MCSymbol *const TOCEntryTarget = TOCMapPair.first;
       MCSymbol *const TOCEntryLabel = TOCMapPair.second;
 
       OutStreamer->EmitLabel(TOCEntryLabel);
       if (isPPC64) {
-        TS.emitTCEntry(*TOCEntryTarget);
+        TS.emitTCEntry(*TOCEntryTarget,*TOCEntryTarget);
       } else {
         OutStreamer->EmitValueToAlignment(4);
         OutStreamer->EmitSymbolValue(TOCEntryTarget, 4);
       }
     }
   }
 
   return AsmPrinter::doFinalization(M);
void PPCAIXAsmPrinter::SetupMachineFunction(MachineFunction &MF) {
   MCSectionXCOFF *FnDescSec = OutStreamer->getContext().getXCOFFSection(
       CurrentFnDescSym->getName(), XCOFF::XMC_DS, XCOFF::XTY_SD,
       XCOFF::C_HIDEXT, SectionKind::getData());
   cast<MCSymbolXCOFF>(CurrentFnDescSym)->setContainingCsect(FnDescSec);
 
   return AsmPrinter::SetupMachineFunction(MF);
 }
 
-void PPCAIXAsmPrinter::EmitGlobalVariable(const GlobalVariable *GV) {
+void PPCAIXAsmPrinter::ValidateGV(const GlobalVariable *GV) {
   // Early error checking limiting what is supported.
   if (GV->isThreadLocal())
     report_fatal_error("Thread local not yet supported on AIX.");
 
   if (GV->hasSection())
     report_fatal_error("Custom section for Data not yet supported.");
 
   if (GV->hasComdat())
     report_fatal_error("COMDAT not yet supported by AIX.");
+}
+
+void PPCAIXAsmPrinter::EmitGlobalVariable(const GlobalVariable *GV) {
+  ValidateGV(GV);
+
+  // Create the symbol, set its storage class.
+  MCSymbolXCOFF *GVSym = cast<MCSymbolXCOFF>(getSymbol(GV));
+  GVSym->setStorageClass(
+      TargetLoweringObjectFileXCOFF::getStorageClassForGlobal(GV));
+
+  // Handle external global variables later.
+  if (!GV->hasInitializer()) {
+    return;
+  }
 
   SectionKind GVKind = getObjFileLowering().getKindForGlobal(GV, TM);
   if ((!GVKind.isCommon() && !GVKind.isBSS() && !GVKind.isData() &&
        !GVKind.isReadOnly()) ||
       GVKind.isMergeable2ByteCString() || GVKind.isMergeable4ByteCString() ||
       GVKind.isMergeableConst())
     report_fatal_error("Encountered a global variable kind that is "
                        "not supported yet.");
 
   // Create the containing csect and switch to it.
   MCSectionXCOFF *Csect = cast<MCSectionXCOFF>(
       getObjFileLowering().SectionForGlobal(GV, GVKind, TM));
   OutStreamer->SwitchSection(Csect);
-
-  // Create the symbol, set its storage class, and emit it.
-  MCSymbolXCOFF *GVSym = cast<MCSymbolXCOFF>(getSymbol(GV));
-  GVSym->setStorageClass(
-      TargetLoweringObjectFileXCOFF::getStorageClassForGlobal(GV));
   GVSym->setContainingCsect(Csect);
 
   const DataLayout &DL = GV->getParent()->getDataLayout();
 
   // Handle common symbols.
   if (GVKind.isCommon() || GVKind.isBSSLocal()) {
     unsigned Align =
       GV->getAlignment() ? GV->getAlignment() : DL.getPreferredAlignment(GV);
void PPCAIXAsmPrinter::EmitFunctionDescriptor() {
   // Emit function descriptor.
   OutStreamer->SwitchSection(
       cast<MCSymbolXCOFF>(CurrentFnDescSym)->getContainingCsect());
   OutStreamer->EmitLabel(CurrentFnDescSym);
   // Emit function entry point address.
   OutStreamer->EmitValue(MCSymbolRefExpr::create(CurrentFnSym, OutContext),
                          PointerSize);
   // Emit TOC base address.
-  MCSymbol *TOCBaseSym = OutContext.getOrCreateSymbol(StringRef("TOC[TC0]"));
+  const MCSectionXCOFF *TOCBaseSec = OutStreamer->getContext().getXCOFFSection(
+      StringRef("TOC"), XCOFF::XMC_TC0, XCOFF::XTY_SD, XCOFF::C_HIDEXT,
+      SectionKind::getData());
+  const MCSymbol *TOCBaseSym = TOCBaseSec->getQualNameSymbol();
   OutStreamer->EmitValue(MCSymbolRefExpr::create(TOCBaseSym, OutContext),
                          PointerSize);
   // Emit a null environment pointer.
   OutStreamer->EmitIntValue(0, PointerSize);
 
   OutStreamer->SwitchSection(Current.first, Current.second);
 }
 
 void PPCAIXAsmPrinter::EmitEndOfAsmFile(Module &M) {
   // If there are no functions in this module, we will never need to reference
   // the TOC base.
   if (M.empty())
     return;
 
   // Emit TOC base.
   MCSectionXCOFF *TOCBaseSection = OutStreamer->getContext().getXCOFFSection(
       StringRef("TOC"), XCOFF::XMC_TC0, XCOFF::XTY_SD, XCOFF::C_HIDEXT,
       SectionKind::getData());
   // Switch to section to emit TOC base.
   OutStreamer->SwitchSection(TOCBaseSection);
+
+  PPCTargetStreamer &TS =
+      static_cast<PPCTargetStreamer &>(*OutStreamer->getTargetStreamer());
+
+  for (auto &I : TOC) {
+    // Setup the Csect for the current TC entry.
+    MCSectionXCOFF *TCEntry = OutStreamer->getContext().getXCOFFSection(
+        cast<MCSymbolXCOFF>(I.first)->getUnqualifiedName(), XCOFF::XMC_TC,
+        XCOFF::XTY_SD, XCOFF::C_HIDEXT, SectionKind::getData());
+    cast<MCSymbolXCOFF>(I.second)->setContainingCsect(TCEntry);
+    OutStreamer->SwitchSection(TCEntry);
+
+    OutStreamer->EmitLabel(I.second);
+    TS.emitTCEntry(*TCEntry->getQualNameSymbol(),*I.first);
+  }
 }
 
+MCSymbol *
+PPCAIXAsmPrinter::getMCSymbolForTOCPseudoMO(const MachineOperand &MO) {
+  const GlobalObject *GO;
+  if (MO.getType() != MachineOperand::MO_GlobalAddress ||
+      !(GO = dyn_cast<const GlobalObject>(MO.getGlobal())))
+    return PPCAsmPrinter::getMCSymbolForTOCPseudoMO(MO);
+
+  const GlobalVariable *GV = dyn_cast<const GlobalVariable>(GO);
+  if (GV) {
+    ValidateGV(GV);
+
+    if (GV->hasInitializer()) {
+      SectionKind GVKind = getObjFileLowering().getKindForGlobal(GV, TM);
+      // If the operand is a common then we should refer to the csect symbol.
+      if (GVKind.isCommon() || GVKind.isBSSLocal()) {
+        MCSectionXCOFF *Csect = cast<MCSectionXCOFF>(
+            getObjFileLowering().SectionForGlobal(GV, GVKind, TM));
+        return Csect->getQualNameSymbol();
+      }
+    }
+  }
+
+  // If the MO is a function, we want to make sure to refer to the descriptor.
+  const Function *F = dyn_cast<const Function>(GO);
+
+  if (GV || F) {
+    MCSymbolXCOFF *XSym = cast<MCSymbolXCOFF>(getSymbol(GO));
+
+    // If the global value is a global variable with out initializer or is a
+    // declaration of a function, then MCSymbol XSym represents an external.
+    // Hence we may need to explictly create a MCSectionXCOFF for it.
+    if ((GV || F->isDeclaration()) && !XSym->hasContainingCsect()) {
+      // Make sure the storage class is set.
+      const XCOFF::StorageClass SC =
+          TargetLoweringObjectFileXCOFF::getStorageClassForGlobal(GO);
+      XSym->setStorageClass(SC);
+
+      MCSectionXCOFF *Csect = OutStreamer->getContext().getXCOFFSection(
+          XSym->getName(), GV ? XCOFF::XMC_UA : XCOFF::XMC_DS, XCOFF::XTY_ER,
+          SC, SectionKind::getMetadata());
+      XSym->setContainingCsect(Csect);
+
+      return Csect->getQualNameSymbol();
+    }
+
+    return XSym->getContainingCsect()->getQualNameSymbol();
+  }
+
+  return PPCAsmPrinter::getMCSymbolForTOCPseudoMO(MO);
+}
 
 /// createPPCAsmPrinterPass - Returns a pass that prints the PPC assembly code
 /// for a MachineFunction to the given output stream, in a format that the
 /// Darwin assembler can deal with.
 ///
 static AsmPrinter *
 createPPCAsmPrinterPass(TargetMachine &tm,
                         std::unique_ptr<MCStreamer> &&Streamer) {
   if (tm.getTargetTriple().isMacOSX())

llvm/lib/Target/PowerPC/PPCMCInstLower.cpp

static MCSymbol *GetSymbolFromOperand(const MachineOperand &MO,
   } else {
     const GlobalValue *GV = MO.getGlobal();
     TM.getNameWithPrefix(Name, GV, Mang);
   }
 
   Name += Suffix;
   MCSymbol *Sym = Ctx.getOrCreateSymbol(Name);
 
+
   // If the symbol reference is actually to a non_lazy_ptr, not to the symbol,
   // then add the suffix.
   if (MO.getTargetFlags() & PPCII::MO_NLP_FLAG) {
     MachineModuleInfoMachO &MachO = getMachOMMI(AP);
 
     MachineModuleInfoImpl::StubValueTy &StubSym = MachO.getGVStubEntry(Sym);
 
     if (!StubSym.getPointer()) {

llvm/lib/Target/PowerPC/PPCTargetStreamer.h

 class MCSymbol;
 class MCSymbolELF;
 
 class PPCTargetStreamer : public MCTargetStreamer {
 public:
   PPCTargetStreamer(MCStreamer &S);
   ~PPCTargetStreamer() override;
 
-  virtual void emitTCEntry(const MCSymbol &S) = 0;
+  virtual void emitTCEntry(const MCSymbol &Entry, const MCSymbol &Target) = 0;
   virtual void emitMachine(StringRef CPU) = 0;
   virtual void emitAbiVersion(int AbiVersion) = 0;
   virtual void emitLocalEntry(MCSymbolELF *S, const MCExpr *LocalOffset) = 0;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_LIB_TARGET_POWERPC_PPCTARGETSTREAMER_H

llvm/test/CodeGen/PowerPC/aix-lower-block-address.ll

 
 ; 64LARGE-ASM-LABEL: foo
 ; 64LARGE-ASM: .foo:
 ; 64LARGE-ASM: Ltmp0:
 ; 64LARGE-ASM:         addis [[REG1:[0-9]+]], LC0@u(2)
 ; 64LARGE-ASM:         ld [[REG2:[0-9]+]], LC0@l([[REG1]])
 
 ; CHECK: .toc
-; CHECK-NOT: .tc
+; CHECK: .tc Ltmp0[TC],Ltmp0

llvm/test/CodeGen/PowerPC/aix-lower-constant-pool-index.ll

 ; 64LARGE-ASM:         .long   1085276160
 ; 64LARGE-ASM: .test_float:
 ; 64LARGE-ASM:         addis [[REG1:[0-9]+]], LC0@u(2)
 ; 64LARGE-ASM:         ld [[REG2:[0-9]+]], LC0@l([[REG1]])
 ; 64LARGE-ASM:         lfs 1, 0([[REG2]])
 ; 64LARGE-ASM:         blr
 
 ; CHECK: .toc
-; CHECK-NOT: .tc
+; CHECK: .tc .LCPI0_0[TC],.LCPI0_0

llvm/test/CodeGen/PowerPC/aix-lower-jump-table.ll

 ; 64LARGE-ASM:      .align  2
 ; 64LARGE-ASM: .LJTI0_0:
 ; 64LARGE-ASM:      .long   LBB0_2-.LJTI0_0
 ; 64LARGE-ASM:      .long   LBB0_3-.LJTI0_0
 ; 64LARGE-ASM:      .long   LBB0_4-.LJTI0_0
 ; 64LARGE-ASM:      .long   LBB0_5-.LJTI0_0
 
 ; CHECK: .toc
-; CHECK-NOT: .tc
+; CHECK: .tc .LJTI0_0[TC],.LJTI0_0

llvm/test/CodeGen/PowerPC/aix-xcoff-data-only-notoc.ll

+; RUN: llc -mtriple powerpc-ibm-aix-xcoff < %s | FileCheck %s
+; RUN: llc -mtriple powerpc64-ibm-aix-xcoff < %s 2>&1 | FileCheck %s
+
+@a = external global i32, align 4
+@b = external global i64, align 8
+@c = external global i16, align 2
+@globa = common global i32 0, align 4
+
+@ptr = internal global void (...)* null, align 4
+
+; CHECK-NOT: .toc
+

llvm/test/CodeGen/PowerPC/aix-xcoff-toc.ll

+; RUN: llc  -verify-machineinstrs -mcpu=pwr7 -mtriple powerpc-ibm-aix-xcoff < %s | FileCheck --check-prefixes CHECK,CHECK32 %s
+; RUN: llc  -verify-machineinstrs -mcpu=pwr7 -mtriple powerpc64-ibm-aix-xcoff < %s 2>&1 | FileCheck --check-prefixes CHECK,CHECK64  %s
+
+@a = external global i32, align 4
+@b = external global i64, align 8
+@c = external global i16, align 2
+@globa = common global i32 0, align 4
+
+@ptr = internal global void (...)* null, align 4
+
+declare void @foo()
+
+define void @bar() {
+  %1 = alloca i8*, align 8
+  store i32 0, i32* @a, align 4
+  store i64 0, i64* @b, align 8
+  store i16 0, i16* @c, align 2
+  store i32 0, i32* @globa, align 4
+  store void (...)* bitcast (void ()* @bar to void (...)*), void (...)** @ptr, align 4
+  store i8* bitcast (void ()* @foo to i8*), i8** %1, align 8
+  ret void
+}
+
+; CHECK-NOT: .comm a
+; CHECK-NOT: .lcomm a
+; CHECK-NOT: .comm b
+; CHECK-NOT: .lcomm b
+; CHECK-NOT: .comm c
+; CHECK-NOT: .lcomm c
+; CHECK: .comm globa[RW],4,2
+; CHECK32: .lcomm ptr,4,ptr[BS],2
+; CHECK64: .lcomm ptr,8,ptr[BS],2
+; CHECK:      .toc
+; CHECK-NEXT: LC0:
+; CHECK-NEXT: .tc   a[TC],a[UA]
+; CHECK-NEXT: LC1:
+; CHECK-NEXT: .tc   b[TC],b[UA]
+; CHECK-NEXT: LC2:
+; CHECK-NEXT: .tc   c[TC],c[UA]
+; CHECK-NEXT: LC3:
+; CHECK-NEXT: .tc   globa[TC],globa[RW]
+; CHECK-NEXT: LC4:
+; CHECK-NEXT: .tc   ptr[TC],ptr[BS]
+; CHECK-NEXT: LC5:
+; CHECK-NEXT: .tc   bar[TC],bar[DS]
+; CHECK-NEXT: LC6:
+; CHECK-NEXT: .tc   foo[TC],foo[DS]
+

llvm/test/CodeGen/PowerPC/lower-globaladdr32-aix-asm.ll

 ; SMALL: blr
 
 ; LARGE-LABEL: .test_store:{{$}}
 ; LARGE: addis [[REG1:[0-9]+]], LC1@u(2)
 ; LARGE: lwz [[REG2:[0-9]+]], LC1@l([[REG1]])
 ; LARGE: stw [[REG3:[0-9]+]], 0([[REG2]])
 ; LARGE: blr
 
-; TODO Update test when TOC-entry emission lands.
-; CHECK-NOT: .tc
+; CHECK: .tc a[TC],a
+; CHECK: .tc b[TC],b

llvm/test/CodeGen/PowerPC/lower-globaladdr64-aix-asm.ll

 ; SMALL: blr
 
 ; LARGE-LABEL: .test_store:{{$}}
 ; LARGE: addis [[REG1:[0-9]+]], LC1@u(2)
 ; LARGE: ld [[REG2:[0-9]+]], LC1@l([[REG1]])
 ; LARGE: stw [[REG3:[0-9]+]], 0([[REG2]])
 ; LARGE: blr
 
-; TODO Update test when TOC-entry emission lands.
-; CHECK-NOT: .tc
+; CHECK: .tc a[TC],a
+; CHECK: .tc b[TC],b