Do not use posix_fallocate because it's slow.

[ruiu]

Summary

posix_fallocate is too slow if your filesystem does not support the
fallocate system call.

That's still harmless if you are creating relatively small files,
or the overhead of creating files takes only a small part of an
entire process, but for lld, the issue is pretty noticeable. lld
can now link an 1.7 GiB executable in about 7 seconds on my machine,
and posix_fallocate takes 1 second. Spending a second on every linker
invocation just to prepare for "disk full" errors doesn't make much
sense.

[ruiu]

• Use fallocate(2) if available.

[ruiu]

Thank you for reviewing. But I think my test environment was not set up correctly. While it is an ext4, fallocate(2) returned an error. After mkfs'ing the partition, fallocate(2) started working, and the original code worked as fast as with this patch. So it seems there's no point to submit this patch. I'll withdraw it.

llvm/cmake/config-ix.cmake

 check_symbol_exists(getpagesize unistd.h HAVE_GETPAGESIZE)
 check_symbol_exists(sysconf unistd.h HAVE_SYSCONF)
 check_symbol_exists(getrusage sys/resource.h HAVE_GETRUSAGE)
 check_symbol_exists(setrlimit sys/resource.h HAVE_SETRLIMIT)
 check_symbol_exists(isatty unistd.h HAVE_ISATTY)
 check_symbol_exists(futimens sys/stat.h HAVE_FUTIMENS)
 check_symbol_exists(futimes sys/time.h HAVE_FUTIMES)
 check_symbol_exists(posix_fallocate fcntl.h HAVE_POSIX_FALLOCATE)
+
+set(CMAKE_REQUIRED_DEFINITIONS "-D_GNU_SOURCE")
+check_symbol_exists(fallocate fcntl.h HAVE_FALLOCATE)
+set(CMAKE_REQUIRED_DEFINITIONS "")
+
 # AddressSanitizer conflicts with lib/Support/Unix/Signals.inc
 # Avoid sigaltstack on Apple platforms, where backtrace() cannot handle it
 # (rdar://7089625) and _Unwind_Backtrace is unusable because it cannot unwind
 # past the signal handler after an assertion failure (rdar://29866587).
 if( HAVE_SIGNAL_H AND NOT LLVM_USE_SANITIZER MATCHES ".*Address.*" AND NOT APPLE )
   check_symbol_exists(sigaltstack signal.h HAVE_SIGALTSTACK)
 endif()
 if( HAVE_SYS_UIO_H )

llvm/include/llvm/Config/config.h.cmake

 #cmakedefine HAVE_DLOPEN ${HAVE_DLOPEN}
 
 /* Define if dladdr() is available on this platform. */
 #cmakedefine HAVE_DLADDR ${HAVE_DLADDR}
 
 /* Define to 1 if you have the <errno.h> header file. */
 #cmakedefine HAVE_ERRNO_H ${HAVE_ERRNO_H}
 
+/* Define to 1 if you have the `fallocate' function. */
+#cmakedefine HAVE_FALLOCATE ${HAVE_FALLOCATE}
+
 /* Define to 1 if you have the <fcntl.h> header file. */
 #cmakedefine HAVE_FCNTL_H ${HAVE_FCNTL_H}
 
 /* Define to 1 if you have the <fenv.h> header file. */
 #cmakedefine HAVE_FENV_H ${HAVE_FENV_H}
 
 /* Define if libffi is available on this platform. */
 #cmakedefine HAVE_FFI_CALL ${HAVE_FFI_CALL}

llvm/lib/Support/Unix/Path.inc

std::error_code rename(const Twine &from, const Twine &to) {
 
   if (::rename(f.begin(), t.begin()) == -1)
     return std::error_code(errno, std::generic_category());
 
   return std::error_code();
 }
 
 std::error_code resize_file(int FD, uint64_t Size) {
-#if defined(HAVE_POSIX_FALLOCATE)
-  // If we have posix_fallocate use it. Unlike ftruncate it always allocates
-  // space, so we get an error if the disk is full.
-  if (int Err = ::posix_fallocate(FD, 0, Size)) {
-    if (Err != EOPNOTSUPP)
-      return std::error_code(Err, std::generic_category());
-  }
+#ifdef HAVE_FALLOCATE
+  // We prefer fallocate over ftruncate because only the former system
+  // call can detect a "disk full" error. ftruncate creates a sparse
+  // file, so it succeeds even if sufficient disk space is not available.
+  //
+  // fallocate() is a Linux-only system call. POSIX defines posix_fallocate,
+  // but the function is very slow in some implementations (including glibc's)
+  // because it attempts to actually write zero bytes to each disk block.
+  // Thus, we do not want to use posix_fallocate.
+  if (fallocate(FD, 0, 0, Size) == 0)
+    return std::error_code();
+  if (errno == ENOSPC)
+    return std::error_code(errno, std::generic_category());
 #endif
-  // Use ftruncate as a fallback. It may or may not allocate space. At least on
-  // OS X with HFS+ it does.
+
   if (::ftruncate(FD, Size) == -1)
     return std::error_code(errno, std::generic_category());
-
   return std::error_code();
 }
 
 static int convertAccessMode(AccessMode Mode) {
   switch (Mode) {
   case AccessMode::Exist:
     return F_OK;
   case AccessMode::Write: