[PowerPC][XCOFF] Adds support for writing the .bss section for object files.

[sfertile]

Summary

Adds support for writing the .bss section for XCOFF object files.

Adds Wrapper classes for MCSymbol and MCSection into the XCOFF target
object writer. Also adds a class to represent the top-level sections, which we
materialize in the ObjectWriter.

executePostLayoutBinding will map all csects into the appropriate
container depending on its storage mapping class, and map all symbols
into their containing csect. Once all symbols have been processed we
- Assign addresses and symbol table indices.
- Calculate section sizes.
- Build the section header table.
- Assign the sections paw_pointer value for non-virtual sections.

Since the .bss section is virtual, writing the header table is enough to
add support. Writing of a sections raw data, or of any relocations is
not included in this patch.

Testing is done by dumping the section header table, but it needs to be
extended to include dumping the symbol table once readobj support for
dumping auxiliary entries lands.

[sfertile]

ping

[hubert.reinterpretcast]

This patch needs a rebase. It no longer applies cleanly.

[hubert.reinterpretcast]

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

4

As mentioned in your patch summary, there should be a follow-up patch to this (dependent on D65240) that checks the symbol table entries. Just putting the comment here in-line to help track it.

[hubert.reinterpretcast]

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

1846

One or the other of D64825 or this needs to be rebased on the other when one lands.

[sfertile]

Rebased.

[daltenty]

I think this patch needs to be rebased again now that D64825 has landed

[jasonliu]

llvm/lib/MC/XCOFFObjectWriter.cpp

422

We effectively only have BSS symbol's MCSection(CSect) entry in the symbol table, but not BSS symbol's MCSymbol.
So BSS symbol's MCSymbol symbol table index should be the same as the BSS CSect's symbol table index, otherwise we would skip some symbol table index.

[jasonliu]

llvm/lib/MC/XCOFFObjectWriter.cpp

422

Sorry... ignore the above comments. You already did what I think we should do.

[sfertile]

Rebased.

[daltenty]

LGTM

[sfertile]

Rebased to reflect changes made in https://reviews.llvm.org/rL368584

[DiggerLin]

llvm/include/llvm/BinaryFormat/XCOFF.h

152

I think we should use the same name st NumberOfSections for same as in the XCOFFObjectFile.h ?

155

ditto, NumberOfSymTableEntries in the XCOFFObjectFile.h

llvm/lib/MC/XCOFFObjectWriter.cpp

186

the element of the sections is cleared, I do no think we need to reset every element here

[xingxue]

LGTM.

llvm/include/llvm/MC/StringTableBuilder.h

25

Nit: add a space after XCOFF.

[DiggerLin]

llvm/lib/MC/XCOFFObjectWriter.cpp

118

Do we need to add assert here for the strlen(N) <= XCOFF::NameSize ?

186

Sorry, please ignore the comment, the Sections is the vector of Section*.

[sfertile]

llvm/include/llvm/MC/StringTableBuilder.h

25

Thanks. I've updated this locally but don't plan to update the diff unless there are any other changes requested before I commit.

llvm/lib/MC/XCOFFObjectWriter.cpp

118

I had considered this, since passing a name longer then that would definitely be an error. The reason I didn't add it was because I figured whenever we add support for a new section, we will have accompanying lit testing, which would (hopefully) catch that we added the section with the wrong name.

• I have an implicit assumption here that we will be using the 'conventional' name for each of the section types we add support for.

[DiggerLin]

llvm/lib/MC/XCOFFObjectWriter.cpp

405

Can we use a function for the code line 405~432, I think the Text section and Data section maybe use the same code later

[hubert.reinterpretcast]

llvm/include/llvm/MC/MCSymbolXCOFF.h

27

If possible, we should have this initialized in the constructor. Failing that, we should use have a way to check that it has been initialized and assert in the accessor when it is not.

[hubert.reinterpretcast]

llvm/lib/MC/MCXCOFFStreamer.cpp

35–49

Please revert the accidental whitespace change.

37

I recommend removing the extra parentheses.

48

I would recommend picking up the default argument values instead of specifying them explicitly as magic numbers with no context.

llvm/lib/MC/StringTableBuilder.cpp

72

Comma after "AIX".

[hubert.reinterpretcast]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1670

Comma before the "and".

1673

Use clang-format.

[hubert.reinterpretcast]

llvm/lib/MC/XCOFFObjectWriter.cpp

31

+ read-only data

32

s/intialized/initialized/;
Add a comma before "and".

37

There are .bss and .data section csects with XMC_RW storage mapping class.

50

s/csects/csect's/;

55

Does this need to be modifiable? If not, please make this const.

71

Does this need to be modifiable? If not, please make this const.

85

s/seperatly/separately/;
s/ eg:/, e.g.,/;

285–288

Is the plan to have 64-bit versions of the functions? If the plan is to use the same functions, then having 64-bit guards on all of them now might make sense.

342

"The" before "BSS Section".

s/unique/special/;

External references behave similarly, and it is permitted to generate other csects "[containing] a single symbol" without a label definition by emitting the csect with a form of external linkage and using the linkage name of the symbol for the csect.

343

Missing "the" before "contained symbol".
s/does not need/cannot be represented in the symbol table as/;

349

s/symbols/symbol's/;

369

Newline after this to clarify the binding of the comment.

373

Newline after this to clarify the binding of the comment.

428

s/4 byte/4-byte/;

429

s/It's/Its/;

453

Fix the consecutive spaces.

[hubert.reinterpretcast]

I am still working through this version, but I think this might need another pass on an updated copy.

llvm/lib/MC/XCOFFObjectWriter.cpp

44

My observations of the XLC and GCC behaviour on AIX does not support what this patch does with this value. Namely, it is observed that the physical/virtual address assigned to the .bss section is not necessarily 16-byte aligned.

70

If we mean ControlSection32, then let us name it that. Otherwise, I suggest adding in the FIXMEs for 64-bit support now.

317

I suspect const auto *Sec is intended. As it is, we get a const pointer to non-const.

421

• The unary + looks to be stray.
• s/Csects/CSects/;

426

Please indicate why += and why the multiplication instead of using SymbolTableIndex.

435

I suggest adding in the auxiliary header size even if it is currently always zero.

437

auto *Sec to be consistent (and I like to be explicit on expecting a pointer anyway).

445

s/too/to/;

456

I'm not sure where we should address this, but it seems both XLC and GCC generate at least 4-byte alignment by default.

458

I believe it is more robust to use Sec->getCSectType() <= 0x07u.

Also:
s/Csect/CSect/;
s/3-bits/3 bits./;

462

To improve clarity, use "OR" or "bitwise-or" to represent the operation.

463

The & 0xFF does nothing?

[DiggerLin]

llvm/lib/MC/XCOFFObjectWriter.cpp

422

it looks Csect.Syms[0].SymbolTableIndex only assigned here, but never been used anywhere, it is I think we delete it here and delete the define of SymbolTableIndex in the Symbol structure.

[sfertile]

Rebased and addressed numerous review comments.

llvm/include/llvm/BinaryFormat/XCOFF.h

152

Sorry I missed this comment yesterday and didn't address it when responding to the others. I've updated it now. Not all the names are exactly the same, for example I 've used SymbolTableFileOffset instead SymbolTableOffset and skipped the comment explaining 'Offset` means 'FileOffset` in this context.

llvm/lib/MC/XCOFFObjectWriter.cpp

405

We can, but the handling is subtly different for different sections: symbol index assignment is different between the .bss sections and other sections. .data will have multiple sets of different csects that get mapped into it, etc. We will likely need to separate address/offset assignments from symbol table building, and I think we will want to have other sections implemented before trying to common up the code.

[sfertile]

llvm/include/llvm/BinaryFormat/XCOFF.h

155

Updated.

llvm/include/llvm/MC/MCSymbolXCOFF.h

27

Because of the way MCSymbols are created we won't be able to pass in a value to the constructor, so we will need a way to check if the Storage class has been set. I don't want to add an 'Uninitialized` enum value and we can't just use the obvious -1 since that is C_EFCN. What are peoples thoughts on using an optional<StorageClass> as the member?

llvm/lib/MC/XCOFFObjectWriter.cpp

44

I think we chose a default of 16 for all sections to keep it simple, after seeing that gcc aligned .data to 16 bytes, but other sections only to 4.

285–288

I haven't given any consideration on how we want to split the 32-bit/64-bit functionality yet.

422

In general a symbol needs a symbol table index, however the symbols we map to the .bss section are special in that they don't get a label-def so their symbol table index is the index of their containing csect. I've included setting the SymbolTableIndex because it shows that a symbol in the .bss not getting a unique symbol table entry is the desired behavior, as opposed to it was simply forgotten. . If you feel strongly about it I can remove it from this patch, and we will need to add it back when we either add support for .text/,data sections or when we add support for emitting relocations.

426

Changed to use SymbolTableIndex.

456

I believe @xingxue looked into this and may have an answer to where/how we intend to address this.

458

Updated. Most of the tools and documentation use either CSECT or csect. In these error messages 'csect' is the first word so I am capitalizing it. Should we always stick to 'CSect', and why?

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1673

I did: I use clang format enabled in vim. I also tried formatting with git-clang-format and end up with the same formating as my vim integration. What formatting do you get when you format this?

[hubert.reinterpretcast]

llvm/include/llvm/MC/MCSymbolXCOFF.h

27

I would be in favour of doing that.

llvm/lib/MC/XCOFFObjectWriter.cpp

38

s/of its/whether it's/;

44

This is from a GCC-compiled object file; the .data section is not 16-byte aligned:

                         Section Header for .data
PHYaddr      VTRaddr     SCTsiz      RAWptr      RELptr
0x00000004  0x00000004  0x00000014  0x00000068  0x0000007c

180

Period at the end of the sentence.

285–288

Being clear in each function about its applicability to the 64-bit support is something that factors into the review. We can name the functions as being 32-bit specific, and then we are clear that the function has not been evaluated for 64-bit support. Even if we decide later that some of these functions should be common between the 32-bit and 64-bit paths, I believe it is less harmful to have a clearly 32-bit specific version of the function in the first place than to have cases with ambiguous scope.

If we know up front that some cases will be common, then we should be clear about those cases too (by adding the appropriate TODOs).

422

I prefer to keep the assignment in.

458

Why did we name the functions CSect? I don't see why we need different styles for how to capitalize "csect".

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1673

You did, and the formatting did change. There is now one more space on the second line.

[DiggerLin]

LGTM

[sfertile]

Changed MCSymbolXCOFF StorageClass member to be an optional<StorageClass> and added asserts checking for redefineing the storage class and accessing an unset storage class.
Minor comment changes.

llvm/lib/MC/XCOFFObjectWriter.cpp

44

I'm thoroughly confused at this point. gcc emits assembly and for a bunch of different test cases and it consistently emits .csect .data[RW], 4. According the the AIX assembly language reference, the expression after the csect name and storage mapping class is the log base-2 of alignment. Even with this alignment, some tools report the .data sections alignment as 2^3, some as 16, and the virtual address assigned to it typically ends up being only 4-byte aligned as you observed. I'm probably mistaking the .data csect for the .data sections alignment in some of these cases, but even if the .data section contains a 16 byte aligned .data csect, why is it not 16 byte aligned? sigh.

The binary output llvm writes, and the binary output the system assembler will produce for the assembly llvm produces from the same input should semantically match as close as possible. At this point I think choosing the correct long term behavior is outside the scope of this patch, whose intent to add experimental support. If an alignment of 16 on the .data csect was chosen only for matching gcc's assembly output then I am fine changing both assembly output and binary output to some other default (4-byte ?) alignment . If there was some other important limitation causing us to choose 16-byte aligned for assembly output then I think we keep this patch as is, until we can find out if hte system assemblers alignment treatment is intentional or not.

@xingxue I would appreciate your thoughts on relaxing the default alignment in the assembly output.

285–288

My problem with this is its implying more detailed though on 64-bit object support then I put into this patch. I haven't considered 64-bit support at all other then blocking writing 64-bit objects, so everything is strictly 32-bit. I don't think trying to mark up any of the structures or functions with '32' serves much purpose. Whoever adds 64-bit support will need to decide how they intend to proceed and we can evaluate the direction then.

422

FWIW I prefer to keep it as well.

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1673

Sorry I didn't realize it changed between the 2 patches.

[hubert.reinterpretcast]

llvm/lib/MC/XCOFFObjectWriter.cpp

44

I am not aware of a way to refer to the XCOFF sections in assembly. The belief that XCOFF sections are low-level artifacts below the level of assembly is one of the reasons why MCSectionXCOFF represents a CSECT and not a section.

The .data[RW], 4 does modify the symbol table entry for the CSECT to indicate 16-byte alignment. CSECTs in object files are aligned in relation to the physical/virtual address allocation and not in relation to the base address of their containing section. The snippet I posted above is for a case where the .data section contains a 16-byte aligned CSECT at 0x10. The offset of the CSECT data in relation to the start of the data section image in the object file is 0xC, which is not a multiple of 16.

285–288

Whether or not named as being 32-bit specific, please locally have the assertions for each function. For types, prevent the creation of objects of that type when targeting 64-bit XCOFF.

[hubert.reinterpretcast]

llvm/lib/MC/XCOFFObjectWriter.cpp

73

uint64_t, add FIXME, or rename.

74

uint64_t, add FIXME, or rename.

91

uint64_t, add FIXME, or rename.

92

Same comment.

93

int64_t/uint64_t, add FIXME, or rename.

94

Same comment.

96

We are coding to C++14, so because this may be converted to a int32_t (because that is the actual type according to the system headers), store this as an int32_t.

98

This Alignment is not a representation of an XCOFF field, so it should follow the convention for types representing alignment values in LLVM. See also D64790.

101

s/Virutal/Virtual/;

123

s/Container for/Type to be used for a container representing/;

124

XMC_PR? There's no XMC_PC in the header I am looking at.

130

https://llvm.org/docs/CodingStandards.html#do-not-use-braced-initializer-lists-to-call-a-constructor.

165

s/raw_pointer/raw-pointer/;

168

Remove the comma.

211

s/corrresponding/corresponding/;

214

The East const here is foreign in relation to the rest of this function.

216

VecSec? Do you mean CSections?

234

s/initilized/initialized/;

[hubert.reinterpretcast]

llvm/lib/MC/XCOFFObjectWriter.cpp

232

Why the braces for this case but not the others?

235

This code does not belong in this patch. The patch modifies Text, but does not add it to the list of non-empty sections.

243

Add a period to the end of the sentence.

245

Same comment.

256

Comma before "add".

257

Off-by-one error. This can be fixed by using nameInStringTable on the Symbol created for the symbol.

330

Linno is the abbreviation used for field in an auxiliary entry, not for the XCOFF section.

[xingxue]

llvm/lib/MC/XCOFFObjectWriter.cpp

44

What Hubert says makes sense. Variables in .csect .data[RW] are contained in the .data section where the alignments specified for csect are honored.

[sfertile]

llvm/lib/MC/XCOFFObjectWriter.cpp

44

Yeah I get it now. The section itself only has 4 byte alignment; its starting address has to be 4 byte aligned, and the size has to be a multiple of 4 bytes. Then we pad out the virtual address when allocating an address to any of the contained csects so that they are properly aligned. We aren't actually wasting any space in the sense that linking will happen at the csect granularity, not by copying an objects entire data section, so the extra padding is inconsequential to the linked module.

98

Regarding our other section alignment related discussion, we no longer need this field. Instead we use the DefaultSectionAlign of 4 regardless of the alignment of any contained csects. (Thanks for pointing out D64790 though, I wasn't aware of it).

458

I honestly don't know. I've seen all 3 version used recently (and pretty sure I've used all 3 myself). If there is an 'official' way to capitalize it then lets use that, other wise lets pick one and use it consistently through out llvm codebase. I don't care which format, as long as we are consistent.

[sfertile]

Addressed most review comments other then those related to 32-bit vs 64-bit.

[hubert.reinterpretcast]

llvm/lib/MC/XCOFFObjectWriter.cpp

321

Newline before the comment.

325

Newline before this line.

327

Newline before the comment.

330

Newline before the comment.

333

Newline before this line.

352

Not really consequential, but llvm::object::XCOFFSymbolEntry::NameInStrTblType::Magic is signed.

367

s/visibilty/visibility/;

382

uint8_t.

384

uint8_t.

386

uint32_t.

388

uint16_t.

395

The last sentence should be more explicitly worded as a statement of LLVM behaviour: We can place the shared (as opposed to thread-local) address 0 immediately after the section header table.

Note the spelling of "immediately", and the removal of mentioning the file header.

400

s/Which we are not emitting yet/We are not emitting it yet/;

411

I think that this can be an assertion that the incoming Address is already aligned.

428

At this point, we should just assign to SymbolTableEntryCount once after assigning all of the symbol table indices (not just those of the .bss section). In other words, move this somewhere outside of the surrounding if statement.

458

Agreed on consistency. Unfortunately following the "most official" way does not help with consistency. The Assembler Language Reference capitalizes as CSECT; however, my understanding of the LLVM style is that it means we should use CSECT in comments/messages, and Csect in code. as does generate at least one message where the capitalization is "Csect". In any case, "CSect" seems to be the odd one out, which is unfortunate, because then we'd have to rename functions.

[hubert.reinterpretcast]

llvm/lib/MC/XCOFFObjectWriter.cpp

256

For consistency, space before the & and not after.

430

Add "the" before "default".

456

@xingxue, can you chime in on this?

[sfertile]

• Addressed latest round of review comments.
• Replaced 'CSect' in code with 'Csect' and changed errors/comments to use 'CSECT'.
• Added a second fatal error related to emiting 64-bit objects, in executePostBindingLayout.

[sfertile]

Related to the 32-bit vs 64-bit naming and assertions: I can appreciate being defensive about this, but I think trying to disable being able to create the various types and having an assertion (or error) in every function is overkill. Too much defensiveness is just clutter. I've added an earlier fatal_error in executePostlayoutBinding which blocks the ObjectWriter from doing anything interesting. When we are ready to proceed with 64-bit support we can remove that error and either rename the types (and guard all the appropriate functions), or modify the types for both 64-bit and 32-bit support, whichever is appropriate for the way we intend to add 64-bit support.

llvm/lib/MC/XCOFFObjectWriter.cpp

458

I've replaced 'CSect' with 'Csect' in all new code added in this patch, and updated any of the error messages or comments that refer to a singular csect to use 'CSECT'. I wasn't sure about how to treat the plural 'csects' though. To me it seems like we are using plain English when talking a bout multiple csects so they should not be capitalized. Let me know if CSECTs is more appropriate.

I can clean up any other CSect usage in an NFC patch.

[hubert.reinterpretcast]

llvm/lib/MC/XCOFFObjectWriter.cpp

458

Perhaps I was not clear. When I said capitalizes as CSECT, I was referring to the form used at the beginning of a sentence or in title case. The Assembler Language Reference uses the word, written as "csect", in other English contexts. I think we can just avoid using the plural form in places where we should be capitalizing.

[hubert.reinterpretcast]

Related to the 32-bit vs 64-bit naming and assertions: I can appreciate being defensive about this, but I think trying to disable being able to create the various types and having an assertion (or error) in every function is overkill.

Okay, I intend to continue adding comments to reviews on spots where I believe more attention than not would be needed in the future for 64-bit support, but I am fine with where we are on this patch.

The patch LGTM aside from the whole how-to-write-"csect" thing and minor comments. I think we can have these addressed on the commit.

llvm/lib/MC/XCOFFObjectWriter.cpp

325

I'm not seeing the change that adds a newline between the address-writing code and the code for the next two fields.

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

8

I think we've been using 64BIT or XCOFF64 for this.

llvm/include/llvm/BinaryFormat/XCOFF.h

 enum SymbolType {
   XTY_ER = 0, ///< External reference.
   XTY_SD = 1, ///< Csect definition for initialized storage.
   XTY_LD = 2, ///< Label definition.
               ///< Defines an entry point to an initialized csect.
   XTY_CM = 3  ///< Common csect definition. For uninitialized storage.
 };
 
+struct FileHeader32 {
+  uint16_t Magic;
+  uint16_t SectionCount;
+  int32_t TimeStamp;
+  uint32_t SymbolTableFileOffset;
+  int32_t SymbolTableEntryCount;
+  uint16_t AuxiliaryHeaderSize;
+  uint16_t Flags;
+};
+
+struct SectionHeader32 {
+  char Name[XCOFF::SectionNameSize];
+  uint32_t PhysicalAddress;
+  uint32_t VirtualAddress;
+  uint32_t Size;
+  uint32_t FileOffsetToData;
+  uint32_t FileOffsetToRelocations;
+  uint32_t FileOffsetToLineNumbers;
+  uint16_t RelocationCount;
+  uint16_t LineNumberCount;
+  int32_t Flags;
+};
+
 } // end namespace XCOFF
 } // end namespace llvm
 
 #endif

llvm/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h

 //==- llvm/CodeGen/TargetLoweringObjectFileImpl.h - Object Info --*- C++ -*-==//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements classes used to handle lowerings specific to common
 // object file formats.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CODEGEN_TARGETLOWERINGOBJECTFILEIMPL_H
 #define LLVM_CODEGEN_TARGETLOWERINGOBJECTFILEIMPL_H
 
+#include "llvm/BinaryFormat/XCOFF.h"
 #include "llvm/IR/Module.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/Target/TargetLoweringObjectFile.h"
 
 namespace llvm {
 
 class GlobalValue;
 class MachineModuleInfo;
MCSection *getStaticDtorSection(unsigned Priority,
                                   const MCSymbol *KeySym) const override;
 
   const MCExpr *lowerRelativeReference(const GlobalValue *LHS,
                                        const GlobalValue *RHS,
                                        const TargetMachine &TM) const override;
 
   MCSection *SelectSectionForGlobal(const GlobalObject *GO, SectionKind Kind,
                                     const TargetMachine &TM) const override;
+
+  static XCOFF::StorageClass getStorageClassForGlobal(const GlobalObject *GO);
 };
 
 } // end namespace llvm
 
 #endif // LLVM_CODEGEN_TARGETLOWERINGOBJECTFILEIMPL_H

llvm/include/llvm/MC/MCContext.h

MCSectionWasm *getWasmSection(const Twine &Section, SectionKind K,
                                   const char *BeginSymName);
 
     MCSectionWasm *getWasmSection(const Twine &Section, SectionKind K,
                                   const MCSymbolWasm *Group, unsigned UniqueID,
                                   const char *BeginSymName);
 
     MCSectionXCOFF *getXCOFFSection(StringRef Section,
                                     XCOFF::StorageMappingClass MappingClass,
-                                    XCOFF::SymbolType CSectType, SectionKind K,
+                                    XCOFF::SymbolType CSectType,
+                                    XCOFF::StorageClass StorageClass,
+                                    SectionKind K,
                                     const char *BeginSymName = nullptr);
 
     // Create and save a copy of STI and return a reference to the copy.
     MCSubtargetInfo &getSubtargetCopy(const MCSubtargetInfo &STI);
 
     /// @}
 
     /// \name Dwarf Management

llvm/include/llvm/MC/MCSectionXCOFF.h

 //    contained in another XCOFF object file. External reference csects are not
 //    implemented yet.
 class MCSectionXCOFF final : public MCSection {
   friend class MCContext;
 
   StringRef Name;
   XCOFF::StorageMappingClass MappingClass;
   XCOFF::SymbolType Type;
+  XCOFF::StorageClass StorageClass;
 
   MCSectionXCOFF(StringRef Section, XCOFF::StorageMappingClass SMC,
-                 XCOFF::SymbolType ST, SectionKind K, MCSymbol *Begin)
+                 XCOFF::SymbolType ST, XCOFF::StorageClass SC, SectionKind K,
+                 MCSymbol *Begin)
       : MCSection(SV_XCOFF, K, Begin), Name(Section), MappingClass(SMC),
-        Type(ST) {
+        Type(ST), StorageClass(SC) {
     assert((ST == XCOFF::XTY_SD || ST == XCOFF::XTY_CM) &&
            "Invalid or unhandled type for csect.");
   }
 
 public:
   ~MCSectionXCOFF();
 
   static bool classof(const MCSection *S) {

llvm/include/llvm/MC/MCSymbolXCOFF.h

 namespace llvm {
 
 class MCSymbolXCOFF : public MCSymbol {
 public:
   MCSymbolXCOFF(const StringMapEntry<bool> *Name, bool isTemporary)
       : MCSymbol(SymbolKindXCOFF, Name, isTemporary) {}
 
   static bool classof(const MCSymbol *S) { return S->isXCOFF(); }
+
+  void setStorageClass(XCOFF::StorageClass SC) { StorageClass = SC; };
+  XCOFF::StorageClass getStorageClass() const { return StorageClass; }
+
+private:
+  XCOFF::StorageClass StorageClass;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_MC_MCSYMBOLXCOFF_H

llvm/include/llvm/MC/StringTableBuilder.h

 
 namespace llvm {
 
 class raw_ostream;
 
 /// Utility for building string tables with deduplicated suffixes.
 class StringTableBuilder {
 public:
-  enum Kind { ELF, WinCOFF, MachO, RAW, DWARF };
+  enum Kind { ELF, WinCOFF, MachO, RAW, DWARF, XCOFF};
 
 private:
   DenseMap<CachedHashStringRef, size_t> StringIndexMap;
   size_t Size = 0;
   Kind K;
   unsigned Alignment;
   bool Finalized = false;
 

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

MCSection *TargetLoweringObjectFileXCOFF::SelectSectionForGlobal(
   assert(!TM.getFunctionSections() && !TM.getDataSections() &&
          "XCOFF unique sections not yet implemented.");
 
   // Common symbols go into a csect with matching name which will get mapped
   // into the .bss section.
   if (Kind.isBSSLocal() || Kind.isCommon()) {
     SmallString<128> Name;
     getNameWithPrefix(Name, GO, TM);
+    XCOFF::StorageClass SC =
+        TargetLoweringObjectFileXCOFF::getStorageClassForGlobal(GO);
     return getContext().getXCOFFSection(
         Name, Kind.isBSSLocal() ? XCOFF::XMC_BS : XCOFF::XMC_RW, XCOFF::XTY_CM,
-        Kind, /* BeginSymbolName */ nullptr);
+        SC, Kind, /* BeginSymbolName */ nullptr);
   }
 
   if (Kind.isText())
     return TextSection;
 
   report_fatal_error("XCOFF other section types not yet implemented.");
 }
 
MCSection *TargetLoweringObjectFileXCOFF::getStaticDtorSection(
   report_fatal_error("XCOFF dtor section not yet implemented.");
 }
 
 const MCExpr *TargetLoweringObjectFileXCOFF::lowerRelativeReference(
     const GlobalValue *LHS, const GlobalValue *RHS,
     const TargetMachine &TM) const {
   report_fatal_error("XCOFF not yet implemented.");
 }
+
+XCOFF::StorageClass TargetLoweringObjectFileXCOFF::getStorageClassForGlobal(
+    const GlobalObject *GO) {
+  switch (GO->getLinkage()) {
+  case GlobalValue::InternalLinkage:
+    return XCOFF::C_HIDEXT;
+  case GlobalValue::ExternalLinkage:
+  case GlobalValue::CommonLinkage:
+    return XCOFF::C_EXT;
+  case GlobalValue::ExternalWeakLinkage:
+    return XCOFF::C_WEAKEXT;
+  default:
+    report_fatal_error(
+        "Unhandled linkage when mapping linkage to StorageClass.");
+  }
+}

llvm/lib/MC/MCContext.cpp

MCSectionWasm *MCContext::getWasmSection(const Twine &Section, SectionKind Kind,
   Begin->setFragment(F);
 
   return Result;
 }
 
 MCSectionXCOFF *MCContext::getXCOFFSection(StringRef Section,
                                            XCOFF::StorageMappingClass SMC,
                                            XCOFF::SymbolType Type,
+                                           XCOFF::StorageClass SC,
                                            SectionKind Kind,
                                            const char *BeginSymName) {
   // Do the lookup. If we have a hit, return it.
   auto IterBool = XCOFFUniquingMap.insert(
       std::make_pair(XCOFFSectionKey{Section.str(), SMC}, nullptr));
   auto &Entry = *IterBool.first;
   if (!IterBool.second)
     return Entry.second;
 
   // Otherwise, return a new section.
   StringRef CachedName = Entry.first.SectionName;
 
   MCSymbol *Begin = nullptr;
   if (BeginSymName)
     Begin = createTempSymbol(BeginSymName, false);
 
   MCSectionXCOFF *Result = new (XCOFFAllocator.Allocate())
-      MCSectionXCOFF(CachedName, SMC, Type, Kind, Begin);
+      MCSectionXCOFF(CachedName, SMC, Type, SC, Kind, Begin);
   Entry.second = Result;
 
   auto *F = new MCDataFragment();
   Result->getFragmentList().insert(Result->begin(), F);
   F->setParent(Result);
 
   if (Begin)
     Begin->setFragment(F);

llvm/lib/MC/MCObjectFileInfo.cpp

void MCObjectFileInfo::initWasmMCObjectFileInfo(const Triple &T) {
   // TODO: Define more sections.
 }
 
 void MCObjectFileInfo::initXCOFFMCObjectFileInfo(const Triple &T) {
   // The default csect for program code. Functions without a specified section
   // get placed into this csect. The choice of csect name is not a property of
   // the ABI or object file format. For example, the XL compiler uses an unnamed
   // csect for program code.
-  TextSection =
-      Ctx->getXCOFFSection(".text", XCOFF::StorageMappingClass::XMC_PR,
-                           XCOFF::XTY_SD, SectionKind::getText());
+  TextSection = Ctx->getXCOFFSection(
+      ".text", XCOFF::StorageMappingClass::XMC_PR, XCOFF::XTY_SD,
+      XCOFF::C_HIDEXT, SectionKind::getText());
 }
 
 void MCObjectFileInfo::InitMCObjectFileInfo(const Triple &TheTriple, bool PIC,
                                             MCContext &ctx,
                                             bool LargeCodeModel) {
   PositionIndependent = PIC;
   Ctx = &ctx;
 

llvm/lib/MC/MCXCOFFStreamer.cpp

 //===- lib/MC/MCXCOFFStreamer.cpp - XCOFF Object Output -------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file assembles .s files and emits XCOFF .o object files.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/MC/MCXCOFFStreamer.h"
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCCodeEmitter.h"
 #include "llvm/MC/MCObjectWriter.h"
+#include "llvm/MC/MCSymbolXCOFF.h"
 #include "llvm/Support/TargetRegistry.h"
 
 using namespace llvm;
 
 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,
                                           MCSymbolAttr Attribute) {
   report_fatal_error("Symbol attributes not implemented for XCOFF.");
 }
 
 void MCXCOFFStreamer::EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
-                                       unsigned ByteAlignment) {
-  report_fatal_error("Emiting common symbols not implemented for XCOFF.");
+  getAssembler().registerSymbol(*Symbol);
+  Symbol->setExternal((cast<MCSymbolXCOFF>(Symbol))->getStorageClass() !=
+                      XCOFF::C_HIDEXT);
+  Symbol->setCommon(Size, ByteAlignment);
+
+  // Need to add this symbol to the current Fragment which will belong to the
+  // containing CSECT.
+  auto *F = dyn_cast_or_null<MCDataFragment>(getCurrentFragment());
+  assert(F && "Expected a valid section with a fragment set.");
+  Symbol->setFragment(F);
+
+  // Emit the alignment and storage for the variable to the section.
+  EmitValueToAlignment(ByteAlignment, 0, 1, 0);
+  EmitZeros(Size);
 }
 
 void MCXCOFFStreamer::EmitZerofill(MCSection *Section, MCSymbol *Symbol,
                                    uint64_t Size, unsigned ByteAlignment,
                                    SMLoc Loc) {
   report_fatal_error("Zero fill not implemented for XCOFF.");
 }
 
if (RelaxAll)
     S->getAssembler().setRelaxAll(true);
   return S;
 }
 
 void MCXCOFFStreamer::EmitXCOFFLocalCommonSymbol(MCSymbol *Symbol, uint64_t Size,
                                             unsigned ByteAlign) {
   llvm_unreachable("Not implemented yet.");
 }
 No newline at end of file

llvm/lib/MC/StringTableBuilder.cpp

void StringTableBuilder::initSize() {
   case DWARF:
     Size = 0;
     break;
   case MachO:
   case ELF:
     // Start the table with a NUL byte.
     Size = 1;
     break;
+  case XCOFF:
   case WinCOFF:
     // Make room to write the table size later.
     Size = 4;
     break;
   }
 }
 
 StringTableBuilder::StringTableBuilder(Kind K, unsigned Alignment)

 
 void StringTableBuilder::write(uint8_t *Buf) const {
   assert(isFinalized());
   for (const StringPair &P : StringIndexMap) {
     StringRef Data = P.first.val();
     if (!Data.empty())
       memcpy(Buf + P.second, Data.data(), Data.size());
   }
-  if (K != WinCOFF)
-    return;
+  // The COFF formats store the size of the string table in the first 4 bytes.
+  // For Windows, the format is little-endian; for AIX it is big-endian.
+  if (K == WinCOFF)
     support::endian::write32le(Buf, Size);
+  else if (K == XCOFF)
+    support::endian::write32be(Buf, Size);
 }
 
 // Returns the character at Pos from end of a string.
 static int charTailAt(StringPair *P, size_t Pos) {
   StringRef S = P->first.val();
   if (Pos >= S.size())
     return -1;
   return (unsigned char)S[S.size() - Pos - 1];

llvm/lib/MC/XCOFFObjectWriter.cpp

 //===-- lib/MC/XCOFFObjectWriter.cpp - XCOFF file writer ------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements XCOFF object file writer information.
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/BinaryFormat/XCOFF.h"
+#include "llvm/MC/MCAsmLayout.h"
 #include "llvm/MC/MCAssembler.h"
 #include "llvm/MC/MCObjectWriter.h"
+#include "llvm/MC/MCSectionXCOFF.h"
+#include "llvm/MC/MCSymbolXCOFF.h"
 #include "llvm/MC/MCValue.h"
 #include "llvm/MC/MCXCOFFObjectWriter.h"
+#include "llvm/MC/StringTableBuilder.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/MathExtras.h"
+
+#include <deque>
 
 using namespace llvm;
 
+// An XCOFF object file has a limited set of predefined sections. The most
+// important ones for us (right now) are:
+// .text --> contains program code.
+// .data --> contains intialized data, function descriptors and the TOC.
+// .bss  --> contains uninitialized data.
+// Each of these sections is composed of 'Control Sections', more commonly
+// referred to as csects. A control section is an indivisible unit of code or
+// data, and acts as a container for symbols. A csect is mapped
+// into a section based on its storage-mapping class.
+//
+// We don't represent the sections in the MC layer as there is nothing
+// interesting about them at at that level: they carry information that is
+// only relevant to the ObjectWriter, so we materialize them in this class.
 namespace {
 
+constexpr unsigned DefaultSectionAlign = 16;
+
+// The system assembler will only emit Data and BSS sections that are a multiple
+// of 4.
+constexpr unsigned SectionSizeMultiple = 4;
+
+// Packs the csects alignment and type into a byte.
+uint8_t getEncodedType(const MCSectionXCOFF *);
+
+// Wrapper around an MCSymbolXCOFF.
+struct Symbol {
+  const MCSymbolXCOFF *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::SymbolNameSize;
+  }
+
+  Symbol(const MCSymbolXCOFF *MCSym) : MCSym(MCSym), SymbolTableIndex(-1) {}
+};
+
+// Wrapper for an MCSectionXCOFF.
+struct ControlSection {
+  const MCSectionXCOFF *MCCSect;
+  uint32_t SymbolTableIndex;
+  uint32_t Address;
+  uint32_t Size;
+
+  SmallVector<Symbol, 1> Syms;
+
+  ControlSection(const MCSectionXCOFF *MCSec)
+      : MCCSect(MCSec), SymbolTableIndex(-1), Address(-1) {}
+};
+
+// 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 seperatly eg: the .data section containing read-write, descriptor,
+// TOCBase and TOC-entry csects.
+struct Section {
+  char Name[XCOFF::SectionNameSize];
+  // The physical/virtual address of the section. For an object file
+  // these values are equivalent.
+  uint32_t Address;
+  uint32_t Size;
+  uint32_t FileOffsetToData;
+  uint32_t FileOffsetToRelocations;
+  uint32_t RelocationCount;
+  uint32_t Flags;
+
+  uint32_t Alignment;
+  uint16_t Index;
+
+  // Virutal sections do not need storage allocated in the object file.
+  const bool IsVirtual;
+
+  void reset() {
+    Address = 0;
+    Size = 0;
+    FileOffsetToData = 0;
+    FileOffsetToRelocations = 0;
+    RelocationCount = 0;
+    Alignment = DefaultSectionAlign;
+    Index = -1;
+  }
+
+  Section(const char *N, XCOFF::SectionTypeFlags Flags, bool IsVirtual)
+      : Address(0), Size(0), FileOffsetToData(0), FileOffsetToRelocations(0),
+        RelocationCount(0), Flags(Flags), Alignment(DefaultSectionAlign),
+        Index(-1), IsVirtual(IsVirtual) {
+    strncpy(Name, N, XCOFF::SectionNameSize);
+  }
+};
+
 class XCOFFObjectWriter : public MCObjectWriter {
+  // Container for a set of csects with (approximately) the same storage mapping
+  // class. For example all the csects with a storage mapping class of `xmc_pc`
+  // will get placed into the same container.
+  using ControlSections = std::deque<ControlSection>;
+
   support::endian::Writer W;
   std::unique_ptr<MCXCOFFObjectTargetWriter> TargetObjectWriter;
+  StringTableBuilder Strings{StringTableBuilder::XCOFF};
+
+  // The non-empty sections, in the order they will appear in the section header
+  // table.
+  std::vector<Section *> Sections;
+
+  // The Predefined sections.
+  Section Text;
+  Section BSS;
+
+  // ControlSections. These store the csects which make up different parts of
+  // the sections. Should have one for each set of csects that get mapped into
+  // the same section and get handled in a 'similar' way.
+  ControlSections ProgramCodeCSects;
+  ControlSections BSSCSects;
+
+  uint32_t SymbolTableEntryCount = 0;
+  uint32_t SymbolTableOffset = 0;
+
+  virtual void reset() override;
 
   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;
 
+  void writeFileHeader();
+  void writeSectionHeaderTable();
+  void writeSymbolTable();
+
+  // 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 &);
+
 public:
   XCOFFObjectWriter(std::unique_ptr<MCXCOFFObjectTargetWriter> MOTW,
                     raw_pwrite_stream &OS);
 };
 
 XCOFFObjectWriter::XCOFFObjectWriter(
     std::unique_ptr<MCXCOFFObjectTargetWriter> MOTW, raw_pwrite_stream &OS)
-    : W(OS, support::big), TargetObjectWriter(std::move(MOTW)) {}
+    : W(OS, support::big), TargetObjectWriter(std::move(MOTW)),
+      Text(".text", XCOFF::STYP_TEXT, /* IsVirtual */ false),
+      BSS(".bss", XCOFF::STYP_BSS, /* IsVirtual */ true) {}
+
+void XCOFFObjectWriter::reset() {
+  // Reset any sections we have written to, and empty the section header table.
+  for (auto *Sec : Sections)
+    Sec->reset();
+  Sections.clear();
+
+  // Clear any csects we have stored.
+  ProgramCodeCSects.clear();
+  BSSCSects.clear();
+
+  // 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) {
+  // Maps the MC Section representation to its corrresponding ControlSection
+  // wrapper. Needed for finding the ControlSection to insert an MCSymbol into
+  // from its containing MCSectionXCOFF.
+  DenseMap<MCSectionXCOFF const *, ControlSection *> WrapperMap;
+
+  // Creates the csect wrapper in VecSec, adds to the map, and adjusts the
+  // alignment of the containing section accordingly.
+  auto Add = [&WrapperMap](Section *Sec, ControlSections &CSections,
+                           const MCSectionXCOFF *CSect) {
+    unsigned Align = CSect->getAlignment();
+    Sec->Alignment = std::max(Align, Sec->Alignment);
+    CSections.emplace_back(CSect);
+    WrapperMap[CSect] = &CSections.back();
+  };
+
+  for (const auto &S : Asm) {
+    const MCSectionXCOFF *MCSec = dyn_cast<const MCSectionXCOFF>(&S);
+    assert(WrapperMap.find(MCSec) == WrapperMap.end() &&
+           "Cannot add a CSect twice.");
+
+    switch (MCSec->getMappingClass()) {
+    case XCOFF::XMC_PR: {
+      assert(XCOFF::XTY_SD == MCSec->getCSectType() &&
+             "Only an initilized csect can contain program code.");
+      Add(&Text, ProgramCodeCSects, MCSec);
+      break;
+    }
+    case XCOFF::XMC_RW:
+      if (XCOFF::XTY_CM == MCSec->getCSectType()) {
+        Add(&BSS, BSSCSects, MCSec);
+        break;
+      }
+      report_fatal_error("Unhandled mapping of read-write csect to section");
+    default:
+      report_fatal_error("Unhandled mapping of csect to section");
+    }
+  }
+
+  for (const MCSymbol &S : Asm.symbols()) {
+    // Nothing to do for temporary symbols.
+    if (S.isTemporary())
+      continue;
+    const MCSymbolXCOFF *XSym = cast<MCSymbolXCOFF>(&S);
+
+    // If the name does not fit in the storage provided in the symbol table
+    // entry add it to the string table.
+    if (XSym->getName().size() >= XCOFF::SymbolNameSize) {
+      Strings.add(XSym->getName());
+    }
+
+    // Map the symbol into its containing csect.
+    MCSectionXCOFF *ContainingCSect =
+        dyn_cast<MCSectionXCOFF>(XSym->getFragment(false)->getParent());
+    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);
+  }
 
-void XCOFFObjectWriter::executePostLayoutBinding(MCAssembler &,
-                                                 const MCAsmLayout &) {
-  // TODO Implement once we have sections and symbols to handle.
+  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 &) {
   // 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();
 
-  // TODO FIXME Assign section numbers/finalize sections.
+  writeFileHeader();
+  writeSectionHeaderTable();
+  // TODO writeSections();
+  // TODO writeRelocations();
 
   // TODO FIXME Finalize symbols.
+  writeSymbolTable();
+  // Write the string table.
+  Strings.write(W.OS);
 
+  return W.OS.tell() - StartOffset;
+}
+
+void XCOFFObjectWriter::writeFileHeader() {
   // Magic.
   W.write<uint16_t>(0x01df);
   // Number of sections.
-  W.write<uint16_t>(0);
+  W.write<uint16_t>(Sections.size());
   // Timestamp field. For reproducible output we write a 0, which represents no
   // timestamp.
   W.write<int32_t>(0);
   // Byte Offset to the start of the symbol table.
-  W.write<uint32_t>(0);
+  W.write<uint32_t>(SymbolTableOffset);
   // Number of entries in the symbol table.
-  W.write<int32_t>(0);
+  W.write<int32_t>(SymbolTableEntryCount);
   // Size of the optional header.
   W.write<uint16_t>(0);
   // Flags.
   W.write<uint16_t>(0);
+}
 
-  return W.OS.tell() - StartOffset;
+void XCOFFObjectWriter::writeSectionHeaderTable() {
+  for (const auto Sec : Sections) {
+    // Write Name.
+    ArrayRef<char> NameRef(Sec->Name, XCOFF::SectionNameSize);
+    W.write(NameRef);
+    // Write the Physical Address and Virtual Address. In an object file these
+    // are the same.
+    W.write<uint32_t>(Sec->Address);
+    W.write<uint32_t>(Sec->Address);
+    W.write<uint32_t>(Sec->Size);
+    W.write<uint32_t>(Sec->FileOffsetToData);
+    // Relocation pointer and Lineno pointer. Not supported yet.
+    W.write<uint32_t>(0);
+    W.write<uint32_t>(0);
+    // Relocation and Linno 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() == 1 &&
+          ProgramCodeCSects.back().Syms.size() == 0) &&
+         ".text csects not handled yet.");
+
+  // BSS Section is unique in that the csects contain a single symbol, and the
+  // contained symbol does not need a label definition.
+  for (auto &Sec : BSSCSects) {
+    assert(Sec.Syms.size() == 1 &&
+           "Uninitialized csect cannot contain more then 1 symbol.");
+    Symbol &Sym = Sec.Syms.back();
+
+    // Write the symbols name.
+    if (Sym.nameInStringTable()) {
+      W.write<uint32_t>(0);
+      W.write<uint32_t>(Strings.getOffset(Sym.getName()));
+    } else {
+      char Name[XCOFF::SymbolNameSize];
+      std::strncpy(Name, Sym.getName().data(), XCOFF::SymbolNameSize);
+      ArrayRef<char> NameRef(Name, XCOFF::SymbolNameSize);
+      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 visibilty 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<int8_t>(getEncodedType(Sec.MCCSect));
+    // Storage mapping class.
+    W.write<int8_t>(Sec.MCCSect->getMappingClass());
+    // Reserved (x_stab).
+    W.write<int32_t>(0);
+    // Reserved (x_snstab).
+    W.write<int16_t>(0);
+  }
+}
+
+void XCOFFObjectWriter::assignAddressesAndIndices(
+    const llvm::MCAsmLayout &Layout) {
+  // The address corrresponds to the address of sections and symbols in the
+  // object file. Address 0 is immediatly after the file header and section
+  // header table.
+  uint32_t Address = 0;
+  // Section indices are 1-based in XCOFF.
+  uint16_t SectionIndex = 1;
+  // The first symbol table entry is for the file name. Which we are not
+  // emitting yet, so start at index 0.
+  uint32_t SymbolTableIndex = 0;
+
+  // Text section comes first. TODO
+  // Data section Second. TODO
+
+  // BSS Section third.
+  if (!BSSCSects.empty()) {
+    Sections.push_back(&BSS);
+    BSS.Index = SectionIndex++;
+    Address = alignTo(Address, BSS.Alignment);
+    uint32_t StartAddress = Address;
+    for (auto &Csect : BSSCSects) {
+      const MCSectionXCOFF *MCSec = Csect.MCCSect;
+      Address = alignTo(Address, MCSec->getAlignment());
+      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 &&
+             +"Csects in the BSS can only contain a single symbol.");
+      Csect.Syms[0].SymbolTableIndex = Csect.SymbolTableIndex;
+    }
+    // There will be a csect definition for each symbol in the .bss section.
+    // Each of which has 2 symbol table entries.
+    SymbolTableEntryCount += BSSCSects.size() * 2;
+
+    // Pad out Address to a 4 byte alignment. This is to match how the system
+    // assembler handles the .bss section. It's size is always a multiple of 4.
+    Address = alignTo(Address, SectionSizeMultiple);
+    BSS.Size = Address - StartAddress;
+  }
+
+  // Calculate the RawPointer value for each section.
+  uint64_t RawPointer = sizeof(XCOFF::FileHeader32) +
+                        Sections.size() * sizeof(XCOFF::SectionHeader32);
+  for (auto Sec : Sections) {
+    if (!Sec->IsVirtual) {
+      Sec->FileOffsetToData = RawPointer;
+      RawPointer += Sec->Size;
+    }
+  }
+
+  // TODO Add in Relocation storage to the RawPointer Calculation.
+  // TODO What to align the SymbolTable too?
+  // TODO Error check that the number of symbol table entries fits in 32-bits
+  // signed ...
+  if (SymbolTableEntryCount)
+    SymbolTableOffset = RawPointer;
+}
+
+// Takes the log base 2 of the alignment and shifts the result into the 5 most
+// significant  bits of a byte, then or's in the csect type into the least
+// significant 3 bits.
+uint8_t getEncodedType(const MCSectionXCOFF *Sec) {
+  unsigned Align = Sec->getAlignment();
+  assert(isPowerOf2_32(Align) && "Alignment must be a power of 2.");
+  assert(((Sec->getCSectType() & 0xF8) == 0) && "Csect type exceeds 3-bits");
+  unsigned Log2Align = Log2_32(Align);
+  // Result is a number in the range [0, 31] which fits in the 5 least
+  // significant bits. Shift this value into the 5 most significant bits, and
+  // or in the csect type.
+  uint8_t EncodedAlign = (Log2Align & 0xFF) << 3;
+  return EncodedAlign | Sec->getCSectType();
 }
 
 } // end anonymous namespace
 
 std::unique_ptr<MCObjectWriter>
 llvm::createXCOFFObjectWriter(std::unique_ptr<MCXCOFFObjectTargetWriter> MOTW,
                               raw_pwrite_stream &OS) {
   return llvm::make_unique<XCOFFObjectWriter>(std::move(MOTW), OS);
 }

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

void PPCAIXAsmPrinter::EmitGlobalVariable(const GlobalVariable *GV) {
   if (!GVKind.isCommon() && !GVKind.isBSSLocal())
     report_fatal_error("Only common variables are supported on AIX for now.");
 
   // Create the containing csect and switch to it.
   MCSectionXCOFF *CSect = cast<MCSectionXCOFF>(
       getObjFileLowering().SectionForGlobal(GV, GVKind, TM));
   OutStreamer->SwitchSection(CSect);
 
-  // Create the symbol and emit it.
+  // Create the symbol, set its storage class and emit it.
   MCSymbolXCOFF *XSym = cast<MCSymbolXCOFF>(getSymbol(GV));
+  XSym->setStorageClass(
+     TargetLoweringObjectFileXCOFF::getStorageClassForGlobal(GV));
   const DataLayout &DL = GV->getParent()->getDataLayout();
   unsigned Align =
       GV->getAlignment() ? GV->getAlignment() : DL.getPreferredAlignment(GV);
   uint64_t Size = DL.getTypeAllocSize(GV->getType()->getElementType());
 
   if (GVKind.isBSSLocal())
     OutStreamer->EmitXCOFFLocalCommonSymbol(XSym, Size, Align);
   else

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

 ; RUN: llc -mtriple powerpc-ibm-aix-xcoff < %s | FileCheck %s
 
+; RUN: llc -mtriple powerpc-ibm-aix-xcoff -filetype=obj -o %t.o < %s
+; RUN: llvm-readobj --section-headers --file-header %t.o | \
+; RUN: FileCheck --check-prefix=OBJ %s
+
 @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 [32 x i8] zeroinitializer, align 1
+@array = common local_unnamed_addr global [33 x i8] zeroinitializer, align 1
 
 ; 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,32,0
+; 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:   TimeStamp:
+; OBJ-NEXT:   SymbolTableOffset: 0x3C
+; OBJ-NEXT:   SymbolTableEntries: 14
+; OBJ-NEXT:   OptionalHeaderSize: 0x0
+; OBJ-NEXT:   Flags: 0x0
+; OBJ-NEXT: }
+; OBJ-NEXT: Sections [
+; OBJ-NEXT:   Section {
+; OBJ-NEXT:     Index: 1
+; 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: ]