[AIX][XCOFF] Add support for generating assembly code for one-byte mergable strings

[xingxue]

Summary

This patch adds support for generating assembly code for one-byte mergeable strings.

Generating assembly code for multi-byte mergeable strings and the XCOFF object code for mergeable strings will be supported later.

[daltenty]

LGTM

llvm/lib/MC/MCSectionXCOFF.cpp

66

aside: we should probably eventually think about simplifying and cleaning up the logic in this function since we almost always just want to print .csect QUALNAME after asserting some things for unimplemented features

llvm/lib/BinaryFormat/XCOFF.cpp

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

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

if (Kind.isBSSLocal() || Kind.isCommon()) {
     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,
         SC, Kind, /* BeginSymbolName */ nullptr);
   }
 
+  if (Kind.isMergeableCString()) {
+    if (!Kind.isMergeable1ByteCString())
+      report_fatal_error("Unhandled multi-byte mergeable string kind.");
+
+    unsigned Align = GO->getParent()->getDataLayout().getPreferredAlignment(
+        cast<GlobalVariable>(GO));
+
+    unsigned EntrySize = getEntrySizeForKind(Kind);
+    std::string SizeSpec = ".rodata.str" + utostr(EntrySize) + ".";
+    SmallString<128> Name;
+    Name = SizeSpec + utostr(Align);
+
+    return getContext().getXCOFFSection(
+        Name, XCOFF::XMC_RO, XCOFF::XTY_SD,
+        TargetLoweringObjectFileXCOFF::getStorageClassForGlobal(GO),
+        Kind, /* BeginSymbolName */ nullptr);
+  }
+
   if (Kind.isText())
     return TextSection;
 
   if (Kind.isData())
     return DataSection;
 
   // Zero initialized data must be emitted to the .data section because external
   // linkage control sections that get mapped to the .bss section will be linked
const MCExpr *TargetLoweringObjectFileXCOFF::lowerRelativeReference(
     const TargetMachine &TM) const {
   report_fatal_error("XCOFF not yet implemented.");
 }
 
 XCOFF::StorageClass TargetLoweringObjectFileXCOFF::getStorageClassForGlobal(
     const GlobalObject *GO) {
   switch (GO->getLinkage()) {
   case GlobalValue::InternalLinkage:
+  case GlobalValue::PrivateLinkage:
     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/MCSectionXCOFF.cpp

if (getKind().isBSSLocal() || getKind().isCommon()) {
     assert(getCSectType() == XCOFF::XTY_CM &&
            "wrong csect type for .bss csect");
     // Don't have to print a directive for switching to section for commons.
     // '.comm' and '.lcomm' directives for the variable will create the needed
     // csect.
     return;
   }
 
+  if (getKind().isMergeableCString()) {
+    if (!getKind().isMergeable1ByteCString())
+      report_fatal_error("Unhandled multi-byte mergeable string kind.");
+
+    assert((getMappingClass() == XCOFF::XMC_RO) &&
+           "Generated a storage-mapping class for a Mergeable1ByteCString we "
+           "don't understand how to switch to.");
+    OS << "\t.csect " << QualName->getName() << '\n';
+    return;
+  }
+
   report_fatal_error("Printing for this SectionKind is unimplemented.");
 }
 
 bool MCSectionXCOFF::UseCodeAlign() const { return getKind().isText(); }
 
 bool MCSectionXCOFF::isVirtualSection() const { return XCOFF::XTY_CM == Type; }

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.isBSS() && !GVKind.isData())
+  if (!GVKind.isCommon() && !GVKind.isBSS() && !GVKind.isData() &&
+      !GVKind.isMergeable1ByteCString())
     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);
 

llvm/test/CodeGen/PowerPC/aix-xcoff-mergeable-str.ll

+; This file tests the codegen of mergeable strings in AIX assembly only.
+; Once the codegen of mergeable strings for XCOFF object files is supported
+; the test in this file should be merged into aix-xcoff-data.ll with additional
+; tests for XCOFF object files.
+
+; RUN: llc -verify-machineinstrs -mcpu=pwr7 \
+; RUN:     -mtriple powerpc-ibm-aix-xcoff < %s | FileCheck %s
+; RUN: llc -verify-machineinstrs -mcpu=pwr7 \
+; RUN:     -mtriple powerpc64-ibm-aix-xcoff < %s | FileCheck %s
+
+@strA = private unnamed_addr constant [14 x i8] c"hello world!\0A\00", align 1
+
+; CHECK:      .csect .rodata.str1.1[RO]
+; CHECK-NEXT: .LstrA:
+; CHECK-NEXT: .byte   104
+; CHECK-NEXT: .byte   101
+; CHECK-NEXT: .byte   108
+; CHECK-NEXT: .byte   108
+; CHECK-NEXT: .byte   111
+; CHECK-NEXT: .byte   32
+; CHECK-NEXT: .byte   119
+; CHECK-NEXT: .byte   111
+; CHECK-NEXT: .byte   114
+; CHECK-NEXT: .byte   108
+; CHECK-NEXT: .byte   100
+; CHECK-NEXT: .byte   33
+; CHECK-NEXT: .byte   10
+; CHECK-NEXT: .byte   0