Merge "Fix the stdio fwrite benchmark."
diff --git a/libc/Android.bp b/libc/Android.bp
index b0e0d8c..be45f40 100644
--- a/libc/Android.bp
+++ b/libc/Android.bp
@@ -1385,6 +1385,7 @@
     defaults: ["libc_defaults"],
     srcs: [
         "bionic/NetdClientDispatch.cpp",
+        "bionic/__bionic_get_shell_path.cpp",
         "bionic/__cmsg_nxthdr.cpp",
         "bionic/__errno.cpp",
         "bionic/__gnu_basename.cpp",
@@ -1399,6 +1400,7 @@
         "bionic/assert.cpp",
         "bionic/atof.cpp",
         "bionic/bionic_arc4random.cpp",
+        "bionic/bionic_futex.cpp",
         "bionic/bionic_netlink.cpp",
         "bionic/bionic_systrace.cpp",
         "bionic/bionic_time_conversions.cpp",
diff --git a/libc/async_safe/async_safe_log.cpp b/libc/async_safe/async_safe_log.cpp
index 99ff0c7..d81ef34 100644
--- a/libc/async_safe/async_safe_log.cpp
+++ b/libc/async_safe/async_safe_log.cpp
@@ -60,43 +60,36 @@
 
 struct BufferOutputStream {
  public:
-  BufferOutputStream(char* buffer, size_t size) : total(0) {
-    buffer_ = buffer;
-    end_ = buffer + size - 1;
-    pos_ = buffer_;
-    pos_[0] = '\0';
+  BufferOutputStream(char* buffer, size_t size) : total(0), pos_(buffer), avail_(size) {
+    if (avail_ > 0) pos_[0] = '\0';
   }
-
-  ~BufferOutputStream() {}
+  ~BufferOutputStream() = default;
 
   void Send(const char* data, int len) {
     if (len < 0) {
       len = strlen(data);
     }
-
     total += len;
 
-    while (len > 0) {
-      int avail = end_ - pos_;
-      if (avail == 0) {
-        return;
-      }
-      if (avail > len) {
-        avail = len;
-      }
-      memcpy(pos_, data, avail);
-      pos_ += avail;
-      pos_[0] = '\0';
-      len -= avail;
+    if (avail_ <= 1) {
+      // No space to put anything else.
+      return;
     }
+
+    if (static_cast<size_t>(len) >= avail_) {
+      len = avail_ - 1;
+    }
+    memcpy(pos_, data, len);
+    pos_ += len;
+    pos_[0] = '\0';
+    avail_ -= len;
   }
 
   size_t total;
 
  private:
-  char* buffer_;
   char* pos_;
-  char* end_;
+  size_t avail_;
 };
 
 struct FdOutputStream {
@@ -107,16 +100,15 @@
     if (len < 0) {
       len = strlen(data);
     }
-
     total += len;
 
     while (len > 0) {
-      int rc = TEMP_FAILURE_RETRY(write(fd_, data, len));
-      if (rc == -1) {
+      ssize_t bytes = TEMP_FAILURE_RETRY(write(fd_, data, len));
+      if (bytes == -1) {
         return;
       }
-      data += rc;
-      len -= rc;
+      data += bytes;
+      len -= bytes;
     }
   }
 
@@ -409,15 +401,6 @@
   }
 }
 
-int async_safe_format_buffer(char* buffer, size_t buffer_size, const char* format, ...) {
-  BufferOutputStream os(buffer, buffer_size);
-  va_list args;
-  va_start(args, format);
-  out_vformat(os, format, args);
-  va_end(args);
-  return os.total;
-}
-
 int async_safe_format_buffer_va_list(char* buffer, size_t buffer_size, const char* format,
                                      va_list args) {
   BufferOutputStream os(buffer, buffer_size);
@@ -425,6 +408,14 @@
   return os.total;
 }
 
+int async_safe_format_buffer(char* buffer, size_t buffer_size, const char* format, ...) {
+  va_list args;
+  va_start(args, format);
+  int buffer_len = async_safe_format_buffer_va_list(buffer, buffer_size, format, args);
+  va_end(args);
+  return buffer_len;
+}
+
 int async_safe_format_fd(int fd, const char* format, ...) {
   FdOutputStream os(fd);
   va_list args;
diff --git a/libc/bionic/__bionic_get_shell_path.cpp b/libc/bionic/__bionic_get_shell_path.cpp
new file mode 100644
index 0000000..477fa4a
--- /dev/null
+++ b/libc/bionic/__bionic_get_shell_path.cpp
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <errno.h>
+#include <string.h>
+#include <sys/cdefs.h>
+#include <unistd.h>
+
+__LIBC_HIDDEN__ static const char* __libc_system_sh = "/system/bin/sh";
+__LIBC_HIDDEN__ static const char* __libc_vendor_sh = "/vendor/bin/sh";
+
+static const char* init_sh_path() {
+  /* look for /system or /vendor prefix */
+  char exe_path[7];
+  ssize_t len = readlink("/proc/self/exe", exe_path, sizeof(exe_path));
+  if (len != -1 && !strncmp(exe_path, __libc_vendor_sh, sizeof(exe_path))) {
+    return __libc_vendor_sh;
+  }
+
+  return __libc_system_sh;
+}
+
+__LIBC_HIDDEN__ extern "C" const char* __bionic_get_shell_path() {
+  static const char* sh_path = init_sh_path();
+  return sh_path;
+}
diff --git a/libc/bionic/__cxa_guard.cpp b/libc/bionic/__cxa_guard.cpp
index 06926df..30b5f41 100644
--- a/libc/bionic/__cxa_guard.cpp
+++ b/libc/bionic/__cxa_guard.cpp
@@ -104,7 +104,7 @@
       }
     }
 
-    __futex_wait_ex(&gv->state, false, CONSTRUCTION_UNDERWAY_WITH_WAITER, false, nullptr);
+    __futex_wait_ex(&gv->state, false, CONSTRUCTION_UNDERWAY_WITH_WAITER);
     old_value = atomic_load_explicit(&gv->state, memory_order_acquire);
   }
 }
diff --git a/libc/bionic/bionic_futex.cpp b/libc/bionic/bionic_futex.cpp
new file mode 100644
index 0000000..dd66e40
--- /dev/null
+++ b/libc/bionic/bionic_futex.cpp
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2017 The Android Open Source Project
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *  * Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in
+ *    the documentation and/or other materials provided with the
+ *    distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include "private/bionic_futex.h"
+
+#include <time.h>
+
+#include "private/bionic_time_conversions.h"
+
+int __futex_wait_ex(volatile void* ftx, bool shared, int value, bool use_realtime_clock,
+                    const timespec* abs_timeout) {
+  const timespec* futex_abs_timeout = abs_timeout;
+  // pthread's and semaphore's default behavior is to use CLOCK_REALTIME, however this behavior is
+  // essentially never intended, as that clock is prone to change discontinuously.
+  //
+  // What users really intend is to use CLOCK_MONOTONIC, however only pthread_cond_timedwait()
+  // provides this as an option and even there, a large amount of existing code does not opt into
+  // CLOCK_MONOTONIC.
+  //
+  // We have seen numerous bugs directly attributable to this difference.  Therefore, we provide
+  // this general workaround to always use CLOCK_MONOTONIC for waiting, regardless of what the input
+  // timespec is.
+  timespec converted_monotonic_abs_timeout;
+  if (abs_timeout && use_realtime_clock) {
+    monotonic_time_from_realtime_time(converted_monotonic_abs_timeout, *abs_timeout);
+    if (converted_monotonic_abs_timeout.tv_sec < 0) {
+      return -ETIMEDOUT;
+    }
+    futex_abs_timeout = &converted_monotonic_abs_timeout;
+  }
+
+  return __futex(ftx, (shared ? FUTEX_WAIT_BITSET : FUTEX_WAIT_BITSET_PRIVATE), value,
+                 futex_abs_timeout, FUTEX_BITSET_MATCH_ANY);
+}
diff --git a/libc/bionic/bionic_time_conversions.cpp b/libc/bionic/bionic_time_conversions.cpp
index ade3a55..d21e12e 100644
--- a/libc/bionic/bionic_time_conversions.cpp
+++ b/libc/bionic/bionic_time_conversions.cpp
@@ -51,3 +51,24 @@
   tv.tv_sec = ts.tv_sec;
   tv.tv_usec = ts.tv_nsec / 1000;
 }
+
+void monotonic_time_from_realtime_time(timespec& monotonic_time, const timespec& realtime_time) {
+  monotonic_time = realtime_time;
+
+  timespec cur_monotonic_time;
+  clock_gettime(CLOCK_MONOTONIC, &cur_monotonic_time);
+  timespec cur_realtime_time;
+  clock_gettime(CLOCK_REALTIME, &cur_realtime_time);
+
+  monotonic_time.tv_nsec -= cur_realtime_time.tv_nsec;
+  monotonic_time.tv_nsec += cur_monotonic_time.tv_nsec;
+  if (monotonic_time.tv_nsec >= NS_PER_S) {
+    monotonic_time.tv_nsec -= NS_PER_S;
+    monotonic_time.tv_sec += 1;
+  } else if (monotonic_time.tv_nsec < 0) {
+    monotonic_time.tv_nsec += NS_PER_S;
+    monotonic_time.tv_sec -= 1;
+  }
+  monotonic_time.tv_sec -= cur_realtime_time.tv_sec;
+  monotonic_time.tv_sec += cur_monotonic_time.tv_sec;
+}
diff --git a/libc/bionic/system_properties.cpp b/libc/bionic/system_properties.cpp
index a958699..6906ecd 100644
--- a/libc/bionic/system_properties.cpp
+++ b/libc/bionic/system_properties.cpp
@@ -1051,16 +1051,15 @@
     if (!initialize_properties_from_file("/system/etc/selinux/plat_property_contexts")) {
       return false;
     }
-    if (!initialize_properties_from_file("/vendor/etc/selinux/nonplat_property_contexts")) {
-      return false;
-    }
+    // Don't check for failure here, so we always have a sane list of properties.
+    // E.g. In case of recovery, the vendor partition will not have mounted and we
+    // still need the system / platform properties to function.
+    initialize_properties_from_file("/vendor/etc/selinux/nonplat_property_contexts");
   } else {
     if (!initialize_properties_from_file("/plat_property_contexts")) {
       return false;
     }
-    if (!initialize_properties_from_file("/nonplat_property_contexts")) {
-      return false;
-    }
+    initialize_properties_from_file("/nonplat_property_contexts");
   }
 
   return true;
diff --git a/libc/include/arpa/nameser.h b/libc/include/arpa/nameser.h
index 9507f49..ffb5250 100644
--- a/libc/include/arpa/nameser.h
+++ b/libc/include/arpa/nameser.h
@@ -562,63 +562,61 @@
 #define	ns_makecanon		__ns_makecanon
 #define	ns_samename		__ns_samename
 
-int ns_msg_getflag(ns_msg, int);
-uint16_t ns_get16(const u_char*);
-uint32_t ns_get32(const u_char*);
-void ns_put16(uint16_t, u_char*);
-void ns_put32(uint32_t, u_char*);
-int ns_initparse(const u_char*, int, ns_msg*);
-int ns_skiprr(const u_char*, const u_char*, ns_sect, int);
-int ns_parserr(ns_msg*, ns_sect, int, ns_rr*);
-int ns_sprintrr(const ns_msg*, const ns_rr*, const char*, const char*, char*, size_t);
-int ns_sprintrrf(const u_char*, size_t, const char*, ns_class, ns_type, u_long, const u_char*,
-                 size_t, const char*, const char*, char*, size_t);
-int ns_format_ttl(u_long, char*, size_t);
-int ns_name_ntol(const u_char*, u_char*, size_t);
-int ns_name_ntop(const u_char*, char*, size_t);
-int ns_name_pton(const char*, u_char*, size_t);
-int ns_name_unpack(const u_char*, const u_char*, const u_char*, u_char*, size_t);
-int ns_name_pack(const u_char*, u_char*, int, const u_char**, const u_char**);
-int ns_name_uncompress(const u_char*, const u_char*, const u_char*, char*, size_t);
-int ns_name_compress(const char*, u_char*, size_t, const u_char**, const u_char**);
-int ns_name_skip(const u_char**, const u_char*);
-void ns_name_rollback(const u_char*, const u_char**, const u_char**);
+int ns_msg_getflag(ns_msg __handle, int __flag);
+uint16_t ns_get16(const u_char* __src);
+uint32_t ns_get32(const u_char* __src);
+void ns_put16(uint16_t __src, u_char* __dst);
+void ns_put32(uint32_t __src, u_char* __dst);
+int ns_initparse(const u_char* __msg, int __msg_size, ns_msg* __handle);
+int ns_skiprr(const u_char* __ptr, const u_char* __eom, ns_sect __section, int __count);
+int ns_parserr(ns_msg* __handle, ns_sect __section, int __rr_number, ns_rr* __rr);
+int ns_sprintrr(const ns_msg* __handle, const ns_rr* __rr, const char* __name_ctx, const char* __origin, char* __buf, size_t __buf_size);
+int ns_sprintrrf(const u_char* __msg, size_t __msg_size, const char* __name, ns_class __class, ns_type __type, u_long __ttl, const u_char* __rdata, size_t __rdata_size, const char* __name_ctx, const char* __origin, char* __buf, size_t __buf_size);
+int ns_format_ttl(u_long __ttl, char* __dst, size_t __dst_size);
+int ns_name_ntol(const u_char* __src, u_char* __dst, size_t __dst_size);
+int ns_name_ntop(const u_char* __src, char* __dst, size_t __dst_size);
+int ns_name_pton(const char* __src, u_char* __dst, size_t __dst_size);
+int ns_name_unpack(const u_char* __msg, const u_char* __eom, const u_char* __src, u_char* __dst, size_t __dst_size);
+int ns_name_pack(const u_char* __src, u_char* __dst, int __dst_size, const u_char** __dn_ptrs, const u_char** __last_dn_ptr);
+int ns_name_uncompress(const u_char* __msg, const u_char* __eom, const u_char* __src, char* __dst, size_t __dst_size);
+int ns_name_compress(const char* __src, u_char* __dst, size_t __dst_size, const u_char** __dn_ptrs, const u_char** __last_dn_ptr);
+int ns_name_skip(const u_char** __ptr_ptr, const u_char* __eom);
+void ns_name_rollback(const u_char* __src, const u_char** __dn_ptrs, const u_char** __last_dn_ptr);
 
-int ns_makecanon(const char*, char*, size_t);
-int ns_samename(const char*, const char*);
+int ns_makecanon(const char* __src, char* __dst, size_t __dst_size);
+int ns_samename(const char* __lhs, const char* __rhs);
 
 #else
 /* The names of these symbols were accidentally prefixed with __ in L. */
 /* The duplication here is intentional to avoid declaring different symbols with the same
  * declaration. */
-int ns_msg_getflag(ns_msg, int) __INTRODUCED_IN_64(23);
-uint16_t ns_get16(const u_char*) __INTRODUCED_IN_64(23);
-uint32_t ns_get32(const u_char*) __INTRODUCED_IN_64(23);
-void ns_put16(uint16_t, u_char*) __INTRODUCED_IN_64(23);
-void ns_put32(uint32_t, u_char*) __INTRODUCED_IN_64(23);
-int ns_initparse(const u_char*, int, ns_msg*) __INTRODUCED_IN_64(23);
-int ns_skiprr(const u_char*, const u_char*, ns_sect, int) __INTRODUCED_IN_64(23);
-int ns_parserr(ns_msg*, ns_sect, int, ns_rr*) __INTRODUCED_IN_64(23);
-int ns_sprintrr(const ns_msg*, const ns_rr*, const char*, const char*, char*, size_t)
+int ns_msg_getflag(ns_msg __handle, int __flag) __INTRODUCED_IN_64(23);
+uint16_t ns_get16(const u_char* __src) __INTRODUCED_IN_64(23);
+uint32_t ns_get32(const u_char* __src) __INTRODUCED_IN_64(23);
+void ns_put16(uint16_t __src, u_char* __dst) __INTRODUCED_IN_64(23);
+void ns_put32(uint32_t __src, u_char* __dst) __INTRODUCED_IN_64(23);
+int ns_initparse(const u_char* __msg, int __msg_size, ns_msg* __handle) __INTRODUCED_IN_64(23);
+int ns_skiprr(const u_char* __ptr, const u_char* __eom, ns_sect __section, int __count) __INTRODUCED_IN_64(23);
+int ns_parserr(ns_msg* __handle, ns_sect __section, int __rr_number, ns_rr* __rr) __INTRODUCED_IN_64(23);
+int ns_sprintrr(const ns_msg* __handle, const ns_rr* __rr, const char* __name_ctx, const char* __origin, char* __buf, size_t __buf_size)
   __INTRODUCED_IN_64(23);
-int ns_sprintrrf(const u_char*, size_t, const char*, ns_class, ns_type, u_long, const u_char*,
-                 size_t, const char*, const char*, char*, size_t) __INTRODUCED_IN_64(23);
-int ns_format_ttl(u_long, char*, size_t) __INTRODUCED_IN_64(23);
-int ns_name_ntol(const u_char*, u_char*, size_t) __INTRODUCED_IN_64(23);
-int ns_name_ntop(const u_char*, char*, size_t) __INTRODUCED_IN_64(23);
-int ns_name_pton(const char*, u_char*, size_t) __INTRODUCED_IN_64(23);
-int ns_name_unpack(const u_char*, const u_char*, const u_char*, u_char*, size_t)
+int ns_sprintrrf(const u_char* __msg, size_t __msg_size, const char* __name, ns_class __class, ns_type __type, u_long __ttl, const u_char* __rdata, size_t __rdata_size, const char* __name_ctx, const char* __origin, char* __buf, size_t __buf_size) __INTRODUCED_IN_64(23);
+int ns_format_ttl(u_long __ttl, char* __dst, size_t __dst_size) __INTRODUCED_IN_64(23);
+int ns_name_ntol(const u_char* __src, u_char* __dst, size_t __dst_size) __INTRODUCED_IN_64(23);
+int ns_name_ntop(const u_char* __src, char* __dst, size_t __dst_size) __INTRODUCED_IN_64(23);
+int ns_name_pton(const char* __src, u_char* __dst, size_t __dst_size) __INTRODUCED_IN_64(23);
+int ns_name_unpack(const u_char* __msg, const u_char* __eom, const u_char* __src, u_char* __dst, size_t __dst_size)
   __INTRODUCED_IN_64(23);
-int ns_name_pack(const u_char*, u_char*, int, const u_char**, const u_char**) __INTRODUCED_IN_64(23);
-int ns_name_uncompress(const u_char*, const u_char*, const u_char*, char*, size_t)
+int ns_name_pack(const u_char* __src, u_char* __dst, int __dst_size, const u_char** __dn_ptrs, const u_char** __last_dn_ptr) __INTRODUCED_IN_64(23);
+int ns_name_uncompress(const u_char* __msg, const u_char* __eom, const u_char* __src, char* __dst, size_t __dst_size)
   __INTRODUCED_IN_64(23);
-int ns_name_compress(const char*, u_char*, size_t, const u_char**, const u_char**)
+int ns_name_compress(const char* __src, u_char* __dst, size_t __dst_size, const u_char** __dn_ptrs, const u_char** __last_dn_ptr)
   __INTRODUCED_IN_64(23);
-int ns_name_skip(const u_char**, const u_char*) __INTRODUCED_IN_64(23);
-void ns_name_rollback(const u_char*, const u_char**, const u_char**) __INTRODUCED_IN_64(23);
+int ns_name_skip(const u_char** __ptr_ptr, const u_char* __eom) __INTRODUCED_IN_64(23);
+void ns_name_rollback(const u_char* __src, const u_char** __dn_ptrs, const u_char** __last_dn_ptr) __INTRODUCED_IN_64(23);
 
-int ns_makecanon(const char*, char*, size_t) __INTRODUCED_IN_64(23);
-int ns_samename(const char*, const char*) __INTRODUCED_IN_64(23);
+int ns_makecanon(const char* __src, char* __dst, size_t __dst_size) __INTRODUCED_IN_64(23);
+int ns_samename(const char* __lhs, const char* __rhs) __INTRODUCED_IN_64(23);
 #endif /* !defined(__LP64__) */
 
 __END_DECLS
diff --git a/libc/include/complex.h b/libc/include/complex.h
index c020e4f..79fe07c 100644
--- a/libc/include/complex.h
+++ b/libc/include/complex.h
@@ -59,102 +59,102 @@
 
 /* 7.3.5 Trigonometric functions */
 /* 7.3.5.1 The cacos functions */
-double complex cacos(double complex) __INTRODUCED_IN(23);
-float complex cacosf(float complex) __INTRODUCED_IN(23);
-long double complex cacosl(long double complex) __INTRODUCED_IN(26);
+double complex cacos(double complex __z) __INTRODUCED_IN(23);
+float complex cacosf(float complex __z) __INTRODUCED_IN(23);
+long double complex cacosl(long double complex __z) __INTRODUCED_IN(26);
 /* 7.3.5.2 The casin functions */
-double complex casin(double complex) __INTRODUCED_IN(23);
-float complex casinf(float complex) __INTRODUCED_IN(23);
-long double complex casinl(long double complex) __INTRODUCED_IN(26);
+double complex casin(double complex __z) __INTRODUCED_IN(23);
+float complex casinf(float complex __z) __INTRODUCED_IN(23);
+long double complex casinl(long double complex __z) __INTRODUCED_IN(26);
 /* 7.3.5.1 The catan functions */
-double complex catan(double complex) __INTRODUCED_IN(23);
-float complex catanf(float complex) __INTRODUCED_IN(23);
-long double complex catanl(long double complex) __INTRODUCED_IN(26);
+double complex catan(double complex __z) __INTRODUCED_IN(23);
+float complex catanf(float complex __z) __INTRODUCED_IN(23);
+long double complex catanl(long double complex __z) __INTRODUCED_IN(26);
 /* 7.3.5.1 The ccos functions */
-double complex ccos(double complex) __INTRODUCED_IN(23);
-float complex ccosf(float complex) __INTRODUCED_IN(23);
-long double complex ccosl(long double complex) __INTRODUCED_IN(26);
+double complex ccos(double complex __z) __INTRODUCED_IN(23);
+float complex ccosf(float complex __z) __INTRODUCED_IN(23);
+long double complex ccosl(long double complex __z) __INTRODUCED_IN(26);
 /* 7.3.5.1 The csin functions */
-double complex csin(double complex) __INTRODUCED_IN(23);
-float complex csinf(float complex) __INTRODUCED_IN(23);
-long double complex csinl(long double complex) __INTRODUCED_IN(26);
+double complex csin(double complex __z) __INTRODUCED_IN(23);
+float complex csinf(float complex __z) __INTRODUCED_IN(23);
+long double complex csinl(long double complex __z) __INTRODUCED_IN(26);
 /* 7.3.5.1 The ctan functions */
-double complex ctan(double complex) __INTRODUCED_IN(23);
-float complex ctanf(float complex) __INTRODUCED_IN(23);
-long double complex ctanl(long double complex) __INTRODUCED_IN(26);
+double complex ctan(double complex __z) __INTRODUCED_IN(23);
+float complex ctanf(float complex __z) __INTRODUCED_IN(23);
+long double complex ctanl(long double complex __z) __INTRODUCED_IN(26);
 
 /* 7.3.6 Hyperbolic functions */
 /* 7.3.6.1 The cacosh functions */
-double complex cacosh(double complex) __INTRODUCED_IN(23);
-float complex cacoshf(float complex) __INTRODUCED_IN(23);
-long double complex cacoshl(long double complex) __INTRODUCED_IN(26);
+double complex cacosh(double complex __z) __INTRODUCED_IN(23);
+float complex cacoshf(float complex __z) __INTRODUCED_IN(23);
+long double complex cacoshl(long double complex __z) __INTRODUCED_IN(26);
 /* 7.3.6.2 The casinh functions */
-double complex casinh(double complex) __INTRODUCED_IN(23);
-float complex casinhf(float complex) __INTRODUCED_IN(23);
-long double complex casinhl(long double complex) __INTRODUCED_IN(26);
+double complex casinh(double complex __z) __INTRODUCED_IN(23);
+float complex casinhf(float complex __z) __INTRODUCED_IN(23);
+long double complex casinhl(long double complex __z) __INTRODUCED_IN(26);
 /* 7.3.6.3 The catanh functions */
-double complex catanh(double complex) __INTRODUCED_IN(23);
-float complex catanhf(float complex) __INTRODUCED_IN(23);
-long double complex catanhl(long double complex) __INTRODUCED_IN(26);
+double complex catanh(double complex __z) __INTRODUCED_IN(23);
+float complex catanhf(float complex __z) __INTRODUCED_IN(23);
+long double complex catanhl(long double complex __z) __INTRODUCED_IN(26);
 /* 7.3.6.4 The ccosh functions */
-double complex ccosh(double complex) __INTRODUCED_IN(23);
-float complex ccoshf(float complex) __INTRODUCED_IN(23);
-long double complex ccoshl(long double complex) __INTRODUCED_IN(26);
+double complex ccosh(double complex __z) __INTRODUCED_IN(23);
+float complex ccoshf(float complex __z) __INTRODUCED_IN(23);
+long double complex ccoshl(long double complex __z) __INTRODUCED_IN(26);
 /* 7.3.6.5 The csinh functions */
-double complex csinh(double complex) __INTRODUCED_IN(23);
-float complex csinhf(float complex) __INTRODUCED_IN(23);
-long double complex csinhl(long double complex) __INTRODUCED_IN(26);
+double complex csinh(double complex __z) __INTRODUCED_IN(23);
+float complex csinhf(float complex __z) __INTRODUCED_IN(23);
+long double complex csinhl(long double complex __z) __INTRODUCED_IN(26);
 /* 7.3.6.6 The ctanh functions */
-double complex ctanh(double complex) __INTRODUCED_IN(23);
-float complex ctanhf(float complex) __INTRODUCED_IN(23);
-long double complex ctanhl(long double complex) __INTRODUCED_IN(26);
+double complex ctanh(double complex __z) __INTRODUCED_IN(23);
+float complex ctanhf(float complex __z) __INTRODUCED_IN(23);
+long double complex ctanhl(long double complex __z) __INTRODUCED_IN(26);
 
 /* 7.3.7 Exponential and logarithmic functions */
 /* 7.3.7.1 The cexp functions */
-double complex cexp(double complex) __INTRODUCED_IN(23);
-float complex cexpf(float complex) __INTRODUCED_IN(23);
-long double complex cexpl(long double complex) __INTRODUCED_IN(26);
+double complex cexp(double complex __z) __INTRODUCED_IN(23);
+float complex cexpf(float complex __z) __INTRODUCED_IN(23);
+long double complex cexpl(long double complex __z) __INTRODUCED_IN(26);
 /* 7.3.7.2 The clog functions */
-double complex clog(double complex) __INTRODUCED_IN(26);
-float complex clogf(float complex) __INTRODUCED_IN(26);
-long double complex clogl(long double complex) __INTRODUCED_IN(26);
+double complex clog(double complex __z) __INTRODUCED_IN(26);
+float complex clogf(float complex __z) __INTRODUCED_IN(26);
+long double complex clogl(long double complex __z) __INTRODUCED_IN(26);
 
 /* 7.3.8 Power and absolute-value functions */
 /* 7.3.8.1 The cabs functions */
-double cabs(double complex) __INTRODUCED_IN(23);
-float cabsf(float complex) __INTRODUCED_IN(23);
-long double cabsl(long double complex) __INTRODUCED_IN_32(21) __INTRODUCED_IN_64(23);
+double cabs(double complex __z) __INTRODUCED_IN(23);
+float cabsf(float complex __z) __INTRODUCED_IN(23);
+long double cabsl(long double complex __z) __INTRODUCED_IN_32(21) __INTRODUCED_IN_64(23);
 /* 7.3.8.2 The cpow functions */
-double complex cpow(double complex, double complex) __INTRODUCED_IN(26);
-float complex cpowf(float complex, float complex) __INTRODUCED_IN(26);
-long double complex cpowl(long double complex, long double complex) __INTRODUCED_IN(26);
+double complex cpow(double complex __x, double complex __z) __INTRODUCED_IN(26);
+float complex cpowf(float complex __x, float complex __z) __INTRODUCED_IN(26);
+long double complex cpowl(long double complex __x, long double complex __z) __INTRODUCED_IN(26);
 /* 7.3.8.3 The csqrt functions */
-double complex csqrt(double complex) __INTRODUCED_IN(23);
-float complex csqrtf(float complex) __INTRODUCED_IN(23);
-long double complex csqrtl(long double complex) __INTRODUCED_IN_32(21) __INTRODUCED_IN_64(23);
+double complex csqrt(double complex __z) __INTRODUCED_IN(23);
+float complex csqrtf(float complex __z) __INTRODUCED_IN(23);
+long double complex csqrtl(long double complex __z) __INTRODUCED_IN_32(21) __INTRODUCED_IN_64(23);
 
 /* 7.3.9 Manipulation functions */
 /* 7.3.9.1 The carg functions */
-double carg(double complex) __INTRODUCED_IN(23);
-float cargf(float complex) __INTRODUCED_IN(23);
-long double cargl(long double complex) __INTRODUCED_IN(23);
+double carg(double complex __z) __INTRODUCED_IN(23);
+float cargf(float complex __z) __INTRODUCED_IN(23);
+long double cargl(long double complex __z) __INTRODUCED_IN(23);
 /* 7.3.9.2 The cimag functions */
-double cimag(double complex) __INTRODUCED_IN(23);
-float cimagf(float complex) __INTRODUCED_IN(23);
-long double cimagl(long double complex) __INTRODUCED_IN(23);
+double cimag(double complex __z) __INTRODUCED_IN(23);
+float cimagf(float complex __z) __INTRODUCED_IN(23);
+long double cimagl(long double complex __z) __INTRODUCED_IN(23);
 /* 7.3.9.3 The conj functions */
-double complex conj(double complex) __INTRODUCED_IN(23);
-float complex conjf(float complex) __INTRODUCED_IN(23);
-long double complex conjl(long double complex) __INTRODUCED_IN(23);
+double complex conj(double complex __z) __INTRODUCED_IN(23);
+float complex conjf(float complex __z) __INTRODUCED_IN(23);
+long double complex conjl(long double complex __z) __INTRODUCED_IN(23);
 /* 7.3.9.4 The cproj functions */
-double complex cproj(double complex) __INTRODUCED_IN(23);
-float complex cprojf(float complex) __INTRODUCED_IN(23);
-long double complex cprojl(long double complex) __INTRODUCED_IN_32(21) __INTRODUCED_IN_64(23);
+double complex cproj(double complex __z) __INTRODUCED_IN(23);
+float complex cprojf(float complex __z) __INTRODUCED_IN(23);
+long double complex cprojl(long double complex __z) __INTRODUCED_IN_32(21) __INTRODUCED_IN_64(23);
 /* 7.3.9.5 The creal functions */
-double creal(double complex) __INTRODUCED_IN(23);
-float crealf(float complex) __INTRODUCED_IN(23);
-long double creall(long double complex) __INTRODUCED_IN(23);
+double creal(double complex __z) __INTRODUCED_IN(23);
+float crealf(float complex __z) __INTRODUCED_IN(23);
+long double creall(long double complex __z) __INTRODUCED_IN(23);
 
 __END_DECLS
 
-#endif /* _COMPLEX_H */
+#endif
diff --git a/libc/include/fenv.h b/libc/include/fenv.h
index a4c37e6..ae35ae3 100644
--- a/libc/include/fenv.h
+++ b/libc/include/fenv.h
@@ -37,25 +37,25 @@
 
 // fenv was always available on x86.
 #if __ANDROID_API__ >= __ANDROID_API_L__ || defined(__i386__)
-int feclearexcept(int) __INTRODUCED_IN_ARM(21) __INTRODUCED_IN_MIPS(21) __INTRODUCED_IN_X86(9);
-int fegetexceptflag(fexcept_t*, int) __INTRODUCED_IN_ARM(21) __INTRODUCED_IN_MIPS(21)
+int feclearexcept(int __exceptions) __INTRODUCED_IN_ARM(21) __INTRODUCED_IN_MIPS(21) __INTRODUCED_IN_X86(9);
+int fegetexceptflag(fexcept_t* __flag_ptr, int __exceptions) __INTRODUCED_IN_ARM(21) __INTRODUCED_IN_MIPS(21)
     __INTRODUCED_IN_X86(9);
-int feraiseexcept(int) __INTRODUCED_IN_ARM(21) __INTRODUCED_IN_MIPS(21) __INTRODUCED_IN_X86(9);
-int fesetexceptflag(const fexcept_t*, int) __INTRODUCED_IN_ARM(21) __INTRODUCED_IN_MIPS(21)
+int feraiseexcept(int __exceptions) __INTRODUCED_IN_ARM(21) __INTRODUCED_IN_MIPS(21) __INTRODUCED_IN_X86(9);
+int fesetexceptflag(const fexcept_t* __flag_ptr, int __exceptions) __INTRODUCED_IN_ARM(21) __INTRODUCED_IN_MIPS(21)
     __INTRODUCED_IN_X86(9);
-int fetestexcept(int) __INTRODUCED_IN_ARM(21) __INTRODUCED_IN_MIPS(21) __INTRODUCED_IN_X86(9);
+int fetestexcept(int __exceptions) __INTRODUCED_IN_ARM(21) __INTRODUCED_IN_MIPS(21) __INTRODUCED_IN_X86(9);
 
 int fegetround(void) __INTRODUCED_IN_ARM(21) __INTRODUCED_IN_MIPS(21) __INTRODUCED_IN_X86(9);
-int fesetround(int) __INTRODUCED_IN_ARM(21) __INTRODUCED_IN_MIPS(21) __INTRODUCED_IN_X86(9);
+int fesetround(int __rounding_mode) __INTRODUCED_IN_ARM(21) __INTRODUCED_IN_MIPS(21) __INTRODUCED_IN_X86(9);
 
-int fegetenv(fenv_t*) __INTRODUCED_IN_ARM(21) __INTRODUCED_IN_MIPS(21) __INTRODUCED_IN_X86(9);
-int feholdexcept(fenv_t*) __INTRODUCED_IN_ARM(21) __INTRODUCED_IN_MIPS(21) __INTRODUCED_IN_X86(9);
-int fesetenv(const fenv_t*) __INTRODUCED_IN_ARM(21) __INTRODUCED_IN_MIPS(21) __INTRODUCED_IN_X86(9);
-int feupdateenv(const fenv_t*) __INTRODUCED_IN_ARM(21) __INTRODUCED_IN_MIPS(21)
+int fegetenv(fenv_t* __env) __INTRODUCED_IN_ARM(21) __INTRODUCED_IN_MIPS(21) __INTRODUCED_IN_X86(9);
+int feholdexcept(fenv_t* __env) __INTRODUCED_IN_ARM(21) __INTRODUCED_IN_MIPS(21) __INTRODUCED_IN_X86(9);
+int fesetenv(const fenv_t* __env) __INTRODUCED_IN_ARM(21) __INTRODUCED_IN_MIPS(21) __INTRODUCED_IN_X86(9);
+int feupdateenv(const fenv_t* __env) __INTRODUCED_IN_ARM(21) __INTRODUCED_IN_MIPS(21)
     __INTRODUCED_IN_X86(9);
 
-int feenableexcept(int) __INTRODUCED_IN_ARM(21) __INTRODUCED_IN_MIPS(21) __INTRODUCED_IN_X86(9);
-int fedisableexcept(int) __INTRODUCED_IN_ARM(21) __INTRODUCED_IN_MIPS(21) __INTRODUCED_IN_X86(9);
+int feenableexcept(int __exceptions) __INTRODUCED_IN_ARM(21) __INTRODUCED_IN_MIPS(21) __INTRODUCED_IN_X86(9);
+int fedisableexcept(int __exceptions) __INTRODUCED_IN_ARM(21) __INTRODUCED_IN_MIPS(21) __INTRODUCED_IN_X86(9);
 int fegetexcept(void) __INTRODUCED_IN_ARM(21) __INTRODUCED_IN_MIPS(21) __INTRODUCED_IN_X86(9);
 #else
 /* Defined as inlines for pre-21 ARM and MIPS. */
diff --git a/libc/include/math.h b/libc/include/math.h
index 7dd1539..248ed3c 100644
--- a/libc/include/math.h
+++ b/libc/include/math.h
@@ -89,69 +89,69 @@
  * as __attribute_const__. In C99, FENV_ACCESS affects the purity of these functions.
  */
 
-int __fpclassifyd(double) __attribute_const__;
-int __fpclassifyf(float) __attribute_const__;
-int __fpclassifyl(long double) __attribute_const__;
-int __isfinitef(float) __attribute_const__;
-int __isfinite(double) __attribute_const__;
-int __isfinitel(long double) __attribute_const__;
-int __isinff(float) __attribute_const__;
-int __isinfl(long double) __attribute_const__;
-int __isnanf(float) __attribute_const__ __INTRODUCED_IN(21);
-int __isnanl(long double) __attribute_const__;
-int __isnormalf(float) __attribute_const__;
-int __isnormal(double) __attribute_const__;
-int __isnormall(long double) __attribute_const__;
-int __signbit(double) __attribute_const__;
-int __signbitf(float) __attribute_const__;
-int __signbitl(long double) __attribute_const__;
+int __fpclassifyd(double __x) __attribute_const__;
+int __fpclassifyf(float __x) __attribute_const__;
+int __fpclassifyl(long double __x) __attribute_const__;
+int __isfinitef(float __x) __attribute_const__;
+int __isfinite(double __x) __attribute_const__;
+int __isfinitel(long double __x) __attribute_const__;
+int __isinff(float __x) __attribute_const__;
+int __isinfl(long double __x) __attribute_const__;
+int __isnanf(float __x) __attribute_const__ __INTRODUCED_IN(21);
+int __isnanl(long double __x) __attribute_const__;
+int __isnormalf(float __x) __attribute_const__;
+int __isnormal(double __x) __attribute_const__;
+int __isnormall(long double __x) __attribute_const__;
+int __signbit(double __x) __attribute_const__;
+int __signbitf(float __x) __attribute_const__;
+int __signbitl(long double __x) __attribute_const__;
 
-double	acos(double);
-double	asin(double);
-double	atan(double);
-double	atan2(double, double);
-double	cos(double);
-double	sin(double);
-double	tan(double);
+double acos(double __x);
+double asin(double __x);
+double atan(double __x);
+double atan2(double __y, double __x);
+double cos(double __x);
+double sin(double __x);
+double tan(double __x);
 
-double	cosh(double);
-double	sinh(double);
-double	tanh(double);
+double cosh(double __x);
+double sinh(double __x);
+double tanh(double __x);
 
-double	exp(double);
-double	frexp(double, int *);	/* fundamentally !__attribute_const__ */
-double	ldexp(double, int);
-double	log(double);
-double	log10(double);
-double	modf(double, double *);	/* fundamentally !__attribute_const__ */
+double exp(double __x);
+double frexp(double __x, int* __exponent); /* fundamentally !__attribute_const__ */
+double ldexp(double __x, int __exponent);
+double log(double __x);
+double log10(double __x);
+double modf(double __x, double* __integral_part); /* fundamentally !__attribute_const__ */
 
-double	pow(double, double);
-double	sqrt(double);
+double pow(double __x, double __y);
+double sqrt(double __x);
 
-double	ceil(double);
-double	fabs(double) __attribute_const__;
-double	floor(double);
-double	fmod(double, double);
+double ceil(double __x);
+double fabs(double __x) __attribute_const__;
+double floor(double __x);
+double fmod(double __x, double __y);
 
-double	acosh(double);
-double	asinh(double);
-double	atanh(double);
-double	cbrt(double);
-double	erf(double);
-double	erfc(double);
-double	exp2(double);
-double	expm1(double);
-double	fma(double, double, double);
-double	hypot(double, double);
-int	ilogb(double) __attribute_const__;
-double	lgamma(double);
-long long llrint(double);
-long long llround(double);
-double	log1p(double);
-double log2(double) __INTRODUCED_IN(18);
-double	logb(double);
-long	lrint(double);
-long	lround(double);
+double acosh(double __x);
+double asinh(double __x);
+double atanh(double __x);
+double cbrt(double __x);
+double erf(double __x);
+double erfc(double __x);
+double exp2(double __x);
+double expm1(double __x);
+double fma(double __x, double __y, double __z);
+double hypot(double __x, double __y);
+int ilogb(double __x) __attribute_const__;
+double lgamma(double __x);
+long long llrint(double __x);
+long long llround(double __x);
+double log1p(double __x);
+double log2(double __x) __INTRODUCED_IN(18);
+double logb(double __x);
+long lrint(double __x);
+long lround(double __x);
 
 /*
  * https://code.google.com/p/android/issues/detail?id=271629
@@ -164,160 +164,160 @@
  * to the std namespace, making it impossible to use both <cmath> (which gets
  * included by a lot of other standard headers) and ::isnan.
  */
-int(isinf)(double) __attribute_const__ __INTRODUCED_IN(21);
-int	(isnan)(double) __attribute_const__;
+int (isinf)(double __x) __attribute_const__ __INTRODUCED_IN(21);
+int (isnan)(double __x) __attribute_const__;
 
-double nan(const char*) __attribute_const__ __INTRODUCED_IN_ARM(13) __INTRODUCED_IN_MIPS(13)
+double nan(const char* __kind) __attribute_const__ __INTRODUCED_IN_ARM(13) __INTRODUCED_IN_MIPS(13)
     __INTRODUCED_IN_X86(9);
 
-double	nextafter(double, double);
-double	remainder(double, double);
-double	remquo(double, double, int*);
-double	rint(double);
+double nextafter(double __x, double __y);
+double remainder(double __x, double __y);
+double remquo(double __x, double __y, int* __quotient_bits);
+double rint(double __x);
 
-double	copysign(double, double) __attribute_const__;
-double	fdim(double, double);
-double	fmax(double, double) __attribute_const__;
-double	fmin(double, double) __attribute_const__;
-double	nearbyint(double);
-double	round(double);
-double scalbln(double, long) __INTRODUCED_IN_X86(18) __VERSIONER_NO_GUARD;
-double scalbn(double, int);
-double	tgamma(double);
-double	trunc(double);
+double copysign(double __value, double __sign) __attribute_const__;
+double fdim(double __x, double __y);
+double fmax(double __x, double __y) __attribute_const__;
+double fmin(double __x, double __y) __attribute_const__;
+double nearbyint(double __x);
+double round(double __x);
+double scalbln(double __x, long __exponent) __INTRODUCED_IN_X86(18) __VERSIONER_NO_GUARD;
+double scalbn(double __x, int __exponent);
+double tgamma(double __x);
+double trunc(double __x);
 
-float	acosf(float);
-float	asinf(float);
-float	atanf(float);
-float	atan2f(float, float);
-float	cosf(float);
-float	sinf(float);
-float	tanf(float);
+float acosf(float __x);
+float asinf(float __x);
+float atanf(float __x);
+float atan2f(float __y, float __x);
+float cosf(float __x);
+float sinf(float __x);
+float tanf(float __x);
 
-float	coshf(float);
-float	sinhf(float);
-float	tanhf(float);
+float coshf(float __x);
+float sinhf(float __x);
+float tanhf(float __x);
 
-float	exp2f(float);
-float	expf(float);
-float	expm1f(float);
-float	frexpf(float, int *);	/* fundamentally !__attribute_const__ */
-int	ilogbf(float) __attribute_const__;
-float	ldexpf(float, int);
-float	log10f(float);
-float	log1pf(float);
-float log2f(float) __INTRODUCED_IN(18);
-float	logf(float);
-float	modff(float, float *);	/* fundamentally !__attribute_const__ */
+float exp2f(float __x);
+float expf(float __x);
+float expm1f(float __x);
+float frexpf(float __x, int* __exponent); /* fundamentally !__attribute_const__ */
+int ilogbf(float __x) __attribute_const__;
+float ldexpf(float __x, int __exponent);
+float log10f(float __x);
+float log1pf(float __x);
+float log2f(float __x) __INTRODUCED_IN(18);
+float logf(float __x);
+float modff(float __x, float* __integral_part); /* fundamentally !__attribute_const__ */
 
-float	powf(float, float);
-float	sqrtf(float);
+float powf(float __x, float __y);
+float sqrtf(float __x);
 
-float	ceilf(float);
-float	fabsf(float) __attribute_const__;
-float	floorf(float);
-float	fmodf(float, float);
-float	roundf(float);
+float ceilf(float __x);
+float fabsf(float __x) __attribute_const__;
+float floorf(float __x);
+float fmodf(float __x, float __y);
+float roundf(float __x);
 
-float	erff(float);
-float	erfcf(float);
-float	hypotf(float, float);
-float	lgammaf(float);
-float tgammaf(float) __INTRODUCED_IN_ARM(13) __INTRODUCED_IN_MIPS(13) __INTRODUCED_IN_X86(9);
+float erff(float __x);
+float erfcf(float __x);
+float hypotf(float __x, float __y);
+float lgammaf(float __x);
+float tgammaf(float __x) __INTRODUCED_IN_ARM(13) __INTRODUCED_IN_MIPS(13) __INTRODUCED_IN_X86(9);
 
-float	acoshf(float);
-float	asinhf(float);
-float	atanhf(float);
-float	cbrtf(float);
-float	logbf(float);
-float	copysignf(float, float) __attribute_const__;
-long long llrintf(float);
-long long llroundf(float);
-long	lrintf(float);
-long	lroundf(float);
-float nanf(const char*) __attribute_const__ __INTRODUCED_IN_ARM(13) __INTRODUCED_IN_MIPS(13)
+float acoshf(float __x);
+float asinhf(float __x);
+float atanhf(float __x);
+float cbrtf(float __x);
+float logbf(float __x);
+float copysignf(float __value, float __sign) __attribute_const__;
+long long llrintf(float __x);
+long long llroundf(float __x);
+long lrintf(float __x);
+long lroundf(float __x);
+float nanf(const char* __kind) __attribute_const__ __INTRODUCED_IN_ARM(13) __INTRODUCED_IN_MIPS(13)
     __INTRODUCED_IN_X86(9);
-float	nearbyintf(float);
-float	nextafterf(float, float);
-float	remainderf(float, float);
-float	remquof(float, float, int *);
-float	rintf(float);
-float	scalblnf(float, long) __INTRODUCED_IN_X86(18) __VERSIONER_NO_GUARD;
-float scalbnf(float, int);
-float	truncf(float);
+float nearbyintf(float __x);
+float nextafterf(float __x, float __y);
+float remainderf(float __x, float __y);
+float remquof(float __x, float __y, int* __quotient_bits);
+float rintf(float __x);
+float scalblnf(float __x, long __exponent) __INTRODUCED_IN_X86(18) __VERSIONER_NO_GUARD;
+float scalbnf(float __x, int __exponent);
+float truncf(float __x);
 
-float	fdimf(float, float);
-float	fmaf(float, float, float);
-float	fmaxf(float, float) __attribute_const__;
-float	fminf(float, float) __attribute_const__;
+float fdimf(float __x, float __y);
+float fmaf(float __x, float __y, float __z);
+float fmaxf(float __x, float __y) __attribute_const__;
+float fminf(float __x, float __y) __attribute_const__;
 
-long double acoshl(long double) __INTRODUCED_IN(21);
-long double acosl(long double) __INTRODUCED_IN(21);
-long double asinhl(long double) __INTRODUCED_IN(21);
-long double asinl(long double) __INTRODUCED_IN(21);
-long double atan2l(long double, long double) __INTRODUCED_IN(21);
-long double atanhl(long double) __INTRODUCED_IN(21);
-long double atanl(long double) __INTRODUCED_IN(21);
-long double cbrtl(long double) __INTRODUCED_IN(21);
-long double ceill(long double);
-long double copysignl(long double, long double) __attribute_const__;
-long double coshl(long double) __INTRODUCED_IN(21);
-long double cosl(long double) __INTRODUCED_IN(21);
-long double erfcl(long double) __INTRODUCED_IN(21);
-long double erfl(long double) __INTRODUCED_IN(21);
-long double exp2l(long double) __INTRODUCED_IN(21);
-long double expl(long double) __INTRODUCED_IN(21);
-long double expm1l(long double) __INTRODUCED_IN(21);
-long double fabsl(long double) __attribute_const__;
-long double fdiml(long double, long double);
-long double floorl(long double);
-long double fmal(long double, long double, long double) __INTRODUCED_IN(21) __VERSIONER_NO_GUARD;
-long double fmaxl(long double, long double) __attribute_const__;
-long double fminl(long double, long double) __attribute_const__;
-long double fmodl(long double, long double) __INTRODUCED_IN(21);
-long double frexpl(long double value, int*)
+long double acoshl(long double __x) __INTRODUCED_IN(21);
+long double acosl(long double __x) __INTRODUCED_IN(21);
+long double asinhl(long double __x) __INTRODUCED_IN(21);
+long double asinl(long double __x) __INTRODUCED_IN(21);
+long double atan2l(long double __y, long double __x) __INTRODUCED_IN(21);
+long double atanhl(long double __x) __INTRODUCED_IN(21);
+long double atanl(long double __x) __INTRODUCED_IN(21);
+long double cbrtl(long double __x) __INTRODUCED_IN(21);
+long double ceill(long double __x);
+long double copysignl(long double __value, long double __sign) __attribute_const__;
+long double coshl(long double __x) __INTRODUCED_IN(21);
+long double cosl(long double __x) __INTRODUCED_IN(21);
+long double erfcl(long double __x) __INTRODUCED_IN(21);
+long double erfl(long double __x) __INTRODUCED_IN(21);
+long double exp2l(long double __x) __INTRODUCED_IN(21);
+long double expl(long double __x) __INTRODUCED_IN(21);
+long double expm1l(long double __x) __INTRODUCED_IN(21);
+long double fabsl(long double __x) __attribute_const__;
+long double fdiml(long double __x, long double __y);
+long double floorl(long double __x);
+long double fmal(long double __x, long double __y, long double __z) __INTRODUCED_IN(21) __VERSIONER_NO_GUARD;
+long double fmaxl(long double __x, long double __y) __attribute_const__;
+long double fminl(long double __x, long double __y) __attribute_const__;
+long double fmodl(long double __x, long double __y) __INTRODUCED_IN(21);
+long double frexpl(long double __x, int* __exponent)
     __INTRODUCED_IN(21) __VERSIONER_NO_GUARD; /* fundamentally !__attribute_const__ */
-long double hypotl(long double, long double) __INTRODUCED_IN(21);
-int ilogbl(long double) __attribute_const__;
-long double ldexpl(long double, int);
-long double lgammal(long double) __INTRODUCED_IN(21);
-long long llrintl(long double) __INTRODUCED_IN(21);
-long long llroundl(long double);
-long double log10l(long double) __INTRODUCED_IN(21);
-long double log1pl(long double) __INTRODUCED_IN(21);
-long double log2l(long double) __INTRODUCED_IN(18);
-long double logbl(long double) __INTRODUCED_IN(18);
-long double logl(long double) __INTRODUCED_IN(21);
-long lrintl(long double) __INTRODUCED_IN(21);
-long lroundl(long double);
-long double modfl(long double, long double*) __INTRODUCED_IN(21); /* fundamentally !__attribute_const__ */
-long double nanl(const char*) __attribute_const__ __INTRODUCED_IN(13);
-long double nearbyintl(long double) __INTRODUCED_IN(21);
-long double nextafterl(long double, long double) __INTRODUCED_IN(21) __VERSIONER_NO_GUARD;
-double nexttoward(double, long double) __INTRODUCED_IN(18) __VERSIONER_NO_GUARD;
-float nexttowardf(float, long double);
-long double nexttowardl(long double, long double) __INTRODUCED_IN(18) __VERSIONER_NO_GUARD;
-long double powl(long double, long double) __INTRODUCED_IN(21);
-long double remainderl(long double, long double) __INTRODUCED_IN(21);
-long double remquol(long double, long double, int*) __INTRODUCED_IN(21);
-long double rintl(long double) __INTRODUCED_IN(21);
-long double roundl(long double);
-long double scalblnl(long double, long) __INTRODUCED_IN_X86(18) __VERSIONER_NO_GUARD;
-long double scalbnl(long double, int);
-long double sinhl(long double) __INTRODUCED_IN(21);
-long double sinl(long double) __INTRODUCED_IN(21);
-long double sqrtl(long double) __INTRODUCED_IN(21);
-long double tanhl(long double) __INTRODUCED_IN(21);
-long double tanl(long double) __INTRODUCED_IN(21);
-long double tgammal(long double) __INTRODUCED_IN(21);
-long double truncl(long double);
+long double hypotl(long double __x, long double __y) __INTRODUCED_IN(21);
+int ilogbl(long double __x) __attribute_const__;
+long double ldexpl(long double __x, int __exponent);
+long double lgammal(long double __x) __INTRODUCED_IN(21);
+long long llrintl(long double __x) __INTRODUCED_IN(21);
+long long llroundl(long double __x);
+long double log10l(long double __x) __INTRODUCED_IN(21);
+long double log1pl(long double __x) __INTRODUCED_IN(21);
+long double log2l(long double __x) __INTRODUCED_IN(18);
+long double logbl(long double __x) __INTRODUCED_IN(18);
+long double logl(long double __x) __INTRODUCED_IN(21);
+long lrintl(long double __x) __INTRODUCED_IN(21);
+long lroundl(long double __x);
+long double modfl(long double __x, long double* __integral_part) __INTRODUCED_IN(21); /* fundamentally !__attribute_const__ */
+long double nanl(const char* __kind) __attribute_const__ __INTRODUCED_IN(13);
+long double nearbyintl(long double __x) __INTRODUCED_IN(21);
+long double nextafterl(long double __x, long double __y) __INTRODUCED_IN(21) __VERSIONER_NO_GUARD;
+double nexttoward(double __x, long double __y) __INTRODUCED_IN(18) __VERSIONER_NO_GUARD;
+float nexttowardf(float __x, long double __y);
+long double nexttowardl(long double __x, long double __y) __INTRODUCED_IN(18) __VERSIONER_NO_GUARD;
+long double powl(long double __x, long double __y) __INTRODUCED_IN(21);
+long double remainderl(long double __x, long double __y) __INTRODUCED_IN(21);
+long double remquol(long double __x, long double __y, int* __quotient_bits) __INTRODUCED_IN(21);
+long double rintl(long double __x) __INTRODUCED_IN(21);
+long double roundl(long double __x);
+long double scalblnl(long double __x, long __exponent) __INTRODUCED_IN_X86(18) __VERSIONER_NO_GUARD;
+long double scalbnl(long double __x, int __exponent);
+long double sinhl(long double __x) __INTRODUCED_IN(21);
+long double sinl(long double __x) __INTRODUCED_IN(21);
+long double sqrtl(long double __x) __INTRODUCED_IN(21);
+long double tanhl(long double __x) __INTRODUCED_IN(21);
+long double tanl(long double __x) __INTRODUCED_IN(21);
+long double tgammal(long double __x) __INTRODUCED_IN(21);
+long double truncl(long double __x);
 
-double j0(double);
-double j1(double);
-double jn(int, double);
-double y0(double);
-double y1(double);
-double yn(int, double);
+double j0(double __x);
+double j1(double __x);
+double jn(int __n, double __x);
+double y0(double __x);
+double y1(double __x);
+double yn(int __n, double __x);
 
 #define M_E		2.7182818284590452354	/* e */
 #define M_LOG2E		1.4426950408889634074	/* log 2e */
@@ -336,29 +336,29 @@
 #define MAXFLOAT	((float)3.40282346638528860e+38)
 
 #if defined(__USE_BSD) || defined(__USE_GNU)
-double gamma(double);
-double scalb(double, double);
-double drem(double, double);
-int finite(double) __attribute_const__;
-int isnanf(float) __attribute_const__;
-double gamma_r(double, int*);
-double lgamma_r(double, int*);
-double significand(double);
-long double lgammal_r(long double, int*) __INTRODUCED_IN(23);
-long double significandl(long double) __INTRODUCED_IN(21);
-float dremf(float, float);
-int finitef(float) __attribute_const__;
-float gammaf(float);
-float j0f(float);
-float j1f(float);
-float jnf(int, float);
-float scalbf(float, float);
-float y0f(float);
-float y1f(float);
-float ynf(int, float);
-float gammaf_r(float, int *);
-float lgammaf_r(float, int *);
-float significandf(float);
+double gamma(double __x);
+double scalb(double __x, double __exponent);
+double drem(double __x, double __y);
+int finite(double __x) __attribute_const__;
+int isnanf(float __x) __attribute_const__;
+double gamma_r(double __x, int* __sign);
+double lgamma_r(double __x, int* __sign);
+double significand(double __x);
+long double lgammal_r(long double __x, int* __sign) __INTRODUCED_IN(23);
+long double significandl(long double __x) __INTRODUCED_IN(21);
+float dremf(float __x, float __y);
+int finitef(float __x) __attribute_const__;
+float gammaf(float __x);
+float j0f(float __x);
+float j1f(float __x);
+float jnf(int __n, float __x);
+float scalbf(float __x, float __exponent);
+float y0f(float __x);
+float y1f(float __x);
+float ynf(int __n, float __x);
+float gammaf_r(float __x, int* __sign);
+float lgammaf_r(float __x, int* __sign);
+float significandf(float __x);
 #endif
 
 #if defined(__USE_GNU)
@@ -375,11 +375,11 @@
 #define M_2_SQRTPIl     1.128379167095512573896158903121545172L /* 2/sqrt(pi) */
 #define M_SQRT2l        1.414213562373095048801688724209698079L /* sqrt(2) */
 #define M_SQRT1_2l      0.707106781186547524400844362104849039L /* 1/sqrt(2) */
-void sincos(double, double*, double*);
-void sincosf(float, float*, float*);
-void sincosl(long double, long double*, long double*);
+void sincos(double __x, double* __sin, double* __cos);
+void sincosf(float __x, float* __sin, float* __cos);
+void sincosl(long double __x, long double* __sin, long double* __cos);
 #endif
 
 __END_DECLS
 
-#endif /* !_MATH_H_ */
+#endif
diff --git a/libc/include/paths.h b/libc/include/paths.h
index b76d045..d2c5956 100644
--- a/libc/include/paths.h
+++ b/libc/include/paths.h
@@ -34,7 +34,9 @@
 
 #include <sys/cdefs.h>
 
+#ifndef _PATH_BSHELL
 #define	_PATH_BSHELL	"/system/bin/sh"
+#endif
 #define	_PATH_CONSOLE	"/dev/console"
 #define	_PATH_DEFPATH	"/sbin:/system/sbin:/system/bin:/system/xbin:/vendor/bin:/vendor/xbin"
 #define	_PATH_DEV	"/dev/"
diff --git a/libc/include/resolv.h b/libc/include/resolv.h
index 2c12819..d6db4cf 100644
--- a/libc/include/resolv.h
+++ b/libc/include/resolv.h
@@ -40,25 +40,25 @@
 __BEGIN_DECLS
 
 #define b64_ntop __b64_ntop
-int b64_ntop(u_char const*, size_t, char*, size_t);
+int b64_ntop(u_char const* __src, size_t __src_size, char* __dst, size_t __dst_size);
 #define b64_pton __b64_pton
-int b64_pton(char const*, u_char*, size_t);
+int b64_pton(char const* __src, u_char* __dst, size_t __dst_size);
 
 #define dn_comp __dn_comp
-int dn_comp(const char*, u_char*, int, u_char**, u_char**);
+int dn_comp(const char* __src, u_char* __dst, int __dst_size, u_char** __dn_ptrs , u_char** __last_dn_ptr);
 
-int dn_expand(const u_char*, const u_char*, const u_char*, char*, int);
+int dn_expand(const u_char* __msg, const u_char* __eom, const u_char* __src, char* __dst, int __dst_size);
 
 #define p_class __p_class
-const char* p_class(int);
+const char* p_class(int __class);
 #define p_type __p_type
-const char* p_type(int);
+const char* p_type(int __type);
 
 int res_init(void);
-int res_mkquery(int, const char*, int, int, const u_char*, int, const u_char*, u_char*, int);
-int res_query(const char*, int, int, u_char*, int);
-int res_search(const char*, int, int, u_char*, int);
+int res_mkquery(int __opcode, const char* __domain_name, int __class, int __type, const u_char* __data, int __data_size, const u_char* __new_rr_in, u_char* __buf, int __buf_size);
+int res_query(const char* __name, int __class, int __type, u_char* __answer, int __answer_size);
+int res_search(const char* __name, int __class, int __type, u_char* __answer, int __answer_size);
 
 __END_DECLS
 
-#endif /* _RESOLV_H_ */
+#endif
diff --git a/libc/include/string.h b/libc/include/string.h
index 164146d..33ef468 100644
--- a/libc/include/string.h
+++ b/libc/include/string.h
@@ -41,83 +41,81 @@
 #include <strings.h>
 #endif
 
-void* memccpy(void*, const void*, int, size_t);
-void* memchr(const void*, int, size_t) __attribute_pure__ __overloadable __RENAME_CLANG(memchr);
-void* memrchr(const void*, int, size_t) __attribute_pure__ __overloadable __RENAME_CLANG(memrchr);
-int memcmp(const void*, const void*, size_t) __attribute_pure__;
+void* memccpy(void* __dst, const void* __src, int __stop_char, size_t __n);
+void* memchr(const void* __s, int __ch, size_t __n) __attribute_pure__ __overloadable __RENAME_CLANG(memchr);
+void* memrchr(const void* __s, int __ch, size_t __n) __attribute_pure__ __overloadable __RENAME_CLANG(memrchr);
+int memcmp(const void* __lhs, const void* __rhs, size_t __n) __attribute_pure__;
 void* memcpy(void*, const void*, size_t)
         __overloadable __RENAME_CLANG(memcpy);
 #if defined(__USE_GNU)
-void* mempcpy(void*, const void*, size_t) __INTRODUCED_IN(23);
+void* mempcpy(void* __dst, const void* __src, size_t __n) __INTRODUCED_IN(23);
 #endif
-void* memmove(void*, const void*, size_t) __overloadable __RENAME_CLANG(memmove);
-void* memset(void*, int, size_t) __overloadable __RENAME_CLANG(memset);
-void* memmem(const void*, size_t, const void*, size_t) __attribute_pure__;
+void* memmove(void* __dst, const void* __src, size_t __n) __overloadable __RENAME_CLANG(memmove);
+void* memset(void* __dst, int __ch, size_t __n) __overloadable __RENAME_CLANG(memset);
+void* memmem(const void* __haystack, size_t __haystack_size, const void* __needle, size_t __needle_size) __attribute_pure__;
 
-char* strchr(const char*, int) __attribute_pure__ __overloadable __RENAME_CLANG(strchr);
-char* __strchr_chk(const char*, int, size_t) __INTRODUCED_IN(18);
+char* strchr(const char* __s, int __ch) __attribute_pure__ __overloadable __RENAME_CLANG(strchr);
+char* __strchr_chk(const char* __s, int __ch, size_t __n) __INTRODUCED_IN(18);
 #if defined(__USE_GNU)
 #if defined(__cplusplus)
 /* The versioner doesn't handle C++ blocks yet, so manually guarded. */
 #if __ANDROID_API__ >= 24
-extern "C++" char* strchrnul(char*, int) __RENAME(strchrnul) __attribute_pure__ __INTRODUCED_IN(24);
-extern "C++" const char* strchrnul(const char*, int) __RENAME(strchrnul) __attribute_pure__ __INTRODUCED_IN(24);
+extern "C++" char* strchrnul(char* __s, int __ch) __RENAME(strchrnul) __attribute_pure__ __INTRODUCED_IN(24);
+extern "C++" const char* strchrnul(const char* __s, int __ch) __RENAME(strchrnul) __attribute_pure__ __INTRODUCED_IN(24);
 #endif  /* __ANDROID_API__ >= 24 */
 #else
-char* strchrnul(const char*, int) __attribute_pure__ __INTRODUCED_IN(24);
+char* strchrnul(const char* __s, int __ch) __attribute_pure__ __INTRODUCED_IN(24);
 #endif
 #endif
 
-char* strrchr(const char*, int) __attribute_pure__ __overloadable __RENAME_CLANG(strrchr);
-char* __strrchr_chk(const char*, int, size_t) __INTRODUCED_IN(18);
+char* strrchr(const char* __s, int __ch) __attribute_pure__ __overloadable __RENAME_CLANG(strrchr);
+char* __strrchr_chk(const char* __s, int __ch, size_t __n) __INTRODUCED_IN(18);
 
-size_t strlen(const char*) __attribute_pure__ __overloadable
-        __RENAME_CLANG(strlen);
-size_t __strlen_chk(const char*, size_t) __INTRODUCED_IN(17);
+size_t strlen(const char* __s) __attribute_pure__ __overloadable __RENAME_CLANG(strlen);
+size_t __strlen_chk(const char* __s, size_t __n) __INTRODUCED_IN(17);
 
-int strcmp(const char*, const char*) __attribute_pure__;
-char* stpcpy(char*, const char*) __overloadable __RENAME_CLANG(stpcpy) __INTRODUCED_IN(21);
-char* strcpy(char*, const char*)
-        __overloadable __RENAME_CLANG(strcpy);
-char* strcat(char*, const char*) __overloadable __RENAME_CLANG(strcat);
-char* strdup(const char*);
+int strcmp(const char* __lhs, const char* __rhs) __attribute_pure__;
+char* stpcpy(char* __dst, const char* __src) __overloadable __RENAME_CLANG(stpcpy) __INTRODUCED_IN(21);
+char* strcpy(char* __dst, const char* __src) __overloadable __RENAME_CLANG(strcpy);
+char* strcat(char* __dst, const char* __src) __overloadable __RENAME_CLANG(strcat);
+char* strdup(const char* __s);
 
-char* strstr(const char*, const char*) __attribute_pure__;
-char* strcasestr(const char*, const char*) __attribute_pure__;
-char* strtok(char*, const char*);
-char* strtok_r(char*, const char*, char**);
+char* strstr(const char* __haystack, const char* __needle) __attribute_pure__;
+char* strcasestr(const char* __haystack, const char* __needle) __attribute_pure__;
+char* strtok(char* __s, const char* __delimiter);
+char* strtok_r(char* __s, const char* __delimiter, char** __pos_ptr);
 
-char* strerror(int);
-char* strerror_l(int, locale_t) __INTRODUCED_IN(23);
+char* strerror(int __errno_value);
+char* strerror_l(int __errno_value, locale_t __l) __INTRODUCED_IN(23);
 #if defined(__USE_GNU) && __ANDROID_API__ >= 23
-char* strerror_r(int, char*, size_t) __RENAME(__gnu_strerror_r) __INTRODUCED_IN(23);
+char* strerror_r(int __errno_value, char* __buf, size_t __n) __RENAME(__gnu_strerror_r) __INTRODUCED_IN(23);
 #else /* POSIX */
-int strerror_r(int, char*, size_t);
+int strerror_r(int __errno_value, char* __buf, size_t __n);
 #endif
 
-size_t strnlen(const char*, size_t) __attribute_pure__;
-char* strncat(char*, const char*, size_t) __overloadable __RENAME_CLANG(strncat);
-char* strndup(const char*, size_t);
-int strncmp(const char*, const char*, size_t) __attribute_pure__;
-char* stpncpy(char*, const char*, size_t) __overloadable __RENAME_CLANG(stpncpy) __INTRODUCED_IN(21);
-char* strncpy(char*, const char*, size_t) __overloadable __RENAME_CLANG(strncpy);
+size_t strnlen(const char* __s, size_t __n) __attribute_pure__;
+char* strncat(char* __dst, const char* __src, size_t __n) __overloadable __RENAME_CLANG(strncat);
+char* strndup(const char* __s, size_t __n);
+int strncmp(const char* __lhs, const char* __rhs, size_t __n) __attribute_pure__;
+char* stpncpy(char* __dst, const char* __src, size_t __n) __overloadable __RENAME_CLANG(stpncpy) __INTRODUCED_IN(21);
+char* strncpy(char* __dst, const char* __src, size_t __n) __overloadable __RENAME_CLANG(strncpy);
 
-size_t strlcat(char*, const char*, size_t) __overloadable __RENAME_CLANG(strlcat);
-size_t strlcpy(char*, const char*, size_t) __overloadable __RENAME_CLANG(strlcpy);
+size_t strlcat(char* __dst, const char* __src, size_t __n) __overloadable __RENAME_CLANG(strlcat);
+size_t strlcpy(char* __dst, const char* __src, size_t __n) __overloadable __RENAME_CLANG(strlcpy);
 
-size_t strcspn(const char*, const char*) __attribute_pure__;
-char* strpbrk(const char*, const char*) __attribute_pure__;
-char* strsep(char**, const char*);
-size_t strspn(const char*, const char*);
+size_t strcspn(const char* __s, const char* __reject) __attribute_pure__;
+char* strpbrk(const char* __s, const char* __accept) __attribute_pure__;
+char* strsep(char** __s_ptr, const char* __delimiter);
+size_t strspn(const char* __s, const char* __accept);
 
-char* strsignal(int);
+char* strsignal(int __signal);
 
-int strcoll(const char*, const char*) __attribute_pure__;
-size_t strxfrm(char*, const char*, size_t);
+int strcoll(const char* __lhs, const char* __rhs) __attribute_pure__;
+size_t strxfrm(char* __dst, const char* __src, size_t __n);
 
 #if __ANDROID_API__ >= __ANDROID_API_L__
-int strcoll_l(const char*, const char*, locale_t) __attribute_pure__ __INTRODUCED_IN(21);
-size_t strxfrm_l(char*, const char*, size_t, locale_t) __INTRODUCED_IN(21);
+int strcoll_l(const char* __lhs, const char* __rhs, locale_t __l) __attribute_pure__ __INTRODUCED_IN(21);
+size_t strxfrm_l(char* __dst, const char* __src, size_t __n, locale_t __l) __INTRODUCED_IN(21);
 #else
 // Implemented as static inlines before 21.
 #endif
@@ -130,11 +128,11 @@
 #if defined(__cplusplus)
 /* The versioner doesn't handle C++ blocks yet, so manually guarded. */
 #if __ANDROID_API__ >= 23
-extern "C++" char* basename(char*) __RENAME(__gnu_basename) __INTRODUCED_IN(23);
-extern "C++" const char* basename(const char*) __RENAME(__gnu_basename) __INTRODUCED_IN(23);
+extern "C++" char* basename(char* __path) __RENAME(__gnu_basename) __INTRODUCED_IN(23);
+extern "C++" const char* basename(const char* __path) __RENAME(__gnu_basename) __INTRODUCED_IN(23);
 #endif  /* __ANDROID_API__ >= 23 */
 #else
-char* basename(const char*) __RENAME(__gnu_basename) __INTRODUCED_IN(23);
+char* basename(const char* __path) __RENAME(__gnu_basename) __INTRODUCED_IN(23);
 #endif
 #endif
 
@@ -230,4 +228,4 @@
 
 __END_DECLS
 
-#endif /* _STRING_H */
+#endif
diff --git a/libc/include/sys/cdefs.h b/libc/include/sys/cdefs.h
index 71d8426..58eebc5 100644
--- a/libc/include/sys/cdefs.h
+++ b/libc/include/sys/cdefs.h
@@ -239,9 +239,18 @@
 
 #define __BIONIC_FORTIFY_UNKNOWN_SIZE ((size_t) -1)
 
-#if defined(_FORTIFY_SOURCE) && _FORTIFY_SOURCE > 0 && \
-      (defined(__clang__) || (defined(__OPTIMIZE__) && __OPTIMIZE__ > 0))
-#  define __BIONIC_FORTIFY 1
+#if defined(_FORTIFY_SOURCE) && _FORTIFY_SOURCE > 0
+#  if defined(__clang__)
+/* FORTIFY's _chk functions effectively disable ASAN's stdlib interceptors. */
+#    if !__has_feature(address_sanitizer)
+#      define __BIONIC_FORTIFY 1
+#    endif
+#  elif defined(__OPTIMIZE__) && __OPTIMIZE__ > 0
+#    define __BIONIC_FORTIFY 1
+#  endif
+#endif
+
+#if defined(__BIONIC_FORTIFY)
 #  if _FORTIFY_SOURCE == 2
 #    define __bos_level 1
 #  else
diff --git a/libc/private/bionic_futex.h b/libc/private/bionic_futex.h
index 946d9dd..9b89131 100644
--- a/libc/private/bionic_futex.h
+++ b/libc/private/bionic_futex.h
@@ -36,13 +36,10 @@
 #include <sys/syscall.h>
 #include <unistd.h>
 
-__BEGIN_DECLS
-
 struct timespec;
 
 static inline __always_inline int __futex(volatile void* ftx, int op, int value,
-                                          const struct timespec* timeout,
-                                          int bitset) {
+                                          const timespec* timeout, int bitset) {
   // Our generated syscall assembler sets errno, but our callers (pthread functions) don't want to.
   int saved_errno = errno;
   int result = syscall(__NR_futex, ftx, op, value, timeout, NULL, bitset);
@@ -61,17 +58,16 @@
   return __futex(ftx, shared ? FUTEX_WAKE : FUTEX_WAKE_PRIVATE, count, NULL, 0);
 }
 
-static inline int __futex_wait(volatile void* ftx, int value, const struct timespec* timeout) {
+static inline int __futex_wait(volatile void* ftx, int value, const timespec* timeout) {
   return __futex(ftx, FUTEX_WAIT, value, timeout, 0);
 }
 
-static inline int __futex_wait_ex(volatile void* ftx, bool shared, int value,
-                                  bool use_realtime_clock, const struct timespec* abs_timeout) {
-  return __futex(ftx, (shared ? FUTEX_WAIT_BITSET : FUTEX_WAIT_BITSET_PRIVATE) |
-                 (use_realtime_clock ? FUTEX_CLOCK_REALTIME : 0), value, abs_timeout,
+static inline int __futex_wait_ex(volatile void* ftx, bool shared, int value) {
+  return __futex(ftx, (shared ? FUTEX_WAIT_BITSET : FUTEX_WAIT_BITSET_PRIVATE), value, nullptr,
                  FUTEX_BITSET_MATCH_ANY);
 }
 
-__END_DECLS
+__LIBC_HIDDEN__ int __futex_wait_ex(volatile void* ftx, bool shared, int value,
+                                    bool use_realtime_clock, const timespec* abs_timeout);
 
 #endif /* _BIONIC_FUTEX_H */
diff --git a/libc/private/bionic_lock.h b/libc/private/bionic_lock.h
index 3dbafe0..b389247 100644
--- a/libc/private/bionic_lock.h
+++ b/libc/private/bionic_lock.h
@@ -64,7 +64,7 @@
     }
     while (atomic_exchange_explicit(&state, LockedWithWaiter, memory_order_acquire) != Unlocked) {
       // TODO: As the critical section is brief, it is a better choice to spin a few times befor sleeping.
-      __futex_wait_ex(&state, process_shared, LockedWithWaiter, false, nullptr);
+      __futex_wait_ex(&state, process_shared, LockedWithWaiter);
     }
     return;
   }
diff --git a/libc/private/bionic_time_conversions.h b/libc/private/bionic_time_conversions.h
index b9eaad2..fb049f2 100644
--- a/libc/private/bionic_time_conversions.h
+++ b/libc/private/bionic_time_conversions.h
@@ -42,6 +42,9 @@
 
 __LIBC_HIDDEN__ void timeval_from_timespec(timeval& tv, const timespec& ts);
 
+__LIBC_HIDDEN__ void monotonic_time_from_realtime_time(timespec& monotonic_time,
+                                                       const timespec& realtime_time);
+
 __END_DECLS
 
 static inline int check_timespec(const timespec* ts, bool null_allowed) {
diff --git a/libc/tools/check-symbols-glibc.py b/libc/tools/check-symbols-glibc.py
index 631fd93..e40f3e3 100755
--- a/libc/tools/check-symbols-glibc.py
+++ b/libc/tools/check-symbols-glibc.py
@@ -186,14 +186,17 @@
 # being implemented (fattach).
 in_posix_and_glibc_but_actually_dead = set([
   'a64l',
+  'confstr',
   'fattach',
   'fdetach',
+  'gethostid',
   'getmsg',
   'getpmsg',
   'isastream',
   'l64a',
   'putmsg',
   'putpmsg',
+  'ulimit',
 ])
 
 posix = posix - in_posix_and_glibc_but_actually_dead
diff --git a/libc/upstream-netbsd/android/include/netbsd-compat.h b/libc/upstream-netbsd/android/include/netbsd-compat.h
index 45b974a..af5ae29 100644
--- a/libc/upstream-netbsd/android/include/netbsd-compat.h
+++ b/libc/upstream-netbsd/android/include/netbsd-compat.h
@@ -44,4 +44,8 @@
 #include <stddef.h>
 int reallocarr(void*, size_t, size_t);
 
+/* Use appropriate shell depending on process's executable. */
+__LIBC_HIDDEN__ extern const char* __bionic_get_shell_path();
+#define _PATH_BSHELL __bionic_get_shell_path()
+
 #endif
diff --git a/libc/upstream-openbsd/android/include/openbsd-compat.h b/libc/upstream-openbsd/android/include/openbsd-compat.h
index baf5057..d831435 100644
--- a/libc/upstream-openbsd/android/include/openbsd-compat.h
+++ b/libc/upstream-openbsd/android/include/openbsd-compat.h
@@ -71,6 +71,10 @@
  */
 #define _PATH_TMP "/data/local/tmp/"
 
+/* Use appropriate shell depending on process's executable. */
+__LIBC_HIDDEN__ extern const char* __bionic_get_shell_path();
+#define _PATH_BSHELL __bionic_get_shell_path()
+
 /* We have OpenBSD's getentropy_linux.c, but we don't mention getentropy in any header. */
 __LIBC_HIDDEN__ extern int getentropy(void*, size_t);
 
diff --git a/linker/linker_config.cpp b/linker/linker_config.cpp
index 0a9aeab..2bdde1e 100644
--- a/linker/linker_config.cpp
+++ b/linker/linker_config.cpp
@@ -371,6 +371,15 @@
                                       bool is_asan,
                                       const Config** config,
                                       std::string* error_msg) {
+  // TODO(b/38114603) Currently, multiple namespaces does not support ASAN mode
+  // where some symbols should be intercepted via LD_PRELOAD; LD_PRELOADed libs
+  // are not being preloaded into the linked namespaces other than the default
+  // namespace. Until we fix the problem, we temporarily disable ld.config.txt
+  // in ASAN mode.
+  if (is_asan) {
+    return false;
+  }
+
   g_config.clear();
 
   std::unordered_map<std::string, PropertyValue> property_map;
diff --git a/linker/tests/linker_config_test.cpp b/linker/tests/linker_config_test.cpp
index c6fade9..87609d0 100644
--- a/linker/tests/linker_config_test.cpp
+++ b/linker/tests/linker_config_test.cpp
@@ -168,6 +168,7 @@
   run_linker_config_smoke_test(false);
 }
 
-TEST(linker_config, asan_smoke) {
-  run_linker_config_smoke_test(true);
-}
+// TODO(b/38114603) revive this test when ld.config.txt is enabled for ASAN mode
+//TEST(linker_config, asan_smoke) {
+//  run_linker_config_smoke_test(true);
+//}
diff --git a/tests/Android.bp b/tests/Android.bp
index 084d393..ea3f39f 100644
--- a/tests/Android.bp
+++ b/tests/Android.bp
@@ -192,6 +192,26 @@
     },
 }
 
+// If building this fails, then we have both FORTIFY and ASAN enabled, which
+// isn't desirable. (Ideally, we'd emit FORTIFY diagnostics even with ASAN
+// enabled, but that's not a reality today.) This is meant to be otherwise
+// unused.
+cc_test_library {
+    name: "fortify_disabled_for_asan",
+    cflags: [
+        "-Werror",
+        "-D_FORTIFY_SOURCE=2",
+        // "sanitize: address" doesn't work on platforms where libasan isn't
+        // enabled. Since the intent is just to build this, we can get away with
+        // passing this flag on its own.
+        "-fsanitize=address",
+    ],
+    // Ignore that we don't have ASAN symbols linked in.
+    allow_undefined_symbols: true,
+    srcs: ["fortify_compilation_test.cpp"],
+    clang: true,
+}
+
 cc_test_library {
     name: "libfortify1-tests-clang",
     defaults: ["bionic_fortify_tests_defaults", "bionic_tests_defaults"],
diff --git a/tests/async_safe_test.cpp b/tests/async_safe_test.cpp
index 3d6fcaa..e71ba7a 100644
--- a/tests/async_safe_test.cpp
+++ b/tests/async_safe_test.cpp
@@ -181,8 +181,20 @@
   char buf[BUFSIZ];
   ASSERT_EQ(11, async_safe_format_buffer(buf, sizeof(buf), "hello %s", "world"));
   EXPECT_STREQ("hello world", buf);
+
   ASSERT_EQ(11, async_safe_format_buffer(buf, 8, "hello %s", "world"));
   EXPECT_STREQ("hello w", buf);
+
+  ASSERT_EQ(11, async_safe_format_buffer(buf, 6, "hello %s", "world"));
+  EXPECT_STREQ("hello", buf);
+
+  ASSERT_EQ(4, async_safe_format_buffer(nullptr, 0, "xxxx"));
+
+  ASSERT_EQ(4, async_safe_format_buffer(buf, 1, "xxxx"));
+  EXPECT_STREQ("", buf);
+
+  ASSERT_EQ(4, async_safe_format_buffer(buf, 2, "xxxx"));
+  EXPECT_STREQ("x", buf);
 #else // __BIONIC__
   GTEST_LOG_(INFO) << "This test does nothing.\n";
 #endif // __BIONIC__
diff --git a/tests/fcntl_test.cpp b/tests/fcntl_test.cpp
index 4532a4b..7e78830 100644
--- a/tests/fcntl_test.cpp
+++ b/tests/fcntl_test.cpp
@@ -20,6 +20,7 @@
 #include <fcntl.h>
 #include <string.h>
 #include <sys/utsname.h>
+#include <sys/vfs.h>
 
 #include "TemporaryFile.h"
 
@@ -28,6 +29,7 @@
 // Glibc v2.19 doesn't include these in fcntl.h so host builds will fail without.
 #if !defined(FALLOC_FL_PUNCH_HOLE) || !defined(FALLOC_FL_KEEP_SIZE)
 #include <linux/falloc.h>
+#include <linux/magic.h>
 #endif
 
 TEST(fcntl, fcntl_smoke) {
@@ -290,8 +292,12 @@
 
   if (major < 4 || (major == 4 && minor < 1)) {
     TemporaryFile tf;
-    ASSERT_EQ(-1, fallocate(tf.fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE, 0, 1));
-    ASSERT_EQ(errno, EOPNOTSUPP);
+    struct statfs sfs;
+    ASSERT_EQ(0, fstatfs(tf.fd, &sfs));
+    if (sfs.f_type == EXT4_SUPER_MAGIC) {
+      ASSERT_EQ(-1, fallocate(tf.fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE, 0, 1));
+      ASSERT_EQ(errno, EOPNOTSUPP);
+    }
   }
 }
 
diff --git a/tests/wchar_test.cpp b/tests/wchar_test.cpp
index a7e49e8..eb23cf3 100644
--- a/tests/wchar_test.cpp
+++ b/tests/wchar_test.cpp
@@ -782,20 +782,20 @@
 
 template <typename T>
 void TestWcsToFloat(WcsToFloatFn<T> fn) {
-  TestSingleWcsToFloat(fn, L"123", static_cast<T>(123.0), 3);
-  TestSingleWcsToFloat(fn, L"123#", static_cast<T>(123.0), 3);
-  TestSingleWcsToFloat(fn, L"   123 45", static_cast<T>(123.0), 6);
-  TestSingleWcsToFloat(fn, L"9.0", static_cast<T>(9.0), 3);
-  TestSingleWcsToFloat(fn, L"-9.0", static_cast<T>(-9.0), 4);
-  TestSingleWcsToFloat(fn, L" \t\v\f\r\n9.0", static_cast<T>(9.0), 9);
+  TestSingleWcsToFloat(fn, L"123", static_cast<T>(123.0L), 3);
+  TestSingleWcsToFloat(fn, L"123#", static_cast<T>(123.0L), 3);
+  TestSingleWcsToFloat(fn, L"   123 45", static_cast<T>(123.0L), 6);
+  TestSingleWcsToFloat(fn, L"9.0", static_cast<T>(9.0L), 3);
+  TestSingleWcsToFloat(fn, L"-9.0", static_cast<T>(-9.0L), 4);
+  TestSingleWcsToFloat(fn, L" \t\v\f\r\n9.0", static_cast<T>(9.0L), 9);
 }
 
 template <typename T>
 void TestWcsToFloatHexFloats(WcsToFloatFn<T> fn) {
-  TestSingleWcsToFloat(fn, L"0.9e1", static_cast<T>(9.0), 5);
-  TestSingleWcsToFloat(fn, L"0x1.2p3", static_cast<T>(9.0), 7);
-  TestSingleWcsToFloat(fn, L"+1e+100", static_cast<T>(1e100), 7);
-  TestSingleWcsToFloat(fn, L"0x10000.80", static_cast<T>(65536.50), 10);
+  TestSingleWcsToFloat(fn, L"0.9e1", static_cast<T>(9.0L), 5);
+  TestSingleWcsToFloat(fn, L"0x1.2p3", static_cast<T>(9.0L), 7);
+  TestSingleWcsToFloat(fn, L"+1e+100", static_cast<T>(1e100L), 7);
+  TestSingleWcsToFloat(fn, L"0x10000.80", static_cast<T>(65536.50L), 10);
 }
 
 template <typename T>