MidnightBSD support in LLVM

[laffer1]

Summary

Adds MidnightBSD operating system to LLVM.

[lebedev.ri]

Please upload patches with the full context (-U99999).
Also, i suspect the test coverage is missing.

[krytarowski]

Why to patch mips-specific code for MidnightBSD? Why to patch code for sanitizers and instrumentation in general?

[laffer1]

The mips support is because I recently brought it into MidnightBSD for a future platform.

I can reroll the patch against SVN, but I did follow the guide for git https://llvm.org/docs/GettingStarted.html#checkout

[arsenm]

Are there any actual codegen changes vs. FreeBSD, since you seem to have just added handling to everywhere FreeBSD is? if not, can you just make this an alias of freebsd in the triple parsing?

CMakeLists.txt

811

Just drop the entire endif contents?

[krytarowski]

In D51577#1221922, @arsenm wrote:

Are there any actual codegen changes vs. FreeBSD, since you seem to have just added handling to everywhere FreeBSD is? if not, can you just make this an alias of freebsd in the triple parsing?

MidnightBSD is a fork of FreeBSD rebranded as a distinct OS. I think that the correct solution is to fix MidnightBSD and let it to recognize self as (a legacy version of) FreeBSD.

[krytarowski]

Adding some more context, there are a few remixes of FreeBSD such as TruOS, GhostBSD, DesktopBSD etc... and all of them are custom reconfiguration of defaults and they keep self recognition to __FreeBSD__. MidnightBSD is similar, it's a remix of FreeBSD with GNUSTEP. For some reason the project decided to fork the FreeBSD distribution entirely, however over the years there were no[t so many] distinct features to recognize this OS as a distinct version of BSD ( https://github.com/freebsd/freebsd/blob/master/share/misc/bsd-family-tree ).

I know that this is harsh, but this is the current track of patches for MidnightBSD, that they are regularly rejected in projects. Unless the MidnightBSD community can attach a buildbot in the building farm, I recommend to reject this code and recommend to MidnightBSD to fix self-recognition... and probably rebase to recent FreeBSD to get MIPS support also in sanitizers.

[laffer1]

What are the requirements for the build farm? At most I could probably spin up an AWS instance right now.

Does every project get treated like this when they try to add support? Did you make Linus provide build hardware too?

[krytarowski]

https://llvm.org/docs/HowToAddABuilder.html

CMakeLists.txt

 # (this is a variable that CrossCompile sets on recursive invocations)
 endif()
 
-if(${CMAKE_SYSTEM_NAME} MATCHES "(FreeBSD|DragonFly)")
+if(${CMAKE_SYSTEM_NAME} MATCHES "(FreeBSD|DragonFly|MidnightBSD)")
   # On FreeBSD, /usr/local/* is not used by default. In order to build LLVM
   # with libxml2, iconv.h, etc., we must add /usr/local paths.
   include_directories(SYSTEM "/usr/local/include")
   link_directories("/usr/local/lib")
-endif(${CMAKE_SYSTEM_NAME} MATCHES "(FreeBSD|DragonFly)")
+endif(${CMAKE_SYSTEM_NAME} MATCHES "(FreeBSD|DragonFly|MidnightBSD)")
 
 if( ${CMAKE_SYSTEM_NAME} MATCHES SunOS )
    # special hack for Solaris to handle crazy system sys/regset.h

cmake/config.guess

     i*86:AROS:*:*)
   echo ${UNAME_MACHINE}-pc-aros
   exit ;;
+    *:MidnightBSD:*:*)
+        UNAME_PROCESSOR=`/usr/bin/uname -p`
+        case ${UNAME_PROCESSOR} in
+            amd64)
+                echo x86_64-unknown-mdinightbsd${UNAME_RELEASE};;
+            *)
+                echo ${UNAME_PROCESSOR}-unknown-midnightbsd${UNAME_RELEASE};;
+        esac
+        exit ;;
 esac
 
 #echo '(No uname command or uname output not recognized.)' 1>&2

cmake/modules/AddLLVM.cmake

     set(_install_rpath "@loader_path/../lib" ${extra_libdir})
   elseif(UNIX)
     set(_install_rpath "\$ORIGIN/../lib${LLVM_LIBDIR_SUFFIX}" ${extra_libdir})
-    if(${CMAKE_SYSTEM_NAME} MATCHES "(FreeBSD|DragonFly)")
+    if(${CMAKE_SYSTEM_NAME} MATCHES "(FreeBSD|DragonFly|MidnightBSD)")
       set_property(TARGET ${name} APPEND_STRING PROPERTY
                    LINK_FLAGS " -Wl,-z,origin ")
     endif()

cmake/modules/HandleLLVMOptions.cmake

 # build might work on ELF but fail on MachO/COFF.
 if(NOT (${CMAKE_SYSTEM_NAME} MATCHES "Darwin" OR WIN32 OR CYGWIN OR
         ${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD" OR
+        ${CMAKE_SYSTEM_NAME} MATCHES "MidnightBSD" OR
         ${CMAKE_SYSTEM_NAME} MATCHES "OpenBSD") AND
    NOT LLVM_USE_SANITIZER)
   set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,-z,defs")

include/llvm/ADT/Triple.h

     Contiki,
     AMDPAL,     // AMD PAL Runtime
     HermitCore, // HermitCore Unikernel/Multikernel
-    LastOSType = HermitCore
+    MidnightBSD,
+    LastOSType = MidnightBSD
   };
   enum EnvironmentType {
     UnknownEnvironment,

     return getOS() == Triple::KFreeBSD;
   }
 
+  bool isOSMidnightBSD() const {
+    return getOS() == Triple::MidnightBSD;
+  }
+
   /// Tests whether the OS uses glibc.
   bool isOSGlibc() const {
     return (getOS() == Triple::Linux || getOS() == Triple::KFreeBSD) &&

include/llvm/MC/MCELFObjectWriter.h

       case Triple::HermitCore:
         return ELF::ELFOSABI_STANDALONE;
       case Triple::PS4:
+      case Triple::MidnightBSD:
       case Triple::FreeBSD:
         return ELF::ELFOSABI_FREEBSD;
       default:

lib/Analysis/TargetLibraryInfo.cpp

   case Triple::WatchOS:
   case Triple::FreeBSD:
   case Triple::Linux:
+  case Triple::MidnightBSD:
     break;
   default:
     TLI.setUnavailable(LibFunc_ffsl);

   case Triple::WatchOS:
   case Triple::FreeBSD:
   case Triple::Linux:
+  case Triple::MidnightBSD:
     break;
   default:
     TLI.setUnavailable(LibFunc_ffsll);

   // http://svn.freebsd.org/base/head/lib/libc/string/fls.c
   // http://svn.freebsd.org/base/head/lib/libc/string/flsl.c
   // http://svn.freebsd.org/base/head/lib/libc/string/flsll.c
-  if (!T.isOSFreeBSD()) {
+  if (!T.isOSFreeBSD() && !T.isOSMidnightBSD()) {
     TLI.setUnavailable(LibFunc_fls);
     TLI.setUnavailable(LibFunc_flsl);
     TLI.setUnavailable(LibFunc_flsll);

lib/CodeGen/TargetLoweringObjectFileImpl.cpp

     // FreeBSD must be explicit about the data size and using pcrel since it's
     // assembler/linker won't do the automatic conversion that the Linux tools
     // do.
-    if (TgtM.getTargetTriple().isOSFreeBSD()) {
+    if (TgtM.getTargetTriple().isOSFreeBSD() || TgtM.getTargetTriple().isOSMidnightBSD()) {
       PersonalityEncoding |= dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
       LSDAEncoding = dwarf::DW_EH_PE_pcrel | dwarf::DW_EH_PE_sdata4;
     }

lib/Support/Triple.cpp

   case Contiki: return "contiki";
   case AMDPAL: return "amdpal";
   case HermitCore: return "hermit";
+  case MidnightBSD: return "midnightbsd";
   }
 
   llvm_unreachable("Invalid OSType");

     .StartsWith("contiki", Triple::Contiki)
     .StartsWith("amdpal", Triple::AMDPAL)
     .StartsWith("hermit", Triple::HermitCore)
+    .StartsWith("midnightbsd", Triple::MidnightBSD)
     .Default(Triple::UnknownOS);
 }
 

   // Some defaults are forced.
   switch (getOS()) {
   case llvm::Triple::FreeBSD:
+  case llvm::Triple::MidnightBSD:
   case llvm::Triple::NetBSD:
     if (!MArch.empty() && MArch == "v6")
       return "arm1176jzf-s";

lib/Support/Unix/Memory.inc

 #if defined(__mips__)
 #  if defined(__OpenBSD__)
 #    include <mips64/sysarch.h>
-#  elif !defined(__FreeBSD__)
+#  elif !defined(__FreeBSD__) && !defined(__MidnightBSD__)
 #    include <sys/cachectl.h>
 #  endif
 #endif

       llvm::sys::Memory::MF_EXEC:
     return PROT_READ | PROT_WRITE | PROT_EXEC;
   case llvm::sys::Memory::MF_EXEC:
-#if defined(__FreeBSD__)
+#if defined(__FreeBSD__) || defined(__MidnightBSD__)
     // On PowerPC, having an executable page that has no read permission
     // can have unintended consequences.  The function InvalidateInstruction-
     // Cache uses instructions dcbf and icbi, both of which are treated by

lib/Support/Unix/Path.inc

 
 #include <sys/types.h>
 #if !defined(__APPLE__) && !defined(__OpenBSD__) && !defined(__FreeBSD__) &&   \
-    !defined(__linux__)
+    !defined(__linux__) && !defined(__MidnightBSD__)
 #include <sys/statvfs.h>
 #define STATVFS statvfs
 #define FSTATVFS fstatvfs
 #define STATVFS_F_FRSIZE(vfs) vfs.f_frsize
 #else
-#if defined(__OpenBSD__) || defined(__FreeBSD__)
+#if defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__MidnightBSD__)
 #include <sys/mount.h>
 #include <sys/param.h>
 #elif defined(__linux__)

 
 #if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) ||     \
     defined(__minix) || defined(__FreeBSD_kernel__) || defined(__linux__) ||   \
-    defined(__CYGWIN__) || defined(__DragonFly__) || defined(_AIX)
+    defined(__CYGWIN__) || defined(__DragonFly__) || defined(_AIX) ||          \
+    defined(__MidnightBSD__)
 static int
 test_dir(char ret[PATH_MAX], const char *dir, const char *bin)
 {

   }
 #elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) ||   \
     defined(__minix) || defined(__DragonFly__) ||                              \
-    defined(__FreeBSD_kernel__) || defined(_AIX)
+    defined(__FreeBSD_kernel__) || defined(_AIX) ||                            \
+    defined(__MidnightBSD__)
   char exe_path[PATH_MAX];
 
   if (getprogpath(exe_path, argv0) != NULL)

lib/Support/Unix/Signals.inc

 
 #if defined(HAVE_BACKTRACE) && ENABLE_BACKTRACES && HAVE_LINK_H &&    \
     (defined(__linux__) || defined(__FreeBSD__) ||                             \
-     defined(__FreeBSD_kernel__) || defined(__NetBSD__))
+     defined(__FreeBSD_kernel__) || defined(__NetBSD__) ||            \
+     defined(__MidnightBSD__))
 struct DlIteratePhdrData {
   void **StackTrace;
   int depth;

lib/Target/Mips/MCTargetDesc/MipsMCAsmInfo.cpp

 
   // Enable IAS by default for FreeBSD / OpenBSD mips64/mips64el.
   if (TheTriple.isOSFreeBSD() ||
-      TheTriple.isOSOpenBSD())
+      TheTriple.isOSOpenBSD() ||
+      TheTriple.isOSMidnightBSD())
     UseIntegratedAssembler = true;
 }

lib/Target/X86/X86FrameLowering.cpp

     report_fatal_error("Segmented stacks do not support vararg functions.");
   if (!STI.isTargetLinux() && !STI.isTargetDarwin() && !STI.isTargetWin32() &&
       !STI.isTargetWin64() && !STI.isTargetFreeBSD() &&
-      !STI.isTargetDragonFly())
+      !STI.isTargetDragonFly() && !STI.isTargetMidnightBSD())
     report_fatal_error("Segmented stacks not supported on this platform.");
 
   // Eventually StackSize will be calculated by a link-time pass; which will

     } else if (STI.isTargetWin64()) {
       TlsReg = X86::GS;
       TlsOffset = 0x28; // pvArbitrary, reserved for application use
-    } else if (STI.isTargetFreeBSD()) {
+    } else if (STI.isTargetFreeBSD() || STI.isTargetMidnightBSD()) {
       TlsReg = X86::FS;
       TlsOffset = 0x18;
     } else if (STI.isTargetDragonFly()) {

       TlsOffset = 0x10; // use tls_tcb.tcb_segstack
     } else if (STI.isTargetFreeBSD()) {
       report_fatal_error("Segmented stacks not supported on FreeBSD i386.");
+    } else if (STI.isTargetMidnightBSD()) {
+      report_fatal_error("Segmented stacks not supported on MidnightBSD i386.");
     } else {
       report_fatal_error("Segmented stacks not supported on this platform.");
     }

lib/Target/X86/X86TargetMachine.cpp

     return llvm::make_unique<TargetLoweringObjectFileMachO>();
   }
 
-  if (TT.isOSFreeBSD())
+  if (TT.isOSFreeBSD() || TT.isOSMidnightBSD())
     return llvm::make_unique<X86FreeBSDTargetObjectFile>();
   if (TT.isOSLinux() || TT.isOSNaCl() || TT.isOSIAMCU())
     return llvm::make_unique<X86LinuxNaClTargetObjectFile>();

lib/Transforms/Instrumentation/AddressSanitizer.cpp

   bool IsWindows = TargetTriple.isOSWindows();
   bool IsFuchsia = TargetTriple.isOSFuchsia();
   bool IsMyriad = TargetTriple.getVendor() == llvm::Triple::Myriad;
+  bool IsMidnightBSD = TargetTriple.isOSMidnightBSD();
 
   ShadowMapping Mapping;
 

       Mapping.Offset = kDynamicShadowSentinel;
     else if (IsMIPS32)
       Mapping.Offset = kMIPS32_ShadowOffset32;
-    else if (IsFreeBSD)
+    else if (IsFreeBSD || isMidnightBSD)
       Mapping.Offset = kFreeBSD_ShadowOffset32;
     else if (IsNetBSD)
       Mapping.Offset = kNetBSD_ShadowOffset32;

lib/Transforms/Instrumentation/InstrProfiling.cpp

   if (Triple(M.getTargetTriple()).isOSLinux() ||
       Triple(M.getTargetTriple()).isOSFreeBSD() ||
       Triple(M.getTargetTriple()).isOSFuchsia() ||
-      Triple(M.getTargetTriple()).isPS4CPU())
+      Triple(M.getTargetTriple()).isPS4CPU() ||
+      Triple(M.getTargetTriple()).isOSMidnightBSD())
     return false;
 
   return true;

tools/llvm-shlib/CMakeLists.txt

      OR ("${CMAKE_SYSTEM_NAME}" STREQUAL "OpenBSD")
      OR ("${CMAKE_SYSTEM_NAME}" STREQUAL "Fuchsia")
      OR ("${CMAKE_SYSTEM_NAME}" STREQUAL "DragonFly")
+     OR ("${CMAKE_SYSTEM_NAME}" STREQUAL "MidnightBSD")
      OR ("${CMAKE_SYSTEM_NAME}" STREQUAL "SunOS")) # FIXME: It should be "GNU ld for elf"
     configure_file(
     ${CMAKE_CURRENT_SOURCE_DIR}/simple_version_script.map.in