Cleans up mac projects, and builds everything 64 bit

src/client/mac/handler/minidump_generator.cc

 // Copyright (c) 2006, 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 39 matching lines @@
 namespace google_breakpad {
 
 #if __LP64__
 #define LC_SEGMENT_ARCH LC_SEGMENT_64
 #else
 #define LC_SEGMENT_ARCH LC_SEGMENT
 #endif
 
 // constructor when generating from within the crashed process
 MinidumpGenerator::MinidumpGenerator()
-    : exception_type_(0),
+    : writer_(),
+      exception_type_(0),
       exception_code_(0),
       exception_subcode_(0),
       exception_thread_(0),
       crashing_task_(mach_task_self()),
       handler_thread_(mach_thread_self()),
       dynamic_images_(NULL) {
   GatherSystemInformation();
 }
 
 // constructor when generating from a different process than the
 // crashed process
 MinidumpGenerator::MinidumpGenerator(mach_port_t crashing_task,
                                      mach_port_t handler_thread)
-    : exception_type_(0),
+    : writer_(),
+      exception_type_(0),
       exception_code_(0),
       exception_subcode_(0),
       exception_thread_(0),
       crashing_task_(crashing_task),
-      handler_thread_(handler_thread) {
+      handler_thread_(handler_thread),
+      dynamic_images_(NULL) {
   if (crashing_task != mach_task_self()) {
     dynamic_images_ = new DynamicImages(crashing_task_);
   } else {
     dynamic_images_ = NULL;
   }
 
   GatherSystemInformation();
 }
 
 MinidumpGenerator::~MinidumpGenerator() {
@@ skipping 391 matching lines @@
   AddReg(r11);
   AddReg(r12);
   AddReg(r13);
   AddReg(r14);
   AddReg(r15);
   AddReg(rip);
   // according to AMD's software developer guide, bits above 18 are
   // not used in the flags register.  Since the minidump format
   // specifies 32 bits for the flags register, we can truncate safely
   // with no loss.
-  context_ptr->eflags = machine_state->__rflags;
+  context_ptr->eflags = static_cast<u_int32_t>(machine_state->__rflags);
   AddReg(cs);
   AddReg(fs);
   AddReg(gs);
 #endif
 #undef AddReg(a)
 
   return true;
 }
 #endif
 
@@ skipping 218 matching lines @@
 
     memset(module, 0, sizeof(MDRawModule));
 
     MDLocationDescriptor string_location;
 
     const char* name = image->GetFilePath();
     if (!writer_.WriteString(name, 0, &string_location))
       return false;
 
     module->base_of_image = image->GetVMAddr() + image->GetVMAddrSlide();
-    module->size_of_image = image->GetVMSize();
+    module->size_of_image = static_cast<u_int32_t>(image->GetVMSize());
     module->module_name_rva = string_location.rva;
 
     // We'll skip the executable module, because they don't have
     // LC_ID_DYLIB load commands, and the crash processing server gets
     // version information from the Plist file, anyway.
     if (index != (uint32_t)FindExecutableModule()) {
       module->version_info.signature = MD_VSFIXEDFILEINFO_SIGNATURE;
       module->version_info.struct_version |= MD_VSFIXEDFILEINFO_VERSION;
       // Convert MAC dylib version format, which is a 32 bit number, to the
       // format used by minidump.  The mac format is <16 bits>.<8 bits>.<8 bits>
@@ skipping 46 matching lines @@
         const breakpad_mach_segment_command *seg =
           reinterpret_cast<const breakpad_mach_segment_command *>(cmd);
 
         if (!strcmp(seg->segname, "__TEXT")) {
           MDLocationDescriptor string_location;
 
           if (!writer_.WriteString(name, 0, &string_location))
             return false;
 
           module->base_of_image = seg->vmaddr + slide;
-          module->size_of_image = seg->vmsize;
+          module->size_of_image = static_cast<u_int32_t>(seg->vmsize);
           module->module_name_rva = string_location.rva;
 
           if (!WriteCVRecord(module, cpu_type, name))
             return false;
 
           return true;
         }
       }
 
       cmd = reinterpret_cast<struct load_command*>((char *)cmd + cmd->cmdsize);
@@ skipping 128 matching lines @@
     MD_MISCINFO_FLAGS1_PROCESS_TIMES |
     MD_MISCINFO_FLAGS1_PROCESSOR_POWER_INFO;
 
   // Process ID
   info_ptr->process_id = getpid();
 
   // Times
   struct rusage usage;
   if (getrusage(RUSAGE_SELF, &usage) != -1) {
     // Omit the fractional time since the MDRawMiscInfo only wants seconds
-    info_ptr->process_user_time = usage.ru_utime.tv_sec;
-    info_ptr->process_kernel_time = usage.ru_stime.tv_sec;
+    info_ptr->process_user_time =
+        static_cast<u_int32_t>(usage.ru_utime.tv_sec);
+    info_ptr->process_kernel_time =
+        static_cast<u_int32_t>(usage.ru_stime.tv_sec);
   }
   int mib[4] = { CTL_KERN, KERN_PROC, KERN_PROC_PID, info_ptr->process_id };
   size_t size;
   if (!sysctl(mib, sizeof(mib) / sizeof(mib[0]), NULL, &size, NULL, 0)) {
     mach_vm_address_t addr;
     if (mach_vm_allocate(mach_task_self(),
                          &addr,
                          size,
                          true) == KERN_SUCCESS) {
       struct kinfo_proc *proc = (struct kinfo_proc *)addr;
       if (!sysctl(mib, sizeof(mib) / sizeof(mib[0]), proc, &size, NULL, 0))
-        info_ptr->process_create_time = proc->kp_proc.p_starttime.tv_sec;
+        info_ptr->process_create_time =
+            static_cast<u_int32_t>(proc->kp_proc.p_starttime.tv_sec);
       mach_vm_deallocate(mach_task_self(), addr, size);
     }
   }
 
   // Speed
   uint64_t speed;
   size = sizeof(speed);
   sysctlbyname("hw.cpufrequency_max", &speed, &size, NULL, 0);
-  info_ptr->processor_max_mhz = speed / (1000 * 1000);
-  info_ptr->processor_mhz_limit = speed / (1000 * 1000);
+  info_ptr->processor_max_mhz = static_cast<u_int32_t>(speed / (1000000));

[Mark Mentovai, 2010/07/19 03:31:22]

These three were marginally easier before when they were 1000 * 1000. It’s
easier to count three zeroes by eye than six. “Wait, did he write six or seven?”
It’s hard to count them without holding a mouse cursor up to the number. (You
did write six.)

+  info_ptr->processor_mhz_limit = static_cast<u_int32_t>(speed / (1000000));
   size = sizeof(speed);
   sysctlbyname("hw.cpufrequency", &speed, &size, NULL, 0);
-  info_ptr->processor_current_mhz = speed / (1000 * 1000);
+  info_ptr->processor_current_mhz = static_cast<u_int32_t>(speed / (1000000));
 
   return true;
 }
 
 bool MinidumpGenerator::WriteBreakpadInfoStream(
     MDRawDirectory *breakpad_info_stream) {
   TypedMDRVA<MDRawBreakpadInfo> info(&writer_);
 
   if (!info.Allocate())
     return false;
@@ skipping 10 matching lines @@
   } else {
     info_ptr->validity = MD_BREAKPAD_INFO_VALID_DUMP_THREAD_ID;
     info_ptr->dump_thread_id = handler_thread_;
     info_ptr->requesting_thread_id = 0;
   }
 
   return true;
 }
 
 }  // namespace google_breakpad