[PowerPC][AIX] Adds support for writing the .data section in assembly files

[xingxue]

Summary

Adds support for generating the .data section in assembly files for global variables with a non-zero initialization. The support for writing the .data section in XCOFF object files will be added in a follow-on patch. Any relocations are not included in this patch.

[hubert.reinterpretcast]

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

165–167

This does not need to be a non-static member function. It can be a static member function.

llvm/lib/MC/MCAsmStreamer.cpp

1122

Given the code here, the name of the function (and the variable) is misleading. It should say useDotAlignForAlignment, because we don't fall back to anything else when the requested alignment is not a power of two.

1123

With the suggestion to change the error text below, I think we can remove the comment.

1125

Suggestion: "Only power-of-two alignments are supported with .align."

llvm/lib/MC/MCSectionXCOFF.cpp

33

What we should write here, and whether llvm_unreachable is appropriate depends. I think that the current patch allows us to say that we do not handle switching to data sections with other storage mapping classes yet. That can be an assert, but probably not an unreachable.

assert(getMappingClass() == XCOFF::XMC_RW &&
       "Unhandled storage-mapping class for data section.");

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1662–1664

Stray change from isBSSLocal to isBSS. Please fix.

1663

Suggestion: "Encountered a global variable kind that is not supported yet."

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

26

We should seek to understand why GCC and XL uses 4-byte alignment.

[xingxue]

Addressed comments:

• Rename function useDotAlignForPowerOfTwoAlignment() to useDotAlignForAlignment() and the associated variable from UseDotAlignForPowerOfTwoAlignment to UseDotAlignForAlignment.
• Define AsmPrinter::getGVAlignmentLog2() as a static member function.
• Change from calling llvm_unreachable() to assert() as suggested for unsupported storage-mapping class of the data section.
• Fix the condition of supported global variable kind.

[xingxue]

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1663

Good catch, thanks!

[hubert.reinterpretcast]

A few small changes, but otherwise LGTM.

llvm/include/llvm/MC/MCAsmInfo.h

168

Suggestion: "True if .align is to be used for alignment. Only power-of-two alignment is supported."

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

1677–1680

Add a newline before the comment.

1678

I think this should be isBSSLocal.

[xingxue]

Addressed comments:

• Changed the comment for variable UseDotAlignForAlignment as suggested.
• Replaced condition GVKind.isBSS() with GVKind.isBSSLocal().
• Added a new line.

[xingxue]

Merged with the master and fixed a typo.

llvm/include/llvm/CodeGen/AsmPrinter.h

public:
   /// the target.
   void EmitVisibility(MCSymbol *Sym, unsigned Visibility,
                       bool IsDefinition = true) const;
 
   /// This emits linkage information about \p GVSym based on \p GV, if this is
   /// supported by the target.
   void EmitLinkage(const GlobalValue *GV, MCSymbol *GVSym) const;
 
+  /// Return the alignment in log2 form for the specified \p GV.
+  static unsigned getGVAlignmentLog2(const GlobalValue *GV,
+                                     const DataLayout &DL,
+                                     unsigned InBits = 0);
+
 private:
   /// Private state for PrintSpecial()
   // Assign a unique ID to this machine instruction.
   mutable const MachineInstr *LastMI = nullptr;
   mutable unsigned LastFn = 0;
   mutable unsigned Counter = ~0U;
 
   /// This method emits the header for the current function.

llvm/include/llvm/MC/MCAsmInfo.h

protected:
   /// quotes.
   bool SupportsQuotedNames = true;
 
   /// This is true if data region markers should be printed as
   /// ".data_region/.end_data_region" directives. If false, use "$d/$a" labels
   /// instead.
   bool UseDataRegionDirectives = false;
 
+  /// True if .align is to be used for alignment. Only power-of-two
+  /// alignment is supported.
+  bool UseDotAlignForAlignment = false;
+
   //===--- Data Emission Directives -------------------------------------===//
 
   /// This should be set to the directive used to get some number of zero bytes
   /// emitted to the current section.  Common cases are "\t.zero\t" and
   /// "\t.space\t".  If this is set to null, the Data*bitsDirective's will be
   /// used to emit zero bytes.  Defaults to "\t.zero\t"
   const char *ZeroDirective;
 
public:
   unsigned getAssemblerDialect() const { return AssemblerDialect; }
   bool doesAllowAtInName() const { return AllowAtInName; }
   bool supportsNameQuoting() const { return SupportsQuotedNames; }
 
   bool doesSupportDataRegionDirectives() const {
     return UseDataRegionDirectives;
   }
 
+  bool useDotAlignForAlignment() const {
+    return UseDotAlignForAlignment;
+  }
+
   const char *getZeroDirective() const { return ZeroDirective; }
   const char *getAsciiDirective() const { return AsciiDirective; }
   const char *getAscizDirective() const { return AscizDirective; }
   bool getAlignmentIsInBytes() const { return AlignmentIsInBytes; }
   unsigned getTextAlignFillValue() const { return TextAlignFillValue; }
   const char *getGlobalDirective() const { return GlobalDirective; }
 
   bool doesSetDirectiveSuppressReloc() const {

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

static gcp_map_type &getGCMap(void *&P) {
   if (!P)
     P = new gcp_map_type();
   return *(gcp_map_type*)P;
 }
 
 /// getGVAlignmentLog2 - Return the alignment to use for the specified global
 /// value in log2 form.  This rounds up to the preferred alignment if possible
 /// and legal.
-static unsigned getGVAlignmentLog2(const GlobalValue *GV, const DataLayout &DL,
-                                   unsigned InBits = 0) {
+unsigned AsmPrinter::getGVAlignmentLog2(const GlobalValue *GV,
+                                        const DataLayout &DL,
+                                        unsigned InBits) {
   unsigned NumBits = 0;
   if (const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV))
     NumBits = DL.getPreferredAlignmentLog(GVar);
 
   // If InBits is specified, round it to it.
   if (InBits > NumBits)
     NumBits = InBits;
 

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

if (Kind.isBSSLocal() || Kind.isCommon()) {
     return getContext().getXCOFFSection(
         Name, Kind.isBSSLocal() ? XCOFF::XMC_BS : XCOFF::XMC_RW, XCOFF::XTY_CM,
         SC, Kind, /* BeginSymbolName */ nullptr);
   }
 
   if (Kind.isText())
     return TextSection;
 
+  if (Kind.isData())
+    return DataSection;
+
   report_fatal_error("XCOFF other section types not yet implemented.");
 }
 
 bool TargetLoweringObjectFileXCOFF::shouldPutJumpTableInFunctionSection(
     bool UsesLabelDifference, const Function &F) const {
   report_fatal_error("TLOF XCOFF not yet implemented.");
 }
 

llvm/lib/MC/MCAsmInfoXCOFF.cpp

 
 void MCAsmInfoXCOFF::anchor() {}
 
 MCAsmInfoXCOFF::MCAsmInfoXCOFF() {
   IsLittleEndian = false;
   HasDotTypeDotSizeDirective = false;
   COMMDirectiveAlignmentIsInBytes = false;
   LCOMMDirectiveAlignmentType = LCOMM::Log2Alignment;
+  UseDotAlignForAlignment = true;
+  AsciiDirective = nullptr; // not supported
+  AscizDirective = nullptr; // not supported
+  Data64bitsDirective = "\t.llong\t";
 }

llvm/lib/MC/MCAsmStreamer.cpp

void MCAsmStreamer::emitFill(const MCExpr &NumValues, int64_t Size,
   OS << ", " << Size << ", 0x";
   OS.write_hex(truncateToSize(Expr, 4));
   EmitEOL();
 }
 
 void MCAsmStreamer::EmitValueToAlignment(unsigned ByteAlignment, int64_t Value,
                                          unsigned ValueSize,
                                          unsigned MaxBytesToEmit) {
+  if (MAI->useDotAlignForAlignment()) {
+    if (!isPowerOf2_32(ByteAlignment))
+      report_fatal_error("Only power-of-two alignments are supported "
+                         "with .align.");
+    OS << "\t.align\t";
+    OS << Log2_32(ByteAlignment);
+    EmitEOL();
+    return;
+  }
+
   // Some assemblers don't support non-power of two alignments, so we always
   // emit alignments as a power of two if possible.
   if (isPowerOf2_32(ByteAlignment)) {
     switch (ValueSize) {
     default:
       llvm_unreachable("Invalid size for machine code value!");
     case 1:
       OS << "\t.p2align\t";

llvm/lib/MC/MCObjectFileInfo.cpp

 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,
       XCOFF::C_HIDEXT, SectionKind::getText());
+
+  DataSection = Ctx->getXCOFFSection(
+      ".data", XCOFF::StorageMappingClass::XMC_RW, XCOFF::XTY_SD,
+      XCOFF::C_HIDEXT, SectionKind::getData());
 }
 
 void MCObjectFileInfo::InitMCObjectFileInfo(const Triple &TheTriple, bool PIC,
                                             MCContext &ctx,
                                             bool LargeCodeModel) {
   PositionIndependent = PIC;
   Ctx = &ctx;
 

llvm/lib/MC/MCSectionXCOFF.cpp

if (getMappingClass() != XCOFF::XMC_PR)
       llvm_unreachable("Unsupported storage-mapping class for .text csect");
 
     OS << "\t.csect " << getSectionName() << "["
        << "PR"
        << "]" << '\n';
     return;
   }
 
+  if (getKind().isData()) {
+    assert(getMappingClass() != XCOFF::XMC_RW &&
+           "Unhandled storage-mapping class for data section.");
+
+    OS << "\t.csect " << getSectionName() << "["
+       << "RW"
+       << "]" << '\n';
+    return;
+  }
+
   if (getKind().isBSSLocal() || getKind().isCommon()) {
     assert((getMappingClass() == XCOFF::XMC_RW ||
             getMappingClass() == XCOFF::XMC_BS) &&
            "Generated a storage-mapping class for a common/bss csect we don't "
            "understand how to switch to.");
     assert(getCSectType() == XCOFF::XTY_CM &&
            "wrong csect type for .bss csect");
     // Don't have to print a directive for switching to section for commons.

llvm/lib/Target/PowerPC/PPCAsmPrinter.cpp

void PPCAIXAsmPrinter::EmitGlobalVariable(const GlobalVariable *GV) {
 
   if (GV->hasSection())
     report_fatal_error("Custom section for Data not yet supported.");
 
   if (GV->hasComdat())
     report_fatal_error("COMDAT not yet supported by AIX.");
 
   SectionKind GVKind = getObjFileLowering().getKindForGlobal(GV, TM);
-  if (!GVKind.isCommon() && !GVKind.isBSSLocal())
-    report_fatal_error("Only common variables are supported on AIX for now.");
+  if (!GVKind.isCommon() && !GVKind.isBSSLocal() && !GVKind.isData())
+    report_fatal_error("Encountered a global variable kind that is "
+                       "not supported yet.");
 
   // Create the containing csect and switch to it.
   MCSectionXCOFF *CSect = cast<MCSectionXCOFF>(
       getObjFileLowering().SectionForGlobal(GV, GVKind, TM));
   OutStreamer->SwitchSection(CSect);
 
   // Create the symbol, set its storage class, and emit it.
-  MCSymbolXCOFF *XSym = cast<MCSymbolXCOFF>(getSymbol(GV));
-  XSym->setStorageClass(
+  MCSymbolXCOFF *GVSym = cast<MCSymbolXCOFF>(getSymbol(GV));
+  GVSym->setStorageClass(
       TargetLoweringObjectFileXCOFF::getStorageClassForGlobal(GV));
+
   const DataLayout &DL = GV->getParent()->getDataLayout();
+
+  // Handle common symbols.
+  if (GVKind.isCommon() || GVKind.isBSSLocal()) {
     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);
+      OutStreamer->EmitXCOFFLocalCommonSymbol(GVSym, Size, Align);
     else
-    OutStreamer->EmitCommonSymbol(XSym, Size, Align);
+      OutStreamer->EmitCommonSymbol(GVSym, Size, Align);
+    return;
+  }
+
+  // Get the alignment in the log2 form.
+  const unsigned AlignLog = getGVAlignmentLog2(GV, DL);
+
+  MCSymbol *EmittedInitSym = GVSym;
+  EmitLinkage(GV, EmittedInitSym);
+  EmitAlignment(AlignLog, GV);
+  OutStreamer->EmitLabel(EmittedInitSym);
+  EmitGlobalConstant(GV->getParent()->getDataLayout(), GV->getInitializer());
 }
 
 /// createPPCAsmPrinterPass - Returns a pass that prints the PPC assembly code
 /// for a MachineFunction to the given output stream, in a format that the
 /// Darwin assembler can deal with.
 ///
 static AsmPrinter *
 createPPCAsmPrinterPass(TargetMachine &tm,

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

+; RUN: llc -mtriple powerpc-ibm-aix-xcoff < %s | FileCheck %s
+; RUN: llc -mtriple powerpc64-ibm-aix-xcoff < %s | FileCheck %s
+
+@ivar = local_unnamed_addr global i32 35, align 4
+@llvar = local_unnamed_addr global i64 36, align 8
+@svar = local_unnamed_addr global i16 37, align 2
+@fvar = local_unnamed_addr global float 8.000000e+02, align 4
+@dvar = local_unnamed_addr global double 9.000000e+02, align 8
+@over_aligned = local_unnamed_addr global double 9.000000e+02, align 32
+@charr = local_unnamed_addr global [4 x i8] c"abcd", align 1
+@dblarr = local_unnamed_addr global [4 x double] [double 1.000000e+00, double 2.000000e+00, double 3.000000e+00, double 4.000000e+00], align 8
+
+; CHECK:      .csect .data[RW]
+; CHECK-NEXT: .globl  ivar
+; CHECK-NEXT: .align  2
+; CHECK-NEXT: ivar:
+; CHECK-NEXT: .long   35
+
+; CHECK:      .globl  llvar
+; CHECK-NEXT: .align  3
+; CHECK-NEXT: llvar:
+; CHECK-NEXT: .llong  36
+
+; CHECK:      .globl  svar
+; CHECK-NEXT: .align  1
+; CHECK-NEXT: svar:
+; CHECK-NEXT: .short  37
+
+; CHECK:      .globl  fvar
+; CHECK-NEXT: .align  2
+; CHECK-NEXT: fvar:
+; CHECK-NEXT: .long   1145569280
+
+; CHECK:      .globl  dvar
+; CHECK-NEXT: .align  3
+; CHECK-NEXT: dvar:
+; CHECK-NEXT: .llong  4651127699538968576
+
+; CHECK:      .globl  over_aligned
+; CHECK-NEXT: .align  5
+; CHECK-NEXT: over_aligned:
+; CHECK-NEXT: .llong  4651127699538968576
+
+; CHECK:      .globl  charr
+; CHECK-NEXT: charr:
+; CHECK-NEXT: .byte   97
+; CHECK-NEXT: .byte   98
+; CHECK-NEXT: .byte   99
+; CHECK-NEXT: .byte   100
+
+; CHECK:      .globl  dblarr
+; CHECK-NEXT: .align  3
+; CHECK-NEXT: dblarr:
+; CHECK-NEXT: .llong  4607182418800017408
+; CHECK-NEXT: .llong  4611686018427387904
+; CHECK-NEXT: .llong  4613937818241073152
+; CHECK-NEXT: .llong  4616189618054758400
+