diff --git a/libartbase/base/mem_map_test.cc b/libartbase/base/mem_map_test.cc
index bf143d4..5815cf9 100644
--- a/libartbase/base/mem_map_test.cc
+++ b/libartbase/base/mem_map_test.cc
@@ -53,7 +53,7 @@
     // Find a valid map address and unmap it before returning.
     std::string error_msg;
     MemMap map = MemMap::MapAnonymous("temp",
-                                      /* addr */ nullptr,
+                                      /* addr= */ nullptr,
                                       size,
                                       PROT_READ,
                                       low_4gb,
@@ -68,7 +68,7 @@
     const size_t page_size = static_cast<size_t>(kPageSize);
     // Map a two-page memory region.
     MemMap m0 = MemMap::MapAnonymous("MemMapTest_RemapAtEndTest_map0",
-                                     /* addr */ nullptr,
+                                     /* addr= */ nullptr,
                                      2 * page_size,
                                      PROT_READ | PROT_WRITE,
                                      low_4gb,
@@ -165,17 +165,17 @@
 TEST_F(MemMapTest, ReplaceMapping_SameSize) {
   std::string error_msg;
   MemMap dest = MemMap::MapAnonymous("MapAnonymousEmpty-atomic-replace-dest",
-                                     /* addr */ nullptr,
+                                     /* addr= */ nullptr,
                                      kPageSize,
                                      PROT_READ,
-                                     /* low_4gb */ false,
+                                     /* low_4gb= */ false,
                                      &error_msg);
   ASSERT_TRUE(dest.IsValid());
   MemMap source = MemMap::MapAnonymous("MapAnonymous-atomic-replace-source",
-                                       /* addr */ nullptr,
+                                       /* addr= */ nullptr,
                                        kPageSize,
                                        PROT_WRITE | PROT_READ,
-                                       /* low_4gb */ false,
+                                       /* low_4gb= */ false,
                                        &error_msg);
   ASSERT_TRUE(source.IsValid());
   void* source_addr = source.Begin();
@@ -200,21 +200,21 @@
 TEST_F(MemMapTest, ReplaceMapping_MakeLarger) {
   std::string error_msg;
   MemMap dest = MemMap::MapAnonymous("MapAnonymousEmpty-atomic-replace-dest",
-                                     /* addr */ nullptr,
+                                     /* addr= */ nullptr,
                                      5 * kPageSize,  // Need to make it larger
                                                      // initially so we know
                                                      // there won't be mappings
                                                      // in the way we we move
                                                      // source.
                                      PROT_READ,
-                                     /* low_4gb */ false,
+                                     /* low_4gb= */ false,
                                      &error_msg);
   ASSERT_TRUE(dest.IsValid());
   MemMap source = MemMap::MapAnonymous("MapAnonymous-atomic-replace-source",
-                                       /* addr */ nullptr,
+                                       /* addr= */ nullptr,
                                        3 * kPageSize,
                                        PROT_WRITE | PROT_READ,
-                                       /* low_4gb */ false,
+                                       /* low_4gb= */ false,
                                        &error_msg);
   ASSERT_TRUE(source.IsValid());
   uint8_t* source_addr = source.Begin();
@@ -246,17 +246,17 @@
 TEST_F(MemMapTest, ReplaceMapping_MakeSmaller) {
   std::string error_msg;
   MemMap dest = MemMap::MapAnonymous("MapAnonymousEmpty-atomic-replace-dest",
-                                     /* addr */ nullptr,
+                                     /* addr= */ nullptr,
                                      3 * kPageSize,
                                      PROT_READ,
-                                     /* low_4gb */ false,
+                                     /* low_4gb= */ false,
                                      &error_msg);
   ASSERT_TRUE(dest.IsValid());
   MemMap source = MemMap::MapAnonymous("MapAnonymous-atomic-replace-source",
-                                       /* addr */ nullptr,
+                                       /* addr= */ nullptr,
                                        kPageSize,
                                        PROT_WRITE | PROT_READ,
-                                       /* low_4gb */ false,
+                                       /* low_4gb= */ false,
                                        &error_msg);
   ASSERT_TRUE(source.IsValid());
   uint8_t* source_addr = source.Begin();
@@ -285,11 +285,11 @@
   MemMap dest =
       MemMap::MapAnonymous(
           "MapAnonymousEmpty-atomic-replace-dest",
-          /* addr */ nullptr,
+          /* addr= */ nullptr,
           3 * kPageSize,  // Need to make it larger initially so we know there won't be mappings in
                           // the way we we move source.
           PROT_READ | PROT_WRITE,
-          /* low_4gb */ false,
+          /* low_4gb= */ false,
           &error_msg);
   ASSERT_TRUE(dest.IsValid());
   // Resize down to 1 page so we can remap the rest.
@@ -299,7 +299,7 @@
                                        dest.Begin() + kPageSize,
                                        2 * kPageSize,
                                        PROT_WRITE | PROT_READ,
-                                       /* low_4gb */ false,
+                                       /* low_4gb= */ false,
                                        &error_msg);
   ASSERT_TRUE(source.IsValid());
   ASSERT_EQ(dest.Begin() + kPageSize, source.Begin());
@@ -332,20 +332,20 @@
   CommonInit();
   std::string error_msg;
   MemMap map = MemMap::MapAnonymous("MapAnonymousEmpty",
-                                    /* addr */ nullptr,
+                                    /* addr= */ nullptr,
                                     0,
                                     PROT_READ,
-                                    /* low_4gb */ false,
+                                    /* low_4gb= */ false,
                                     &error_msg);
   ASSERT_FALSE(map.IsValid()) << error_msg;
   ASSERT_FALSE(error_msg.empty());
 
   error_msg.clear();
   map = MemMap::MapAnonymous("MapAnonymousNonEmpty",
-                             /* addr */ nullptr,
+                             /* addr= */ nullptr,
                              kPageSize,
                              PROT_READ | PROT_WRITE,
-                             /* low_4gb */ false,
+                             /* low_4gb= */ false,
                              &error_msg);
   ASSERT_TRUE(map.IsValid()) << error_msg;
   ASSERT_TRUE(error_msg.empty());
@@ -358,7 +358,7 @@
                                     reinterpret_cast<uint8_t*>(kPageSize),
                                     0x20000,
                                     PROT_READ | PROT_WRITE,
-                                    /* low_4gb */ false,
+                                    /* low_4gb= */ false,
                                     nullptr);
   ASSERT_FALSE(map.IsValid());
 }
@@ -368,20 +368,20 @@
   CommonInit();
   std::string error_msg;
   MemMap map = MemMap::MapAnonymous("MapAnonymousEmpty",
-                                    /* addr */ nullptr,
+                                    /* addr= */ nullptr,
                                     0,
                                     PROT_READ,
-                                    /* low_4gb */ true,
+                                    /* low_4gb= */ true,
                                     &error_msg);
   ASSERT_FALSE(map.IsValid()) << error_msg;
   ASSERT_FALSE(error_msg.empty());
 
   error_msg.clear();
   map = MemMap::MapAnonymous("MapAnonymousNonEmpty",
-                             /* addr */ nullptr,
+                             /* addr= */ nullptr,
                              kPageSize,
                              PROT_READ | PROT_WRITE,
-                             /* low_4gb */ true,
+                             /* low_4gb= */ true,
                              &error_msg);
   ASSERT_TRUE(map.IsValid()) << error_msg;
   ASSERT_TRUE(error_msg.empty());
@@ -394,12 +394,12 @@
   constexpr size_t kMapSize = kPageSize;
   std::unique_ptr<uint8_t[]> data(new uint8_t[kMapSize]());
   ASSERT_TRUE(scratch_file.GetFile()->WriteFully(&data[0], kMapSize));
-  MemMap map = MemMap::MapFile(/*byte_count*/kMapSize,
+  MemMap map = MemMap::MapFile(/*byte_count=*/kMapSize,
                                PROT_READ,
                                MAP_PRIVATE,
                                scratch_file.GetFd(),
-                               /*start*/0,
-                               /*low_4gb*/true,
+                               /*start=*/0,
+                               /*low_4gb=*/true,
                                scratch_file.GetFilename().c_str(),
                                &error_msg);
   ASSERT_TRUE(map.IsValid()) << error_msg;
@@ -413,23 +413,23 @@
   CommonInit();
   std::string error_msg;
   // Find a valid address.
-  uint8_t* valid_address = GetValidMapAddress(kPageSize, /*low_4gb*/false);
+  uint8_t* valid_address = GetValidMapAddress(kPageSize, /*low_4gb=*/false);
   // Map at an address that should work, which should succeed.
   MemMap map0 = MemMap::MapAnonymous("MapAnonymous0",
                                      valid_address,
                                      kPageSize,
                                      PROT_READ | PROT_WRITE,
-                                     /* low_4gb */ false,
+                                     /* low_4gb= */ false,
                                      &error_msg);
   ASSERT_TRUE(map0.IsValid()) << error_msg;
   ASSERT_TRUE(error_msg.empty());
   ASSERT_TRUE(map0.BaseBegin() == valid_address);
   // Map at an unspecified address, which should succeed.
   MemMap map1 = MemMap::MapAnonymous("MapAnonymous1",
-                                     /* addr */ nullptr,
+                                     /* addr= */ nullptr,
                                      kPageSize,
                                      PROT_READ | PROT_WRITE,
-                                     /* low_4gb */ false,
+                                     /* low_4gb= */ false,
                                      &error_msg);
   ASSERT_TRUE(map1.IsValid()) << error_msg;
   ASSERT_TRUE(error_msg.empty());
@@ -439,7 +439,7 @@
                                      reinterpret_cast<uint8_t*>(map1.BaseBegin()),
                                      kPageSize,
                                      PROT_READ | PROT_WRITE,
-                                     /* low_4gb */ false,
+                                     /* low_4gb= */ false,
                                      &error_msg);
   ASSERT_FALSE(map2.IsValid()) << error_msg;
   ASSERT_TRUE(!error_msg.empty());
@@ -469,12 +469,12 @@
   memset(&data[2 * kPageSize], 0xaa, kPageSize);
   ASSERT_TRUE(scratch_file.GetFile()->WriteFully(&data[0], kMapSize));
 
-  MemMap map = MemMap::MapFile(/*byte_count*/kMapSize,
+  MemMap map = MemMap::MapFile(/*byte_count=*/kMapSize,
                                PROT_READ,
                                MAP_PRIVATE,
                                scratch_file.GetFd(),
-                               /*start*/0,
-                               /*low_4gb*/true,
+                               /*start=*/0,
+                               /*low_4gb=*/true,
                                scratch_file.GetFilename().c_str(),
                                &error_msg);
   ASSERT_TRUE(map.IsValid()) << error_msg;
@@ -522,7 +522,7 @@
                                reinterpret_cast<uint8_t*>(start_addr),
                                size,
                                PROT_READ | PROT_WRITE,
-                               /*low_4gb*/ true,
+                               /*low_4gb=*/ true,
                                &error_msg);
     if (map.IsValid()) {
       break;
@@ -543,7 +543,7 @@
                                     reinterpret_cast<uint8_t*>(ptr),
                                     2 * kPageSize,  // brings it over the top.
                                     PROT_READ | PROT_WRITE,
-                                    /* low_4gb */ false,
+                                    /* low_4gb= */ false,
                                     &error_msg);
   ASSERT_FALSE(map.IsValid());
   ASSERT_FALSE(error_msg.empty());
@@ -558,7 +558,7 @@
                            reinterpret_cast<uint8_t*>(UINT64_C(0x100000000)),
                            kPageSize,
                            PROT_READ | PROT_WRITE,
-                           /* low_4gb */ true,
+                           /* low_4gb= */ true,
                            &error_msg);
   ASSERT_FALSE(map.IsValid());
   ASSERT_FALSE(error_msg.empty());
@@ -571,7 +571,7 @@
                                     reinterpret_cast<uint8_t*>(0xF0000000),
                                     0x20000000,
                                     PROT_READ | PROT_WRITE,
-                                    /* low_4gb */ true,
+                                    /* low_4gb= */ true,
                                     &error_msg);
   ASSERT_FALSE(map.IsValid());
   ASSERT_FALSE(error_msg.empty());
@@ -585,9 +585,9 @@
                                     nullptr,
                                     0x20000,
                                     PROT_READ | PROT_WRITE,
-                                    /* low_4gb */ false,
-                                    /* reuse */ false,
-                                    /* reservation */ nullptr,
+                                    /* low_4gb= */ false,
+                                    /* reuse= */ false,
+                                    /* reservation= */ nullptr,
                                     &error_msg);
   ASSERT_TRUE(map.IsValid());
   ASSERT_TRUE(error_msg.empty());
@@ -595,9 +595,9 @@
                                      reinterpret_cast<uint8_t*>(map.BaseBegin()),
                                      0x10000,
                                      PROT_READ | PROT_WRITE,
-                                     /* low_4gb */ false,
-                                     /* reuse */ true,
-                                     /* reservation */ nullptr,
+                                     /* low_4gb= */ false,
+                                     /* reuse= */ true,
+                                     /* reservation= */ nullptr,
                                      &error_msg);
   ASSERT_TRUE(map2.IsValid());
   ASSERT_TRUE(error_msg.empty());
@@ -609,10 +609,10 @@
   constexpr size_t kNumPages = 3;
   // Map a 3-page mem map.
   MemMap map = MemMap::MapAnonymous("MapAnonymous0",
-                                    /* addr */ nullptr,
+                                    /* addr= */ nullptr,
                                     kPageSize * kNumPages,
                                     PROT_READ | PROT_WRITE,
-                                    /* low_4gb */ false,
+                                    /* low_4gb= */ false,
                                     &error_msg);
   ASSERT_TRUE(map.IsValid()) << error_msg;
   ASSERT_TRUE(error_msg.empty());
@@ -627,7 +627,7 @@
                                      map_base,
                                      kPageSize,
                                      PROT_READ | PROT_WRITE,
-                                     /* low_4gb */ false,
+                                     /* low_4gb= */ false,
                                      &error_msg);
   ASSERT_TRUE(map0.IsValid()) << error_msg;
   ASSERT_TRUE(error_msg.empty());
@@ -635,7 +635,7 @@
                                      map_base + kPageSize,
                                      kPageSize,
                                      PROT_READ | PROT_WRITE,
-                                     /* low_4gb */ false,
+                                     /* low_4gb= */ false,
                                      &error_msg);
   ASSERT_TRUE(map1.IsValid()) << error_msg;
   ASSERT_TRUE(error_msg.empty());
@@ -643,7 +643,7 @@
                                      map_base + kPageSize * 2,
                                      kPageSize,
                                      PROT_READ | PROT_WRITE,
-                                     /* low_4gb */ false,
+                                     /* low_4gb= */ false,
                                      &error_msg);
   ASSERT_TRUE(map2.IsValid()) << error_msg;
   ASSERT_TRUE(error_msg.empty());
@@ -672,10 +672,10 @@
   const size_t page_size = static_cast<size_t>(kPageSize);
   // Map a region.
   MemMap m0 = MemMap::MapAnonymous("MemMapTest_AlignByTest_map0",
-                                   /* addr */ nullptr,
+                                   /* addr= */ nullptr,
                                    14 * page_size,
                                    PROT_READ | PROT_WRITE,
-                                   /* low_4gb */ false,
+                                   /* low_4gb= */ false,
                                    &error_msg);
   ASSERT_TRUE(m0.IsValid());
   uint8_t* base0 = m0.Begin();
@@ -778,10 +778,10 @@
   ASSERT_TRUE(scratch_file.GetFile()->WriteFully(&data[0], kMapSize));
 
   MemMap reservation = MemMap::MapAnonymous("Test reservation",
-                                            /* addr */ nullptr,
+                                            /* addr= */ nullptr,
                                             kMapSize,
                                             PROT_NONE,
-                                            /* low_4gb */ false,
+                                            /* low_4gb= */ false,
                                             &error_msg);
   ASSERT_TRUE(reservation.IsValid());
   ASSERT_TRUE(error_msg.empty());
@@ -791,14 +791,14 @@
   static_assert(kChunk1Size < kMapSize, "We want to split the reservation.");
   uint8_t* addr1 = reservation.Begin();
   MemMap map1 = MemMap::MapFileAtAddress(addr1,
-                                         /* byte_count */ kChunk1Size,
+                                         /* byte_count= */ kChunk1Size,
                                          PROT_READ,
                                          MAP_PRIVATE,
                                          scratch_file.GetFd(),
-                                         /* start */ 0,
-                                         /* low_4gb */ false,
+                                         /* start= */ 0,
+                                         /* low_4gb= */ false,
                                          scratch_file.GetFilename().c_str(),
-                                         /* reuse */ false,
+                                         /* reuse= */ false,
                                          &reservation,
                                          &error_msg);
   ASSERT_TRUE(map1.IsValid()) << error_msg;
@@ -816,10 +816,10 @@
   uint8_t* addr2 = reservation.Begin();
   MemMap map2 = MemMap::MapAnonymous("MiddleReservation",
                                      addr2,
-                                     /* byte_count */ kChunk2Size,
+                                     /* byte_count= */ kChunk2Size,
                                      PROT_READ,
-                                     /* low_4gb */ false,
-                                     /* reuse */ false,
+                                     /* low_4gb= */ false,
+                                     /* reuse= */ false,
                                      &reservation,
                                      &error_msg);
   ASSERT_TRUE(map2.IsValid()) << error_msg;
@@ -833,14 +833,14 @@
   const size_t kChunk3Size = reservation.Size() - 1u;
   uint8_t* addr3 = reservation.Begin();
   MemMap map3 = MemMap::MapFileAtAddress(addr3,
-                                         /* byte_count */ kChunk3Size,
+                                         /* byte_count= */ kChunk3Size,
                                          PROT_READ,
                                          MAP_PRIVATE,
                                          scratch_file.GetFd(),
-                                         /* start */ dchecked_integral_cast<size_t>(addr3 - addr1),
-                                         /* low_4gb */ false,
+                                         /* start= */ dchecked_integral_cast<size_t>(addr3 - addr1),
+                                         /* low_4gb= */ false,
                                          scratch_file.GetFilename().c_str(),
-                                         /* reuse */ false,
+                                         /* reuse= */ false,
                                          &reservation,
                                          &error_msg);
   ASSERT_TRUE(map3.IsValid()) << error_msg;