[X86] Add elfiamcu triple support, and a workaround for PR3997

[mkuper]

Summary

This patch has two parts:

1. It adds support for "elfiamcu" triple to support the x86 Intel MCU psABI. This is something already supported by GCC trunk.

2. It introduces elfiamcu-specific code, which is a workaround for PR3997. The IAMCU psABI requires everything, including library functions to pass the first 3 parameters in-reg (note that the ABI is slightly different from -mregparm 3). Unfortunately, inreg marking for x86-32 is done by the frontend. Optimistically speaking, RTLIB function signatures ought to be simple enough for this to work. If not, we'll have to reconsider solving PR3997 more thoroughly.

Any suggestions on how to make this work better are welcome.

[DavidKreitzer]

lib/Target/X86/X86ISelLowering.cpp

27523 ↗

(On Diff #38101)

Is there an easy way to assert this, i.e. that there are no fancy types? Also, you probably want to explicitly handle varargs functions here, either by asserting that you cannot get here for varargs functions or by excluding them from the inreg marking.

[rnk]

It'd be nice if we come come up with a more general solution to PR3997. If we had a way to send arbitrary module-wide flags through to the backend like TargetTuple, then we'd go ahead and put mregparm=3 there. Obviously we don't, and we've been trying to move towards per-function attributes. So, we could conceivably slap an attribute like "libcall-regparms"=N on every function, and then, during markInRegArguments, look at that after checking the triple.

What do you guys think?

[mkuper]

In D13977#273248, @rnk wrote:

It'd be nice if we come come up with a more general solution to PR3997. If we had a way to send arbitrary module-wide flags through to the backend like TargetTuple, then we'd go ahead and put mregparm=3 there. Obviously we don't, and we've been trying to move towards per-function attributes. So, we could conceivably slap an attribute like "libcall-regparms"=N on every function, and then, during markInRegArguments, look at that after checking the triple.

What do you guys think?

My only objection to this is that it gives the impression that it's ok to mix different libcall-regparms functions in the same module. IIRC the main reasoning for relying mainly on per-function attributes is LTO - and I'm fairly sure this particular mix-and-match should never happen, regardless of LTO. Having said that, I don't think we currently have a better way to do this.

Also, given how long-standing the issue in PR3997 is, I'm somewhat reluctant (perhaps, scared) to fix it.
Is it reasonable to assume nobody is relying on the current ("broken/GCC-incompatible") behavior of -mregparm? And how much do we care about being backward compatible with that?

[rnk]

lgtm

Yeah, I can definitely understand not wanting to stir the pot. Users of mregparm=3 probably have #ifdefs to work around this on the declaration of memcpy.

llvm/trunk/include/llvm/ADT/Triple.h

enum EnvironmentType {
     EABIHF,
     Android,
 
     MSVC,
     Itanium,
     Cygnus,
     AMDOpenCL,
     CoreCLR,
-    LastEnvironmentType = CoreCLR
+    ELFIAMCU,
+    LastEnvironmentType = ELFIAMCU
   };
   enum ObjectFormatType {
     UnknownObjectFormat,
 
     COFF,
     ELF,
     MachO,
   };
public:
   bool isOSSolaris() const {
     return getOS() == Triple::Solaris;
   }
 
   bool isOSBitrig() const {
     return getOS() == Triple::Bitrig;
   }
 
+  bool isEnvironmentIAMCU() const {
+    return getEnvironment() == Triple::ELFIAMCU;
+  }
+
   bool isWindowsMSVCEnvironment() const {
     return getOS() == Triple::Win32 &&
            (getEnvironment() == Triple::UnknownEnvironment ||
             getEnvironment() == Triple::MSVC);
   }
 
   bool isKnownWindowsMSVCEnvironment() const {
     return getOS() == Triple::Win32 && getEnvironment() == Triple::MSVC;

llvm/trunk/lib/Support/Triple.cpp

const char *Triple::getEnvironmentTypeName(EnvironmentType Kind) {
   case EABI: return "eabi";
   case EABIHF: return "eabihf";
   case Android: return "android";
   case MSVC: return "msvc";
   case Itanium: return "itanium";
   case Cygnus: return "cygnus";
   case AMDOpenCL: return "amdopencl";
   case CoreCLR: return "coreclr";
+  case ELFIAMCU: return "elfiamcu";
   }
 
   llvm_unreachable("Invalid EnvironmentType!");
 }
 
 static Triple::ArchType parseBPFArch(StringRef ArchName) {
   if (ArchName.equals("bpf")) {
     if (sys::IsLittleEndianHost)
return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
     .StartsWith("code16", Triple::CODE16)
     .StartsWith("gnu", Triple::GNU)
     .StartsWith("android", Triple::Android)
     .StartsWith("msvc", Triple::MSVC)
     .StartsWith("itanium", Triple::Itanium)
     .StartsWith("cygnus", Triple::Cygnus)
     .StartsWith("amdopencl", Triple::AMDOpenCL)
     .StartsWith("coreclr", Triple::CoreCLR)
+    .StartsWith("elfiamcu", Triple::ELFIAMCU)
     .Default(Triple::UnknownEnvironment);
 }
 
 static Triple::ObjectFormatType parseFormat(StringRef EnvironmentName) {
   return StringSwitch<Triple::ObjectFormatType>(EnvironmentName)
     .EndsWith("coff", Triple::COFF)
     .EndsWith("elf", Triple::ELF)
     .EndsWith("macho", Triple::MachO)

llvm/trunk/lib/Target/X86/X86Subtarget.h

public:
   bool isTargetCOFF() const { return TargetTriple.isOSBinFormatCOFF(); }
   bool isTargetMachO() const { return TargetTriple.isOSBinFormatMachO(); }
 
   bool isTargetLinux() const { return TargetTriple.isOSLinux(); }
   bool isTargetAndroid() const { return TargetTriple.isAndroid(); }
   bool isTargetNaCl() const { return TargetTriple.isOSNaCl(); }
   bool isTargetNaCl32() const { return isTargetNaCl() && !is64Bit(); }
   bool isTargetNaCl64() const { return isTargetNaCl() && is64Bit(); }
+  bool isTargetMCU() const { return TargetTriple.isEnvironmentIAMCU(); }
 
   bool isTargetWindowsMSVC() const {
     return TargetTriple.isWindowsMSVCEnvironment();
   }
 
   bool isTargetKnownWindowsMSVC() const {
     return TargetTriple.isKnownWindowsMSVCEnvironment();
   }

llvm/trunk/unittests/ADT/TripleTest.cpp

TEST(TripleTest, ParsedIDs) {
   Triple T;
 
   T = Triple("i386-apple-darwin");
   EXPECT_EQ(Triple::x86, T.getArch());
   EXPECT_EQ(Triple::Apple, T.getVendor());
   EXPECT_EQ(Triple::Darwin, T.getOS());
   EXPECT_EQ(Triple::UnknownEnvironment, T.getEnvironment());
 
+  T = Triple("i386-pc-linux-elfiamcu");
+  EXPECT_EQ(Triple::x86, T.getArch());
+  EXPECT_EQ(Triple::PC, T.getVendor());
+  EXPECT_EQ(Triple::Linux, T.getOS());
+  EXPECT_EQ(Triple::ELFIAMCU, T.getEnvironment());
+
   T = Triple("x86_64-pc-linux-gnu");
   EXPECT_EQ(Triple::x86_64, T.getArch());
   EXPECT_EQ(Triple::PC, T.getVendor());
   EXPECT_EQ(Triple::Linux, T.getOS());
   EXPECT_EQ(Triple::GNU, T.getEnvironment());
 
   T = Triple("powerpc-bgp-linux");
   EXPECT_EQ(Triple::ppc, T.getArch());