Output XCOFF object text section header and symbol entry for program code

[DiggerLin]

Summary

Original form of this patch is provided by Stefan Pintillie.

1. The patch try to output program code section header , symbol entry for program code (PR) and Instruction into the raw text section.
2. The patch include how to alignment and layout the CSection in the text section.
3. The patch also reorganize the code , put some codes into a function(XCOFFObjectWriter::writeSymbolTableEntryForControlSection)

Additional: We can not add raw data of text section test in the patch, If want to output raw text section data,it need a function description patch first.

[hubert.reinterpretcast]

llvm/lib/MC/XCOFFObjectWriter.cpp

53

Is this answer in relation to some specific use of Syms or its containing class?

158

Stray top-level const on function parameter declaration on a function declaration.

160

Stray top-level const on function parameter declaration on a function declaration.

301

Please don't copy the ControlSections.

301

We already use Sec and Csect for similar cases. I don't think we need to add CSection into the mix.

306

Is the llvm:: qualification necessary?

336

putNameInStringTable sounds like an action. Maybe use nameShouldBeInStringTable.

337

Names of NameSize length are placed in the symbol table.

Please add appropriate testing. This is a regression that was not caught.

340

This function is misnamed for what it does. It writes the symbol table entry name field, not the symbol name.

470–480

Same question re: llvm:: as before.

472

Please don't copy the ControlSections.

[hubert.reinterpretcast]

llvm/lib/MC/XCOFFObjectWriter.cpp

342

Minor nit: This was fixed in D65159 to use int32_t (not that there is a real difference). However this is my second comment on this patch regarding its replacement of more correct code with less correct code.

363

Neither GCC nor XL fail to set the function property when debugging is enabled. This is at least a TODO.

364

s/symbol/symbol's/;

371

Since the field is named SectionLen in llvm::object::XCOFFCsectAuxEnt32, a comment is warranted regarding its use also for referencing the containing csect by symbol table index. Please also add a comment in include/llvm/Object/XCOFFObjectFile.h.

377

This field is unsigned; see D65159:

W.write<uint8_t>(getEncodedType(Sec.MCCsect));

379

Ditto.

381

Ditto.

383

Ditto.

[hubert.reinterpretcast]

llvm/lib/MC/XCOFFObjectWriter.cpp

352

This function is misnamed. It neither handles all variations of the LLVM concept of "symbol" nor the same for the XCOFF concept of "symbol". Maybe use writeSymbolTableEntryForCsectMemberLabel.

354

Top-level const still not fixed here.

387

Ditto re: top-level const.

llvm/test/CodeGen/PowerPC/aix-return55.ll

8

foo: with the colon. .foo: if possible.

[hubert.reinterpretcast]

llvm/lib/MC/XCOFFObjectWriter.cpp

396

Please add a comment about this value being always zero (for now). Again, this was better in the existing code before this patch.

409

Unsigned.

411

Unsigned.

413

Unsigned.

415

Unsigned.

509

Technically this assert is too late. INT_MAX is allowed to be the same as INT16_MAX, so the addition may overflow even in the promoted type.

527

The string text should probably be about the size not being properly padded to a multiple of the section alignment.

536–537

Ditto regarding the assertion being too late.

[hubert.reinterpretcast]

The lack of testing with regards to what gets written for the raw data of the .text XCOFF section ought to be addressed.

[DiggerLin]

llvm/lib/MC/XCOFFObjectWriter.cpp

53

the problem is happened in the // Print out symbol table for the data section.

// Print out symbol table for the program code.
for (const auto CSection : ProgramCodeCsects) {
  // Write out the control section first and then each symbol in it.
  writeSymbolTableEntryForControlSection(CSection, Text.Index,
                                         CSection.MCCsect->getStorageClass());
  for (const auto Sym : CSection.Syms) {
    writeSymbolTableEntryForCsectMemberLabel(Sym, CSection, Text.Index,
                                   Layout.getSymbolOffset(*(Sym.MCSym)));
  }
} 
for (const auto CSection : ProgramCodeCsects) {

it will caused Symbol::operator=. since we will change to for (const auto& CSection : ProgramCodeCsects) in new copy, I will recover "const MCSymbolXCOFF *const MCSym;"

158

change the "const int16_t" to "int16_t"

160

change the "const int16_t" to "int16_t"

301

change as suggestion

306

yes, it is not necessary, the file already has using namespace llvm;

336

I prefer to use isNameInStringTable

337

changed, and I have asked Xing to add some test case for symbol name which length is 8 and symbol name which length large than 8 . @xingxue

340

it write symbol name information in the function, I think writeSymbolName is OK.

342

changed.thanks

363

add a new TODO

364

done

379

changed.

383

changed

387

fixed , thanks

396

added a comment

409

changed.thanks

413

changed.thanks

415

changed.thanks

470–480

deleted

472

changed

509

I delete the assert, I do not think we need assert here.

[DiggerLin]

new patch which address comment

[DiggerLin]

llvm/lib/MC/XCOFFObjectWriter.cpp

527

changed assert to Address= alignTo(Address, DefaultSectionAlign);

536–537

the assert will be deleted

llvm/test/CodeGen/PowerPC/aix-return55.ll

8

changed .thanks

[DiggerLin]

address comment

[xingxue]

llvm/lib/MC/XCOFFObjectWriter.cpp

301

I'd suggest to use Csect to be consistent with what is used in this file for other similar cases.

[sfertile]

llvm/lib/MC/XCOFFObjectWriter.cpp

53

since we will change to for (const auto& CSection : ProgramCodeCsects) in new copy, I will recover "const MCSymbolXCOFF *const MCSym;"

👍

367

Minor nit: IIUC We aren't supporting the old XCOFF32 interpretation, but rather setting the bit (which is optional in the new interpretation) when debugging is enabled.

371

I'm not disagreeing with this, but it should be done in a separate patch.

498

Why did you change this, then add an 'Address' in each of the section layout calculations? We can use Text.Address/BSS.Address to calculate the sections size, so no need for an extra variable.

509

we assigned uint32_t Address = 0; at begin, I do not think we need to assert assigning Text.Address here, because if always true here.

I'm suggesting we need to assign Text.Address = Address even though we expect Address to be zero. If we for example decided there should be a section mapped before the .text section in the object file then Address may not be zero.I understand its unlikely for us to make such a change, but that is not a good reason to skip assigning the address.

[DiggerLin]

llvm/lib/MC/XCOFFObjectWriter.cpp

301

changed as suggestion

[DiggerLin]

llvm/lib/MC/XCOFFObjectWriter.cpp

498

there is a patch https://reviews.llvm.org/D67125 , which will change Address to SectionStartAddress. And we think SectionStartAddress can express meaning than Address.

What we need another available Address in the uint32_t Address = SectionStartAddress; , the Address is used to store the start address of the Csection.

there is a more variable "Address" as your pointout, but I think the code will more readable with the additional variable "Address"

509

added as suggestion

[hubert.reinterpretcast]

I might have more comments later, but I'm posting what I have currently.

llvm/lib/MC/XCOFFObjectWriter.cpp

336

This really sounds like the name is already in the string table.

362

The old comment is fine here. Please switch back to the shorter version. This is a part of the documentation that requires careful reading in context (and is a bad idea to quote portions from).

367

The second TODO should say:

// TODO Set the function indicator (bit 10, 0x0020) for functions
// when debugging is enabled.

402

Use the shorter version of the comment here too,

470–480

I'm not seeing the change. llvm:: still here.

[DiggerLin]

In D66969#1671945, @hubert.reinterpretcast wrote:

The lack of testing with regards to what gets written for the raw data of the .text XCOFF section ought to be addressed.

in the patch we cannot deal with the DS csect in function in void XCOFFObjectWriter::executePostLayoutBinding . we can not generate a raw data of the '.text" XCOFF section.
there are upcoming patch which deal with the DS csect , I think we will add the test in that patch @jasonliu.

llvm/lib/MC/XCOFFObjectWriter.cpp

336

changed as suggestion

352

changed as suggestion

362

changed as suggestion

362

changed as suggestion

367

changed as suggestion

402

changed as suggestion

[sfertile]

llvm/lib/MC/XCOFFObjectWriter.cpp

365

Minor nit: Extra space after TODO

498

I don't see how the change helps readability. Originally we have a single variable that represent the next assignable address in the file. When we assign a section start address it simply starts at that next available address. After the change we now have a variable to track the SectionStartAddress, which doesn't seem any different or special compared to any of the other addresses we assign. And we have the extra overhead of creating a local and assigning that with the value of section start address, then modifying that in the loop making sure we have to copy its modified value out to SectionStartAddress at the end of the loop. Why is the sections start address different from any other address we assign in the loop? In what way does having the extra variable increase readability?

509

I'm OK with postponing the overflow checking for now, since there is only 3 sections we might be emitting.

llvm/test/CodeGen/PowerPC/aix-return55.ll

8

Still missing the : in the CHECK-LABEL line.

[DiggerLin]

llvm/lib/MC/XCOFFObjectWriter.cpp

365

changed

498

changed as suggestion.

llvm/test/CodeGen/PowerPC/aix-return55.ll

8

added

[hubert.reinterpretcast]

llvm/lib/MC/XCOFFObjectWriter.cpp

303

We have code that introduces alignment padding, so I suspect we should have code here to write out the padding.

402

There are some cases here of two consecutive spaces. It is not necessarily wrong, but we should be consistent.

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

84

I think this warrants more explanation. Is the ability of the regex to match non-space characters intended?

[hubert.reinterpretcast]

In D66969#1683070, @DiggerLin wrote:

we can not generate a raw data of the '.text" XCOFF section.
there are upcoming patch which deal with the DS csect , I think we will add the test in that patch @jasonliu.

I believe that the .text section testing should be separate. The fact that the patch you mention would enable the ability to generate a non-zero size XCOFF .text section does not mean that it should cover testing beyond its own scope.

From the current patch, we have identified a need for follow-up patches to test .text sections that aren't empty, to test the placement of symbol names, and to address the naming of a field that this patch uses for a different purpose. If the second sounds out-of-place, then that is because the current commit message does not actually describe the scope of the patch well. The patch did a refactoring of interfaces, and that portion of the patch is why the second follow-up patch is tied to this one.

Please update the commit message to describe the scope of the current patch (especially that necessary dependencies for there to be non-empty .text sections have not landed) and to indicate a plan for follow-on patches.

[hubert.reinterpretcast]

llvm/lib/MC/XCOFFObjectWriter.cpp

537–539

A comment is necessary here regarding alignment padding between the start of the section and the first item allocated within the section (which might require a stricter alignment). A question is why such padding is done "physically" in within the section as opposed to doing the padding "virtually" by adjusting the section's address in the address space.

[DiggerLin]

llvm/lib/MC/XCOFFObjectWriter.cpp

303

Added new function to support it.

402

delete extras space.

537–539

added a comment

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

84

there is Index: 0

Name: .text

before Symbol {

Index: 2
Name: a

origin test case will match .text symbol first and the value of Index will be zero.

using ; SYMS: Index: #Index:{{[[:space:]].*}}Name: a
can make sure that it match Symbol {

Index: 2
Name: a

not symbol .text and the index value will 2.

[DiggerLin]

added a new padding zero for the section and csection.

[DiggerLin]

updated two test cases.
as
SYMS: Index: #Index:{{[[:space:]]*}}Name: a

[sfertile]

We need to verify if we need the storage padding or not before finalizing, but otherwise the patch looks pretty good.

llvm/lib/MC/XCOFFObjectWriter.cpp

69

We might be able to skip writing the actual zeros for padding, and instead just pad out the virtual addresses assigned to the sections/csects. I believe @hubert.reinterpretcast was following up with one of the AIX system toolchain devs to verify.

537–539

I'm sorry Digger, but I am having trouble figuring out what the comment is trying to convey.

Is it that each section is padded out to DefaultSectionAlign so that Address must be properly aligned already?

Is it trying to explain how we don't have to align the sections virtual address anymore then DefaultSectionAlign (even when contained csects may be more strictly aligned then that) becuase the sections alignment is immaterial?

[DiggerLin]

first Csect of each section do not need padding zero. And we also need to adjust section virtual address to first Csect's address.

[hubert.reinterpretcast]

llvm/lib/MC/XCOFFObjectWriter.cpp

89

Remove this field (see comments on later lines).

103

Remove this field (see comments on later lines).

511

The inter-csect padding is not really a property of the csect requiring alignment. We do not need to store this value here. The amount of padding to write can be determined by tracking the virtual address of the raw section data being written during the serialization into the object file. The next virtual address following the padding should be Csect.Address.

525

The Size field accounts for the padding. We do not need to store this value here. The amount of padding to write can be determined by tracking the virtual address of the raw section data being written during the serialization into the object file. The next virtual address following the padding should be Text.Address + Text.Size.

[hubert.reinterpretcast]

llvm/lib/MC/XCOFFObjectWriter.cpp

371

@DiggerLin, please post such a patch (perhaps going so far as to rename the field to SectionOrLength) so we do not lose track of this.

[DiggerLin]

llvm/lib/MC/XCOFFObjectWriter.cpp

371

I created a NFC patch. https://reviews.llvm.org/D68650

[DiggerLin]

llvm/lib/MC/XCOFFObjectWriter.cpp

89

After I discuss with Sean, We decide to keep variable PaddingSize here. with additional variable, it can make the code more readable and the logic of padding more easy to understand.

103

After I discuss with Sean, We decide to keep variable PaddingSize here. with additional variable, it can make the code more readable and the logic of padding more easy to understand.

511

I got what you talk about, But If we do not calculate the padding size here, We have to calculate the padding size in the XCOFFObjectWriter::writeSections , it will make the logic of the function writeSections complicated.

for example
// Write the program code control sections one at a time.

uint32_t PaddingSize = 0;   //additional variable here.
for (auto it= ProgramCodeCsects.begin(); it!=ProgramCodeCsects.end() ;++it ) {
  if (PaddingSize)
    W.OS.write_zeros(Csect.PaddingSize);
 // And I think I also need some comment to explain following code.
 if(std::next(it) != ProgramCodeCsects.end() )
     PaddingSize = std::next(it)->Address - it->Address - it->size;
  Asm.writeSectionData(W.OS, Csect.MCCsect, Layout);
}

525

some reason as above.

[DiggerLin]

change padding method as hubert 's suggestion.

[DiggerLin]

add if (PaddingSize) protect.

[hubert.reinterpretcast]

llvm/lib/MC/XCOFFObjectWriter.cpp

301

Suggestion: CurrentAddressLocation

304

I think the code can be made sufficiently self-explanatory that we don't need a comment here.

307

The above write to PaddingSize is only read by the if and the use inside the if.

if (uint32_t PaddingSize = Csect.Address - CurrentAddressLocation)

313

Suggestion:
The size of the tail padding in a section is the end virtual address of the current section minus the the end virtual address of the last csect in that section.

315

if (!ProgramCodeCsects.empty())

however, I suggest checking the section and not the group of csects (they aren't the same thing):

if (Text.Index != -1)

317

Same comment about the write to PaddingSize.

513

There's two spaces after the +.

525

Use "csect" instead of "Csect" when using the term in an English context where the word would not be capitalized.

Suggestion:
The first csect of a section can be aligned by adjusting the virtual address of its containing section instead of writing zeroes into the object file.

537–539

The difference in the calculation for the virtual address of the .bss section and that of the .text section might complicate efforts to common up the handling. Note that a change in how the virtual address of .bss is calculated is within the scope of this patch because it changes the value from being always zero.

[hubert.reinterpretcast]

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

56

It seems this file was changed accidentally by today's updates. The (space) character before the * is correct.

[DiggerLin]

llvm/lib/MC/XCOFFObjectWriter.cpp

301

changed as suggestion

304

deleted the comment.

313

changed comment as suggestion

315

changed as suggestion.

317

changed as suggestion.

513

deleted, thanks

525

changed as suggestion

537–539

changed , thanks

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

56

changed , thanks

[hubert.reinterpretcast]

Just some minor comments. I think this is almost ready.

llvm/lib/MC/XCOFFObjectWriter.cpp

155

This should be a static member function or a non-member function.

358

Maybe check for overflow here.

478

Please remove the excess parentheses.

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

84

Can this be merged with the previous line?

SYMS:        Symbol {{[{][[:space:]] *}}Index: [[#Index:]]{{[[:space:]] *}}Name: a{{$}}

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

36

Same comment re: merging with the previous line.

56

Same comment re: merging with the previous line.

[DiggerLin]

llvm/lib/MC/XCOFFObjectWriter.cpp

155

thanks for your suggestion.

358

added

478

deleted

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

84

yes ,your suggestion is more reasonable.

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

36

changed

56

changed as suggestion.

[hubert.reinterpretcast]

LGTM with minor changes that can be made on the check-in.

llvm/lib/MC/XCOFFObjectWriter.cpp

357

This would not be sufficient to avoid overflow if SymbolOffset is less than UINT32_MAX away from UINT64_MAX, use: SymbolOffset <= UINT32_MAX - CSectionRef.Address.

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

84

Please use {{[{] instead of {{{ to avoid ambiguity as to where the regular expression starts and, if the regular expression starts with the first {{, to avoid the undefined results indicated by POSIX regarding { as the first character of an ERE.

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

56

Same comment.

llvm/include/llvm/MC/MCSectionXCOFF.h

public:
   ~MCSectionXCOFF();
 
   static bool classof(const MCSection *S) {
     return S->getVariant() == SV_XCOFF;
   }
 
   StringRef getSectionName() const { return Name; }
   XCOFF::StorageMappingClass getMappingClass() const { return MappingClass; }
+  XCOFF::StorageClass getStorageClass() const { return StorageClass; }
   XCOFF::SymbolType getCSectType() const { return Type; }
 
   void PrintSwitchToSection(const MCAsmInfo &MAI, const Triple &T,
                             raw_ostream &OS,
                             const MCExpr *Subsection) const override;
   bool UseCodeAlign() const override;
   bool isVirtualSection() const override;
 };
 
 } // end namespace llvm
 
 #endif

llvm/lib/MC/MCXCOFFStreamer.cpp

 
 MCXCOFFStreamer::MCXCOFFStreamer(MCContext &Context,
                                  std::unique_ptr<MCAsmBackend> MAB,
                                  std::unique_ptr<MCObjectWriter> OW,
                                  std::unique_ptr<MCCodeEmitter> Emitter)
     : MCObjectStreamer(Context, std::move(MAB), std::move(OW),
                        std::move(Emitter)) {}
 
-bool MCXCOFFStreamer::EmitSymbolAttribute(MCSymbol *Symbol,
+bool MCXCOFFStreamer::EmitSymbolAttribute(MCSymbol *Sym,
                                           MCSymbolAttr Attribute) {
-  report_fatal_error("Symbol attributes not implemented for XCOFF.");
+  auto *Symbol = cast<MCSymbolXCOFF>(Sym);
+  getAssembler().registerSymbol(*Symbol);
+
+  switch (Attribute) {
+  case MCSA_Global:
+    Symbol->setStorageClass(XCOFF::C_EXT);
+    Symbol->setExternal(true);
+    break;
+  default:
+    report_fatal_error("Not implemented yet.");
+  }
+  return true;
 }
 
 void MCXCOFFStreamer::EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                                        unsigned ByteAlignment) {
   getAssembler().registerSymbol(*Symbol);
   Symbol->setExternal(cast<MCSymbolXCOFF>(Symbol)->getStorageClass() !=
                       XCOFF::C_HIDEXT);
   Symbol->setCommon(Size, ByteAlignment);

 
 void MCXCOFFStreamer::EmitZerofill(MCSection *Section, MCSymbol *Symbol,
                                    uint64_t Size, unsigned ByteAlignment,
                                    SMLoc Loc) {
   report_fatal_error("Zero fill not implemented for XCOFF.");
 }
 
 void MCXCOFFStreamer::EmitInstToData(const MCInst &Inst,
-                                     const MCSubtargetInfo &) {
-  report_fatal_error("Instruction emission not implemented for XCOFF.");
+                                     const MCSubtargetInfo &STI) {
+  MCAssembler &Assembler = getAssembler();
+  SmallVector<MCFixup, 4> Fixups;
+  SmallString<256> Code;
+  raw_svector_ostream VecOS(Code);
+  Assembler.getEmitter().encodeInstruction(Inst, VecOS, Fixups, STI);
+
+  // TODO: Handle Fixups later
+
+  MCDataFragment *DF = getOrCreateDataFragment(&STI);
+  DF->setHasInstructions(STI);
+  DF->getContents().append(Code.begin(), Code.end());
 }
 
 MCStreamer *llvm::createXCOFFStreamer(MCContext &Context,
                                       std::unique_ptr<MCAsmBackend> &&MAB,
                                       std::unique_ptr<MCObjectWriter> &&OW,
                                       std::unique_ptr<MCCodeEmitter> &&CE,
                                       bool RelaxAll) {
   MCXCOFFStreamer *S = new MCXCOFFStreamer(Context, std::move(MAB),
                                            std::move(OW), std::move(CE));

llvm/lib/MC/XCOFFObjectWriter.cpp

 
 constexpr unsigned DefaultSectionAlign = 4;
 
 // Packs the csect's alignment and type into a byte.
 uint8_t getEncodedType(const MCSectionXCOFF *);
 
 // Wrapper around an MCSymbolXCOFF.
 struct Symbol {
   const MCSymbolXCOFF *const MCSym;
   uint32_t SymbolTableIndex;
 
   XCOFF::StorageClass getStorageClass() const {
     return MCSym->getStorageClass();
   }
   StringRef getName() const { return MCSym->getName(); }
-  bool nameInStringTable() const {
-    return MCSym->getName().size() > XCOFF::NameSize;
-  }
-
   Symbol(const MCSymbolXCOFF *MCSym) : MCSym(MCSym), SymbolTableIndex(-1) {}
 };
 
 // Wrapper for an MCSectionXCOFF.
 struct ControlSection {
   const MCSectionXCOFF *const MCCsect;
   uint32_t SymbolTableIndex;
   uint32_t Address;
   uint32_t Size;
+  uint32_t PaddingSize;
 
   SmallVector<Symbol, 1> Syms;
-
+  StringRef getName() const { return MCCsect->getSectionName(); }
   ControlSection(const MCSectionXCOFF *MCSec)
-      : MCCsect(MCSec), SymbolTableIndex(-1), Address(-1) {}
+      : MCCsect(MCSec), SymbolTableIndex(-1), Address(-1), Size(0),
+        PaddingSize(0) {}
 };
 
 // Represents the data related to a section excluding the csects that make up
 // the raw data of the section. The csects are stored separately as not all
 // sections contain csects, and some sections contain csects which are better
 // stored separately, e.g. the .data section containing read-write, descriptor,
 // TOCBase and TOC-entry csects.
 struct Section {
   char Name[XCOFF::NameSize];
   // The physical/virtual address of the section. For an object file
   // these values are equivalent.
   uint32_t Address;
   uint32_t Size;
+  uint32_t PaddingSize;
   uint32_t FileOffsetToData;
   uint32_t FileOffsetToRelocations;
   uint32_t RelocationCount;
   int32_t Flags;
 
-  uint16_t Index;
+  int16_t Index;
 
   // Virtual sections do not need storage allocated in the object file.
   const bool IsVirtual;
 
   void reset() {
     Address = 0;
     Size = 0;
+    PaddingSize = 0;
     FileOffsetToData = 0;
     FileOffsetToRelocations = 0;
     RelocationCount = 0;
     Index = -1;
   }
 
   Section(const char *N, XCOFF::SectionTypeFlags Flags, bool IsVirtual)
-      : Address(0), Size(0), FileOffsetToData(0), FileOffsetToRelocations(0),
-        RelocationCount(0), Flags(Flags), Index(-1), IsVirtual(IsVirtual) {
+      : Address(0), Size(0), PaddingSize(0), FileOffsetToData(0),
+        FileOffsetToRelocations(0), RelocationCount(0), Flags(Flags), Index(-1),
+        IsVirtual(IsVirtual) {
     strncpy(Name, N, XCOFF::NameSize);
   }
 };
 
 class XCOFFObjectWriter : public MCObjectWriter {
   // Type to be used for a container representing a set of csects with
   // (approximately) the same storage mapping class. For example all the csects
   // with a storage mapping class of `xmc_pr` will get placed into the same
class XCOFFObjectWriter : public MCObjectWriter {
 
   void executePostLayoutBinding(MCAssembler &, const MCAsmLayout &) override;
 
   void recordRelocation(MCAssembler &, const MCAsmLayout &, const MCFragment *,
                         const MCFixup &, MCValue, uint64_t &) override;
 
   uint64_t writeObject(MCAssembler &, const MCAsmLayout &) override;
 
+  bool nameShouldBeInStringTable(const StringRef &);
+  void writeSymbolName(const StringRef &);
+  void writeSymbolTableEntryForCsectMemberLabel(const Symbol &,
+                                                const ControlSection &, int16_t,
+                                                uint64_t);
+  void writeSymbolTableEntryForControlSection(const ControlSection &, int16_t,
+                                              XCOFF::StorageClass);
   void writeFileHeader();
   void writeSectionHeaderTable();
-  void writeSymbolTable();
+  void writeSections(const MCAssembler &Asm, const MCAsmLayout &Layout);
+  void writeSymbolTable(const MCAsmLayout &Layout);
 
   // Called after all the csects and symbols have been processed by
   // `executePostLayoutBinding`, this function handles building up the majority
   // of the structures in the object file representation. Namely:
   // *) Calculates physical/virtual addresses, raw-pointer offsets, and section
   //    sizes.
   // *) Assigns symbol table indices.
   // *) Builds up the section header table by adding any non-empty sections to
   //    `Sections`.
-  void assignAddressesAndIndices(const llvm::MCAsmLayout &);
+  void assignAddressesAndIndices(const MCAsmLayout &);
 
   bool
   needsAuxiliaryHeader() const { /* TODO aux header support not implemented. */
     return false;
   }
 
   // Returns the size of the auxiliary header to be written to the object file.
   size_t auxiliaryHeaderSize() const {
void XCOFFObjectWriter::reset() {
   // Reset the symbol table and string table.
   SymbolTableEntryCount = 0;
   SymbolTableOffset = 0;
   Strings.clear();
 
   MCObjectWriter::reset();
 }
 
-void XCOFFObjectWriter::executePostLayoutBinding(
-    llvm::MCAssembler &Asm, const llvm::MCAsmLayout &Layout) {
+void XCOFFObjectWriter::executePostLayoutBinding(MCAssembler &Asm,
+                                                 const MCAsmLayout &Layout) {
   if (TargetObjectWriter->is64Bit())
     report_fatal_error("64-bit XCOFF object files are not supported yet.");
 
   // Maps the MC Section representation to its corresponding ControlSection
   // wrapper. Needed for finding the ControlSection to insert an MCSymbol into
   // from its containing MCSectionXCOFF.
   DenseMap<const MCSectionXCOFF *, ControlSection *> WrapperMap;
 
   for (const auto &S : Asm) {
     const MCSectionXCOFF *MCSec = dyn_cast<const MCSectionXCOFF>(&S);
     assert(WrapperMap.find(MCSec) == WrapperMap.end() &&
            "Cannot add a csect twice.");
 
+    // If the name does not fit in the storage provided in the symbol table
+    // entry, add it to the string table.
+    if (nameShouldBeInStringTable(MCSec->getSectionName()))
+      Strings.add(MCSec->getSectionName());
+
     switch (MCSec->getMappingClass()) {
     case XCOFF::XMC_PR:
       assert(XCOFF::XTY_SD == MCSec->getCSectType() &&
              "Only an initialized csect can contain program code.");
-      // TODO FIXME Handle .text section csects.
+      ProgramCodeCsects.emplace_back(MCSec);
+      WrapperMap[MCSec] = &ProgramCodeCsects.back();
       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.");
for (const MCSymbol &S : Asm.symbols()) {
     assert(WrapperMap.find(ContainingCsect) != WrapperMap.end() &&
            "Expected containing csect to exist in map");
 
     // Lookup the containing csect and add the symbol to it.
     WrapperMap[ContainingCsect]->Syms.emplace_back(XSym);
 
     // If the name does not fit in the storage provided in the symbol table
     // entry, add it to the string table.
-    const Symbol &WrapperSym = WrapperMap[ContainingCsect]->Syms.back();
-    if (WrapperSym.nameInStringTable()) {
-      Strings.add(WrapperSym.getName());
-    }
+    if (nameShouldBeInStringTable(XSym->getName()))
+      Strings.add(XSym->getName());
     }
 
   Strings.finalize();
   assignAddressesAndIndices(Layout);
 }
 
 void XCOFFObjectWriter::recordRelocation(MCAssembler &, const MCAsmLayout &,
                                          const MCFragment *, const MCFixup &,
                                          MCValue, uint64_t &) {
   report_fatal_error("XCOFF relocations not supported.");
 }
 
-uint64_t XCOFFObjectWriter::writeObject(MCAssembler &Asm, const MCAsmLayout &) {
+void XCOFFObjectWriter::writeSections(const MCAssembler &Asm,
+                                      const MCAsmLayout &Layout) {
+  // Write the program code control sections one at a time.
+  for (const auto &Csect : ProgramCodeCsects) {
+    if (Csect.PaddingSize)
+      W.OS.write_zeros(Csect.PaddingSize);
+    Asm.writeSectionData(W.OS, Csect.MCCsect, Layout);
+  }
+
+  if (ProgramCodeCsects.size() && Text.PaddingSize)
+    W.OS.write_zeros(Text.PaddingSize);
+}
+
+uint64_t XCOFFObjectWriter::writeObject(MCAssembler &Asm,
+                                        const MCAsmLayout &Layout) {
   // We always emit a timestamp of 0 for reproducibility, so ensure incremental
   // linking is not enabled, in case, like with Windows COFF, such a timestamp
   // is incompatible with incremental linking of XCOFF.
   if (Asm.isIncrementalLinkerCompatible())
     report_fatal_error("Incremental linking not supported for XCOFF.");
 
   if (TargetObjectWriter->is64Bit())
     report_fatal_error("64-bit XCOFF object files are not supported yet.");
 
   uint64_t StartOffset = W.OS.tell();
 
   writeFileHeader();
   writeSectionHeaderTable();
-  // TODO writeSections();
+  writeSections(Asm, Layout);
   // TODO writeRelocations();
 
-  // TODO FIXME Finalize symbols.
-  writeSymbolTable();
+  writeSymbolTable(Layout);
   // Write the string table.
   Strings.write(W.OS);
 
   return W.OS.tell() - StartOffset;
 }
 
+bool XCOFFObjectWriter::nameShouldBeInStringTable(const StringRef &SymbolName) {
+  return SymbolName.size() > XCOFF::NameSize;
+}
+
+void XCOFFObjectWriter::writeSymbolName(const StringRef &SymbolName) {
+  if (nameShouldBeInStringTable(SymbolName)) {
+    W.write<int32_t>(0);
+    W.write<uint32_t>(Strings.getOffset(SymbolName));
+  } else {
+    char Name[XCOFF::NameSize];
+    std::strncpy(Name, SymbolName.data(), XCOFF::NameSize);
+    ArrayRef<char> NameRef(Name, XCOFF::NameSize);
+    W.write(NameRef);
+  }
+}
+
+void XCOFFObjectWriter::writeSymbolTableEntryForCsectMemberLabel(
+    const Symbol &SymbolRef, const ControlSection &CSectionRef,
+    int16_t SectionIndex, uint64_t SymbolOffset) {
+  // Name or Zeros and string table offset
+  writeSymbolName(SymbolRef.getName());
+
+  W.write<uint32_t>(CSectionRef.Address + SymbolOffset);
+  W.write<int16_t>(SectionIndex);
+  // Basic/Derived type. See the description of the n_type field for symbol
+  // table entries for a detailed description. Since we don't yet support
+  // visibility, and all other bits are either optionally set or reserved, this
+  // is always zero.
+  // TODO FIXME How to assert a symbol's visibilty is default?
+  // TODO Set the function indicator (bit 10, 0x0020) for functions
+  // when debugging is enabled.
+  W.write<uint16_t>(0);
+  W.write<uint8_t>(SymbolRef.getStorageClass());
+  // Always 1 aux entry for now.
+  W.write<uint8_t>(1);
+
+  // Now output the auxiliary entry.
+  W.write<uint32_t>(CSectionRef.SymbolTableIndex);
+  // Parameter typecheck hash. Not supported.
+  W.write<uint32_t>(0);
+  // Typecheck section number. Not supported.
+  W.write<uint16_t>(0);
+  // Symbol type: Label
+  W.write<uint8_t>(XCOFF::XTY_LD);
+  // Storage mapping class.
+  W.write<uint8_t>(CSectionRef.MCCsect->getMappingClass());
+  // Reserved (x_stab).
+  W.write<uint32_t>(0);
+  // Reserved (x_snstab).
+  W.write<uint16_t>(0);
+}
+
+void XCOFFObjectWriter::writeSymbolTableEntryForControlSection(
+    const ControlSection &CSectionRef, int16_t SectionIndex,
+    XCOFF::StorageClass StorageClass) {
+  // n_name, n_zeros, n_offset
+  writeSymbolName(CSectionRef.getName());
+  // n_value
+  W.write<uint32_t>(CSectionRef.Address);
+  // n_scnum
+  W.write<int16_t>(SectionIndex);
+  // Basic/Derived type. See the description of the n_type field for symbol
+  // table entries for a detailed description. Since we don't yet support
+  // visibility, and all other bits are either optionally set or reserved, this
+  // is always zero.
+  // TODO FIXME How to assert a symbol's visibilty is default?
+  // TODO Set the function indicator (bit 10, 0x0020) for functions
+  // when debugging is enabled.
+  W.write<uint16_t>(0);
+  // n_sclass
+  W.write<uint8_t>(StorageClass);
+  // Always 1 aux entry for now.
+  W.write<uint8_t>(1);
+
+  // Now output the auxiliary entry.
+  W.write<uint32_t>(CSectionRef.Size);
+  // Parameter typecheck hash. Not supported.
+  W.write<uint32_t>(0);
+  // Typecheck section number. Not supported.
+  W.write<uint16_t>(0);
+  // Symbol type.
+  W.write<uint8_t>(getEncodedType(CSectionRef.MCCsect));
+  // Storage mapping class.
+  W.write<uint8_t>(CSectionRef.MCCsect->getMappingClass());
+  // Reserved (x_stab).
+  W.write<uint32_t>(0);
+  // Reserved (x_snstab).
+  W.write<uint16_t>(0);
+}
+
 void XCOFFObjectWriter::writeFileHeader() {
   // Magic.
   W.write<uint16_t>(0x01df);
   // Number of sections.
   W.write<uint16_t>(Sections.size());
   // Timestamp field. For reproducible output we write a 0, which represents no
   // timestamp.
   W.write<int32_t>(0);
for (const auto *Sec : Sections) {
     // Relocation and line-number counts. Not supported yet.
     W.write<uint16_t>(0);
     W.write<uint16_t>(0);
 
     W.write<int32_t>(Sec->Flags);
   }
 }
 
-void XCOFFObjectWriter::writeSymbolTable() {
-  assert(ProgramCodeCsects.size() == 0 && ".text csects not handled yet.");
+void XCOFFObjectWriter::writeSymbolTable(const MCAsmLayout &Layout) {
+  // Print out symbol table for the program code.
+  for (const auto &Csect : ProgramCodeCsects) {
+    // Write out the control section first and then each symbol in it.
+    writeSymbolTableEntryForControlSection(Csect, Text.Index,
+                                           Csect.MCCsect->getStorageClass());
+    for (const auto &Sym : Csect.Syms) {
+      writeSymbolTableEntryForCsectMemberLabel(
+          Sym, Csect, Text.Index, Layout.getSymbolOffset(*(Sym.MCSym)));
+    }
+  }
 
   // The BSS Section is special in that the csects must contain a single symbol,
   // and the contained symbol cannot be represented in the symbol table as a
   // label definition.
-  for (auto &Sec : BSSCsects) {
-    assert(Sec.Syms.size() == 1 &&
+  for (auto &Csect : BSSCsects) {
+    assert(Csect.Syms.size() == 1 &&
            "Uninitialized csect cannot contain more then 1 symbol.");
-    Symbol &Sym = Sec.Syms.back();
-
-    // Write the symbol's name.
-    if (Sym.nameInStringTable()) {
-      W.write<int32_t>(0);
-      W.write<uint32_t>(Strings.getOffset(Sym.getName()));
-    } else {
-      char Name[XCOFF::NameSize];
-      std::strncpy(Name, Sym.getName().data(), XCOFF::NameSize);
-      ArrayRef<char> NameRef(Name, XCOFF::NameSize);
-      W.write(NameRef);
-    }
-
-    W.write<uint32_t>(Sec.Address);
-    W.write<int16_t>(BSS.Index);
-    // Basic/Derived type. See the description of the n_type field for symbol
-    // table entries for a detailed description. Since we don't yet support
-    // visibility, and all other bits are either optionally set or reserved,
-    // this is always zero.
-    // TODO FIXME How to assert a symbols visibility is default?
-    W.write<uint16_t>(0);
-
-    W.write<uint8_t>(Sym.getStorageClass());
-
-    // Always 1 aux entry for now.
-    W.write<uint8_t>(1);
-
-    W.write<uint32_t>(Sec.Size);
-
-    // Parameter typecheck hash. Not supported.
-    W.write<uint32_t>(0);
-    // Typecheck section number. Not supported.
-    W.write<uint16_t>(0);
-    // Symbol type.
-    W.write<uint8_t>(getEncodedType(Sec.MCCsect));
-    // Storage mapping class.
-    W.write<uint8_t>(Sec.MCCsect->getMappingClass());
-    // Reserved (x_stab).
-    W.write<uint32_t>(0);
-    // Reserved (x_snstab).
-    W.write<uint16_t>(0);
+    Symbol &Sym = Csect.Syms.back();
+    writeSymbolTableEntryForControlSection(Csect, BSS.Index,
+                                           Sym.getStorageClass());
   }
 }
 
-void XCOFFObjectWriter::assignAddressesAndIndices(
-    const llvm::MCAsmLayout &Layout) {
+void XCOFFObjectWriter::assignAddressesAndIndices(const MCAsmLayout &Layout) {
   // The address corrresponds to the address of sections and symbols in the
   // object file. We place the shared address 0 immediately after the
   // section header table.
   uint32_t Address = 0;
   // Section indices are 1-based in XCOFF.
-  uint16_t SectionIndex = 1;
+  int16_t SectionIndex = 1;
   // The first symbol table entry is for the file name. We are not emitting it
   // yet, so start at index 0.
   uint32_t SymbolTableIndex = 0;
 
-  // Text section comes first. TODO
+  // Text section comes first.
+  if (!ProgramCodeCsects.empty()) {
+    Sections.push_back(&Text);
+    Text.Index = SectionIndex++;
+    Text.Address = Address;
+    for (auto &Csect : ProgramCodeCsects) {
+      const MCSectionXCOFF *MCSec = Csect.MCCsect;
+      Csect.PaddingSize = alignTo(Address, MCSec->getAlignment()) - Address;
+      Address += Csect.PaddingSize;
+      Csect.Address = Address;
+      Address += Layout.getSectionAddressSize(MCSec);
+      Csect.SymbolTableIndex = SymbolTableIndex;
+      // 1 main and 1 auxiliary symbol table entry for the csect.
+      SymbolTableIndex += 2;
+      Csect.Size = Layout.getSectionAddressSize(MCSec);
+      for (auto &Sym : Csect.Syms) {
+        Sym.SymbolTableIndex = SymbolTableIndex;
+        // 1 main and 1 auxiliary symbol table entry for each contained symbol
+        SymbolTableIndex += 2;
+      }
+    }
+    Text.PaddingSize = alignTo(Address, DefaultSectionAlign) - Address;
+    Address += Text.PaddingSize;
+    Text.Size = Address - Text.Address;
+  }
+
   // Data section Second. TODO
 
   // BSS Section third.
   if (!BSSCsects.empty()) {
     Sections.push_back(&BSS);
     BSS.Index = SectionIndex++;
-    assert(alignTo(Address, DefaultSectionAlign) == Address &&
-           "Improperly aligned address for section.");
-    uint32_t StartAddress = Address;
+    // We use alignment Address of previous section as BSS start Address, it
+    // maybe not need.
+    BSS.Address = Address;
     for (auto &Csect : BSSCsects) {
       const MCSectionXCOFF *MCSec = Csect.MCCsect;
-      Address = alignTo(Address, MCSec->getAlignment());
+      Csect.PaddingSize = alignTo(Address, MCSec->getAlignment()) - Address;
+      Address += Csect.PaddingSize;
       Csect.Address = Address;
       Address += Layout.getSectionAddressSize(MCSec);
       Csect.SymbolTableIndex = SymbolTableIndex;
       // 1 main and 1 auxiliary symbol table entry for the csect.
       SymbolTableIndex += 2;
       Csect.Size = Layout.getSectionAddressSize(MCSec);
 
       assert(Csect.Syms.size() == 1 &&
              "csect in the BSS can only contain a single symbol.");
       Csect.Syms[0].SymbolTableIndex = Csect.SymbolTableIndex;
     }
     // Pad out Address to the default alignment. This is to match how the system
     // assembler handles the .bss section. Its size is always a multiple of 4.
-    Address = alignTo(Address, DefaultSectionAlign);
-    BSS.Size = Address - StartAddress;
+    BSS.PaddingSize = alignTo(Address, DefaultSectionAlign) - Address;
+    Address += BSS.PaddingSize;
+    BSS.Size = Address - BSS.Address;
   }
 
   SymbolTableEntryCount = SymbolTableIndex;
 
   // Calculate the RawPointer value for each section.
   uint64_t RawPointer = sizeof(XCOFF::FileHeader32) + auxiliaryHeaderSize() +
                         Sections.size() * sizeof(XCOFF::SectionHeader32);
   for (auto *Sec : Sections) {

llvm/test/CodeGen/PowerPC/aix-return55.ll

+; RUN: llc -mcpu=pwr9 -mtriple=powerpc-ibm-aix-xcoff -verify-machineinstrs < %s | FileCheck %s
+
+
+define dso_local signext i32 @foo() {
+entry:
+  ret i32 55
+; CHECK-LABEL: .foo
+; CHECK: li 3, 55
+; CHECK: blr
+}
+

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

 ; XCOFF64: LLVM ERROR: 64-bit XCOFF object files are not supported yet.
 
 @a = common global i32 0, align 4
 @b = common global i64 0, align 8
 @c = common global i16 0, align 2
 
 @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
 ; CHECK-NEXT: .comm   array,33,0
 
 ; OBJ:      File: {{.*}}aix-xcoff-common.ll.tmp.o
 ; OBJ-NEXT: Format: aixcoff-rs6000
 ; OBJ-NEXT: Arch: powerpc
 ; OBJ-NEXT: AddressSize: 32bit
 ; OBJ-NEXT: FileHeader {
 ; OBJ-NEXT:   Magic: 0x1DF
-; OBJ-NEXT:   NumberOfSections: 1
+; OBJ-NEXT:   NumberOfSections: 2
 ; OBJ-NEXT:   TimeStamp:
-; OBJ-NEXT:   SymbolTableOffset: 0x3C
-; OBJ-NEXT:   SymbolTableEntries: 14
+; OBJ-NEXT:   SymbolTableOffset: 0x64
+; OBJ-NEXT:   SymbolTableEntries: 16
 ; OBJ-NEXT:   OptionalHeaderSize: 0x0
 ; OBJ-NEXT:   Flags: 0x0
 ; OBJ-NEXT: }
 ; OBJ-NEXT: Sections [
 ; OBJ-NEXT:   Section {
 ; OBJ-NEXT:     Index: 1
+; OBJ-NEXT:     Name: .text
+; OBJ-NEXT:     PhysicalAddress: 0x0
+; OBJ-NEXT:     VirtualAddress: 0x0
+; OBJ-NEXT:     Size: 0x0
+; OBJ-NEXT:     RawDataOffset: 0x64
+; OBJ-NEXT:     RelocationPointer: 0x0
+; OBJ-NEXT:     LineNumberPointer: 0x0
+; OBJ-NEXT:     NumberOfRelocations: 0
+; OBJ-NEXT:     NumberOfLineNumbers: 0
+; OBJ-NEXT:     Type: STYP_TEXT (0x20)
+; OBJ-NEXT:   }
+; OBJ-NEXT:   Section {
+; OBJ-NEXT:     Index: 2
 ; OBJ-NEXT:     Name: .bss
 ; OBJ-NEXT:     PhysicalAddress: 0x0
 ; OBJ-NEXT:     VirtualAddress: 0x0
 ; OBJ-NEXT:     Size: 0x6C
 ; OBJ-NEXT:     RawDataOffset: 0x0
 ; OBJ-NEXT:     RelocationPointer: 0x0
 ; OBJ-NEXT:     LineNumberPointer: 0x0
 ; OBJ-NEXT:     NumberOfRelocations: 0
 ; OBJ-NEXT:     NumberOfLineNumbers: 0
 ; OBJ-NEXT:     Type: STYP_BSS (0x80)
 ; OBJ-NEXT:   }
 ; OBJ-NEXT: ]
 
 ; SYMS:      File: {{.*}}aix-xcoff-common.ll.tmp.o
 ; SYMS-NEXT: Format: aixcoff-rs6000
 ; SYMS-NEXT: Arch: powerpc
 ; SYMS-NEXT: AddressSize: 32bit
 ; SYMS-NEXT: Symbols [
 ; SYMS-NEXT:   Symbol {
-; SYMS-NEXT:     Index: [[#Index:]]
-; SYMS-NEXT:     Name: a
+; SYMS:          Index: [[#Index:]]{{[[:space:]].*}}Name: a
 ; SYMS-NEXT:     Value (RelocatableAddress): 0x0
 ; SYMS-NEXT:     Section: .bss
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_EXT (0x2)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-NEXT:       Index: [[#Index + 1]]
 ; SYMS-NEXT:       SectionLen: 4

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

 ; CHECK-NEXT: .lcomm c,2,c,1
 
 ; OBJ:      File: {{.*}}aix-xcoff-lcomm.ll.tmp.o
 ; OBJ-NEXT: Format: aixcoff-rs6000
 ; OBJ-NEXT: Arch: powerpc
 ; OBJ-NEXT: AddressSize: 32bit
 ; OBJ-NEXT: FileHeader {
 ; OBJ-NEXT:   Magic: 0x1DF
-; OBJ-NEXT:   NumberOfSections: 1
+; OBJ-NEXT:   NumberOfSections: 2
 ; OBJ-NEXT:   TimeStamp:
-; OBJ-NEXT:   SymbolTableOffset: 0x3C
-; OBJ-NEXT:   SymbolTableEntries: 6
+; OBJ-NEXT:   SymbolTableOffset: 0x64
+; OBJ-NEXT:   SymbolTableEntries: 8
 ; OBJ-NEXT:   OptionalHeaderSize: 0x0
 ; OBJ-NEXT:   Flags: 0x0
 ; OBJ-NEXT: }
 ; OBJ-NEXT: Sections [
-; OBJ-NEXT:   Section {
-; OBJ-NEXT:     Index: 1
+; OBJ:        Section {
+; OBJ:          Index: 2
 ; OBJ-NEXT:     Name: .bss
 ; OBJ-NEXT:     PhysicalAddress: 0x0
 ; OBJ-NEXT:     VirtualAddress: 0x0
 ; OBJ-NEXT:     Size: 0x14
 ; OBJ-NEXT:     RawDataOffset: 0x0
 ; OBJ-NEXT:     RelocationPointer: 0x0
 ; OBJ-NEXT:     LineNumberPointer: 0x0
 ; OBJ-NEXT:     NumberOfRelocations: 0
 ; OBJ-NEXT:     NumberOfLineNumbers: 0
 ; OBJ-NEXT:     Type: STYP_BSS (0x80)
 ; OBJ-NEXT:   }
 ; OBJ-NEXT: ]
 
 ; SYMS:      File: {{.*}}aix-xcoff-lcomm.ll.tmp.o
 ; SYMS-NEXT: Format: aixcoff-rs6000
 ; SYMS-NEXT: Arch: powerpc
 ; SYMS-NEXT: AddressSize: 32bit
 ; SYMS-NEXT: Symbols [
 ; SYMS-NEXT:   Symbol {
-; SYMS-NEXT:     Index: [[#Index:]]
-; SYMS-NEXT:     Name: a
+; SYMS:          Index: [[#Index:]]{{[[:space:]].*}}Name: a
 ; SYMS-NEXT:     Value (RelocatableAddress): 0x0
 ; SYMS-NEXT:     Section: .bss
 ; SYMS-NEXT:     Type: 0x0
 ; SYMS-NEXT:     StorageClass: C_HIDEXT (0x6B)
 ; SYMS-NEXT:     NumberOfAuxEntries: 1
 ; SYMS-NEXT:     CSECT Auxiliary Entry {
 ; SYMS-NEXT:       Index: [[#Index + 1]]
 ; SYMS-NEXT:       SectionLen: 4