unittests: fix -Wnarrowing build errors

src/common/dwarf/dwarf2reader_cfi_unittest.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
@@ skipping 13 matching lines @@
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // Original author: Jim Blandy <jimb@mozilla.com> <jimb@red-bean.com>
 
 // dwarf2reader_cfi_unittest.cc: Unit tests for dwarf2reader::CallFrameInfo
 
+#include <stdint.h>
 #include <stdlib.h>
 
 #include <string>
 #include <vector>
 
 // The '.eh_frame' format, used by the Linux C++ ABI for exception
 // handling, is poorly specified. To help test our support for .eh_frame,
 // if you #define WRITE_ELF while compiling this file, and add the
 // 'include' directory from the binutils, gcc, or gdb source tree to the
 // #include path, then each test that calls the
@@ skipping 135 matching lines @@
 
   MockCallFrameInfoHandler handler;
   MockCallFrameErrorReporter reporter;
 };
 
 class CFI: public CFIFixture, public Test { };
 
 TEST_F(CFI, EmptyRegion) {
   EXPECT_CALL(handler, Entry(_, _, _, _, _, _)).Times(0);
   EXPECT_CALL(handler, End()).Times(0);
-  static const char data[1] = { 42 };
+  static const uint8_t data[] = { 42 };
 
   ByteReader byte_reader(ENDIANNESS_BIG);
   CallFrameInfo parser(data, 0, &byte_reader, &handler, &reporter);
   EXPECT_TRUE(parser.Start());
 }
 
 TEST_F(CFI, IncompleteLength32) {
   CFISection section(kBigEndian, 8);
   section
       // Not even long enough for an initial length.
       .D16(0xa0f)
       // Padding to keep valgrind happy. We subtract these off when we
       // construct the parser.
       .D16(0);
 
   EXPECT_CALL(handler, Entry(_, _, _, _, _, _)).Times(0);
   EXPECT_CALL(handler, End()).Times(0);
 
   EXPECT_CALL(reporter, Incomplete(_, CallFrameInfo::kUnknown))
       .WillOnce(Return());
 
   string contents;
   ASSERT_TRUE(section.GetContents(&contents));
 
   ByteReader byte_reader(ENDIANNESS_BIG);
   byte_reader.SetAddressSize(8);
-  CallFrameInfo parser(contents.data(), contents.size() - 2,
+  CallFrameInfo parser(reinterpret_cast<const uint8_t *>(contents.data()),
+                       contents.size() - 2,
                        &byte_reader, &handler, &reporter);
   EXPECT_FALSE(parser.Start());
 }
 
 TEST_F(CFI, IncompleteLength64) {
   CFISection section(kLittleEndian, 4);
   section
       // An incomplete 64-bit DWARF initial length.
       .D32(0xffffffff).D32(0x71fbaec2)
       // Padding to keep valgrind happy. We subtract these off when we
       // construct the parser.
       .D32(0);
 
   EXPECT_CALL(handler, Entry(_, _, _, _, _, _)).Times(0);
   EXPECT_CALL(handler, End()).Times(0);
 
   EXPECT_CALL(reporter, Incomplete(_, CallFrameInfo::kUnknown))
       .WillOnce(Return());
 
   string contents;
   ASSERT_TRUE(section.GetContents(&contents));
 
   ByteReader byte_reader(ENDIANNESS_LITTLE);
   byte_reader.SetAddressSize(4);
-  CallFrameInfo parser(contents.data(), contents.size() - 4,
+  CallFrameInfo parser(reinterpret_cast<const uint8_t *>(contents.data()),
+                       contents.size() - 4,
                        &byte_reader, &handler, &reporter);
   EXPECT_FALSE(parser.Start());
 }
 
 TEST_F(CFI, IncompleteId32) {
   CFISection section(kBigEndian, 8);
   section
       .D32(3)                      // Initial length, not long enough for id
       .D8(0xd7).D8(0xe5).D8(0xf1)  // incomplete id
       .CIEHeader(8727, 3983, 8889, 3, "")
       .FinishEntry();
 
   EXPECT_CALL(handler, Entry(_, _, _, _, _, _)).Times(0);
   EXPECT_CALL(handler, End()).Times(0);
 
   EXPECT_CALL(reporter, Incomplete(_, CallFrameInfo::kUnknown))
       .WillOnce(Return());
 
   string contents;
   ASSERT_TRUE(section.GetContents(&contents));
 
   ByteReader byte_reader(ENDIANNESS_BIG);
   byte_reader.SetAddressSize(8);
-  CallFrameInfo parser(contents.data(), contents.size(),
+  CallFrameInfo parser(reinterpret_cast<const uint8_t *>(contents.data()),
+                       contents.size(),
                        &byte_reader, &handler, &reporter);
   EXPECT_FALSE(parser.Start());
 }
 
 TEST_F(CFI, BadId32) {
   CFISection section(kBigEndian, 8);
   section
       .D32(0x100)                       // Initial length
       .D32(0xe802fade)                  // bogus ID
       .Append(0x100 - 4, 0x42);         // make the length true
   section
       .CIEHeader(1672, 9872, 8529, 3, "")
       .FinishEntry();
 
   EXPECT_CALL(handler, Entry(_, _, _, _, _, _)).Times(0);
   EXPECT_CALL(handler, End()).Times(0);
 
   EXPECT_CALL(reporter, CIEPointerOutOfRange(_, 0xe802fade))
       .WillOnce(Return());
 
   string contents;
   ASSERT_TRUE(section.GetContents(&contents));
 
   ByteReader byte_reader(ENDIANNESS_BIG);
   byte_reader.SetAddressSize(8);
-  CallFrameInfo parser(contents.data(), contents.size(),
+  CallFrameInfo parser(reinterpret_cast<const uint8_t *>(contents.data()),
+                       contents.size(),
                        &byte_reader, &handler, &reporter);
   EXPECT_FALSE(parser.Start());
 }
 
 // A lone CIE shouldn't cause any handler calls.
 TEST_F(CFI, SingleCIE) {
   CFISection section(kLittleEndian, 4);
   section.CIEHeader(0xffe799a8, 0x3398dcdd, 0x6e9683de, 3, "");
   section.Append(10, dwarf2reader::DW_CFA_nop);
   section.FinishEntry();
 
   PERHAPS_WRITE_DEBUG_FRAME_FILE("SingleCIE", section);
 
   EXPECT_CALL(handler, Entry(_, _, _, _, _, _)).Times(0);
   EXPECT_CALL(handler, End()).Times(0);
 
   string contents;
   EXPECT_TRUE(section.GetContents(&contents));
   ByteReader byte_reader(ENDIANNESS_LITTLE);
   byte_reader.SetAddressSize(4);
-  CallFrameInfo parser(contents.data(), contents.size(),
+  CallFrameInfo parser(reinterpret_cast<const uint8_t *>(contents.data()),
+                       contents.size(),
                        &byte_reader, &handler, &reporter);
   EXPECT_TRUE(parser.Start());
 }
 
 // One FDE, one CIE.
 TEST_F(CFI, OneFDE) {
   CFISection section(kBigEndian, 4);
   Label cie;
   section
       .Mark(&cie)
       .CIEHeader(0x4be22f75, 0x2492236e, 0x6b6efb87, 3, "")
       .FinishEntry()
       .FDEHeader(cie, 0x7714740d, 0x3d5a10cd)
       .FinishEntry();
 
   PERHAPS_WRITE_DEBUG_FRAME_FILE("OneFDE", section);
 
   {
     InSequence s;
     EXPECT_CALL(handler,
                 Entry(_, 0x7714740d, 0x3d5a10cd, 3, "", 0x6b6efb87))
         .WillOnce(Return(true));
     EXPECT_CALL(handler, End()).WillOnce(Return(true));
   }
 
   string contents;
   EXPECT_TRUE(section.GetContents(&contents));
   ByteReader byte_reader(ENDIANNESS_BIG);
   byte_reader.SetAddressSize(4);
-  CallFrameInfo parser(contents.data(), contents.size(),
+  CallFrameInfo parser(reinterpret_cast<const uint8_t *>(contents.data()),
+                       contents.size(),
                        &byte_reader, &handler, &reporter);
   EXPECT_TRUE(parser.Start());
 }
 
 // Two FDEs share a CIE.
 TEST_F(CFI, TwoFDEsOneCIE) {
   CFISection section(kBigEndian, 4);
   Label cie;
   section
       // First FDE. readelf complains about this one because it makes
@@ skipping 22 matching lines @@
     EXPECT_CALL(handler,
                 Entry(_, 0x6057d391, 0x700f608d, 3, "", 0xbd43cb59))
         .WillOnce(Return(true));
     EXPECT_CALL(handler, End()).WillOnce(Return(true));
   }
 
   string contents;
   EXPECT_TRUE(section.GetContents(&contents));
   ByteReader byte_reader(ENDIANNESS_BIG);
   byte_reader.SetAddressSize(4);
-  CallFrameInfo parser(contents.data(), contents.size(),
+  CallFrameInfo parser(reinterpret_cast<const uint8_t *>(contents.data()),
+                       contents.size(),
                        &byte_reader, &handler, &reporter);
   EXPECT_TRUE(parser.Start());
 }
 
 // Two FDEs, two CIEs.
 TEST_F(CFI, TwoFDEsTwoCIEs) {
   CFISection section(kLittleEndian, 8);
   Label cie1, cie2;
   section
       // First CIE.
@@ skipping 28 matching lines @@
                 Entry(_, 0xf6054ca18b10bf5fULL, 0x45fdb970d8bca342ULL, 3,
                       "", 0xbf45e65a))
         .WillOnce(Return(true));
     EXPECT_CALL(handler, End()).WillOnce(Return(true));
   }
 
   string contents;
   EXPECT_TRUE(section.GetContents(&contents));
   ByteReader byte_reader(ENDIANNESS_LITTLE);
   byte_reader.SetAddressSize(8);
-  CallFrameInfo parser(contents.data(), contents.size(),
+  CallFrameInfo parser(reinterpret_cast<const uint8_t *>(contents.data()),
+                       contents.size(),
                        &byte_reader, &handler, &reporter);
   EXPECT_TRUE(parser.Start());
 }
 
 // An FDE whose CIE specifies a version we don't recognize.
 TEST_F(CFI, BadVersion) {
   CFISection section(kBigEndian, 4);
   Label cie1, cie2;
   section
       .Mark(&cie1)
@@ skipping 23 matching lines @@
                                0x96cb3264))
         .WillOnce(Return(true));
     EXPECT_CALL(handler, End())
         .WillOnce(Return(true));
   }
 
   string contents;
   EXPECT_TRUE(section.GetContents(&contents));
   ByteReader byte_reader(ENDIANNESS_BIG);
   byte_reader.SetAddressSize(4);
-  CallFrameInfo parser(contents.data(), contents.size(),
+  CallFrameInfo parser(reinterpret_cast<const uint8_t *>(contents.data()),
+                       contents.size(),
                        &byte_reader, &handler, &reporter);
   EXPECT_FALSE(parser.Start());
 }
 
 // An FDE whose CIE specifies an augmentation we don't recognize.
 TEST_F(CFI, BadAugmentation) {
   CFISection section(kBigEndian, 4);
   Label cie1, cie2;
   section
       .Mark(&cie1)
@@ skipping 23 matching lines @@
                                0xf2f519b2))
         .WillOnce(Return(true));
     EXPECT_CALL(handler, End())
         .WillOnce(Return(true));
   }
 
   string contents;
   EXPECT_TRUE(section.GetContents(&contents));
   ByteReader byte_reader(ENDIANNESS_BIG);
   byte_reader.SetAddressSize(4);
-  CallFrameInfo parser(contents.data(), contents.size(),
+  CallFrameInfo parser(reinterpret_cast<const uint8_t *>(contents.data()),
+                       contents.size(),
                        &byte_reader, &handler, &reporter);
   EXPECT_FALSE(parser.Start());
 }
 
 // The return address column field is a byte in CFI version 1
 // (DWARF2), but a ULEB128 value in version 3 (DWARF3).
 TEST_F(CFI, CIEVersion1ReturnColumn) {
   CFISection section(kBigEndian, 4);
   Label cie;
   section
@@ skipping 13 matching lines @@
     InSequence s;
     EXPECT_CALL(handler, Entry(_, 0xb8d347b5, 0x825e55dc, 1, "", 0x9f))
         .WillOnce(Return(true));
     EXPECT_CALL(handler, End()).WillOnce(Return(true));
   }
 
   string contents;
   EXPECT_TRUE(section.GetContents(&contents));
   ByteReader byte_reader(ENDIANNESS_BIG);
   byte_reader.SetAddressSize(4);
-  CallFrameInfo parser(contents.data(), contents.size(),
+  CallFrameInfo parser(reinterpret_cast<const uint8_t *>(contents.data()),
+                       contents.size(),
                        &byte_reader, &handler, &reporter);
   EXPECT_TRUE(parser.Start());
 }
 
 // The return address column field is a byte in CFI version 1
 // (DWARF2), but a ULEB128 value in version 3 (DWARF3).
 TEST_F(CFI, CIEVersion3ReturnColumn) {
   CFISection section(kBigEndian, 4);
   Label cie;
   section
@@ skipping 13 matching lines @@
     InSequence s;
     EXPECT_CALL(handler, Entry(_, 0x86763f2b, 0x2a66dc23, 3, "", 0x89))
         .WillOnce(Return(true));
     EXPECT_CALL(handler, End()).WillOnce(Return(true));
   }
 
   string contents;
   EXPECT_TRUE(section.GetContents(&contents));
   ByteReader byte_reader(ENDIANNESS_BIG);
   byte_reader.SetAddressSize(4);
-  CallFrameInfo parser(contents.data(), contents.size(),
+  CallFrameInfo parser(reinterpret_cast<const uint8_t *>(contents.data()),
+                       contents.size(),
                        &byte_reader, &handler, &reporter);
   EXPECT_TRUE(parser.Start());
 }
 
 struct CFIInsnFixture: public CFIFixture {
   CFIInsnFixture() : CFIFixture() {
     data_factor = 0xb6f;
     return_register = 0x9be1ed9f;
     version = 3;
     cfa_base_register = 0x383a3aa;
@@ skipping 60 matching lines @@
     EXPECT_TRUE(section->GetContents(&contents));
     dwarf2reader::Endianness endianness;
     if (section->endianness() == kBigEndian)
       endianness = ENDIANNESS_BIG;
     else {
       assert(section->endianness() == kLittleEndian);
       endianness = ENDIANNESS_LITTLE;
     }
     ByteReader byte_reader(endianness);
     byte_reader.SetAddressSize(section->AddressSize());
-    CallFrameInfo parser(contents.data(), contents.size(),
+    CallFrameInfo parser(reinterpret_cast<const uint8_t *>(contents.data()),
+                         contents.size(),
                          &byte_reader, &handler, &reporter);
     if (succeeds)
       EXPECT_TRUE(parser.Start());
     else
       EXPECT_FALSE(parser.Start());
   }
 
   Label cie_label;
   Sequence s;
   uint64 code_factor;
@@ skipping 1300 matching lines @@
     EXPECT_TRUE(section->GetContents(&contents));
     dwarf2reader::Endianness endianness;
     if (section->endianness() == kBigEndian)
       endianness = ENDIANNESS_BIG;
     else {
       assert(section->endianness() == kLittleEndian);
       endianness = ENDIANNESS_LITTLE;
     }
     ByteReader byte_reader(endianness);
     byte_reader.SetAddressSize(section->AddressSize());
-    byte_reader.SetCFIDataBase(encoded_pointer_bases.cfi, contents.data());
+    byte_reader.SetCFIDataBase(encoded_pointer_bases.cfi,
+                               reinterpret_cast<const uint8_t *>(contents.data()));
     byte_reader.SetTextBase(encoded_pointer_bases.text);
     byte_reader.SetDataBase(encoded_pointer_bases.data);
-    CallFrameInfo parser(contents.data(), contents.size(),
+    CallFrameInfo parser(reinterpret_cast<const uint8_t *>(contents.data()),
+                         contents.size(),
                          &byte_reader, &handler, &reporter, true);
     if (succeeds)
       EXPECT_TRUE(parser.Start());
     else
       EXPECT_FALSE(parser.Start());
   }
 
 };
 
 class EHFrame: public EHFrameFixture, public Test { };
@@ skipping 437 matching lines @@
     exit(1);
   }
 
   if (fclose(out) == EOF) {
     fprintf(stderr, "error closing ELF file '%s': %s\n",
             filename, strerror(errno));
     exit(1);
   }
 }
 #endif