[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

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.

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;

include/llvm/Target/TargetLowering.h

struct CallLoweringInfo {
     }
 
     ArgListTy &getArgs() {
       return Args;
     }
 
   };
 
+  // Mark inreg arguments for lib-calls. For normal calls this is done by
+  // the frontend ABI code.
+  virtual void markInRegArguments(SelectionDAG &DAG, 
+                 TargetLowering::ArgListTy &Args) const {
+    return;
+  }
+
   /// This function lowers an abstract call to a function into an actual call.
   /// This returns a pair of operands.  The first element is the return value
   /// for the function (if RetTy is not VoidTy).  The second element is the
   /// outgoing token chain. It calls LowerCall to do the actual lowering.
   std::pair<SDValue, SDValue> LowerCallTo(CallLoweringInfo &CLI) const;
 
   /// This hook must be implemented to lower calls into the specified
   /// DAG. The outgoing arguments to the call are described by the Outs array,

lib/CodeGen/SelectionDAG/TargetLowering.cpp

TargetLowering::makeLibCall(SelectionDAG &DAG,
   TargetLowering::ArgListEntry Entry;
   for (unsigned i = 0; i != NumOps; ++i) {
     Entry.Node = Ops[i];
     Entry.Ty = Entry.Node.getValueType().getTypeForEVT(*DAG.getContext());
     Entry.isSExt = shouldSignExtendTypeInLibCall(Ops[i].getValueType(), isSigned);
     Entry.isZExt = !shouldSignExtendTypeInLibCall(Ops[i].getValueType(), isSigned);
     Args.push_back(Entry);
   }
+
+  markInRegArguments(DAG, Args);
+
   if (LC == RTLIB::UNKNOWN_LIBCALL)
     report_fatal_error("Unsupported library call operation!");
   SDValue Callee = DAG.getExternalSymbol(getLibcallName(LC),
                                          getPointerTy(DAG.getDataLayout()));
 
   Type *RetTy = RetVT.getTypeForEVT(*DAG.getContext());
   TargetLowering::CallLoweringInfo CLI(DAG);
   bool signExtend = shouldSignExtendTypeInLibCall(RetVT, isSigned);

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)

lib/Target/X86/X86ISelLowering.h

public:
     bool isNoopAddrSpaceCast(unsigned SrcAS, unsigned DestAS) const override;
 
     bool useLoadStackGuardNode() const override;
     /// \brief Customize the preferred legalization strategy for certain types.
     LegalizeTypeAction getPreferredVectorAction(EVT VT) const override;
 
     bool isIntDivCheap(EVT VT, AttributeSet Attr) const override;
 
+    void markInRegArguments(SelectionDAG &DAG, TargetLowering::ArgListTy& Args)
+      const override;
+
   protected:
     std::pair<const TargetRegisterClass *, uint8_t>
     findRepresentativeClass(const TargetRegisterInfo *TRI,
                             MVT VT) const override;
 
   private:
     /// Keep a pointer to the X86Subtarget around so that we can
     /// make the right decision when generating code for different targets.

lib/Target/X86/X86ISelLowering.cpp

bool X86TargetLowering::isIntDivCheap(EVT VT, AttributeSet Attr) const {
   // The exception to this is vector division. Since x86 doesn't have vector
   // integer division, leaving the division as-is is a loss even in terms of
   // size, because it will have to be scalarized, while the alternative code
   // sequence can be performed in vector form.
   bool OptSize = Attr.hasAttribute(AttributeSet::FunctionIndex,
                                    Attribute::MinSize);
   return OptSize && !VT.isVector();
 }
+
+void X86TargetLowering::markInRegArguments(SelectionDAG &DAG,
+       TargetLowering::ArgListTy& Args) const {
+  // The MCU psABI requires some arguments to be passed in-register.
+  // For regular calls, the inreg arguments are marked by the front-end.
+  // However, for compiler generated library calls, we have to patch this
+  // up here.
+  if (!Subtarget->isTargetMCU() || !Args.size())
+    return;
+
+  unsigned FreeRegs = 3;
+  for (auto &Arg : Args) {
+    // For library functions, we do not expect any fancy types.
+    unsigned Size = DAG.getDataLayout().getTypeSizeInBits(Arg.Ty);
+    unsigned SizeInRegs = (Size + 31) / 32;
+    if (SizeInRegs > 2 || SizeInRegs > FreeRegs)
+      continue;
+
+    Arg.isInReg = true;
+    FreeRegs -= SizeInRegs;
+    if (!FreeRegs)
+      break;
+  }
+}

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();
   }

test/CodeGen/X86/mcu-abi.ll

+; RUN: llc < %s -mtriple=i686-pc-linux-elfiamcu | FileCheck %s
+
+; CHECK-LABEL: test_lib_args:
+; CHECK: movl %edx, %eax
+; CHECK: calll __fixsfsi
+define i32 @test_lib_args(float inreg %a, float inreg %b) #0 {
+  %ret = fptosi float %b to i32
+  ret i32 %ret
+}
+
+attributes #0 = { nounwind "use-soft-float"="true"}

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());