Use range-based for loops in linux/minidump_writer/minidump_writer.cc.

src/client/linux/minidump_writer/minidump_writer.cc

 // Copyright (c) 2010, 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
@@ skipping 491 matching lines @@
     *list.get() = num_output_mappings;
 
     // First write all the mappings from the dumper
     unsigned int j = 0;
     for (unsigned i = 0; i < num_mappings; ++i) {
       const MappingInfo& mapping = *dumper_->mappings()[i];
       if (!ShouldIncludeMapping(mapping) || HaveMappingInfo(mapping))
         continue;
 
       MDRawModule mod;
-      if (!FillRawModule(mapping, true, i, mod, NULL))
+      if (!FillRawModule(mapping, true, i, &mod, NULL))
         return false;
       list.CopyIndexAfterObject(j++, &mod, MD_MODULE_SIZE);
     }
     // Next write all the mappings provided by the caller
     for (MappingList::const_iterator iter = mapping_list_.begin();
          iter != mapping_list_.end();
          ++iter) {
       MDRawModule mod;
-      if (!FillRawModule(iter->first, false, 0, mod, iter->second))
+      if (!FillRawModule(iter->first, false, 0, &mod, iter->second))
         return false;
       list.CopyIndexAfterObject(j++, &mod, MD_MODULE_SIZE);
     }
 
     return true;
   }
 
   // Fill the MDRawModule |mod| with information about the provided
   // |mapping|. If |identifier| is non-NULL, use it instead of calculating
   // a file ID from the mapping.
   bool FillRawModule(const MappingInfo& mapping,
                      bool member,
                      unsigned int mapping_id,
-                     MDRawModule& mod,
+                     MDRawModule* mod,
                      const uint8_t* identifier) {
-    my_memset(&mod, 0, MD_MODULE_SIZE);
+    my_memset(mod, 0, MD_MODULE_SIZE);
 
-    mod.base_of_image = mapping.start_addr;
-    mod.size_of_image = mapping.size;
+    mod->base_of_image = mapping.start_addr;
+    mod->size_of_image = mapping.size;
 
     uint8_t cv_buf[MDCVInfoPDB70_minsize + NAME_MAX];
     uint8_t* cv_ptr = cv_buf;
 
     const uint32_t cv_signature = MD_CVINFOPDB70_SIGNATURE;
     my_memcpy(cv_ptr, &cv_signature, sizeof(cv_signature));
     cv_ptr += sizeof(cv_signature);
     uint8_t* signature = cv_ptr;
     cv_ptr += sizeof(MDGUID);
     if (identifier) {
@@ skipping 14 matching lines @@
 
     const size_t file_name_len = my_strlen(file_name);
     UntypedMDRVA cv(&minidump_writer_);
     if (!cv.Allocate(MDCVInfoPDB70_minsize + file_name_len + 1))
       return false;
 
     // Write pdb_file_name
     my_memcpy(cv_ptr, file_name, file_name_len + 1);
     cv.Copy(cv_buf, MDCVInfoPDB70_minsize + file_name_len + 1);
 
-    mod.cv_record = cv.location();
+    mod->cv_record = cv.location();
 
     MDLocationDescriptor ld;
     if (!minidump_writer_.WriteString(file_path, my_strlen(file_path), &ld))
       return false;
-    mod.module_name_rva = ld.rva;
+    mod->module_name_rva = ld.rva;
     return true;
   }
 
   bool WriteMemoryListStream(MDRawDirectory* dirent) {
     TypedMDRVA<uint32_t> list(&minidump_writer_);
     if (memory_blocks_.size()) {
       if (!list.AllocateObjectAndArray(memory_blocks_.size(),
                                        sizeof(MDMemoryDescriptor)))
         return false;
     } else {
@@ skipping 86 matching lines @@
 
     for (int i = 0; ; ++i) {
       ElfW(Dyn) dyn;
       dynamic_length += sizeof(dyn);
       if (!dumper_->CopyFromProcess(&dyn, GetCrashThread(), dynamic + i,
                                     sizeof(dyn))) {
         return false;
       }
 
 #ifdef __mips__
-      if (dyn.d_tag == DT_MIPS_RLD_MAP) {
+      const int32_t debug_tag = DT_MIPS_RLD_MAP;
+#else
+      const int32_t debug_tag = DT_DEBUG;
+#endif
+      if (dyn.d_tag == debug_tag) {
         r_debug = reinterpret_cast<struct r_debug*>(dyn.d_un.d_ptr);
         continue;
-      }
-#else
-      if (dyn.d_tag == DT_DEBUG) {
-        r_debug = reinterpret_cast<struct r_debug*>(dyn.d_un.d_ptr);
-        continue;
-      }
-#endif
-      else if (dyn.d_tag == DT_NULL) {
+      } else if (dyn.d_tag == DT_NULL) {
         break;
       }
     }
 
     // The "r_map" field of that r_debug struct contains a linked list of all
     // loaded DSOs.
     // Our list of DSOs potentially is different from the ones in the crashing
     // process. So, we have to be careful to never dereference pointers
     // directly. Instead, we use CopyFromProcess() everywhere.
     // See <link.h> for a more detailed discussion of the how the dynamic
@@ skipping 121 matching lines @@
 
     const int fd = sys_open("/proc/cpuinfo", O_RDONLY, 0);
     if (fd < 0)
       return false;
 
     {
       PageAllocator allocator;
       ProcCpuInfoReader* const reader = new(allocator) ProcCpuInfoReader(fd);
       const char* field;
       while (reader->GetNextField(&field)) {
-        for (size_t i = 0;
-             i < sizeof(cpu_info_table) / sizeof(cpu_info_table[0]);
-             i++) {
-          CpuInfoEntry* entry = &cpu_info_table[i];
-          if (i > 0 && entry->found) {
+        bool is_first_entry = true;
+        for (CpuInfoEntry& entry : cpu_info_table) {
+          if (!is_first_entry && entry.found) {
             // except for the 'processor' field, ignore repeated values.
             continue;
           }
-          if (!my_strcmp(field, entry->info_name)) {
+          is_first_entry = false;
+          if (!my_strcmp(field, entry.info_name)) {
             size_t value_len;
             const char* value = reader->GetValueAndLen(&value_len);
             if (value_len == 0)
               continue;
 
             uintptr_t val;
             if (my_read_decimal_ptr(&val, value) == value)
               continue;
 
-            entry->value = static_cast<int>(val);
-            entry->found = true;
+            entry.value = static_cast<int>(val);
+            entry.found = true;
           }
         }
 
         // special case for vendor_id
         if (!my_strcmp(field, vendor_id_name)) {
           size_t value_len;
           const char* value = reader->GetValueAndLen(&value_len);
           if (value_len > 0)
             my_strlcpy(vendor_id, value, sizeof(vendor_id));
         }
       }
       sys_close(fd);
     }
 
     // make sure we got everything we wanted
-    for (size_t i = 0;
-         i < sizeof(cpu_info_table) / sizeof(cpu_info_table[0]);
-         i++) {
-      if (!cpu_info_table[i].found) {
+    for (const CpuInfoEntry& entry : cpu_info_table) {
+      if (!entry.found) {
         return false;
       }
     }
     // cpu_info_table[0] holds the last cpu id listed in /proc/cpuinfo,
     // assuming this is the highest id, change it to the number of CPUs
     // by adding one.
     cpu_info_table[0].value++;
 
     sys_info->number_of_processors = cpu_info_table[0].value;
 #if defined(__i386__) || defined(__x86_64__)
@@ skipping 115 matching lines @@
       // to happen properly.
       return true;
     }
 
     {
       PageAllocator allocator;
       ProcCpuInfoReader* const reader =
           new(allocator) ProcCpuInfoReader(fd);
       const char* field;
       while (reader->GetNextField(&field)) {
-        for (size_t i = 0;
-             i < sizeof(cpu_id_entries)/sizeof(cpu_id_entries[0]);
-             ++i) {
-          const CpuIdEntry* entry = &cpu_id_entries[i];
-          if (my_strcmp(entry->field, field) != 0)
+        for (const CpuInfoEntry& entry : cpu_info_table) {
+          if (my_strcmp(entry.field, field) != 0)
             continue;
           uintptr_t result = 0;
           const char* value = reader->GetValue();
           const char* p = value;
           if (value[0] == '0' && value[1] == 'x') {
             p = my_read_hex_ptr(&result, value+2);
-          } else if (entry->format == 'x') {
+          } else if (entry.format == 'x') {
             p = my_read_hex_ptr(&result, value);
           } else {
             p = my_read_decimal_ptr(&result, value);
           }
           if (p == value)
             continue;
 
-          result &= (1U << entry->bit_length)-1;
-          result <<= entry->bit_lshift;
+          result &= (1U << entry.bit_length)-1;
+          result <<= entry.bit_lshift;
           sys_info->cpu.arm_cpu_info.cpuid |=
               static_cast<uint32_t>(result);
         }
 #if defined(__arm__)
         // Get the architecture version from the "Processor" field.
         // Note that it is also available in the "CPU architecture" field,
         // however, some existing kernels are misconfigured and will report
         // invalid values here (e.g. 6, while the CPU is ARMv7-A based).
         // The "Processor" field doesn't have this issue.
         if (!my_strcmp(field, "Processor")) {
@@ skipping 33 matching lines @@
         // Rebuild the ELF hwcaps from the 'Features' field.
         if (!my_strcmp(field, "Features")) {
           size_t value_len;
           const char* value = reader->GetValueAndLen(&value_len);
 
           // Parse each space-separated tag.
           while (value_len > 0) {
             const char* tag = value;
             size_t tag_len = value_len;
             const char* p = my_strchr(tag, ' ');
-            if (p != NULL) {
+            if (p) {
               tag_len = static_cast<size_t>(p - tag);
               value += tag_len + 1;
               value_len -= tag_len + 1;
             } else {
               tag_len = strlen(tag);
               value_len = 0;
             }
-            for (size_t i = 0;
-                 i != sizeof(cpu_features_entries) /
-                     sizeof(cpu_features_entries[0]);
-                ++i) {
-              const CpuFeaturesEntry* entry = &cpu_features_entries[i];
-              if (tag_len == strlen(entry->tag) &&
-                  !memcmp(tag, entry->tag, tag_len)) {
-                sys_info->cpu.arm_cpu_info.elf_hwcaps |= entry->hwcaps;
+            for (const CpuInfoEntry& entry : cpu_features_entries) {
+              if (tag_len == strlen(entry.tag) &&
+                  !memcmp(tag, entry.tag, tag_len)) {
+                sys_info->cpu.arm_cpu_info.elf_hwcaps |= entry.hwcaps;
                 break;
               }
             }
           }
         }
       }
       sys_close(fd);
     }
 
     return true;
@@ skipping 245 matching lines @@
                    const MappingList& mappings,
                    const AppMemoryList& appmem,
                    LinuxDumper* dumper) {
   MinidumpWriter writer(filename, -1, NULL, mappings, appmem, dumper);
   if (!writer.Init())
     return false;
   return writer.Dump();
 }
 
 }  // namespace google_breakpad