[mips] Add MIPS ABI enumeration and getter function to the Triple class

[atanasyan]

Summary

MIPS uses multiple ABIs. Now LLVM supports three of them: O32, N32, and N64. The Triple::Environment has items GNU, GNUABIN32, and GNUABI64, but these items do not cover all possible cases. Ideally, we have to add something like AndroidN64, MuslN32, MuslN64 etc.

This change selects another approach. It adds MipsABI enumeration to the Triple class and treats MIPS ABI like the SubArchType. To recognize ABI it parses "environmet" component of a target triple and retrieve ABI type from it.

This change allows to keep selected MIPS ABI in one place - a target triple. In the next patches I'm going to stop using MCTargetOptions::ABIName for propagating MIPS ABI and to fix some issues which require type of selected MIPS ABI in places where MCTargetOptions::ABIName is not available at all (like MipsMCAsmInfo).

[atanasyan]

Ping?

[rengolin]

Hi Simon,

I really don't like treating Mips different than all others. But I really don't know enough about the Mips ABI problems to come up with a better way (all I know it's that they're worse than ARM's ABI problems).

I'm hoping that Eric knows better. :)

--renato

[atanasyan]

Hi Renato,

In D38799#904200, @rengolin wrote:

I really don't like treating Mips different than all others. But I really don't know enough about the Mips ABI problems to come up with a better way (all I know it's that they're worse than ARM's ABI problems).

This patch is really MIPS specific. But I think the problem is actually more general. Now, for example, we have three "environment" GNU, EABI, and Musl and "HF" ABI variants for each of this environment. If we support more C libraries, we will have to add new Environment items for each supported environment+ABI pair. Something like NewLib, NewLibHF etc. The idea of this patch is to separate notions of Environment and ABI and escape growing the Environment enumeration if we need to add new ABI for existing "environment".

[rengolin]

In D38799#904251, @atanasyan wrote:

This patch is really MIPS specific. But I think the problem is actually more general. Now, for example, we have three "environment" GNU, EABI, and Musl and "HF" ABI variants for each of this environment. If we support more C libraries, we will have to add new Environment items for each supported environment+ABI pair. Something like NewLib, NewLibHF etc. The idea of this patch is to separate notions of Environment and ABI and escape growing the Environment enumeration if we need to add new ABI for existing "environment".

I agree that we could clean up a lot of crud by separating environment from ABI, but this is not what this patch is doing, at least for every other non-Mips architecture. Adding more special treatments to the already special Triple class won't help.

I also agree that ARM hasn't made that easy to begin with, and a lot of it is ARM's fault (the arch, not the company:).

@echristo do you have any visibility on Triple changes that would help this cleanup to happen soon?

cheers,
--renato

[atanasyan]

In D38799#904291, @rengolin wrote:

In D38799#904251, @atanasyan wrote:

This patch is really MIPS specific. But I think the problem is actually more general. Now, for example, we have three "environment" GNU, EABI, and Musl and "HF" ABI variants for each of this environment. If we support more C libraries, we will have to add new Environment items for each supported environment+ABI pair. Something like NewLib, NewLibHF etc. The idea of this patch is to separate notions of Environment and ABI and escape growing the Environment enumeration if we need to add new ABI for existing "environment".

I agree that we could clean up a lot of crud by separating environment from ABI, but this is not what this patch is doing, at least for every other non-Mips architecture. Adding more special treatments to the already special Triple class won't help.

I also agree that ARM hasn't made that easy to begin with, and a lot of it is ARM's fault (the arch, not the company:).

From my point of view, we have two options: a) exclude ABI information and pass it everywhere as a separate argument; b) keep ABI inside a triple, but separate environment and ABI entities. A disadvantage of the first option is that we have to change a lot of public API including the "C" interface. This patch tries to go alongside the second option. I agree that the patch changes MIPS parts only and does not touch ARM-specific ABIs. I'd be happy to provide more general solution and extend idea of the patch on other architectures if I get some sort of approval.

include/llvm/ADT/Triple.h

enum OSType {
     Contiki,
     AMDPAL,     // AMD PAL Runtime
     LastOSType = AMDPAL
   };
   enum EnvironmentType {
     UnknownEnvironment,
 
     GNU,
-    GNUABIN32,
-    GNUABI64,
     GNUEABI,
     GNUEABIHF,
     GNUX32,
     CODE16,
     EABI,
     EABIHF,
     Android,
     Musl,
public:
   enum ObjectFormatType {
     UnknownObjectFormat,
 
     COFF,
     ELF,
     MachO,
     Wasm,
   };
+  enum MipsABI {
+    O32,
+    N32,
+    N64,
+  };
 
 private:
   std::string Data;
 
   /// The parsed arch type.
   ArchType Arch;
 
   /// The parsed subarchitecture type.
public:
   void getiOSVersion(unsigned &Major, unsigned &Minor,
                      unsigned &Micro) const;
 
   /// getWatchOSVersion - Parse the version number as with getOSVersion.  This
   /// should only be called with WatchOS or generic triples.
   void getWatchOSVersion(unsigned &Major, unsigned &Minor,
                          unsigned &Micro) const;
 
+  /// getMipsABI - Parse environment component to retrieve MIPS ABI name.
+  MipsABI getMipsABI() const;
+
   /// @}
   /// @name Direct Component Access
   /// @{
 
   const std::string &str() const { return Data; }
 
   const std::string &getTriple() const { return Data; }
 
public:
   }
 
   bool isOSIAMCU() const {
     return getOS() == Triple::ELFIAMCU;
   }
 
   bool isGNUEnvironment() const {
     EnvironmentType Env = getEnvironment();
-    return Env == Triple::GNU || Env == Triple::GNUABIN32 ||
-           Env == Triple::GNUABI64 || Env == Triple::GNUEABI ||
+    return Env == Triple::GNU || Env == Triple::GNUEABI ||
            Env == Triple::GNUEABIHF || Env == Triple::GNUX32;
   }
 
   bool isOSContiki() const {
     return getOS() == Triple::Contiki;
   }
 
   /// Tests whether the OS is Haiku.

lib/Support/Triple.cpp

StringRef Triple::getOSTypeName(OSType Kind) {
 
   llvm_unreachable("Invalid OSType");
 }
 
 StringRef Triple::getEnvironmentTypeName(EnvironmentType Kind) {
   switch (Kind) {
   case UnknownEnvironment: return "unknown";
   case GNU: return "gnu";
-  case GNUABIN32: return "gnuabin32";
-  case GNUABI64: return "gnuabi64";
   case GNUEABIHF: return "gnueabihf";
   case GNUEABI: return "gnueabi";
   case GNUX32: return "gnux32";
   case CODE16: return "code16";
   case EABI: return "eabi";
   case EABIHF: return "eabihf";
   case Android: return "android";
   case Musl: return "musl";
return StringSwitch<Triple::OSType>(OSName)
     .StartsWith("amdpal", Triple::AMDPAL)
     .Default(Triple::UnknownOS);
 }
 
 static Triple::EnvironmentType parseEnvironment(StringRef EnvironmentName) {
   return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
     .StartsWith("eabihf", Triple::EABIHF)
     .StartsWith("eabi", Triple::EABI)
-    .StartsWith("gnuabin32", Triple::GNUABIN32)
-    .StartsWith("gnuabi64", Triple::GNUABI64)
     .StartsWith("gnueabihf", Triple::GNUEABIHF)
     .StartsWith("gnueabi", Triple::GNUEABI)
     .StartsWith("gnux32", Triple::GNUX32)
     .StartsWith("code16", Triple::CODE16)
     .StartsWith("gnu", Triple::GNU)
     .StartsWith("android", Triple::Android)
     .StartsWith("musleabihf", Triple::MuslEABIHF)
     .StartsWith("musleabi", Triple::MuslEABI)
case llvm::Triple::MuslEABIHF:
       return "arm1176jzf-s";
     default:
       return "arm7tdmi";
     }
   }
 
   llvm_unreachable("invalid arch name");
 }
+
+Triple::MipsABI Triple::getMipsABI() const {
+  if (getEnvironmentName().endswith("abin32"))
+    return N32;
+  if (getEnvironmentName().endswith("abi64"))
+    return N64;
+  switch (getArch()) {
+  case mips:
+  case mipsel:
+    return O32;
+  case mips64:
+  case mips64el:
+    return N64;
+  default:
+    llvm_unreachable("non-MIPS arch name");
+  }
+}

lib/Target/Mips/MCTargetDesc/MipsMCAsmInfo.cpp

MipsMCAsmInfo::MipsMCAsmInfo(const Triple &TheTriple) {
   TPRel32Directive            = "\t.tprelword\t";
   TPRel64Directive            = "\t.tpreldword\t";
   UseAssignmentForEHBegin = true;
   SupportsDebugInformation = true;
   ExceptionsType = ExceptionHandling::DwarfCFI;
   DwarfRegNumForCFI = true;
   HasMipsExpressions = true;
 
-  // Enable IAS by default for O32.
-  if (TheTriple.getArch() == Triple::mips ||
-      TheTriple.getArch() == Triple::mipsel)
-    UseIntegratedAssembler = true;
-
-  // Enable IAS by default for Debian mips64/mips64el.
-  if (TheTriple.getEnvironment() == Triple::GNUABI64)
-    UseIntegratedAssembler = true;
-
-  // Enable IAS by default for Android mips64el that uses N64 ABI.
-  if (TheTriple.getArch() == Triple::mips64el && TheTriple.isAndroid())
-    UseIntegratedAssembler = true;
+  // Enable IAS by default for O32 and N64 ABI.
+  UseIntegratedAssembler = TheTriple.getMipsABI() == Triple::O32 ||
+                           TheTriple.getMipsABI() == Triple::N64;
 }

unittests/ADT/TripleTest.cpp

TEST(TripleTest, ParsedIDs) {
   EXPECT_EQ(Triple::GNU, T.getEnvironment());
 
   T = Triple("mips64el-img-linux-gnu");
   EXPECT_EQ(Triple::mips64el, T.getArch());
   EXPECT_EQ(Triple::ImaginationTechnologies, T.getVendor());
   EXPECT_EQ(Triple::Linux, T.getOS());
   EXPECT_EQ(Triple::GNU, T.getEnvironment());
 
-  T = Triple("mips64el-img-linux-gnuabin32");
-  EXPECT_EQ(Triple::mips64el, T.getArch());
-  EXPECT_EQ(Triple::ImaginationTechnologies, T.getVendor());
-  EXPECT_EQ(Triple::Linux, T.getOS());
-  EXPECT_EQ(Triple::GNUABIN32, T.getEnvironment());
-
-  T = Triple("mips64el-unknown-linux-gnuabi64");
-  EXPECT_EQ(Triple::mips64el, T.getArch());
-  EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
-  EXPECT_EQ(Triple::Linux, T.getOS());
-  EXPECT_EQ(Triple::GNUABI64, T.getEnvironment());
-
   T = Triple("huh");
   EXPECT_EQ(Triple::UnknownArch, T.getArch());
 }
 
 static std::string Join(StringRef A, StringRef B, StringRef C) {
   std::string Str = A; Str += '-'; Str += B; Str += '-'; Str += C;
   return Str;
 }
// AARCH64
     Triple T = Triple("aarch64");
     EXPECT_EQ(Triple::aarch64, T.getArch());
   }
   {
     Triple T = Triple("aarch64_be");
     EXPECT_EQ(Triple::aarch64_be, T.getArch());
   }
 }
+
+TEST(TripleTest, ParseMipsABI) {
+  Triple T = Triple("mips-img-linux");
+  EXPECT_EQ(Triple::mips, T.getArch());
+  EXPECT_EQ(Triple::ImaginationTechnologies, T.getVendor());
+  EXPECT_EQ(Triple::Linux, T.getOS());
+  EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
+  EXPECT_EQ(Triple::O32, T.getMipsABI());
+
+  T = Triple("mips64-img-linux");
+  EXPECT_EQ(Triple::mips64, T.getArch());
+  EXPECT_EQ(Triple::ImaginationTechnologies, T.getVendor());
+  EXPECT_EQ(Triple::Linux, T.getOS());
+  EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
+  EXPECT_EQ(Triple::N64, T.getMipsABI());
+
+  T = Triple("mips64--linux-android");
+  EXPECT_EQ(Triple::mips64, T.getArch());
+  EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
+  EXPECT_EQ(Triple::Linux, T.getOS());
+  EXPECT_EQ(Triple::Android, T.getEnvironment());
+  EXPECT_EQ(Triple::N64, T.getMipsABI());
+
+  T = Triple("mips64-img-linux-gnuabin32");
+  EXPECT_EQ(Triple::mips64, T.getArch());
+  EXPECT_EQ(Triple::ImaginationTechnologies, T.getVendor());
+  EXPECT_EQ(Triple::Linux, T.getOS());
+  EXPECT_EQ(Triple::GNU, T.getEnvironment());
+  EXPECT_EQ(Triple::N32, T.getMipsABI());
+
+  T = Triple("mips64-unknown-linux-gnuabi64");
+  EXPECT_EQ(Triple::mips64, T.getArch());
+  EXPECT_EQ(Triple::UnknownVendor, T.getVendor());
+  EXPECT_EQ(Triple::Linux, T.getOS());
+  EXPECT_EQ(Triple::GNU, T.getEnvironment());
+  EXPECT_EQ(Triple::N64, T.getMipsABI());
+}
 } // end anonymous namespace