[AIX]Emit function descriptor csect in assembly

[Xiangling_L]

Summary

This patch emits the function descriptor csect for functions with definitions under both 32-bit/64-bit mode on AIX.

During PPCAIXAsmPrinter::EmitFunctionEntryLabel we emit the csect for each function descriptor.

[xingxue]

This patch needs a rebase.

[sfertile]

llvm/include/llvm/MC/MCAsmInfo.h

321

True if we have a .lglobl directive. This is used to emit .lglobl .foo for static function on AIX.

Doesn't explain what .lglobal does. Instead I would suggest something along the lines of:

True if we have a .lglobl directive, which is used to emit the information of a static symbol into the symbol table. Defaults to false.

400

nit: NeedsFunctionDescriptors instead?

llvm/lib/MC/MCSectionXCOFF.cpp

27

A report_fatal_error is probably more appropriate until we have added all the storage mapping classes.

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1740

minor nit: Size --> PointerSize

[Xiangling_L]

Rebase on latest master

[Xiangling_L]

Address 1st round reviews

[jasonliu]

llvm/lib/MC/MCSectionXCOFF.cpp

27

This marked done, but haven't really addressed.

[xingxue]

llvm/lib/MC/MCSectionXCOFF.cpp

27

In my committed patch https://reviews.llvm.org/D66154, the llvm_unreachable() here was replaced with assert() under Hubert's suggestion, which makes sense to me.

[sfertile]

llvm/lib/MC/MCSectionXCOFF.cpp

27

I'm OK with assert as well.

[hubert.reinterpretcast]

llvm/lib/MC/MCSectionXCOFF.cpp

27

The other patch did not invoke undefined behaviour if the assertion failed. This patch does (there is no return statement following the llvm_unreachable). report_fatal_error makes sense. Also, we should indicate "Unhandled storage-mapping class." "Unsupported" has proven itself to be confusing.

[Xiangling_L]

Update llvm_unreachable to report_fatal_error

[Xiangling_L]

minor changes

[jasonliu]

llvm/include/llvm/CodeGen/AsmPrinter.h

116

For the current patch, we use CurrentFnSym to represent function entry point on AIX, meaning '.' + function name. And we use this new data member to represent function descriptor on AIX.
It seems a bit inconsistent with the current usage of CurrentFnSym, as other target seems to use CurrentFnSym for the similar purpose of a function descriptor on AIX.
And we have a CurrentFnSymForSize down below which seems only used by ELFv1 abi, and the way it is used in code right now seems to match what we want for a function entry point.
So I'm wondering if it is possible to use CurrentFnSym to represent function descriptor on AIX, and rename CurrentFnSymForSize to be CurrentFnEntryPoint so that it could use on ELFv1 and AIX. In this way, we could avoid creating another target specific data member, and have a more general MCSymbol for this similar kind of purpose.

[Xiangling_L]

llvm/include/llvm/CodeGen/AsmPrinter.h

116

The CurrentFnSym is supposed to be used as the entry point of function on all targets. This patch follows this convention, so a new symbol CurrentFnDescSym is created for AIX.

[jasonliu]

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

1671

const ?

1678

Could reuse SecName here? Maybe rename SecName to be FnDescSymName.

1680

Function &F could get reused by line 1662.

1681

const here as well?

[jasonliu]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1772

We would emit the TOC anchor every time even if we don't need it.
I think we should do the SwitchSection in EmitEndOfAsmFile. We would only emit TOC anchor if there is a function definition in the module.
Then a later on patch could implement the emitTCEntry in that same function.

[jasonliu]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1740

const

[jasonliu]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1744

The const_cast is interesting here. It makes me question if we have the right interface for getContainingCsect().
Maybe the getter function should return a non-const MCSectionXCOFF instead? Since SwitchSection could call Section.setIsRegistered(true) which actually modifies that MCSectionXCOFF. Would it be undefined behavior? Please correct me if I'm wrong...

[Xiangling_L]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1744

I had this doubt too, we can discussed more in the meeting.

1772

Yes, it's a better idea to emit in EmitEndOfAsmFile. Though a little concern is that I look through this function descriptor patch again, and I think actually we seems don't have to emit .toc in this patch, but it makes more sense to put this part together with emit TC entry patch. Since even if this patch does emit TC0 in function descriptor, we create it by using the enum value MCSymbolRefExpr::VK_PPC_TOC_TC0.

And by doing so, we can unwind the emitTCEntry patch from the dependency of this one. I can do CHECK-NOT: .tc and CHECK-NOT: .toc, then whichever patch lands later, can update testcases.

But of course, if you still think we want to have .toc emitted in this patch, I would be happy to update the patch.

[Xiangling_L]

1. Emit .toc at the end of asm file

2. remove "const" from get/set containing csect

[Xiangling_L]

update testcase

[jasonliu]

llvm/lib/MC/MCExpr.cpp

445 ↗

(On Diff #218576)

I don't quite like how we do the special case here just for VK_PPC_TOC_TC0 kind.
Not sure if we can do something better. Or we could leave it like this for now, and if we find other MCSymbolRefExpr like this, we could common them up.
Any thoughts, @sfertile @hubert.reinterpretcast ?

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1747

Minor nit: add a comment before this line
Emit TOC base address.

1765

Minor nit for the naming here:
We seems to use TOC anchor and TOC base to indicate the same thing interchangeably.
It might be better to use one term through out. In the assembler guide for AIX, we use TOC anchor only.
However, in llvm source, we use TOC base instead.
So maybe it's better to just be consistent with the existing source, and use the term TOC base?
Some suggestions on the naming:
Rename TOC to TOCStr
Rename TOCAnchor to TOCBaseSec

1771

Minor nit: emit TOC base.

[sfertile]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1762

There may be symbol references we could emit in assembly that require a TOC-base. Its not really an issue now but it may be once we implement the integrated assembler for AIX. I'm not sure if its better to be sloppy and simply always emit a TOC-base (an unused one would be benign ...)

[sfertile]

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

1663–1681

The code for creating the entry point and descriptor symbols and their csects looks good, I don't think it needs any changes for functionality/correctness. I have a suggestion related to style though. We are inserting about 20 lines of AIX specific implementation details into a constructor thats only about 15 lines long before the change. Most developers that read this won't care about the AIX specific details, should we split the AIX entry point and descriptor setup into some helper functions? Something like

if ((MAI->needsFunctionDescriptors()) {
   assert(TM.getTargetTriple().isOSAIX() && "Function descriptor is only"
                                             " supported on AIX.");
  CurrentFnDescSym = getAIXDescriptorSymbol(MF.getFunction(), OutStreamer->getContext());
  CurrentFnSym = getAIXEntryPointSymbol(MF.getFunction(),  cast<MCSectionXCOFF>(getObjFileLowering(), TM);
} else {

keeps this function very readable by having descriptive helper functions bury the implementation details.

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1764

if (M.empty())
  return;

Prefer an early return to nesting all the code inside an if statement.

llvm/test/CodeGen/PowerPC/test_func_desc.ll

16

This IR is overly verbose, could we replace it with

%1 = call i32 @foo()
%2 = call i32 @foo_extern()
%3 = call i32 @foo_static()
%4 = add nsw i32 %1, %2
%5 = add nsw i32 %4, %3
ret i32 %5

(If I'm missing something from the test, you can generate less verbose IR by feeding this through opt -S -mem2reg)

60

should this be main:? I believe we are checking for label for the symbol main.

75

ditto. (static_foo:)

[sfertile]

llvm/lib/MC/MCExpr.cpp

445 ↗

(On Diff #218576)

I'm not aware of any other square brackets used in symbol references on AIX, but I'm still pretty new to AIX assembly so that doesn't mean there isn't any.

We *could* add a bitfield to the MCSymbolRefExpr (similar to the UseParensForSymbolVariant field, but then we likely just have the same 'if' in the SymbolRef constructor to set the new bitfield.

[jasonliu]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1762

I have a slight preference on emitting TOC-base on a needed base, and deal with the issue that integrated assembler introduce when we see one. In this way, we know exactly when we need to emit TOC-base and when not.
And yes, an unused TOC-base would just get garbage collected by linker; GCC on AIX would also always emit a TOC-base. Hence, it's a slight preference on my side.

[DiggerLin]

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

670

if we can use if (TM.getTargetTriple().isOSAIX() && here, we do not need needsFunctionDescriptors() function and variable needsFunctionDescriptors?

1663–1681

1. why using "if (MAI->needsFunctionDescriptors()) " here . can we using if(TM.getTargetTriple().isOSAIX) { here. I think for all aix assembly, they all need function description . and then we can delete the needsFunctionDescriptors from the patch ? and we can also delete assert(TM.getTargetTriple().isOSAIX() && "Function descriptor is only supported on AIX.");
2. I have another suggestion is that we make void PPCAIXAsmPrinter::SetupMachineFunction(MachineFunction &MF) as virtual function(and keep the content), and add new function AsmPrinter::SetupMachineFunction(MachineFunction &MF), put the new content in the PPCAIXAsmPrinter::SetupMachineFunction(MachineFunction &MF).

llvm/lib/MC/MCSectionXCOFF.cpp

20

since we will have a lot of StorageMappingClass value, can we use a macro like
#define ECASE(X) case XCOFF::XMC_##X: return #X
switch (SMC) {

ECASE(DS);
ECASE(RW);

}

or we can use array StorageMappingClassArray = {"PR", "RO","DB".......,"TE"};
return StorageMappingClassArray [SMC];

it maybe more simple or readable.

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1755

from the begin of the function to here, it actually emit a function description, can we add a new function and put the content into the new function and invoke the new function here ?

[hubert.reinterpretcast]

llvm/include/llvm/MC/MCExpr.h

238 ↗

(On Diff #218576)

The comment is meant to express what the variant looks like when printed (thus, @ does not match). In any case, I have doubts that this is the correct way to represent [TC0]. We can look at TOC[TC0] as referring less to the symbol, but more referring to the csect. In any case, the TC0 is the storage mapping class, which we have been using uppercase for.

[sfertile]

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

1663–1681

@DiggerLin wrote:

why using "if (MAI->needsFunctionDescriptors()) " here . can we using if(TM.getTargetTriple().isOSAIX) { here. I think for all aix assembly, they all need function description . and then we can delete the needsFunctionDescriptors from the patch ?

From the description of the MCAsmInfo class:

/// This class is intended to be used as a base class for asm
/// properties and features specific to the target.

Adding a hook to MAI for descriptors and querying that is a valid way to represent this. That said, there are other places in this file that change the codegen based on explicit check of either the OS or the binary format. Personally I slightly prefer the way the patch is doing this already mainly because needsFunctionDescriptors() makes the code self-documenting as opposed to getTargetTriple().isOSAIX().

@DiggerLin wrote:

2. I have another suggestion is that we make void PPCAIXAsmPrinter::SetupMachineFunction(MachineFunction &MF) as virtual function ...

This suggestion of making SetupMachineFunction virtual is better then my suggestion of a local helper function.

[sfertile]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1755

A good suggestion. I think we should take it a bit farther though. Add an AsmPrinter::EmitDescriptor() virtual function. Calling the base class implementation should be a fatal_error. Then somewhere we can explicitly check the MCAsmInfo if descriptors are needed, and call this new virtual if they are. My suggestion would be in runOnMachineFunction.

[hubert.reinterpretcast]

> cat toccommon.c
int TOC;
void f(void) { }

> ./bin/clang toccommon.c -target powerpc64-ibm-aix -m32 -fomit-frame-pointer -S
clang-10: /redacted/llvm/include/llvm/MC/MCSymbolXCOFF.h:41: void llvm::MCSymbolXCOFF::setContainingCsect(llvm::MCSectionXCOFF*): Assertion `(!ContainingCsect || ContainingCsect == C) && "Trying to set a containing csect that doesn't match the one that" "this symbol is already mapped to."' failed.

[Xiangling_L]

llvm/include/llvm/MC/MCExpr.h

238 ↗

(On Diff #218576)

Thanks, I will update the comment. But I verified on AIX with Clangtana and GCC, it's TOC[tc0] as TOC base address in function descriptor.

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

670

Yes, querying target will lead to correct result as well, but using MAI->needsFunctionDescriptors() is the way that we embed target-specific feature to target-independent file AsmPrinter.cpp and I think it is more self-explanatory.

llvm/lib/MC/MCSectionXCOFF.cpp

20

I like your idea to make this snippet of code simpler and more readable. But it seems that StorageMappingClassArray cannot handle report_fatal_error situation. And personally, I feel it's okay to keep it this way by wasting a little bit more space rather than spending time searching and reading macro.

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1755

Some description of function EmitFunctionEntryLabel():

This is a virtual function to allow targets to do their wild and crazy things as required.

So my understanding is on AIX, we use this function to emit function descriptor as the comment specifies.

1762

Currently, I prefer leaving it to emit .toc when needed as Jason said we may want to know exactly when we need to emit TOC anchor. But I will leave this discussion open and see if there are more input about this.

[Xiangling_L]

Address 2nd round comments

[Xiangling_L]

Chang TOC base section name to ".toc" and fix testcase assertion error

[Xiangling_L]

Minor changes

[hubert.reinterpretcast]

llvm/include/llvm/MC/MCExpr.h

238 ↗

(On Diff #218576)

XL generates TOC{TC0}, not TOC[tc0].

[hubert.reinterpretcast]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1770

Why are we naming a symbol .toc here and not really doing anything with it here or elsewhere in the patch?

1772

The csect name is "TOC" in the symbol table, but we're naming it .toc. here.

[hubert.reinterpretcast]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1697

Please add a comment to explain why this does not call the base class version of SetupMachineFunction and instead has some copy/paste. Alternatively, call the base class version if possible.

[hubert.reinterpretcast]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1747

This comment is in the wrong place. The comment for this line should be "[e]mit entry point address".

1750

I do not believe that the TOC base is a variant of unrelated symbols coincidentally named "TOC".

llvm/test/CodeGen/PowerPC/test_func_desc.ll

3

--check-prefixes=CHECK,32BIT

6

Ditto.

61

This is technically not needed for this case, and XL does not generate this unnecessary function descriptor.

[sfertile]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1755

I think we are pushing past the limits of what the comment intended. I take it to mean 'the wild and crazy function entry point things`. The way the ELF V1 abi handles descriptors (with the entry point being a local symbol, and the descriptor being the global symbol) it kindof squeaks into this definition. For AIX we are emitting 2 distinct symbols, one of which has no relation to the function entry point symbol other then referencing its address.

1770

Do we need a TOC symbol to represent the TOC base? Is the TOC base a csect with no contained symbol, or is it similar to the common csects where there is an implicit symbol with the same name contained in the csect? It seems like we really only need the symbol for our internal MC representation, in which case the name doesn't matter outside of being unique and not clashing with anything in the users namespace.

[sfertile]

llvm/include/llvm/MC/MCExpr.h

238 ↗

(On Diff #218576)

According to the assembly language ref:

A qualname operand takes the form of:
symbol[XX]
OR
symbol{XX}

So both bracketing formats are acceptable, I believe we have been using '[XX]' so far in llvm.

The assembly language ref also uses both uppercase and lowercase spellings for the storage mapping class, but I believe we have used uppercase exclusively so far in llvm.

[hubert.reinterpretcast]

llvm/include/llvm/MC/MCExpr.h

238 ↗

(On Diff #218576)

Yes, and the group of comments was regarding the capitalization. The comment indicating the bracketing used was a counterexample to the response made to my comment regarding the capitalization.

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1750

Jason and I discussed this off-list, and we believe this to be too much of a hack. In the long term, we probably need some way to separate things that are defined as a label (or QualName without a storage mapping class) from things that are defined by a QualName that has a storage mapping class (like TOC entries). The way a reference should be written in the assembly depends on the form of the definition. One of the decisions to be made is whether they are all MCSymbols or only some of them are MCSymbols. If they are all MCSymbols then we need to differentiate them on more than just the plain name. As far as the system assembler behaviour is concerned, even the name and storage mapping class is not sufficiently unique (it is possible to generate an external reference to a symbol whose name and storage mapping class is the same as another symbol in the assembler source file). A compromise that might be okay for now is to write the csect reference using a symbol named "TOC[TC0]".

1770

Since this needs a QualName with the storage mapping class for referencing in the assembly, it is more the former (a csect with no contained symbol).

Note that we could choose to use a QualName with the storage mapping class for the .comm-produced csects too, but references to the csect need to match the form used on the .comm pseudo-op. Since the form used on the .comm pseudo-op affects how references look, I think not using the QualName is the right behaviour in terms of being the least surprising.

As for the question of whether we need a symbol to represent the TOC base, I think the question is better asked with regards to how we want to represent references to the TOC base in the MC representation, the mechanism for generating the symbol table entry in the binary emission, and how we will make those references refer to the correct symbol table entry in the binary emission.

[DiggerLin]

llvm/include/llvm/MC/MCSymbolXCOFF.h

38

why delete const here ?

[jasonliu]

llvm/include/llvm/MC/MCSymbolXCOFF.h

38

Please refer to the const_cast comment I made earlier.

[Xiangling_L]

llvm/test/CodeGen/PowerPC/test_func_desc.ll

61

Yes, this function descriptor is unnecessary. But I vaguely recall that we decided the optimization of function descriptor generation would not be taken into consideration temporarily. So I am thinking is that okay to leave it as it is, and remove this part when we have optimization implemented?

[hubert.reinterpretcast]

llvm/test/CodeGen/PowerPC/test_func_desc.ll

61

Sure.

[Xiangling_L]

Address comments

[Xiangling_L]

add EmitFunctionDescriptor()

[Xiangling_L]

Delete "EmitFunctionEntryLabel()" target-specific one for AIX

[jasonliu]

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

769

This could be done in the header instead. People could know it's a platform specific thing when reading the header, no need to jump to the source file.
Also I think we could use llvm_unreachable in this situation instead to get minor optimization advantage, but no big deal.

llvm/lib/MC/MCAsmInfoXCOFF.cpp

37

We used isValidUnquotedName when printing symbol name in this context:
...

StringRef Name = getName();
if (!MAI || MAI->isValidUnquotedName(Name)) {
  OS << Name;
  return;
}

if (MAI && !MAI->supportsNameQuoting())
  report_fatal_error("Symbol name with unsupported characters");

...

If we always return true for isValidUnquotedName then we won't be able to detect symbol name with unsupported characters.
On that note, we should probably set SupportsQuotedNames to be false for AIX target.
Using TOC[TC0] as symbol name is kinda a hack since XCOFF symbol could not contain '[' AFAIK.
So maybe we would override isValidUnquotedName and make it very similar to the original one, except '[' is a valid Name temporarily. Add a FIXME to say remove this whole function when we don't use TOC[TC0] as symbol any more.

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1739

Minor nit: we don't need the "return".

[hubert.reinterpretcast]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1739

I do not believe there is definitive coding standard guidance on this, but when deferring the rest of the control flow and the return value in a function to another function, using return is my preference even in the case of returning void (if both the caller and callee return void).

[Xiangling_L]

Edit isValidUnquotedName to return true only for TOC symbol '"TOC[TC0]" on AIX

[jasonliu]

LGTM with some minor change.

Should SupportsQuotedNames return false on AIX?

llvm/lib/MC/MCAsmInfoXCOFF.cpp

38

nit: remove space in " TOC[TC0]".

[Xiangling_L]

minor changes

[hubert.reinterpretcast]

llvm/lib/MC/MCAsmInfoXCOFF.cpp

30

Minor nit: Add "a" before "symbol name". Capitalize "remove".
Change "don't use [ ... ] anymore" to "stop using [ ... ]".

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1699

I think the base class SetupMachineFunction might be usable if it called two functions in order to setup a function descriptor symbol as necessary, and then retrieve the entry point symbol. Although the copy/paste is currently one line, it might grow in the future.

1770

Please name the section "TOC" and not "TOC[TC0]". The section name is not used by the assembly generation, but we might find a use for it for the object generation.

[Xiangling_L]

Refactor the "SetupMachineFunction" to make it usable as a base class version.

[hubert.reinterpretcast]

llvm/include/llvm/CodeGen/AsmPrinter.h

115

runOnMachineFunction reference seems out-of-date with the current patch.

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

1665

Assert also that CurrentFnDescSym is set.

llvm/lib/MC/MCAsmInfoXCOFF.cpp

30

s/remove/Remove/;
s/any more//;

[Xiangling_L]

Correct some comments;
Add an assertion for CurrentFnDescSym.

[hubert.reinterpretcast]

LGTM. Thanks.

[Xiangling_L]

In D66724#1684292, @hubert.reinterpretcast wrote:

LGTM. Thanks.

Thank you for your reviews.

[MaskRay]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1755

Reading the generic AsmPrinter code, when if (MAI->needsFunctionDescriptors()) made me a bit sad.

I am not sure this "pushing past the limits of what the comment intended" was a strong argument for EmitFunctionDescriptor and needsFunctionDescriptors(). This is the way all other targets (AMDGPUAsmPrinter, ARMAsmPrinter, MipsAsmPrinter, NVPTXAsmPrinter, PPCLinuxAsmPrinter, and XCoreAsmPrinter) handle things. AIX does not have to be an exception.

If needsFunctionDescriptors() is really AIX specific, I feel that TM.getTargetTriple().isOSAIX() will made a casual reader's life simpler. I did not know what function descriptors are and jumped over hoops to know this is really AIX specific. We can add the abstraction when more targets use it.

Please see D72989.

llvm/include/llvm/CodeGen/AsmPrinter.h

public:
 
   /// Optimization remark emitter.
   MachineOptimizationRemarkEmitter *ORE;
 
   /// The symbol for the current function. This is recalculated at the beginning
   /// of each call to runOnMachineFunction().
   MCSymbol *CurrentFnSym = nullptr;
 
+  /// The symbol for the current function descriptor on AIX. This is created
+  /// at the beginning of each call to SetupMachineFunction().
+  MCSymbol *CurrentFnDescSym = nullptr;
+
   /// 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 = nullptr;
 
   /// Map global GOT equivalent MCSymbols to GlobalVariables and keep track of
   /// its number of uses by other globals.
   using GOTEquivUsePair = std::pair<const GlobalVariable *, unsigned>;
public:
   }
 
   //===------------------------------------------------------------------===//
   // Coarse grained IR lowering routines.
   //===------------------------------------------------------------------===//
 
   /// This should be called when a new MachineFunction is being processed from
   /// runOnMachineFunction.
-  void SetupMachineFunction(MachineFunction &MF);
+  virtual void SetupMachineFunction(MachineFunction &MF);
 
   /// This method emits the body and trailer for a function.
   void EmitFunctionBody();
 
   void emitCFIInstruction(const MachineInstr &MI);
 
   void emitFrameAlloc(const MachineInstr &MI);
 
virtual void EmitInstruction(const MachineInstr *) {
     llvm_unreachable("EmitInstruction not implemented");
   }
 
   /// Return the symbol for the specified constant pool entry.
   virtual MCSymbol *GetCPISymbol(unsigned CPID) const;
 
   virtual void EmitFunctionEntryLabel();
 
+  virtual void EmitFunctionDescriptor() {
+    llvm_unreachable("Function descriptor is target-specific.");
+  }
+
   virtual void EmitMachineConstantPoolValue(MachineConstantPoolValue *MCPV);
 
   /// Targets can override this to change how global constants that are part of
   /// a C++ static/global constructor list are emitted.
   virtual void EmitXXStructor(const DataLayout &DL, const Constant *CV) {
     EmitGlobalConstant(DL, CV);
   }
 

llvm/include/llvm/MC/MCAsmInfo.h

protected:
   /// True if we have a directive to declare a global as being a weak defined
   /// symbol that can be hidden (unexported).  Defaults to false.
   bool HasWeakDefCanBeHiddenDirective = false;
 
   /// True if we have a .linkonce directive.  This is used on cygwin/mingw.
   /// Defaults to false.
   bool HasLinkOnceDirective = false;
 
+  /// True if we have a .lglobl directive, which is used to emit the information
+  /// of a static symbol into the symbol table. Defaults to false.
+  bool HasDotLGloblDirective = false;
+
   /// This attribute, if not MCSA_Invalid, is used to declare a symbol as having
   /// hidden visibility.  Defaults to MCSA_Hidden.
   MCSymbolAttr HiddenVisibilityAttr = MCSA_Hidden;
 
   /// 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;
 
protected:
   // If true, emit GOTPCRELX/REX_GOTPCRELX instead of GOTPCREL, on
   // X86_64 ELF.
   bool RelaxELFRelocations = true;
 
   // If true, then the lexer and expression parser will support %neg(),
   // %hi(), and similar unary operators.
   bool HasMipsExpressions = false;
 
+  // If true, emit function descriptor symbol on AIX.
+  bool NeedsFunctionDescriptors = false;
+
 public:
   explicit MCAsmInfo();
   virtual ~MCAsmInfo();
 
   /// Get the code pointer size in bytes.
   unsigned getCodePointerSize() const { return CodePointerSize; }
 
   /// Get the callee-saved register stack slot
public:
   bool hasWeakDefDirective() const { return HasWeakDefDirective; }
 
   bool hasWeakDefCanBeHiddenDirective() const {
     return HasWeakDefCanBeHiddenDirective;
   }
 
   bool hasLinkOnceDirective() const { return HasLinkOnceDirective; }
 
+  bool hasDotLGloblDirective() const { return HasDotLGloblDirective; }
+
   MCSymbolAttr getHiddenVisibilityAttr() const { return HiddenVisibilityAttr; }
 
   MCSymbolAttr getHiddenDeclarationVisibilityAttr() const {
     return HiddenDeclarationVisibilityAttr;
   }
 
   MCSymbolAttr getProtectedVisibilityAttr() const {
     return ProtectedVisibilityAttr;
void setCompressDebugSections(DebugCompressionType CompressDebugSections) {
     this->CompressDebugSections = CompressDebugSections;
   }
 
   bool shouldUseLogicalShr() const { return UseLogicalShr; }
 
   bool canRelaxRelocations() const { return RelaxELFRelocations; }
   void setRelaxELFRelocations(bool V) { RelaxELFRelocations = V; }
   bool hasMipsExpressions() const { return HasMipsExpressions; }
+  bool needsFunctionDescriptors() const { return NeedsFunctionDescriptors; }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_MC_MCASMINFO_H

llvm/include/llvm/MC/MCAsmInfoXCOFF.h

 
 namespace llvm {
 
 class MCAsmInfoXCOFF : public MCAsmInfo {
   virtual void anchor();
 
 protected:
   MCAsmInfoXCOFF();
+
+public:
+  // Return true only when the identifier Name does not need quotes to be
+  // syntactically correct for XCOFF.
+  bool isValidUnquotedName(StringRef Name) const override;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_MC_MCASMINFOXCOFF_H

llvm/include/llvm/MC/MCDirectives.h

enum MCSymbolAttr {
   MCSA_ELF_TypeFunction,    ///< .type _foo, STT_FUNC  # aka @function
   MCSA_ELF_TypeIndFunction, ///< .type _foo, STT_GNU_IFUNC
   MCSA_ELF_TypeObject,      ///< .type _foo, STT_OBJECT  # aka @object
   MCSA_ELF_TypeTLS,         ///< .type _foo, STT_TLS     # aka @tls_object
   MCSA_ELF_TypeCommon,      ///< .type _foo, STT_COMMON  # aka @common
   MCSA_ELF_TypeNoType,      ///< .type _foo, STT_NOTYPE  # aka @notype
   MCSA_ELF_TypeGnuUniqueObject, /// .type _foo, @gnu_unique_object
   MCSA_Global,              ///< .globl
+  MCSA_LGlobal,             ///< .lglobl (XCOFF)
   MCSA_Hidden,              ///< .hidden (ELF)
   MCSA_IndirectSymbol,      ///< .indirect_symbol (MachO)
   MCSA_Internal,            ///< .internal (ELF)
   MCSA_LazyReference,       ///< .lazy_reference (MachO)
   MCSA_Local,               ///< .local (ELF)
   MCSA_NoDeadStrip,         ///< .no_dead_strip (MachO)
   MCSA_SymbolResolver,      ///< .symbol_resolver (MachO)
   MCSA_AltEntry,            ///< .alt_entry (MachO)

llvm/include/llvm/MC/MCSymbolXCOFF.h

public:
   };
 
   XCOFF::StorageClass getStorageClass() const {
     assert(StorageClass.hasValue() &&
            "StorageClass not set on XCOFF MCSymbol.");
     return StorageClass.getValue();
   }
 
-  void setContainingCsect(const MCSectionXCOFF *C) {
+  void setContainingCsect(MCSectionXCOFF *C) {
     assert((!ContainingCsect || ContainingCsect == C) &&
            "Trying to set a containing csect that doesn't match the one that"
            "this symbol is already mapped to.");
     ContainingCsect = C;
   }
 
-  const MCSectionXCOFF *getContainingCsect() const {
+  MCSectionXCOFF *getContainingCsect() const {
     assert(ContainingCsect &&
            "Trying to get containing csect but none was set.");
     return ContainingCsect;
   }
 
 private:
   Optional<XCOFF::StorageClass> StorageClass;
-  const MCSectionXCOFF *ContainingCsect = nullptr;
+  MCSectionXCOFF *ContainingCsect = nullptr;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_MC_MCSYMBOLXCOFF_H

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

 #include "llvm/MC/MCDirectives.h"
 #include "llvm/MC/MCDwarf.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCSection.h"
 #include "llvm/MC/MCSectionCOFF.h"
 #include "llvm/MC/MCSectionELF.h"
 #include "llvm/MC/MCSectionMachO.h"
+#include "llvm/MC/MCSectionXCOFF.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/MC/MCTargetOptions.h"
 #include "llvm/MC/MCValue.h"
 #include "llvm/MC/SectionKind.h"
 #include "llvm/Pass.h"
 #include "llvm/Remarks/Remark.h"
 #include "llvm/Remarks/RemarkFormat.h"
 #include "llvm/Remarks/RemarkStringTable.h"
 #include "llvm/Support/Casting.h"
if (MAI->hasWeakDefDirective()) {
       OutStreamer->EmitSymbolAttribute(GVSym, MCSA_Weak);
     }
     return;
   case GlobalValue::ExternalLinkage:
     // If external, declare as a global symbol: .globl _foo
     OutStreamer->EmitSymbolAttribute(GVSym, MCSA_Global);
     return;
   case GlobalValue::PrivateLinkage:
+    return;
   case GlobalValue::InternalLinkage:
+    if (MAI->hasDotLGloblDirective())
+      OutStreamer->EmitSymbolAttribute(GVSym, MCSA_LGlobal);
     return;
   case GlobalValue::AppendingLinkage:
   case GlobalValue::AvailableExternallyLinkage:
   case GlobalValue::ExternalWeakLinkage:
     llvm_unreachable("Should never emit this");
   }
   llvm_unreachable("Unknown linkage type!");
 }
void AsmPrinter::EmitFunctionHeader() {
 
   // Print out constants referenced by the function
   EmitConstantPool();
 
   // Print the 'header' of function.
   OutStreamer->SwitchSection(getObjFileLowering().SectionForGlobal(&F, TM));
   EmitVisibility(CurrentFnSym, F.getVisibility());
 
+  if (MAI->needsFunctionDescriptors() &&
+      F.getLinkage() != GlobalValue::InternalLinkage)
+    EmitLinkage(&F, CurrentFnDescSym);
+
   EmitLinkage(&F, CurrentFnSym);
   if (MAI->hasFunctionAlignment())
     EmitAlignment(MF->getAlignment(), &F);
 
   if (MAI->hasDotTypeDotSizeDirective())
     OutStreamer->EmitSymbolAttribute(CurrentFnSym, MCSA_ELF_TypeFunction);
 
   if (F.hasFnAttribute(Attribute::Cold))
if (MAI->hasSubsectionsViaSymbols()) {
 
       // Emit an .alt_entry directive for the actual function symbol.
       OutStreamer->EmitSymbolAttribute(CurrentFnSym, MCSA_AltEntry);
     } else {
       EmitGlobalConstant(F.getParent()->getDataLayout(), F.getPrefixData());
     }
   }
 
-  // Emit the CurrentFnSym.  This is a virtual function to allow targets to
-  // do their wild and crazy things as required.
+  // Emit the function descriptor. This is a virtual function to allow targets
+  // to emit their specific function descriptor.
+  if (MAI->needsFunctionDescriptors())
+    EmitFunctionDescriptor();
+
+  // Emit the CurrentFnSym. This is a virtual function to allow targets to do
+  // their wild and crazy things as required.
   EmitFunctionEntryLabel();
 
   // If the function had address-taken blocks that got deleted, then we have
   // references to the dangling symbols.  Emit them at the start of the function
   // so that we don't get references to undefined symbols.
   std::vector<MCSymbol*> DeadBlockSyms;
   MMI->takeDeletedSymbolsForFunction(&F, DeadBlockSyms);
   for (unsigned i = 0, e = DeadBlockSyms.size(); i != e; ++i) {
void AsmPrinter::EmitFunctionEntryLabel() {
   if (CurrentFnSym->isDefined())
     report_fatal_error("'" + Twine(CurrentFnSym->getName()) +
                        "' label emitted multiple times to assembly file");
 
   return OutStreamer->EmitLabel(CurrentFnSym);
 }
 
 /// emitComments - Pretty-print comments for instructions.
 static void emitComments(const MachineInstr &MI, raw_ostream &CommentOS) {
   const MachineFunction *MF = MI.getMF();
   const TargetInstrInfo *TII = MF->getSubtarget().getInstrInfo();
 
   // Check for spills and reloads
 
   // We assume a single instruction only has a spill or reload, not
   // both.
   Optional<unsigned> Size;

 MCSymbol *AsmPrinter::getCurExceptionSym() {
   if (!CurExceptionSym)
     CurExceptionSym = createTempSymbol("exception");
   return CurExceptionSym;
 }
 
 void AsmPrinter::SetupMachineFunction(MachineFunction &MF) {
   this->MF = &MF;
+
   // Get the function symbol.
+  if (MAI->needsFunctionDescriptors()) {
+    assert(TM.getTargetTriple().isOSAIX() && "Function descriptor is only"
+                                             " supported on AIX.");
+    assert(CurrentFnDescSym && "The function descriptor symbol needs to be"
+                               " initalized first.");
+
+    // Get the function entry point symbol.
+    CurrentFnSym =
+        OutContext.getOrCreateSymbol("." + CurrentFnDescSym->getName());
+
+    const Function &F = MF.getFunction();
+    MCSectionXCOFF *FnEntryPointSec =
+        cast<MCSectionXCOFF>(getObjFileLowering().SectionForGlobal(&F, TM));
+    // Set the containing csect.
+    cast<MCSymbolXCOFF>(CurrentFnSym)->setContainingCsect(FnEntryPointSec);
+  } else {
     CurrentFnSym = getSymbol(&MF.getFunction());
+  }
+
   CurrentFnSymForSize = CurrentFnSym;
   CurrentFnBegin = nullptr;
   CurExceptionSym = nullptr;
   bool NeedsLocalForSize = MAI->needsLocalForSize();
   if (needFuncLabelsForEHOrDebugInfo(MF, MMI) || NeedsLocalForSize ||
       MF.getTarget().Options.EmitStackSizeSection) {
     CurrentFnBegin = createTempSymbol("func_begin");
     if (NeedsLocalForSize)

llvm/lib/MC/MCAsmInfoXCOFF.cpp

 MCAsmInfoXCOFF::MCAsmInfoXCOFF() {
   IsLittleEndian = false;
   HasDotTypeDotSizeDirective = false;
   COMMDirectiveAlignmentIsInBytes = false;
   LCOMMDirectiveAlignmentType = LCOMM::Log2Alignment;
   UseDotAlignForAlignment = true;
   AsciiDirective = nullptr; // not supported
   AscizDirective = nullptr; // not supported
+  NeedsFunctionDescriptors = true;
+  HasDotLGloblDirective = true;
   Data64bitsDirective = "\t.llong\t";
+  SupportsQuotedNames = false;
+}
+
+bool MCAsmInfoXCOFF::isValidUnquotedName(StringRef Name) const {
+  // FIXME: Remove this function when we stop using "TOC[TC0]" as a symbol name.
+  if (Name.equals("TOC[TC0]"))
+    return true;
+
+  return MCAsmInfo::isValidUnquotedName(Name);
 }

llvm/lib/MC/MCAsmStreamer.cpp

case MCSA_ELF_TypeGnuUniqueObject:  /// .type _foo, @gnu_unique_object
     case MCSA_ELF_TypeNoType:      OS << "notype"; break;
     case MCSA_ELF_TypeGnuUniqueObject: OS << "gnu_unique_object"; break;
     }
     EmitEOL();
     return true;
   case MCSA_Global: // .globl/.global
     OS << MAI->getGlobalDirective();
     break;
+  case MCSA_LGlobal:        OS << "\t.lglobl\t";          break;
   case MCSA_Hidden:         OS << "\t.hidden\t";          break;
   case MCSA_IndirectSymbol: OS << "\t.indirect_symbol\t"; break;
   case MCSA_Internal:       OS << "\t.internal\t";        break;
   case MCSA_LazyReference:  OS << "\t.lazy_reference\t";  break;
   case MCSA_Local:          OS << "\t.local\t";           break;
   case MCSA_NoDeadStrip:
     if (!MAI->hasNoDeadStrip())
       return false;

llvm/lib/MC/MCELFStreamer.cpp

case MCSA_Hidden:
     break;
 
   case MCSA_Internal:
     Symbol->setVisibility(ELF::STV_INTERNAL);
     break;
 
   case MCSA_AltEntry:
     llvm_unreachable("ELF doesn't support the .alt_entry attribute");
+
+  case MCSA_LGlobal:
+    llvm_unreachable("ELF doesn't support the .lglobl attribute");
   }
 
   return true;
 }
 
 void MCELFStreamer::EmitCommonSymbol(MCSymbol *S, uint64_t Size,
                                      unsigned ByteAlignment) {
   auto *Symbol = cast<MCSymbolELF>(S);

llvm/lib/MC/MCMachOStreamer.cpp

bool MCMachOStreamer::EmitSymbolAttribute(MCSymbol *Sym,
   case MCSA_ELF_TypeNoType:
   case MCSA_ELF_TypeGnuUniqueObject:
   case MCSA_Hidden:
   case MCSA_IndirectSymbol:
   case MCSA_Internal:
   case MCSA_Protected:
   case MCSA_Weak:
   case MCSA_Local:
+  case MCSA_LGlobal:
     return false;
 
   case MCSA_Global:
     Symbol->setExternal(true);
     // This effectively clears the undefined lazy bit, in Darwin 'as', although
     // it isn't very consistent because it implements this as part of symbol
     // lookup.
     //

llvm/lib/MC/MCSectionXCOFF.cpp

 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
 MCSectionXCOFF::~MCSectionXCOFF() = default;
 
+static StringRef getMappingClassString(XCOFF::StorageMappingClass SMC) {
+  switch (SMC) {
+  case XCOFF::XMC_DS:
+    return "DS";
+  case XCOFF::XMC_RW:
+    return "RW";
+  case XCOFF::XMC_PR:
+    return "PR";
+  default:
+    report_fatal_error("Unhandled storage-mapping class.");
+  }
+}
+
 void MCSectionXCOFF::PrintSwitchToSection(const MCAsmInfo &MAI, const Triple &T,
                                           raw_ostream &OS,
                                           const MCExpr *Subsection) const {
   if (getKind().isText()) {
     if (getMappingClass() != XCOFF::XMC_PR)
-      llvm_unreachable("Unsupported storage-mapping class for .text csect");
+      report_fatal_error("Unhandled storage-mapping class for .text csect");
 
     OS << "\t.csect " << getSectionName() << "["
-       << "PR"
+       << getMappingClassString(getMappingClass())
        << "]" << '\n';
     return;
   }
 
   if (getKind().isData()) {
-    assert(getMappingClass() == XCOFF::XMC_RW &&
-           "Unhandled storage-mapping class for data section.");
-
+    switch (getMappingClass()) {
+    case XCOFF::XMC_RW:
+    case XCOFF::XMC_DS:
       OS << "\t.csect " << getSectionName() << "["
-       << "RW"
-       << "]" << '\n';
+         << getMappingClassString(getMappingClass()) << "]" << '\n';
+      break;
+    case XCOFF::XMC_TC0:
+      OS << "\t.toc\n";
+      break;
+    default:
+      report_fatal_error(
+          "Unhandled storage-mapping class for .data csect.");
+    }
     return;
   }
 
   if (getKind().isBSSLocal() || getKind().isCommon()) {
     assert((getMappingClass() == XCOFF::XMC_RW ||
             getMappingClass() == XCOFF::XMC_BS) &&
            "Generated a storage-mapping class for a common/bss csect we don't "
            "understand how to switch to.");

llvm/lib/MC/XCOFFObjectWriter.cpp

case XCOFF::XMC_PR:
       break;
     case XCOFF::XMC_RW:
       if (XCOFF::XTY_CM == MCSec->getCSectType()) {
         BSSCsects.emplace_back(MCSec);
         WrapperMap[MCSec] = &BSSCsects.back();
         break;
       }
       report_fatal_error("Unhandled mapping of read-write csect to section.");
+    case XCOFF::XMC_TC0:
+      // TODO FIXME Handle emiting the TOC base.
+      break;
     case XCOFF::XMC_BS:
       assert(XCOFF::XTY_CM == MCSec->getCSectType() &&
              "Mapping invalid csect. CSECT with bss storage class must be "
              "common type.");
       BSSCsects.emplace_back(MCSec);
       WrapperMap[MCSec] = &BSSCsects.back();
       break;
     default:

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

 
 class PPCAIXAsmPrinter : public PPCAsmPrinter {
 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;
+
   void EmitGlobalVariable(const GlobalVariable *GV) override;
+
+  void EmitFunctionDescriptor() override;
+
+  void EmitEndOfAsmFile(Module &) override;
 };
 
 } // end anonymous namespace
 
 void PPCAsmPrinter::PrintSymbolOperand(const MachineOperand &MO,
                                        raw_ostream &O) {
   // Computing the address of a global symbol, not calling it.
   const GlobalValue *GV = MO.getGlobal();
bool PPCDarwinAsmPrinter::doFinalization(Module &M) {
   // implementation of multiple entry points).  If this doesn't occur, the
   // linker can safely perform dead code stripping.  Since LLVM never generates
   // code that does this, it is always safe to set.
   OutStreamer->EmitAssemblerFlag(MCAF_SubsectionsViaSymbols);
 
   return AsmPrinter::doFinalization(M);
 }
 
+void PPCAIXAsmPrinter::SetupMachineFunction(MachineFunction &MF) {
+  // Get the function descriptor symbol.
+  CurrentFnDescSym = getSymbol(&MF.getFunction());
+  // Set the containing csect.
+  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) {
   // 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.");
 
   SectionKind GVKind = getObjFileLowering().getKindForGlobal(GV, TM);
   if (!GVKind.isCommon() && !GVKind.isBSSLocal() && !GVKind.isData())
     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));
void PPCAIXAsmPrinter::EmitGlobalVariable(const GlobalVariable *GV) {
 
   MCSymbol *EmittedInitSym = GVSym;
   EmitLinkage(GV, EmittedInitSym);
   EmitAlignment(getGVAlignment(GV, DL), GV);
   OutStreamer->EmitLabel(EmittedInitSym);
   EmitGlobalConstant(GV->getParent()->getDataLayout(), GV->getInitializer());
 }
 
+void PPCAIXAsmPrinter::EmitFunctionDescriptor() {
+  const DataLayout &DL = getDataLayout();
+  const unsigned PointerSize = DL.getPointerSizeInBits() == 64 ? 8 : 4;
+
+  MCSectionSubPair Current = OutStreamer->getCurrentSection();
+  // 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]"));
+  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.
+  MCSymbol *TOCBaseSym = OutContext.getOrCreateSymbol(StringRef("TOC[TC0]"));
+  MCSectionXCOFF *TOCBaseSection = OutStreamer->getContext().getXCOFFSection(
+      StringRef("TOC"), XCOFF::XMC_TC0, XCOFF::XTY_SD, XCOFF::C_HIDEXT,
+      SectionKind::getData());
+  cast<MCSymbolXCOFF>(TOCBaseSym)->setContainingCsect(TOCBaseSection);
+  // Switch to section to emit TOC base.
+  OutStreamer->SwitchSection(TOCBaseSection);
+}
+
+
 /// 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/test/CodeGen/PowerPC/aix-xcoff-common.ll

 
 @d = common local_unnamed_addr global double 0.000000e+00, align 8
 @f = common local_unnamed_addr global float 0.000000e+00, align 4
 
 @over_aligned = common local_unnamed_addr global double 0.000000e+00, align 32
 
 @array = common local_unnamed_addr global [33 x i8] zeroinitializer, align 1
 
+; CHECK-NOT: .toc
+
 ; CHECK:      .csect .text[PR]
 ; CHECK-NEXT:  .file
 ; CHECK-NEXT: .comm   a,4,2
 ; CHECK-NEXT: .comm   b,8,3
 ; CHECK-NEXT: .comm   c,2,1
 ; CHECK-NEXT: .comm   d,8,3
 ; CHECK-NEXT: .comm   f,4,2
 ; CHECK-NEXT: .comm   over_aligned,8,5

llvm/test/CodeGen/PowerPC/test_func_desc.ll

+; RUN: llc -mtriple powerpc-ibm-aix-xcoff < %s | \
+; RUN: FileCheck --check-prefixes=CHECK,32BIT %s
+
+; RUN: llc -mtriple powerpc64-ibm-aix-xcoff < %s | \
+; RUN: FileCheck --check-prefixes=CHECK,64BIT %s
+
+
+define i32 @foo() {
+entry:
+  ret i32 3
+}
+
+define i32 @main() {
+entry:
+  %0 = call i32 @foo()
+  %1 = call i32 bitcast (i32 (...)* @extern_foo to i32 ()*)()
+  %2 = call i32 @static_foo()
+  %3 = add nsw i32 %0, %1
+  %4 = add nsw i32 %3, %2
+  ret i32 %4
+}
+
+declare i32 @extern_foo(...)
+
+define internal i32 @static_foo() {
+entry:
+  ret i32 3
+}
+
+; CHECK: .globl foo
+; CHECK: .globl .foo
+; CHECK: .csect foo[DS]
+; CHECK-NEXT: foo:
+; 32BIT: .long .foo
+; 32BIT-NEXT: .long TOC[TC0]
+; 32BIT-NEXT: .long 0
+; 64BIT: .llong .foo
+; 64BIT-NEXT: .llong TOC[TC0]
+; 64BIT-NEXT: .llong 0
+; CHECK-NEXT: .csect .text[PR]
+; CHECK-LABEL: .foo:
+
+; CHECK: .globl main
+; CHECK: .globl .main
+; CHECK: .csect main[DS]
+; CHECK-NEXT: main:
+; 32BIT: .long .main
+; 32BIT-NEXT: .long TOC[TC0]
+; 32BIT-NEXT: .long 0
+; 64BIT: .llong .main
+; 64BIT-NEXT: .llong TOC[TC0]
+; 64BIT-NEXT: .llong 0
+; CHECK-NEXT: .csect .text[PR]
+; CHECK-LABEL: .main:
+; CHECK: bl .foo
+; CHECK: bl .extern_foo
+; CHECK: bl .static_foo
+
+; CHECK: .lglobl .static_foo
+; CHECK: .csect static_foo[DS]
+; CHECK-NEXT: static_foo:
+; 32BIT: .long .static_foo
+; 32BIT-NEXT: .long TOC[TC0]
+; 32BIT-NEXT: .long 0
+; 64BIT: .llong .static_foo
+; 64BIT-NEXT: .llong TOC[TC0]
+; 64BIT-NEXT: .llong 0
+; CHECK-NEXT: .csect .text[PR]
+; CHECK-LABEL: .static_foo:
+
+; CHECK-NOT: .csect extern_foo
+
+; CHECK: .toc
+; CHECK-NOT: .tc