unittests: fix -Wnarrowing build errors

src/common/mac/dump_syms.cc

 // -*- mode: c++ -*-
 
 // Copyright (c) 2011, 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
@@ skipping 23 matching lines @@
 // dump_syms.mm: Create a symbol file for use with minidumps
 
 #include "common/mac/dump_syms.h"
 
 #include <assert.h>
 #include <dirent.h>
 #include <errno.h>
 #include <libgen.h>
 #include <mach-o/arch.h>
 #include <mach-o/fat.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 #include <ostream>
 #include <string>
 #include <vector>
 
 #include "common/dwarf/bytereader-inl.h"
@@ skipping 255 matching lines @@
       public DwarfCUToModule::LineToModuleHandler {
  public:
   // Create a line-to-module converter using BYTE_READER.
   DumperLineToModule(dwarf2reader::ByteReader *byte_reader)
       : byte_reader_(byte_reader) { }
 
   void StartCompilationUnit(const string& compilation_dir) {
     compilation_dir_ = compilation_dir;
   }
 
-  void ReadProgram(const char *program, uint64 length,
+  void ReadProgram(const uint8_t *program, uint64 length,
                    Module *module, vector<Module::Line> *lines) {
     DwarfLineToModule handler(module, compilation_dir_, lines);
     dwarf2reader::LineInfo parser(program, length, byte_reader_, &handler);
     parser.Start();
   }
  private:
   string compilation_dir_;
   dwarf2reader::ByteReader *byte_reader_;  // WEAK
 };
 
 bool DumpSymbols::ReadDwarf(google_breakpad::Module *module,
                             const mach_o::Reader &macho_reader,
                             const mach_o::SectionMap &dwarf_sections,
                             bool handle_inter_cu_refs) const {
   // Build a byte reader of the appropriate endianness.
   ByteReader byte_reader(macho_reader.big_endian()
                          ? dwarf2reader::ENDIANNESS_BIG
                          : dwarf2reader::ENDIANNESS_LITTLE);
 
   // Construct a context for this file.
   DwarfCUToModule::FileContext file_context(selected_object_name_,
                                             module,
                                             handle_inter_cu_refs);
 
   // Build a dwarf2reader::SectionMap from our mach_o::SectionMap.
   for (mach_o::SectionMap::const_iterator it = dwarf_sections.begin();
        it != dwarf_sections.end(); ++it) {
     file_context.AddSectionToSectionMap(
         it->first,
-        reinterpret_cast<const char *>(it->second.contents.start),
+        it->second.contents.start,
         it->second.contents.Size());
   }
 
   // Find the __debug_info section.
   dwarf2reader::SectionMap::const_iterator debug_info_entry =
       file_context.section_map().find("__debug_info");
   assert(debug_info_entry != file_context.section_map().end());
-  const std::pair<const char*, uint64>& debug_info_section =
+  const std::pair<const uint8_t *, uint64>& debug_info_section =
       debug_info_entry->second;
   // There had better be a __debug_info section!
   if (!debug_info_section.first) {
     fprintf(stderr, "%s: __DWARF segment of file has no __debug_info section\n",
             selected_object_name_.c_str());
     return false;
   }
 
   // Build a line-to-module loader for the root handler to use.
   DumperLineToModule line_to_module(&byte_reader);
@@ skipping 49 matching lines @@
         fprintf(stderr, "architecture '%s'", arch->name);
       else
         fprintf(stderr, "architecture %d,%d",
                 macho_reader.cpu_type(), macho_reader.cpu_subtype());
       fprintf(stderr, " to Breakpad symbol file: no register name table\n");
       return false;
     }
   }
 
   // Find the call frame information and its size.
-  const char *cfi = reinterpret_cast<const char *>(section.contents.start);
+  const uint8_t *cfi = section.contents.start;
   size_t cfi_size = section.contents.Size();
 
   // Plug together the parser, handler, and their entourages.
   DwarfCFIToModule::Reporter module_reporter(selected_object_name_,
                                              section.section_name);
   DwarfCFIToModule handler(module, register_names, &module_reporter);
   dwarf2reader::ByteReader byte_reader(macho_reader.big_endian() ?
                                        dwarf2reader::ENDIANNESS_BIG :
                                        dwarf2reader::ENDIANNESS_LITTLE);
   byte_reader.SetAddressSize(macho_reader.bits_64() ? 8 : 4);
@@ skipping 179 matching lines @@
   if (ReadSymbolData(&module) && module) {
     bool res = module->Write(stream, symbol_data_);
     delete module;
     return res;
   }
 
   return false;
 }
 
 }  // namespace google_breakpad