unittests: fix -Wnarrowing build errors

src/common/dwarf/dwarf2reader.h

 // -*- mode: C++ -*-
 
 // 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.
@@ skipping 40 matching lines @@
 #include "common/dwarf/types.h"
 #include "common/using_std_string.h"
 
 namespace dwarf2reader {
 struct LineStateMachine;
 class Dwarf2Handler;
 class LineInfoHandler;
 
 // This maps from a string naming a section to a pair containing a
 // the data for the section, and the size of the section.
-typedef std::map<string, std::pair<const char*, uint64> > SectionMap;
+typedef std::map<string, std::pair<const uint8_t *, uint64> > SectionMap;
 typedef std::list<std::pair<enum DwarfAttribute, enum DwarfForm> >
     AttributeList;
 typedef AttributeList::iterator AttributeIterator;
 typedef AttributeList::const_iterator ConstAttributeIterator;
 
 struct LineInfoHeader {
   uint64 total_length;
   uint16 version;
   uint64 prologue_length;
   uint8 min_insn_length; // insn stands for instructin
   bool default_is_stmt; // stmt stands for statement
   int8 line_base;
   uint8 line_range;
   uint8 opcode_base;
   // Use a pointer so that signalsafe_addr2line is able to use this structure
   // without heap allocation problem.
   std::vector<unsigned char> *std_opcode_lengths;
 };
 
 class LineInfo {
  public:
 
   // Initializes a .debug_line reader. Buffer and buffer length point
   // to the beginning and length of the line information to read.
   // Reader is a ByteReader class that has the endianness set
   // properly.
-  LineInfo(const char* buffer_, uint64 buffer_length,
+  LineInfo(const uint8_t *buffer_, uint64 buffer_length,
            ByteReader* reader, LineInfoHandler* handler);
 
   virtual ~LineInfo() {
     if (header_.std_opcode_lengths) {
       delete header_.std_opcode_lengths;
     }
   }
 
   // Start processing line info, and calling callbacks in the handler.
   // Consumes the line number information for a single compilation unit.
   // Returns the number of bytes processed.
   uint64 Start();
 
   // Process a single line info opcode at START using the state
   // machine at LSM.  Return true if we should define a line using the
   // current state of the line state machine.  Place the length of the
   // opcode in LEN.
   // If LSM_PASSES_PC is non-NULL, this function also checks if the lsm
   // passes the address of PC. In other words, LSM_PASSES_PC will be
   // set to true, if the following condition is met.
   //
   // lsm's old address < PC <= lsm's new address
   static bool 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);
 
  private:
   // Reads the DWARF2/3 header for this line info.
   void ReadHeader();
 
   // Reads the DWARF2/3 line information
   void ReadLines();
 
   // The associated handler to call processing functions in
   LineInfoHandler* handler_;
 
   // The associated ByteReader that handles endianness issues for us
   ByteReader* reader_;
 
   // A DWARF2/3 line info header.  This is not the same size as
   // in the actual file, as the one in the file may have a 32 bit or
   // 64 bit lengths
 
   struct LineInfoHeader header_;
 
   // buffer is the buffer for our line info, starting at exactly where
   // the line info to read is.  after_header is the place right after
   // the end of the line information header.
-  const char* buffer_;
+  const uint8_t *buffer_;
 #ifndef NDEBUG
   uint64 buffer_length_;
 #endif
-  const char* after_header_;
+  const uint8_t *after_header_;
 };
 
 // This class is the main interface between the line info reader and
 // the client.  The virtual functions inside this get called for
 // interesting events that happen during line info reading.  The
 // default implementation does nothing
 
 class LineInfoHandler {
  public:
   LineInfoHandler() { }
@@ skipping 104 matching lines @@
   } header_;
 
   // Reads the DWARF2/3 header for this compilation unit.
   void ReadHeader();
 
   // Reads the DWARF2/3 abbreviations for this compilation unit
   void ReadAbbrevs();
 
   // Processes a single DIE for this compilation unit and return a new
   // pointer just past the end of it
-  const char* ProcessDIE(uint64 dieoffset,
-                                  const char* start,
-                                  const Abbrev& abbrev);
+  const uint8_t *ProcessDIE(uint64 dieoffset,
+                            const uint8_t *start,
+                            const Abbrev& abbrev);
 
   // Processes a single attribute and return a new pointer just past the
   // end of it
-  const char* ProcessAttribute(uint64 dieoffset,
-                                        const char* start,
-                                        enum DwarfAttribute attr,
-                                        enum DwarfForm form);
+  const uint8_t *ProcessAttribute(uint64 dieoffset,
+                                  const uint8_t *start,
+                                  enum DwarfAttribute attr,
+                                  enum DwarfForm form);
 
   // Processes all DIEs for this compilation unit
   void ProcessDIEs();
 
   // Skips the die with attributes specified in ABBREV starting at
   // START, and return the new place to position the stream to.
-  const char* SkipDIE(const char* start,
-                               const Abbrev& abbrev);
+  const uint8_t *SkipDIE(const uint8_t *start, const Abbrev& abbrev);
 
   // Skips the attribute starting at START, with FORM, and return the
   // new place to position the stream to.
-  const char* SkipAttribute(const char* start,
-                                     enum DwarfForm form);
+  const uint8_t *SkipAttribute(const uint8_t *start, enum DwarfForm form);
 
   // Offset from section start is the offset of this compilation unit
   // from the beginning of the .debug_info section.
   uint64 offset_from_section_start_;
 
   // buffer is the buffer for our CU, starting at .debug_info + offset
   // passed in from constructor.
   // after_header points to right after the compilation unit header.
-  const char* buffer_;
+  const uint8_t *buffer_;
   uint64 buffer_length_;
-  const char* after_header_;
+  const uint8_t *after_header_;
 
   // The associated ByteReader that handles endianness issues for us
   ByteReader* reader_;
 
   // The map of sections in our file to buffers containing their data
   const SectionMap& sections_;
 
   // The associated handler to call processing functions in
   Dwarf2Handler* handler_;
 
   // Set of DWARF2/3 abbreviations for this compilation unit.  Indexed
   // by abbreviation number, which means that abbrevs_[0] is not
   // valid.
   std::vector<Abbrev>* abbrevs_;
 
   // String section buffer and length, if we have a string section.
   // This is here to avoid doing a section lookup for strings in
   // ProcessAttribute, which is in the hot path for DWARF2 reading.
-  const char* string_buffer_;
+  const uint8_t *string_buffer_;
   uint64 string_buffer_length_;
 };
 
 // This class is the main interface between the reader and the
 // client.  The virtual functions inside this get called for
 // interesting events that happen during DWARF2 reading.
 // The default implementation skips everything.
 
 class Dwarf2Handler {
  public:
@@ skipping 42 matching lines @@
 
   // Called when we have an attribute with a buffer of data to give to our
   // handler. The attribute is for the DIE at OFFSET from the beginning of the
   // .debug_info section. Its name is ATTR, its form is FORM, DATA points to
   // the buffer's contents, and its length in bytes is LENGTH. The buffer is
   // owned by the caller, not the callee, and may not persist for very long.
   // If you want the data to be available later, it needs to be copied.
   virtual void ProcessAttributeBuffer(uint64 offset,
                                       enum DwarfAttribute attr,
                                       enum DwarfForm form,
-                                      const char* data,
+                                      const uint8_t *data,
                                       uint64 len) { }
 
   // Called when we have an attribute with string data to give to our handler.
   // The attribute is for the DIE at OFFSET from the beginning of the
   // .debug_info section. Its name is ATTR, its form is FORM, and its value is
   // DATA.
   virtual void ProcessAttributeString(uint64 offset,
                                       enum DwarfAttribute attr,
                                       enum DwarfForm form,
                                       const string& data) { }
@@ skipping 235 matching lines @@
   //   could pass false for EH_FRAME, but call READER's Set*Base members.
   //
   // The extensions the Linux C++ ABI makes to DWARF for exception
   // handling are described here, rather poorly:
   // http://refspecs.linux-foundation.org/LSB_4.0.0/LSB-Core-generic/LSB-Core-generic/dwarfext.html
   // http://refspecs.linux-foundation.org/LSB_4.0.0/LSB-Core-generic/LSB-Core-generic/ehframechpt.html
   // 
   // The mechanics of C++ exception handling, personality routines,
   // and language-specific data areas are described here, rather nicely:
   // http://www.codesourcery.com/public/cxx-abi/abi-eh.html
-  CallFrameInfo(const char *buffer, size_t buffer_length,
+  CallFrameInfo(const uint8_t *buffer, size_t buffer_length,
                 ByteReader *reader, Handler *handler, Reporter *reporter,
                 bool eh_frame = false)
       : buffer_(buffer), buffer_length_(buffer_length),
         reader_(reader), handler_(handler), reporter_(reporter),
         eh_frame_(eh_frame) { }
 
   ~CallFrameInfo() { }
 
   // Parse the entries in BUFFER, reporting what we find to HANDLER.
   // Return true if we reach the end of the section successfully, or
   // false if we encounter an error.
   bool Start();
 
   // Return the textual name of KIND. For error reporting.
   static const char *KindName(EntryKind kind);
 
  private:
 
   struct CIE;
 
   // A CFI entry, either an FDE or a CIE.
   struct Entry {
     // The starting offset of the entry in the section, for error
     // reporting.
     size_t offset;
 
     // The start of this entry in the buffer.
-    const char *start;
+    const uint8_t *start;
     
     // Which kind of entry this is.
     //
     // We want to be able to use this for error reporting even while we're
     // in the midst of parsing. Error reporting code may assume that kind,
     // offset, and start fields are valid, although kind may be kUnknown.
     EntryKind kind;
 
     // The end of this entry's common prologue (initial length and id), and
     // the start of this entry's kind-specific fields.
-    const char *fields;
+    const uint8_t *fields;
 
     // The start of this entry's instructions.
-    const char *instructions;
+    const uint8_t *instructions;
 
     // The address past the entry's last byte in the buffer. (Note that
     // since offset points to the entry's initial length field, and the
     // length field is the number of bytes after that field, this is not
     // simply buffer_ + offset + length.)
-    const char *end;
+    const uint8_t *end;
 
     // For both DWARF CFI and .eh_frame sections, this is the CIE id in a
     // CIE, and the offset of the associated CIE in an FDE.
     uint64 id;
 
     // The CIE that applies to this entry, if we've parsed it. If this is a
     // CIE, then this field points to this structure.
     CIE *cie;
   };
 
@@ skipping 56 matching lines @@
   class ValExpressionRule;
   class RuleMap;
   class State;
   
   // Parse the initial length and id of a CFI entry, either a CIE, an FDE,
   // or a .eh_frame end-of-data mark. CURSOR points to the beginning of the
   // data to parse. On success, populate ENTRY as appropriate, and return
   // true. On failure, report the problem, and return false. Even if we
   // return false, set ENTRY->end to the first byte after the entry if we
   // were able to figure that out, or NULL if we weren't.
-  bool ReadEntryPrologue(const char *cursor, Entry *entry);
+  bool ReadEntryPrologue(const uint8_t *cursor, Entry *entry);
 
   // Parse the fields of a CIE after the entry prologue, including any 'z'
   // augmentation data. Assume that the 'Entry' fields of CIE are
   // populated; use CIE->fields and CIE->end as the start and limit for
   // parsing. On success, populate the rest of *CIE, and return true; on
   // failure, report the problem and return false.
   bool ReadCIEFields(CIE *cie);
 
   // Parse the fields of an FDE after the entry prologue, including any 'z'
   // augmentation data. Assume that the 'Entry' fields of *FDE are
   // initialized; use FDE->fields and FDE->end as the start and limit for
   // parsing. Assume that FDE->cie is fully initialized. On success,
   // populate the rest of *FDE, and return true; on failure, report the
   // problem and return false.
   bool ReadFDEFields(FDE *fde);
 
   // Report that ENTRY is incomplete, and return false. This is just a
   // trivial wrapper for invoking reporter_->Incomplete; it provides a
   // little brevity.
   bool ReportIncomplete(Entry *entry);
 
   // Return true if ENCODING has the DW_EH_PE_indirect bit set.
   static bool IsIndirectEncoding(DwarfPointerEncoding encoding) {
     return encoding & DW_EH_PE_indirect;
   }
 
   // The contents of the DWARF .debug_info section we're parsing.
-  const char *buffer_;
+  const uint8_t *buffer_;
   size_t buffer_length_;
 
   // For reading multi-byte values with the appropriate endianness.
   ByteReader *reader_;
 
   // The handler to which we should report the data we find.
   Handler *handler_;
 
   // For reporting problems in the info we're parsing.
   Reporter *reporter_;
@@ skipping 237 matching lines @@
   // The name of the file whose CFI we're reading.
   string filename_;
 
   // The name of the CFI section in that file.
   string section_;
 };
 
 }  // namespace dwarf2reader
 
 #endif  // UTIL_DEBUGINFO_DWARF2READER_H__