diff --git a/linker/dlfcn.cpp b/linker/dlfcn.cpp
index 799284e..2486e02 100644
--- a/linker/dlfcn.cpp
+++ b/linker/dlfcn.cpp
@@ -238,14 +238,14 @@
 soinfo* get_libdl_info() {
   if ((__libdl_info.flags & FLAG_LINKED) == 0) {
     __libdl_info.flags |= FLAG_LINKED;
-    __libdl_info.strtab = ANDROID_LIBDL_STRTAB;
-    __libdl_info.symtab = g_libdl_symtab;
-    __libdl_info.nbucket = sizeof(g_libdl_buckets)/sizeof(unsigned);
-    __libdl_info.nchain = sizeof(g_libdl_chains)/sizeof(unsigned);
-    __libdl_info.bucket = g_libdl_buckets;
-    __libdl_info.chain = g_libdl_chains;
+    __libdl_info.strtab_ = ANDROID_LIBDL_STRTAB;
+    __libdl_info.symtab_ = g_libdl_symtab;
+    __libdl_info.nbucket_ = sizeof(g_libdl_buckets)/sizeof(unsigned);
+    __libdl_info.nchain_ = sizeof(g_libdl_chains)/sizeof(unsigned);
+    __libdl_info.bucket_ = g_libdl_buckets;
+    __libdl_info.chain_ = g_libdl_chains;
     __libdl_info.ref_count = 1;
-    __libdl_info.strtab_size = sizeof(ANDROID_LIBDL_STRTAB);
+    __libdl_info.strtab_size_ = sizeof(ANDROID_LIBDL_STRTAB);
   }
 
   return &__libdl_info;
diff --git a/linker/linker.cpp b/linker/linker.cpp
index fdcd83a..11d7b94 100644
--- a/linker/linker.cpp
+++ b/linker/linker.cpp
@@ -434,11 +434,11 @@
 
 ElfW(Sym)* soinfo::gnu_lookup(SymbolName& symbol_name) {
   uint32_t hash = symbol_name.gnu_hash();
-  uint32_t h2 = hash >> gnu_shift2;
+  uint32_t h2 = hash >> gnu_shift2_;
 
   uint32_t bloom_mask_bits = sizeof(ElfW(Addr))*8;
-  uint32_t word_num = (hash / bloom_mask_bits) & gnu_maskwords;
-  ElfW(Addr) bloom_word = gnu_bloom_filter[word_num];
+  uint32_t word_num = (hash / bloom_mask_bits) & gnu_maskwords_;
+  ElfW(Addr) bloom_word = gnu_bloom_filter_[word_num];
 
   // test against bloom filter
   if ((1 & (bloom_word >> (hash % bloom_mask_bits)) & (bloom_word >> (h2 % bloom_mask_bits))) == 0) {
@@ -446,20 +446,20 @@
   }
 
   // bloom test says "probably yes"...
-  uint32_t n = bucket[hash % nbucket];
+  uint32_t n = bucket_[hash % nbucket_];
 
   if (n == 0) {
     return nullptr;
   }
 
   do {
-    ElfW(Sym)* s = symtab + n;
-    if (((chain[n] ^ hash) >> 1) == 0 &&
+    ElfW(Sym)* s = symtab_ + n;
+    if (((chain_[n] ^ hash) >> 1) == 0 &&
         strcmp(get_string(s->st_name), symbol_name.get_name()) == 0 &&
         is_symbol_global_and_defined(this, s)) {
       return s;
     }
-  } while ((chain[n++] & 1) == 0);
+  } while ((chain_[n++] & 1) == 0);
 
   return nullptr;
 }
@@ -468,10 +468,10 @@
   uint32_t hash = symbol_name.elf_hash();
 
   TRACE_TYPE(LOOKUP, "SEARCH %s in %s@%p h=%x(elf) %zd",
-             symbol_name.get_name(), name, reinterpret_cast<void*>(base), hash, hash % nbucket);
+             symbol_name.get_name(), name, reinterpret_cast<void*>(base), hash, hash % nbucket_);
 
-  for (uint32_t n = bucket[hash % nbucket]; n != 0; n = chain[n]) {
-    ElfW(Sym)* s = symtab + n;
+  for (uint32_t n = bucket_[hash % nbucket_]; n != 0; n = chain_[n]) {
+    ElfW(Sym)* s = symtab_ + n;
     if (strcmp(get_string(s->st_name), symbol_name.get_name()) == 0 && is_symbol_global_and_defined(this, s)) {
       TRACE_TYPE(LOOKUP, "FOUND %s in %s (%p) %zd",
                symbol_name.get_name(), name, reinterpret_cast<void*>(s->st_value),
@@ -481,7 +481,7 @@
   }
 
   TRACE_TYPE(LOOKUP, "NOT FOUND %s in %s@%p %x %zd",
-             symbol_name.get_name(), name, reinterpret_cast<void*>(base), hash, hash % nbucket);
+             symbol_name.get_name(), name, reinterpret_cast<void*>(base), hash, hash % nbucket_);
 
   return nullptr;
 }
@@ -491,15 +491,15 @@
 
   strlcpy(this->name, name, sizeof(this->name));
   flags = FLAG_NEW_SOINFO;
-  version = SOINFO_VERSION;
+  version_ = SOINFO_VERSION;
 
   if (file_stat != nullptr) {
-    this->st_dev = file_stat->st_dev;
-    this->st_ino = file_stat->st_ino;
-    this->file_offset = file_offset;
+    this->st_dev_ = file_stat->st_dev;
+    this->st_ino_ = file_stat->st_ino;
+    this->file_offset_ = file_offset;
   }
 
-  this->rtld_flags = rtld_flags;
+  this->rtld_flags_ = rtld_flags;
 }
 
 
@@ -793,19 +793,19 @@
 ElfW(Sym)* soinfo::gnu_addr_lookup(const void* addr) {
   ElfW(Addr) soaddr = reinterpret_cast<ElfW(Addr)>(addr) - base;
 
-  for (size_t i = 0; i < nbucket; ++i) {
-    uint32_t n = bucket[i];
+  for (size_t i = 0; i < nbucket_; ++i) {
+    uint32_t n = bucket_[i];
 
     if (n == 0) {
       continue;
     }
 
     do {
-      ElfW(Sym)* sym = symtab + n;
+      ElfW(Sym)* sym = symtab_ + n;
       if (symbol_matches_soaddr(sym, soaddr)) {
         return sym;
       }
-    } while ((chain[n++] & 1) == 0);
+    } while ((chain_[n++] & 1) == 0);
   }
 
   return nullptr;
@@ -816,8 +816,8 @@
 
   // Search the library's symbol table for any defined symbol which
   // contains this address.
-  for (size_t i = 0; i < nchain; ++i) {
-    ElfW(Sym)* sym = symtab + i;
+  for (size_t i = 0; i < nchain_; ++i) {
+    ElfW(Sym)* sym = symtab_ + i;
     if (symbol_matches_soaddr(sym, soaddr)) {
       return sym;
     }
@@ -948,7 +948,7 @@
   si->phnum = elf_reader.phdr_count();
   si->phdr = elf_reader.loaded_phdr();
 
-  if (!si->PrelinkImage()) {
+  if (!si->prelink_image()) {
     soinfo_free(si);
     return nullptr;
   }
@@ -1104,7 +1104,7 @@
 
   bool linked = local_group.visit([&](soinfo* si) {
     if ((si->flags & FLAG_LINKED) == 0) {
-      if (!si->LinkImage(global_group, local_group, extinfo)) {
+      if (!si->link_image(global_group, local_group, extinfo)) {
         return false;
       }
       si->flags |= FLAG_LINKED;
@@ -1143,7 +1143,7 @@
 
   if (si->ref_count == 1) {
     TRACE("unloading '%s'", si->name);
-    si->CallDestructors();
+    si->call_destructors();
 
     if (si->has_min_version(0)) {
       soinfo* child = nullptr;
@@ -1217,7 +1217,7 @@
   protect_data(PROT_READ | PROT_WRITE);
   soinfo* si = find_library(name, flags, extinfo);
   if (si != nullptr) {
-    si->CallConstructors();
+    si->call_constructors();
   }
   protect_data(PROT_READ);
   return si;
@@ -1239,7 +1239,7 @@
 }
 
 #if defined(USE_RELA)
-int soinfo::Relocate(ElfW(Rela)* rela, unsigned count, const soinfo_list_t& global_group, const soinfo_list_t& local_group) {
+int soinfo::relocate(ElfW(Rela)* rela, unsigned count, const soinfo_list_t& global_group, const soinfo_list_t& local_group) {
   for (size_t idx = 0; idx < count; ++idx, ++rela) {
     unsigned type = ELFW(R_TYPE)(rela->r_info);
     unsigned sym = ELFW(R_SYM)(rela->r_info);
@@ -1256,11 +1256,11 @@
     soinfo* lsi = nullptr;
 
     if (sym != 0) {
-      sym_name = get_string(symtab[sym].st_name);
+      sym_name = get_string(symtab_[sym].st_name);
       s = soinfo_do_lookup(this, sym_name, &lsi, global_group,local_group);
       if (s == nullptr) {
         // We only allow an undefined symbol if this is a weak reference...
-        s = &symtab[sym];
+        s = &symtab_[sym];
         if (ELF_ST_BIND(s->st_info) != STB_WEAK) {
           DL_ERR("cannot locate symbol \"%s\" referenced by \"%s\"...", sym_name, name);
           return -1;
@@ -1516,7 +1516,7 @@
 }
 
 #else // REL, not RELA.
-int soinfo::Relocate(ElfW(Rel)* rel, unsigned count, const soinfo_list_t& global_group, const soinfo_list_t& local_group) {
+int soinfo::relocate(ElfW(Rel)* rel, unsigned count, const soinfo_list_t& global_group, const soinfo_list_t& local_group) {
   for (size_t idx = 0; idx < count; ++idx, ++rel) {
     unsigned type = ELFW(R_TYPE)(rel->r_info);
     // TODO: don't use unsigned for 'sym'. Use uint32_t or ElfW(Addr) instead.
@@ -1534,11 +1534,11 @@
     soinfo* lsi = nullptr;
 
     if (sym != 0) {
-      sym_name = get_string(symtab[sym].st_name);
+      sym_name = get_string(symtab_[sym].st_name);
       s = soinfo_do_lookup(this, sym_name, &lsi, global_group, local_group);
       if (s == nullptr) {
         // We only allow an undefined symbol if this is a weak reference...
-        s = &symtab[sym];
+        s = &symtab_[sym];
         if (ELF_ST_BIND(s->st_info) != STB_WEAK) {
           DL_ERR("cannot locate symbol \"%s\" referenced by \"%s\"...", sym_name, name);
           return -1;
@@ -1722,13 +1722,10 @@
 
 #if defined(__mips__)
 bool soinfo::mips_relocate_got(const soinfo_list_t& global_group, const soinfo_list_t& local_group) {
-  ElfW(Addr)** got = plt_got;
+  ElfW(Addr)** got = plt_got_;
   if (got == nullptr) {
     return true;
   }
-  unsigned local_gotno = mips_local_gotno;
-  unsigned gotsym = mips_gotsym;
-  unsigned symtabno = mips_symtabno;
 
   // got[0] is the address of the lazy resolver function.
   // got[1] may be used for a GNU extension.
@@ -1741,22 +1738,22 @@
       got[g++] = reinterpret_cast<ElfW(Addr)*>(0xdeadfeed);
     }
     // Relocate the local GOT entries.
-    for (; g < local_gotno; g++) {
+    for (; g < mips_local_gotno_; g++) {
       got[g] = reinterpret_cast<ElfW(Addr)*>(reinterpret_cast<uintptr_t>(got[g]) + load_bias);
     }
   }
 
   // Now for the global GOT entries...
-  ElfW(Sym)* sym = symtab + gotsym;
-  got = plt_got + local_gotno;
-  for (size_t g = gotsym; g < symtabno; g++, sym++, got++) {
+  ElfW(Sym)* sym = symtab_ + mips_gotsym_;
+  got = plt_got_ + mips_local_gotno_;
+  for (size_t g = mips_gotsym_; g < mips_symtabno_; g++, sym++, got++) {
     // This is an undefined reference... try to locate it.
     const char* sym_name = get_string(sym->st_name);
     soinfo* lsi = nullptr;
     ElfW(Sym)* s = soinfo_do_lookup(this, sym_name, &lsi, global_group, local_group);
     if (s == nullptr) {
       // We only allow an undefined symbol if this is a weak reference.
-      s = &symtab[g];
+      s = &symtab_[g];
       if (ELF_ST_BIND(s->st_info) != STB_WEAK) {
         DL_ERR("cannot locate \"%s\"...", sym_name);
         return false;
@@ -1773,7 +1770,7 @@
 }
 #endif
 
-void soinfo::CallArray(const char* array_name __unused, linker_function_t* functions, size_t count, bool reverse) {
+void soinfo::call_array(const char* array_name __unused, linker_function_t* functions, size_t count, bool reverse) {
   if (functions == nullptr) {
     return;
   }
@@ -1786,13 +1783,13 @@
 
   for (int i = begin; i != end; i += step) {
     TRACE("[ %s[%d] == %p ]", array_name, i, functions[i]);
-    CallFunction("function", functions[i]);
+    call_function("function", functions[i]);
   }
 
   TRACE("[ Done calling %s for '%s' ]", array_name, name);
 }
 
-void soinfo::CallFunction(const char* function_name __unused, linker_function_t function) {
+void soinfo::call_function(const char* function_name __unused, linker_function_t function) {
   if (function == nullptr || reinterpret_cast<uintptr_t>(function) == static_cast<uintptr_t>(-1)) {
     return;
   }
@@ -1806,13 +1803,13 @@
   protect_data(PROT_READ | PROT_WRITE);
 }
 
-void soinfo::CallPreInitConstructors() {
+void soinfo::call_pre_init_constructors() {
   // DT_PREINIT_ARRAY functions are called before any other constructors for executables,
   // but ignored in a shared library.
-  CallArray("DT_PREINIT_ARRAY", preinit_array, preinit_array_count, false);
+  call_array("DT_PREINIT_ARRAY", preinit_array_, preinit_array_count_, false);
 }
 
-void soinfo::CallConstructors() {
+void soinfo::call_constructors() {
   if (constructors_called) {
     return;
   }
@@ -1829,34 +1826,34 @@
   //    out above, the libc constructor will be called again (recursively!).
   constructors_called = true;
 
-  if ((flags & FLAG_EXE) == 0 && preinit_array != nullptr) {
+  if ((flags & FLAG_EXE) == 0 && preinit_array_ != nullptr) {
     // The GNU dynamic linker silently ignores these, but we warn the developer.
     PRINT("\"%s\": ignoring %zd-entry DT_PREINIT_ARRAY in shared library!",
-          name, preinit_array_count);
+          name, preinit_array_count_);
   }
 
   get_children().for_each([] (soinfo* si) {
-    si->CallConstructors();
+    si->call_constructors();
   });
 
   TRACE("\"%s\": calling constructors", name);
 
   // DT_INIT should be called before DT_INIT_ARRAY if both are present.
-  CallFunction("DT_INIT", init_func);
-  CallArray("DT_INIT_ARRAY", init_array, init_array_count, false);
+  call_function("DT_INIT", init_func_);
+  call_array("DT_INIT_ARRAY", init_array_, init_array_count_, false);
 }
 
-void soinfo::CallDestructors() {
+void soinfo::call_destructors() {
   if (!constructors_called) {
     return;
   }
   TRACE("\"%s\": calling destructors", name);
 
   // DT_FINI_ARRAY must be parsed in reverse order.
-  CallArray("DT_FINI_ARRAY", fini_array, fini_array_count, true);
+  call_array("DT_FINI_ARRAY", fini_array_, fini_array_count_, true);
 
   // DT_FINI should be called after DT_FINI_ARRAY if both are present.
-  CallFunction("DT_FINI", fini_func);
+  call_function("DT_FINI", fini_func_);
 
   // This is needed on second call to dlopen
   // after library has been unloaded with RTLD_NODELETE
@@ -1865,8 +1862,8 @@
 
 void soinfo::add_child(soinfo* child) {
   if (has_min_version(0)) {
-    child->parents.push_back(this);
-    this->children.push_back(child);
+    child->parents_.push_back(this);
+    this->children_.push_back(child);
   }
 }
 
@@ -1876,26 +1873,26 @@
   }
 
   // 1. Untie connected soinfos from 'this'.
-  children.for_each([&] (soinfo* child) {
-    child->parents.remove_if([&] (const soinfo* parent) {
+  children_.for_each([&] (soinfo* child) {
+    child->parents_.remove_if([&] (const soinfo* parent) {
       return parent == this;
     });
   });
 
-  parents.for_each([&] (soinfo* parent) {
-    parent->children.remove_if([&] (const soinfo* child) {
+  parents_.for_each([&] (soinfo* parent) {
+    parent->children_.remove_if([&] (const soinfo* child) {
       return child == this;
     });
   });
 
   // 2. Once everything untied - clear local lists.
-  parents.clear();
-  children.clear();
+  parents_.clear();
+  children_.clear();
 }
 
 dev_t soinfo::get_st_dev() const {
   if (has_min_version(0)) {
-    return st_dev;
+    return st_dev_;
   }
 
   return 0;
@@ -1903,7 +1900,7 @@
 
 ino_t soinfo::get_st_ino() const {
   if (has_min_version(0)) {
-    return st_ino;
+    return st_ino_;
   }
 
   return 0;
@@ -1911,7 +1908,7 @@
 
 off64_t soinfo::get_file_offset() const {
   if (has_min_version(1)) {
-    return file_offset;
+    return file_offset_;
   }
 
   return 0;
@@ -1919,7 +1916,7 @@
 
 uint32_t soinfo::get_rtld_flags() const {
   if (has_min_version(1)) {
-    return rtld_flags;
+    return rtld_flags_;
   }
 
   return 0;
@@ -1927,7 +1924,7 @@
 
 uint32_t soinfo::get_dt_flags_1() const {
   if (has_min_version(1)) {
-    return dt_flags_1;
+    return dt_flags_1_;
   }
 
   return 0;
@@ -1935,14 +1932,14 @@
 void soinfo::set_dt_flags_1(uint32_t dt_flags_1) {
   if (has_min_version(1)) {
     if ((dt_flags_1 & DF_1_GLOBAL) != 0) {
-      rtld_flags |= RTLD_GLOBAL;
+      rtld_flags_ |= RTLD_GLOBAL;
     }
 
     if ((dt_flags_1 & DF_1_NODELETE) != 0) {
-      rtld_flags |= RTLD_NODELETE;
+      rtld_flags_ |= RTLD_NODELETE;
     }
 
-    this->dt_flags_1 = dt_flags_1;
+    dt_flags_1_ = dt_flags_1;
   }
 }
 
@@ -1952,18 +1949,18 @@
 
 soinfo::soinfo_list_t& soinfo::get_children() {
   if (has_min_version(0)) {
-    return this->children;
+    return children_;
   }
 
   return g_empty_list;
 }
 
 soinfo::soinfo_list_t& soinfo::get_parents() {
-  if ((this->flags & FLAG_NEW_SOINFO) == 0) {
-    return g_empty_list;
+  if (has_min_version(0)) {
+    return parents_;
   }
 
-  return this->parents;
+  return g_empty_list;
 }
 
 ElfW(Addr) soinfo::resolve_symbol_address(ElfW(Sym)* s) {
@@ -1975,11 +1972,11 @@
 }
 
 const char* soinfo::get_string(ElfW(Word) index) const {
-  if (has_min_version(1) && (index >= strtab_size)) {
-    __libc_fatal("%s: strtab out of bounds error; STRSZ=%zd, name=%d", name, strtab_size, index);
+  if (has_min_version(1) && (index >= strtab_size_)) {
+    __libc_fatal("%s: strtab out of bounds error; STRSZ=%zd, name=%d", name, strtab_size_, index);
   }
 
-  return strtab + index;
+  return strtab_ + index;
 }
 
 bool soinfo::is_gnu_hash() const {
@@ -2051,7 +2048,7 @@
   return return_value;
 }
 
-bool soinfo::PrelinkImage() {
+bool soinfo::prelink_image() {
   /* Extract dynamic section */
   ElfW(Word) dynamic_flags = 0;
   phdr_table_get_dynamic_section(phdr, phnum, load_bias, &dynamic, &dynamic_flags);
@@ -2091,52 +2088,52 @@
         break;
 
       case DT_HASH:
-        if (nbucket != 0) {
+        if (nbucket_ != 0) {
           // in case of --hash-style=both, we prefer gnu
           break;
         }
 
-        nbucket = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[0];
-        nchain = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[1];
-        bucket = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr + 8);
-        chain = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr + 8 + nbucket * 4);
+        nbucket_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[0];
+        nchain_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[1];
+        bucket_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr + 8);
+        chain_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr + 8 + nbucket_ * 4);
         break;
 
       case DT_GNU_HASH:
-        if (nbucket != 0) {
+        if (nbucket_ != 0) {
           // in case of --hash-style=both, we prefer gnu
-          nchain = 0;
+          nchain_ = 0;
         }
 
-        nbucket = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[0];
+        nbucket_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[0];
         // skip symndx
-        gnu_maskwords = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[2];
-        gnu_shift2 = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[3];
+        gnu_maskwords_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[2];
+        gnu_shift2_ = reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[3];
 
-        gnu_bloom_filter = reinterpret_cast<ElfW(Addr)*>(load_bias + d->d_un.d_ptr + 16);
-        bucket = reinterpret_cast<uint32_t*>(gnu_bloom_filter + gnu_maskwords);
+        gnu_bloom_filter_ = reinterpret_cast<ElfW(Addr)*>(load_bias + d->d_un.d_ptr + 16);
+        bucket_ = reinterpret_cast<uint32_t*>(gnu_bloom_filter_ + gnu_maskwords_);
         // amend chain for symndx = header[1]
-        chain = bucket + nbucket - reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[1];
+        chain_ = bucket_ + nbucket_ - reinterpret_cast<uint32_t*>(load_bias + d->d_un.d_ptr)[1];
 
-        if (!powerof2(gnu_maskwords)) {
-          DL_ERR("invalid maskwords for gnu_hash = 0x%x, in \"%s\" expecting power to two", gnu_maskwords, name);
+        if (!powerof2(gnu_maskwords_)) {
+          DL_ERR("invalid maskwords for gnu_hash = 0x%x, in \"%s\" expecting power to two", gnu_maskwords_, name);
           return false;
         }
-        --gnu_maskwords;
+        --gnu_maskwords_;
 
         flags |= FLAG_GNU_HASH;
         break;
 
       case DT_STRTAB:
-        strtab = reinterpret_cast<const char*>(load_bias + d->d_un.d_ptr);
+        strtab_ = reinterpret_cast<const char*>(load_bias + d->d_un.d_ptr);
         break;
 
       case DT_STRSZ:
-        strtab_size = d->d_un.d_val;
+        strtab_size_ = d->d_un.d_val;
         break;
 
       case DT_SYMTAB:
-        symtab = reinterpret_cast<ElfW(Sym)*>(load_bias + d->d_un.d_ptr);
+        symtab_ = reinterpret_cast<ElfW(Sym)*>(load_bias + d->d_un.d_ptr);
         break;
 
       case DT_SYMENT:
@@ -2162,24 +2159,24 @@
 
       case DT_JMPREL:
 #if defined(USE_RELA)
-        plt_rela = reinterpret_cast<ElfW(Rela)*>(load_bias + d->d_un.d_ptr);
+        plt_rela_ = reinterpret_cast<ElfW(Rela)*>(load_bias + d->d_un.d_ptr);
 #else
-        plt_rel = reinterpret_cast<ElfW(Rel)*>(load_bias + d->d_un.d_ptr);
+        plt_rel_ = reinterpret_cast<ElfW(Rel)*>(load_bias + d->d_un.d_ptr);
 #endif
         break;
 
       case DT_PLTRELSZ:
 #if defined(USE_RELA)
-        plt_rela_count = d->d_un.d_val / sizeof(ElfW(Rela));
+        plt_rela_count_ = d->d_un.d_val / sizeof(ElfW(Rela));
 #else
-        plt_rel_count = d->d_un.d_val / sizeof(ElfW(Rel));
+        plt_rel_count_ = d->d_un.d_val / sizeof(ElfW(Rel));
 #endif
         break;
 
       case DT_PLTGOT:
 #if defined(__mips__)
         // Used by mips and mips64.
-        plt_got = reinterpret_cast<ElfW(Addr)**>(load_bias + d->d_un.d_ptr);
+        plt_got_ = reinterpret_cast<ElfW(Addr)**>(load_bias + d->d_un.d_ptr);
 #endif
         // Ignore for other platforms... (because RTLD_LAZY is not supported)
         break;
@@ -2199,11 +2196,11 @@
 #endif
 #if defined(USE_RELA)
       case DT_RELA:
-        rela = reinterpret_cast<ElfW(Rela)*>(load_bias + d->d_un.d_ptr);
+        rela_ = reinterpret_cast<ElfW(Rela)*>(load_bias + d->d_un.d_ptr);
         break;
 
       case DT_RELASZ:
-        rela_count = d->d_un.d_val / sizeof(ElfW(Rela));
+        rela_count_ = d->d_un.d_val / sizeof(ElfW(Rela));
         break;
 
       case DT_RELAENT:
@@ -2226,11 +2223,11 @@
         return false;
 #else
       case DT_REL:
-        rel = reinterpret_cast<ElfW(Rel)*>(load_bias + d->d_un.d_ptr);
+        rel_ = reinterpret_cast<ElfW(Rel)*>(load_bias + d->d_un.d_ptr);
         break;
 
       case DT_RELSZ:
-        rel_count = d->d_un.d_val / sizeof(ElfW(Rel));
+        rel_count_ = d->d_un.d_val / sizeof(ElfW(Rel));
         break;
 
       case DT_RELENT:
@@ -2252,40 +2249,40 @@
         return false;
 #endif
       case DT_INIT:
-        init_func = reinterpret_cast<linker_function_t>(load_bias + d->d_un.d_ptr);
-        DEBUG("%s constructors (DT_INIT) found at %p", name, init_func);
+        init_func_ = reinterpret_cast<linker_function_t>(load_bias + d->d_un.d_ptr);
+        DEBUG("%s constructors (DT_INIT) found at %p", name, init_func_);
         break;
 
       case DT_FINI:
-        fini_func = reinterpret_cast<linker_function_t>(load_bias + d->d_un.d_ptr);
-        DEBUG("%s destructors (DT_FINI) found at %p", name, fini_func);
+        fini_func_ = reinterpret_cast<linker_function_t>(load_bias + d->d_un.d_ptr);
+        DEBUG("%s destructors (DT_FINI) found at %p", name, fini_func_);
         break;
 
       case DT_INIT_ARRAY:
-        init_array = reinterpret_cast<linker_function_t*>(load_bias + d->d_un.d_ptr);
-        DEBUG("%s constructors (DT_INIT_ARRAY) found at %p", name, init_array);
+        init_array_ = reinterpret_cast<linker_function_t*>(load_bias + d->d_un.d_ptr);
+        DEBUG("%s constructors (DT_INIT_ARRAY) found at %p", name, init_array_);
         break;
 
       case DT_INIT_ARRAYSZ:
-        init_array_count = ((unsigned)d->d_un.d_val) / sizeof(ElfW(Addr));
+        init_array_count_ = ((unsigned)d->d_un.d_val) / sizeof(ElfW(Addr));
         break;
 
       case DT_FINI_ARRAY:
-        fini_array = reinterpret_cast<linker_function_t*>(load_bias + d->d_un.d_ptr);
-        DEBUG("%s destructors (DT_FINI_ARRAY) found at %p", name, fini_array);
+        fini_array_ = reinterpret_cast<linker_function_t*>(load_bias + d->d_un.d_ptr);
+        DEBUG("%s destructors (DT_FINI_ARRAY) found at %p", name, fini_array_);
         break;
 
       case DT_FINI_ARRAYSZ:
-        fini_array_count = ((unsigned)d->d_un.d_val) / sizeof(ElfW(Addr));
+        fini_array_count_ = ((unsigned)d->d_un.d_val) / sizeof(ElfW(Addr));
         break;
 
       case DT_PREINIT_ARRAY:
-        preinit_array = reinterpret_cast<linker_function_t*>(load_bias + d->d_un.d_ptr);
-        DEBUG("%s constructors (DT_PREINIT_ARRAY) found at %p", name, preinit_array);
+        preinit_array_ = reinterpret_cast<linker_function_t*>(load_bias + d->d_un.d_ptr);
+        DEBUG("%s constructors (DT_PREINIT_ARRAY) found at %p", name, preinit_array_);
         break;
 
       case DT_PREINIT_ARRAYSZ:
-        preinit_array_count = ((unsigned)d->d_un.d_val) / sizeof(ElfW(Addr));
+        preinit_array_count_ = ((unsigned)d->d_un.d_val) / sizeof(ElfW(Addr));
         break;
 
       case DT_TEXTREL:
@@ -2342,15 +2339,15 @@
         break;
 
       case DT_MIPS_SYMTABNO:
-        mips_symtabno = d->d_un.d_val;
+        mips_symtabno_ = d->d_un.d_val;
         break;
 
       case DT_MIPS_LOCAL_GOTNO:
-        mips_local_gotno = d->d_un.d_val;
+        mips_local_gotno_ = d->d_un.d_val;
         break;
 
       case DT_MIPS_GOTSYM:
-        mips_gotsym = d->d_un.d_val;
+        mips_gotsym_ = d->d_un.d_val;
         break;
 #endif
       // Ignored: "Its use has been superseded by the DF_BIND_NOW flag"
@@ -2373,29 +2370,29 @@
   }
 
   DEBUG("si->base = %p, si->strtab = %p, si->symtab = %p",
-        reinterpret_cast<void*>(base), strtab, symtab);
+        reinterpret_cast<void*>(base), strtab_, symtab_);
 
   // Sanity checks.
   if (relocating_linker && needed_count != 0) {
     DL_ERR("linker cannot have DT_NEEDED dependencies on other libraries");
     return false;
   }
-  if (nbucket == 0) {
+  if (nbucket_ == 0) {
     DL_ERR("empty/missing DT_HASH/DT_GNU_HASH in \"%s\" (new hash type from the future?)", name);
     return false;
   }
-  if (strtab == 0) {
+  if (strtab_ == 0) {
     DL_ERR("empty/missing DT_STRTAB in \"%s\"", name);
     return false;
   }
-  if (symtab == 0) {
+  if (symtab_ == 0) {
     DL_ERR("empty/missing DT_SYMTAB in \"%s\"", name);
     return false;
   }
   return true;
 }
 
-bool soinfo::LinkImage(const soinfo_list_t& global_group, const soinfo_list_t& local_group, const android_dlextinfo* extinfo) {
+bool soinfo::link_image(const soinfo_list_t& global_group, const soinfo_list_t& local_group, const android_dlextinfo* extinfo) {
 
 #if !defined(__LP64__)
   if (has_text_relocations) {
@@ -2412,28 +2409,28 @@
 #endif
 
 #if defined(USE_RELA)
-  if (rela != nullptr) {
+  if (rela_ != nullptr) {
     DEBUG("[ relocating %s ]", name);
-    if (Relocate(rela, rela_count, global_group, local_group)) {
+    if (relocate(rela_, rela_count_, global_group, local_group)) {
       return false;
     }
   }
-  if (plt_rela != nullptr) {
+  if (plt_rela_ != nullptr) {
     DEBUG("[ relocating %s plt ]", name);
-    if (Relocate(plt_rela, plt_rela_count, global_group, local_group)) {
+    if (relocate(plt_rela_, plt_rela_count_, global_group, local_group)) {
       return false;
     }
   }
 #else
-  if (rel != nullptr) {
+  if (rel_ != nullptr) {
     DEBUG("[ relocating %s ]", name);
-    if (Relocate(rel, rel_count, global_group, local_group)) {
+    if (relocate(rel_, rel_count_, global_group, local_group)) {
       return false;
     }
   }
-  if (plt_rel != nullptr) {
+  if (plt_rel_ != nullptr) {
     DEBUG("[ relocating %s plt ]", name);
-    if (Relocate(plt_rel, plt_rel_count, global_group, local_group)) {
+    if (relocate(plt_rel_, plt_rel_count_, global_group, local_group)) {
       return false;
     }
   }
@@ -2506,8 +2503,8 @@
   si->size = phdr_table_get_load_size(si->phdr, si->phnum);
   si->load_bias = get_elf_exec_load_bias(ehdr_vdso);
 
-  si->PrelinkImage();
-  si->LinkImage(g_empty_list, soinfo::soinfo_list_t::make_list(si), nullptr);
+  si->prelink_image();
+  si->link_image(g_empty_list, soinfo::soinfo_list_t::make_list(si), nullptr);
 #endif
 }
 
@@ -2636,7 +2633,7 @@
 
   somain = si;
 
-  si->PrelinkImage();
+  si->prelink_image();
 
   // add somain to global group
   si->set_dt_flags_1(si->get_dt_flags_1() | DF_1_GLOBAL);
@@ -2667,15 +2664,15 @@
 
   add_vdso(args);
 
-  si->CallPreInitConstructors();
+  si->call_pre_init_constructors();
 
-  /* After the PrelinkImage, the si->load_bias is initialized.
+  /* After the prelink_image, the si->load_bias is initialized.
    * For so lib, the map->l_addr will be updated in notify_gdb_of_load.
    * We need to update this value for so exe here. So Unwind_Backtrace
    * for some arch like x86 could work correctly within so exe.
    */
   map->l_addr = si->load_bias;
-  si->CallConstructors();
+  si->call_constructors();
 
 #if TIMING
   gettimeofday(&t1, nullptr);
@@ -2790,7 +2787,7 @@
   // itself without having to look into local_group and (2) allocators
   // are not yet initialized, and therefore we cannot use linked_list.push_*
   // functions at this point.
-  if (!(linker_so.PrelinkImage() && linker_so.LinkImage(g_empty_list, g_empty_list, nullptr))) {
+  if (!(linker_so.prelink_image() && linker_so.link_image(g_empty_list, g_empty_list, nullptr))) {
     // It would be nice to print an error message, but if the linker
     // can't link itself, there's no guarantee that we'll be able to
     // call write() (because it involves a GOT reference). We may as
@@ -2805,7 +2802,7 @@
   __libc_init_tls(args);
 
   // Initialize the linker's own global variables
-  linker_so.CallConstructors();
+  linker_so.call_constructors();
 
   // Initialize static variables. Note that in order to
   // get correct libdl_info we need to call constructors
diff --git a/linker/linker.h b/linker/linker.h
index 21ecb22..d28f70e 100644
--- a/linker/linker.h
+++ b/linker/linker.h
@@ -164,60 +164,60 @@
   uint32_t flags;
 
  private:
-  const char* strtab;
-  ElfW(Sym)* symtab;
+  const char* strtab_;
+  ElfW(Sym)* symtab_;
 
-  size_t nbucket;
-  size_t nchain;
-  uint32_t* bucket;
-  uint32_t* chain;
+  size_t nbucket_;
+  size_t nchain_;
+  uint32_t* bucket_;
+  uint32_t* chain_;
 
- public:
 #if defined(__mips__) || !defined(__LP64__)
   // This is only used by mips and mips64, but needs to be here for
   // all 32-bit architectures to preserve binary compatibility.
-  ElfW(Addr)** plt_got;
+  ElfW(Addr)** plt_got_;
 #endif
 
 #if defined(USE_RELA)
-  ElfW(Rela)* plt_rela;
-  size_t plt_rela_count;
+  ElfW(Rela)* plt_rela_;
+  size_t plt_rela_count_;
 
-  ElfW(Rela)* rela;
-  size_t rela_count;
+  ElfW(Rela)* rela_;
+  size_t rela_count_;
 #else
-  ElfW(Rel)* plt_rel;
-  size_t plt_rel_count;
+  ElfW(Rel)* plt_rel_;
+  size_t plt_rel_count_;
 
-  ElfW(Rel)* rel;
-  size_t rel_count;
+  ElfW(Rel)* rel_;
+  size_t rel_count_;
 #endif
 
-  linker_function_t* preinit_array;
-  size_t preinit_array_count;
+  linker_function_t* preinit_array_;
+  size_t preinit_array_count_;
 
-  linker_function_t* init_array;
-  size_t init_array_count;
-  linker_function_t* fini_array;
-  size_t fini_array_count;
+  linker_function_t* init_array_;
+  size_t init_array_count_;
+  linker_function_t* fini_array_;
+  size_t fini_array_count_;
 
-  linker_function_t init_func;
-  linker_function_t fini_func;
+  linker_function_t init_func_;
+  linker_function_t fini_func_;
 
+ public:
 #if defined(__arm__)
   // ARM EABI section used for stack unwinding.
   uint32_t* ARM_exidx;
   size_t ARM_exidx_count;
 #elif defined(__mips__)
  private:
-  uint32_t mips_symtabno;
-  uint32_t mips_local_gotno;
-  uint32_t mips_gotsym;
+  uint32_t mips_symtabno_;
+  uint32_t mips_local_gotno_;
+  uint32_t mips_gotsym_;
   bool mips_relocate_got(const soinfo_list_t& global_group, const soinfo_list_t& local_group);
 
- public:
 #endif
 
+ public:
   size_t ref_count;
   link_map link_map_head;
 
@@ -232,13 +232,14 @@
 #endif
   bool has_DT_SYMBOLIC;
 
+ public:
   soinfo(const char* name, const struct stat* file_stat, off64_t file_offset, int rtld_flags);
 
-  void CallConstructors();
-  void CallDestructors();
-  void CallPreInitConstructors();
-  bool PrelinkImage();
-  bool LinkImage(const soinfo_list_t& global_group, const soinfo_list_t& local_group, const android_dlextinfo* extinfo);
+  void call_constructors();
+  void call_destructors();
+  void call_pre_init_constructors();
+  bool prelink_image();
+  bool link_image(const soinfo_list_t& global_group, const soinfo_list_t& local_group, const android_dlextinfo* extinfo);
 
   void add_child(soinfo* child);
   void remove_all_links();
@@ -263,7 +264,7 @@
   bool is_gnu_hash() const;
 
   bool inline has_min_version(uint32_t min_version) const {
-    return (flags & FLAG_NEW_SOINFO) != 0 && version >= min_version;
+    return (flags & FLAG_NEW_SOINFO) != 0 && version_ >= min_version;
   }
 
  private:
@@ -272,38 +273,38 @@
   ElfW(Sym)* gnu_lookup(SymbolName& symbol_name);
   ElfW(Sym)* gnu_addr_lookup(const void* addr);
 
-  void CallArray(const char* array_name, linker_function_t* functions, size_t count, bool reverse);
-  void CallFunction(const char* function_name, linker_function_t function);
+  void call_array(const char* array_name, linker_function_t* functions, size_t count, bool reverse);
+  void call_function(const char* function_name, linker_function_t function);
 #if defined(USE_RELA)
-  int Relocate(ElfW(Rela)* rela, unsigned count, const soinfo_list_t& global_group, const soinfo_list_t& local_group);
+  int relocate(ElfW(Rela)* rela, unsigned count, const soinfo_list_t& global_group, const soinfo_list_t& local_group);
 #else
-  int Relocate(ElfW(Rel)* rel, unsigned count, const soinfo_list_t& global_group, const soinfo_list_t& local_group);
+  int relocate(ElfW(Rel)* rel, unsigned count, const soinfo_list_t& global_group, const soinfo_list_t& local_group);
 #endif
 
  private:
   // This part of the structure is only available
   // when FLAG_NEW_SOINFO is set in this->flags.
-  uint32_t version;
+  uint32_t version_;
 
   // version >= 0
-  dev_t st_dev;
-  ino_t st_ino;
+  dev_t st_dev_;
+  ino_t st_ino_;
 
   // dependency graph
-  soinfo_list_t children;
-  soinfo_list_t parents;
+  soinfo_list_t children_;
+  soinfo_list_t parents_;
 
   // version >= 1
-  off64_t file_offset;
-  uint32_t rtld_flags;
-  uint32_t dt_flags_1;
-  size_t strtab_size;
+  off64_t file_offset_;
+  uint32_t rtld_flags_;
+  uint32_t dt_flags_1_;
+  size_t strtab_size_;
 
   // version >= 2
-  uint32_t gnu_maskwords;
-  uint32_t gnu_shift2;
+  uint32_t gnu_maskwords_;
+  uint32_t gnu_shift2_;
 
-  ElfW(Addr)* gnu_bloom_filter;
+  ElfW(Addr)* gnu_bloom_filter_;
 
   friend soinfo* get_libdl_info();
 };