Target: Add the midipix target

[martell]

Summary

Adds the midipix target for windows hosts.

[martell]

add context

[martell]

Needs feedback from midipix.
I have left a few notes.

include/llvm/ADT/Triple.h

536

Should we have a separate value called isOSMidipix() instead incase we support other hosts with a middle posix layer such as OSX, BSD, Consoles etc.

lib/Analysis/TargetLibraryInfo.cpp

145

Are these lib functions available midipix even though not on cygwin or mingw?

lib/Support/Triple.cpp

896

LLVM has a 4 part triplet, crazy I know.
x86_64-midipix-windows-midipix or i686-midipix-windows-midipix
or
x86_64-windows-midipix and i686-windows-midipix without the vendor part.

Example of mingw is x86_64-pc-windows-gnu which converts as x86_64-pc-mingw32
This gives us room to have x86_64-darwin-midipix in future etc.

Comments?

lib/Target/X86/MCTargetDesc/X86MCTargetDesc.cpp

62

Not sure what is going on here?
It falls back to the same flavor

176

We might have to add a new flavor similar to X86MCAsmInfoGNUCOFFcalled X86MCAsmInfoMIDIPIXCOFF where support for .got is added.
Will need feedback from llvm devs on if we can just use X86MCAsmInfoGNUCOFF

lib/Target/X86/X86FrameLowering.cpp

724

Do we just use alloca on midipix and never chkstk?

lib/Target/X86/X86ISelDAGToDAG.cpp

657

I assume we still need to emit the __main special code for this target?

lib/Target/X86/X86ISelLowering.cpp

461

Is the lowering the same as mingw here?

2825

Same as above for the main vs __main hook

lib/Target/X86/X86Subtarget.h

547

Same as above, should we convert into 2 functions?

tools/lli/lli.cpp

539

Again handler for __main hooking

include/llvm/ADT/Triple.h

enum EnvironmentType {
     CODE16,
     EABI,
     EABIHF,
     Android,
     Musl,
     MuslEABI,
     MuslEABIHF,
 
+    Midipix,
     MSVC,
     Itanium,
     Cygnus,
     AMDOpenCL,
     CoreCLR,
     OpenCL,
     LastEnvironmentType = OpenCL
   };
public:
   bool isWindowsCygwinEnvironment() const {
     return getOS() == Triple::Win32 && getEnvironment() == Triple::Cygnus;
   }
 
   bool isWindowsGNUEnvironment() const {
     return getOS() == Triple::Win32 && getEnvironment() == Triple::GNU;
   }
 
+  bool isWindowsMidipixEnvironment() const {
+    return getOS() == Triple::Win32 && getEnvironment() == Triple::Midipix;
+  }
+
   /// Tests for either Cygwin or MinGW OS
-  bool isOSCygMing() const {
-    return isWindowsCygwinEnvironment() || isWindowsGNUEnvironment();
+  bool isOSMidiCygMing() const {
+    return isWindowsMidipixEnvironment() || isWindowsCygwinEnvironment() ||
+           isWindowsGNUEnvironment();
   }
 
   /// Is this a "Windows" OS targeting a "MSVCRT.dll" environment.
   bool isOSMSVCRT() const {
     return isWindowsMSVCEnvironment() || isWindowsGNUEnvironment() ||
            isWindowsItaniumEnvironment();
   }
 

lib/Analysis/TargetLibraryInfo.cpp

static void initialize(TargetLibraryInfoImpl &TLI, const Triple &T,
 
   // iprintf and friends are only available on XCore and TCE.
   if (T.getArch() != Triple::xcore && T.getArch() != Triple::tce) {
     TLI.setUnavailable(LibFunc_iprintf);
     TLI.setUnavailable(LibFunc_siprintf);
     TLI.setUnavailable(LibFunc_fiprintf);
   }
 
-  if (T.isOSWindows() && !T.isOSCygMing()) {
+  if (T.isOSWindows() && !T.isOSMidiCygMing()) {
     // Win32 does not support long double
     TLI.setUnavailable(LibFunc_acosl);
     TLI.setUnavailable(LibFunc_asinl);
     TLI.setUnavailable(LibFunc_atanl);
     TLI.setUnavailable(LibFunc_atan2l);
     TLI.setUnavailable(LibFunc_ceill);
     TLI.setUnavailable(LibFunc_copysignl);
     TLI.setUnavailable(LibFunc_cosl);

lib/Support/Triple.cpp

StringRef Triple::getEnvironmentTypeName(EnvironmentType Kind) {
   case GNUX32: return "gnux32";
   case CODE16: return "code16";
   case EABI: return "eabi";
   case EABIHF: return "eabihf";
   case Android: return "android";
   case Musl: return "musl";
   case MuslEABI: return "musleabi";
   case MuslEABIHF: return "musleabihf";
+  case Midipix: return "midipix";
   case MSVC: return "msvc";
   case Itanium: return "itanium";
   case Cygnus: return "cygnus";
   case AMDOpenCL: return "amdopencl";
   case CoreCLR: return "coreclr";
   case OpenCL: return "opencl";
   }
 
return StringSwitch<Triple::EnvironmentType>(EnvironmentName)
     .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)
     .StartsWith("musl", Triple::Musl)
+    .StartsWith("midipix",Triple::Midipix)
     .StartsWith("msvc", Triple::MSVC)
     .StartsWith("itanium", Triple::Itanium)
     .StartsWith("cygnus", Triple::Cygnus)
     .StartsWith("amdopencl", Triple::AMDOpenCL)
     .StartsWith("coreclr", Triple::CoreCLR)
     .StartsWith("opencl", Triple::OpenCL)
     .Default(Triple::UnknownEnvironment);
 }
: Data((ArchStr + Twine('-') + VendorStr + Twine('-') + OSStr + Twine('-') +
       ObjectFormat(parseFormat(EnvironmentStr.str())) {
   if (ObjectFormat == Triple::UnknownObjectFormat)
     ObjectFormat = getDefaultFormat(*this);
 }
 
 std::string Triple::normalize(StringRef Str) {
   bool IsMinGW32 = false;
   bool IsCygwin = false;
+  bool IsMidipix = false;
 
   // Parse into components.
   SmallVector<StringRef, 4> Components;
   Str.split(Components, '-');
 
   // If the first component corresponds to a known architecture, preferentially
   // use it for the architecture.  If the second component corresponds to a
   // known vendor, preferentially use it for the vendor, etc.  This avoids silly
   // component movement when a component parses as (eg) both a valid arch and a
   // valid os.
   ArchType Arch = UnknownArch;
   if (Components.size() > 0)
     Arch = parseArch(Components[0]);
   VendorType Vendor = UnknownVendor;
   if (Components.size() > 1)
     Vendor = parseVendor(Components[1]);
   OSType OS = UnknownOS;
   if (Components.size() > 2) {
     OS = parseOS(Components[2]);
     IsCygwin = Components[2].startswith("cygwin");
     IsMinGW32 = Components[2].startswith("mingw");
+    IsMidipix = Components[2].startswith("midipix");
   }
   EnvironmentType Environment = UnknownEnvironment;
   if (Components.size() > 3)
     Environment = parseEnvironment(Components[3]);
   ObjectFormatType ObjectFormat = UnknownObjectFormat;
   if (Components.size() > 4)
     ObjectFormat = parseFormat(Components[4]);
 
for (unsigned Idx = 0; Idx != Components.size(); ++Idx) {
       case 1:
         Vendor = parseVendor(Comp);
         Valid = Vendor != UnknownVendor;
         break;
       case 2:
         OS = parseOS(Comp);
         IsCygwin = Comp.startswith("cygwin");
         IsMinGW32 = Comp.startswith("mingw");
-        Valid = OS != UnknownOS || IsCygwin || IsMinGW32;
+        IsMidipix = Comp.startswith("midipix");
+        Valid = OS != UnknownOS || IsCygwin || IsMinGW32 || IsMidipix;
         break;
       case 3:
         Environment = parseEnvironment(Comp);
         Valid = Environment != UnknownEnvironment;
         if (!Valid) {
           ObjectFormat = parseFormat(Comp);
           Valid = ObjectFormat != UnknownObjectFormat;
         }
std::string Triple::normalize(StringRef Str) {
   } else if (IsMinGW32) {
     Components.resize(4);
     Components[2] = "windows";
     Components[3] = "gnu";
   } else if (IsCygwin) {
     Components.resize(4);
     Components[2] = "windows";
     Components[3] = "cygnus";
+  } else if (IsMidipix) {
+    Components.resize(4);
+    Components[2] = "windows";
+    Components[3] = "midipix";
   }
-  if (IsMinGW32 || IsCygwin ||
+  if (IsMinGW32 || IsCygwin || IsMidipix ||
       (OS == Triple::Win32 && Environment != UnknownEnvironment)) {
     if (ObjectFormat != UnknownObjectFormat && ObjectFormat != Triple::COFF) {
       Components.resize(5);
       Components[4] = getObjectFormatTypeName(ObjectFormat);
     }
   }
 
   // Stick the corrected components back together to form the normalized string.

lib/Target/X86/MCTargetDesc/X86MCTargetDesc.cpp

 }
 
 unsigned X86_MC::getDwarfRegFlavour(const Triple &TT, bool isEH) {
   if (TT.getArch() == Triple::x86_64)
     return DWARFFlavour::X86_64;
 
   if (TT.isOSDarwin())
     return isEH ? DWARFFlavour::X86_32_DarwinEH : DWARFFlavour::X86_32_Generic;
-  if (TT.isOSCygMing())
+  if (TT.isOSMidiCygMing())
     // Unsupported by now, just quick fallback
     return DWARFFlavour::X86_32_Generic;
   return DWARFFlavour::X86_32_Generic;
 }
 
 void X86_MC::initLLVMToSEHAndCVRegMapping(MCRegisterInfo *MRI) {
   // FIXME: TableGen these.
   for (unsigned Reg = X86::NoRegister + 1; Reg < X86::NUM_TARGET_REGS; ++Reg) {
if (TheTriple.isOSBinFormatMachO()) {
     else
       MAI = new X86MCAsmInfoDarwin(TheTriple);
   } else if (TheTriple.isOSBinFormatELF()) {
     // Force the use of an ELF container.
     MAI = new X86ELFMCAsmInfo(TheTriple);
   } else if (TheTriple.isWindowsMSVCEnvironment() ||
              TheTriple.isWindowsCoreCLREnvironment()) {
     MAI = new X86MCAsmInfoMicrosoft(TheTriple);
-  } else if (TheTriple.isOSCygMing() ||
+  } else if (TheTriple.isOSMidiCygMing() ||
              TheTriple.isWindowsItaniumEnvironment()) {
     MAI = new X86MCAsmInfoGNUCOFF(TheTriple);
   } else {
     // The default is ELF.
     MAI = new X86ELFMCAsmInfo(TheTriple);
   }
 
   // Initialize initial frame state.
   // Calculate amount of bytes used for return address storing
   int stackGrowth = is64Bit ? -8 : -4;

lib/Target/X86/X86CallingConv.td

def CC_X86_32_ThisCall_Win : CallingConv<[
 
   // Pass sret arguments indirectly through stack.
   CCIfSRet<CCAssignToStack<4, 4>>,
 
   CCDelegateTo<CC_X86_32_ThisCall_Common>
 ]>;
 
 def CC_X86_32_ThisCall : CallingConv<[
-  CCIfSubtarget<"isTargetCygMing()", CCDelegateTo<CC_X86_32_ThisCall_Mingw>>,
+  CCIfSubtarget<"isTargetMidiCygMing()", CCDelegateTo<CC_X86_32_ThisCall_Mingw>>,
   CCDelegateTo<CC_X86_32_ThisCall_Win>
 ]>;
 
 def CC_X86_32_FastCC : CallingConv<[
   // Handles byval parameters.  Note that we can't rely on the delegation
   // to CC_X86_32_Common for this because that happens after code that
   // puts arguments in registers.
   CCIfByVal<CCPassByVal<4, 4>>,

lib/Target/X86/X86FrameLowering.cpp

void X86FrameLowering::emitStackProbeCall(MachineFunction &MF,
   unsigned CallOp;
   if (Is64Bit)
     CallOp = IsLargeCodeModel ? X86::CALL64r : X86::CALL64pcrel32;
   else
     CallOp = X86::CALLpcrel32;
 
   const char *Symbol;
   if (Is64Bit) {
-    if (STI.isTargetCygMing()) {
+    if (STI.isTargetMidiCygMing()) {
       Symbol = "___chkstk_ms";
     } else {
       Symbol = "__chkstk";
     }
-  } else if (STI.isTargetCygMing())
+  } else if (STI.isTargetMidiCygMing())
     Symbol = "_alloca";
   else
     Symbol = "_chkstk";
 
   MachineInstrBuilder CI;
   MachineBasicBlock::iterator ExpansionMBBI = std::prev(MBBI);
 
   // All current stack probes take AX and SP as input, clobber flags, and

lib/Target/X86/X86ISelDAGToDAG.cpp

for (SelectionDAG::allnodes_iterator I = CurDAG->allnodes_begin(),
     ++I;
     CurDAG->DeleteNode(N);
   }
 }
 
 
 /// Emit any code that needs to be executed only in the main function.
 void X86DAGToDAGISel::emitSpecialCodeForMain() {
-  if (Subtarget->isTargetCygMing()) {
+  if (Subtarget->isTargetMidiCygMing()) {
     TargetLowering::ArgListTy Args;
     auto &DL = CurDAG->getDataLayout();
 
     TargetLowering::CallLoweringInfo CLI(*CurDAG);
     CLI.setChain(CurDAG->getRoot())
         .setCallee(CallingConv::C, Type::getVoidTy(*CurDAG->getContext()),
                    CurDAG->getExternalSymbol("__main", TLI->getPointerTy(DL)),
                    std::move(Args));

lib/Target/X86/X86ISelLowering.cpp

X86TargetLowering::X86TargetLowering(const X86TargetMachine &TM,
   }
 
   if (Subtarget.hasCmpxchg16b()) {
     setOperationAction(ISD::ATOMIC_CMP_SWAP_WITH_SUCCESS, MVT::i128, Custom);
   }
 
   // FIXME - use subtarget debug flags
   if (!Subtarget.isTargetDarwin() && !Subtarget.isTargetELF() &&
-      !Subtarget.isTargetCygMing() && !Subtarget.isTargetWin64() &&
+      !Subtarget.isTargetMidiCygMing() && !Subtarget.isTargetWin64() &&
       TM.Options.ExceptionModel != ExceptionHandling::SjLj) {
     setOperationAction(ISD::EH_LABEL, MVT::Other, Expand);
   }
 
   setOperationAction(ISD::FRAME_TO_ARGS_OFFSET, MVT::i32, Custom);
   setOperationAction(ISD::FRAME_TO_ARGS_OFFSET, MVT::i64, Custom);
 
   setOperationAction(ISD::INIT_TRAMPOLINE, MVT::Other, Custom);
SDValue X86TargetLowering::LowerFormalArguments(
     const SmallVectorImpl<ISD::InputArg> &Ins, const SDLoc &dl,
     SelectionDAG &DAG, SmallVectorImpl<SDValue> &InVals) const {
   MachineFunction &MF = DAG.getMachineFunction();
   X86MachineFunctionInfo *FuncInfo = MF.getInfo<X86MachineFunctionInfo>();
   const TargetFrameLowering &TFI = *Subtarget.getFrameLowering();
 
   const Function *Fn = MF.getFunction();
   if (Fn->hasExternalLinkage() &&
-      Subtarget.isTargetCygMing() &&
+      Subtarget.isTargetMidiCygMing() &&
       Fn->getName() == "main")
     FuncInfo->setForceFramePointer(true);
 
   MachineFrameInfo &MFI = MF.getFrameInfo();
   bool Is64Bit = Subtarget.is64Bit();
   bool IsWin64 = Subtarget.isCallingConvWin64(CallConv);
 
   assert(

lib/Target/X86/X86Subtarget.h

public:
   bool isTargetWindowsGNU() const {
     return TargetTriple.isWindowsGNUEnvironment();
   }
 
   bool isTargetWindowsItanium() const {
     return TargetTriple.isWindowsItaniumEnvironment();
   }
 
-  bool isTargetCygMing() const { return TargetTriple.isOSCygMing(); }
+  bool isTargetMidiCygMing() const { return TargetTriple.isOSMidiCygMing(); }
 
   bool isOSWindows() const { return TargetTriple.isOSWindows(); }
 
   bool isTargetWin64() const {
     return In64BitMode && TargetTriple.isOSWindows();
   }
 
   bool isTargetWin32() const {
-    return !In64BitMode && (isTargetCygMing() || isTargetKnownWindowsMSVC());
+    return !In64BitMode && (isTargetMidiCygMing() || isTargetKnownWindowsMSVC());
   }
 
   bool isPICStyleGOT() const { return PICStyle == PICStyles::GOT; }
   bool isPICStyleRIPRel() const { return PICStyle == PICStyles::RIPRel; }
 
   bool isPICStyleStubPIC() const {
     return PICStyle == PICStyles::StubPIC;
   }

tools/lli/lli.cpp

for (unsigned i = 0, e = ExtraArchives.size(); i != e; ++i) {
 
     object::OwningBinary<object::Archive> OB(std::move(Ar), std::move(ArBuf));
 
     EE->addArchive(std::move(OB));
   }
 
   // If the target is Cygwin/MingW and we are generating remote code, we
   // need an extra module to help out with linking.
-  if (RemoteMCJIT && Triple(Mod->getTargetTriple()).isOSCygMing()) {
+  if (RemoteMCJIT && Triple(Mod->getTargetTriple()).isOSMidiCygMing()) {
     addCygMingExtraModule(*EE, Context, Mod->getTargetTriple());
   }
 
   // The following functions have no effect if their respective profiling
   // support wasn't enabled in the build configuration.
   EE->RegisterJITEventListener(
                 JITEventListener::createOProfileJITEventListener());
   EE->RegisterJITEventListener(

tools/llvm-config/llvm-config.cpp

#endif
   /// in the first place. This can't be done at configure/build time.
 
   StringRef SharedExt, SharedVersionedExt, SharedDir, SharedPrefix, StaticExt,
       StaticPrefix, StaticDir = "lib", DirSep = "/";
   const Triple HostTriple(Triple::normalize(LLVM_HOST_TRIPLE));
   if (HostTriple.isOSWindows()) {
     SharedExt = "dll";
     SharedVersionedExt = LLVM_DYLIB_VERSION ".dll";
-    if (HostTriple.isOSCygMing()) {
+    if (HostTriple.isOSMidiCygMing()) {
       StaticExt = "a";
       StaticPrefix = "lib";
     } else {
       StaticExt = "lib";
       DirSep = "\\";
       std::replace(ActiveObjRoot.begin(), ActiveObjRoot.end(), '/', '\\');
       std::replace(ActivePrefix.begin(), ActivePrefix.end(), '/', '\\');
       std::replace(ActiveBinDir.begin(), ActiveBinDir.end(), '/', '\\');