Add XCOFF triple object format type for AIX

[jasonliu]

Summary

This patch adds an XCOFF triple object format type into LLVM. This XCOFF triple object file type will be used later by object file and assembly generation for the AIX platform.

[hubert.reinterpretcast]

llvm/lib/Support/Triple.cpp

537

If the conclusion is that checking XCOFF before COFF is fine, then we should remove the FIXME and just leave a normal comment.

[apaprocki]

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

2080

No need to be sorry: :) This should probably just say error: XCOFF is unimplemented to be more direct in case anything is expecting "error:" in the output.

llvm/lib/Support/Triple.cpp

537

Agreed, existing code seems fine as long as there is a comment explaining that xcoff must come before coff in case it isn't obvious at a quick glance.

[jasonliu]

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

2080

Sure. Will address in next revision.

llvm/lib/Support/Triple.cpp

537

Sounds good. I will remove FIXME and leave a normal comment to indicate the order dependency.

[jasonliu]

Address some review comments

[JDevlieghere]

clang/lib/CodeGen/BackendUtil.cpp

1470

This is confusing, you say fall through but you break? I would prefer a llvm_unreachable("XCOFF not yet implemented"); here and elsewhere in this patch.

1486

See previous comment.

clang/lib/CodeGen/CodeGenModule.cpp

4410

See previous comment.

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

2080

Just bundle this with the WASM case, the error message is correct for both.

llvm/lib/MC/MCContext.cpp

165

See previous comment.

[jasonliu]

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

2080

I think they are different.
The error message for WASM seems to suggest that it will never ever get supported on WASM.
But it is not the case for XCOFF, we want to indicate that it is not implemented yet.

[jasonliu]

clang/lib/CodeGen/BackendUtil.cpp

1470

Thanks for the comment. Will address in next revision.

1486

Will address in next revision.

clang/lib/CodeGen/CodeGenModule.cpp

4410

Will address in next revision.

[jasonliu]

llvm/lib/MC/MCContext.cpp

165

It is certain that we will need MCSymbolXCOFF. But before we run into cases where we actually need a MCSymbolXCOFF, we could use the generic MCSymbol first for XCOFF platform. So I don't want to put a llvm_unreachable here.

[JDevlieghere]

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

2080

I don't think the error message suggests that at all, and it's definitely not true. At this point neither XCOFF nor WASM is supported, and that's exactly what the log message says.

[hubert.reinterpretcast]

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

2080

I agree that the error message for WASM does not indicate that the lack of support is inherent or intended to be permanent; however, it is not indicative either of an intent to implement the support. I am not sure what the intent is for WASM, but I do know that the intent for XCOFF is to eventually implement the support. I do not see how using an ambiguous message in this commit (when we know what the intent is) is superior to the alternative of having an unambiguous message.

[jasonliu]

Address comments in last revision.

[davide]

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

2080

I think we should keep this consistent with the other target so my vote is for grouping XCOFF with WASM. After all, if it's going to be implemented soon, the message will go away :)

[hubert.reinterpretcast]

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

2080

Well, I don't know about "soon"...
Using the WASM message for XCOFF is not actually wrong; so, I can be okay with it.

[sfertile]

llvm/lib/MC/MCContext.cpp

165

Would it make sense to add an llvm_unreachable now, and the first patch that actually uses an MCSymbol stubs out the class and removes the unreachable?

[jasonliu]

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

2080

Okay. Shared message it is.

llvm/lib/MC/MCContext.cpp

165

The first patch that uses MCSymbol do not necessarily need to stub out MCSymbolXCOFF, as MCSymbol seems to be generic and usable until we are doing some XCOFF specific things that needs to be represented by MCSymbolXCOFF. If the intention is MCSymbol should never get used, and different object file should have their own MCSymbolXXX class from the start, then I could add in the llvm_unreachable here, and I would also propose to replace the "return new (Name, *this) MCSymbol(MCSymbol::SymbolKindUnset, Name, IsTemporary);" with an llvm_unreachable as well.

[jasonliu]

Share the same "unsupported error" message with WASM.

[sfertile]

LGTM.

llvm/lib/MC/MCContext.cpp

165

Ok I think falling through to create the generic MCSymbol in this patch is reasonable.

[hubert.reinterpretcast]

@jasonliu, you have had a number of patches committed into the project already (D22698, D22702, D34649). Please go ahead with requesting commit access, and commit this patch with the additional fix when you are ready.

llvm/lib/MC/MCObjectFileInfo.cpp

806

This line is over 80 characters.

clang/lib/CodeGen/BackendUtil.cpp

static const char* getSectionNameForBitcode(const Triple &T) {
   switch (T.getObjectFormat()) {
   case Triple::MachO:
     return "__LLVM,__bitcode";
   case Triple::COFF:
   case Triple::ELF:
   case Triple::Wasm:
   case Triple::UnknownObjectFormat:
     return ".llvmbc";
+  case Triple::XCOFF:
+    llvm_unreachable("XCOFF is not yet implemented");
+    break;
   }
   llvm_unreachable("Unimplemented ObjectFormatType");
 }
 
 static const char* getSectionNameForCommandline(const Triple &T) {
   switch (T.getObjectFormat()) {
   case Triple::MachO:
     return "__LLVM,__cmdline";
   case Triple::COFF:
   case Triple::ELF:
   case Triple::Wasm:
   case Triple::UnknownObjectFormat:
     return ".llvmcmd";
+  case Triple::XCOFF:
+    llvm_unreachable("XCOFF is not yet implemented");
+    break;
   }
   llvm_unreachable("Unimplemented ObjectFormatType");
 }
 
 // With -fembed-bitcode, save a copy of the llvm IR as data in the
 // __LLVM,__bitcode section.
 void clang::EmbedBitcode(llvm::Module *M, const CodeGenOptions &CGOpts,
                          llvm::MemoryBufferRef Buf) {

clang/lib/CodeGen/CodeGenModule.cpp

CodeGenModule::GetAddrOfConstantCFString(const StringLiteral *Literal) {
 
   // The struct.
   GV = Fields.finishAndCreateGlobal("_unnamed_cfstring_", Alignment,
                                     /*isConstant=*/false,
                                     llvm::GlobalVariable::PrivateLinkage);
   switch (Triple.getObjectFormat()) {
   case llvm::Triple::UnknownObjectFormat:
     llvm_unreachable("unknown file format");
+  case llvm::Triple::XCOFF:
+    llvm_unreachable("XCOFF is not yet implemented");
   case llvm::Triple::COFF:
   case llvm::Triple::ELF:
   case llvm::Triple::Wasm:
     GV->setSection("cfstring");
     break;
   case llvm::Triple::MachO:
     GV->setSection("__DATA,__cfstring");
     break;

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

if (response.IsNormalResponse()) {
           assert(pointer_byte_size == m_process_arch.GetAddressByteSize());
         }
       } else if (cpu != LLDB_INVALID_CPUTYPE && !os_name.empty() &&
                  !vendor_name.empty()) {
         llvm::Triple triple(llvm::Twine("-") + vendor_name + "-" + os_name);
 
         assert(triple.getObjectFormat() != llvm::Triple::UnknownObjectFormat);
         assert(triple.getObjectFormat() != llvm::Triple::Wasm);
+        assert(triple.getObjectFormat() != llvm::Triple::XCOFF);
         switch (triple.getObjectFormat()) {
         case llvm::Triple::MachO:
           m_process_arch.SetArchitecture(eArchTypeMachO, cpu, sub);
           break;
         case llvm::Triple::ELF:
           m_process_arch.SetArchitecture(eArchTypeELF, cpu, sub);
           break;
         case llvm::Triple::COFF:
           m_process_arch.SetArchitecture(eArchTypeCOFF, cpu, sub);
           break;
         case llvm::Triple::Wasm:
+        case llvm::Triple::XCOFF:
           if (log)
             log->Printf("error: not supported target architecture");
           return false;
         case llvm::Triple::UnknownObjectFormat:
           if (log)
             log->Printf("error: failed to determine target architecture");
           return false;
         }
 
         if (pointer_byte_size) {
           assert(pointer_byte_size == m_process_arch.GetAddressByteSize());
         }
         if (byte_order != eByteOrderInvalid) {
           assert(byte_order == m_process_arch.GetByteOrder());

llvm/include/llvm/ADT/Triple.h

public:
   };
   enum ObjectFormatType {
     UnknownObjectFormat,
 
     COFF,
     ELF,
     MachO,
     Wasm,
+    XCOFF,
   };
 
 private:
   std::string Data;
 
   /// The parsed arch type.
   ArchType Arch;
 
public:
 
   /// Tests whether the OS uses glibc.
   bool isOSGlibc() const {
     return (getOS() == Triple::Linux || getOS() == Triple::KFreeBSD ||
             getOS() == Triple::Hurd) &&
            !isAndroid();
   }
 
+  /// Tests whether the OS is AIX.
+  bool isOSAIX() const {
+    return getOS() == Triple::AIX;
+  }
+
   /// Tests whether the OS uses the ELF binary format.
   bool isOSBinFormatELF() const {
     return getObjectFormat() == Triple::ELF;
   }
 
   /// Tests whether the OS uses the COFF binary format.
   bool isOSBinFormatCOFF() const {
     return getObjectFormat() == Triple::COFF;
   }
 
   /// Tests whether the environment is MachO.
   bool isOSBinFormatMachO() const {
     return getObjectFormat() == Triple::MachO;
   }
 
   /// Tests whether the OS uses the Wasm binary format.
   bool isOSBinFormatWasm() const {
     return getObjectFormat() == Triple::Wasm;
   }
   
+  /// Tests whether the OS uses the XCOFF binary format.
+  bool isOSBinFormatXCOFF() const {
+    return getObjectFormat() == Triple::XCOFF;
+  }
+
   /// Tests whether the target is the PS4 CPU
   bool isPS4CPU() const {
     return getArch() == Triple::x86_64 &&
            getVendor() == Triple::SCEI &&
            getOS() == Triple::PS4;
   }
 
   /// Tests whether the target is the PS4 platform

llvm/include/llvm/MC/MCObjectFileInfo.h

public:
   MCSection *getXDataSection() const { return XDataSection; }
   MCSection *getSXDataSection() const { return SXDataSection; }
   MCSection *getGFIDsSection() const { return GFIDsSection; }
 
   MCSection *getEHFrameSection() {
     return EHFrameSection;
   }
 
-  enum Environment { IsMachO, IsELF, IsCOFF, IsWasm };
+  enum Environment { IsMachO, IsELF, IsCOFF, IsWasm, IsXCOFF };
   Environment getObjectFileType() const { return Env; }
 
   bool isPositionIndependent() const { return PositionIndependent; }
 
 private:
   Environment Env;
   bool PositionIndependent;
   MCContext *Ctx;

llvm/lib/MC/MCContext.cpp

if (MOFI) {
     case MCObjectFileInfo::IsCOFF:
       return new (Name, *this) MCSymbolCOFF(Name, IsTemporary);
     case MCObjectFileInfo::IsELF:
       return new (Name, *this) MCSymbolELF(Name, IsTemporary);
     case MCObjectFileInfo::IsMachO:
       return new (Name, *this) MCSymbolMachO(Name, IsTemporary);
     case MCObjectFileInfo::IsWasm:
       return new (Name, *this) MCSymbolWasm(Name, IsTemporary);
+    case MCObjectFileInfo::IsXCOFF:
+      // TODO: Need to implement class MCSymbolXCOFF.
+      break;
     }
   }
   return new (Name, *this) MCSymbol(MCSymbol::SymbolKindUnset, Name,
                                     IsTemporary);
 }
 
 MCSymbol *MCContext::createSymbol(StringRef Name, bool AlwaysAddSuffix,
                                   bool CanBeUnnamed) {

llvm/lib/MC/MCObjectFileInfo.cpp

void MCObjectFileInfo::InitMCObjectFileInfo(const Triple &TheTriple, bool PIC,
   case Triple::ELF:
     Env = IsELF;
     initELFMCObjectFileInfo(TT, LargeCodeModel);
     break;
   case Triple::Wasm:
     Env = IsWasm;
     initWasmMCObjectFileInfo(TT);
     break;
+  case Triple::XCOFF:
+    Env = IsXCOFF;
+    // TODO: Initialize MCObjectFileInfo for XCOFF format when MCSectionXCOFF is ready.
+    break;
   case Triple::UnknownObjectFormat:
     report_fatal_error("Cannot initialize MC for unknown object file format.");
     break;
   }
 }
 
 MCSection *MCObjectFileInfo::getDwarfComdatSection(const char *Name,
                                                    uint64_t Hash) const {
   switch (TT.getObjectFormat()) {
   case Triple::ELF:
     return Ctx->getELFSection(Name, ELF::SHT_PROGBITS, ELF::SHF_GROUP, 0,
                               utostr(Hash));
   case Triple::MachO:
   case Triple::COFF:
   case Triple::Wasm:
+  case Triple::XCOFF:
   case Triple::UnknownObjectFormat:
     report_fatal_error("Cannot get DWARF comdat section for this object file "
                        "format: not implemented.");
     break;
   }
   llvm_unreachable("Unknown ObjectFormatType");
 }
 

llvm/lib/MC/MCParser/AsmParser.cpp

case MCObjectFileInfo::IsMachO:
     IsDarwin = true;
     break;
   case MCObjectFileInfo::IsELF:
     PlatformParser.reset(createELFAsmParser());
     break;
   case MCObjectFileInfo::IsWasm:
     PlatformParser.reset(createWasmAsmParser());
     break;
+  case MCObjectFileInfo::IsXCOFF:
+    // TODO: Need to implement createXCOFFAsmParser for XCOFF format.
+    break;
   }
 
   PlatformParser->Initialize(*this);
   initializeDirectiveKindMap();
 
   NumOfMacroInstantiations = 0;
 }
 

llvm/lib/Support/Triple.cpp

return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
     .StartsWith("cygnus", Triple::Cygnus)
     .StartsWith("coreclr", Triple::CoreCLR)
     .StartsWith("simulator", Triple::Simulator)
     .Default(Triple::UnknownEnvironment);
 }
 
 static Triple::ObjectFormatType parseFormat(StringRef EnvironmentName) {
   return StringSwitch<Triple::ObjectFormatType>(EnvironmentName)
+    // "xcoff" must come before "coff" because of the order-dependendent
+    // pattern matching.
+    .EndsWith("xcoff", Triple::XCOFF)
     .EndsWith("coff", Triple::COFF)
     .EndsWith("elf", Triple::ELF)
     .EndsWith("macho", Triple::MachO)
     .EndsWith("wasm", Triple::Wasm)
     .Default(Triple::UnknownObjectFormat);
 }
 
 static Triple::SubArchType parseSubArch(StringRef SubArchName) {

 
 static StringRef getObjectFormatTypeName(Triple::ObjectFormatType Kind) {
   switch (Kind) {
   case Triple::UnknownObjectFormat: return "";
   case Triple::COFF: return "coff";
   case Triple::ELF: return "elf";
   case Triple::MachO: return "macho";
   case Triple::Wasm: return "wasm";
+  case Triple::XCOFF: return "xcoff";
   }
   llvm_unreachable("unknown object format type");
 }
 
 static Triple::ObjectFormatType getDefaultFormat(const Triple &T) {
   switch (T.getArch()) {
   case Triple::UnknownArch:
   case Triple::aarch64:
static Triple::ObjectFormatType getDefaultFormat(const Triple &T) {
   case Triple::thumbeb:
   case Triple::xcore:
     return Triple::ELF;
 
   case Triple::ppc:
   case Triple::ppc64:
     if (T.isOSDarwin())
       return Triple::MachO;
+    else if (T.isOSAIX())
+      return Triple::XCOFF;
     return Triple::ELF;
 
   case Triple::wasm32:
   case Triple::wasm64:
     return Triple::Wasm;
   }
   llvm_unreachable("unknown architecture");
 }

llvm/lib/Target/ARM/AsmParser/ARMAsmParser.cpp

case MCObjectFileInfo::IsELF:
     CurrentFormat = ELF;
     break;
   case MCObjectFileInfo::IsCOFF:
     CurrentFormat = COFF;
     break;
   case MCObjectFileInfo::IsWasm:
     CurrentFormat = WASM;
     break;
+  case MCObjectFileInfo::IsXCOFF:
+    llvm_unreachable("unexpected object format");
+    break;
   }
 
   if (~Prefix->SupportedFormats & CurrentFormat) {
     Error(Parser.getTok().getLoc(),
           "cannot represent relocation in the current file format");
     return true;
   }
 

llvm/unittests/ADT/TripleTest.cpp

EXPECT_EQ(Triple::Wasm,
             Triple("wasm32-unknown-unknown-wasm").getObjectFormat());
   EXPECT_EQ(Triple::Wasm,
             Triple("wasm64-unknown-unknown-wasm").getObjectFormat());
   EXPECT_EQ(Triple::Wasm,
             Triple("wasm32-unknown-wasi-musl-wasm").getObjectFormat());
   EXPECT_EQ(Triple::Wasm,
             Triple("wasm64-unknown-wasi-musl-wasm").getObjectFormat());
 
+  EXPECT_EQ(Triple::XCOFF, Triple("powerpc-ibm-aix").getObjectFormat());
+  EXPECT_EQ(Triple::XCOFF, Triple("powerpc64-ibm-aix").getObjectFormat());
+  EXPECT_EQ(Triple::XCOFF, Triple("powerpc---xcoff").getObjectFormat());
+  EXPECT_EQ(Triple::XCOFF, Triple("powerpc64---xcoff").getObjectFormat());
+
   Triple MSVCNormalized(Triple::normalize("i686-pc-windows-msvc-elf"));
   EXPECT_EQ(Triple::ELF, MSVCNormalized.getObjectFormat());
 
   Triple GNUWindowsNormalized(Triple::normalize("i686-pc-windows-gnu-elf"));
   EXPECT_EQ(Triple::ELF, GNUWindowsNormalized.getObjectFormat());
 
   Triple CygnusNormalised(Triple::normalize("i686-pc-windows-cygnus-elf"));
   EXPECT_EQ(Triple::ELF, CygnusNormalised.getObjectFormat());
 
   Triple CygwinNormalized(Triple::normalize("i686-pc-cygwin-elf"));
   EXPECT_EQ(Triple::ELF, CygwinNormalized.getObjectFormat());
 
   Triple T = Triple("");
   T.setObjectFormat(Triple::ELF);
   EXPECT_EQ(Triple::ELF, T.getObjectFormat());
 
   T.setObjectFormat(Triple::MachO);
   EXPECT_EQ(Triple::MachO, T.getObjectFormat());
+  
+  T.setObjectFormat(Triple::XCOFF);
+  EXPECT_EQ(Triple::XCOFF, T.getObjectFormat());
 }
 
 TEST(TripleTest, NormalizeWindows) {
   EXPECT_EQ("i686-pc-windows-msvc", Triple::normalize("i686-pc-win32"));
   EXPECT_EQ("i686-unknown-windows-msvc", Triple::normalize("i686-win32"));
   EXPECT_EQ("i686-pc-windows-gnu", Triple::normalize("i686-pc-mingw32"));
   EXPECT_EQ("i686-unknown-windows-gnu", Triple::normalize("i686-mingw32"));
   EXPECT_EQ("i686-pc-windows-gnu", Triple::normalize("i686-pc-mingw32-w64"));