Restoring authorship annotation for Anton Samokhvalov <pg83@yandex.ru>. Commit 2 of 2.

8 files changed, 3144 insertions, 3144 deletions

diff --git a/contrib/libs/linuxvdso/original/config.h b/contrib/libs/linuxvdso/original/config.h
index 9ac2e91d8b..06598e84c0 100644
--- a/contrib/libs/linuxvdso/original/config.h
+++ b/contrib/libs/linuxvdso/original/config.h
@@ -1,11 +1,11 @@
-#pragma once 
- 
-#include <inttypes.h> 
- 
-#if !defined(__WORDSIZE) 
-    #define __WORDSIZE (sizeof(unsigned long) * 8) 
-#endif 
- 
-#define DISALLOW_COPY_AND_ASSIGN(x) 
-#define RunningOnValgrind() false 
-#define COMPILE_ASSERT(x, y) 
+#pragma once
+
+#include <inttypes.h>
+
+#if !defined(__WORDSIZE)
+    #define __WORDSIZE (sizeof(unsigned long) * 8)
+#endif
+
+#define DISALLOW_COPY_AND_ASSIGN(x)
+#define RunningOnValgrind() false
+#define COMPILE_ASSERT(x, y)
diff --git a/contrib/libs/linuxvdso/original/elf_mem_image.cc b/contrib/libs/linuxvdso/original/elf_mem_image.cc
index d18ef43f10..066fcba4e3 100644
--- a/contrib/libs/linuxvdso/original/elf_mem_image.cc
+++ b/contrib/libs/linuxvdso/original/elf_mem_image.cc
@@ -1,436 +1,436 @@
-// Copyright (c) 2008, Google Inc. 
-// 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. 
-//     * Neither the name of Google Inc. nor the names of its 
-// contributors may be used to endorse or promote products derived from 
-// this software without specific prior written permission. 
-// 
-// 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. 
- 
-// --- 
-// Author: Paul Pluzhnikov 
-// 
-// Allow dynamic symbol lookup in an in-memory Elf image. 
-// 
- 
-#include "elf_mem_image.h" 
-#include "logging.h" 
- 
-#ifdef HAVE_ELF_MEM_IMAGE  // defined in elf_mem_image.h 
- 
-#if defined(_musl_) 
-    #include <endian.h> 
-#endif 
- 
-#include <stddef.h>   // for size_t, ptrdiff_t 
- 
-// From binutils/include/elf/common.h (this doesn't appear to be documented 
-// anywhere else). 
-// 
-//   /* This flag appears in a Versym structure.  It means that the symbol 
-//      is hidden, and is only visible with an explicit version number. 
-//      This is a GNU extension.  */ 
-//   #define VERSYM_HIDDEN           0x8000 
-// 
-//   /* This is the mask for the rest of the Versym information.  */ 
-//   #define VERSYM_VERSION          0x7fff 
- 
-#define VERSYM_VERSION 0x7fff 
- 
-namespace base { 
- 
-namespace { 
-template <int N> class ElfClass { 
- public: 
-  static const int kElfClass = -1; 
-  static int ElfBind(const ElfW(Sym) *) { 
-    CHECK(false); // << "Unexpected word size"; 
-    return 0; 
-  } 
-  static int ElfType(const ElfW(Sym) *) { 
-    CHECK(false); // << "Unexpected word size"; 
-    return 0; 
-  } 
-}; 
- 
-template <> class ElfClass<32> { 
- public: 
-  static const int kElfClass = ELFCLASS32; 
-  static int ElfBind(const ElfW(Sym) *symbol) { 
-    return ELF32_ST_BIND(symbol->st_info); 
-  } 
-  static int ElfType(const ElfW(Sym) *symbol) { 
-    return ELF32_ST_TYPE(symbol->st_info); 
-  } 
-}; 
- 
-template <> class ElfClass<64> { 
- public: 
-  static const int kElfClass = ELFCLASS64; 
-  static int ElfBind(const ElfW(Sym) *symbol) { 
-    return ELF64_ST_BIND(symbol->st_info); 
-  } 
-  static int ElfType(const ElfW(Sym) *symbol) { 
-    return ELF64_ST_TYPE(symbol->st_info); 
-  } 
-}; 
- 
-typedef ElfClass<__WORDSIZE> CurrentElfClass; 
- 
-// Extract an element from one of the ELF tables, cast it to desired type. 
-// This is just a simple arithmetic and a glorified cast. 
-// Callers are responsible for bounds checking. 
-template <class T> 
-const T* GetTableElement(const ElfW(Ehdr) *ehdr, 
-                         ElfW(Off) table_offset, 
-                         ElfW(Word) element_size, 
-                         size_t index) { 
-  return reinterpret_cast<const T*>(reinterpret_cast<const char *>(ehdr) 
-                                    + table_offset 
-                                    + index * element_size); 
-} 
-}  // namespace 
- 
-const void *const ElfMemImage::kInvalidBase = 
-    reinterpret_cast<const void *>(~0L); 
- 
-ElfMemImage::ElfMemImage(const void *base) { 
-  Init(base); 
-} 
- 
-int ElfMemImage::GetNumSymbols() const { 
-  if (!hash_) { 
-    return 0; 
-  } 
-  // See http://www.caldera.com/developers/gabi/latest/ch5.dynamic.html#hash 
-  return hash_[1]; 
-} 
- 
-const ElfW(Sym) *ElfMemImage::GetDynsym(int index) const { 
-  CHECK_LT(index, GetNumSymbols()); 
-  return dynsym_ + index; 
-} 
- 
-const ElfW(Versym) *ElfMemImage::GetVersym(int index) const { 
-  CHECK_LT(index, GetNumSymbols()); 
-  return versym_ + index; 
-} 
- 
-const ElfW(Phdr) *ElfMemImage::GetPhdr(int index) const { 
-  CHECK_LT(index, ehdr_->e_phnum); 
-  return GetTableElement<ElfW(Phdr)>(ehdr_, 
-                                     ehdr_->e_phoff, 
-                                     ehdr_->e_phentsize, 
-                                     index); 
-} 
- 
-const char *ElfMemImage::GetDynstr(ElfW(Word) offset) const { 
-  CHECK_LT(offset, strsize_); 
-  return dynstr_ + offset; 
-} 
- 
-const void *ElfMemImage::GetSymAddr(const ElfW(Sym) *sym) const { 
-  if (sym->st_shndx == SHN_UNDEF || sym->st_shndx >= SHN_LORESERVE) { 
-    // Symbol corresponds to "special" (e.g. SHN_ABS) section. 
-    return reinterpret_cast<const void *>(sym->st_value); 
-  } 
-  CHECK_LT(link_base_, sym->st_value); 
-  return GetTableElement<char>(ehdr_, 0, 1, sym->st_value) - link_base_; 
-} 
- 
-const ElfW(Verdef) *ElfMemImage::GetVerdef(int index) const { 
-  CHECK_LE(index, verdefnum_); 
-  const ElfW(Verdef) *version_definition = verdef_; 
-  while (version_definition->vd_ndx < index && version_definition->vd_next) { 
-    const char *const version_definition_as_char = 
-        reinterpret_cast<const char *>(version_definition); 
-    version_definition = 
-        reinterpret_cast<const ElfW(Verdef) *>(version_definition_as_char + 
-                                               version_definition->vd_next); 
-  } 
-  return version_definition->vd_ndx == index ? version_definition : NULL; 
-} 
- 
-const ElfW(Verdaux) *ElfMemImage::GetVerdefAux( 
-    const ElfW(Verdef) *verdef) const { 
-  return reinterpret_cast<const ElfW(Verdaux) *>(verdef+1); 
-} 
- 
-const char *ElfMemImage::GetVerstr(ElfW(Word) offset) const { 
-  CHECK_LT(offset, strsize_); 
-  return dynstr_ + offset; 
-} 
- 
-void ElfMemImage::Init(const void *base) { 
-  ehdr_      = NULL; 
-  dynsym_    = NULL; 
-  dynstr_    = NULL; 
-  versym_    = NULL; 
-  verdef_    = NULL; 
-  hash_      = NULL; 
-  strsize_   = 0; 
-  verdefnum_ = 0; 
-  link_base_ = ~0L;  // Sentinel: PT_LOAD .p_vaddr can't possibly be this. 
+// Copyright (c) 2008, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+
+// ---
+// Author: Paul Pluzhnikov
+//
+// Allow dynamic symbol lookup in an in-memory Elf image.
+//
+
+#include "elf_mem_image.h"
+#include "logging.h"
+
+#ifdef HAVE_ELF_MEM_IMAGE  // defined in elf_mem_image.h
+
+#if defined(_musl_)
+    #include <endian.h>
+#endif
+
+#include <stddef.h>   // for size_t, ptrdiff_t
+
+// From binutils/include/elf/common.h (this doesn't appear to be documented
+// anywhere else).
+//
+//   /* This flag appears in a Versym structure.  It means that the symbol
+//      is hidden, and is only visible with an explicit version number.
+//      This is a GNU extension.  */
+//   #define VERSYM_HIDDEN           0x8000
+//
+//   /* This is the mask for the rest of the Versym information.  */
+//   #define VERSYM_VERSION          0x7fff
+
+#define VERSYM_VERSION 0x7fff
+
+namespace base {
+
+namespace {
+template <int N> class ElfClass {
+ public:
+  static const int kElfClass = -1;
+  static int ElfBind(const ElfW(Sym) *) {
+    CHECK(false); // << "Unexpected word size";
+    return 0;
+  }
+  static int ElfType(const ElfW(Sym) *) {
+    CHECK(false); // << "Unexpected word size";
+    return 0;
+  }
+};
+
+template <> class ElfClass<32> {
+ public:
+  static const int kElfClass = ELFCLASS32;
+  static int ElfBind(const ElfW(Sym) *symbol) {
+    return ELF32_ST_BIND(symbol->st_info);
+  }
+  static int ElfType(const ElfW(Sym) *symbol) {
+    return ELF32_ST_TYPE(symbol->st_info);
+  }
+};
+
+template <> class ElfClass<64> {
+ public:
+  static const int kElfClass = ELFCLASS64;
+  static int ElfBind(const ElfW(Sym) *symbol) {
+    return ELF64_ST_BIND(symbol->st_info);
+  }
+  static int ElfType(const ElfW(Sym) *symbol) {
+    return ELF64_ST_TYPE(symbol->st_info);
+  }
+};
+
+typedef ElfClass<__WORDSIZE> CurrentElfClass;
+
+// Extract an element from one of the ELF tables, cast it to desired type.
+// This is just a simple arithmetic and a glorified cast.
+// Callers are responsible for bounds checking.
+template <class T>
+const T* GetTableElement(const ElfW(Ehdr) *ehdr,
+                         ElfW(Off) table_offset,
+                         ElfW(Word) element_size,
+                         size_t index) {
+  return reinterpret_cast<const T*>(reinterpret_cast<const char *>(ehdr)
+                                    + table_offset
+                                    + index * element_size);
+}
+}  // namespace
+
+const void *const ElfMemImage::kInvalidBase =
+    reinterpret_cast<const void *>(~0L);
+
+ElfMemImage::ElfMemImage(const void *base) {
+  Init(base);
+}
+
+int ElfMemImage::GetNumSymbols() const {
+  if (!hash_) {
+    return 0;
+  }
+  // See http://www.caldera.com/developers/gabi/latest/ch5.dynamic.html#hash
+  return hash_[1];
+}
+
+const ElfW(Sym) *ElfMemImage::GetDynsym(int index) const {
+  CHECK_LT(index, GetNumSymbols());
+  return dynsym_ + index;
+}
+
+const ElfW(Versym) *ElfMemImage::GetVersym(int index) const {
+  CHECK_LT(index, GetNumSymbols());
+  return versym_ + index;
+}
+
+const ElfW(Phdr) *ElfMemImage::GetPhdr(int index) const {
+  CHECK_LT(index, ehdr_->e_phnum);
+  return GetTableElement<ElfW(Phdr)>(ehdr_,
+                                     ehdr_->e_phoff,
+                                     ehdr_->e_phentsize,
+                                     index);
+}
+
+const char *ElfMemImage::GetDynstr(ElfW(Word) offset) const {
+  CHECK_LT(offset, strsize_);
+  return dynstr_ + offset;
+}
+
+const void *ElfMemImage::GetSymAddr(const ElfW(Sym) *sym) const {
+  if (sym->st_shndx == SHN_UNDEF || sym->st_shndx >= SHN_LORESERVE) {
+    // Symbol corresponds to "special" (e.g. SHN_ABS) section.
+    return reinterpret_cast<const void *>(sym->st_value);
+  }
+  CHECK_LT(link_base_, sym->st_value);
+  return GetTableElement<char>(ehdr_, 0, 1, sym->st_value) - link_base_;
+}
+
+const ElfW(Verdef) *ElfMemImage::GetVerdef(int index) const {
+  CHECK_LE(index, verdefnum_);
+  const ElfW(Verdef) *version_definition = verdef_;
+  while (version_definition->vd_ndx < index && version_definition->vd_next) {
+    const char *const version_definition_as_char =
+        reinterpret_cast<const char *>(version_definition);
+    version_definition =
+        reinterpret_cast<const ElfW(Verdef) *>(version_definition_as_char +
+                                               version_definition->vd_next);
+  }
+  return version_definition->vd_ndx == index ? version_definition : NULL;
+}
+
+const ElfW(Verdaux) *ElfMemImage::GetVerdefAux(
+    const ElfW(Verdef) *verdef) const {
+  return reinterpret_cast<const ElfW(Verdaux) *>(verdef+1);
+}
+
+const char *ElfMemImage::GetVerstr(ElfW(Word) offset) const {
+  CHECK_LT(offset, strsize_);
+  return dynstr_ + offset;
+}
+
+void ElfMemImage::Init(const void *base) {
+  ehdr_      = NULL;
+  dynsym_    = NULL;
+  dynstr_    = NULL;
+  versym_    = NULL;
+  verdef_    = NULL;
+  hash_      = NULL;
+  strsize_   = 0;
+  verdefnum_ = 0;
+  link_base_ = ~0L;  // Sentinel: PT_LOAD .p_vaddr can't possibly be this.
   if (!base || base == kInvalidBase) {
-    return; 
-  } 
-  const intptr_t base_as_uintptr_t = reinterpret_cast<uintptr_t>(base); 
-  // Fake VDSO has low bit set. 
-  const bool fake_vdso = ((base_as_uintptr_t & 1) != 0); 
-  base = reinterpret_cast<const void *>(base_as_uintptr_t & ~1); 
-  const char *const base_as_char = reinterpret_cast<const char *>(base); 
-  if (base_as_char[EI_MAG0] != ELFMAG0 || base_as_char[EI_MAG1] != ELFMAG1 || 
-      base_as_char[EI_MAG2] != ELFMAG2 || base_as_char[EI_MAG3] != ELFMAG3) { 
-    RAW_DCHECK(false, "no ELF magic"); // at %p", base); 
-    return; 
-  } 
-  int elf_class = base_as_char[EI_CLASS]; 
-  if (elf_class != CurrentElfClass::kElfClass) { 
-    DCHECK_EQ(elf_class, CurrentElfClass::kElfClass); 
-    return; 
-  } 
-  switch (base_as_char[EI_DATA]) { 
-    case ELFDATA2LSB: { 
-      if (__LITTLE_ENDIAN != __BYTE_ORDER) { 
-        DCHECK_EQ(__LITTLE_ENDIAN, __BYTE_ORDER); // << ": wrong byte order"; 
-        return; 
-      } 
-      break; 
-    } 
-    case ELFDATA2MSB: { 
-      if (__BIG_ENDIAN != __BYTE_ORDER) { 
-        DCHECK_EQ(__BIG_ENDIAN, __BYTE_ORDER); // << ": wrong byte order"; 
-        return; 
-      } 
-      break; 
-    } 
-    default: { 
-      RAW_DCHECK(false, "unexpected data encoding"); // << base_as_char[EI_DATA]; 
-      return; 
-    } 
-  } 
- 
-  ehdr_ = reinterpret_cast<const ElfW(Ehdr) *>(base); 
-  const ElfW(Phdr) *dynamic_program_header = NULL; 
-  for (int i = 0; i < ehdr_->e_phnum; ++i) { 
-    const ElfW(Phdr) *const program_header = GetPhdr(i); 
-    switch (program_header->p_type) { 
-      case PT_LOAD: 
-        if (link_base_ == ~0L) { 
-          link_base_ = program_header->p_vaddr; 
-        } 
-        break; 
-      case PT_DYNAMIC: 
-        dynamic_program_header = program_header; 
-        break; 
-    } 
-  } 
-  if (link_base_ == ~0L || !dynamic_program_header) { 
-    RAW_DCHECK(~0L != link_base_, "no PT_LOADs in VDSO"); 
-    RAW_DCHECK(dynamic_program_header, "no PT_DYNAMIC in VDSO"); 
-    // Mark this image as not present. Can not recur infinitely. 
-    Init(0); 
-    return; 
-  } 
-  ptrdiff_t relocation = 
-      base_as_char - reinterpret_cast<const char *>(link_base_); 
-  ElfW(Dyn) *dynamic_entry = 
-      reinterpret_cast<ElfW(Dyn) *>(dynamic_program_header->p_vaddr + 
-                                    relocation); 
-  for (; dynamic_entry->d_tag != DT_NULL; ++dynamic_entry) { 
-    ElfW(Xword) value = dynamic_entry->d_un.d_val; 
-    if (fake_vdso) { 
-      // A complication: in the real VDSO, dynamic entries are not relocated 
-      // (it wasn't loaded by a dynamic loader). But when testing with a 
-      // "fake" dlopen()ed vdso library, the loader relocates some (but 
-      // not all!) of them before we get here. 
-      if (dynamic_entry->d_tag == DT_VERDEF) { 
-        // The only dynamic entry (of the ones we care about) libc-2.3.6 
-        // loader doesn't relocate. 
-        value += relocation; 
-      } 
-    } else { 
-      // Real VDSO. Everything needs to be relocated. 
-      value += relocation; 
-    } 
-    switch (dynamic_entry->d_tag) { 
-      case DT_HASH: 
-        hash_ = reinterpret_cast<ElfW(Word) *>(value); 
-        break; 
-      case DT_SYMTAB: 
-        dynsym_ = reinterpret_cast<ElfW(Sym) *>(value); 
-        break; 
-      case DT_STRTAB: 
-        dynstr_ = reinterpret_cast<const char *>(value); 
-        break; 
-      case DT_VERSYM: 
-        versym_ = reinterpret_cast<ElfW(Versym) *>(value); 
-        break; 
-      case DT_VERDEF: 
-        verdef_ = reinterpret_cast<ElfW(Verdef) *>(value); 
-        break; 
-      case DT_VERDEFNUM: 
-        verdefnum_ = dynamic_entry->d_un.d_val; 
-        break; 
-      case DT_STRSZ: 
-        strsize_ = dynamic_entry->d_un.d_val; 
-        break; 
-      default: 
-        // Unrecognized entries explicitly ignored. 
-        break; 
-    } 
-  } 
-  if (!hash_ || !dynsym_ || !dynstr_ || !versym_ || 
-      !verdef_ || !verdefnum_ || !strsize_) { 
-    RAW_DCHECK(hash_, "invalid VDSO (no DT_HASH)"); 
-    RAW_DCHECK(dynsym_, "invalid VDSO (no DT_SYMTAB)"); 
-    RAW_DCHECK(dynstr_, "invalid VDSO (no DT_STRTAB)"); 
-    RAW_DCHECK(versym_, "invalid VDSO (no DT_VERSYM)"); 
-    RAW_DCHECK(verdef_, "invalid VDSO (no DT_VERDEF)"); 
-    RAW_DCHECK(verdefnum_, "invalid VDSO (no DT_VERDEFNUM)"); 
-    RAW_DCHECK(strsize_, "invalid VDSO (no DT_STRSZ)"); 
-    // Mark this image as not present. Can not recur infinitely. 
-    Init(0); 
-    return; 
-  } 
-} 
- 
-bool ElfMemImage::LookupSymbol(const char *name, 
-                               const char *version, 
-                               int type, 
-                               SymbolInfo *info) const { 
-  for (SymbolIterator it = begin(); it != end(); ++it) { 
-    if (strcmp(it->name, name) == 0 && strcmp(it->version, version) == 0 && 
-        CurrentElfClass::ElfType(it->symbol) == type) { 
-      if (info) { 
-        *info = *it; 
-      } 
-      return true; 
-    } 
-  } 
-  return false; 
-} 
- 
-bool ElfMemImage::LookupSymbolByAddress(const void *address, 
-                                        SymbolInfo *info_out) const { 
-  for (SymbolIterator it = begin(); it != end(); ++it) { 
-    const char *const symbol_start = 
-        reinterpret_cast<const char *>(it->address); 
-    const char *const symbol_end = symbol_start + it->symbol->st_size; 
-    if (symbol_start <= address && address < symbol_end) { 
-      if (info_out) { 
-        // Client wants to know details for that symbol (the usual case). 
-        if (CurrentElfClass::ElfBind(it->symbol) == STB_GLOBAL) { 
-          // Strong symbol; just return it. 
-          *info_out = *it; 
-          return true; 
-        } else { 
-          // Weak or local. Record it, but keep looking for a strong one. 
-          *info_out = *it; 
-        } 
-      } else { 
-        // Client only cares if there is an overlapping symbol. 
-        return true; 
-      } 
-    } 
-  } 
-  return false; 
-} 
- 
-ElfMemImage::SymbolIterator::SymbolIterator(const void *const image, int index) 
-    : index_(index), image_(image) { 
-} 
- 
-const ElfMemImage::SymbolInfo *ElfMemImage::SymbolIterator::operator->() const { 
-  return &info_; 
-} 
- 
-const ElfMemImage::SymbolInfo& ElfMemImage::SymbolIterator::operator*() const { 
-  return info_; 
-} 
- 
-bool ElfMemImage::SymbolIterator::operator==(const SymbolIterator &rhs) const { 
-  return this->image_ == rhs.image_ && this->index_ == rhs.index_; 
-} 
- 
-bool ElfMemImage::SymbolIterator::operator!=(const SymbolIterator &rhs) const { 
-  return !(*this == rhs); 
-} 
- 
-ElfMemImage::SymbolIterator &ElfMemImage::SymbolIterator::operator++() { 
-  this->Update(1); 
-  return *this; 
-} 
- 
-ElfMemImage::SymbolIterator ElfMemImage::begin() const { 
-  SymbolIterator it(this, 0); 
-  it.Update(0); 
-  return it; 
-} 
- 
-ElfMemImage::SymbolIterator ElfMemImage::end() const { 
-  return SymbolIterator(this, GetNumSymbols()); 
-} 
- 
-void ElfMemImage::SymbolIterator::Update(int increment) { 
-  const ElfMemImage *image = reinterpret_cast<const ElfMemImage *>(image_); 
-  CHECK(image->IsPresent() || increment == 0); 
-  if (!image->IsPresent()) { 
-    return; 
-  } 
-  index_ += increment; 
-  if (index_ >= image->GetNumSymbols()) { 
-    index_ = image->GetNumSymbols(); 
-    return; 
-  } 
-  const ElfW(Sym)    *symbol = image->GetDynsym(index_); 
-  const ElfW(Versym) *version_symbol = image->GetVersym(index_); 
-  CHECK(symbol && version_symbol); 
-  const char *const symbol_name = image->GetDynstr(symbol->st_name); 
-  const ElfW(Versym) version_index = version_symbol[0] & VERSYM_VERSION; 
-  const ElfW(Verdef) *version_definition = NULL; 
-  const char *version_name = ""; 
-  if (symbol->st_shndx == SHN_UNDEF) { 
-    // Undefined symbols reference DT_VERNEED, not DT_VERDEF, and 
-    // version_index could well be greater than verdefnum_, so calling 
-    // GetVerdef(version_index) may trigger assertion. 
-  } else { 
-    version_definition = image->GetVerdef(version_index); 
-  } 
-  if (version_definition) { 
-    // I am expecting 1 or 2 auxiliary entries: 1 for the version itself, 
-    // optional 2nd if the version has a parent. 
-    CHECK_LE(1, version_definition->vd_cnt); 
-    CHECK_LE(version_definition->vd_cnt, 2); 
-    const ElfW(Verdaux) *version_aux = image->GetVerdefAux(version_definition); 
-    version_name = image->GetVerstr(version_aux->vda_name); 
-  } 
-  info_.name    = symbol_name; 
-  info_.version = version_name; 
-  info_.address = image->GetSymAddr(symbol); 
-  info_.symbol  = symbol; 
-} 
- 
-}  // namespace base 
- 
-#endif  // HAVE_ELF_MEM_IMAGE 
+    return;
+  }
+  const intptr_t base_as_uintptr_t = reinterpret_cast<uintptr_t>(base);
+  // Fake VDSO has low bit set.
+  const bool fake_vdso = ((base_as_uintptr_t & 1) != 0);
+  base = reinterpret_cast<const void *>(base_as_uintptr_t & ~1);
+  const char *const base_as_char = reinterpret_cast<const char *>(base);
+  if (base_as_char[EI_MAG0] != ELFMAG0 || base_as_char[EI_MAG1] != ELFMAG1 ||
+      base_as_char[EI_MAG2] != ELFMAG2 || base_as_char[EI_MAG3] != ELFMAG3) {
+    RAW_DCHECK(false, "no ELF magic"); // at %p", base);
+    return;
+  }
+  int elf_class = base_as_char[EI_CLASS];
+  if (elf_class != CurrentElfClass::kElfClass) {
+    DCHECK_EQ(elf_class, CurrentElfClass::kElfClass);
+    return;
+  }
+  switch (base_as_char[EI_DATA]) {
+    case ELFDATA2LSB: {
+      if (__LITTLE_ENDIAN != __BYTE_ORDER) {
+        DCHECK_EQ(__LITTLE_ENDIAN, __BYTE_ORDER); // << ": wrong byte order";
+        return;
+      }
+      break;
+    }
+    case ELFDATA2MSB: {
+      if (__BIG_ENDIAN != __BYTE_ORDER) {
+        DCHECK_EQ(__BIG_ENDIAN, __BYTE_ORDER); // << ": wrong byte order";
+        return;
+      }
+      break;
+    }
+    default: {
+      RAW_DCHECK(false, "unexpected data encoding"); // << base_as_char[EI_DATA];
+      return;
+    }
+  }
+
+  ehdr_ = reinterpret_cast<const ElfW(Ehdr) *>(base);
+  const ElfW(Phdr) *dynamic_program_header = NULL;
+  for (int i = 0; i < ehdr_->e_phnum; ++i) {
+    const ElfW(Phdr) *const program_header = GetPhdr(i);
+    switch (program_header->p_type) {
+      case PT_LOAD:
+        if (link_base_ == ~0L) {
+          link_base_ = program_header->p_vaddr;
+        }
+        break;
+      case PT_DYNAMIC:
+        dynamic_program_header = program_header;
+        break;
+    }
+  }
+  if (link_base_ == ~0L || !dynamic_program_header) {
+    RAW_DCHECK(~0L != link_base_, "no PT_LOADs in VDSO");
+    RAW_DCHECK(dynamic_program_header, "no PT_DYNAMIC in VDSO");
+    // Mark this image as not present. Can not recur infinitely.
+    Init(0);
+    return;
+  }
+  ptrdiff_t relocation =
+      base_as_char - reinterpret_cast<const char *>(link_base_);
+  ElfW(Dyn) *dynamic_entry =
+      reinterpret_cast<ElfW(Dyn) *>(dynamic_program_header->p_vaddr +
+                                    relocation);
+  for (; dynamic_entry->d_tag != DT_NULL; ++dynamic_entry) {
+    ElfW(Xword) value = dynamic_entry->d_un.d_val;
+    if (fake_vdso) {
+      // A complication: in the real VDSO, dynamic entries are not relocated
+      // (it wasn't loaded by a dynamic loader). But when testing with a
+      // "fake" dlopen()ed vdso library, the loader relocates some (but
+      // not all!) of them before we get here.
+      if (dynamic_entry->d_tag == DT_VERDEF) {
+        // The only dynamic entry (of the ones we care about) libc-2.3.6
+        // loader doesn't relocate.
+        value += relocation;
+      }
+    } else {
+      // Real VDSO. Everything needs to be relocated.
+      value += relocation;
+    }
+    switch (dynamic_entry->d_tag) {
+      case DT_HASH:
+        hash_ = reinterpret_cast<ElfW(Word) *>(value);
+        break;
+      case DT_SYMTAB:
+        dynsym_ = reinterpret_cast<ElfW(Sym) *>(value);
+        break;
+      case DT_STRTAB:
+        dynstr_ = reinterpret_cast<const char *>(value);
+        break;
+      case DT_VERSYM:
+        versym_ = reinterpret_cast<ElfW(Versym) *>(value);
+        break;
+      case DT_VERDEF:
+        verdef_ = reinterpret_cast<ElfW(Verdef) *>(value);
+        break;
+      case DT_VERDEFNUM:
+        verdefnum_ = dynamic_entry->d_un.d_val;
+        break;
+      case DT_STRSZ:
+        strsize_ = dynamic_entry->d_un.d_val;
+        break;
+      default:
+        // Unrecognized entries explicitly ignored.
+        break;
+    }
+  }
+  if (!hash_ || !dynsym_ || !dynstr_ || !versym_ ||
+      !verdef_ || !verdefnum_ || !strsize_) {
+    RAW_DCHECK(hash_, "invalid VDSO (no DT_HASH)");
+    RAW_DCHECK(dynsym_, "invalid VDSO (no DT_SYMTAB)");
+    RAW_DCHECK(dynstr_, "invalid VDSO (no DT_STRTAB)");
+    RAW_DCHECK(versym_, "invalid VDSO (no DT_VERSYM)");
+    RAW_DCHECK(verdef_, "invalid VDSO (no DT_VERDEF)");
+    RAW_DCHECK(verdefnum_, "invalid VDSO (no DT_VERDEFNUM)");
+    RAW_DCHECK(strsize_, "invalid VDSO (no DT_STRSZ)");
+    // Mark this image as not present. Can not recur infinitely.
+    Init(0);
+    return;
+  }
+}
+
+bool ElfMemImage::LookupSymbol(const char *name,
+                               const char *version,
+                               int type,
+                               SymbolInfo *info) const {
+  for (SymbolIterator it = begin(); it != end(); ++it) {
+    if (strcmp(it->name, name) == 0 && strcmp(it->version, version) == 0 &&
+        CurrentElfClass::ElfType(it->symbol) == type) {
+      if (info) {
+        *info = *it;
+      }
+      return true;
+    }
+  }
+  return false;
+}
+
+bool ElfMemImage::LookupSymbolByAddress(const void *address,
+                                        SymbolInfo *info_out) const {
+  for (SymbolIterator it = begin(); it != end(); ++it) {
+    const char *const symbol_start =
+        reinterpret_cast<const char *>(it->address);
+    const char *const symbol_end = symbol_start + it->symbol->st_size;
+    if (symbol_start <= address && address < symbol_end) {
+      if (info_out) {
+        // Client wants to know details for that symbol (the usual case).
+        if (CurrentElfClass::ElfBind(it->symbol) == STB_GLOBAL) {
+          // Strong symbol; just return it.
+          *info_out = *it;
+          return true;
+        } else {
+          // Weak or local. Record it, but keep looking for a strong one.
+          *info_out = *it;
+        }
+      } else {
+        // Client only cares if there is an overlapping symbol.
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+ElfMemImage::SymbolIterator::SymbolIterator(const void *const image, int index)
+    : index_(index), image_(image) {
+}
+
+const ElfMemImage::SymbolInfo *ElfMemImage::SymbolIterator::operator->() const {
+  return &info_;
+}
+
+const ElfMemImage::SymbolInfo& ElfMemImage::SymbolIterator::operator*() const {
+  return info_;
+}
+
+bool ElfMemImage::SymbolIterator::operator==(const SymbolIterator &rhs) const {
+  return this->image_ == rhs.image_ && this->index_ == rhs.index_;
+}
+
+bool ElfMemImage::SymbolIterator::operator!=(const SymbolIterator &rhs) const {
+  return !(*this == rhs);
+}
+
+ElfMemImage::SymbolIterator &ElfMemImage::SymbolIterator::operator++() {
+  this->Update(1);
+  return *this;
+}
+
+ElfMemImage::SymbolIterator ElfMemImage::begin() const {
+  SymbolIterator it(this, 0);
+  it.Update(0);
+  return it;
+}
+
+ElfMemImage::SymbolIterator ElfMemImage::end() const {
+  return SymbolIterator(this, GetNumSymbols());
+}
+
+void ElfMemImage::SymbolIterator::Update(int increment) {
+  const ElfMemImage *image = reinterpret_cast<const ElfMemImage *>(image_);
+  CHECK(image->IsPresent() || increment == 0);
+  if (!image->IsPresent()) {
+    return;
+  }
+  index_ += increment;
+  if (index_ >= image->GetNumSymbols()) {
+    index_ = image->GetNumSymbols();
+    return;
+  }
+  const ElfW(Sym)    *symbol = image->GetDynsym(index_);
+  const ElfW(Versym) *version_symbol = image->GetVersym(index_);
+  CHECK(symbol && version_symbol);
+  const char *const symbol_name = image->GetDynstr(symbol->st_name);
+  const ElfW(Versym) version_index = version_symbol[0] & VERSYM_VERSION;
+  const ElfW(Verdef) *version_definition = NULL;
+  const char *version_name = "";
+  if (symbol->st_shndx == SHN_UNDEF) {
+    // Undefined symbols reference DT_VERNEED, not DT_VERDEF, and
+    // version_index could well be greater than verdefnum_, so calling
+    // GetVerdef(version_index) may trigger assertion.
+  } else {
+    version_definition = image->GetVerdef(version_index);
+  }
+  if (version_definition) {
+    // I am expecting 1 or 2 auxiliary entries: 1 for the version itself,
+    // optional 2nd if the version has a parent.
+    CHECK_LE(1, version_definition->vd_cnt);
+    CHECK_LE(version_definition->vd_cnt, 2);
+    const ElfW(Verdaux) *version_aux = image->GetVerdefAux(version_definition);
+    version_name = image->GetVerstr(version_aux->vda_name);
+  }
+  info_.name    = symbol_name;
+  info_.version = version_name;
+  info_.address = image->GetSymAddr(symbol);
+  info_.symbol  = symbol;
+}
+
+}  // namespace base
+
+#endif  // HAVE_ELF_MEM_IMAGE
diff --git a/contrib/libs/linuxvdso/original/elf_mem_image.h b/contrib/libs/linuxvdso/original/elf_mem_image.h
index b6619bcab9..580184cb37 100644
--- a/contrib/libs/linuxvdso/original/elf_mem_image.h
+++ b/contrib/libs/linuxvdso/original/elf_mem_image.h
@@ -1,135 +1,135 @@
-#pragma once 
- 
-// Copyright (c) 2008, Google Inc. 
-// 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. 
-//     * Neither the name of Google Inc. nor the names of its 
-// contributors may be used to endorse or promote products derived from 
-// this software without specific prior written permission. 
-// 
-// 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. 
- 
-// --- 
-// Author: Paul Pluzhnikov 
-// 
-// Allow dynamic symbol lookup for in-memory Elf images. 
- 
-#ifndef BASE_ELF_MEM_IMAGE_H_ 
-#define BASE_ELF_MEM_IMAGE_H_ 
- 
-#include "config.h" 
- 
-#include <features.h>   // for __GLIBC__ 
- 
-// Maybe one day we can rewrite this file not to require the elf 
-// symbol extensions in glibc, but for right now we need them. 
-#if (defined(__ELF__) && defined(__GLIBC__) && !defined(__native_client__)) || defined(_musl_) 
- 
-#define HAVE_ELF_MEM_IMAGE 1 
- 
-#include <stdlib.h> 
-#include <link.h>  // for ElfW 
- 
-namespace base { 
- 
-// An in-memory ELF image (may not exist on disk). 
-class ElfMemImage { 
- public: 
-  // Sentinel: there could never be an elf image at this address. 
-  static const void *const kInvalidBase; 
- 
-  // Information about a single vdso symbol. 
-  // All pointers are into .dynsym, .dynstr, or .text of the VDSO. 
-  // Do not free() them or modify through them. 
-  struct SymbolInfo { 
-    const char      *name;      // E.g. "__vdso_getcpu" 
-    const char      *version;   // E.g. "LINUX_2.6", could be "" 
-                                // for unversioned symbol. 
-    const void      *address;   // Relocated symbol address. 
-    const ElfW(Sym) *symbol;    // Symbol in the dynamic symbol table. 
-  }; 
- 
-  // Supports iteration over all dynamic symbols. 
-  class SymbolIterator { 
-   public: 
-    friend class ElfMemImage; 
-    const SymbolInfo *operator->() const; 
-    const SymbolInfo &operator*() const; 
-    SymbolIterator& operator++(); 
-    bool operator!=(const SymbolIterator &rhs) const; 
-    bool operator==(const SymbolIterator &rhs) const; 
-   private: 
-    SymbolIterator(const void *const image, int index); 
-    void Update(int incr); 
-    SymbolInfo info_; 
-    int index_; 
-    const void *const image_; 
-  }; 
- 
- 
-  explicit ElfMemImage(const void *base); 
-  void                 Init(const void *base); 
-  bool                 IsPresent() const { return ehdr_ != NULL; } 
-  const ElfW(Phdr)*    GetPhdr(int index) const; 
-  const ElfW(Sym)*     GetDynsym(int index) const; 
-  const ElfW(Versym)*  GetVersym(int index) const; 
-  const ElfW(Verdef)*  GetVerdef(int index) const; 
-  const ElfW(Verdaux)* GetVerdefAux(const ElfW(Verdef) *verdef) const; 
-  const char*          GetDynstr(ElfW(Word) offset) const; 
-  const void*          GetSymAddr(const ElfW(Sym) *sym) const; 
-  const char*          GetVerstr(ElfW(Word) offset) const; 
-  int                  GetNumSymbols() const; 
- 
-  SymbolIterator begin() const; 
-  SymbolIterator end() const; 
- 
-  // Look up versioned dynamic symbol in the image. 
-  // Returns false if image is not present, or doesn't contain given 
-  // symbol/version/type combination. 
-  // If info_out != NULL, additional details are filled in. 
-  bool LookupSymbol(const char *name, const char *version, 
-                    int symbol_type, SymbolInfo *info_out) const; 
- 
-  // Find info about symbol (if any) which overlaps given address. 
-  // Returns true if symbol was found; false if image isn't present 
-  // or doesn't have a symbol overlapping given address. 
-  // If info_out != NULL, additional details are filled in. 
-  bool LookupSymbolByAddress(const void *address, SymbolInfo *info_out) const; 
- 
- private: 
-  const ElfW(Ehdr) *ehdr_; 
-  const ElfW(Sym) *dynsym_; 
-  const ElfW(Versym) *versym_; 
-  const ElfW(Verdef) *verdef_; 
-  const ElfW(Word) *hash_; 
-  const char *dynstr_; 
-  size_t strsize_; 
-  size_t verdefnum_; 
-  ElfW(Addr) link_base_;     // Link-time base (p_vaddr of first PT_LOAD). 
-}; 
- 
-}  // namespace base 
- 
-#endif  // __ELF__ and __GLIBC__ and !__native_client__ 
- 
-#endif  // BASE_ELF_MEM_IMAGE_H_ 
+#pragma once
+
+// Copyright (c) 2008, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+
+// ---
+// Author: Paul Pluzhnikov
+//
+// Allow dynamic symbol lookup for in-memory Elf images.
+
+#ifndef BASE_ELF_MEM_IMAGE_H_
+#define BASE_ELF_MEM_IMAGE_H_
+
+#include "config.h"
+
+#include <features.h>   // for __GLIBC__
+
+// Maybe one day we can rewrite this file not to require the elf
+// symbol extensions in glibc, but for right now we need them.
+#if (defined(__ELF__) && defined(__GLIBC__) && !defined(__native_client__)) || defined(_musl_)
+
+#define HAVE_ELF_MEM_IMAGE 1
+
+#include <stdlib.h>
+#include <link.h>  // for ElfW
+
+namespace base {
+
+// An in-memory ELF image (may not exist on disk).
+class ElfMemImage {
+ public:
+  // Sentinel: there could never be an elf image at this address.
+  static const void *const kInvalidBase;
+
+  // Information about a single vdso symbol.
+  // All pointers are into .dynsym, .dynstr, or .text of the VDSO.
+  // Do not free() them or modify through them.
+  struct SymbolInfo {
+    const char      *name;      // E.g. "__vdso_getcpu"
+    const char      *version;   // E.g. "LINUX_2.6", could be ""
+                                // for unversioned symbol.
+    const void      *address;   // Relocated symbol address.
+    const ElfW(Sym) *symbol;    // Symbol in the dynamic symbol table.
+  };
+
+  // Supports iteration over all dynamic symbols.
+  class SymbolIterator {
+   public:
+    friend class ElfMemImage;
+    const SymbolInfo *operator->() const;
+    const SymbolInfo &operator*() const;
+    SymbolIterator& operator++();
+    bool operator!=(const SymbolIterator &rhs) const;
+    bool operator==(const SymbolIterator &rhs) const;
+   private:
+    SymbolIterator(const void *const image, int index);
+    void Update(int incr);
+    SymbolInfo info_;
+    int index_;
+    const void *const image_;
+  };
+
+
+  explicit ElfMemImage(const void *base);
+  void                 Init(const void *base);
+  bool                 IsPresent() const { return ehdr_ != NULL; }
+  const ElfW(Phdr)*    GetPhdr(int index) const;
+  const ElfW(Sym)*     GetDynsym(int index) const;
+  const ElfW(Versym)*  GetVersym(int index) const;
+  const ElfW(Verdef)*  GetVerdef(int index) const;
+  const ElfW(Verdaux)* GetVerdefAux(const ElfW(Verdef) *verdef) const;
+  const char*          GetDynstr(ElfW(Word) offset) const;
+  const void*          GetSymAddr(const ElfW(Sym) *sym) const;
+  const char*          GetVerstr(ElfW(Word) offset) const;
+  int                  GetNumSymbols() const;
+
+  SymbolIterator begin() const;
+  SymbolIterator end() const;
+
+  // Look up versioned dynamic symbol in the image.
+  // Returns false if image is not present, or doesn't contain given
+  // symbol/version/type combination.
+  // If info_out != NULL, additional details are filled in.
+  bool LookupSymbol(const char *name, const char *version,
+                    int symbol_type, SymbolInfo *info_out) const;
+
+  // Find info about symbol (if any) which overlaps given address.
+  // Returns true if symbol was found; false if image isn't present
+  // or doesn't have a symbol overlapping given address.
+  // If info_out != NULL, additional details are filled in.
+  bool LookupSymbolByAddress(const void *address, SymbolInfo *info_out) const;
+
+ private:
+  const ElfW(Ehdr) *ehdr_;
+  const ElfW(Sym) *dynsym_;
+  const ElfW(Versym) *versym_;
+  const ElfW(Verdef) *verdef_;
+  const ElfW(Word) *hash_;
+  const char *dynstr_;
+  size_t strsize_;
+  size_t verdefnum_;
+  ElfW(Addr) link_base_;     // Link-time base (p_vaddr of first PT_LOAD).
+};
+
+}  // namespace base
+
+#endif  // __ELF__ and __GLIBC__ and !__native_client__
+
+#endif  // BASE_ELF_MEM_IMAGE_H_
diff --git a/contrib/libs/linuxvdso/original/linux_syscall_support.h b/contrib/libs/linuxvdso/original/linux_syscall_support.h
index 37d182ad3c..0edb951c54 100644
--- a/contrib/libs/linuxvdso/original/linux_syscall_support.h
+++ b/contrib/libs/linuxvdso/original/linux_syscall_support.h
@@ -1,1644 +1,1644 @@
-#pragma once 
- 
-/* Copyright (c) 2005-2008, Google Inc. 
- * 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. 
- *     * Neither the name of Google Inc. nor the names of its 
- * contributors may be used to endorse or promote products derived from 
- * this software without specific prior written permission. 
- * 
- * 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. 
- * 
- * --- 
- * Author: Markus Gutschke 
- */ 
- 
-/* This file includes Linux-specific support functions common to the 
- * coredumper and the thread lister; primarily, this is a collection 
- * of direct system calls, and a couple of symbols missing from 
- * standard header files. 
- * There are a few options that the including file can set to control 
- * the behavior of this file: 
- * 
- * SYS_CPLUSPLUS: 
- *   The entire header file will normally be wrapped in 'extern "C" { }", 
- *   making it suitable for compilation as both C and C++ source. If you 
- *   do not want to do this, you can set the SYS_CPLUSPLUS macro to inhibit 
- *   the wrapping. N.B. doing so will suppress inclusion of all prerequisite 
- *   system header files, too. It is the caller's responsibility to provide 
- *   the necessary definitions. 
- * 
- * SYS_ERRNO: 
- *   All system calls will update "errno" unless overriden by setting the 
- *   SYS_ERRNO macro prior to including this file. SYS_ERRNO should be 
- *   an l-value. 
- * 
- * SYS_INLINE: 
- *   New symbols will be defined "static inline", unless overridden by 
- *   the SYS_INLINE macro. 
- * 
- * SYS_LINUX_SYSCALL_SUPPORT_H 
- *   This macro is used to avoid multiple inclusions of this header file. 
- *   If you need to include this file more than once, make sure to 
- *   unset SYS_LINUX_SYSCALL_SUPPORT_H before each inclusion. 
- * 
- * SYS_PREFIX: 
- *   New system calls will have a prefix of "sys_" unless overridden by 
- *   the SYS_PREFIX macro. Valid values for this macro are [0..9] which 
- *   results in prefixes "sys[0..9]_". It is also possible to set this 
- *   macro to -1, which avoids all prefixes. 
- * 
- * This file defines a few internal symbols that all start with "LSS_". 
- * Do not access these symbols from outside this file. They are not part 
- * of the supported API. 
- * 
- * NOTE: This is a stripped down version of the official opensource 
- * version of linux_syscall_support.h, which lives at 
- *    http://code.google.com/p/linux-syscall-support/ 
- * It includes only the syscalls that are used in perftools, plus a 
- * few extra.  Here's the breakdown: 
- * 1) Perftools uses these: grep -rho 'sys_[a-z0-9_A-Z]* *(' src | sort -u 
- *      sys__exit( 
- *      sys_clone( 
- *      sys_close( 
- *      sys_fcntl( 
- *      sys_fstat( 
- *      sys_futex( 
- *      sys_futex1( 
- *      sys_getcpu( 
- *      sys_getdents( 
- *      sys_getppid( 
- *      sys_gettid( 
- *      sys_lseek( 
- *      sys_mmap( 
- *      sys_mremap( 
- *      sys_munmap( 
- *      sys_open( 
- *      sys_pipe( 
- *      sys_prctl( 
- *      sys_ptrace( 
- *      sys_ptrace_detach( 
- *      sys_read( 
- *      sys_sched_yield( 
- *      sys_sigaction( 
- *      sys_sigaltstack( 
- *      sys_sigdelset( 
- *      sys_sigfillset( 
- *      sys_sigprocmask( 
- *      sys_socket( 
- *      sys_stat( 
- *      sys_waitpid( 
- * 2) These are used as subroutines of the above: 
- *      sys_getpid       -- gettid 
- *      sys_kill         -- ptrace_detach 
- *      sys_restore      -- sigaction 
- *      sys_restore_rt   -- sigaction 
- *      sys_socketcall   -- socket 
- *      sys_wait4        -- waitpid 
- * 3) I left these in even though they're not used.  They either 
- * complement the above (write vs read) or are variants (rt_sigaction): 
- *      sys_fstat64 
- *      sys_getdents64 
- *      sys_llseek 
- *      sys_mmap2 
- *      sys_openat 
- *      sys_rt_sigaction 
- *      sys_rt_sigprocmask 
- *      sys_sigaddset 
- *      sys_sigemptyset 
- *      sys_stat64 
- *      sys_write 
- */ 
-#ifndef SYS_LINUX_SYSCALL_SUPPORT_H 
-#define SYS_LINUX_SYSCALL_SUPPORT_H 
- 
-/* We currently only support x86-32, x86-64, ARM, MIPS, and PPC on Linux. 
- * Porting to other related platforms should not be difficult. 
- */ 
-#if (defined(__i386__) || defined(__x86_64__) || defined(__arm__) || \ 
-     defined(__mips__) || defined(__PPC__)) && defined(__linux) 
- 
-#ifndef SYS_CPLUSPLUS 
-#ifdef __cplusplus 
-/* Some system header files in older versions of gcc neglect to properly 
- * handle being included from C++. As it appears to be harmless to have 
- * multiple nested 'extern "C"' blocks, just add another one here. 
- */ 
-extern "C" { 
-#endif 
- 
-#include <errno.h> 
-#include <signal.h> 
-#include <stdarg.h> 
-#include <string.h> 
-#include <sys/ptrace.h> 
-#include <sys/resource.h> 
-#include <sys/time.h> 
-#include <sys/types.h> 
-#include <syscall.h> 
-#include <unistd.h> 
-#include <linux/unistd.h> 
-#include <endian.h> 
- 
-#ifdef __mips__ 
-/* Include definitions of the ABI currently in use.                          */ 
-#include <sgidefs.h> 
-#endif 
- 
-#endif 
- 
-/* As glibc often provides subtly incompatible data structures (and implicit 
- * wrapper functions that convert them), we provide our own kernel data 
- * structures for use by the system calls. 
- * These structures have been developed by using Linux 2.6.23 headers for 
- * reference. Note though, we do not care about exact API compatibility 
- * with the kernel, and in fact the kernel often does not have a single 
- * API that works across architectures. Instead, we try to mimic the glibc 
- * API where reasonable, and only guarantee ABI compatibility with the 
- * kernel headers. 
- * Most notably, here are a few changes that were made to the structures 
- * defined by kernel headers: 
- * 
- * - we only define structures, but not symbolic names for kernel data 
- *   types. For the latter, we directly use the native C datatype 
- *   (i.e. "unsigned" instead of "mode_t"). 
- * - in a few cases, it is possible to define identical structures for 
- *   both 32bit (e.g. i386) and 64bit (e.g. x86-64) platforms by 
- *   standardizing on the 64bit version of the data types. In particular, 
- *   this means that we use "unsigned" where the 32bit headers say 
- *   "unsigned long". 
- * - overall, we try to minimize the number of cases where we need to 
- *   conditionally define different structures. 
- * - the "struct kernel_sigaction" class of structures have been 
- *   modified to more closely mimic glibc's API by introducing an 
- *   anonymous union for the function pointer. 
- * - a small number of field names had to have an underscore appended to 
- *   them, because glibc defines a global macro by the same name. 
- */ 
- 
-/* include/linux/dirent.h                                                    */ 
-struct kernel_dirent64 { 
-  unsigned long long d_ino; 
-  long long          d_off; 
-  unsigned short     d_reclen; 
-  unsigned char      d_type; 
-  char               d_name[256]; 
-}; 
- 
-/* include/linux/dirent.h                                                    */ 
-struct kernel_dirent { 
-  long               d_ino; 
-  long               d_off; 
-  unsigned short     d_reclen; 
-  char               d_name[256]; 
-}; 
- 
-/* include/linux/time.h                                                      */ 
-struct kernel_timespec { 
-  long               tv_sec; 
-  long               tv_nsec; 
-}; 
- 
-/* include/linux/time.h                                                      */ 
-struct kernel_timeval { 
-  long               tv_sec; 
-  long               tv_usec; 
-}; 
- 
-/* include/linux/resource.h                                                  */ 
-struct kernel_rusage { 
-  struct kernel_timeval ru_utime; 
-  struct kernel_timeval ru_stime; 
-  long               ru_maxrss; 
-  long               ru_ixrss; 
-  long               ru_idrss; 
-  long               ru_isrss; 
-  long               ru_minflt; 
-  long               ru_majflt; 
-  long               ru_nswap; 
-  long               ru_inblock; 
-  long               ru_oublock; 
-  long               ru_msgsnd; 
-  long               ru_msgrcv; 
-  long               ru_nsignals; 
-  long               ru_nvcsw; 
-  long               ru_nivcsw; 
-}; 
- 
-struct siginfo; 
-#if defined(__i386__) || defined(__arm__) || defined(__PPC__) 
- 
-/* include/asm-{arm,i386,mips,ppc}/signal.h                                  */ 
-struct kernel_old_sigaction { 
-  union { 
-    void             (*sa_handler_)(int); 
-    void             (*sa_sigaction_)(int, struct siginfo *, void *); 
-  }; 
-  unsigned long      sa_mask; 
-  unsigned long      sa_flags; 
-  void               (*sa_restorer)(void); 
-} __attribute__((packed,aligned(4))); 
-#elif (defined(__mips__) && _MIPS_SIM == _MIPS_SIM_ABI32) 
-  #define kernel_old_sigaction kernel_sigaction 
-#endif 
- 
-/* Some kernel functions (e.g. sigaction() in 2.6.23) require that the 
- * exactly match the size of the signal set, even though the API was 
- * intended to be extensible. We define our own KERNEL_NSIG to deal with 
- * this. 
- * Please note that glibc provides signals [1.._NSIG-1], whereas the 
- * kernel (and this header) provides the range [1..KERNEL_NSIG]. The 
- * actual number of signals is obviously the same, but the constants 
- * differ by one. 
- */ 
-#ifdef __mips__ 
-#define KERNEL_NSIG 128 
-#else 
-#define KERNEL_NSIG  64 
-#endif 
- 
-/* include/asm-{arm,i386,mips,x86_64}/signal.h                               */ 
-struct kernel_sigset_t { 
-  unsigned long sig[(KERNEL_NSIG + 8*sizeof(unsigned long) - 1)/ 
-                    (8*sizeof(unsigned long))]; 
-}; 
- 
-/* include/asm-{arm,i386,mips,x86_64,ppc}/signal.h                           */ 
-struct kernel_sigaction { 
-#ifdef __mips__ 
-  unsigned long      sa_flags; 
-  union { 
-    void             (*sa_handler_)(int); 
-    void             (*sa_sigaction_)(int, struct siginfo *, void *); 
-  }; 
-  struct kernel_sigset_t sa_mask; 
-#else 
-  union { 
-    void             (*sa_handler_)(int); 
-    void             (*sa_sigaction_)(int, struct siginfo *, void *); 
-  }; 
-  unsigned long      sa_flags; 
-  void               (*sa_restorer)(void); 
-  struct kernel_sigset_t sa_mask; 
-#endif 
-}; 
- 
-/* include/asm-{arm,i386,mips,ppc}/stat.h                                    */ 
-#ifdef __mips__ 
-#if _MIPS_SIM == _MIPS_SIM_ABI64 
-struct kernel_stat { 
-#else 
-struct kernel_stat64 { 
-#endif 
-  unsigned           st_dev; 
-  unsigned           __pad0[3]; 
-  unsigned long long st_ino; 
-  unsigned           st_mode; 
-  unsigned           st_nlink; 
-  unsigned           st_uid; 
-  unsigned           st_gid; 
-  unsigned           st_rdev; 
-  unsigned           __pad1[3]; 
-  long long          st_size; 
-  unsigned           st_atime_; 
-  unsigned           st_atime_nsec_; 
-  unsigned           st_mtime_; 
-  unsigned           st_mtime_nsec_; 
-  unsigned           st_ctime_; 
-  unsigned           st_ctime_nsec_; 
-  unsigned           st_blksize; 
-  unsigned           __pad2; 
-  unsigned long long st_blocks; 
-}; 
-#elif defined __PPC__ 
-struct kernel_stat64 { 
-  unsigned long long st_dev; 
-  unsigned long long st_ino; 
-  unsigned           st_mode; 
-  unsigned           st_nlink; 
-  unsigned           st_uid; 
-  unsigned           st_gid; 
-  unsigned long long st_rdev; 
-  unsigned short int __pad2; 
-  long long          st_size; 
-  long               st_blksize; 
-  long long          st_blocks; 
-  long               st_atime_; 
-  unsigned long      st_atime_nsec_; 
-  long               st_mtime_; 
-  unsigned long      st_mtime_nsec_; 
-  long               st_ctime_; 
-  unsigned long      st_ctime_nsec_; 
-  unsigned long      __unused4; 
-  unsigned long      __unused5; 
-}; 
-#else 
-struct kernel_stat64 { 
-  unsigned long long st_dev; 
-  unsigned char      __pad0[4]; 
-  unsigned           __st_ino; 
-  unsigned           st_mode; 
-  unsigned           st_nlink; 
-  unsigned           st_uid; 
-  unsigned           st_gid; 
-  unsigned long long st_rdev; 
-  unsigned char      __pad3[4]; 
-  long long          st_size; 
-  unsigned           st_blksize; 
-  unsigned long long st_blocks; 
-  unsigned           st_atime_; 
-  unsigned           st_atime_nsec_; 
-  unsigned           st_mtime_; 
-  unsigned           st_mtime_nsec_; 
-  unsigned           st_ctime_; 
-  unsigned           st_ctime_nsec_; 
-  unsigned long long st_ino; 
-}; 
-#endif 
- 
-/* include/asm-{arm,i386,mips,x86_64,ppc}/stat.h                             */ 
-#if defined(__i386__) || defined(__arm__) 
-struct kernel_stat { 
-  /* The kernel headers suggest that st_dev and st_rdev should be 32bit 
-   * quantities encoding 12bit major and 20bit minor numbers in an interleaved 
-   * format. In reality, we do not see useful data in the top bits. So, 
-   * we'll leave the padding in here, until we find a better solution. 
-   */ 
-  unsigned short     st_dev; 
-  short              pad1; 
-  unsigned           st_ino; 
-  unsigned short     st_mode; 
-  unsigned short     st_nlink; 
-  unsigned short     st_uid; 
-  unsigned short     st_gid; 
-  unsigned short     st_rdev; 
-  short              pad2; 
-  unsigned           st_size; 
-  unsigned           st_blksize; 
-  unsigned           st_blocks; 
-  unsigned           st_atime_; 
-  unsigned           st_atime_nsec_; 
-  unsigned           st_mtime_; 
-  unsigned           st_mtime_nsec_; 
-  unsigned           st_ctime_; 
-  unsigned           st_ctime_nsec_; 
-  unsigned           __unused4; 
-  unsigned           __unused5; 
-}; 
-#elif defined(__x86_64__) 
-struct kernel_stat { 
-  unsigned long      st_dev; 
-  unsigned long      st_ino; 
-  unsigned long      st_nlink; 
-  unsigned           st_mode; 
-  unsigned           st_uid; 
-  unsigned           st_gid; 
-  unsigned           __pad0; 
-  unsigned long      st_rdev; 
-  long               st_size; 
-  long               st_blksize; 
-  long               st_blocks; 
-  unsigned long      st_atime_; 
-  unsigned long      st_atime_nsec_; 
-  unsigned long      st_mtime_; 
-  unsigned long      st_mtime_nsec_; 
-  unsigned long      st_ctime_; 
-  unsigned long      st_ctime_nsec_; 
-  long               __unused[3]; 
-}; 
-#elif defined(__PPC__) 
-struct kernel_stat { 
-  unsigned           st_dev; 
-  unsigned long      st_ino;      // ino_t 
-  unsigned long      st_mode;     // mode_t 
-  unsigned short     st_nlink;    // nlink_t 
-  unsigned           st_uid;      // uid_t 
-  unsigned           st_gid;      // gid_t 
-  unsigned           st_rdev; 
-  long               st_size;     // off_t 
-  unsigned long      st_blksize; 
-  unsigned long      st_blocks; 
-  unsigned long      st_atime_; 
-  unsigned long      st_atime_nsec_; 
-  unsigned long      st_mtime_; 
-  unsigned long      st_mtime_nsec_; 
-  unsigned long      st_ctime_; 
-  unsigned long      st_ctime_nsec_; 
-  unsigned long      __unused4; 
-  unsigned long      __unused5; 
-}; 
-#elif (defined(__mips__) && _MIPS_SIM != _MIPS_SIM_ABI64) 
-struct kernel_stat { 
-  unsigned           st_dev; 
-  int                st_pad1[3]; 
-  unsigned           st_ino; 
-  unsigned           st_mode; 
-  unsigned           st_nlink; 
-  unsigned           st_uid; 
-  unsigned           st_gid; 
-  unsigned           st_rdev; 
-  int                st_pad2[2]; 
-  long               st_size; 
-  int                st_pad3; 
-  long               st_atime_; 
-  long               st_atime_nsec_; 
-  long               st_mtime_; 
-  long               st_mtime_nsec_; 
-  long               st_ctime_; 
-  long               st_ctime_nsec_; 
-  int                st_blksize; 
-  int                st_blocks; 
-  int                st_pad4[14]; 
-}; 
-#endif 
- 
- 
-/* Definitions missing from the standard header files                        */ 
-#ifndef O_DIRECTORY 
-#if defined(__arm__) 
-#define O_DIRECTORY             0040000 
-#else 
-#define O_DIRECTORY             0200000 
-#endif 
-#endif 
-#ifndef PR_GET_DUMPABLE 
-#define PR_GET_DUMPABLE         3 
-#endif 
-#ifndef PR_SET_DUMPABLE 
-#define PR_SET_DUMPABLE         4 
-#endif 
-#ifndef AT_FDCWD 
-#define AT_FDCWD                (-100) 
-#endif 
-#ifndef AT_SYMLINK_NOFOLLOW 
-#define AT_SYMLINK_NOFOLLOW     0x100 
-#endif 
-#ifndef AT_REMOVEDIR 
-#define AT_REMOVEDIR            0x200 
-#endif 
-#ifndef MREMAP_FIXED 
-#define MREMAP_FIXED            2 
-#endif 
-#ifndef SA_RESTORER 
-#define SA_RESTORER             0x04000000 
-#endif 
- 
-#if defined(__i386__) 
-#ifndef __NR_rt_sigaction 
-#define __NR_rt_sigaction       174 
-#define __NR_rt_sigprocmask     175 
-#endif 
-#ifndef __NR_stat64 
-#define __NR_stat64             195 
-#endif 
-#ifndef __NR_fstat64 
-#define __NR_fstat64            197 
-#endif 
-#ifndef __NR_getdents64 
-#define __NR_getdents64         220 
-#endif 
-#ifndef __NR_gettid 
-#define __NR_gettid             224 
-#endif 
-#ifndef __NR_futex 
-#define __NR_futex              240 
-#endif 
-#ifndef __NR_openat 
-#define __NR_openat             295 
-#endif 
-#ifndef __NR_getcpu 
-#define __NR_getcpu             318 
-#endif 
-/* End of i386 definitions                                                   */ 
-#elif defined(__arm__) 
-#ifndef __syscall 
-#if defined(__thumb__) || defined(__ARM_EABI__) 
-#define __SYS_REG(name) register long __sysreg __asm__("r6") = __NR_##name; 
-#define __SYS_REG_LIST(regs...) [sysreg] "r" (__sysreg) , ##regs 
-#define __syscall(name) "swi\t0" 
-#define __syscall_safe(name)                     \ 
-  "push  {r7}\n"                                 \ 
-  "mov   r7,%[sysreg]\n"                         \ 
-  __syscall(name)"\n"                            \ 
-  "pop   {r7}" 
-#else 
-#define __SYS_REG(name) 
-#define __SYS_REG_LIST(regs...) regs 
-#define __syscall(name) "swi\t" __sys1(__NR_##name) "" 
-#define __syscall_safe(name) __syscall(name) 
-#endif 
-#endif 
-#ifndef __NR_rt_sigaction 
-#define __NR_rt_sigaction       (__NR_SYSCALL_BASE + 174) 
-#define __NR_rt_sigprocmask     (__NR_SYSCALL_BASE + 175) 
-#endif 
-#ifndef __NR_stat64 
-#define __NR_stat64             (__NR_SYSCALL_BASE + 195) 
-#endif 
-#ifndef __NR_fstat64 
-#define __NR_fstat64            (__NR_SYSCALL_BASE + 197) 
-#endif 
-#ifndef __NR_getdents64 
-#define __NR_getdents64         (__NR_SYSCALL_BASE + 217) 
-#endif 
-#ifndef __NR_gettid 
-#define __NR_gettid             (__NR_SYSCALL_BASE + 224) 
-#endif 
-#ifndef __NR_futex 
-#define __NR_futex              (__NR_SYSCALL_BASE + 240) 
-#endif 
-/* End of ARM definitions                                                  */ 
-#elif defined(__x86_64__) 
-#ifndef __NR_gettid 
-#define __NR_gettid             186 
-#endif 
-#ifndef __NR_futex 
-#define __NR_futex              202 
-#endif 
-#ifndef __NR_getdents64 
-#define __NR_getdents64         217 
-#endif 
-#ifndef __NR_openat 
-#define __NR_openat             257 
-#endif 
-/* End of x86-64 definitions                                                 */ 
-#elif defined(__mips__) 
-#if _MIPS_SIM == _MIPS_SIM_ABI32 
-#ifndef __NR_rt_sigaction 
-#define __NR_rt_sigaction       (__NR_Linux + 194) 
-#define __NR_rt_sigprocmask     (__NR_Linux + 195) 
-#endif 
-#ifndef __NR_stat64 
-#define __NR_stat64             (__NR_Linux + 213) 
-#endif 
-#ifndef __NR_fstat64 
-#define __NR_fstat64            (__NR_Linux + 215) 
-#endif 
-#ifndef __NR_getdents64 
-#define __NR_getdents64         (__NR_Linux + 219) 
-#endif 
-#ifndef __NR_gettid 
-#define __NR_gettid             (__NR_Linux + 222) 
-#endif 
-#ifndef __NR_futex 
-#define __NR_futex              (__NR_Linux + 238) 
-#endif 
-#ifndef __NR_openat 
-#define __NR_openat             (__NR_Linux + 288) 
-#endif 
-#ifndef __NR_fstatat 
-#define __NR_fstatat            (__NR_Linux + 293) 
-#endif 
-#ifndef __NR_getcpu 
-#define __NR_getcpu             (__NR_Linux + 312) 
-#endif 
-/* End of MIPS (old 32bit API) definitions */ 
-#elif  _MIPS_SIM == _MIPS_SIM_ABI64 
-#ifndef __NR_gettid 
-#define __NR_gettid             (__NR_Linux + 178) 
-#endif 
-#ifndef __NR_futex 
-#define __NR_futex              (__NR_Linux + 194) 
-#endif 
-#ifndef __NR_openat 
-#define __NR_openat             (__NR_Linux + 247) 
-#endif 
-#ifndef __NR_fstatat 
-#define __NR_fstatat            (__NR_Linux + 252) 
-#endif 
-#ifndef __NR_getcpu 
-#define __NR_getcpu             (__NR_Linux + 271) 
-#endif 
-/* End of MIPS (64bit API) definitions */ 
-#else 
-#ifndef __NR_gettid 
-#define __NR_gettid             (__NR_Linux + 178) 
-#endif 
-#ifndef __NR_futex 
-#define __NR_futex              (__NR_Linux + 194) 
-#endif 
-#ifndef __NR_openat 
-#define __NR_openat             (__NR_Linux + 251) 
-#endif 
-#ifndef __NR_fstatat 
-#define __NR_fstatat            (__NR_Linux + 256) 
-#endif 
-#ifndef __NR_getcpu 
-#define __NR_getcpu             (__NR_Linux + 275) 
-#endif 
-/* End of MIPS (new 32bit API) definitions                                   */ 
-#endif 
-/* End of MIPS definitions                                                   */ 
-#elif defined(__PPC__) 
-#ifndef __NR_rt_sigaction 
-#define __NR_rt_sigaction       173 
-#define __NR_rt_sigprocmask     174 
-#endif 
-#ifndef __NR_stat64 
-#define __NR_stat64             195 
-#endif 
-#ifndef __NR_fstat64 
-#define __NR_fstat64            197 
-#endif 
-#ifndef __NR_getdents64 
-#define __NR_getdents64         202 
-#endif 
-#ifndef __NR_gettid 
-#define __NR_gettid             207 
-#endif 
-#ifndef __NR_futex 
-#define __NR_futex              221 
-#endif 
-#ifndef __NR_openat 
-#define __NR_openat             286 
-#endif 
-#ifndef __NR_getcpu 
-#define __NR_getcpu             302 
-#endif 
-/* End of powerpc defininitions                                              */ 
-#endif 
- 
- 
-/* After forking, we must make sure to only call system calls.               */ 
-#if __BOUNDED_POINTERS__ 
-  #error "Need to port invocations of syscalls for bounded ptrs" 
-#else 
-  /* The core dumper and the thread lister get executed after threads 
-   * have been suspended. As a consequence, we cannot call any functions 
-   * that acquire locks. Unfortunately, libc wraps most system calls 
-   * (e.g. in order to implement pthread_atfork, and to make calls 
-   * cancellable), which means we cannot call these functions. Instead, 
-   * we have to call syscall() directly. 
-   */ 
-  #undef LSS_ERRNO 
-  #ifdef SYS_ERRNO 
-    /* Allow the including file to override the location of errno. This can 
-     * be useful when using clone() with the CLONE_VM option. 
-     */ 
-    #define LSS_ERRNO SYS_ERRNO 
-  #else 
-    #define LSS_ERRNO errno 
-  #endif 
- 
-  #undef LSS_INLINE 
-  #ifdef SYS_INLINE 
-    #define LSS_INLINE SYS_INLINE 
-  #else 
-    #define LSS_INLINE static inline 
-  #endif 
- 
-  /* Allow the including file to override the prefix used for all new 
-   * system calls. By default, it will be set to "sys_". 
-   */ 
-  #undef LSS_NAME 
-  #ifndef SYS_PREFIX 
-    #define LSS_NAME(name) sys_##name 
-  #elif SYS_PREFIX < 0 
-    #define LSS_NAME(name) name 
-  #elif SYS_PREFIX == 0 
-    #define LSS_NAME(name) sys0_##name 
-  #elif SYS_PREFIX == 1 
-    #define LSS_NAME(name) sys1_##name 
-  #elif SYS_PREFIX == 2 
-    #define LSS_NAME(name) sys2_##name 
-  #elif SYS_PREFIX == 3 
-    #define LSS_NAME(name) sys3_##name 
-  #elif SYS_PREFIX == 4 
-    #define LSS_NAME(name) sys4_##name 
-  #elif SYS_PREFIX == 5 
-    #define LSS_NAME(name) sys5_##name 
-  #elif SYS_PREFIX == 6 
-    #define LSS_NAME(name) sys6_##name 
-  #elif SYS_PREFIX == 7 
-    #define LSS_NAME(name) sys7_##name 
-  #elif SYS_PREFIX == 8 
-    #define LSS_NAME(name) sys8_##name 
-  #elif SYS_PREFIX == 9 
-    #define LSS_NAME(name) sys9_##name 
-  #endif 
- 
-  #undef  LSS_RETURN 
-  #if (defined(__i386__) || defined(__x86_64__) || defined(__arm__)) 
-  /* Failing system calls return a negative result in the range of 
-   * -1..-4095. These are "errno" values with the sign inverted. 
-   */ 
-  #define LSS_RETURN(type, res)                                               \ 
-    do {                                                                      \ 
-      if ((unsigned long)(res) >= (unsigned long)(-4095)) {                   \ 
-        LSS_ERRNO = -(res);                                                   \ 
-        res = -1;                                                             \ 
-      }                                                                       \ 
-      return (type) (res);                                                    \ 
-    } while (0) 
-  #elif defined(__mips__) 
-  /* On MIPS, failing system calls return -1, and set errno in a 
-   * separate CPU register. 
-   */ 
-  #define LSS_RETURN(type, res, err)                                          \ 
-    do {                                                                      \ 
-      if (err) {                                                              \ 
-        LSS_ERRNO = (res);                                                    \ 
-        res = -1;                                                             \ 
-      }                                                                       \ 
-      return (type) (res);                                                    \ 
-    } while (0) 
-  #elif defined(__PPC__) 
-  /* On PPC, failing system calls return -1, and set errno in a 
-   * separate CPU register. See linux/unistd.h. 
-   */ 
-  #define LSS_RETURN(type, res, err)                                          \ 
-   do {                                                                       \ 
-     if (err & 0x10000000 ) {                                                 \ 
-       LSS_ERRNO = (res);                                                     \ 
-       res = -1;                                                              \ 
-     }                                                                        \ 
-     return (type) (res);                                                     \ 
-   } while (0) 
-  #endif 
-  #if defined(__i386__) 
-    #if defined(NO_FRAME_POINTER) && (100 * __GNUC__ + __GNUC_MINOR__ >= 404) 
-      /* This only works for GCC-4.4 and above -- the first version to use 
-         .cfi directives for dwarf unwind info.  */ 
-      #define CFI_ADJUST_CFA_OFFSET(adjust)                                   \ 
-                  ".cfi_adjust_cfa_offset " #adjust "\n" 
-    #else 
-      #define CFI_ADJUST_CFA_OFFSET(adjust) /**/ 
-    #endif 
- 
-    /* In PIC mode (e.g. when building shared libraries), gcc for i386 
-     * reserves ebx. Unfortunately, most distribution ship with implementations 
-     * of _syscallX() which clobber ebx. 
-     * Also, most definitions of _syscallX() neglect to mark "memory" as being 
-     * clobbered. This causes problems with compilers, that do a better job 
-     * at optimizing across __asm__ calls. 
-     * So, we just have to redefine all of the _syscallX() macros. 
-     */ 
-    #undef  LSS_BODY 
-    #define LSS_BODY(type,args...)                                            \ 
-      long __res;                                                             \ 
-      __asm__ __volatile__("push %%ebx\n"                                     \ 
-                           CFI_ADJUST_CFA_OFFSET(4)                           \ 
-                           "movl %2,%%ebx\n"                                  \ 
-                           "int $0x80\n"                                      \ 
-                           "pop %%ebx\n"                                      \ 
-                           CFI_ADJUST_CFA_OFFSET(-4)                          \ 
-                           args                                               \ 
-                           : "esp", "memory");                                \ 
-      LSS_RETURN(type,__res) 
-    #undef  _syscall0 
-    #define _syscall0(type,name)                                              \ 
-      type LSS_NAME(name)(void) {                                             \ 
-        long __res;                                                           \ 
-        __asm__ volatile("int $0x80"                                          \ 
-                         : "=a" (__res)                                       \ 
-                         : "0" (__NR_##name)                                  \ 
-                         : "memory");                                         \ 
-        LSS_RETURN(type,__res);                                               \ 
-      } 
-    #undef  _syscall1 
-    #define _syscall1(type,name,type1,arg1)                                   \ 
-      type LSS_NAME(name)(type1 arg1) {                                       \ 
-        LSS_BODY(type,                                                        \ 
-             : "=a" (__res)                                                   \ 
-             : "0" (__NR_##name), "ri" ((long)(arg1)));                       \ 
-      } 
-    #undef  _syscall2 
-    #define _syscall2(type,name,type1,arg1,type2,arg2)                        \ 
-      type LSS_NAME(name)(type1 arg1,type2 arg2) {                            \ 
-        LSS_BODY(type,                                                        \ 
-             : "=a" (__res)                                                   \ 
-             : "0" (__NR_##name),"ri" ((long)(arg1)), "c" ((long)(arg2)));    \ 
-      } 
-    #undef  _syscall3 
-    #define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3)             \ 
-      type LSS_NAME(name)(type1 arg1,type2 arg2,type3 arg3) {                 \ 
-        LSS_BODY(type,                                                        \ 
-             : "=a" (__res)                                                   \ 
-             : "0" (__NR_##name), "ri" ((long)(arg1)), "c" ((long)(arg2)),    \ 
-               "d" ((long)(arg3)));                                           \ 
-      } 
-    #undef  _syscall4 
-    #define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4)  \ 
-      type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4) {   \ 
-        LSS_BODY(type,                                                        \ 
-             : "=a" (__res)                                                   \ 
-             : "0" (__NR_##name), "ri" ((long)(arg1)), "c" ((long)(arg2)),    \ 
-               "d" ((long)(arg3)),"S" ((long)(arg4)));                        \ 
-      } 
-    #undef  _syscall5 
-    #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4,  \ 
-                      type5,arg5)                                             \ 
-      type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4,     \ 
-                          type5 arg5) {                                       \ 
-        long __res;                                                           \ 
-        __asm__ __volatile__("push %%ebx\n"                                   \ 
-                             "movl %2,%%ebx\n"                                \ 
-                             "movl %1,%%eax\n"                                \ 
-                             "int  $0x80\n"                                   \ 
-                             "pop  %%ebx"                                     \ 
-                             : "=a" (__res)                                   \ 
-                             : "i" (__NR_##name), "ri" ((long)(arg1)),        \ 
-                               "c" ((long)(arg2)), "d" ((long)(arg3)),        \ 
-                               "S" ((long)(arg4)), "D" ((long)(arg5))         \ 
-                             : "esp", "memory");                              \ 
-        LSS_RETURN(type,__res);                                               \ 
-      } 
-    #undef  _syscall6 
-    #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4,  \ 
-                      type5,arg5,type6,arg6)                                  \ 
-      type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4,     \ 
-                          type5 arg5, type6 arg6) {                           \ 
-        long __res;                                                           \ 
-        struct { long __a1; long __a6; } __s = { (long)arg1, (long) arg6 };   \ 
-        __asm__ __volatile__("push %%ebp\n"                                   \ 
-                             "push %%ebx\n"                                   \ 
-                             "movl 4(%2),%%ebp\n"                             \ 
-                             "movl 0(%2), %%ebx\n"                            \ 
-                             "movl %1,%%eax\n"                                \ 
-                             "int  $0x80\n"                                   \ 
-                             "pop  %%ebx\n"                                   \ 
-                             "pop  %%ebp"                                     \ 
-                             : "=a" (__res)                                   \ 
-                             : "i" (__NR_##name),  "0" ((long)(&__s)),        \ 
-                               "c" ((long)(arg2)), "d" ((long)(arg3)),        \ 
-                               "S" ((long)(arg4)), "D" ((long)(arg5))         \ 
-                             : "esp", "memory");                              \ 
-        LSS_RETURN(type,__res);                                               \ 
-      } 
-    LSS_INLINE int LSS_NAME(clone)(int (*fn)(void *), void *child_stack, 
-                                   int flags, void *arg, int *parent_tidptr, 
-                                   void *newtls, int *child_tidptr) { 
-      long __res; 
-      __asm__ __volatile__(/* if (fn == NULL) 
-                            *   return -EINVAL; 
-                            */ 
-                           "movl   %3,%%ecx\n" 
-                           "jecxz  1f\n" 
- 
-                           /* if (child_stack == NULL) 
-                            *   return -EINVAL; 
-                            */ 
-                           "movl   %4,%%ecx\n" 
-                           "jecxz  1f\n" 
- 
-                           /* Set up alignment of the child stack: 
-                            * child_stack = (child_stack & ~0xF) - 20; 
-                            */ 
-                           "andl   $-16,%%ecx\n" 
-                           "subl   $20,%%ecx\n" 
- 
-                           /* Push "arg" and "fn" onto the stack that will be 
-                            * used by the child. 
-                            */ 
-                           "movl   %6,%%eax\n" 
-                           "movl   %%eax,4(%%ecx)\n" 
-                           "movl   %3,%%eax\n" 
-                           "movl   %%eax,(%%ecx)\n" 
- 
-                           /* %eax = syscall(%eax = __NR_clone, 
-                            *                %ebx = flags, 
-                            *                %ecx = child_stack, 
-                            *                %edx = parent_tidptr, 
-                            *                %esi = newtls, 
-                            *                %edi = child_tidptr) 
-                            * Also, make sure that %ebx gets preserved as it is 
-                            * used in PIC mode. 
-                            */ 
-                           "movl   %8,%%esi\n" 
-                           "movl   %7,%%edx\n" 
-                           "movl   %5,%%eax\n" 
-                           "movl   %9,%%edi\n" 
-                           "pushl  %%ebx\n" 
-                           "movl   %%eax,%%ebx\n" 
-                           "movl   %2,%%eax\n" 
-                           "int    $0x80\n" 
- 
-                           /* In the parent: restore %ebx 
-                            * In the child:  move "fn" into %ebx 
-                            */ 
-                           "popl   %%ebx\n" 
- 
-                           /* if (%eax != 0) 
-                            *   return %eax; 
-                            */ 
-                           "test   %%eax,%%eax\n" 
-                           "jnz    1f\n" 
- 
-                           /* In the child, now. Terminate frame pointer chain. 
-                            */ 
-                           "movl   $0,%%ebp\n" 
- 
-                           /* Call "fn". "arg" is already on the stack. 
-                            */ 
-                           "call   *%%ebx\n" 
- 
-                           /* Call _exit(%ebx). Unfortunately older versions 
-                            * of gcc restrict the number of arguments that can 
-                            * be passed to asm(). So, we need to hard-code the 
-                            * system call number. 
-                            */ 
-                           "movl   %%eax,%%ebx\n" 
-                           "movl   $1,%%eax\n" 
-                           "int    $0x80\n" 
- 
-                           /* Return to parent. 
-                            */ 
-                         "1:\n" 
-                           : "=a" (__res) 
-                           : "0"(-EINVAL), "i"(__NR_clone), 
-                             "m"(fn), "m"(child_stack), "m"(flags), "m"(arg), 
-                             "m"(parent_tidptr), "m"(newtls), "m"(child_tidptr) 
-                           : "esp", "memory", "ecx", "edx", "esi", "edi"); 
-      LSS_RETURN(int, __res); 
-    } 
- 
-    LSS_INLINE void (*LSS_NAME(restore_rt)(void))(void) { 
-      /* On i386, the kernel does not know how to return from a signal 
-       * handler. Instead, it relies on user space to provide a 
-       * restorer function that calls the {rt_,}sigreturn() system call. 
-       * Unfortunately, we cannot just reference the glibc version of this 
-       * function, as glibc goes out of its way to make it inaccessible. 
-       */ 
-      void (*res)(void); 
-      __asm__ __volatile__("call   2f\n" 
-                         "0:.align 16\n" 
-                         "1:movl   %1,%%eax\n" 
-                           "int    $0x80\n" 
-                         "2:popl   %0\n" 
-                           "addl   $(1b-0b),%0\n" 
-                           : "=a" (res) 
-                           : "i"  (__NR_rt_sigreturn)); 
-      return res; 
-    } 
-    LSS_INLINE void (*LSS_NAME(restore)(void))(void) { 
-      /* On i386, the kernel does not know how to return from a signal 
-       * handler. Instead, it relies on user space to provide a 
-       * restorer function that calls the {rt_,}sigreturn() system call. 
-       * Unfortunately, we cannot just reference the glibc version of this 
-       * function, as glibc goes out of its way to make it inaccessible. 
-       */ 
-      void (*res)(void); 
-      __asm__ __volatile__("call   2f\n" 
-                         "0:.align 16\n" 
-                         "1:pop    %%eax\n" 
-                           "movl   %1,%%eax\n" 
-                           "int    $0x80\n" 
-                         "2:popl   %0\n" 
-                           "addl   $(1b-0b),%0\n" 
-                           : "=a" (res) 
-                           : "i"  (__NR_sigreturn)); 
-      return res; 
-    } 
-  #elif defined(__x86_64__) 
-    /* There are no known problems with any of the _syscallX() macros 
-     * currently shipping for x86_64, but we still need to be able to define 
-     * our own version so that we can override the location of the errno 
-     * location (e.g. when using the clone() system call with the CLONE_VM 
-     * option). 
-     */ 
-    #undef  LSS_BODY 
-    #define LSS_BODY(type,name, ...)                                          \ 
-          long __res;                                                         \ 
-          __asm__ __volatile__("syscall" : "=a" (__res) : "0" (__NR_##name),  \ 
-            ##__VA_ARGS__ : "r11", "rcx", "memory");                          \ 
-          LSS_RETURN(type, __res) 
-    #undef _syscall0 
-    #define _syscall0(type,name)                                              \ 
-      type LSS_NAME(name)() {                                                 \ 
-        LSS_BODY(type, name);                                                 \ 
-      } 
-    #undef _syscall1 
-    #define _syscall1(type,name,type1,arg1)                                   \ 
-      type LSS_NAME(name)(type1 arg1) {                                       \ 
-        LSS_BODY(type, name, "D" ((long)(arg1)));                             \ 
-      } 
-    #undef _syscall2 
-    #define _syscall2(type,name,type1,arg1,type2,arg2)                        \ 
-      type LSS_NAME(name)(type1 arg1, type2 arg2) {                           \ 
-        LSS_BODY(type, name, "D" ((long)(arg1)), "S" ((long)(arg2)));         \ 
-      } 
-    #undef _syscall3 
-    #define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3)             \ 
-      type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3) {               \ 
-        LSS_BODY(type, name, "D" ((long)(arg1)), "S" ((long)(arg2)),          \ 
-                             "d" ((long)(arg3)));                             \ 
-      } 
-    #undef _syscall4 
-    #define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4)  \ 
-      type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4) {   \ 
-          long __res;                                                         \ 
-          __asm__ __volatile__("movq %5,%%r10; syscall" :                     \ 
-            "=a" (__res) : "0" (__NR_##name),                                 \ 
-            "D" ((long)(arg1)), "S" ((long)(arg2)), "d" ((long)(arg3)),       \ 
-            "r" ((long)(arg4)) : "r10", "r11", "rcx", "memory");              \ 
-          LSS_RETURN(type, __res);                                            \ 
-      } 
-    #undef _syscall5 
-    #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4,  \ 
-                      type5,arg5)                                             \ 
-      type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4,     \ 
-                          type5 arg5) {                                       \ 
-          long __res;                                                         \ 
-          __asm__ __volatile__("movq %5,%%r10; movq %6,%%r8; syscall" :       \ 
-            "=a" (__res) : "0" (__NR_##name),                                 \ 
-            "D" ((long)(arg1)), "S" ((long)(arg2)), "d" ((long)(arg3)),       \ 
-            "r" ((long)(arg4)), "r" ((long)(arg5)) :                          \ 
-            "r8", "r10", "r11", "rcx", "memory");                             \ 
-          LSS_RETURN(type, __res);                                            \ 
-      } 
-    #undef _syscall6 
-    #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4,  \ 
-                      type5,arg5,type6,arg6)                                  \ 
-      type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4,     \ 
-                          type5 arg5, type6 arg6) {                           \ 
-          long __res;                                                         \ 
-          __asm__ __volatile__("movq %5,%%r10; movq %6,%%r8; movq %7,%%r9;"   \ 
-                               "syscall" :                                    \ 
-            "=a" (__res) : "0" (__NR_##name),                                 \ 
-            "D" ((long)(arg1)), "S" ((long)(arg2)), "d" ((long)(arg3)),       \ 
-            "r" ((long)(arg4)), "r" ((long)(arg5)), "r" ((long)(arg6)) :      \ 
-            "r8", "r9", "r10", "r11", "rcx", "memory");                       \ 
-          LSS_RETURN(type, __res);                                            \ 
-      } 
-    LSS_INLINE int LSS_NAME(clone)(int (*fn)(void *), void *child_stack, 
-                                   int flags, void *arg, int *parent_tidptr, 
-                                   void *newtls, int *child_tidptr) { 
-      long __res; 
-      { 
-        __asm__ __volatile__(/* if (fn == NULL) 
-                              *   return -EINVAL; 
-                              */ 
-                             "testq  %4,%4\n" 
-                             "jz     1f\n" 
- 
-                             /* if (child_stack == NULL) 
-                              *   return -EINVAL; 
-                              */ 
-                             "testq  %5,%5\n" 
-                             "jz     1f\n" 
- 
-                             /* Set up alignment of the child stack: 
-                              * child_stack = (child_stack & ~0xF) - 16; 
-                              */ 
-                             "andq   $-16,%5\n" 
-                             "subq   $16,%5\n" 
- 
-                             /* Push "arg" and "fn" onto the stack that will be 
-                              * used by the child. 
-                              */ 
-                             "movq   %7,8(%5)\n" 
-                             "movq   %4,0(%5)\n" 
- 
-                             /* %rax = syscall(%rax = __NR_clone, 
-                              *                %rdi = flags, 
-                              *                %rsi = child_stack, 
-                              *                %rdx = parent_tidptr, 
-                              *                %r8  = new_tls, 
-                              *                %r10 = child_tidptr) 
-                              */ 
-                             "movq   %2,%%rax\n" 
-                             "movq   %9,%%r8\n" 
-                             "movq   %10,%%r10\n" 
-                             "syscall\n" 
- 
-                             /* if (%rax != 0) 
-                              *   return; 
-                              */ 
-                             "testq  %%rax,%%rax\n" 
-                             "jnz    1f\n" 
- 
-                             /* In the child. Terminate frame pointer chain. 
-                              */ 
-                             "xorq   %%rbp,%%rbp\n" 
- 
-                             /* Call "fn(arg)". 
-                              */ 
-                             "popq   %%rax\n" 
-                             "popq   %%rdi\n" 
-                             "call   *%%rax\n" 
- 
-                             /* Call _exit(%ebx). 
-                              */ 
-                             "movq   %%rax,%%rdi\n" 
-                             "movq   %3,%%rax\n" 
-                             "syscall\n" 
- 
-                             /* Return to parent. 
-                              */ 
-                           "1:\n" 
-                             : "=a" (__res) 
-                             : "0"(-EINVAL), "i"(__NR_clone), "i"(__NR_exit), 
-                               "r"(fn), "S"(child_stack), "D"(flags), "r"(arg), 
-                               "d"(parent_tidptr), "g"(newtls), "g"(child_tidptr) 
-                             : "rsp", "memory", "r8", "r10", "r11", "rcx"); 
-      } 
-      LSS_RETURN(int, __res); 
-    } 
- 
-    LSS_INLINE void (*LSS_NAME(restore_rt)(void))(void) { 
-      /* On x86-64, the kernel does not know how to return from 
-       * a signal handler. Instead, it relies on user space to provide a 
-       * restorer function that calls the rt_sigreturn() system call. 
-       * Unfortunately, we cannot just reference the glibc version of this 
-       * function, as glibc goes out of its way to make it inaccessible. 
-       */ 
-      void (*res)(void); 
-      __asm__ __volatile__("call   2f\n" 
-                         "0:.align 16\n" 
-                         "1:movq   %1,%%rax\n" 
-                           "syscall\n" 
-                         "2:popq   %0\n" 
-                           "addq   $(1b-0b),%0\n" 
-                           : "=a" (res) 
-                           : "i"  (__NR_rt_sigreturn)); 
-      return res; 
-    } 
-  #elif defined(__arm__) 
-    /* Most definitions of _syscallX() neglect to mark "memory" as being 
-     * clobbered. This causes problems with compilers, that do a better job 
-     * at optimizing across __asm__ calls. 
-     * So, we just have to redefine all fo the _syscallX() macros. 
-     */ 
-    #undef LSS_REG 
-    #define LSS_REG(r,a) register long __r##r __asm__("r"#r) = (long)a 
- 
-    /* r0..r3 are scratch registers and not preserved across function 
-     * calls.  We need to first evaluate the first 4 syscall arguments 
-     * and store them on stack.  They must be loaded into r0..r3 after 
-     * all function calls to avoid r0..r3 being clobbered. 
-     */ 
-    #undef LSS_SAVE_ARG 
-    #define LSS_SAVE_ARG(r,a) long __tmp##r = (long)a 
-    #undef LSS_LOAD_ARG 
-    #define LSS_LOAD_ARG(r) register long __r##r __asm__("r"#r) = __tmp##r 
- 
-    #undef  LSS_BODY 
-    #define LSS_BODY(type, name, args...)                                     \ 
+#pragma once
+
+/* Copyright (c) 2005-2008, Google Inc.
+ * 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.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * 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.
+ *
+ * ---
+ * Author: Markus Gutschke
+ */
+
+/* This file includes Linux-specific support functions common to the
+ * coredumper and the thread lister; primarily, this is a collection
+ * of direct system calls, and a couple of symbols missing from
+ * standard header files.
+ * There are a few options that the including file can set to control
+ * the behavior of this file:
+ *
+ * SYS_CPLUSPLUS:
+ *   The entire header file will normally be wrapped in 'extern "C" { }",
+ *   making it suitable for compilation as both C and C++ source. If you
+ *   do not want to do this, you can set the SYS_CPLUSPLUS macro to inhibit
+ *   the wrapping. N.B. doing so will suppress inclusion of all prerequisite
+ *   system header files, too. It is the caller's responsibility to provide
+ *   the necessary definitions.
+ *
+ * SYS_ERRNO:
+ *   All system calls will update "errno" unless overriden by setting the
+ *   SYS_ERRNO macro prior to including this file. SYS_ERRNO should be
+ *   an l-value.
+ *
+ * SYS_INLINE:
+ *   New symbols will be defined "static inline", unless overridden by
+ *   the SYS_INLINE macro.
+ *
+ * SYS_LINUX_SYSCALL_SUPPORT_H
+ *   This macro is used to avoid multiple inclusions of this header file.
+ *   If you need to include this file more than once, make sure to
+ *   unset SYS_LINUX_SYSCALL_SUPPORT_H before each inclusion.
+ *
+ * SYS_PREFIX:
+ *   New system calls will have a prefix of "sys_" unless overridden by
+ *   the SYS_PREFIX macro. Valid values for this macro are [0..9] which
+ *   results in prefixes "sys[0..9]_". It is also possible to set this
+ *   macro to -1, which avoids all prefixes.
+ *
+ * This file defines a few internal symbols that all start with "LSS_".
+ * Do not access these symbols from outside this file. They are not part
+ * of the supported API.
+ *
+ * NOTE: This is a stripped down version of the official opensource
+ * version of linux_syscall_support.h, which lives at
+ *    http://code.google.com/p/linux-syscall-support/
+ * It includes only the syscalls that are used in perftools, plus a
+ * few extra.  Here's the breakdown:
+ * 1) Perftools uses these: grep -rho 'sys_[a-z0-9_A-Z]* *(' src | sort -u
+ *      sys__exit(
+ *      sys_clone(
+ *      sys_close(
+ *      sys_fcntl(
+ *      sys_fstat(
+ *      sys_futex(
+ *      sys_futex1(
+ *      sys_getcpu(
+ *      sys_getdents(
+ *      sys_getppid(
+ *      sys_gettid(
+ *      sys_lseek(
+ *      sys_mmap(
+ *      sys_mremap(
+ *      sys_munmap(
+ *      sys_open(
+ *      sys_pipe(
+ *      sys_prctl(
+ *      sys_ptrace(
+ *      sys_ptrace_detach(
+ *      sys_read(
+ *      sys_sched_yield(
+ *      sys_sigaction(
+ *      sys_sigaltstack(
+ *      sys_sigdelset(
+ *      sys_sigfillset(
+ *      sys_sigprocmask(
+ *      sys_socket(
+ *      sys_stat(
+ *      sys_waitpid(
+ * 2) These are used as subroutines of the above:
+ *      sys_getpid       -- gettid
+ *      sys_kill         -- ptrace_detach
+ *      sys_restore      -- sigaction
+ *      sys_restore_rt   -- sigaction
+ *      sys_socketcall   -- socket
+ *      sys_wait4        -- waitpid
+ * 3) I left these in even though they're not used.  They either
+ * complement the above (write vs read) or are variants (rt_sigaction):
+ *      sys_fstat64
+ *      sys_getdents64
+ *      sys_llseek
+ *      sys_mmap2
+ *      sys_openat
+ *      sys_rt_sigaction
+ *      sys_rt_sigprocmask
+ *      sys_sigaddset
+ *      sys_sigemptyset
+ *      sys_stat64
+ *      sys_write
+ */
+#ifndef SYS_LINUX_SYSCALL_SUPPORT_H
+#define SYS_LINUX_SYSCALL_SUPPORT_H
+
+/* We currently only support x86-32, x86-64, ARM, MIPS, and PPC on Linux.
+ * Porting to other related platforms should not be difficult.
+ */
+#if (defined(__i386__) || defined(__x86_64__) || defined(__arm__) || \
+     defined(__mips__) || defined(__PPC__)) && defined(__linux)
+
+#ifndef SYS_CPLUSPLUS
+#ifdef __cplusplus
+/* Some system header files in older versions of gcc neglect to properly
+ * handle being included from C++. As it appears to be harmless to have
+ * multiple nested 'extern "C"' blocks, just add another one here.
+ */
+extern "C" {
+#endif
+
+#include <errno.h>
+#include <signal.h>
+#include <stdarg.h>
+#include <string.h>
+#include <sys/ptrace.h>
+#include <sys/resource.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <syscall.h>
+#include <unistd.h>
+#include <linux/unistd.h>
+#include <endian.h>
+
+#ifdef __mips__
+/* Include definitions of the ABI currently in use.                          */
+#include <sgidefs.h>
+#endif
+
+#endif
+
+/* As glibc often provides subtly incompatible data structures (and implicit
+ * wrapper functions that convert them), we provide our own kernel data
+ * structures for use by the system calls.
+ * These structures have been developed by using Linux 2.6.23 headers for
+ * reference. Note though, we do not care about exact API compatibility
+ * with the kernel, and in fact the kernel often does not have a single
+ * API that works across architectures. Instead, we try to mimic the glibc
+ * API where reasonable, and only guarantee ABI compatibility with the
+ * kernel headers.
+ * Most notably, here are a few changes that were made to the structures
+ * defined by kernel headers:
+ *
+ * - we only define structures, but not symbolic names for kernel data
+ *   types. For the latter, we directly use the native C datatype
+ *   (i.e. "unsigned" instead of "mode_t").
+ * - in a few cases, it is possible to define identical structures for
+ *   both 32bit (e.g. i386) and 64bit (e.g. x86-64) platforms by
+ *   standardizing on the 64bit version of the data types. In particular,
+ *   this means that we use "unsigned" where the 32bit headers say
+ *   "unsigned long".
+ * - overall, we try to minimize the number of cases where we need to
+ *   conditionally define different structures.
+ * - the "struct kernel_sigaction" class of structures have been
+ *   modified to more closely mimic glibc's API by introducing an
+ *   anonymous union for the function pointer.
+ * - a small number of field names had to have an underscore appended to
+ *   them, because glibc defines a global macro by the same name.
+ */
+
+/* include/linux/dirent.h                                                    */
+struct kernel_dirent64 {
+  unsigned long long d_ino;
+  long long          d_off;
+  unsigned short     d_reclen;
+  unsigned char      d_type;
+  char               d_name[256];
+};
+
+/* include/linux/dirent.h                                                    */
+struct kernel_dirent {
+  long               d_ino;
+  long               d_off;
+  unsigned short     d_reclen;
+  char               d_name[256];
+};
+
+/* include/linux/time.h                                                      */
+struct kernel_timespec {
+  long               tv_sec;
+  long               tv_nsec;
+};
+
+/* include/linux/time.h                                                      */
+struct kernel_timeval {
+  long               tv_sec;
+  long               tv_usec;
+};
+
+/* include/linux/resource.h                                                  */
+struct kernel_rusage {
+  struct kernel_timeval ru_utime;
+  struct kernel_timeval ru_stime;
+  long               ru_maxrss;
+  long               ru_ixrss;
+  long               ru_idrss;
+  long               ru_isrss;
+  long               ru_minflt;
+  long               ru_majflt;
+  long               ru_nswap;
+  long               ru_inblock;
+  long               ru_oublock;
+  long               ru_msgsnd;
+  long               ru_msgrcv;
+  long               ru_nsignals;
+  long               ru_nvcsw;
+  long               ru_nivcsw;
+};
+
+struct siginfo;
+#if defined(__i386__) || defined(__arm__) || defined(__PPC__)
+
+/* include/asm-{arm,i386,mips,ppc}/signal.h                                  */
+struct kernel_old_sigaction {
+  union {
+    void             (*sa_handler_)(int);
+    void             (*sa_sigaction_)(int, struct siginfo *, void *);
+  };
+  unsigned long      sa_mask;
+  unsigned long      sa_flags;
+  void               (*sa_restorer)(void);
+} __attribute__((packed,aligned(4)));
+#elif (defined(__mips__) && _MIPS_SIM == _MIPS_SIM_ABI32)
+  #define kernel_old_sigaction kernel_sigaction
+#endif
+
+/* Some kernel functions (e.g. sigaction() in 2.6.23) require that the
+ * exactly match the size of the signal set, even though the API was
+ * intended to be extensible. We define our own KERNEL_NSIG to deal with
+ * this.
+ * Please note that glibc provides signals [1.._NSIG-1], whereas the
+ * kernel (and this header) provides the range [1..KERNEL_NSIG]. The
+ * actual number of signals is obviously the same, but the constants
+ * differ by one.
+ */
+#ifdef __mips__
+#define KERNEL_NSIG 128
+#else
+#define KERNEL_NSIG  64
+#endif
+
+/* include/asm-{arm,i386,mips,x86_64}/signal.h                               */
+struct kernel_sigset_t {
+  unsigned long sig[(KERNEL_NSIG + 8*sizeof(unsigned long) - 1)/
+                    (8*sizeof(unsigned long))];
+};
+
+/* include/asm-{arm,i386,mips,x86_64,ppc}/signal.h                           */
+struct kernel_sigaction {
+#ifdef __mips__
+  unsigned long      sa_flags;
+  union {
+    void             (*sa_handler_)(int);
+    void             (*sa_sigaction_)(int, struct siginfo *, void *);
+  };
+  struct kernel_sigset_t sa_mask;
+#else
+  union {
+    void             (*sa_handler_)(int);
+    void             (*sa_sigaction_)(int, struct siginfo *, void *);
+  };
+  unsigned long      sa_flags;
+  void               (*sa_restorer)(void);
+  struct kernel_sigset_t sa_mask;
+#endif
+};
+
+/* include/asm-{arm,i386,mips,ppc}/stat.h                                    */
+#ifdef __mips__
+#if _MIPS_SIM == _MIPS_SIM_ABI64
+struct kernel_stat {
+#else
+struct kernel_stat64 {
+#endif
+  unsigned           st_dev;
+  unsigned           __pad0[3];
+  unsigned long long st_ino;
+  unsigned           st_mode;
+  unsigned           st_nlink;
+  unsigned           st_uid;
+  unsigned           st_gid;
+  unsigned           st_rdev;
+  unsigned           __pad1[3];
+  long long          st_size;
+  unsigned           st_atime_;
+  unsigned           st_atime_nsec_;
+  unsigned           st_mtime_;
+  unsigned           st_mtime_nsec_;
+  unsigned           st_ctime_;
+  unsigned           st_ctime_nsec_;
+  unsigned           st_blksize;
+  unsigned           __pad2;
+  unsigned long long st_blocks;
+};
+#elif defined __PPC__
+struct kernel_stat64 {
+  unsigned long long st_dev;
+  unsigned long long st_ino;
+  unsigned           st_mode;
+  unsigned           st_nlink;
+  unsigned           st_uid;
+  unsigned           st_gid;
+  unsigned long long st_rdev;
+  unsigned short int __pad2;
+  long long          st_size;
+  long               st_blksize;
+  long long          st_blocks;
+  long               st_atime_;
+  unsigned long      st_atime_nsec_;
+  long               st_mtime_;
+  unsigned long      st_mtime_nsec_;
+  long               st_ctime_;
+  unsigned long      st_ctime_nsec_;
+  unsigned long      __unused4;
+  unsigned long      __unused5;
+};
+#else
+struct kernel_stat64 {
+  unsigned long long st_dev;
+  unsigned char      __pad0[4];
+  unsigned           __st_ino;
+  unsigned           st_mode;
+  unsigned           st_nlink;
+  unsigned           st_uid;
+  unsigned           st_gid;
+  unsigned long long st_rdev;
+  unsigned char      __pad3[4];
+  long long          st_size;
+  unsigned           st_blksize;
+  unsigned long long st_blocks;
+  unsigned           st_atime_;
+  unsigned           st_atime_nsec_;
+  unsigned           st_mtime_;
+  unsigned           st_mtime_nsec_;
+  unsigned           st_ctime_;
+  unsigned           st_ctime_nsec_;
+  unsigned long long st_ino;
+};
+#endif
+
+/* include/asm-{arm,i386,mips,x86_64,ppc}/stat.h                             */
+#if defined(__i386__) || defined(__arm__)
+struct kernel_stat {
+  /* The kernel headers suggest that st_dev and st_rdev should be 32bit
+   * quantities encoding 12bit major and 20bit minor numbers in an interleaved
+   * format. In reality, we do not see useful data in the top bits. So,
+   * we'll leave the padding in here, until we find a better solution.
+   */
+  unsigned short     st_dev;
+  short              pad1;
+  unsigned           st_ino;
+  unsigned short     st_mode;
+  unsigned short     st_nlink;
+  unsigned short     st_uid;
+  unsigned short     st_gid;
+  unsigned short     st_rdev;
+  short              pad2;
+  unsigned           st_size;
+  unsigned           st_blksize;
+  unsigned           st_blocks;
+  unsigned           st_atime_;
+  unsigned           st_atime_nsec_;
+  unsigned           st_mtime_;
+  unsigned           st_mtime_nsec_;
+  unsigned           st_ctime_;
+  unsigned           st_ctime_nsec_;
+  unsigned           __unused4;
+  unsigned           __unused5;
+};
+#elif defined(__x86_64__)
+struct kernel_stat {
+  unsigned long      st_dev;
+  unsigned long      st_ino;
+  unsigned long      st_nlink;
+  unsigned           st_mode;
+  unsigned           st_uid;
+  unsigned           st_gid;
+  unsigned           __pad0;
+  unsigned long      st_rdev;
+  long               st_size;
+  long               st_blksize;
+  long               st_blocks;
+  unsigned long      st_atime_;
+  unsigned long      st_atime_nsec_;
+  unsigned long      st_mtime_;
+  unsigned long      st_mtime_nsec_;
+  unsigned long      st_ctime_;
+  unsigned long      st_ctime_nsec_;
+  long               __unused[3];
+};
+#elif defined(__PPC__)
+struct kernel_stat {
+  unsigned           st_dev;
+  unsigned long      st_ino;      // ino_t
+  unsigned long      st_mode;     // mode_t
+  unsigned short     st_nlink;    // nlink_t
+  unsigned           st_uid;      // uid_t
+  unsigned           st_gid;      // gid_t
+  unsigned           st_rdev;
+  long               st_size;     // off_t
+  unsigned long      st_blksize;
+  unsigned long      st_blocks;
+  unsigned long      st_atime_;
+  unsigned long      st_atime_nsec_;
+  unsigned long      st_mtime_;
+  unsigned long      st_mtime_nsec_;
+  unsigned long      st_ctime_;
+  unsigned long      st_ctime_nsec_;
+  unsigned long      __unused4;
+  unsigned long      __unused5;
+};
+#elif (defined(__mips__) && _MIPS_SIM != _MIPS_SIM_ABI64)
+struct kernel_stat {
+  unsigned           st_dev;
+  int                st_pad1[3];
+  unsigned           st_ino;
+  unsigned           st_mode;
+  unsigned           st_nlink;
+  unsigned           st_uid;
+  unsigned           st_gid;
+  unsigned           st_rdev;
+  int                st_pad2[2];
+  long               st_size;
+  int                st_pad3;
+  long               st_atime_;
+  long               st_atime_nsec_;
+  long               st_mtime_;
+  long               st_mtime_nsec_;
+  long               st_ctime_;
+  long               st_ctime_nsec_;
+  int                st_blksize;
+  int                st_blocks;
+  int                st_pad4[14];
+};
+#endif
+
+
+/* Definitions missing from the standard header files                        */
+#ifndef O_DIRECTORY
+#if defined(__arm__)
+#define O_DIRECTORY             0040000
+#else
+#define O_DIRECTORY             0200000
+#endif
+#endif
+#ifndef PR_GET_DUMPABLE
+#define PR_GET_DUMPABLE         3
+#endif
+#ifndef PR_SET_DUMPABLE
+#define PR_SET_DUMPABLE         4
+#endif
+#ifndef AT_FDCWD
+#define AT_FDCWD                (-100)
+#endif
+#ifndef AT_SYMLINK_NOFOLLOW
+#define AT_SYMLINK_NOFOLLOW     0x100
+#endif
+#ifndef AT_REMOVEDIR
+#define AT_REMOVEDIR            0x200
+#endif
+#ifndef MREMAP_FIXED
+#define MREMAP_FIXED            2
+#endif
+#ifndef SA_RESTORER
+#define SA_RESTORER             0x04000000
+#endif
+
+#if defined(__i386__)
+#ifndef __NR_rt_sigaction
+#define __NR_rt_sigaction       174
+#define __NR_rt_sigprocmask     175
+#endif
+#ifndef __NR_stat64
+#define __NR_stat64             195
+#endif
+#ifndef __NR_fstat64
+#define __NR_fstat64            197
+#endif
+#ifndef __NR_getdents64
+#define __NR_getdents64         220
+#endif
+#ifndef __NR_gettid
+#define __NR_gettid             224
+#endif
+#ifndef __NR_futex
+#define __NR_futex              240
+#endif
+#ifndef __NR_openat
+#define __NR_openat             295
+#endif
+#ifndef __NR_getcpu
+#define __NR_getcpu             318
+#endif
+/* End of i386 definitions                                                   */
+#elif defined(__arm__)
+#ifndef __syscall
+#if defined(__thumb__) || defined(__ARM_EABI__)
+#define __SYS_REG(name) register long __sysreg __asm__("r6") = __NR_##name;
+#define __SYS_REG_LIST(regs...) [sysreg] "r" (__sysreg) , ##regs
+#define __syscall(name) "swi\t0"
+#define __syscall_safe(name)                     \
+  "push  {r7}\n"                                 \
+  "mov   r7,%[sysreg]\n"                         \
+  __syscall(name)"\n"                            \
+  "pop   {r7}"
+#else
+#define __SYS_REG(name)
+#define __SYS_REG_LIST(regs...) regs
+#define __syscall(name) "swi\t" __sys1(__NR_##name) ""
+#define __syscall_safe(name) __syscall(name)
+#endif
+#endif
+#ifndef __NR_rt_sigaction
+#define __NR_rt_sigaction       (__NR_SYSCALL_BASE + 174)
+#define __NR_rt_sigprocmask     (__NR_SYSCALL_BASE + 175)
+#endif
+#ifndef __NR_stat64
+#define __NR_stat64             (__NR_SYSCALL_BASE + 195)
+#endif
+#ifndef __NR_fstat64
+#define __NR_fstat64            (__NR_SYSCALL_BASE + 197)
+#endif
+#ifndef __NR_getdents64
+#define __NR_getdents64         (__NR_SYSCALL_BASE + 217)
+#endif
+#ifndef __NR_gettid
+#define __NR_gettid             (__NR_SYSCALL_BASE + 224)
+#endif
+#ifndef __NR_futex
+#define __NR_futex              (__NR_SYSCALL_BASE + 240)
+#endif
+/* End of ARM definitions                                                  */
+#elif defined(__x86_64__)
+#ifndef __NR_gettid
+#define __NR_gettid             186
+#endif
+#ifndef __NR_futex
+#define __NR_futex              202
+#endif
+#ifndef __NR_getdents64
+#define __NR_getdents64         217
+#endif
+#ifndef __NR_openat
+#define __NR_openat             257
+#endif
+/* End of x86-64 definitions                                                 */
+#elif defined(__mips__)
+#if _MIPS_SIM == _MIPS_SIM_ABI32
+#ifndef __NR_rt_sigaction
+#define __NR_rt_sigaction       (__NR_Linux + 194)
+#define __NR_rt_sigprocmask     (__NR_Linux + 195)
+#endif
+#ifndef __NR_stat64
+#define __NR_stat64             (__NR_Linux + 213)
+#endif
+#ifndef __NR_fstat64
+#define __NR_fstat64            (__NR_Linux + 215)
+#endif
+#ifndef __NR_getdents64
+#define __NR_getdents64         (__NR_Linux + 219)
+#endif
+#ifndef __NR_gettid
+#define __NR_gettid             (__NR_Linux + 222)
+#endif
+#ifndef __NR_futex
+#define __NR_futex              (__NR_Linux + 238)
+#endif
+#ifndef __NR_openat
+#define __NR_openat             (__NR_Linux + 288)
+#endif
+#ifndef __NR_fstatat
+#define __NR_fstatat            (__NR_Linux + 293)
+#endif
+#ifndef __NR_getcpu
+#define __NR_getcpu             (__NR_Linux + 312)
+#endif
+/* End of MIPS (old 32bit API) definitions */
+#elif  _MIPS_SIM == _MIPS_SIM_ABI64
+#ifndef __NR_gettid
+#define __NR_gettid             (__NR_Linux + 178)
+#endif
+#ifndef __NR_futex
+#define __NR_futex              (__NR_Linux + 194)
+#endif
+#ifndef __NR_openat
+#define __NR_openat             (__NR_Linux + 247)
+#endif
+#ifndef __NR_fstatat
+#define __NR_fstatat            (__NR_Linux + 252)
+#endif
+#ifndef __NR_getcpu
+#define __NR_getcpu             (__NR_Linux + 271)
+#endif
+/* End of MIPS (64bit API) definitions */
+#else
+#ifndef __NR_gettid
+#define __NR_gettid             (__NR_Linux + 178)
+#endif
+#ifndef __NR_futex
+#define __NR_futex              (__NR_Linux + 194)
+#endif
+#ifndef __NR_openat
+#define __NR_openat             (__NR_Linux + 251)
+#endif
+#ifndef __NR_fstatat
+#define __NR_fstatat            (__NR_Linux + 256)
+#endif
+#ifndef __NR_getcpu
+#define __NR_getcpu             (__NR_Linux + 275)
+#endif
+/* End of MIPS (new 32bit API) definitions                                   */
+#endif
+/* End of MIPS definitions                                                   */
+#elif defined(__PPC__)
+#ifndef __NR_rt_sigaction
+#define __NR_rt_sigaction       173
+#define __NR_rt_sigprocmask     174
+#endif
+#ifndef __NR_stat64
+#define __NR_stat64             195
+#endif
+#ifndef __NR_fstat64
+#define __NR_fstat64            197
+#endif
+#ifndef __NR_getdents64
+#define __NR_getdents64         202
+#endif
+#ifndef __NR_gettid
+#define __NR_gettid             207
+#endif
+#ifndef __NR_futex
+#define __NR_futex              221
+#endif
+#ifndef __NR_openat
+#define __NR_openat             286
+#endif
+#ifndef __NR_getcpu
+#define __NR_getcpu             302
+#endif
+/* End of powerpc defininitions                                              */
+#endif
+
+
+/* After forking, we must make sure to only call system calls.               */
+#if __BOUNDED_POINTERS__
+  #error "Need to port invocations of syscalls for bounded ptrs"
+#else
+  /* The core dumper and the thread lister get executed after threads
+   * have been suspended. As a consequence, we cannot call any functions
+   * that acquire locks. Unfortunately, libc wraps most system calls
+   * (e.g. in order to implement pthread_atfork, and to make calls
+   * cancellable), which means we cannot call these functions. Instead,
+   * we have to call syscall() directly.
+   */
+  #undef LSS_ERRNO
+  #ifdef SYS_ERRNO
+    /* Allow the including file to override the location of errno. This can
+     * be useful when using clone() with the CLONE_VM option.
+     */
+    #define LSS_ERRNO SYS_ERRNO
+  #else
+    #define LSS_ERRNO errno
+  #endif
+
+  #undef LSS_INLINE
+  #ifdef SYS_INLINE
+    #define LSS_INLINE SYS_INLINE
+  #else
+    #define LSS_INLINE static inline
+  #endif
+
+  /* Allow the including file to override the prefix used for all new
+   * system calls. By default, it will be set to "sys_".
+   */
+  #undef LSS_NAME
+  #ifndef SYS_PREFIX
+    #define LSS_NAME(name) sys_##name
+  #elif SYS_PREFIX < 0
+    #define LSS_NAME(name) name
+  #elif SYS_PREFIX == 0
+    #define LSS_NAME(name) sys0_##name
+  #elif SYS_PREFIX == 1
+    #define LSS_NAME(name) sys1_##name
+  #elif SYS_PREFIX == 2
+    #define LSS_NAME(name) sys2_##name
+  #elif SYS_PREFIX == 3
+    #define LSS_NAME(name) sys3_##name
+  #elif SYS_PREFIX == 4
+    #define LSS_NAME(name) sys4_##name
+  #elif SYS_PREFIX == 5
+    #define LSS_NAME(name) sys5_##name
+  #elif SYS_PREFIX == 6
+    #define LSS_NAME(name) sys6_##name
+  #elif SYS_PREFIX == 7
+    #define LSS_NAME(name) sys7_##name
+  #elif SYS_PREFIX == 8
+    #define LSS_NAME(name) sys8_##name
+  #elif SYS_PREFIX == 9
+    #define LSS_NAME(name) sys9_##name
+  #endif
+
+  #undef  LSS_RETURN
+  #if (defined(__i386__) || defined(__x86_64__) || defined(__arm__))
+  /* Failing system calls return a negative result in the range of
+   * -1..-4095. These are "errno" values with the sign inverted.
+   */
+  #define LSS_RETURN(type, res)                                               \
+    do {                                                                      \
+      if ((unsigned long)(res) >= (unsigned long)(-4095)) {                   \
+        LSS_ERRNO = -(res);                                                   \
+        res = -1;                                                             \
+      }                                                                       \
+      return (type) (res);                                                    \
+    } while (0)
+  #elif defined(__mips__)
+  /* On MIPS, failing system calls return -1, and set errno in a
+   * separate CPU register.
+   */
+  #define LSS_RETURN(type, res, err)                                          \
+    do {                                                                      \
+      if (err) {                                                              \
+        LSS_ERRNO = (res);                                                    \
+        res = -1;                                                             \
+      }                                                                       \
+      return (type) (res);                                                    \
+    } while (0)
+  #elif defined(__PPC__)
+  /* On PPC, failing system calls return -1, and set errno in a
+   * separate CPU register. See linux/unistd.h.
+   */
+  #define LSS_RETURN(type, res, err)                                          \
+   do {                                                                       \
+     if (err & 0x10000000 ) {                                                 \
+       LSS_ERRNO = (res);                                                     \
+       res = -1;                                                              \
+     }                                                                        \
+     return (type) (res);                                                     \
+   } while (0)
+  #endif
+  #if defined(__i386__)
+    #if defined(NO_FRAME_POINTER) && (100 * __GNUC__ + __GNUC_MINOR__ >= 404)
+      /* This only works for GCC-4.4 and above -- the first version to use
+         .cfi directives for dwarf unwind info.  */
+      #define CFI_ADJUST_CFA_OFFSET(adjust)                                   \
+                  ".cfi_adjust_cfa_offset " #adjust "\n"
+    #else
+      #define CFI_ADJUST_CFA_OFFSET(adjust) /**/
+    #endif
+
+    /* In PIC mode (e.g. when building shared libraries), gcc for i386
+     * reserves ebx. Unfortunately, most distribution ship with implementations
+     * of _syscallX() which clobber ebx.
+     * Also, most definitions of _syscallX() neglect to mark "memory" as being
+     * clobbered. This causes problems with compilers, that do a better job
+     * at optimizing across __asm__ calls.
+     * So, we just have to redefine all of the _syscallX() macros.
+     */
+    #undef  LSS_BODY
+    #define LSS_BODY(type,args...)                                            \
+      long __res;                                                             \
+      __asm__ __volatile__("push %%ebx\n"                                     \
+                           CFI_ADJUST_CFA_OFFSET(4)                           \
+                           "movl %2,%%ebx\n"                                  \
+                           "int $0x80\n"                                      \
+                           "pop %%ebx\n"                                      \
+                           CFI_ADJUST_CFA_OFFSET(-4)                          \
+                           args                                               \
+                           : "esp", "memory");                                \
+      LSS_RETURN(type,__res)
+    #undef  _syscall0
+    #define _syscall0(type,name)                                              \
+      type LSS_NAME(name)(void) {                                             \
+        long __res;                                                           \
+        __asm__ volatile("int $0x80"                                          \
+                         : "=a" (__res)                                       \
+                         : "0" (__NR_##name)                                  \
+                         : "memory");                                         \
+        LSS_RETURN(type,__res);                                               \
+      }
+    #undef  _syscall1
+    #define _syscall1(type,name,type1,arg1)                                   \
+      type LSS_NAME(name)(type1 arg1) {                                       \
+        LSS_BODY(type,                                                        \
+             : "=a" (__res)                                                   \
+             : "0" (__NR_##name), "ri" ((long)(arg1)));                       \
+      }
+    #undef  _syscall2
+    #define _syscall2(type,name,type1,arg1,type2,arg2)                        \
+      type LSS_NAME(name)(type1 arg1,type2 arg2) {                            \
+        LSS_BODY(type,                                                        \
+             : "=a" (__res)                                                   \
+             : "0" (__NR_##name),"ri" ((long)(arg1)), "c" ((long)(arg2)));    \
+      }
+    #undef  _syscall3
+    #define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3)             \
+      type LSS_NAME(name)(type1 arg1,type2 arg2,type3 arg3) {                 \
+        LSS_BODY(type,                                                        \
+             : "=a" (__res)                                                   \
+             : "0" (__NR_##name), "ri" ((long)(arg1)), "c" ((long)(arg2)),    \
+               "d" ((long)(arg3)));                                           \
+      }
+    #undef  _syscall4
+    #define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4)  \
+      type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4) {   \
+        LSS_BODY(type,                                                        \
+             : "=a" (__res)                                                   \
+             : "0" (__NR_##name), "ri" ((long)(arg1)), "c" ((long)(arg2)),    \
+               "d" ((long)(arg3)),"S" ((long)(arg4)));                        \
+      }
+    #undef  _syscall5
+    #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4,  \
+                      type5,arg5)                                             \
+      type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4,     \
+                          type5 arg5) {                                       \
+        long __res;                                                           \
+        __asm__ __volatile__("push %%ebx\n"                                   \
+                             "movl %2,%%ebx\n"                                \
+                             "movl %1,%%eax\n"                                \
+                             "int  $0x80\n"                                   \
+                             "pop  %%ebx"                                     \
+                             : "=a" (__res)                                   \
+                             : "i" (__NR_##name), "ri" ((long)(arg1)),        \
+                               "c" ((long)(arg2)), "d" ((long)(arg3)),        \
+                               "S" ((long)(arg4)), "D" ((long)(arg5))         \
+                             : "esp", "memory");                              \
+        LSS_RETURN(type,__res);                                               \
+      }
+    #undef  _syscall6
+    #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4,  \
+                      type5,arg5,type6,arg6)                                  \
+      type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4,     \
+                          type5 arg5, type6 arg6) {                           \
+        long __res;                                                           \
+        struct { long __a1; long __a6; } __s = { (long)arg1, (long) arg6 };   \
+        __asm__ __volatile__("push %%ebp\n"                                   \
+                             "push %%ebx\n"                                   \
+                             "movl 4(%2),%%ebp\n"                             \
+                             "movl 0(%2), %%ebx\n"                            \
+                             "movl %1,%%eax\n"                                \
+                             "int  $0x80\n"                                   \
+                             "pop  %%ebx\n"                                   \
+                             "pop  %%ebp"                                     \
+                             : "=a" (__res)                                   \
+                             : "i" (__NR_##name),  "0" ((long)(&__s)),        \
+                               "c" ((long)(arg2)), "d" ((long)(arg3)),        \
+                               "S" ((long)(arg4)), "D" ((long)(arg5))         \
+                             : "esp", "memory");                              \
+        LSS_RETURN(type,__res);                                               \
+      }
+    LSS_INLINE int LSS_NAME(clone)(int (*fn)(void *), void *child_stack,
+                                   int flags, void *arg, int *parent_tidptr,
+                                   void *newtls, int *child_tidptr) {
+      long __res;
+      __asm__ __volatile__(/* if (fn == NULL)
+                            *   return -EINVAL;
+                            */
+                           "movl   %3,%%ecx\n"
+                           "jecxz  1f\n"
+
+                           /* if (child_stack == NULL)
+                            *   return -EINVAL;
+                            */
+                           "movl   %4,%%ecx\n"
+                           "jecxz  1f\n"
+
+                           /* Set up alignment of the child stack:
+                            * child_stack = (child_stack & ~0xF) - 20;
+                            */
+                           "andl   $-16,%%ecx\n"
+                           "subl   $20,%%ecx\n"
+
+                           /* Push "arg" and "fn" onto the stack that will be
+                            * used by the child.
+                            */
+                           "movl   %6,%%eax\n"
+                           "movl   %%eax,4(%%ecx)\n"
+                           "movl   %3,%%eax\n"
+                           "movl   %%eax,(%%ecx)\n"
+
+                           /* %eax = syscall(%eax = __NR_clone,
+                            *                %ebx = flags,
+                            *                %ecx = child_stack,
+                            *                %edx = parent_tidptr,
+                            *                %esi = newtls,
+                            *                %edi = child_tidptr)
+                            * Also, make sure that %ebx gets preserved as it is
+                            * used in PIC mode.
+                            */
+                           "movl   %8,%%esi\n"
+                           "movl   %7,%%edx\n"
+                           "movl   %5,%%eax\n"
+                           "movl   %9,%%edi\n"
+                           "pushl  %%ebx\n"
+                           "movl   %%eax,%%ebx\n"
+                           "movl   %2,%%eax\n"
+                           "int    $0x80\n"
+
+                           /* In the parent: restore %ebx
+                            * In the child:  move "fn" into %ebx
+                            */
+                           "popl   %%ebx\n"
+
+                           /* if (%eax != 0)
+                            *   return %eax;
+                            */
+                           "test   %%eax,%%eax\n"
+                           "jnz    1f\n"
+
+                           /* In the child, now. Terminate frame pointer chain.
+                            */
+                           "movl   $0,%%ebp\n"
+
+                           /* Call "fn". "arg" is already on the stack.
+                            */
+                           "call   *%%ebx\n"
+
+                           /* Call _exit(%ebx). Unfortunately older versions
+                            * of gcc restrict the number of arguments that can
+                            * be passed to asm(). So, we need to hard-code the
+                            * system call number.
+                            */
+                           "movl   %%eax,%%ebx\n"
+                           "movl   $1,%%eax\n"
+                           "int    $0x80\n"
+
+                           /* Return to parent.
+                            */
+                         "1:\n"
+                           : "=a" (__res)
+                           : "0"(-EINVAL), "i"(__NR_clone),
+                             "m"(fn), "m"(child_stack), "m"(flags), "m"(arg),
+                             "m"(parent_tidptr), "m"(newtls), "m"(child_tidptr)
+                           : "esp", "memory", "ecx", "edx", "esi", "edi");
+      LSS_RETURN(int, __res);
+    }
+
+    LSS_INLINE void (*LSS_NAME(restore_rt)(void))(void) {
+      /* On i386, the kernel does not know how to return from a signal
+       * handler. Instead, it relies on user space to provide a
+       * restorer function that calls the {rt_,}sigreturn() system call.
+       * Unfortunately, we cannot just reference the glibc version of this
+       * function, as glibc goes out of its way to make it inaccessible.
+       */
+      void (*res)(void);
+      __asm__ __volatile__("call   2f\n"
+                         "0:.align 16\n"
+                         "1:movl   %1,%%eax\n"
+                           "int    $0x80\n"
+                         "2:popl   %0\n"
+                           "addl   $(1b-0b),%0\n"
+                           : "=a" (res)
+                           : "i"  (__NR_rt_sigreturn));
+      return res;
+    }
+    LSS_INLINE void (*LSS_NAME(restore)(void))(void) {
+      /* On i386, the kernel does not know how to return from a signal
+       * handler. Instead, it relies on user space to provide a
+       * restorer function that calls the {rt_,}sigreturn() system call.
+       * Unfortunately, we cannot just reference the glibc version of this
+       * function, as glibc goes out of its way to make it inaccessible.
+       */
+      void (*res)(void);
+      __asm__ __volatile__("call   2f\n"
+                         "0:.align 16\n"
+                         "1:pop    %%eax\n"
+                           "movl   %1,%%eax\n"
+                           "int    $0x80\n"
+                         "2:popl   %0\n"
+                           "addl   $(1b-0b),%0\n"
+                           : "=a" (res)
+                           : "i"  (__NR_sigreturn));
+      return res;
+    }
+  #elif defined(__x86_64__)
+    /* There are no known problems with any of the _syscallX() macros
+     * currently shipping for x86_64, but we still need to be able to define
+     * our own version so that we can override the location of the errno
+     * location (e.g. when using the clone() system call with the CLONE_VM
+     * option).
+     */
+    #undef  LSS_BODY
+    #define LSS_BODY(type,name, ...)                                          \
+          long __res;                                                         \
+          __asm__ __volatile__("syscall" : "=a" (__res) : "0" (__NR_##name),  \
+            ##__VA_ARGS__ : "r11", "rcx", "memory");                          \
+          LSS_RETURN(type, __res)
+    #undef _syscall0
+    #define _syscall0(type,name)                                              \
+      type LSS_NAME(name)() {                                                 \
+        LSS_BODY(type, name);                                                 \
+      }
+    #undef _syscall1
+    #define _syscall1(type,name,type1,arg1)                                   \
+      type LSS_NAME(name)(type1 arg1) {                                       \
+        LSS_BODY(type, name, "D" ((long)(arg1)));                             \
+      }
+    #undef _syscall2
+    #define _syscall2(type,name,type1,arg1,type2,arg2)                        \
+      type LSS_NAME(name)(type1 arg1, type2 arg2) {                           \
+        LSS_BODY(type, name, "D" ((long)(arg1)), "S" ((long)(arg2)));         \
+      }
+    #undef _syscall3
+    #define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3)             \
+      type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3) {               \
+        LSS_BODY(type, name, "D" ((long)(arg1)), "S" ((long)(arg2)),          \
+                             "d" ((long)(arg3)));                             \
+      }
+    #undef _syscall4
+    #define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4)  \
+      type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4) {   \
+          long __res;                                                         \
+          __asm__ __volatile__("movq %5,%%r10; syscall" :                     \
+            "=a" (__res) : "0" (__NR_##name),                                 \
+            "D" ((long)(arg1)), "S" ((long)(arg2)), "d" ((long)(arg3)),       \
+            "r" ((long)(arg4)) : "r10", "r11", "rcx", "memory");              \
+          LSS_RETURN(type, __res);                                            \
+      }
+    #undef _syscall5
+    #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4,  \
+                      type5,arg5)                                             \
+      type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4,     \
+                          type5 arg5) {                                       \
+          long __res;                                                         \
+          __asm__ __volatile__("movq %5,%%r10; movq %6,%%r8; syscall" :       \
+            "=a" (__res) : "0" (__NR_##name),                                 \
+            "D" ((long)(arg1)), "S" ((long)(arg2)), "d" ((long)(arg3)),       \
+            "r" ((long)(arg4)), "r" ((long)(arg5)) :                          \
+            "r8", "r10", "r11", "rcx", "memory");                             \
+          LSS_RETURN(type, __res);                                            \
+      }
+    #undef _syscall6
+    #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4,  \
+                      type5,arg5,type6,arg6)                                  \
+      type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4,     \
+                          type5 arg5, type6 arg6) {                           \
+          long __res;                                                         \
+          __asm__ __volatile__("movq %5,%%r10; movq %6,%%r8; movq %7,%%r9;"   \
+                               "syscall" :                                    \
+            "=a" (__res) : "0" (__NR_##name),                                 \
+            "D" ((long)(arg1)), "S" ((long)(arg2)), "d" ((long)(arg3)),       \
+            "r" ((long)(arg4)), "r" ((long)(arg5)), "r" ((long)(arg6)) :      \
+            "r8", "r9", "r10", "r11", "rcx", "memory");                       \
+          LSS_RETURN(type, __res);                                            \
+      }
+    LSS_INLINE int LSS_NAME(clone)(int (*fn)(void *), void *child_stack,
+                                   int flags, void *arg, int *parent_tidptr,
+                                   void *newtls, int *child_tidptr) {
+      long __res;
+      {
+        __asm__ __volatile__(/* if (fn == NULL)
+                              *   return -EINVAL;
+                              */
+                             "testq  %4,%4\n"
+                             "jz     1f\n"
+
+                             /* if (child_stack == NULL)
+                              *   return -EINVAL;
+                              */
+                             "testq  %5,%5\n"
+                             "jz     1f\n"
+
+                             /* Set up alignment of the child stack:
+                              * child_stack = (child_stack & ~0xF) - 16;
+                              */
+                             "andq   $-16,%5\n"
+                             "subq   $16,%5\n"
+
+                             /* Push "arg" and "fn" onto the stack that will be
+                              * used by the child.
+                              */
+                             "movq   %7,8(%5)\n"
+                             "movq   %4,0(%5)\n"
+
+                             /* %rax = syscall(%rax = __NR_clone,
+                              *                %rdi = flags,
+                              *                %rsi = child_stack,
+                              *                %rdx = parent_tidptr,
+                              *                %r8  = new_tls,
+                              *                %r10 = child_tidptr)
+                              */
+                             "movq   %2,%%rax\n"
+                             "movq   %9,%%r8\n"
+                             "movq   %10,%%r10\n"
+                             "syscall\n"
+
+                             /* if (%rax != 0)
+                              *   return;
+                              */
+                             "testq  %%rax,%%rax\n"
+                             "jnz    1f\n"
+
+                             /* In the child. Terminate frame pointer chain.
+                              */
+                             "xorq   %%rbp,%%rbp\n"
+
+                             /* Call "fn(arg)".
+                              */
+                             "popq   %%rax\n"
+                             "popq   %%rdi\n"
+                             "call   *%%rax\n"
+
+                             /* Call _exit(%ebx).
+                              */
+                             "movq   %%rax,%%rdi\n"
+                             "movq   %3,%%rax\n"
+                             "syscall\n"
+
+                             /* Return to parent.
+                              */
+                           "1:\n"
+                             : "=a" (__res)
+                             : "0"(-EINVAL), "i"(__NR_clone), "i"(__NR_exit),
+                               "r"(fn), "S"(child_stack), "D"(flags), "r"(arg),
+                               "d"(parent_tidptr), "g"(newtls), "g"(child_tidptr)
+                             : "rsp", "memory", "r8", "r10", "r11", "rcx");
+      }
+      LSS_RETURN(int, __res);
+    }
+
+    LSS_INLINE void (*LSS_NAME(restore_rt)(void))(void) {
+      /* On x86-64, the kernel does not know how to return from
+       * a signal handler. Instead, it relies on user space to provide a
+       * restorer function that calls the rt_sigreturn() system call.
+       * Unfortunately, we cannot just reference the glibc version of this
+       * function, as glibc goes out of its way to make it inaccessible.
+       */
+      void (*res)(void);
+      __asm__ __volatile__("call   2f\n"
+                         "0:.align 16\n"
+                         "1:movq   %1,%%rax\n"
+                           "syscall\n"
+                         "2:popq   %0\n"
+                           "addq   $(1b-0b),%0\n"
+                           : "=a" (res)
+                           : "i"  (__NR_rt_sigreturn));
+      return res;
+    }
+  #elif defined(__arm__)
+    /* Most definitions of _syscallX() neglect to mark "memory" as being
+     * clobbered. This causes problems with compilers, that do a better job
+     * at optimizing across __asm__ calls.
+     * So, we just have to redefine all fo the _syscallX() macros.
+     */
+    #undef LSS_REG
+    #define LSS_REG(r,a) register long __r##r __asm__("r"#r) = (long)a
+
+    /* r0..r3 are scratch registers and not preserved across function
+     * calls.  We need to first evaluate the first 4 syscall arguments
+     * and store them on stack.  They must be loaded into r0..r3 after
+     * all function calls to avoid r0..r3 being clobbered.
+     */
+    #undef LSS_SAVE_ARG
+    #define LSS_SAVE_ARG(r,a) long __tmp##r = (long)a
+    #undef LSS_LOAD_ARG
+    #define LSS_LOAD_ARG(r) register long __r##r __asm__("r"#r) = __tmp##r
+
+    #undef  LSS_BODY
+    #define LSS_BODY(type, name, args...)                                     \
           long __res_r0 __asm__("r0");                               \
-          long __res;                                                         \ 
-          __SYS_REG(name)                                                     \ 
-          __asm__ __volatile__ (__syscall_safe(name)                          \ 
-                                : "=r"(__res_r0)                              \ 
-                                : __SYS_REG_LIST(args)                        \ 
-                                : "lr", "memory");                            \ 
-          __res = __res_r0;                                                   \ 
-          LSS_RETURN(type, __res) 
-    #undef _syscall0 
-    #define _syscall0(type, name)                                             \ 
-      type LSS_NAME(name)() {                                                 \ 
-        LSS_BODY(type, name);                                                 \ 
-      } 
-    #undef _syscall1 
-    #define _syscall1(type, name, type1, arg1)                                \ 
-      type LSS_NAME(name)(type1 arg1) {                                       \ 
-        /* There is no need for using a volatile temp.  */                    \ 
-        LSS_REG(0, arg1);                                                     \ 
-        LSS_BODY(type, name, "r"(__r0));                                      \ 
-      } 
-    #undef _syscall2 
-    #define _syscall2(type, name, type1, arg1, type2, arg2)                   \ 
-      type LSS_NAME(name)(type1 arg1, type2 arg2) {                           \ 
-        LSS_SAVE_ARG(0, arg1);                                                \ 
-        LSS_SAVE_ARG(1, arg2);                                                \ 
-        LSS_LOAD_ARG(0);                                                      \ 
-        LSS_LOAD_ARG(1);                                                      \ 
-        LSS_BODY(type, name, "r"(__r0), "r"(__r1));                           \ 
-      } 
-    #undef _syscall3 
-    #define _syscall3(type, name, type1, arg1, type2, arg2, type3, arg3)      \ 
-      type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3) {               \ 
-        LSS_SAVE_ARG(0, arg1);                                                \ 
-        LSS_SAVE_ARG(1, arg2);                                                \ 
-        LSS_SAVE_ARG(2, arg3);                                                \ 
-        LSS_LOAD_ARG(0);                                                      \ 
-        LSS_LOAD_ARG(1);                                                      \ 
-        LSS_LOAD_ARG(2);                                                      \ 
-        LSS_BODY(type, name, "r"(__r0), "r"(__r1), "r"(__r2));                \ 
-      } 
-    #undef _syscall4 
-    #define _syscall4(type, name, type1, arg1, type2, arg2, type3, arg3,      \ 
-                      type4, arg4)                                            \ 
-      type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4) {   \ 
-        LSS_SAVE_ARG(0, arg1);                                                \ 
-        LSS_SAVE_ARG(1, arg2);                                                \ 
-        LSS_SAVE_ARG(2, arg3);                                                \ 
-        LSS_SAVE_ARG(3, arg4);                                                \ 
-        LSS_LOAD_ARG(0);                                                      \ 
-        LSS_LOAD_ARG(1);                                                      \ 
-        LSS_LOAD_ARG(2);                                                      \ 
-        LSS_LOAD_ARG(3);                                                      \ 
-        LSS_BODY(type, name, "r"(__r0), "r"(__r1), "r"(__r2), "r"(__r3));     \ 
-      } 
-    #undef _syscall5 
-    #define _syscall5(type, name, type1, arg1, type2, arg2, type3, arg3,      \ 
-                      type4, arg4, type5, arg5)                               \ 
-      type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4,     \ 
-                          type5 arg5) {                                       \ 
-        LSS_SAVE_ARG(0, arg1);                                                \ 
-        LSS_SAVE_ARG(1, arg2);                                                \ 
-        LSS_SAVE_ARG(2, arg3);                                                \ 
-        LSS_SAVE_ARG(3, arg4);                                                \ 
-        LSS_REG(4, arg5);                                                     \ 
-        LSS_LOAD_ARG(0);                                                      \ 
-        LSS_LOAD_ARG(1);                                                      \ 
-        LSS_LOAD_ARG(2);                                                      \ 
-        LSS_LOAD_ARG(3);                                                      \ 
-        LSS_BODY(type, name, "r"(__r0), "r"(__r1), "r"(__r2), "r"(__r3),      \ 
-                             "r"(__r4));                                      \ 
-      } 
-    #undef _syscall6 
-    #define _syscall6(type, name, type1, arg1, type2, arg2, type3, arg3,      \ 
-                      type4, arg4, type5, arg5, type6, arg6)                  \ 
-      type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4,     \ 
-                          type5 arg5, type6 arg6) {                           \ 
-        LSS_SAVE_ARG(0, arg1);                                                \ 
-        LSS_SAVE_ARG(1, arg2);                                                \ 
-        LSS_SAVE_ARG(2, arg3);                                                \ 
-        LSS_SAVE_ARG(3, arg4);                                                \ 
-        LSS_REG(4, arg5);                                                     \ 
-        LSS_REG(5, arg6);                                                     \ 
-        LSS_LOAD_ARG(0);                                                      \ 
-        LSS_LOAD_ARG(1);                                                      \ 
-        LSS_LOAD_ARG(2);                                                      \ 
-        LSS_LOAD_ARG(3);                                                      \ 
-        LSS_BODY(type, name, "r"(__r0), "r"(__r1), "r"(__r2), "r"(__r3),      \ 
-                             "r"(__r4), "r"(__r5));                           \ 
-      } 
-    LSS_INLINE int LSS_NAME(clone)(int (*fn)(void *), void *child_stack, 
-                                   int flags, void *arg, int *parent_tidptr, 
-                                   void *newtls, int *child_tidptr) { 
+          long __res;                                                         \
+          __SYS_REG(name)                                                     \
+          __asm__ __volatile__ (__syscall_safe(name)                          \
+                                : "=r"(__res_r0)                              \
+                                : __SYS_REG_LIST(args)                        \
+                                : "lr", "memory");                            \
+          __res = __res_r0;                                                   \
+          LSS_RETURN(type, __res)
+    #undef _syscall0
+    #define _syscall0(type, name)                                             \
+      type LSS_NAME(name)() {                                                 \
+        LSS_BODY(type, name);                                                 \
+      }
+    #undef _syscall1
+    #define _syscall1(type, name, type1, arg1)                                \
+      type LSS_NAME(name)(type1 arg1) {                                       \
+        /* There is no need for using a volatile temp.  */                    \
+        LSS_REG(0, arg1);                                                     \
+        LSS_BODY(type, name, "r"(__r0));                                      \
+      }
+    #undef _syscall2
+    #define _syscall2(type, name, type1, arg1, type2, arg2)                   \
+      type LSS_NAME(name)(type1 arg1, type2 arg2) {                           \
+        LSS_SAVE_ARG(0, arg1);                                                \
+        LSS_SAVE_ARG(1, arg2);                                                \
+        LSS_LOAD_ARG(0);                                                      \
+        LSS_LOAD_ARG(1);                                                      \
+        LSS_BODY(type, name, "r"(__r0), "r"(__r1));                           \
+      }
+    #undef _syscall3
+    #define _syscall3(type, name, type1, arg1, type2, arg2, type3, arg3)      \
+      type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3) {               \
+        LSS_SAVE_ARG(0, arg1);                                                \
+        LSS_SAVE_ARG(1, arg2);                                                \
+        LSS_SAVE_ARG(2, arg3);                                                \
+        LSS_LOAD_ARG(0);                                                      \
+        LSS_LOAD_ARG(1);                                                      \
+        LSS_LOAD_ARG(2);                                                      \
+        LSS_BODY(type, name, "r"(__r0), "r"(__r1), "r"(__r2));                \
+      }
+    #undef _syscall4
+    #define _syscall4(type, name, type1, arg1, type2, arg2, type3, arg3,      \
+                      type4, arg4)                                            \
+      type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4) {   \
+        LSS_SAVE_ARG(0, arg1);                                                \
+        LSS_SAVE_ARG(1, arg2);                                                \
+        LSS_SAVE_ARG(2, arg3);                                                \
+        LSS_SAVE_ARG(3, arg4);                                                \
+        LSS_LOAD_ARG(0);                                                      \
+        LSS_LOAD_ARG(1);                                                      \
+        LSS_LOAD_ARG(2);                                                      \
+        LSS_LOAD_ARG(3);                                                      \
+        LSS_BODY(type, name, "r"(__r0), "r"(__r1), "r"(__r2), "r"(__r3));     \
+      }
+    #undef _syscall5
+    #define _syscall5(type, name, type1, arg1, type2, arg2, type3, arg3,      \
+                      type4, arg4, type5, arg5)                               \
+      type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4,     \
+                          type5 arg5) {                                       \
+        LSS_SAVE_ARG(0, arg1);                                                \
+        LSS_SAVE_ARG(1, arg2);                                                \
+        LSS_SAVE_ARG(2, arg3);                                                \
+        LSS_SAVE_ARG(3, arg4);                                                \
+        LSS_REG(4, arg5);                                                     \
+        LSS_LOAD_ARG(0);                                                      \
+        LSS_LOAD_ARG(1);                                                      \
+        LSS_LOAD_ARG(2);                                                      \
+        LSS_LOAD_ARG(3);                                                      \
+        LSS_BODY(type, name, "r"(__r0), "r"(__r1), "r"(__r2), "r"(__r3),      \
+                             "r"(__r4));                                      \
+      }
+    #undef _syscall6
+    #define _syscall6(type, name, type1, arg1, type2, arg2, type3, arg3,      \
+                      type4, arg4, type5, arg5, type6, arg6)                  \
+      type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4,     \
+                          type5 arg5, type6 arg6) {                           \
+        LSS_SAVE_ARG(0, arg1);                                                \
+        LSS_SAVE_ARG(1, arg2);                                                \
+        LSS_SAVE_ARG(2, arg3);                                                \
+        LSS_SAVE_ARG(3, arg4);                                                \
+        LSS_REG(4, arg5);                                                     \
+        LSS_REG(5, arg6);                                                     \
+        LSS_LOAD_ARG(0);                                                      \
+        LSS_LOAD_ARG(1);                                                      \
+        LSS_LOAD_ARG(2);                                                      \
+        LSS_LOAD_ARG(3);                                                      \
+        LSS_BODY(type, name, "r"(__r0), "r"(__r1), "r"(__r2), "r"(__r3),      \
+                             "r"(__r4), "r"(__r5));                           \
+      }
+    LSS_INLINE int LSS_NAME(clone)(int (*fn)(void *), void *child_stack,
+                                   int flags, void *arg, int *parent_tidptr,
+                                   void *newtls, int *child_tidptr) {
       long __res __asm__("r5");
-      { 
-        if (fn == NULL || child_stack == NULL) { 
-            __res = -EINVAL; 
-            goto clone_exit; 
-        } 
- 
-        /* stash first 4 arguments on stack first because we can only load 
-         * them after all function calls. 
-         */ 
-        int    tmp_flags = flags; 
-        int  * tmp_stack = (int*) child_stack; 
-        void * tmp_ptid  = parent_tidptr; 
-        void * tmp_tls   = newtls; 
- 
+      {
+        if (fn == NULL || child_stack == NULL) {
+            __res = -EINVAL;
+            goto clone_exit;
+        }
+
+        /* stash first 4 arguments on stack first because we can only load
+         * them after all function calls.
+         */
+        int    tmp_flags = flags;
+        int  * tmp_stack = (int*) child_stack;
+        void * tmp_ptid  = parent_tidptr;
+        void * tmp_tls   = newtls;
+
         int  *__ctid  __asm__("r4") = child_tidptr;
- 
-        /* Push "arg" and "fn" onto the stack that will be 
-         * used by the child. 
-         */ 
-        *(--tmp_stack) = (int) arg; 
-        *(--tmp_stack) = (int) fn; 
- 
-        /* We must load r0..r3 last after all possible function calls.  */ 
+
+        /* Push "arg" and "fn" onto the stack that will be
+         * used by the child.
+         */
+        *(--tmp_stack) = (int) arg;
+        *(--tmp_stack) = (int) fn;
+
+        /* We must load r0..r3 last after all possible function calls.  */
         int   __flags __asm__("r0") = tmp_flags;
         void *__stack __asm__("r1") = tmp_stack;
         void *__ptid  __asm__("r2") = tmp_ptid;
         void *__tls   __asm__("r3") = tmp_tls;
- 
-        /* %r0 = syscall(%r0 = flags, 
-         *               %r1 = child_stack, 
-         *               %r2 = parent_tidptr, 
-         *               %r3 = newtls, 
-         *               %r4 = child_tidptr) 
-         */ 
-        __SYS_REG(clone) 
-        __asm__ __volatile__(/* %r0 = syscall(%r0 = flags, 
-                              *               %r1 = child_stack, 
-                              *               %r2 = parent_tidptr, 
-                              *               %r3 = newtls, 
-                              *               %r4 = child_tidptr) 
-                              */ 
-                             "push  {r7}\n" 
-                             "mov   r7,%1\n" 
-                             __syscall(clone)"\n" 
- 
-                             /* if (%r0 != 0) 
-                              *   return %r0; 
-                              */ 
-                             "movs  %0,r0\n" 
-                             "bne   1f\n" 
- 
-                             /* In the child, now. Call "fn(arg)". 
-                              */ 
-                             "ldr   r0,[sp, #4]\n" 
-                             "mov   lr,pc\n" 
-                             "ldr   pc,[sp]\n" 
- 
-                             /* Call _exit(%r0), which never returns.  We only 
-                              * need to set r7 for EABI syscall ABI but we do 
-                              * this always to simplify code sharing between 
-                              * old and new syscall ABIs. 
-                              */ 
-                             "mov   r7,%2\n" 
-                             __syscall(exit)"\n" 
- 
-                             /* Pop r7 from the stack only in the parent. 
-                              */ 
-                           "1: pop {r7}\n" 
-                             : "=r" (__res) 
-                             : "r"(__sysreg), 
-                               "i"(__NR_exit), "r"(__stack), "r"(__flags), 
-                               "r"(__ptid), "r"(__tls), "r"(__ctid) 
-                             : "cc", "lr", "memory"); 
-      } 
-      clone_exit: 
-      LSS_RETURN(int, __res); 
-    } 
-  #elif defined(__mips__) 
-    #undef LSS_REG 
-    #define LSS_REG(r,a) register unsigned long __r##r __asm__("$"#r) =       \ 
-                                 (unsigned long)(a) 
- 
-    #if _MIPS_SIM == _MIPS_SIM_ABI32 
-    // See http://sources.redhat.com/ml/libc-alpha/2004-10/msg00050.html 
-    // or http://www.linux-mips.org/archives/linux-mips/2004-10/msg00142.html 
-    #define MIPS_SYSCALL_CLOBBERS "$1", "$3", "$8", "$9", "$10", "$11", "$12",\ 
-                                "$13", "$14", "$15", "$24", "$25", "memory" 
-    #else 
-    #define MIPS_SYSCALL_CLOBBERS "$1", "$3", "$10", "$11", "$12", "$13",     \ 
-                                "$14", "$15", "$24", "$25", "memory" 
-    #endif 
- 
-    #undef  LSS_BODY 
-    #define LSS_BODY(type,name,r7,...)                                        \ 
+
+        /* %r0 = syscall(%r0 = flags,
+         *               %r1 = child_stack,
+         *               %r2 = parent_tidptr,
+         *               %r3 = newtls,
+         *               %r4 = child_tidptr)
+         */
+        __SYS_REG(clone)
+        __asm__ __volatile__(/* %r0 = syscall(%r0 = flags,
+                              *               %r1 = child_stack,
+                              *               %r2 = parent_tidptr,
+                              *               %r3 = newtls,
+                              *               %r4 = child_tidptr)
+                              */
+                             "push  {r7}\n"
+                             "mov   r7,%1\n"
+                             __syscall(clone)"\n"
+
+                             /* if (%r0 != 0)
+                              *   return %r0;
+                              */
+                             "movs  %0,r0\n"
+                             "bne   1f\n"
+
+                             /* In the child, now. Call "fn(arg)".
+                              */
+                             "ldr   r0,[sp, #4]\n"
+                             "mov   lr,pc\n"
+                             "ldr   pc,[sp]\n"
+
+                             /* Call _exit(%r0), which never returns.  We only
+                              * need to set r7 for EABI syscall ABI but we do
+                              * this always to simplify code sharing between
+                              * old and new syscall ABIs.
+                              */
+                             "mov   r7,%2\n"
+                             __syscall(exit)"\n"
+
+                             /* Pop r7 from the stack only in the parent.
+                              */
+                           "1: pop {r7}\n"
+                             : "=r" (__res)
+                             : "r"(__sysreg),
+                               "i"(__NR_exit), "r"(__stack), "r"(__flags),
+                               "r"(__ptid), "r"(__tls), "r"(__ctid)
+                             : "cc", "lr", "memory");
+      }
+      clone_exit:
+      LSS_RETURN(int, __res);
+    }
+  #elif defined(__mips__)
+    #undef LSS_REG
+    #define LSS_REG(r,a) register unsigned long __r##r __asm__("$"#r) =       \
+                                 (unsigned long)(a)
+
+    #if _MIPS_SIM == _MIPS_SIM_ABI32
+    // See http://sources.redhat.com/ml/libc-alpha/2004-10/msg00050.html
+    // or http://www.linux-mips.org/archives/linux-mips/2004-10/msg00142.html
+    #define MIPS_SYSCALL_CLOBBERS "$1", "$3", "$8", "$9", "$10", "$11", "$12",\
+                                "$13", "$14", "$15", "$24", "$25", "memory"
+    #else
+    #define MIPS_SYSCALL_CLOBBERS "$1", "$3", "$10", "$11", "$12", "$13",     \
+                                "$14", "$15", "$24", "$25", "memory"
+    #endif
+
+    #undef  LSS_BODY
+    #define LSS_BODY(type,name,r7,...)                                        \
           unsigned long __v0 __asm__("$2") = __NR_##name;            \
-          __asm__ __volatile__ ("syscall\n"                                   \ 
-                                : "=&r"(__v0), r7 (__r7)                      \ 
-                                : "0"(__v0), ##__VA_ARGS__                    \ 
-                                : MIPS_SYSCALL_CLOBBERS);                     \ 
-          LSS_RETURN(type, __v0, __r7) 
-    #undef _syscall0 
-    #define _syscall0(type, name)                                             \ 
-      type LSS_NAME(name)() {                                                 \ 
+          __asm__ __volatile__ ("syscall\n"                                   \
+                                : "=&r"(__v0), r7 (__r7)                      \
+                                : "0"(__v0), ##__VA_ARGS__                    \
+                                : MIPS_SYSCALL_CLOBBERS);                     \
+          LSS_RETURN(type, __v0, __r7)
+    #undef _syscall0
+    #define _syscall0(type, name)                                             \
+      type LSS_NAME(name)() {                                                 \
         unsigned long __r7 __asm__("$7");                            \
-        LSS_BODY(type, name, "=r");                                           \ 
-      } 
-    #undef _syscall1 
-    #define _syscall1(type, name, type1, arg1)                                \ 
-      type LSS_NAME(name)(type1 arg1) {                                       \ 
+        LSS_BODY(type, name, "=r");                                           \
+      }
+    #undef _syscall1
+    #define _syscall1(type, name, type1, arg1)                                \
+      type LSS_NAME(name)(type1 arg1) {                                       \
         unsigned long __r7 __asm__("$7");                            \
-        LSS_REG(4, arg1); LSS_BODY(type, name, "=r", "r"(__r4));              \ 
-      } 
-    #undef _syscall2 
-    #define _syscall2(type, name, type1, arg1, type2, arg2)                   \ 
-      type LSS_NAME(name)(type1 arg1, type2 arg2) {                           \ 
+        LSS_REG(4, arg1); LSS_BODY(type, name, "=r", "r"(__r4));              \
+      }
+    #undef _syscall2
+    #define _syscall2(type, name, type1, arg1, type2, arg2)                   \
+      type LSS_NAME(name)(type1 arg1, type2 arg2) {                           \
         unsigned long __r7 __asm__("$7");                            \
-        LSS_REG(4, arg1); LSS_REG(5, arg2);                                   \ 
-        LSS_BODY(type, name, "=r", "r"(__r4), "r"(__r5));                     \ 
-      } 
-    #undef _syscall3 
-    #define _syscall3(type, name, type1, arg1, type2, arg2, type3, arg3)      \ 
-      type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3) {               \ 
+        LSS_REG(4, arg1); LSS_REG(5, arg2);                                   \
+        LSS_BODY(type, name, "=r", "r"(__r4), "r"(__r5));                     \
+      }
+    #undef _syscall3
+    #define _syscall3(type, name, type1, arg1, type2, arg2, type3, arg3)      \
+      type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3) {               \
         unsigned long __r7 __asm__("$7");                            \
-        LSS_REG(4, arg1); LSS_REG(5, arg2); LSS_REG(6, arg3);                 \ 
-        LSS_BODY(type, name, "=r", "r"(__r4), "r"(__r5), "r"(__r6));          \ 
-      } 
-    #undef _syscall4 
-    #define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4)  \ 
-      type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4) {   \ 
-        LSS_REG(4, arg1); LSS_REG(5, arg2); LSS_REG(6, arg3);                 \ 
-        LSS_REG(7, arg4);                                                     \ 
-        LSS_BODY(type, name, "+r", "r"(__r4), "r"(__r5), "r"(__r6));          \ 
-      } 
-    #undef _syscall5 
-    #if _MIPS_SIM == _MIPS_SIM_ABI32 
-    /* The old 32bit MIPS system call API passes the fifth and sixth argument 
-     * on the stack, whereas the new APIs use registers "r8" and "r9". 
-     */ 
-    #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4,  \ 
-                      type5,arg5)                                             \ 
-      type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4,     \ 
-                          type5 arg5) {                                       \ 
-        LSS_REG(4, arg1); LSS_REG(5, arg2); LSS_REG(6, arg3);                 \ 
-        LSS_REG(7, arg4);                                                     \ 
+        LSS_REG(4, arg1); LSS_REG(5, arg2); LSS_REG(6, arg3);                 \
+        LSS_BODY(type, name, "=r", "r"(__r4), "r"(__r5), "r"(__r6));          \
+      }
+    #undef _syscall4
+    #define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4)  \
+      type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4) {   \
+        LSS_REG(4, arg1); LSS_REG(5, arg2); LSS_REG(6, arg3);                 \
+        LSS_REG(7, arg4);                                                     \
+        LSS_BODY(type, name, "+r", "r"(__r4), "r"(__r5), "r"(__r6));          \
+      }
+    #undef _syscall5
+    #if _MIPS_SIM == _MIPS_SIM_ABI32
+    /* The old 32bit MIPS system call API passes the fifth and sixth argument
+     * on the stack, whereas the new APIs use registers "r8" and "r9".
+     */
+    #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4,  \
+                      type5,arg5)                                             \
+      type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4,     \
+                          type5 arg5) {                                       \
+        LSS_REG(4, arg1); LSS_REG(5, arg2); LSS_REG(6, arg3);                 \
+        LSS_REG(7, arg4);                                                     \
         unsigned long __v0 __asm__("$2");                            \
-        __asm__ __volatile__ (".set noreorder\n"                              \ 
-                              "lw    $2, %6\n"                                \ 
-                              "subu  $29, 32\n"                               \ 
-                              "sw    $2, 16($29)\n"                           \ 
-                              "li    $2, %2\n"                                \ 
-                              "syscall\n"                                     \ 
-                              "addiu $29, 32\n"                               \ 
-                              ".set reorder\n"                                \ 
-                              : "=&r"(__v0), "+r" (__r7)                      \ 
-                              : "i" (__NR_##name), "r"(__r4), "r"(__r5),      \ 
-                                "r"(__r6), "m" ((unsigned long)arg5)          \ 
-                              : MIPS_SYSCALL_CLOBBERS);                       \ 
-        LSS_RETURN(type, __v0, __r7);                                         \ 
-      } 
-    #else 
-    #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4,  \ 
-                      type5,arg5)                                             \ 
-      type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4,     \ 
-                          type5 arg5) {                                       \ 
-        LSS_REG(4, arg1); LSS_REG(5, arg2); LSS_REG(6, arg3);                 \ 
-        LSS_REG(7, arg4); LSS_REG(8, arg5);                                   \ 
-        LSS_BODY(type, name, "+r", "r"(__r4), "r"(__r5), "r"(__r6),           \ 
-                 "r"(__r8));                                                  \ 
-      } 
-    #endif 
-    #undef _syscall6 
-    #if _MIPS_SIM == _MIPS_SIM_ABI32 
-    /* The old 32bit MIPS system call API passes the fifth and sixth argument 
-     * on the stack, whereas the new APIs use registers "r8" and "r9". 
-     */ 
-    #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4,  \ 
-                      type5,arg5,type6,arg6)                                  \ 
-      type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4,     \ 
-                          type5 arg5, type6 arg6) {                           \ 
-        LSS_REG(4, arg1); LSS_REG(5, arg2); LSS_REG(6, arg3);                 \ 
-        LSS_REG(7, arg4);                                                     \ 
+        __asm__ __volatile__ (".set noreorder\n"                              \
+                              "lw    $2, %6\n"                                \
+                              "subu  $29, 32\n"                               \
+                              "sw    $2, 16($29)\n"                           \
+                              "li    $2, %2\n"                                \
+                              "syscall\n"                                     \
+                              "addiu $29, 32\n"                               \
+                              ".set reorder\n"                                \
+                              : "=&r"(__v0), "+r" (__r7)                      \
+                              : "i" (__NR_##name), "r"(__r4), "r"(__r5),      \
+                                "r"(__r6), "m" ((unsigned long)arg5)          \
+                              : MIPS_SYSCALL_CLOBBERS);                       \
+        LSS_RETURN(type, __v0, __r7);                                         \
+      }
+    #else
+    #define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4,  \
+                      type5,arg5)                                             \
+      type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4,     \
+                          type5 arg5) {                                       \
+        LSS_REG(4, arg1); LSS_REG(5, arg2); LSS_REG(6, arg3);                 \
+        LSS_REG(7, arg4); LSS_REG(8, arg5);                                   \
+        LSS_BODY(type, name, "+r", "r"(__r4), "r"(__r5), "r"(__r6),           \
+                 "r"(__r8));                                                  \
+      }
+    #endif
+    #undef _syscall6
+    #if _MIPS_SIM == _MIPS_SIM_ABI32
+    /* The old 32bit MIPS system call API passes the fifth and sixth argument
+     * on the stack, whereas the new APIs use registers "r8" and "r9".
+     */
+    #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4,  \
+                      type5,arg5,type6,arg6)                                  \
+      type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4,     \
+                          type5 arg5, type6 arg6) {                           \
+        LSS_REG(4, arg1); LSS_REG(5, arg2); LSS_REG(6, arg3);                 \
+        LSS_REG(7, arg4);                                                     \
         unsigned long __v0 __asm__("$2");                            \
-        __asm__ __volatile__ (".set noreorder\n"                              \ 
-                              "lw    $2, %6\n"                                \ 
-                              "lw    $8, %7\n"                                \ 
-                              "subu  $29, 32\n"                               \ 
-                              "sw    $2, 16($29)\n"                           \ 
-                              "sw    $8, 20($29)\n"                           \ 
-                              "li    $2, %2\n"                                \ 
-                              "syscall\n"                                     \ 
-                              "addiu $29, 32\n"                               \ 
-                              ".set reorder\n"                                \ 
-                              : "=&r"(__v0), "+r" (__r7)                      \ 
-                              : "i" (__NR_##name), "r"(__r4), "r"(__r5),      \ 
-                                "r"(__r6), "r" ((unsigned long)arg5),         \ 
-                                "r" ((unsigned long)arg6)                     \ 
-                              : MIPS_SYSCALL_CLOBBERS);                       \ 
-        LSS_RETURN(type, __v0, __r7);                                         \ 
-      } 
-    #else 
-    #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4,  \ 
-                      type5,arg5,type6,arg6)                                  \ 
-      type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4,     \ 
-                          type5 arg5,type6 arg6) {                            \ 
-        LSS_REG(4, arg1); LSS_REG(5, arg2); LSS_REG(6, arg3);                 \ 
-        LSS_REG(7, arg4); LSS_REG(8, arg5); LSS_REG(9, arg6);                 \ 
-        LSS_BODY(type, name, "+r", "r"(__r4), "r"(__r5), "r"(__r6),           \ 
-                 "r"(__r8), "r"(__r9));                                       \ 
-      } 
-    #endif 
-    LSS_INLINE int LSS_NAME(clone)(int (*fn)(void *), void *child_stack, 
-                                   int flags, void *arg, int *parent_tidptr, 
-                                   void *newtls, int *child_tidptr) { 
+        __asm__ __volatile__ (".set noreorder\n"                              \
+                              "lw    $2, %6\n"                                \
+                              "lw    $8, %7\n"                                \
+                              "subu  $29, 32\n"                               \
+                              "sw    $2, 16($29)\n"                           \
+                              "sw    $8, 20($29)\n"                           \
+                              "li    $2, %2\n"                                \
+                              "syscall\n"                                     \
+                              "addiu $29, 32\n"                               \
+                              ".set reorder\n"                                \
+                              : "=&r"(__v0), "+r" (__r7)                      \
+                              : "i" (__NR_##name), "r"(__r4), "r"(__r5),      \
+                                "r"(__r6), "r" ((unsigned long)arg5),         \
+                                "r" ((unsigned long)arg6)                     \
+                              : MIPS_SYSCALL_CLOBBERS);                       \
+        LSS_RETURN(type, __v0, __r7);                                         \
+      }
+    #else
+    #define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4,  \
+                      type5,arg5,type6,arg6)                                  \
+      type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4,     \
+                          type5 arg5,type6 arg6) {                            \
+        LSS_REG(4, arg1); LSS_REG(5, arg2); LSS_REG(6, arg3);                 \
+        LSS_REG(7, arg4); LSS_REG(8, arg5); LSS_REG(9, arg6);                 \
+        LSS_BODY(type, name, "+r", "r"(__r4), "r"(__r5), "r"(__r6),           \
+                 "r"(__r8), "r"(__r9));                                       \
+      }
+    #endif
+    LSS_INLINE int LSS_NAME(clone)(int (*fn)(void *), void *child_stack,
+                                   int flags, void *arg, int *parent_tidptr,
+                                   void *newtls, int *child_tidptr) {
       unsigned long __v0 __asm__("$2");
       unsigned long __r7 __asm__("$7") = (unsigned long)newtls;
-      { 
+      {
         int   __flags __asm__("$4") = flags;
         void *__stack __asm__("$5") = child_stack;
         void *__ptid  __asm__("$6") = parent_tidptr;
         int  *__ctid  __asm__("$8") = child_tidptr;
-        __asm__ __volatile__( 
-          #if _MIPS_SIM == _MIPS_SIM_ABI32 && _MIPS_SZPTR == 32 
-                             "subu  $29,24\n" 
-          #elif _MIPS_SIM == _MIPS_SIM_NABI32 
-                             "sub   $29,16\n" 
-          #else 
-                             "dsubu $29,16\n" 
-          #endif 
- 
-                             /* if (fn == NULL || child_stack == NULL) 
-                              *   return -EINVAL; 
-                              */ 
-                             "li    %0,%2\n" 
-                             "beqz  %5,1f\n" 
-                             "beqz  %6,1f\n" 
- 
-                             /* Push "arg" and "fn" onto the stack that will be 
-                              * used by the child. 
-                              */ 
-          #if _MIPS_SIM == _MIPS_SIM_ABI32 && _MIPS_SZPTR == 32 
-                             "subu  %6,32\n" 
-                             "sw    %5,0(%6)\n" 
-                             "sw    %8,4(%6)\n" 
-          #elif _MIPS_SIM == _MIPS_SIM_NABI32 
-                             "sub   %6,32\n" 
-                             "sw    %5,0(%6)\n" 
-                             "sw    %8,8(%6)\n" 
-          #else 
-                             "dsubu %6,32\n" 
-                             "sd    %5,0(%6)\n" 
-                             "sd    %8,8(%6)\n" 
-          #endif 
- 
-                             /* $7 = syscall($4 = flags, 
-                              *              $5 = child_stack, 
-                              *              $6 = parent_tidptr, 
-                              *              $7 = newtls, 
-                              *              $8 = child_tidptr) 
-                              */ 
-                             "li    $2,%3\n" 
-                             "syscall\n" 
- 
-                             /* if ($7 != 0) 
-                              *   return $2; 
-                              */ 
-                             "bnez  $7,1f\n" 
-                             "bnez  $2,1f\n" 
- 
-                             /* In the child, now. Call "fn(arg)". 
-                              */ 
-          #if _MIPS_SIM == _MIPS_SIM_ABI32 && _MIPS_SZPTR == 32 
-                            "lw    $25,0($29)\n" 
-                            "lw    $4,4($29)\n" 
-          #elif _MIPS_SIM == _MIPS_SIM_NABI32 
-                            "lw    $25,0($29)\n" 
-                            "lw    $4,8($29)\n" 
-          #else 
-                            "ld    $25,0($29)\n" 
-                            "ld    $4,8($29)\n" 
-          #endif 
-                            "jalr  $25\n" 
- 
-                             /* Call _exit($2) 
-                              */ 
-                            "move  $4,$2\n" 
-                            "li    $2,%4\n" 
-                            "syscall\n" 
- 
-                           "1:\n" 
-          #if _MIPS_SIM == _MIPS_SIM_ABI32 && _MIPS_SZPTR == 32 
-                             "addu  $29, 24\n" 
-          #elif _MIPS_SIM == _MIPS_SIM_NABI32 
-                             "add   $29, 16\n" 
-          #else 
-                             "daddu $29,16\n" 
-          #endif 
-                             : "=&r" (__v0), "=r" (__r7) 
-                             : "i"(-EINVAL), "i"(__NR_clone), "i"(__NR_exit), 
-                               "r"(fn), "r"(__stack), "r"(__flags), "r"(arg), 
-                               "r"(__ptid), "r"(__r7), "r"(__ctid) 
-                             : "$9", "$10", "$11", "$12", "$13", "$14", "$15", 
-                               "$24", "memory"); 
-      } 
-      LSS_RETURN(int, __v0, __r7); 
-    } 
-  #elif defined (__PPC__) 
-    #undef  LSS_LOADARGS_0 
-    #define LSS_LOADARGS_0(name, dummy...)                                    \ 
-        __sc_0 = __NR_##name 
-    #undef  LSS_LOADARGS_1 
-    #define LSS_LOADARGS_1(name, arg1)                                        \ 
-            LSS_LOADARGS_0(name);                                             \ 
-            __sc_3 = (unsigned long) (arg1) 
-    #undef  LSS_LOADARGS_2 
-    #define LSS_LOADARGS_2(name, arg1, arg2)                                  \ 
-            LSS_LOADARGS_1(name, arg1);                                       \ 
-            __sc_4 = (unsigned long) (arg2) 
-    #undef  LSS_LOADARGS_3 
-    #define LSS_LOADARGS_3(name, arg1, arg2, arg3)                            \ 
-            LSS_LOADARGS_2(name, arg1, arg2);                                 \ 
-            __sc_5 = (unsigned long) (arg3) 
-    #undef  LSS_LOADARGS_4 
-    #define LSS_LOADARGS_4(name, arg1, arg2, arg3, arg4)                      \ 
-            LSS_LOADARGS_3(name, arg1, arg2, arg3);                           \ 
-            __sc_6 = (unsigned long) (arg4) 
-    #undef  LSS_LOADARGS_5 
-    #define LSS_LOADARGS_5(name, arg1, arg2, arg3, arg4, arg5)                \ 
-            LSS_LOADARGS_4(name, arg1, arg2, arg3, arg4);                     \ 
-            __sc_7 = (unsigned long) (arg5) 
-    #undef  LSS_LOADARGS_6 
-    #define LSS_LOADARGS_6(name, arg1, arg2, arg3, arg4, arg5, arg6)          \ 
-            LSS_LOADARGS_5(name, arg1, arg2, arg3, arg4, arg5);               \ 
-            __sc_8 = (unsigned long) (arg6) 
-    #undef  LSS_ASMINPUT_0 
-    #define LSS_ASMINPUT_0 "0" (__sc_0) 
-    #undef  LSS_ASMINPUT_1 
-    #define LSS_ASMINPUT_1 LSS_ASMINPUT_0, "1" (__sc_3) 
-    #undef  LSS_ASMINPUT_2 
-    #define LSS_ASMINPUT_2 LSS_ASMINPUT_1, "2" (__sc_4) 
-    #undef  LSS_ASMINPUT_3 
-    #define LSS_ASMINPUT_3 LSS_ASMINPUT_2, "3" (__sc_5) 
-    #undef  LSS_ASMINPUT_4 
-    #define LSS_ASMINPUT_4 LSS_ASMINPUT_3, "4" (__sc_6) 
-    #undef  LSS_ASMINPUT_5 
-    #define LSS_ASMINPUT_5 LSS_ASMINPUT_4, "5" (__sc_7) 
-    #undef  LSS_ASMINPUT_6 
-    #define LSS_ASMINPUT_6 LSS_ASMINPUT_5, "6" (__sc_8) 
-    #undef  LSS_BODY 
-    #define LSS_BODY(nr, type, name, args...)                                 \ 
-        long __sc_ret, __sc_err;                                              \ 
-        {                                                                     \ 
+        __asm__ __volatile__(
+          #if _MIPS_SIM == _MIPS_SIM_ABI32 && _MIPS_SZPTR == 32
+                             "subu  $29,24\n"
+          #elif _MIPS_SIM == _MIPS_SIM_NABI32
+                             "sub   $29,16\n"
+          #else
+                             "dsubu $29,16\n"
+          #endif
+
+                             /* if (fn == NULL || child_stack == NULL)
+                              *   return -EINVAL;
+                              */
+                             "li    %0,%2\n"
+                             "beqz  %5,1f\n"
+                             "beqz  %6,1f\n"
+
+                             /* Push "arg" and "fn" onto the stack that will be
+                              * used by the child.
+                              */
+          #if _MIPS_SIM == _MIPS_SIM_ABI32 && _MIPS_SZPTR == 32
+                             "subu  %6,32\n"
+                             "sw    %5,0(%6)\n"
+                             "sw    %8,4(%6)\n"
+          #elif _MIPS_SIM == _MIPS_SIM_NABI32
+                             "sub   %6,32\n"
+                             "sw    %5,0(%6)\n"
+                             "sw    %8,8(%6)\n"
+          #else
+                             "dsubu %6,32\n"
+                             "sd    %5,0(%6)\n"
+                             "sd    %8,8(%6)\n"
+          #endif
+
+                             /* $7 = syscall($4 = flags,
+                              *              $5 = child_stack,
+                              *              $6 = parent_tidptr,
+                              *              $7 = newtls,
+                              *              $8 = child_tidptr)
+                              */
+                             "li    $2,%3\n"
+                             "syscall\n"
+
+                             /* if ($7 != 0)
+                              *   return $2;
+                              */
+                             "bnez  $7,1f\n"
+                             "bnez  $2,1f\n"
+
+                             /* In the child, now. Call "fn(arg)".
+                              */
+          #if _MIPS_SIM == _MIPS_SIM_ABI32 && _MIPS_SZPTR == 32
+                            "lw    $25,0($29)\n"
+                            "lw    $4,4($29)\n"
+          #elif _MIPS_SIM == _MIPS_SIM_NABI32
+                            "lw    $25,0($29)\n"
+                            "lw    $4,8($29)\n"
+          #else
+                            "ld    $25,0($29)\n"
+                            "ld    $4,8($29)\n"
+          #endif
+                            "jalr  $25\n"
+
+                             /* Call _exit($2)
+                              */
+                            "move  $4,$2\n"
+                            "li    $2,%4\n"
+                            "syscall\n"
+
+                           "1:\n"
+          #if _MIPS_SIM == _MIPS_SIM_ABI32 && _MIPS_SZPTR == 32
+                             "addu  $29, 24\n"
+          #elif _MIPS_SIM == _MIPS_SIM_NABI32
+                             "add   $29, 16\n"
+          #else
+                             "daddu $29,16\n"
+          #endif
+                             : "=&r" (__v0), "=r" (__r7)
+                             : "i"(-EINVAL), "i"(__NR_clone), "i"(__NR_exit),
+                               "r"(fn), "r"(__stack), "r"(__flags), "r"(arg),
+                               "r"(__ptid), "r"(__r7), "r"(__ctid)
+                             : "$9", "$10", "$11", "$12", "$13", "$14", "$15",
+                               "$24", "memory");
+      }
+      LSS_RETURN(int, __v0, __r7);
+    }
+  #elif defined (__PPC__)
+    #undef  LSS_LOADARGS_0
+    #define LSS_LOADARGS_0(name, dummy...)                                    \
+        __sc_0 = __NR_##name
+    #undef  LSS_LOADARGS_1
+    #define LSS_LOADARGS_1(name, arg1)                                        \
+            LSS_LOADARGS_0(name);                                             \
+            __sc_3 = (unsigned long) (arg1)
+    #undef  LSS_LOADARGS_2
+    #define LSS_LOADARGS_2(name, arg1, arg2)                                  \
+            LSS_LOADARGS_1(name, arg1);                                       \
+            __sc_4 = (unsigned long) (arg2)
+    #undef  LSS_LOADARGS_3
+    #define LSS_LOADARGS_3(name, arg1, arg2, arg3)                            \
+            LSS_LOADARGS_2(name, arg1, arg2);                                 \
+            __sc_5 = (unsigned long) (arg3)
+    #undef  LSS_LOADARGS_4
+    #define LSS_LOADARGS_4(name, arg1, arg2, arg3, arg4)                      \
+            LSS_LOADARGS_3(name, arg1, arg2, arg3);                           \
+            __sc_6 = (unsigned long) (arg4)
+    #undef  LSS_LOADARGS_5
+    #define LSS_LOADARGS_5(name, arg1, arg2, arg3, arg4, arg5)                \
+            LSS_LOADARGS_4(name, arg1, arg2, arg3, arg4);                     \
+            __sc_7 = (unsigned long) (arg5)
+    #undef  LSS_LOADARGS_6
+    #define LSS_LOADARGS_6(name, arg1, arg2, arg3, arg4, arg5, arg6)          \
+            LSS_LOADARGS_5(name, arg1, arg2, arg3, arg4, arg5);               \
+            __sc_8 = (unsigned long) (arg6)
+    #undef  LSS_ASMINPUT_0
+    #define LSS_ASMINPUT_0 "0" (__sc_0)
+    #undef  LSS_ASMINPUT_1
+    #define LSS_ASMINPUT_1 LSS_ASMINPUT_0, "1" (__sc_3)
+    #undef  LSS_ASMINPUT_2
+    #define LSS_ASMINPUT_2 LSS_ASMINPUT_1, "2" (__sc_4)
+    #undef  LSS_ASMINPUT_3
+    #define LSS_ASMINPUT_3 LSS_ASMINPUT_2, "3" (__sc_5)
+    #undef  LSS_ASMINPUT_4
+    #define LSS_ASMINPUT_4 LSS_ASMINPUT_3, "4" (__sc_6)
+    #undef  LSS_ASMINPUT_5
+    #define LSS_ASMINPUT_5 LSS_ASMINPUT_4, "5" (__sc_7)
+    #undef  LSS_ASMINPUT_6
+    #define LSS_ASMINPUT_6 LSS_ASMINPUT_5, "6" (__sc_8)
+    #undef  LSS_BODY
+    #define LSS_BODY(nr, type, name, args...)                                 \
+        long __sc_ret, __sc_err;                                              \
+        {                                                                     \
                         unsigned long __sc_0 __asm__ ("r0");         \
                         unsigned long __sc_3 __asm__ ("r3");         \
                         unsigned long __sc_4 __asm__ ("r4");         \
@@ -1646,71 +1646,71 @@ struct kernel_stat {
                         unsigned long __sc_6 __asm__ ("r6");         \
                         unsigned long __sc_7 __asm__ ("r7");         \
                         unsigned long __sc_8 __asm__ ("r8");         \
-                                                                              \ 
-            LSS_LOADARGS_##nr(name, args);                                    \ 
-            __asm__ __volatile__                                              \ 
-                ("sc\n\t"                                                     \ 
-                 "mfcr %0"                                                    \ 
-                 : "=&r" (__sc_0),                                            \ 
-                   "=&r" (__sc_3), "=&r" (__sc_4),                            \ 
-                   "=&r" (__sc_5), "=&r" (__sc_6),                            \ 
-                   "=&r" (__sc_7), "=&r" (__sc_8)                             \ 
-                 : LSS_ASMINPUT_##nr                                          \ 
-                 : "cr0", "ctr", "memory",                                    \ 
-                   "r9", "r10", "r11", "r12");                                \ 
-            __sc_ret = __sc_3;                                                \ 
-            __sc_err = __sc_0;                                                \ 
-        }                                                                     \ 
-        LSS_RETURN(type, __sc_ret, __sc_err) 
-    #undef _syscall0 
-    #define _syscall0(type, name)                                             \ 
-       type LSS_NAME(name)(void) {                                            \ 
-          LSS_BODY(0, type, name);                                            \ 
-       } 
-    #undef _syscall1 
-    #define _syscall1(type, name, type1, arg1)                                \ 
-       type LSS_NAME(name)(type1 arg1) {                                      \ 
-          LSS_BODY(1, type, name, arg1);                                      \ 
-       } 
-    #undef _syscall2 
-    #define _syscall2(type, name, type1, arg1, type2, arg2)                   \ 
-       type LSS_NAME(name)(type1 arg1, type2 arg2) {                          \ 
-          LSS_BODY(2, type, name, arg1, arg2);                                \ 
-       } 
-    #undef _syscall3 
-    #define _syscall3(type, name, type1, arg1, type2, arg2, type3, arg3)      \ 
-       type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3) {              \ 
-          LSS_BODY(3, type, name, arg1, arg2, arg3);                          \ 
-       } 
-    #undef _syscall4 
-    #define _syscall4(type, name, type1, arg1, type2, arg2, type3, arg3,      \ 
-                                  type4, arg4)                                \ 
-       type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4) {  \ 
-          LSS_BODY(4, type, name, arg1, arg2, arg3, arg4);                    \ 
-       } 
-    #undef _syscall5 
-    #define _syscall5(type, name, type1, arg1, type2, arg2, type3, arg3,      \ 
-                                  type4, arg4, type5, arg5)                   \ 
-       type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4,    \ 
-                                               type5 arg5) {                  \ 
-          LSS_BODY(5, type, name, arg1, arg2, arg3, arg4, arg5);              \ 
-       } 
-    #undef _syscall6 
-    #define _syscall6(type, name, type1, arg1, type2, arg2, type3, arg3,      \ 
-                                  type4, arg4, type5, arg5, type6, arg6)      \ 
-       type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4,    \ 
-                                               type5 arg5, type6 arg6) {      \ 
-          LSS_BODY(6, type, name, arg1, arg2, arg3, arg4, arg5, arg6);        \ 
-       } 
-    /* clone function adapted from glibc 2.3.6 clone.S                       */ 
-    /* TODO(csilvers): consider wrapping some args up in a struct, like we 
-     * do for i386's _syscall6, so we can compile successfully on gcc 2.95 
-     */ 
-    LSS_INLINE int LSS_NAME(clone)(int (*fn)(void *), void *child_stack, 
-                                   int flags, void *arg, int *parent_tidptr, 
-                                   void *newtls, int *child_tidptr) { 
-      long __ret, __err; 
-      { 
+                                                                              \
+            LSS_LOADARGS_##nr(name, args);                                    \
+            __asm__ __volatile__                                              \
+                ("sc\n\t"                                                     \
+                 "mfcr %0"                                                    \
+                 : "=&r" (__sc_0),                                            \
+                   "=&r" (__sc_3), "=&r" (__sc_4),                            \
+                   "=&r" (__sc_5), "=&r" (__sc_6),                            \
+                   "=&r" (__sc_7), "=&r" (__sc_8)                             \
+                 : LSS_ASMINPUT_##nr                                          \
+                 : "cr0", "ctr", "memory",                                    \
+                   "r9", "r10", "r11", "r12");                                \
+            __sc_ret = __sc_3;                                                \
+            __sc_err = __sc_0;                                                \
+        }                                                                     \
+        LSS_RETURN(type, __sc_ret, __sc_err)
+    #undef _syscall0
+    #define _syscall0(type, name)                                             \
+       type LSS_NAME(name)(void) {                                            \
+          LSS_BODY(0, type, name);                                            \
+       }
+    #undef _syscall1
+    #define _syscall1(type, name, type1, arg1)                                \
+       type LSS_NAME(name)(type1 arg1) {                                      \
+          LSS_BODY(1, type, name, arg1);                                      \
+       }
+    #undef _syscall2
+    #define _syscall2(type, name, type1, arg1, type2, arg2)                   \
+       type LSS_NAME(name)(type1 arg1, type2 arg2) {                          \
+          LSS_BODY(2, type, name, arg1, arg2);                                \
+       }
+    #undef _syscall3
+    #define _syscall3(type, name, type1, arg1, type2, arg2, type3, arg3)      \
+       type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3) {              \
+          LSS_BODY(3, type, name, arg1, arg2, arg3);                          \
+       }
+    #undef _syscall4
+    #define _syscall4(type, name, type1, arg1, type2, arg2, type3, arg3,      \
+                                  type4, arg4)                                \
+       type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4) {  \
+          LSS_BODY(4, type, name, arg1, arg2, arg3, arg4);                    \
+       }
+    #undef _syscall5
+    #define _syscall5(type, name, type1, arg1, type2, arg2, type3, arg3,      \
+                                  type4, arg4, type5, arg5)                   \
+       type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4,    \
+                                               type5 arg5) {                  \
+          LSS_BODY(5, type, name, arg1, arg2, arg3, arg4, arg5);              \
+       }
+    #undef _syscall6
+    #define _syscall6(type, name, type1, arg1, type2, arg2, type3, arg3,      \
+                                  type4, arg4, type5, arg5, type6, arg6)      \
+       type LSS_NAME(name)(type1 arg1, type2 arg2, type3 arg3, type4 arg4,    \
+                                               type5 arg5, type6 arg6) {      \
+          LSS_BODY(6, type, name, arg1, arg2, arg3, arg4, arg5, arg6);        \
+       }
+    /* clone function adapted from glibc 2.3.6 clone.S                       */
+    /* TODO(csilvers): consider wrapping some args up in a struct, like we
+     * do for i386's _syscall6, so we can compile successfully on gcc 2.95
+     */
+    LSS_INLINE int LSS_NAME(clone)(int (*fn)(void *), void *child_stack,
+                                   int flags, void *arg, int *parent_tidptr,
+                                   void *newtls, int *child_tidptr) {
+      long __ret, __err;
+      {
         int (*__fn)(void *)    __asm__ ("r8")  = fn;
         void *__cstack                 __asm__ ("r4")  = child_stack;
         int __flags                    __asm__ ("r3")  = flags;
@@ -1718,342 +1718,342 @@ struct kernel_stat {
         int * __ptidptr                __asm__ ("r5")  = parent_tidptr;
         void * __newtls                __asm__ ("r6")  = newtls;
         int * __ctidptr                __asm__ ("r7")  = child_tidptr;
-        __asm__ __volatile__( 
-            /* check for fn == NULL 
-             * and child_stack == NULL 
-             */ 
-            "cmpwi cr0, %6, 0\n\t" 
-            "cmpwi cr1, %7, 0\n\t" 
-            "cror cr0*4+eq, cr1*4+eq, cr0*4+eq\n\t" 
-            "beq- cr0, 1f\n\t" 
- 
-            /* set up stack frame for child                                  */ 
-            "clrrwi %7, %7, 4\n\t" 
-            "li 0, 0\n\t" 
-            "stwu 0, -16(%7)\n\t" 
- 
-            /* fn, arg, child_stack are saved across the syscall: r28-30     */ 
-            "mr 28, %6\n\t" 
-            "mr 29, %7\n\t" 
-            "mr 27, %9\n\t" 
- 
-            /* syscall                                                       */ 
-            "li 0, %4\n\t" 
-            /* flags already in r3 
-             * child_stack already in r4 
-             * ptidptr already in r5 
-             * newtls already in r6 
-             * ctidptr already in r7 
-             */ 
-            "sc\n\t" 
- 
-            /* Test if syscall was successful                                */ 
-            "cmpwi cr1, 3, 0\n\t" 
-            "crandc cr1*4+eq, cr1*4+eq, cr0*4+so\n\t" 
-            "bne- cr1, 1f\n\t" 
- 
-            /* Do the function call                                          */ 
-            "mtctr 28\n\t" 
-            "mr 3, 27\n\t" 
-            "bctrl\n\t" 
- 
-            /* Call _exit(r3)                                                */ 
-            "li 0, %5\n\t" 
-            "sc\n\t" 
- 
-            /* Return to parent                                              */ 
-            "1:\n" 
-            "mfcr %1\n\t" 
-            "mr %0, 3\n\t" 
-              : "=r" (__ret), "=r" (__err) 
-              : "0" (-1), "1" (EINVAL), 
-                "i" (__NR_clone), "i" (__NR_exit), 
-                "r" (__fn), "r" (__cstack), "r" (__flags), 
-                "r" (__arg), "r" (__ptidptr), "r" (__newtls), 
-                "r" (__ctidptr) 
-              : "cr0", "cr1", "memory", "ctr", 
-                "r0", "r29", "r27", "r28"); 
-      } 
-      LSS_RETURN(int, __ret, __err); 
-    } 
-  #endif 
-  #define __NR__exit   __NR_exit 
-  #define __NR__gettid __NR_gettid 
-  #define __NR__mremap __NR_mremap 
-  LSS_INLINE _syscall1(int,     close,           int,         f) 
-  LSS_INLINE _syscall1(int,     _exit,           int,         e) 
-  LSS_INLINE _syscall3(int,     fcntl,           int,         f, 
-                       int,            c, long,   a) 
-  LSS_INLINE _syscall2(int,     fstat,           int,         f, 
-                      struct kernel_stat*,   b) 
-  LSS_INLINE _syscall4(int,     futex,           int*,        a, 
-                       int,            o, int,    v, 
-                      struct kernel_timespec*, t) 
-  LSS_INLINE _syscall3(int,     getdents,        int,         f, 
-                      struct kernel_dirent*, d, int,    c) 
-#ifdef __NR_getdents64 
-  LSS_INLINE _syscall3(int,     getdents64,      int,         f, 
-                      struct kernel_dirent64*, d, int,    c) 
-#endif 
-  LSS_INLINE _syscall0(pid_t,   getpid) 
-  LSS_INLINE _syscall0(pid_t,   getppid) 
-  LSS_INLINE _syscall0(pid_t,   _gettid) 
-  LSS_INLINE _syscall2(int,     kill,            pid_t,       p, 
-                       int,            s) 
-  LSS_INLINE _syscall3(off_t,   lseek,           int,         f, 
-                       off_t,          o, int,    w) 
-  LSS_INLINE _syscall2(int,     munmap,          void*,       s, 
-                       size_t,         l) 
-  LSS_INLINE _syscall5(void*,   _mremap,         void*,       o, 
-                       size_t,         os,       size_t,      ns, 
-                       unsigned long,  f, void *, a) 
-  LSS_INLINE _syscall3(int,     open,            const char*, p, 
-                       int,            f, int,    m) 
-  LSS_INLINE _syscall2(int,     prctl,           int,         o, 
-                       long,           a) 
-  LSS_INLINE _syscall4(long,    ptrace,          int,         r, 
-                       pid_t,          p, void *, a, void *, d) 
-  LSS_INLINE _syscall3(ssize_t, read,            int,         f, 
-                       void *,         b, size_t, c) 
-  LSS_INLINE _syscall4(int,     rt_sigaction,    int,         s, 
-                       const struct kernel_sigaction*, a, 
-                       struct kernel_sigaction*, o, size_t,   c) 
-  LSS_INLINE _syscall4(int, rt_sigprocmask,      int,         h, 
-                       const struct kernel_sigset_t*,  s, 
-                       struct kernel_sigset_t*,        o, size_t, c); 
-  LSS_INLINE _syscall0(int,     sched_yield) 
-  LSS_INLINE _syscall2(int,     sigaltstack,     const stack_t*, s, 
-                       const stack_t*, o) 
-  LSS_INLINE _syscall2(int,     stat,            const char*, f, 
-                      struct kernel_stat*,   b) 
-  LSS_INLINE _syscall3(ssize_t, write,            int,        f, 
-                       const void *,   b, size_t, c) 
-  #if defined(__NR_getcpu) 
-    LSS_INLINE _syscall3(long, getcpu, unsigned *, cpu, 
-                         unsigned *, node, void *, unused); 
-  #endif 
-  #if defined(__x86_64__) ||                                                  \ 
-     (defined(__mips__) && _MIPS_SIM != _MIPS_SIM_ABI32) 
-    LSS_INLINE _syscall3(int, socket,             int,   d, 
-                         int,                     t, int,       p) 
-  #endif 
-  #if defined(__x86_64__) 
-    LSS_INLINE _syscall6(void*, mmap,              void*, s, 
-                         size_t,                   l, int,               p, 
-                         int,                      f, int,               d, 
-                         off64_t,                o) 
- 
-    LSS_INLINE int LSS_NAME(sigaction)(int signum, 
-                                       const struct kernel_sigaction *act, 
-                                       struct kernel_sigaction *oldact) { 
-      /* On x86_64, the kernel requires us to always set our own 
-       * SA_RESTORER in order to be able to return from a signal handler. 
-       * This function must have a "magic" signature that the "gdb" 
-       * (and maybe the kernel?) can recognize. 
-       */ 
-      if (act != NULL && !(act->sa_flags & SA_RESTORER)) { 
-        struct kernel_sigaction a = *act; 
-        a.sa_flags   |= SA_RESTORER; 
-        a.sa_restorer = LSS_NAME(restore_rt)(); 
-        return LSS_NAME(rt_sigaction)(signum, &a, oldact, 
-                                      (KERNEL_NSIG+7)/8); 
-      } else { 
-        return LSS_NAME(rt_sigaction)(signum, act, oldact, 
-                                      (KERNEL_NSIG+7)/8); 
-      } 
-    } 
- 
-    LSS_INLINE int LSS_NAME(sigprocmask)(int how, 
-                                         const struct kernel_sigset_t *set, 
-                                         struct kernel_sigset_t *oldset) { 
-      return LSS_NAME(rt_sigprocmask)(how, set, oldset, (KERNEL_NSIG+7)/8); 
-    } 
-  #endif 
-  #if defined(__x86_64__) || \ 
-      defined(__arm__) || \ 
-     (defined(__mips__) && _MIPS_SIM != _MIPS_SIM_ABI32) 
-    LSS_INLINE _syscall4(pid_t, wait4,            pid_t, p, 
-                         int*,                    s, int,       o, 
-                         struct kernel_rusage*,   r) 
-    LSS_INLINE pid_t LSS_NAME(waitpid)(pid_t pid, int *status, int options){ 
-      return LSS_NAME(wait4)(pid, status, options, 0); 
-    } 
-   #endif 
-  #if defined(__i386__) || defined(__x86_64__) || defined(__arm__) 
-    LSS_INLINE _syscall4(int, openat, int, d, const char *, p, int, f, int, m) 
-  #endif 
-  LSS_INLINE int LSS_NAME(sigemptyset)(struct kernel_sigset_t *set) { 
-    memset(&set->sig, 0, sizeof(set->sig)); 
-    return 0; 
-  } 
- 
-  LSS_INLINE int LSS_NAME(sigfillset)(struct kernel_sigset_t *set) { 
-    memset(&set->sig, -1, sizeof(set->sig)); 
-    return 0; 
-  } 
- 
-  LSS_INLINE int LSS_NAME(sigaddset)(struct kernel_sigset_t *set, 
-                                     int signum) { 
-    if (signum < 1 || signum > (int)(8*sizeof(set->sig))) { 
-      LSS_ERRNO = EINVAL; 
-      return -1; 
-    } else { 
-      set->sig[(signum - 1)/(8*sizeof(set->sig[0]))] 
-          |= 1UL << ((signum - 1) % (8*sizeof(set->sig[0]))); 
-      return 0; 
-    } 
-  } 
- 
-  LSS_INLINE int LSS_NAME(sigdelset)(struct kernel_sigset_t *set, 
-                                        int signum) { 
-    if (signum < 1 || signum > (int)(8*sizeof(set->sig))) { 
-      LSS_ERRNO = EINVAL; 
-      return -1; 
-    } else { 
-      set->sig[(signum - 1)/(8*sizeof(set->sig[0]))] 
-          &= ~(1UL << ((signum - 1) % (8*sizeof(set->sig[0])))); 
-      return 0; 
-    } 
-  } 
- 
-  #if defined(__i386__) || \ 
-      defined(__arm__) || \ 
-     (defined(__mips__) && _MIPS_SIM == _MIPS_SIM_ABI32) || defined(__PPC__) 
-    #define __NR__sigaction   __NR_sigaction 
-    #define __NR__sigprocmask __NR_sigprocmask 
-    LSS_INLINE _syscall2(int, fstat64,             int, f, 
-                         struct kernel_stat64 *, b) 
-    LSS_INLINE _syscall5(int, _llseek,     uint, fd, ulong, hi, ulong, lo, 
-                         loff_t *, res, uint, wh) 
-#ifdef __PPC64__ 
-    LSS_INLINE _syscall6(void*, mmap,              void*, s, 
-                         size_t,                   l, int,               p, 
-                         int,                      f, int,               d, 
-                         off_t,                    o) 
-#else 
-    #ifndef __ARM_EABI__ 
-    /* Not available on ARM EABI Linux.  */ 
-    LSS_INLINE _syscall1(void*, mmap,              void*, a) 
-    #endif 
-    LSS_INLINE _syscall6(void*, mmap2,             void*, s, 
-                         size_t,                   l, int,               p, 
-                         int,                      f, int,               d, 
-                         off_t,                    o) 
-#endif 
-    LSS_INLINE _syscall3(int,   _sigaction,        int,   s, 
-                         const struct kernel_old_sigaction*,  a, 
-                         struct kernel_old_sigaction*,        o) 
-    LSS_INLINE _syscall3(int,   _sigprocmask,      int,   h, 
-                         const unsigned long*,     s, 
-                         unsigned long*,           o) 
-    LSS_INLINE _syscall2(int, stat64,              const char *, p, 
-                         struct kernel_stat64 *, b) 
- 
-    LSS_INLINE int LSS_NAME(sigaction)(int signum, 
-                                       const struct kernel_sigaction *act, 
-                                       struct kernel_sigaction *oldact) { 
-      int old_errno = LSS_ERRNO; 
-      int rc; 
-      struct kernel_sigaction a; 
-      if (act != NULL) { 
-        a             = *act; 
-        #ifdef __i386__ 
-        /* On i386, the kernel requires us to always set our own 
-         * SA_RESTORER when using realtime signals. Otherwise, it does not 
-         * know how to return from a signal handler. This function must have 
-         * a "magic" signature that the "gdb" (and maybe the kernel?) can 
-         * recognize. 
-         * Apparently, a SA_RESTORER is implicitly set by the kernel, when 
-         * using non-realtime signals. 
-         * 
-         * TODO: Test whether ARM needs a restorer 
-         */ 
-        if (!(a.sa_flags & SA_RESTORER)) { 
-          a.sa_flags   |= SA_RESTORER; 
-          a.sa_restorer = (a.sa_flags & SA_SIGINFO) 
-                          ? LSS_NAME(restore_rt)() : LSS_NAME(restore)(); 
-        } 
-        #endif 
-      } 
-      rc = LSS_NAME(rt_sigaction)(signum, act ? &a : act, oldact, 
-                                  (KERNEL_NSIG+7)/8); 
-      if (rc < 0 && LSS_ERRNO == ENOSYS) { 
-        struct kernel_old_sigaction oa, ooa, *ptr_a = &oa, *ptr_oa = &ooa; 
-        if (!act) { 
-          ptr_a            = NULL; 
-        } else { 
-          oa.sa_handler_   = act->sa_handler_; 
-          memcpy(&oa.sa_mask, &act->sa_mask, sizeof(oa.sa_mask)); 
-          #ifndef __mips__ 
-          oa.sa_restorer   = act->sa_restorer; 
-          #endif 
-          oa.sa_flags      = act->sa_flags; 
-        } 
-        if (!oldact) { 
-          ptr_oa           = NULL; 
-        } 
-        LSS_ERRNO = old_errno; 
-        rc = LSS_NAME(_sigaction)(signum, ptr_a, ptr_oa); 
-        if (rc == 0 && oldact) { 
-          if (act) { 
-            memcpy(oldact, act, sizeof(*act)); 
-          } else { 
-            memset(oldact, 0, sizeof(*oldact)); 
-          } 
-          oldact->sa_handler_    = ptr_oa->sa_handler_; 
-          oldact->sa_flags       = ptr_oa->sa_flags; 
-          memcpy(&oldact->sa_mask, &ptr_oa->sa_mask, sizeof(ptr_oa->sa_mask)); 
-          #ifndef __mips__ 
-          oldact->sa_restorer    = ptr_oa->sa_restorer; 
-          #endif 
-        } 
-      } 
-      return rc; 
-    } 
- 
-    LSS_INLINE int LSS_NAME(sigprocmask)(int how, 
-                                         const struct kernel_sigset_t *set, 
-                                         struct kernel_sigset_t *oldset) { 
-      int olderrno = LSS_ERRNO; 
-      int rc = LSS_NAME(rt_sigprocmask)(how, set, oldset, (KERNEL_NSIG+7)/8); 
-      if (rc < 0 && LSS_ERRNO == ENOSYS) { 
-        LSS_ERRNO = olderrno; 
-        if (oldset) { 
-          LSS_NAME(sigemptyset)(oldset); 
-        } 
-        rc = LSS_NAME(_sigprocmask)(how, 
-                                    set ? &set->sig[0] : NULL, 
-                                    oldset ? &oldset->sig[0] : NULL); 
-      } 
-      return rc; 
-    } 
-  #endif 
-  #if defined(__PPC__) 
-    #undef LSS_SC_LOADARGS_0 
-    #define LSS_SC_LOADARGS_0(dummy...) 
-    #undef LSS_SC_LOADARGS_1 
-    #define LSS_SC_LOADARGS_1(arg1)                                           \ 
-        __sc_4  = (unsigned long) (arg1) 
-    #undef LSS_SC_LOADARGS_2 
-    #define LSS_SC_LOADARGS_2(arg1, arg2)                                     \ 
-        LSS_SC_LOADARGS_1(arg1);                                              \ 
-        __sc_5  = (unsigned long) (arg2) 
-    #undef LSS_SC_LOADARGS_3 
-    #define LSS_SC_LOADARGS_3(arg1, arg2, arg3)                               \ 
-        LSS_SC_LOADARGS_2(arg1, arg2);                                        \ 
-        __sc_6  = (unsigned long) (arg3) 
-    #undef LSS_SC_LOADARGS_4 
-    #define LSS_SC_LOADARGS_4(arg1, arg2, arg3, arg4)                         \ 
-        LSS_SC_LOADARGS_3(arg1, arg2, arg3);                                  \ 
-        __sc_7  = (unsigned long) (arg4) 
-    #undef LSS_SC_LOADARGS_5 
-    #define LSS_SC_LOADARGS_5(arg1, arg2, arg3, arg4, arg5)                   \ 
-        LSS_SC_LOADARGS_4(arg1, arg2, arg3, arg4);                            \ 
-        __sc_8  = (unsigned long) (arg5) 
-    #undef LSS_SC_BODY 
-    #define LSS_SC_BODY(nr, type, opt, args...)                               \ 
-        long __sc_ret, __sc_err;                                              \ 
-        {                                                                     \ 
+        __asm__ __volatile__(
+            /* check for fn == NULL
+             * and child_stack == NULL
+             */
+            "cmpwi cr0, %6, 0\n\t"
+            "cmpwi cr1, %7, 0\n\t"
+            "cror cr0*4+eq, cr1*4+eq, cr0*4+eq\n\t"
+            "beq- cr0, 1f\n\t"
+
+            /* set up stack frame for child                                  */
+            "clrrwi %7, %7, 4\n\t"
+            "li 0, 0\n\t"
+            "stwu 0, -16(%7)\n\t"
+
+            /* fn, arg, child_stack are saved across the syscall: r28-30     */
+            "mr 28, %6\n\t"
+            "mr 29, %7\n\t"
+            "mr 27, %9\n\t"
+
+            /* syscall                                                       */
+            "li 0, %4\n\t"
+            /* flags already in r3
+             * child_stack already in r4
+             * ptidptr already in r5
+             * newtls already in r6
+             * ctidptr already in r7
+             */
+            "sc\n\t"
+
+            /* Test if syscall was successful                                */
+            "cmpwi cr1, 3, 0\n\t"
+            "crandc cr1*4+eq, cr1*4+eq, cr0*4+so\n\t"
+            "bne- cr1, 1f\n\t"
+
+            /* Do the function call                                          */
+            "mtctr 28\n\t"
+            "mr 3, 27\n\t"
+            "bctrl\n\t"
+
+            /* Call _exit(r3)                                                */
+            "li 0, %5\n\t"
+            "sc\n\t"
+
+            /* Return to parent                                              */
+            "1:\n"
+            "mfcr %1\n\t"
+            "mr %0, 3\n\t"
+              : "=r" (__ret), "=r" (__err)
+              : "0" (-1), "1" (EINVAL),
+                "i" (__NR_clone), "i" (__NR_exit),
+                "r" (__fn), "r" (__cstack), "r" (__flags),
+                "r" (__arg), "r" (__ptidptr), "r" (__newtls),
+                "r" (__ctidptr)
+              : "cr0", "cr1", "memory", "ctr",
+                "r0", "r29", "r27", "r28");
+      }
+      LSS_RETURN(int, __ret, __err);
+    }
+  #endif
+  #define __NR__exit   __NR_exit
+  #define __NR__gettid __NR_gettid
+  #define __NR__mremap __NR_mremap
+  LSS_INLINE _syscall1(int,     close,           int,         f)
+  LSS_INLINE _syscall1(int,     _exit,           int,         e)
+  LSS_INLINE _syscall3(int,     fcntl,           int,         f,
+                       int,            c, long,   a)
+  LSS_INLINE _syscall2(int,     fstat,           int,         f,
+                      struct kernel_stat*,   b)
+  LSS_INLINE _syscall4(int,     futex,           int*,        a,
+                       int,            o, int,    v,
+                      struct kernel_timespec*, t)
+  LSS_INLINE _syscall3(int,     getdents,        int,         f,
+                      struct kernel_dirent*, d, int,    c)
+#ifdef __NR_getdents64
+  LSS_INLINE _syscall3(int,     getdents64,      int,         f,
+                      struct kernel_dirent64*, d, int,    c)
+#endif
+  LSS_INLINE _syscall0(pid_t,   getpid)
+  LSS_INLINE _syscall0(pid_t,   getppid)
+  LSS_INLINE _syscall0(pid_t,   _gettid)
+  LSS_INLINE _syscall2(int,     kill,            pid_t,       p,
+                       int,            s)
+  LSS_INLINE _syscall3(off_t,   lseek,           int,         f,
+                       off_t,          o, int,    w)
+  LSS_INLINE _syscall2(int,     munmap,          void*,       s,
+                       size_t,         l)
+  LSS_INLINE _syscall5(void*,   _mremap,         void*,       o,
+                       size_t,         os,       size_t,      ns,
+                       unsigned long,  f, void *, a)
+  LSS_INLINE _syscall3(int,     open,            const char*, p,
+                       int,            f, int,    m)
+  LSS_INLINE _syscall2(int,     prctl,           int,         o,
+                       long,           a)
+  LSS_INLINE _syscall4(long,    ptrace,          int,         r,
+                       pid_t,          p, void *, a, void *, d)
+  LSS_INLINE _syscall3(ssize_t, read,            int,         f,
+                       void *,         b, size_t, c)
+  LSS_INLINE _syscall4(int,     rt_sigaction,    int,         s,
+                       const struct kernel_sigaction*, a,
+                       struct kernel_sigaction*, o, size_t,   c)
+  LSS_INLINE _syscall4(int, rt_sigprocmask,      int,         h,
+                       const struct kernel_sigset_t*,  s,
+                       struct kernel_sigset_t*,        o, size_t, c);
+  LSS_INLINE _syscall0(int,     sched_yield)
+  LSS_INLINE _syscall2(int,     sigaltstack,     const stack_t*, s,
+                       const stack_t*, o)
+  LSS_INLINE _syscall2(int,     stat,            const char*, f,
+                      struct kernel_stat*,   b)
+  LSS_INLINE _syscall3(ssize_t, write,            int,        f,
+                       const void *,   b, size_t, c)
+  #if defined(__NR_getcpu)
+    LSS_INLINE _syscall3(long, getcpu, unsigned *, cpu,
+                         unsigned *, node, void *, unused);
+  #endif
+  #if defined(__x86_64__) ||                                                  \
+     (defined(__mips__) && _MIPS_SIM != _MIPS_SIM_ABI32)
+    LSS_INLINE _syscall3(int, socket,             int,   d,
+                         int,                     t, int,       p)
+  #endif
+  #if defined(__x86_64__)
+    LSS_INLINE _syscall6(void*, mmap,              void*, s,
+                         size_t,                   l, int,               p,
+                         int,                      f, int,               d,
+                         off64_t,                o)
+
+    LSS_INLINE int LSS_NAME(sigaction)(int signum,
+                                       const struct kernel_sigaction *act,
+                                       struct kernel_sigaction *oldact) {
+      /* On x86_64, the kernel requires us to always set our own
+       * SA_RESTORER in order to be able to return from a signal handler.
+       * This function must have a "magic" signature that the "gdb"
+       * (and maybe the kernel?) can recognize.
+       */
+      if (act != NULL && !(act->sa_flags & SA_RESTORER)) {
+        struct kernel_sigaction a = *act;
+        a.sa_flags   |= SA_RESTORER;
+        a.sa_restorer = LSS_NAME(restore_rt)();
+        return LSS_NAME(rt_sigaction)(signum, &a, oldact,
+                                      (KERNEL_NSIG+7)/8);
+      } else {
+        return LSS_NAME(rt_sigaction)(signum, act, oldact,
+                                      (KERNEL_NSIG+7)/8);
+      }
+    }
+
+    LSS_INLINE int LSS_NAME(sigprocmask)(int how,
+                                         const struct kernel_sigset_t *set,
+                                         struct kernel_sigset_t *oldset) {
+      return LSS_NAME(rt_sigprocmask)(how, set, oldset, (KERNEL_NSIG+7)/8);
+    }
+  #endif
+  #if defined(__x86_64__) || \
+      defined(__arm__) || \
+     (defined(__mips__) && _MIPS_SIM != _MIPS_SIM_ABI32)
+    LSS_INLINE _syscall4(pid_t, wait4,            pid_t, p,
+                         int*,                    s, int,       o,
+                         struct kernel_rusage*,   r)
+    LSS_INLINE pid_t LSS_NAME(waitpid)(pid_t pid, int *status, int options){
+      return LSS_NAME(wait4)(pid, status, options, 0);
+    }
+   #endif
+  #if defined(__i386__) || defined(__x86_64__) || defined(__arm__)
+    LSS_INLINE _syscall4(int, openat, int, d, const char *, p, int, f, int, m)
+  #endif
+  LSS_INLINE int LSS_NAME(sigemptyset)(struct kernel_sigset_t *set) {
+    memset(&set->sig, 0, sizeof(set->sig));
+    return 0;
+  }
+
+  LSS_INLINE int LSS_NAME(sigfillset)(struct kernel_sigset_t *set) {
+    memset(&set->sig, -1, sizeof(set->sig));
+    return 0;
+  }
+
+  LSS_INLINE int LSS_NAME(sigaddset)(struct kernel_sigset_t *set,
+                                     int signum) {
+    if (signum < 1 || signum > (int)(8*sizeof(set->sig))) {
+      LSS_ERRNO = EINVAL;
+      return -1;
+    } else {
+      set->sig[(signum - 1)/(8*sizeof(set->sig[0]))]
+          |= 1UL << ((signum - 1) % (8*sizeof(set->sig[0])));
+      return 0;
+    }
+  }
+
+  LSS_INLINE int LSS_NAME(sigdelset)(struct kernel_sigset_t *set,
+                                        int signum) {
+    if (signum < 1 || signum > (int)(8*sizeof(set->sig))) {
+      LSS_ERRNO = EINVAL;
+      return -1;
+    } else {
+      set->sig[(signum - 1)/(8*sizeof(set->sig[0]))]
+          &= ~(1UL << ((signum - 1) % (8*sizeof(set->sig[0]))));
+      return 0;
+    }
+  }
+
+  #if defined(__i386__) || \
+      defined(__arm__) || \
+     (defined(__mips__) && _MIPS_SIM == _MIPS_SIM_ABI32) || defined(__PPC__)
+    #define __NR__sigaction   __NR_sigaction
+    #define __NR__sigprocmask __NR_sigprocmask
+    LSS_INLINE _syscall2(int, fstat64,             int, f,
+                         struct kernel_stat64 *, b)
+    LSS_INLINE _syscall5(int, _llseek,     uint, fd, ulong, hi, ulong, lo,
+                         loff_t *, res, uint, wh)
+#ifdef __PPC64__
+    LSS_INLINE _syscall6(void*, mmap,              void*, s,
+                         size_t,                   l, int,               p,
+                         int,                      f, int,               d,
+                         off_t,                    o)
+#else
+    #ifndef __ARM_EABI__
+    /* Not available on ARM EABI Linux.  */
+    LSS_INLINE _syscall1(void*, mmap,              void*, a)
+    #endif
+    LSS_INLINE _syscall6(void*, mmap2,             void*, s,
+                         size_t,                   l, int,               p,
+                         int,                      f, int,               d,
+                         off_t,                    o)
+#endif
+    LSS_INLINE _syscall3(int,   _sigaction,        int,   s,
+                         const struct kernel_old_sigaction*,  a,
+                         struct kernel_old_sigaction*,        o)
+    LSS_INLINE _syscall3(int,   _sigprocmask,      int,   h,
+                         const unsigned long*,     s,
+                         unsigned long*,           o)
+    LSS_INLINE _syscall2(int, stat64,              const char *, p,
+                         struct kernel_stat64 *, b)
+
+    LSS_INLINE int LSS_NAME(sigaction)(int signum,
+                                       const struct kernel_sigaction *act,
+                                       struct kernel_sigaction *oldact) {
+      int old_errno = LSS_ERRNO;
+      int rc;
+      struct kernel_sigaction a;
+      if (act != NULL) {
+        a             = *act;
+        #ifdef __i386__
+        /* On i386, the kernel requires us to always set our own
+         * SA_RESTORER when using realtime signals. Otherwise, it does not
+         * know how to return from a signal handler. This function must have
+         * a "magic" signature that the "gdb" (and maybe the kernel?) can
+         * recognize.
+         * Apparently, a SA_RESTORER is implicitly set by the kernel, when
+         * using non-realtime signals.
+         *
+         * TODO: Test whether ARM needs a restorer
+         */
+        if (!(a.sa_flags & SA_RESTORER)) {
+          a.sa_flags   |= SA_RESTORER;
+          a.sa_restorer = (a.sa_flags & SA_SIGINFO)
+                          ? LSS_NAME(restore_rt)() : LSS_NAME(restore)();
+        }
+        #endif
+      }
+      rc = LSS_NAME(rt_sigaction)(signum, act ? &a : act, oldact,
+                                  (KERNEL_NSIG+7)/8);
+      if (rc < 0 && LSS_ERRNO == ENOSYS) {
+        struct kernel_old_sigaction oa, ooa, *ptr_a = &oa, *ptr_oa = &ooa;
+        if (!act) {
+          ptr_a            = NULL;
+        } else {
+          oa.sa_handler_   = act->sa_handler_;
+          memcpy(&oa.sa_mask, &act->sa_mask, sizeof(oa.sa_mask));
+          #ifndef __mips__
+          oa.sa_restorer   = act->sa_restorer;
+          #endif
+          oa.sa_flags      = act->sa_flags;
+        }
+        if (!oldact) {
+          ptr_oa           = NULL;
+        }
+        LSS_ERRNO = old_errno;
+        rc = LSS_NAME(_sigaction)(signum, ptr_a, ptr_oa);
+        if (rc == 0 && oldact) {
+          if (act) {
+            memcpy(oldact, act, sizeof(*act));
+          } else {
+            memset(oldact, 0, sizeof(*oldact));
+          }
+          oldact->sa_handler_    = ptr_oa->sa_handler_;
+          oldact->sa_flags       = ptr_oa->sa_flags;
+          memcpy(&oldact->sa_mask, &ptr_oa->sa_mask, sizeof(ptr_oa->sa_mask));
+          #ifndef __mips__
+          oldact->sa_restorer    = ptr_oa->sa_restorer;
+          #endif
+        }
+      }
+      return rc;
+    }
+
+    LSS_INLINE int LSS_NAME(sigprocmask)(int how,
+                                         const struct kernel_sigset_t *set,
+                                         struct kernel_sigset_t *oldset) {
+      int olderrno = LSS_ERRNO;
+      int rc = LSS_NAME(rt_sigprocmask)(how, set, oldset, (KERNEL_NSIG+7)/8);
+      if (rc < 0 && LSS_ERRNO == ENOSYS) {
+        LSS_ERRNO = olderrno;
+        if (oldset) {
+          LSS_NAME(sigemptyset)(oldset);
+        }
+        rc = LSS_NAME(_sigprocmask)(how,
+                                    set ? &set->sig[0] : NULL,
+                                    oldset ? &oldset->sig[0] : NULL);
+      }
+      return rc;
+    }
+  #endif
+  #if defined(__PPC__)
+    #undef LSS_SC_LOADARGS_0
+    #define LSS_SC_LOADARGS_0(dummy...)
+    #undef LSS_SC_LOADARGS_1
+    #define LSS_SC_LOADARGS_1(arg1)                                           \
+        __sc_4  = (unsigned long) (arg1)
+    #undef LSS_SC_LOADARGS_2
+    #define LSS_SC_LOADARGS_2(arg1, arg2)                                     \
+        LSS_SC_LOADARGS_1(arg1);                                              \
+        __sc_5  = (unsigned long) (arg2)
+    #undef LSS_SC_LOADARGS_3
+    #define LSS_SC_LOADARGS_3(arg1, arg2, arg3)                               \
+        LSS_SC_LOADARGS_2(arg1, arg2);                                        \
+        __sc_6  = (unsigned long) (arg3)
+    #undef LSS_SC_LOADARGS_4
+    #define LSS_SC_LOADARGS_4(arg1, arg2, arg3, arg4)                         \
+        LSS_SC_LOADARGS_3(arg1, arg2, arg3);                                  \
+        __sc_7  = (unsigned long) (arg4)
+    #undef LSS_SC_LOADARGS_5
+    #define LSS_SC_LOADARGS_5(arg1, arg2, arg3, arg4, arg5)                   \
+        LSS_SC_LOADARGS_4(arg1, arg2, arg3, arg4);                            \
+        __sc_8  = (unsigned long) (arg5)
+    #undef LSS_SC_BODY
+    #define LSS_SC_BODY(nr, type, opt, args...)                               \
+        long __sc_ret, __sc_err;                                              \
+        {                                                                     \
           unsigned long __sc_0 __asm__ ("r0") = __NR_socketcall;     \
           unsigned long __sc_3 __asm__ ("r3") = opt;                 \
           unsigned long __sc_4 __asm__ ("r4");                       \
@@ -2061,125 +2061,125 @@ struct kernel_stat {
           unsigned long __sc_6 __asm__ ("r6");                       \
           unsigned long __sc_7 __asm__ ("r7");                       \
           unsigned long __sc_8 __asm__ ("r8");                       \
-          LSS_SC_LOADARGS_##nr(args);                                         \ 
-          __asm__ __volatile__                                                \ 
-              ("stwu 1, -48(1)\n\t"                                           \ 
-               "stw 4, 20(1)\n\t"                                             \ 
-               "stw 5, 24(1)\n\t"                                             \ 
-               "stw 6, 28(1)\n\t"                                             \ 
-               "stw 7, 32(1)\n\t"                                             \ 
-               "stw 8, 36(1)\n\t"                                             \ 
-               "addi 4, 1, 20\n\t"                                            \ 
-               "sc\n\t"                                                       \ 
-               "mfcr %0"                                                      \ 
-                 : "=&r" (__sc_0),                                            \ 
-                   "=&r" (__sc_3), "=&r" (__sc_4),                            \ 
-                   "=&r" (__sc_5), "=&r" (__sc_6),                            \ 
-                   "=&r" (__sc_7), "=&r" (__sc_8)                             \ 
-                 : LSS_ASMINPUT_##nr                                          \ 
-                 : "cr0", "ctr", "memory");                                   \ 
-          __sc_ret = __sc_3;                                                  \ 
-          __sc_err = __sc_0;                                                  \ 
-        }                                                                     \ 
-        LSS_RETURN(type, __sc_ret, __sc_err) 
- 
-    LSS_INLINE int LSS_NAME(socket)(int domain, int type, int protocol) { 
-      LSS_SC_BODY(3, int, 1, domain, type, protocol); 
-    } 
-  #endif 
-  #if defined(__i386__) || \ 
-      (defined(__arm__) && !defined(__ARM_EABI__)) || \ 
-      (defined(__mips__) && _MIPS_SIM == _MIPS_SIM_ABI32) 
- 
-    /* See sys_socketcall in net/socket.c in kernel source. 
-     * It de-multiplexes on its first arg and unpacks the arglist 
-     * array in its second arg. 
-     */ 
-    LSS_INLINE _syscall2(long, socketcall, int, c, unsigned long*, a) 
- 
-    LSS_INLINE int LSS_NAME(socket)(int domain, int type, int protocol) { 
-      unsigned long args[3] = { 
-        (unsigned long) domain, 
-        (unsigned long) type, 
-        (unsigned long) protocol 
-      }; 
-      return LSS_NAME(socketcall)(1, args); 
-    } 
-  #elif defined(__ARM_EABI__) 
-    LSS_INLINE _syscall3(int, socket,             int,   d, 
-                         int,                     t, int,       p) 
-  #endif 
-  #if defined(__i386__) || defined(__PPC__) ||                                \ 
-     (defined(__mips__) && _MIPS_SIM == _MIPS_SIM_ABI32) 
-    LSS_INLINE _syscall3(pid_t, waitpid,          pid_t, p, 
-                         int*,              s,    int,   o) 
-  #endif 
-  #if defined(__mips__) 
-    /* sys_pipe() on MIPS has non-standard calling conventions, as it returns 
-     * both file handles through CPU registers. 
-     */ 
-    LSS_INLINE int LSS_NAME(pipe)(int *p) { 
+          LSS_SC_LOADARGS_##nr(args);                                         \
+          __asm__ __volatile__                                                \
+              ("stwu 1, -48(1)\n\t"                                           \
+               "stw 4, 20(1)\n\t"                                             \
+               "stw 5, 24(1)\n\t"                                             \
+               "stw 6, 28(1)\n\t"                                             \
+               "stw 7, 32(1)\n\t"                                             \
+               "stw 8, 36(1)\n\t"                                             \
+               "addi 4, 1, 20\n\t"                                            \
+               "sc\n\t"                                                       \
+               "mfcr %0"                                                      \
+                 : "=&r" (__sc_0),                                            \
+                   "=&r" (__sc_3), "=&r" (__sc_4),                            \
+                   "=&r" (__sc_5), "=&r" (__sc_6),                            \
+                   "=&r" (__sc_7), "=&r" (__sc_8)                             \
+                 : LSS_ASMINPUT_##nr                                          \
+                 : "cr0", "ctr", "memory");                                   \
+          __sc_ret = __sc_3;                                                  \
+          __sc_err = __sc_0;                                                  \
+        }                                                                     \
+        LSS_RETURN(type, __sc_ret, __sc_err)
+
+    LSS_INLINE int LSS_NAME(socket)(int domain, int type, int protocol) {
+      LSS_SC_BODY(3, int, 1, domain, type, protocol);
+    }
+  #endif
+  #if defined(__i386__) || \
+      (defined(__arm__) && !defined(__ARM_EABI__)) || \
+      (defined(__mips__) && _MIPS_SIM == _MIPS_SIM_ABI32)
+
+    /* See sys_socketcall in net/socket.c in kernel source.
+     * It de-multiplexes on its first arg and unpacks the arglist
+     * array in its second arg.
+     */
+    LSS_INLINE _syscall2(long, socketcall, int, c, unsigned long*, a)
+
+    LSS_INLINE int LSS_NAME(socket)(int domain, int type, int protocol) {
+      unsigned long args[3] = {
+        (unsigned long) domain,
+        (unsigned long) type,
+        (unsigned long) protocol
+      };
+      return LSS_NAME(socketcall)(1, args);
+    }
+  #elif defined(__ARM_EABI__)
+    LSS_INLINE _syscall3(int, socket,             int,   d,
+                         int,                     t, int,       p)
+  #endif
+  #if defined(__i386__) || defined(__PPC__) ||                                \
+     (defined(__mips__) && _MIPS_SIM == _MIPS_SIM_ABI32)
+    LSS_INLINE _syscall3(pid_t, waitpid,          pid_t, p,
+                         int*,              s,    int,   o)
+  #endif
+  #if defined(__mips__)
+    /* sys_pipe() on MIPS has non-standard calling conventions, as it returns
+     * both file handles through CPU registers.
+     */
+    LSS_INLINE int LSS_NAME(pipe)(int *p) {
       unsigned long __v0 __asm__("$2") = __NR_pipe;
       unsigned long __v1 __asm__("$3");
       unsigned long __r7 __asm__("$7");
-      __asm__ __volatile__ ("syscall\n" 
-                            : "=&r"(__v0), "=&r"(__v1), "+r" (__r7) 
-                            : "0"(__v0) 
-                            : "$8", "$9", "$10", "$11", "$12", 
-                              "$13", "$14", "$15", "$24", "memory"); 
-      if (__r7) { 
-        LSS_ERRNO = __v0; 
-        return -1; 
-      } else { 
-        p[0] = __v0; 
-        p[1] = __v1; 
-        return 0; 
-      } 
-    } 
-  #else 
-    LSS_INLINE _syscall1(int,     pipe,           int *, p) 
-  #endif 
- 
-  LSS_INLINE pid_t LSS_NAME(gettid)() { 
-    pid_t tid = LSS_NAME(_gettid)(); 
-    if (tid != -1) { 
-      return tid; 
-    } 
-    return LSS_NAME(getpid)(); 
-  } 
- 
-  LSS_INLINE void *LSS_NAME(mremap)(void *old_address, size_t old_size, 
-                                    size_t new_size, int flags, ...) { 
-    va_list ap; 
-    void *new_address, *rc; 
-    va_start(ap, flags); 
-    new_address = va_arg(ap, void *); 
-    rc = LSS_NAME(_mremap)(old_address, old_size, new_size, 
-                           flags, new_address); 
-    va_end(ap); 
-    return rc; 
-  } 
- 
-  LSS_INLINE int LSS_NAME(ptrace_detach)(pid_t pid) { 
-    /* PTRACE_DETACH can sometimes forget to wake up the tracee and it 
-     * then sends job control signals to the real parent, rather than to 
-     * the tracer. We reduce the risk of this happening by starting a 
-     * whole new time slice, and then quickly sending a SIGCONT signal 
-     * right after detaching from the tracee. 
-     */ 
-    int rc, err; 
-    LSS_NAME(sched_yield)(); 
-    rc = LSS_NAME(ptrace)(PTRACE_DETACH, pid, (void *)0, (void *)0); 
-    err = LSS_ERRNO; 
-    LSS_NAME(kill)(pid, SIGCONT); 
-    LSS_ERRNO = err; 
-    return rc; 
-  } 
-#endif 
- 
-#if defined(__cplusplus) && !defined(SYS_CPLUSPLUS) 
-} 
-#endif 
- 
-#endif 
-#endif 
+      __asm__ __volatile__ ("syscall\n"
+                            : "=&r"(__v0), "=&r"(__v1), "+r" (__r7)
+                            : "0"(__v0)
+                            : "$8", "$9", "$10", "$11", "$12",
+                              "$13", "$14", "$15", "$24", "memory");
+      if (__r7) {
+        LSS_ERRNO = __v0;
+        return -1;
+      } else {
+        p[0] = __v0;
+        p[1] = __v1;
+        return 0;
+      }
+    }
+  #else
+    LSS_INLINE _syscall1(int,     pipe,           int *, p)
+  #endif
+
+  LSS_INLINE pid_t LSS_NAME(gettid)() {
+    pid_t tid = LSS_NAME(_gettid)();
+    if (tid != -1) {
+      return tid;
+    }
+    return LSS_NAME(getpid)();
+  }
+
+  LSS_INLINE void *LSS_NAME(mremap)(void *old_address, size_t old_size,
+                                    size_t new_size, int flags, ...) {
+    va_list ap;
+    void *new_address, *rc;
+    va_start(ap, flags);
+    new_address = va_arg(ap, void *);
+    rc = LSS_NAME(_mremap)(old_address, old_size, new_size,
+                           flags, new_address);
+    va_end(ap);
+    return rc;
+  }
+
+  LSS_INLINE int LSS_NAME(ptrace_detach)(pid_t pid) {
+    /* PTRACE_DETACH can sometimes forget to wake up the tracee and it
+     * then sends job control signals to the real parent, rather than to
+     * the tracer. We reduce the risk of this happening by starting a
+     * whole new time slice, and then quickly sending a SIGCONT signal
+     * right after detaching from the tracee.
+     */
+    int rc, err;
+    LSS_NAME(sched_yield)();
+    rc = LSS_NAME(ptrace)(PTRACE_DETACH, pid, (void *)0, (void *)0);
+    err = LSS_ERRNO;
+    LSS_NAME(kill)(pid, SIGCONT);
+    LSS_ERRNO = err;
+    return rc;
+  }
+#endif
+
+#if defined(__cplusplus) && !defined(SYS_CPLUSPLUS)
+}
+#endif
+
+#endif
+#endif
diff --git a/contrib/libs/linuxvdso/original/logging.h b/contrib/libs/linuxvdso/original/logging.h
index c61eab18e3..209714ccd0 100644
--- a/contrib/libs/linuxvdso/original/logging.h
+++ b/contrib/libs/linuxvdso/original/logging.h
@@ -1,154 +1,154 @@
-#pragma once 
- 
-// Copyright (c) 2005, Google Inc. 
-// 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. 
-//     * Neither the name of Google Inc. nor the names of its 
-// contributors may be used to endorse or promote products derived from 
-// this software without specific prior written permission. 
-// 
-// 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. 
- 
-// --- 
-// This file contains #include information about logging-related stuff. 
-// Pretty much everybody needs to #include this file so that they can 
-// log various happenings. 
-// 
-#ifndef _LOGGING_H_ 
-#define _LOGGING_H_ 
- 
-#include <string.h> 
-#include <stdio.h> 
-#include <unistd.h> 
- 
-#define WRITE_TO_STDERR(buf, len) write(STDERR_FILENO, buf, len) 
- 
-#define CHECK(condition)                                                \ 
-  do {                                                                  \ 
-    if (!(condition)) {                                                 \ 
-      WRITE_TO_STDERR("Check failed: " #condition "\n",                 \ 
-                      sizeof("Check failed: " #condition "\n")-1);      \ 
-      abort();                                                          \ 
-    }                                                                   \ 
-  } while (0) 
- 
-// This takes a message to print.  The name is historical. 
-#define RAW_CHECK(condition, message)                                          \ 
-  do {                                                                         \ 
-    if (!(condition)) {                                                        \ 
-      WRITE_TO_STDERR("Check failed: " #condition ": " message "\n",           \ 
-                      sizeof("Check failed: " #condition ": " message "\n")-1);\ 
-      abort();                                                                 \ 
-    }                                                                          \ 
-  } while (0) 
- 
-// This is like RAW_CHECK, but only in debug-mode 
-#ifdef NDEBUG 
-enum { DEBUG_MODE = 0 }; 
-#define RAW_DCHECK(condition, message) 
-#else 
-enum { DEBUG_MODE = 1 }; 
-#define RAW_DCHECK(condition, message)  RAW_CHECK(condition, message) 
-#endif 
- 
-// This prints errno as well.  Note we use write instead of printf/puts to 
-// avoid the risk we'll call malloc(). 
-#define PCHECK(condition)                                               \ 
-  do {                                                                  \ 
-    if (!(condition)) {                                                 \ 
-      const int err_no = errno;                                         \ 
-      WRITE_TO_STDERR("Check failed: " #condition ": ",                 \ 
-                      sizeof("Check failed: " #condition ": ")-1);      \ 
-      WRITE_TO_STDERR(strerror(err_no), strlen(strerror(err_no)));      \ 
-      WRITE_TO_STDERR("\n", sizeof("\n")-1);                            \ 
-      abort();                                                          \ 
-    }                                                                   \ 
-  } while (0) 
- 
-// Helper macro for binary operators; prints the two values on error 
-// Don't use this macro directly in your code, use CHECK_EQ et al below 
- 
-// WARNING: These don't compile correctly if one of the arguments is a pointer 
-// and the other is NULL. To work around this, simply static_cast NULL to the 
-// type of the desired pointer. 
- 
-// TODO(jandrews): Also print the values in case of failure.  Requires some 
-// sort of type-sensitive ToString() function. 
-#define CHECK_OP(op, val1, val2)                                        \ 
-  do {                                                                  \ 
-    if (!((val1) op (val2))) {                                          \ 
-      fprintf(stderr, "Check failed: %s %s %s\n", #val1, #op, #val2);   \ 
-      abort();                                                          \ 
-    }                                                                   \ 
-  } while (0) 
- 
-#define CHECK_EQ(val1, val2) CHECK_OP(==, val1, val2) 
-#define CHECK_NE(val1, val2) CHECK_OP(!=, val1, val2) 
-#define CHECK_LE(val1, val2) CHECK_OP(<=, val1, val2) 
-#define CHECK_LT(val1, val2) CHECK_OP(< , val1, val2) 
-#define CHECK_GE(val1, val2) CHECK_OP(>=, val1, val2) 
-#define CHECK_GT(val1, val2) CHECK_OP(> , val1, val2) 
- 
-// Synonyms for CHECK_* that are used in some unittests. 
-#define EXPECT_EQ(val1, val2) CHECK_EQ(val1, val2) 
-#define EXPECT_NE(val1, val2) CHECK_NE(val1, val2) 
-#define EXPECT_LE(val1, val2) CHECK_LE(val1, val2) 
-#define EXPECT_LT(val1, val2) CHECK_LT(val1, val2) 
-#define EXPECT_GE(val1, val2) CHECK_GE(val1, val2) 
-#define EXPECT_GT(val1, val2) CHECK_GT(val1, val2) 
-#define ASSERT_EQ(val1, val2) EXPECT_EQ(val1, val2) 
-#define ASSERT_NE(val1, val2) EXPECT_NE(val1, val2) 
-#define ASSERT_LE(val1, val2) EXPECT_LE(val1, val2) 
-#define ASSERT_LT(val1, val2) EXPECT_LT(val1, val2) 
-#define ASSERT_GE(val1, val2) EXPECT_GE(val1, val2) 
-#define ASSERT_GT(val1, val2) EXPECT_GT(val1, val2) 
-// As are these variants. 
-#define EXPECT_TRUE(cond)     CHECK(cond) 
-#define EXPECT_FALSE(cond)    CHECK(!(cond)) 
-#define EXPECT_STREQ(a, b)    CHECK(strcmp(a, b) == 0) 
-#define ASSERT_TRUE(cond)     EXPECT_TRUE(cond) 
-#define ASSERT_FALSE(cond)    EXPECT_FALSE(cond) 
-#define ASSERT_STREQ(a, b)    EXPECT_STREQ(a, b) 
- 
-// Used for (libc) functions that return -1 and set errno 
-#define CHECK_ERR(invocation)  PCHECK((invocation) != -1) 
- 
-// A few more checks that only happen in debug mode 
-#ifdef NDEBUG 
-#define DCHECK_EQ(val1, val2) 
-#define DCHECK_NE(val1, val2) 
-#define DCHECK_LE(val1, val2) 
-#define DCHECK_LT(val1, val2) 
-#define DCHECK_GE(val1, val2) 
-#define DCHECK_GT(val1, val2) 
-#else 
-#define DCHECK_EQ(val1, val2)  CHECK_EQ(val1, val2) 
-#define DCHECK_NE(val1, val2)  CHECK_NE(val1, val2) 
-#define DCHECK_LE(val1, val2)  CHECK_LE(val1, val2) 
-#define DCHECK_LT(val1, val2)  CHECK_LT(val1, val2) 
-#define DCHECK_GE(val1, val2)  CHECK_GE(val1, val2) 
-#define DCHECK_GT(val1, val2)  CHECK_GT(val1, val2) 
-#endif 
- 
- 
-#endif // _LOGGING_H_ 
+#pragma once
+
+// Copyright (c) 2005, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+
+// ---
+// This file contains #include information about logging-related stuff.
+// Pretty much everybody needs to #include this file so that they can
+// log various happenings.
+//
+#ifndef _LOGGING_H_
+#define _LOGGING_H_
+
+#include <string.h>
+#include <stdio.h>
+#include <unistd.h>
+
+#define WRITE_TO_STDERR(buf, len) write(STDERR_FILENO, buf, len)
+
+#define CHECK(condition)                                                \
+  do {                                                                  \
+    if (!(condition)) {                                                 \
+      WRITE_TO_STDERR("Check failed: " #condition "\n",                 \
+                      sizeof("Check failed: " #condition "\n")-1);      \
+      abort();                                                          \
+    }                                                                   \
+  } while (0)
+
+// This takes a message to print.  The name is historical.
+#define RAW_CHECK(condition, message)                                          \
+  do {                                                                         \
+    if (!(condition)) {                                                        \
+      WRITE_TO_STDERR("Check failed: " #condition ": " message "\n",           \
+                      sizeof("Check failed: " #condition ": " message "\n")-1);\
+      abort();                                                                 \
+    }                                                                          \
+  } while (0)
+
+// This is like RAW_CHECK, but only in debug-mode
+#ifdef NDEBUG
+enum { DEBUG_MODE = 0 };
+#define RAW_DCHECK(condition, message)
+#else
+enum { DEBUG_MODE = 1 };
+#define RAW_DCHECK(condition, message)  RAW_CHECK(condition, message)
+#endif
+
+// This prints errno as well.  Note we use write instead of printf/puts to
+// avoid the risk we'll call malloc().
+#define PCHECK(condition)                                               \
+  do {                                                                  \
+    if (!(condition)) {                                                 \
+      const int err_no = errno;                                         \
+      WRITE_TO_STDERR("Check failed: " #condition ": ",                 \
+                      sizeof("Check failed: " #condition ": ")-1);      \
+      WRITE_TO_STDERR(strerror(err_no), strlen(strerror(err_no)));      \
+      WRITE_TO_STDERR("\n", sizeof("\n")-1);                            \
+      abort();                                                          \
+    }                                                                   \
+  } while (0)
+
+// Helper macro for binary operators; prints the two values on error
+// Don't use this macro directly in your code, use CHECK_EQ et al below
+
+// WARNING: These don't compile correctly if one of the arguments is a pointer
+// and the other is NULL. To work around this, simply static_cast NULL to the
+// type of the desired pointer.
+
+// TODO(jandrews): Also print the values in case of failure.  Requires some
+// sort of type-sensitive ToString() function.
+#define CHECK_OP(op, val1, val2)                                        \
+  do {                                                                  \
+    if (!((val1) op (val2))) {                                          \
+      fprintf(stderr, "Check failed: %s %s %s\n", #val1, #op, #val2);   \
+      abort();                                                          \
+    }                                                                   \
+  } while (0)
+
+#define CHECK_EQ(val1, val2) CHECK_OP(==, val1, val2)
+#define CHECK_NE(val1, val2) CHECK_OP(!=, val1, val2)
+#define CHECK_LE(val1, val2) CHECK_OP(<=, val1, val2)
+#define CHECK_LT(val1, val2) CHECK_OP(< , val1, val2)
+#define CHECK_GE(val1, val2) CHECK_OP(>=, val1, val2)
+#define CHECK_GT(val1, val2) CHECK_OP(> , val1, val2)
+
+// Synonyms for CHECK_* that are used in some unittests.
+#define EXPECT_EQ(val1, val2) CHECK_EQ(val1, val2)
+#define EXPECT_NE(val1, val2) CHECK_NE(val1, val2)
+#define EXPECT_LE(val1, val2) CHECK_LE(val1, val2)
+#define EXPECT_LT(val1, val2) CHECK_LT(val1, val2)
+#define EXPECT_GE(val1, val2) CHECK_GE(val1, val2)
+#define EXPECT_GT(val1, val2) CHECK_GT(val1, val2)
+#define ASSERT_EQ(val1, val2) EXPECT_EQ(val1, val2)
+#define ASSERT_NE(val1, val2) EXPECT_NE(val1, val2)
+#define ASSERT_LE(val1, val2) EXPECT_LE(val1, val2)
+#define ASSERT_LT(val1, val2) EXPECT_LT(val1, val2)
+#define ASSERT_GE(val1, val2) EXPECT_GE(val1, val2)
+#define ASSERT_GT(val1, val2) EXPECT_GT(val1, val2)
+// As are these variants.
+#define EXPECT_TRUE(cond)     CHECK(cond)
+#define EXPECT_FALSE(cond)    CHECK(!(cond))
+#define EXPECT_STREQ(a, b)    CHECK(strcmp(a, b) == 0)
+#define ASSERT_TRUE(cond)     EXPECT_TRUE(cond)
+#define ASSERT_FALSE(cond)    EXPECT_FALSE(cond)
+#define ASSERT_STREQ(a, b)    EXPECT_STREQ(a, b)
+
+// Used for (libc) functions that return -1 and set errno
+#define CHECK_ERR(invocation)  PCHECK((invocation) != -1)
+
+// A few more checks that only happen in debug mode
+#ifdef NDEBUG
+#define DCHECK_EQ(val1, val2)
+#define DCHECK_NE(val1, val2)
+#define DCHECK_LE(val1, val2)
+#define DCHECK_LT(val1, val2)
+#define DCHECK_GE(val1, val2)
+#define DCHECK_GT(val1, val2)
+#else
+#define DCHECK_EQ(val1, val2)  CHECK_EQ(val1, val2)
+#define DCHECK_NE(val1, val2)  CHECK_NE(val1, val2)
+#define DCHECK_LE(val1, val2)  CHECK_LE(val1, val2)
+#define DCHECK_LT(val1, val2)  CHECK_LT(val1, val2)
+#define DCHECK_GE(val1, val2)  CHECK_GE(val1, val2)
+#define DCHECK_GT(val1, val2)  CHECK_GT(val1, val2)
+#endif
+
+
+#endif // _LOGGING_H_
diff --git a/contrib/libs/linuxvdso/original/vdso_support.cc b/contrib/libs/linuxvdso/original/vdso_support.cc
index d1763f38db..2977477398 100644
--- a/contrib/libs/linuxvdso/original/vdso_support.cc
+++ b/contrib/libs/linuxvdso/original/vdso_support.cc
@@ -1,139 +1,139 @@
-// Copyright (c) 2008, Google Inc. 
-// 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. 
-//     * Neither the name of Google Inc. nor the names of its 
-// contributors may be used to endorse or promote products derived from 
-// this software without specific prior written permission. 
-// 
-// 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. 
- 
-// --- 
-// Author: Paul Pluzhnikov 
-// 
-// Allow dynamic symbol lookup in the kernel VDSO page. 
-// 
-// VDSOSupport -- a class representing kernel VDSO (if present). 
-// 
- 
-#include "vdso_support.h" 
- 
-#ifdef HAVE_VDSO_SUPPORT     // defined in vdso_support.h 
- 
-#include <fcntl.h> 
-#include <stddef.h>   // for ptrdiff_t 
- 
-#include "linux_syscall_support.h" 
-#include "logging.h" 
- 
-#ifndef AT_SYSINFO_EHDR 
-#define AT_SYSINFO_EHDR 33 
-#endif 
- 
-namespace base { 
- 
+// Copyright (c) 2008, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+
+// ---
+// Author: Paul Pluzhnikov
+//
+// Allow dynamic symbol lookup in the kernel VDSO page.
+//
+// VDSOSupport -- a class representing kernel VDSO (if present).
+//
+
+#include "vdso_support.h"
+
+#ifdef HAVE_VDSO_SUPPORT     // defined in vdso_support.h
+
+#include <fcntl.h>
+#include <stddef.h>   // for ptrdiff_t
+
+#include "linux_syscall_support.h"
+#include "logging.h"
+
+#ifndef AT_SYSINFO_EHDR
+#define AT_SYSINFO_EHDR 33
+#endif
+
+namespace base {
+
 const void *VDSOSupport::vdso_base_ = NULL;
- 
-VDSOSupport::VDSOSupport() 
+
+VDSOSupport::VDSOSupport()
     // If vdso_base_ is still set to NULL, we got here
-    // before VDSOSupport::Init has been called. Call it now. 
+    // before VDSOSupport::Init has been called. Call it now.
     : image_(Init()) {
-} 
- 
-// NOTE: we can't use GoogleOnceInit() below, because we can be 
-// called by tcmalloc, and none of the *once* stuff may be functional yet. 
-// 
-// In addition, we hope that the VDSOSupportHelper constructor 
-// causes this code to run before there are any threads, and before 
-// InitGoogle() has executed any chroot or setuid calls. 
-// 
-// Finally, even if there is a race here, it is harmless, because 
-// the operation should be idempotent. 
-const void *VDSOSupport::Init() { 
+}
+
+// NOTE: we can't use GoogleOnceInit() below, because we can be
+// called by tcmalloc, and none of the *once* stuff may be functional yet.
+//
+// In addition, we hope that the VDSOSupportHelper constructor
+// causes this code to run before there are any threads, and before
+// InitGoogle() has executed any chroot or setuid calls.
+//
+// Finally, even if there is a race here, it is harmless, because
+// the operation should be idempotent.
+const void *VDSOSupport::Init() {
   if (vdso_base_ == NULL) {
-    // Valgrind zaps AT_SYSINFO_EHDR and friends from the auxv[] 
-    // on stack, and so glibc works as if VDSO was not present. 
-    // But going directly to kernel via /proc/self/auxv below bypasses 
-    // Valgrind zapping. So we check for Valgrind separately. 
-    if (RunningOnValgrind()) { 
+    // Valgrind zaps AT_SYSINFO_EHDR and friends from the auxv[]
+    // on stack, and so glibc works as if VDSO was not present.
+    // But going directly to kernel via /proc/self/auxv below bypasses
+    // Valgrind zapping. So we check for Valgrind separately.
+    if (RunningOnValgrind()) {
       vdso_base_ = ElfMemImage::kInvalidBase;
       return vdso_base_;
-    } 
-    int fd = open("/proc/self/auxv", O_RDONLY); 
-    if (fd == -1) { 
-      // Kernel too old to have a VDSO. 
+    }
+    int fd = open("/proc/self/auxv", O_RDONLY);
+    if (fd == -1) {
+      // Kernel too old to have a VDSO.
       vdso_base_ = ElfMemImage::kInvalidBase;
       return vdso_base_;
-    } 
-    ElfW(auxv_t) aux; 
-    while (read(fd, &aux, sizeof(aux)) == sizeof(aux)) { 
-      if (aux.a_type == AT_SYSINFO_EHDR) { 
-        COMPILE_ASSERT(sizeof(vdso_base_) == sizeof(aux.a_un.a_val), 
-                       unexpected_sizeof_pointer_NE_sizeof_a_val); 
-        vdso_base_ = reinterpret_cast<void *>(aux.a_un.a_val); 
-        break; 
-      } 
-    } 
-    close(fd); 
+    }
+    ElfW(auxv_t) aux;
+    while (read(fd, &aux, sizeof(aux)) == sizeof(aux)) {
+      if (aux.a_type == AT_SYSINFO_EHDR) {
+        COMPILE_ASSERT(sizeof(vdso_base_) == sizeof(aux.a_un.a_val),
+                       unexpected_sizeof_pointer_NE_sizeof_a_val);
+        vdso_base_ = reinterpret_cast<void *>(aux.a_un.a_val);
+        break;
+      }
+    }
+    close(fd);
     if (vdso_base_ == NULL) {
-      // Didn't find AT_SYSINFO_EHDR in auxv[]. 
+      // Didn't find AT_SYSINFO_EHDR in auxv[].
       vdso_base_ = ElfMemImage::kInvalidBase;
-    } 
-  } 
-  return vdso_base_; 
-} 
- 
-const void *VDSOSupport::SetBase(const void *base) { 
+    }
+  }
+  return vdso_base_;
+}
+
+const void *VDSOSupport::SetBase(const void *base) {
   CHECK(base != NULL);
-  const void *old_base = vdso_base_; 
-  vdso_base_ = base; 
-  image_.Init(base); 
-  return old_base; 
-} 
- 
-bool VDSOSupport::LookupSymbol(const char *name, 
-                               const char *version, 
-                               int type, 
-                               SymbolInfo *info) const { 
-  return image_.LookupSymbol(name, version, type, info); 
-} 
- 
-bool VDSOSupport::LookupSymbolByAddress(const void *address, 
-                                        SymbolInfo *info_out) const { 
-  return image_.LookupSymbolByAddress(address, info_out); 
-} 
- 
-// We need to make sure VDSOSupport::Init() is called before 
-// the main() runs, since it might do something like setuid or 
-// chroot.  If VDSOSupport 
-// is used in any global constructor, this will happen, since 
-// VDSOSupport's constructor calls Init.  But if not, we need to 
-// ensure it here, with a global constructor of our own.  This 
-// is an allowed exception to the normal rule against non-trivial 
-// global constructors. 
-static class VDSOInitHelper { 
- public: 
-  VDSOInitHelper() { VDSOSupport::Init(); } 
-} vdso_init_helper; 
-} 
- 
-#endif  // HAVE_VDSO_SUPPORT 
+  const void *old_base = vdso_base_;
+  vdso_base_ = base;
+  image_.Init(base);
+  return old_base;
+}
+
+bool VDSOSupport::LookupSymbol(const char *name,
+                               const char *version,
+                               int type,
+                               SymbolInfo *info) const {
+  return image_.LookupSymbol(name, version, type, info);
+}
+
+bool VDSOSupport::LookupSymbolByAddress(const void *address,
+                                        SymbolInfo *info_out) const {
+  return image_.LookupSymbolByAddress(address, info_out);
+}
+
+// We need to make sure VDSOSupport::Init() is called before
+// the main() runs, since it might do something like setuid or
+// chroot.  If VDSOSupport
+// is used in any global constructor, this will happen, since
+// VDSOSupport's constructor calls Init.  But if not, we need to
+// ensure it here, with a global constructor of our own.  This
+// is an allowed exception to the normal rule against non-trivial
+// global constructors.
+static class VDSOInitHelper {
+ public:
+  VDSOInitHelper() { VDSOSupport::Init(); }
+} vdso_init_helper;
+}
+
+#endif  // HAVE_VDSO_SUPPORT
diff --git a/contrib/libs/linuxvdso/original/vdso_support.h b/contrib/libs/linuxvdso/original/vdso_support.h
index 99623338d2..1ccf32c23b 100644
--- a/contrib/libs/linuxvdso/original/vdso_support.h
+++ b/contrib/libs/linuxvdso/original/vdso_support.h
@@ -1,132 +1,132 @@
-#pragma once 
- 
-// Copyright (c) 2008, Google Inc. 
-// 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. 
-//     * Neither the name of Google Inc. nor the names of its 
-// contributors may be used to endorse or promote products derived from 
-// this software without specific prior written permission. 
-// 
-// 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. 
- 
-// --- 
-// Author: Paul Pluzhnikov 
-// 
-// Allow dynamic symbol lookup in the kernel VDSO page. 
-// 
-// VDSO stands for "Virtual Dynamic Shared Object" -- a page of 
-// executable code, which looks like a shared library, but doesn't 
-// necessarily exist anywhere on disk, and which gets mmap()ed into 
-// every process by kernels which support VDSO, such as 2.6.x for 32-bit 
-// executables, and 2.6.24 and above for 64-bit executables. 
-// 
-// More details could be found here: 
-// http://www.trilithium.com/johan/2005/08/linux-gate/ 
-// 
-// VDSOSupport -- a class representing kernel VDSO (if present). 
-// 
-// Example usage: 
-//  VDSOSupport vdso; 
-//  VDSOSupport::SymbolInfo info; 
-//  typedef (*FN)(unsigned *, void *, void *); 
-//  FN fn = NULL; 
-//  if (vdso.LookupSymbol("__vdso_getcpu", "LINUX_2.6", STT_FUNC, &info)) { 
-//     fn = reinterpret_cast<FN>(info.address); 
-//  } 
- 
-#ifndef BASE_VDSO_SUPPORT_H_ 
-#define BASE_VDSO_SUPPORT_H_ 
- 
-#include "config.h" 
-#include "elf_mem_image.h" 
- 
-#ifdef HAVE_ELF_MEM_IMAGE 
- 
-#define HAVE_VDSO_SUPPORT 1 
- 
-#include <stdlib.h>     // for NULL 
- 
-namespace base { 
- 
-// NOTE: this class may be used from within tcmalloc, and can not 
-// use any memory allocation routines. 
-class VDSOSupport { 
- public: 
-  VDSOSupport(); 
- 
-  typedef ElfMemImage::SymbolInfo SymbolInfo; 
-  typedef ElfMemImage::SymbolIterator SymbolIterator; 
- 
-  // Answers whether we have a vdso at all. 
-  bool IsPresent() const { return image_.IsPresent(); } 
- 
-  // Allow to iterate over all VDSO symbols. 
-  SymbolIterator begin() const { return image_.begin(); } 
-  SymbolIterator end() const { return image_.end(); } 
- 
-  // Look up versioned dynamic symbol in the kernel VDSO. 
-  // Returns false if VDSO is not present, or doesn't contain given 
-  // symbol/version/type combination. 
-  // If info_out != NULL, additional details are filled in. 
-  bool LookupSymbol(const char *name, const char *version, 
-                    int symbol_type, SymbolInfo *info_out) const; 
- 
-  // Find info about symbol (if any) which overlaps given address. 
-  // Returns true if symbol was found; false if VDSO isn't present 
-  // or doesn't have a symbol overlapping given address. 
-  // If info_out != NULL, additional details are filled in. 
-  bool LookupSymbolByAddress(const void *address, SymbolInfo *info_out) const; 
- 
-  // Used only for testing. Replace real VDSO base with a mock. 
-  // Returns previous value of vdso_base_. After you are done testing, 
-  // you are expected to call SetBase() with previous value, in order to 
-  // reset state to the way it was. 
-  const void *SetBase(const void *s); 
- 
-  // Computes vdso_base_ and returns it. Should be called as early as 
-  // possible; before any thread creation, chroot or setuid. 
-  static const void *Init(); 
- 
- private: 
-  // image_ represents VDSO ELF image in memory. 
-  // image_.ehdr_ == NULL implies there is no VDSO. 
-  ElfMemImage image_; 
- 
-  // Cached value of auxv AT_SYSINFO_EHDR, computed once. 
-  // This is a tri-state: 
+#pragma once
+
+// Copyright (c) 2008, Google Inc.
+// 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.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// 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.
+
+// ---
+// Author: Paul Pluzhnikov
+//
+// Allow dynamic symbol lookup in the kernel VDSO page.
+//
+// VDSO stands for "Virtual Dynamic Shared Object" -- a page of
+// executable code, which looks like a shared library, but doesn't
+// necessarily exist anywhere on disk, and which gets mmap()ed into
+// every process by kernels which support VDSO, such as 2.6.x for 32-bit
+// executables, and 2.6.24 and above for 64-bit executables.
+//
+// More details could be found here:
+// http://www.trilithium.com/johan/2005/08/linux-gate/
+//
+// VDSOSupport -- a class representing kernel VDSO (if present).
+//
+// Example usage:
+//  VDSOSupport vdso;
+//  VDSOSupport::SymbolInfo info;
+//  typedef (*FN)(unsigned *, void *, void *);
+//  FN fn = NULL;
+//  if (vdso.LookupSymbol("__vdso_getcpu", "LINUX_2.6", STT_FUNC, &info)) {
+//     fn = reinterpret_cast<FN>(info.address);
+//  }
+
+#ifndef BASE_VDSO_SUPPORT_H_
+#define BASE_VDSO_SUPPORT_H_
+
+#include "config.h"
+#include "elf_mem_image.h"
+
+#ifdef HAVE_ELF_MEM_IMAGE
+
+#define HAVE_VDSO_SUPPORT 1
+
+#include <stdlib.h>     // for NULL
+
+namespace base {
+
+// NOTE: this class may be used from within tcmalloc, and can not
+// use any memory allocation routines.
+class VDSOSupport {
+ public:
+  VDSOSupport();
+
+  typedef ElfMemImage::SymbolInfo SymbolInfo;
+  typedef ElfMemImage::SymbolIterator SymbolIterator;
+
+  // Answers whether we have a vdso at all.
+  bool IsPresent() const { return image_.IsPresent(); }
+
+  // Allow to iterate over all VDSO symbols.
+  SymbolIterator begin() const { return image_.begin(); }
+  SymbolIterator end() const { return image_.end(); }
+
+  // Look up versioned dynamic symbol in the kernel VDSO.
+  // Returns false if VDSO is not present, or doesn't contain given
+  // symbol/version/type combination.
+  // If info_out != NULL, additional details are filled in.
+  bool LookupSymbol(const char *name, const char *version,
+                    int symbol_type, SymbolInfo *info_out) const;
+
+  // Find info about symbol (if any) which overlaps given address.
+  // Returns true if symbol was found; false if VDSO isn't present
+  // or doesn't have a symbol overlapping given address.
+  // If info_out != NULL, additional details are filled in.
+  bool LookupSymbolByAddress(const void *address, SymbolInfo *info_out) const;
+
+  // Used only for testing. Replace real VDSO base with a mock.
+  // Returns previous value of vdso_base_. After you are done testing,
+  // you are expected to call SetBase() with previous value, in order to
+  // reset state to the way it was.
+  const void *SetBase(const void *s);
+
+  // Computes vdso_base_ and returns it. Should be called as early as
+  // possible; before any thread creation, chroot or setuid.
+  static const void *Init();
+
+ private:
+  // image_ represents VDSO ELF image in memory.
+  // image_.ehdr_ == NULL implies there is no VDSO.
+  ElfMemImage image_;
+
+  // Cached value of auxv AT_SYSINFO_EHDR, computed once.
+  // This is a tri-state:
   //              0   => value hasn't been determined yet.
   //   kInvalidBase   => there is no VDSO.
-  //           else   => vma of VDSO Elf{32,64}_Ehdr. 
-  // 
-  // When testing with mock VDSO, low bit is set. 
-  // The low bit is always available because vdso_base_ is 
-  // page-aligned. 
-  static const void *vdso_base_; 
- 
-  DISALLOW_COPY_AND_ASSIGN(VDSOSupport); 
-}; 
-}  // namespace base 
- 
-#endif  // HAVE_ELF_MEM_IMAGE 
- 
-#endif  // BASE_VDSO_SUPPORT_H_ 
+  //           else   => vma of VDSO Elf{32,64}_Ehdr.
+  //
+  // When testing with mock VDSO, low bit is set.
+  // The low bit is always available because vdso_base_ is
+  // page-aligned.
+  static const void *vdso_base_;
+
+  DISALLOW_COPY_AND_ASSIGN(VDSOSupport);
+};
+}  // namespace base
+
+#endif  // HAVE_ELF_MEM_IMAGE
+
+#endif  // BASE_VDSO_SUPPORT_H_
diff --git a/contrib/libs/linuxvdso/original/ya.make b/contrib/libs/linuxvdso/original/ya.make
index e545457d87..c5b41c3586 100644
--- a/contrib/libs/linuxvdso/original/ya.make
+++ b/contrib/libs/linuxvdso/original/ya.make
@@ -1,6 +1,6 @@
-LIBRARY() 
+LIBRARY()
 
-LICENSE(BSD-3-Clause) 
+LICENSE(BSD-3-Clause)
 
 LICENSE_TEXTS(.yandex_meta/licenses.list.txt)
 
@@ -8,16 +8,16 @@ OWNER(
     g:contrib
     g:cpp-contrib
 )
- 
+
 NO_UTIL()
 
 NO_RUNTIME()
 
 NO_COMPILER_WARNINGS()
- 
-SRCS( 
-    vdso_support.cc 
-    elf_mem_image.cc 
-) 
- 
-END() 
+
+SRCS(
+    vdso_support.cc
+    elf_mem_image.cc
+)
+
+END()