unittests: fix -Wnarrowing build errors

src/common/dwarf/dwarf2reader.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 65 matching lines @@
   if (iter == sections_.end())
     iter = sections_.find("__debug_abbrev");
   assert(iter != sections_.end());
 
   abbrevs_ = new std::vector<Abbrev>;
   abbrevs_->resize(1);
 
   // The only way to check whether we are reading over the end of the
   // buffer would be to first compute the size of the leb128 data by
   // reading it, then go back and read it again.
-  const char* abbrev_start = iter->second.first +
+  const uint8_t *abbrev_start = iter->second.first +
                                       header_.abbrev_offset;
-  const char* abbrevptr = abbrev_start;
+  const uint8_t *abbrevptr = abbrev_start;
 #ifndef NDEBUG
   const uint64 abbrev_length = iter->second.second - header_.abbrev_offset;
 #endif
 
   while (1) {
     CompilationUnit::Abbrev abbrev;
     size_t len;
     const uint64 number = reader_->ReadUnsignedLEB128(abbrevptr, &len);
 
     if (number == 0)
@@ skipping 26 matching lines @@
         static_cast<enum DwarfAttribute>(nametemp);
       const enum DwarfForm form = static_cast<enum DwarfForm>(formtemp);
       abbrev.attributes.push_back(std::make_pair(name, form));
     }
     assert(abbrev.number == abbrevs_->size());
     abbrevs_->push_back(abbrev);
   }
 }
 
 // Skips a single DIE's attributes.
-const char* CompilationUnit::SkipDIE(const char* start,
-                                              const Abbrev& abbrev) {
+const uint8_t *CompilationUnit::SkipDIE(const uint8_t* start,
+                                        const Abbrev& abbrev) {
   for (AttributeList::const_iterator i = abbrev.attributes.begin();
        i != abbrev.attributes.end();
        i++)  {
     start = SkipAttribute(start, i->second);
   }
   return start;
 }
 
 // Skips a single attribute form's data.
-const char* CompilationUnit::SkipAttribute(const char* start,
-                                                    enum DwarfForm form) {
+const uint8_t *CompilationUnit::SkipAttribute(const uint8_t *start,
+                                              enum DwarfForm form) {
   size_t len;
 
   switch (form) {
     case DW_FORM_indirect:
       form = static_cast<enum DwarfForm>(reader_->ReadUnsignedLEB128(start,
                                                                      &len));
       start += len;
       return SkipAttribute(start, form);
 
     case DW_FORM_flag_present:
       return start;
     case DW_FORM_data1:
     case DW_FORM_flag:
     case DW_FORM_ref1:
       return start + 1;
     case DW_FORM_ref2:
     case DW_FORM_data2:
       return start + 2;
     case DW_FORM_ref4:
     case DW_FORM_data4:
       return start + 4;
     case DW_FORM_ref8:
     case DW_FORM_data8:
     case DW_FORM_ref_sig8:
       return start + 8;
     case DW_FORM_string:
-      return start + strlen(start) + 1;
+      return start + strlen(reinterpret_cast<const char *>(start)) + 1;
     case DW_FORM_udata:
     case DW_FORM_ref_udata:
       reader_->ReadUnsignedLEB128(start, &len);
       return start + len;
 
     case DW_FORM_sdata:
       reader_->ReadSignedLEB128(start, &len);
       return start + len;
     case DW_FORM_addr:
       return start + reader_->AddressSize();
@@ skipping 26 matching lines @@
   fprintf(stderr,"Unhandled form type");
   return NULL;
 }
 
 // Read a DWARF2/3 header.
 // The header is variable length in DWARF3 (and DWARF2 as extended by
 // most compilers), and consists of an length field, a version number,
 // the offset in the .debug_abbrev section for our abbrevs, and an
 // address size.
 void CompilationUnit::ReadHeader() {
-  const char* headerptr = buffer_;
+  const uint8_t *headerptr = buffer_;
   size_t initial_length_size;
 
   assert(headerptr + 4 < buffer_ + buffer_length_);
   const uint64 initial_length
     = reader_->ReadInitialLength(headerptr, &initial_length_size);
   headerptr += initial_length_size;
   header_.length = initial_length;
 
   assert(headerptr + 2 < buffer_ + buffer_length_);
   header_.version = reader_->ReadTwoBytes(headerptr);
@@ skipping 66 matching lines @@
 
   // Now that we have our abbreviations, start processing DIE's.
   ProcessDIEs();
 
   return ourlength;
 }
 
 // If one really wanted, you could merge SkipAttribute and
 // ProcessAttribute
 // This is all boring data manipulation and calling of the handler.
-const char* CompilationUnit::ProcessAttribute(
-    uint64 dieoffset, const char* start, enum DwarfAttribute attr,
+const uint8_t *CompilationUnit::ProcessAttribute(
+    uint64 dieoffset, const uint8_t *start, enum DwarfAttribute attr,
     enum DwarfForm form) {
   size_t len;
 
   switch (form) {
     // DW_FORM_indirect is never used because it is such a space
     // waster.
     case DW_FORM_indirect:
       form = static_cast<enum DwarfForm>(reader_->ReadUnsignedLEB128(start,
                                                                      &len));
       start += len;
@@ skipping 13 matching lines @@
       return start + 2;
     case DW_FORM_data4:
       handler_->ProcessAttributeUnsigned(dieoffset, attr, form,
                                          reader_->ReadFourBytes(start));
       return start + 4;
     case DW_FORM_data8:
       handler_->ProcessAttributeUnsigned(dieoffset, attr, form,
                                          reader_->ReadEightBytes(start));
       return start + 8;
     case DW_FORM_string: {
-      const char* str = start;
+      const char *str = reinterpret_cast<const char *>(start);
       handler_->ProcessAttributeString(dieoffset, attr, form,
                                        str);
       return start + strlen(str) + 1;
     }
     case DW_FORM_udata:
       handler_->ProcessAttributeUnsigned(dieoffset, attr, form,
                                          reader_->ReadUnsignedLEB128(start,
                                                                      &len));
       return start + len;
 
@@ skipping 79 matching lines @@
       handler_->ProcessAttributeBuffer(dieoffset, attr, form, start + len,
                                        datalen);
       return start + datalen + len;
     }
     case DW_FORM_strp: {
       assert(string_buffer_ != NULL);
 
       const uint64 offset = reader_->ReadOffset(start);
       assert(string_buffer_ + offset < string_buffer_ + string_buffer_length_);
 
-      const char* str = string_buffer_ + offset;
+      const char *str = reinterpret_cast<const char *>(string_buffer_ + offset);
       handler_->ProcessAttributeString(dieoffset, attr, form,
                                        str);
       return start + reader_->OffsetSize();
     }
   }
   fprintf(stderr, "Unhandled form type\n");
   return NULL;
 }
 
-const char* CompilationUnit::ProcessDIE(uint64 dieoffset,
-                                                 const char* start,
-                                                 const Abbrev& abbrev) {
+const uint8_t *CompilationUnit::ProcessDIE(uint64 dieoffset,
+                                           const uint8_t *start,
+                                           const Abbrev& abbrev) {
   for (AttributeList::const_iterator i = abbrev.attributes.begin();
        i != abbrev.attributes.end();
        i++)  {
     start = ProcessAttribute(dieoffset, start, i->first, i->second);
   }
   return start;
 }
 
 void CompilationUnit::ProcessDIEs() {
-  const char* dieptr = after_header_;
+  const uint8_t *dieptr = after_header_;
   size_t len;
 
   // lengthstart is the place the length field is based on.
   // It is the point in the header after the initial length field
-  const char* lengthstart = buffer_;
+  const uint8_t *lengthstart = buffer_;
 
   // In 64 bit dwarf, the initial length is 12 bytes, because of the
   // 0xffffffff at the start.
   if (reader_->OffsetSize() == 8)
     lengthstart += 12;
   else
     lengthstart += 4;
 
   std::stack<uint64> die_stack;
   
@@ skipping 27 matching lines @@
     }
 
     if (abbrev.has_children) {
       die_stack.push(absolute_offset);
     } else {
       handler_->EndDIE(absolute_offset);
     }
   }
 }
 
-LineInfo::LineInfo(const char* buffer, uint64 buffer_length,
+LineInfo::LineInfo(const uint8_t *buffer, uint64 buffer_length,
                    ByteReader* reader, LineInfoHandler* handler):
     handler_(handler), reader_(reader), buffer_(buffer) {
 #ifndef NDEBUG
   buffer_length_ = buffer_length;
 #endif
   header_.std_opcode_lengths = NULL;
 }
 
 uint64 LineInfo::Start() {
   ReadHeader();
   ReadLines();
   return after_header_ - buffer_;
 }
 
 // The header for a debug_line section is mildly complicated, because
 // the line info is very tightly encoded.
 void LineInfo::ReadHeader() {
-  const char* lineptr = buffer_;
+  const uint8_t *lineptr = buffer_;
   size_t initial_length_size;
 
   const uint64 initial_length
     = reader_->ReadInitialLength(lineptr, &initial_length_size);
 
   lineptr += initial_length_size;
   header_.total_length = initial_length;
   assert(buffer_ + initial_length_size + header_.total_length <=
         buffer_ + buffer_length_);
 
@@ skipping 26 matching lines @@
   (*header_.std_opcode_lengths)[0] = 0;
   for (int i = 1; i < header_.opcode_base; i++) {
     (*header_.std_opcode_lengths)[i] = reader_->ReadOneByte(lineptr);
     lineptr += 1;
   }
 
   // It is legal for the directory entry table to be empty.
   if (*lineptr) {
     uint32 dirindex = 1;
     while (*lineptr) {
-      const char* dirname = lineptr;
+      const char *dirname = reinterpret_cast<const char *>(lineptr);
       handler_->DefineDir(dirname, dirindex);
       lineptr += strlen(dirname) + 1;
       dirindex++;
     }
   }
   lineptr++;
 
   // It is also legal for the file entry table to be empty.
   if (*lineptr) {
     uint32 fileindex = 1;
     size_t len;
     while (*lineptr) {
-      const char* filename = lineptr;
+      const char *filename = reinterpret_cast<const char *>(lineptr);
       lineptr += strlen(filename) + 1;
 
       uint64 dirindex = reader_->ReadUnsignedLEB128(lineptr, &len);
       lineptr += len;
 
       uint64 mod_time = reader_->ReadUnsignedLEB128(lineptr, &len);
       lineptr += len;
 
       uint64 filelength = reader_->ReadUnsignedLEB128(lineptr, &len);
       lineptr += len;
       handler_->DefineFile(filename, fileindex, static_cast<uint32>(dirindex), 
                            mod_time, filelength);
       fileindex++;
     }
   }
   lineptr++;
 
   after_header_ = lineptr;
 }
 
 /* static */
 bool LineInfo::ProcessOneOpcode(ByteReader* reader,
                                 LineInfoHandler* handler,
                                 const struct LineInfoHeader &header,
-                                const char* start,
+                                const uint8_t *start,
                                 struct LineStateMachine* lsm,
                                 size_t* len,
                                 uintptr pc,
                                 bool *lsm_passes_pc) {
   size_t oplen = 0;
   size_t templen;
   uint8 opcode = reader->ReadOneByte(start);
   oplen++;
   start++;
 
@@ skipping 120 matching lines @@
         case DW_LNE_set_address: {
           // With gcc 4.2.1, we cannot tell the line_no here since
           // DW_LNE_set_address is called before DW_LNS_advance_line is
           // called.  So we do not check if the lsm passes "pc" here.  See
           // also the comment in DW_LNS_advance_line.
           uint64 address = reader->ReadAddress(start);
           lsm->address = address;
         }
           break;
         case DW_LNE_define_file: {
-          const char* filename  = start;
+          const char *filename = reinterpret_cast<const char *>(start);
 
           templen = strlen(filename) + 1;
           start += templen;
 
           uint64 dirindex = reader->ReadUnsignedLEB128(start, &templen);
           oplen += templen;
 
           const uint64 mod_time = reader->ReadUnsignedLEB128(start,
                                                              &templen);
           oplen += templen;
@@ skipping 26 matching lines @@
   }
   *len = oplen;
   return false;
 }
 
 void LineInfo::ReadLines() {
   struct LineStateMachine lsm;
 
   // lengthstart is the place the length field is based on.
   // It is the point in the header after the initial length field
-  const char* lengthstart = buffer_;
+  const uint8_t *lengthstart = buffer_;
 
   // In 64 bit dwarf, the initial length is 12 bytes, because of the
   // 0xffffffff at the start.
   if (reader_->OffsetSize() == 8)
     lengthstart += 12;
   else
     lengthstart += 4;
 
-  const char* lineptr = after_header_;
+  const uint8_t *lineptr = after_header_;
   lsm.Reset(header_.default_is_stmt);
 
   // The LineInfoHandler interface expects each line's length along
   // with its address, but DWARF only provides addresses (sans
   // length), and an end-of-sequence address; one infers the length
   // from the next address. So we report a line only when we get the
   // next line's address, or the end-of-sequence address.
   bool have_pending_line = false;
   uint64 pending_address = 0;
   uint32 pending_file_num = 0, pending_line_num = 0, pending_column_num = 0;
@@ skipping 478 matching lines @@
   Reporter *reporter_;
 
   // The code address to which the next instruction in the stream applies.
   uint64 address_;
 
   // The entry whose instructions we are currently processing. This is
   // first a CIE, and then an FDE.
   const Entry *entry_;
 
   // The next instruction to process.
-  const char *cursor_;
+  const uint8_t *cursor_;
 
   // The current set of rules.
   RuleMap rules_;
 
   // The set of rules established by the CIE, used by DW_CFA_restore
   // and DW_CFA_restore_extended. We set this after interpreting the
   // CIE's instructions.
   RuleMap cie_rules_;
 
   // A stack of saved states, for DW_CFA_remember_state and
@@ skipping 77 matching lines @@
         if (8 > bytes_left) return ReportIncomplete();
         operands->offset = reader_->ReadEightBytes(cursor_);
         cursor_ += 8;
         break;
 
       case 'e': {
         size_t expression_length = reader_->ReadUnsignedLEB128(cursor_, &len);
         if (len > bytes_left || expression_length > bytes_left - len)
           return ReportIncomplete();
         cursor_ += len;
-        operands->expression = string(cursor_, expression_length);
+        operands->expression = string(reinterpret_cast<const char *>(cursor_),
+                                      expression_length);
         cursor_ += expression_length;
         break;
       }
 
       default:
           assert(0);
     }
   }
 
   return true;
@@ skipping 332 matching lines @@
   if (!rule) {
     // This isn't really the right thing to do, but since CFI generally
     // only mentions callee-saves registers, and GCC's convention for
     // callee-saves registers is that they are unchanged, it's a good
     // approximation.
     rule = new SameValueRule();
   }
   return DoRule(reg, rule);
 }
 
-bool CallFrameInfo::ReadEntryPrologue(const char *cursor, Entry *entry) {
-  const char *buffer_end = buffer_ + buffer_length_;
+bool CallFrameInfo::ReadEntryPrologue(const uint8_t *cursor, Entry *entry) {
+  const uint8_t *buffer_end = buffer_ + buffer_length_;
 
   // Initialize enough of ENTRY for use in error reporting.
   entry->offset = cursor - buffer_;
   entry->start = cursor;
   entry->kind = kUnknown;
   entry->end = NULL;
 
   // Read the initial length. This sets reader_'s offset size.
   size_t length_size;
   uint64 length = reader_->ReadInitialLength(cursor, &length_size);
@@ skipping 57 matching lines @@
  
   // The fields specific to this kind of entry start here.
   entry->fields = cursor;
 
   entry->cie = NULL;
 
   return true;
 }
 
 bool CallFrameInfo::ReadCIEFields(CIE *cie) {
-  const char *cursor = cie->fields;
+  const uint8_t *cursor = cie->fields;
   size_t len;
 
   assert(cie->kind == kCIE);
 
   // Prepare for early exit.
   cie->version = 0;
   cie->augmentation.clear();
   cie->code_alignment_factor = 0;
   cie->data_alignment_factor = 0;
   cie->return_address_register = 0;
@@ skipping 10 matching lines @@
   // If we don't recognize the version, we can't parse any more fields of the
   // CIE. For DWARF CFI, we handle versions 1 through 3 (there was never a
   // version 2 of CFI data). For .eh_frame, we handle versions 1 and 3 as well;
   // the difference between those versions seems to be the same as for
   // .debug_frame.
   if (cie->version < 1 || cie->version > 3) {
     reporter_->UnrecognizedVersion(cie->offset, cie->version);
     return false;
   }
 
-  const char *augmentation_start = cursor;
-  const void *augmentation_end =
-      memchr(augmentation_start, '\0', cie->end - augmentation_start);
+  const uint8_t *augmentation_start = cursor;
+  const uint8_t *augmentation_end =
+      reinterpret_cast<const uint8_t *>(memchr(augmentation_start, '\0',
+                                               cie->end - augmentation_start));
   if (! augmentation_end) return ReportIncomplete(cie);
-  cursor = static_cast<const char *>(augmentation_end);
-  cie->augmentation = string(augmentation_start,
-                                  cursor - augmentation_start);
+  cursor = augmentation_end;
+  cie->augmentation = string(reinterpret_cast<const char *>(augmentation_start),
+                             cursor - augmentation_start);
   // Skip the terminating '\0'.
   cursor++;
 
   // Is this CFI augmented?
   if (!cie->augmentation.empty()) {
     // Is it an augmentation we recognize?
     if (cie->augmentation[0] == DW_Z_augmentation_start) {
       // Linux C++ ABI 'z' augmentation, used for exception handling data.
       cie->has_z_augmentation = true;
     } else {
@@ skipping 25 matching lines @@
     cursor += len;
   }
 
   // If we have a 'z' augmentation string, find the augmentation data and
   // use the augmentation string to parse it.
   if (cie->has_z_augmentation) {
     uint64_t data_size = reader_->ReadUnsignedLEB128(cursor, &len);
     if (size_t(cie->end - cursor) < len + data_size)
       return ReportIncomplete(cie);
     cursor += len;
-    const char *data = cursor;
+    const uint8_t *data = cursor;
     cursor += data_size;
-    const char *data_end = cursor;
+    const uint8_t *data_end = cursor;
 
     cie->has_z_lsda = false;
     cie->has_z_personality = false;
     cie->has_z_signal_frame = false;
 
     // Walk the augmentation string, and extract values from the
     // augmentation data as the string directs.
     for (size_t i = 1; i < cie->augmentation.size(); i++) {
       switch (cie->augmentation[i]) {
         case DW_Z_has_LSDA:
@@ skipping 71 matching lines @@
     }
   }
 
   // The CIE's instructions start here.
   cie->instructions = cursor;
 
   return true;
 }
   
 bool CallFrameInfo::ReadFDEFields(FDE *fde) {
-  const char *cursor = fde->fields;
+  const uint8_t *cursor = fde->fields;
   size_t size;
 
   fde->address = reader_->ReadEncodedPointer(cursor, fde->cie->pointer_encoding,
                                              &size);
   if (size > size_t(fde->end - cursor))
     return ReportIncomplete(fde);
   cursor += size;
   reader_->SetFunctionBase(fde->address);
 
   // For the length, we strip off the upper nybble of the encoding used for
@@ skipping 45 matching lines @@
     cursor += data_size;
   }
 
   // The FDE's instructions start after those.
   fde->instructions = cursor;
 
   return true;
 }
   
 bool CallFrameInfo::Start() {
-  const char *buffer_end = buffer_ + buffer_length_;
-  const char *cursor;
+  const uint8_t *buffer_end = buffer_ + buffer_length_;
+  const uint8_t *cursor;
   bool all_ok = true;
-  const char *entry_end;
+  const uint8_t *entry_end;
   bool ok;
 
   // Traverse all the entries in buffer_, skipping CIEs and offering
   // FDEs to the handler.
   for (cursor = buffer_; cursor < buffer_end;
        cursor = entry_end, all_ok = all_ok && ok) {
     FDE fde;
 
     // Make it easy to skip this entry with 'continue': assume that
     // things are not okay until we've checked all the data, and
@@ skipping 233 matching lines @@
                                               uint64 insn_offset) {
   fprintf(stderr,
           "%s: CFI %s at offset 0x%llx in section '%s':"
           " the DW_CFA_restore_state instruction at offset 0x%llx"
           " would clear the CFA rule in effect\n",
           filename_.c_str(), CallFrameInfo::KindName(kind), offset,
           section_.c_str(), insn_offset);
 }
 
 }  // namespace dwarf2reader