[llvm] r296661 - [PDB] Fix and re-enable BinaryStreamArray test.

Zachary Turner via llvm-commits llvm-commits at lists.llvm.org
Wed Mar 1 11:29:11 PST 2017


Author: zturner
Date: Wed Mar  1 13:29:11 2017
New Revision: 296661

URL: http://llvm.org/viewvc/llvm-project?rev=296661&view=rev
Log:
[PDB] Fix and re-enable BinaryStreamArray test.

This was due to the test stream choosing an arbitrary partition
index for introducing the discontinuity rather than choosing
an index that would be correctly aligned for the type of data.

Also added an assertion into FixedStreamArray so that this will
be caught on all bots in the future, and not just the UBSan bot.

Modified:
    llvm/trunk/include/llvm/DebugInfo/MSF/BinaryStreamArray.h
    llvm/trunk/unittests/DebugInfo/PDB/BinaryStreamTest.cpp

Modified: llvm/trunk/include/llvm/DebugInfo/MSF/BinaryStreamArray.h
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/include/llvm/DebugInfo/MSF/BinaryStreamArray.h?rev=296661&r1=296660&r2=296661&view=diff
==============================================================================
--- llvm/trunk/include/llvm/DebugInfo/MSF/BinaryStreamArray.h (original)
+++ llvm/trunk/include/llvm/DebugInfo/MSF/BinaryStreamArray.h Wed Mar  1 13:29:11 2017
@@ -243,6 +243,7 @@ public:
       // an exact multiple of the element size.
       consumeError(std::move(EC));
     }
+    assert(llvm::alignmentAdjustment(Data.data(), alignof(T)) == 0);
     return *reinterpret_cast<const T *>(Data.data());
   }
 

Modified: llvm/trunk/unittests/DebugInfo/PDB/BinaryStreamTest.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/unittests/DebugInfo/PDB/BinaryStreamTest.cpp?rev=296661&r1=296660&r2=296661&view=diff
==============================================================================
--- llvm/trunk/unittests/DebugInfo/PDB/BinaryStreamTest.cpp (original)
+++ llvm/trunk/unittests/DebugInfo/PDB/BinaryStreamTest.cpp Wed Mar  1 13:29:11 2017
@@ -48,8 +48,10 @@ namespace {
 
 class DiscontiguousStream : public WritableBinaryStream {
 public:
-  DiscontiguousStream(MutableArrayRef<uint8_t> Data, endianness Endian)
-      : Data(Data), PartitionIndex(Data.size() / 2), Endian(Endian) {}
+  DiscontiguousStream(MutableArrayRef<uint8_t> Data, endianness Endian,
+                      uint32_t Align)
+      : Data(Data), PartitionIndex(alignDown(Data.size() / 2, Align)),
+        Endian(Endian) {}
 
   endianness getEndian() const override { return Endian; }
 
@@ -150,12 +152,12 @@ protected:
     std::unique_ptr<WritableBinaryStream> Output;
   };
 
-  void initializeInput(ArrayRef<uint8_t> Input) {
+  void initializeInput(ArrayRef<uint8_t> Input, uint32_t Align) {
     InputData = Input;
 
     BrokenInputData.resize(InputData.size());
     if (!Input.empty()) {
-      uint32_t PartitionIndex = InputData.size() / 2;
+      uint32_t PartitionIndex = alignDown(InputData.size() / 2, Align);
       uint32_t RightBytes = InputData.size() - PartitionIndex;
       uint32_t LeftBytes = PartitionIndex;
       if (RightBytes > 0)
@@ -167,41 +169,41 @@ protected:
     for (uint32_t I = 0; I < NumEndians; ++I) {
       auto InByteStream =
           llvm::make_unique<BinaryByteStream>(InputData, Endians[I]);
-      auto InBrokenStream =
-          llvm::make_unique<DiscontiguousStream>(BrokenInputData, Endians[I]);
+      auto InBrokenStream = llvm::make_unique<DiscontiguousStream>(
+          BrokenInputData, Endians[I], Align);
 
       Streams[I * 2].Input = std::move(InByteStream);
       Streams[I * 2 + 1].Input = std::move(InBrokenStream);
     }
   }
 
-  void initializeOutput(uint32_t Size) {
+  void initializeOutput(uint32_t Size, uint32_t Align) {
     OutputData.resize(Size);
     BrokenOutputData.resize(Size);
 
     for (uint32_t I = 0; I < NumEndians; ++I) {
       Streams[I * 2].Output =
           llvm::make_unique<MutableBinaryByteStream>(OutputData, Endians[I]);
-      Streams[I * 2 + 1].Output =
-          llvm::make_unique<DiscontiguousStream>(BrokenOutputData, Endians[I]);
+      Streams[I * 2 + 1].Output = llvm::make_unique<DiscontiguousStream>(
+          BrokenOutputData, Endians[I], Align);
     }
   }
 
-  void initializeOutputFromInput() {
+  void initializeOutputFromInput(uint32_t Align) {
     for (uint32_t I = 0; I < NumEndians; ++I) {
       Streams[I * 2].Output =
           llvm::make_unique<MutableBinaryByteStream>(InputData, Endians[I]);
-      Streams[I * 2 + 1].Output =
-          llvm::make_unique<DiscontiguousStream>(BrokenInputData, Endians[I]);
+      Streams[I * 2 + 1].Output = llvm::make_unique<DiscontiguousStream>(
+          BrokenInputData, Endians[I], Align);
     }
   }
 
-  void initializeInputFromOutput() {
+  void initializeInputFromOutput(uint32_t Align) {
     for (uint32_t I = 0; I < NumEndians; ++I) {
       Streams[I * 2].Input =
           llvm::make_unique<BinaryByteStream>(OutputData, Endians[I]);
-      Streams[I * 2 + 1].Input =
-          llvm::make_unique<DiscontiguousStream>(BrokenOutputData, Endians[I]);
+      Streams[I * 2 + 1].Input = llvm::make_unique<DiscontiguousStream>(
+          BrokenOutputData, Endians[I], Align);
     }
   }
 
@@ -217,7 +219,7 @@ protected:
 // Tests that a we can read from a BinaryByteStream without a StreamReader.
 TEST_F(BinaryStreamTest, BinaryByteStreamBounds) {
   std::vector<uint8_t> InputData = {1, 2, 3, 4, 5};
-  initializeInput(InputData);
+  initializeInput(InputData, 1);
 
   for (auto &Stream : Streams) {
     ArrayRef<uint8_t> Buffer;
@@ -236,7 +238,7 @@ TEST_F(BinaryStreamTest, BinaryByteStrea
 
 TEST_F(BinaryStreamTest, StreamRefBounds) {
   std::vector<uint8_t> InputData = {1, 2, 3, 4, 5};
-  initializeInput(InputData);
+  initializeInput(InputData, 1);
 
   for (const auto &Stream : Streams) {
     ArrayRef<uint8_t> Buffer;
@@ -289,8 +291,8 @@ TEST_F(BinaryStreamTest, StreamRefBounds
 // Test that we can write to a BinaryStream without a StreamWriter.
 TEST_F(BinaryStreamTest, MutableBinaryByteStreamBounds) {
   std::vector<uint8_t> InputData = {'T', 'e', 's', 't', '\0'};
-  initializeInput(InputData);
-  initializeOutput(InputData.size());
+  initializeInput(InputData, 1);
+  initializeOutput(InputData.size(), 1);
 
   // For every combination of input stream and output stream.
   for (auto &Stream : Streams) {
@@ -330,7 +332,7 @@ TEST_F(BinaryStreamTest, FixedStreamArra
   ArrayRef<uint8_t> IntBytes(reinterpret_cast<uint8_t *>(Ints.data()),
                              Ints.size() * sizeof(uint32_t));
 
-  initializeInput(IntBytes);
+  initializeInput(IntBytes, alignof(uint32_t));
 
   for (auto &Stream : Streams) {
     MutableArrayRef<uint8_t> Buffer;
@@ -352,7 +354,7 @@ TEST_F(BinaryStreamTest, VarStreamArray)
                         "Extra Longest Test Of All");
   ArrayRef<uint8_t> StringBytes(
       reinterpret_cast<const uint8_t *>(Strings.data()), Strings.size());
-  initializeInput(StringBytes);
+  initializeInput(StringBytes, 1);
 
   struct StringExtractor {
   public:
@@ -392,7 +394,7 @@ TEST_F(BinaryStreamTest, VarStreamArray)
 TEST_F(BinaryStreamTest, StreamReaderBounds) {
   std::vector<uint8_t> Bytes;
 
-  initializeInput(Bytes);
+  initializeInput(Bytes, 1);
   for (auto &Stream : Streams) {
     StringRef S;
     BinaryStreamReader Reader(*Stream.Input);
@@ -401,7 +403,7 @@ TEST_F(BinaryStreamTest, StreamReaderBou
   }
 
   Bytes.resize(5);
-  initializeInput(Bytes);
+  initializeInput(Bytes, 1);
   for (auto &Stream : Streams) {
     StringRef S;
     BinaryStreamReader Reader(*Stream.Input);
@@ -420,8 +422,8 @@ TEST_F(BinaryStreamTest, StreamReaderInt
   constexpr uint32_t Size =
       sizeof(Little) + sizeof(Big) + sizeof(NS) + sizeof(NI) + sizeof(NUL);
 
-  initializeOutput(Size);
-  initializeInputFromOutput();
+  initializeOutput(Size, alignof(support::ulittle64_t));
+  initializeInputFromOutput(alignof(support::ulittle64_t));
 
   for (auto &Stream : Streams) {
     BinaryStreamWriter Writer(*Stream.Output);
@@ -454,13 +456,13 @@ TEST_F(BinaryStreamTest, StreamReaderInt
   }
 }
 
-TEST_F(BinaryStreamTest, DISABLED_StreamReaderIntegerArray) {
+TEST_F(BinaryStreamTest, StreamReaderIntegerArray) {
   // 1. Arrays of integers
   std::vector<int> Ints = {1, 2, 3, 4, 5};
   ArrayRef<uint8_t> IntBytes(reinterpret_cast<uint8_t *>(&Ints[0]),
                              Ints.size() * sizeof(int));
 
-  initializeInput(IntBytes);
+  initializeInput(IntBytes, alignof(int));
   for (auto &Stream : Streams) {
     BinaryStreamReader Reader(*Stream.Input);
     ArrayRef<int> IntsRef;
@@ -481,8 +483,8 @@ TEST_F(BinaryStreamTest, StreamReaderEnu
 
   std::vector<MyEnum> Enums = {MyEnum::Bar, MyEnum::Baz, MyEnum::Foo};
 
-  initializeOutput(Enums.size() * sizeof(MyEnum));
-  initializeInputFromOutput();
+  initializeOutput(Enums.size() * sizeof(MyEnum), alignof(MyEnum));
+  initializeInputFromOutput(alignof(MyEnum));
   for (auto &Stream : Streams) {
     BinaryStreamWriter Writer(*Stream.Output);
     for (auto Value : Enums)
@@ -515,7 +517,7 @@ TEST_F(BinaryStreamTest, StreamReaderObj
 
   const uint8_t *Bytes = reinterpret_cast<const uint8_t *>(&Foos[0]);
 
-  initializeInput(makeArrayRef(Bytes, 2 * sizeof(Foo)));
+  initializeInput(makeArrayRef(Bytes, 2 * sizeof(Foo)), alignof(Foo));
 
   for (auto &Stream : Streams) {
     // 1. Reading object pointers.
@@ -534,7 +536,7 @@ TEST_F(BinaryStreamTest, StreamReaderStr
   std::vector<uint8_t> Bytes = {'O',  'n', 'e', '\0', 'T', 'w', 'o',
                                 '\0', 'T', 'h', 'r',  'e', 'e', '\0',
                                 'F',  'o', 'u', 'r',  '\0'};
-  initializeInput(Bytes);
+  initializeInput(Bytes, 1);
 
   for (auto &Stream : Streams) {
     BinaryStreamReader Reader(*Stream.Input);
@@ -574,7 +576,7 @@ TEST_F(BinaryStreamTest, StreamReaderStr
 }
 
 TEST_F(BinaryStreamTest, StreamWriterBounds) {
-  initializeOutput(5);
+  initializeOutput(5, 1);
 
   for (auto &Stream : Streams) {
     BinaryStreamWriter Writer(*Stream.Output);
@@ -600,8 +602,8 @@ TEST_F(BinaryStreamTest, StreamWriterInt
   ArrayRef<uint8_t> SourceBytes(reinterpret_cast<uint8_t *>(&SourceInts[0]),
                                 SourceInts.size() * sizeof(int));
 
-  initializeInput(SourceBytes);
-  initializeOutputFromInput();
+  initializeInput(SourceBytes, alignof(int));
+  initializeOutputFromInput(alignof(int));
 
   for (auto &Stream : Streams) {
     BinaryStreamReader Reader(*Stream.Input);
@@ -625,8 +627,8 @@ TEST_F(BinaryStreamTest, StringWriterStr
   size_t Length = 0;
   for (auto S : Strings)
     Length += S.size() + 1;
-  initializeOutput(Length);
-  initializeInputFromOutput();
+  initializeOutput(Length, 1);
+  initializeInputFromOutput(1);
 
   for (auto &Stream : Streams) {
     BinaryStreamWriter Writer(*Stream.Output);




More information about the llvm-commits mailing list