unittests: fix -Wnarrowing build errors

src/common/dwarf/bytereader.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
 // copyright notice, this list of conditions and the following disclaimer
@@ skipping 44 matching lines @@
 void ByteReader::SetAddressSize(uint8 size) {
   address_size_ = size;
   assert(size == 4 || size == 8);
   if (size == 4) {
     this->address_reader_ = &ByteReader::ReadFourBytes;
   } else {
     this->address_reader_ = &ByteReader::ReadEightBytes;
   }
 }
 
-uint64 ByteReader::ReadInitialLength(const char* start, size_t* len) {
+uint64 ByteReader::ReadInitialLength(const uint8_t *start, size_t* len) {
   const uint64 initial_length = ReadFourBytes(start);
   start += 4;
 
   // In DWARF2/3, if the initial length is all 1 bits, then the offset
   // size is 8 and we need to read the next 8 bytes for the real length.
   if (initial_length == 0xffffffff) {
     SetOffsetSize(8);
     *len = 12;
     return ReadOffset(start);
   } else {
@@ skipping 17 matching lines @@
   switch (encoding & 0x70) {
     case DW_EH_PE_absptr:  return true;
     case DW_EH_PE_pcrel:   return have_section_base_;
     case DW_EH_PE_textrel: return have_text_base_;
     case DW_EH_PE_datarel: return have_data_base_;
     case DW_EH_PE_funcrel: return have_function_base_;
     default:               return false;
   }
 }
 
-uint64 ByteReader::ReadEncodedPointer(const char *buffer,
+uint64 ByteReader::ReadEncodedPointer(const uint8_t *buffer,
                                       DwarfPointerEncoding encoding,
                                       size_t *len) const {
   // UsableEncoding doesn't approve of DW_EH_PE_omit, so we shouldn't
   // see it here.
   assert(encoding != DW_EH_PE_omit);
 
   // The Linux Standards Base 4.0 does not make this clear, but the
   // GNU tools (gcc/unwind-pe.h; readelf/dwarf.c; gdb/dwarf2-frame.c)
   // agree that aligned pointers are always absolute, machine-sized,
   // machine-signed pointers.
   if (encoding == DW_EH_PE_aligned) {
     assert(have_section_base_);
 
     // We don't need to align BUFFER in *our* address space. Rather, we
     // need to find the next position in our buffer that would be aligned
     // when the .eh_frame section the buffer contains is loaded into the
     // program's memory. So align assuming that buffer_base_ gets loaded at
     // address section_base_, where section_base_ itself may or may not be
     // aligned.
 
     // First, find the offset to START from the closest prior aligned
     // address.
     uint64 skew = section_base_ & (AddressSize() - 1);
     // Now find the offset from that aligned address to buffer.
     uint64 offset = skew + (buffer - buffer_base_);
     // Round up to the next boundary.
     uint64 aligned = (offset + AddressSize() - 1) & -AddressSize();
     // Convert back to a pointer.
-    const char *aligned_buffer = buffer_base_ + (aligned - skew);
+    const uint8_t *aligned_buffer = buffer_base_ + (aligned - skew);
     // Finally, store the length and actually fetch the pointer.
     *len = aligned_buffer - buffer + AddressSize();
     return ReadAddress(aligned_buffer);
   }
 
   // Extract the value first, ignoring whether it's a pointer or an
   // offset relative to some base.
   uint64 offset;
   switch (encoding & 0x0f) {
     case DW_EH_PE_absptr:
@@ skipping 93 matching lines @@
   // Remove inappropriate upper bits.
   if (AddressSize() == 4)
     pointer = pointer & 0xffffffff;
   else
     assert(AddressSize() == sizeof(uint64));
 
   return pointer;
 }
 
 }  // namespace dwarf2reader