Add encode and decode methods to InlineInfo and document encoding format to the GSYM file format

[clayborg]

Summary

The full GSYM patch started with: https://reviews.llvm.org/D53379

This patch adds the ability to encode and decode InlineInfo objects and adds test coverage.

[aprantl]

lib/DebugInfo/GSYM/InlineInfo.cpp

63

This returns a bool.. what does that mean?

84

and here the return value is ignored?

[clayborg]

lib/DebugInfo/GSYM/InlineInfo.cpp

63

returns true if a InlineInfo is successfully decoded. This is a static function that is called recursively from within this function. The while statement on line 74 uses the return value.

84

I will clear the InlineInfo if this returns false.

[clayborg]

• document arguments to "static bool decodeAll(...)" in InlineInfo.cpp
• If decodeAll() returns false, clear the InlineInfo

[aprantl]

lib/DebugInfo/GSYM/InlineInfo.cpp

101

This also seems weird. Why wouldn't decode() guarantee that it leaves the object in a consistent state? Why silently swallow the error?

Perhaps it would be cleaner if decode returned an expected<InlineInfo> object? Then you don't need a clear() method in the first place.

[clayborg]

lib/DebugInfo/GSYM/InlineInfo.cpp

98–101

We could leave it out as it was before. The decodeAll just returning a bool was for the recursion. It would actually be nice to have this fail with the data it was able to decode. Not sure what error we can really return besides "not enough data"?

[clayborg]

Don't clear the inline info when decodeAll returns false so that we can see what was actually decoded. Not sure how great of an error we can return other than "not enough data". I am open to suggestions?

[MaskRay]

lib/DebugInfo/GSYM/InlineInfo.cpp

103

Doesn't it need a few bytes to represent an empty Ranges? Or is it just unexpected to call encode on an empty Ranges (in this case an assert or llvm_unreachable might be better)

[clayborg]

lib/DebugInfo/GSYM/InlineInfo.cpp

102–103

I think you are correct in that we should avoid calling this function in this case and have the user verify the data is good since this data will eventually be in a blob in the GSYM file that won't make sense to encode it at all of the data is not valid as it will just waste file space.

[clayborg]

• use llvm_unreachable when encoding InlineInfo objects. We don't want them emitted into the GSYM file and taking up space if they aren't valid.
• improve comment about terminating child InlineInfo object siblings.

[JDevlieghere]

lib/DebugInfo/GSYM/InlineInfo.cpp

63

I think Adrian means that an llvm:Error might be a better fit. That way the error can propagate up.

86

This could be an early return.

113

This could be an early return.

[clayborg]

Added error handling to InlineInfo::encode and InlineInfo::decode with full testing.

For encoding return an error when we try to encode an invalid InlineInfo and when a child InlineInfo has an address range that isn't contained in the parent's address range. This will help detect clients that use bad debug info data to create GSYM InlineInfo objects ensure that they correctly construct valid InlineInfo hierarchies. Added the ability to check if an address range is contained within an AddressRanges object to support this feature.

For decoding detect when data is missing from the steam and report an error with the exact offset with an appropriate error message.

[aprantl]

Thanks for implementing the error handling! There is one more comment inline.

lib/DebugInfo/GSYM/InlineInfo.cpp

127

What's the advantage of having invalid InlineInfo objects? Could we just have whoever creates them return a a valid object or an error otherwise?

[MaskRay]

lib/DebugInfo/GSYM/Range.cpp

53

Did you intend to use It[-1].End twice?

I am not certain what this function intends to do, but
should it be return Range.End <= It[-1].End;?

[MaskRay]

lib/DebugInfo/GSYM/InlineInfo.cpp

149

if (llvm::Error E = ...)
  return E

(Avoid Error which is also a type name)

[clayborg]

lib/DebugInfo/GSYM/InlineInfo.cpp

127

InlineInfo objects will be created by converting debug info into these objects. So they start out default constructed and then get populated as we parse the attributes. Clients should ensure these objects are valid prior to adding them to a GSYM file or into another InlineInfo object.

[clayborg]

$ svn commit
Sending include/llvm/DebugInfo/GSYM/InlineInfo.h
Sending include/llvm/DebugInfo/GSYM/Range.h
Sending lib/DebugInfo/GSYM/InlineInfo.cpp
Sending lib/DebugInfo/GSYM/Range.cpp
Sending unittests/DebugInfo/GSYM/GSYMTest.cpp
Transmitting file data .....done
Committing transaction...
Committed revision 370936.

[MaskRay]

lib/DebugInfo/GSYM/Range.cpp

46

Do you know why it returns false if Range.size() == 0?

If I remove Range.size() == 0, the following test will break

EXPECT_FALSE(Ranges.contains(AddressRange(0x1000, 0x1000)));

[clayborg]

lib/DebugInfo/GSYM/Range.cpp

46

This is looking forward to the time when we convert debug info into GSYM. Many compilers will make the low PC and high PC the same for debug info that has been optimized out. Also, an address range with no size is not a valid address range, so it can't be contained inside of another.

include/llvm/DebugInfo/GSYM/InlineInfo.h

 //===- InlineInfo.h ---------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_GSYM_INLINEINFO_H
 #define LLVM_DEBUGINFO_GSYM_INLINEINFO_H
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/DebugInfo/GSYM/Range.h"
+#include "llvm/Support/Error.h"
 #include <stdint.h>
 #include <vector>
 
 
 namespace llvm {
 class raw_ostream;
 
 namespace gsym {
 
 /// Inline information stores the name of the inline function along with
 /// an array of address ranges. It also stores the call file and call line
 /// that called this inline function. This allows us to unwind inline call
 /// stacks back to the inline or concrete function that called this
 /// function. Inlined functions contained in this function are stored in the
 /// "Children" variable. All address ranges must be sorted and all address
 /// ranges of all children must be contained in the ranges of this function.
 /// Any clients that encode information will need to ensure the ranges are
 /// all contined correctly or lookups could fail. Add ranges in these objects
 /// must be contained in the top level FunctionInfo address ranges as well.
+///
+/// ENCODING
+///
+/// When saved to disk, the inline info encodes all ranges to be relative to
+/// a parent address range. This will be the FunctionInfo's start address if
+/// the InlineInfo is directly contained in a FunctionInfo, or a the start
+/// address of the containing parent InlineInfo's first "Ranges" member. This
+/// allows address ranges to be efficiently encoded using ULEB128 encodings as
+/// we encode the offset and size of each range instead of full addresses. This
+/// also makes any encoded addresses easy to relocate as we just need to
+/// relocate the FunctionInfo's start address.
+///
+/// - The AddressRanges member "Ranges" is encoded using an approriate base
+///   address as described above.
+/// - UINT8 boolean value that specifies if the InlineInfo object has children.
+/// - UINT32 string table offset that points to the name of the inline
+///   function.
+/// - ULEB128 integer that specifies the file of the call site that called
+///   this function.
+/// - ULEB128 integer that specifies the source line of the call site that
+///   called this function.
+/// - if this object has children, enocode each child InlineInfo using the
+///   the first address range's start address as the base address.
+///
 struct InlineInfo {
 
   uint32_t Name; ///< String table offset in the string table.
   uint32_t CallFile; ///< 1 based file index in the file table.
   uint32_t CallLine; ///< Source line number.
   AddressRanges Ranges;
   std::vector<InlineInfo> Children;
   InlineInfo() : Name(0), CallFile(0), CallLine(0) {}
struct InlineInfo {
   /// and have the stack trace show the original call site from
   /// non-inlined code.
   ///
   /// \param Addr the address to lookup
   ///
   /// \returns optional vector of InlineInfo objects that describe the
   /// inline call stack for a given address, false otherwise.
   llvm::Optional<InlineArray> getInlineStack(uint64_t Addr) const;
+
+  /// Decode an InlineInfo object from a binary data stream.
+  ///
+  /// \param Data The binary stream to read the data from. This object must
+  /// have the data for the InlineInfo object starting at offset zero. The data
+  /// can contain more data than needed.
+  ///
+  /// \param BaseAddr The base address to use when decoding all address ranges.
+  /// This will be the FunctionInfo's start address if this object is directly
+  /// contained in a FunctionInfo object, or the start address of the first
+  /// address range in an InlineInfo object of this object is a child of
+  /// another InlineInfo object.
+  /// \returns An InlineInfo or an error describing the issue that was
+  /// encountered during decoding.
+  static llvm::Expected<InlineInfo> decode(DataExtractor &Data,
+                                           uint64_t BaseAddr);
+
+  /// Encode this InlineInfo object into FileWriter stream.
+  ///
+  /// \param O The binary stream to write the data to at the current file
+  /// position.
+  ///
+  /// \param BaseAddr The base address to use when encoding all address ranges.
+  /// This will be the FunctionInfo's start address if this object is directly
+  /// contained in a FunctionInfo object, or the start address of the first
+  /// address range in an InlineInfo object of this object is a child of
+  /// another InlineInfo object.
+  ///
+  /// \returns An error object that indicates success or failure or the
+  /// encoding process.
+  llvm::Error encode(FileWriter &O, uint64_t BaseAddr) const;
 };
 
 inline bool operator==(const InlineInfo &LHS, const InlineInfo &RHS) {
   return LHS.Name == RHS.Name && LHS.CallFile == RHS.CallFile &&
          LHS.CallLine == RHS.CallLine && LHS.Ranges == RHS.Ranges &&
          LHS.Children == RHS.Children;
 }
 
 raw_ostream &operator<<(raw_ostream &OS, const InlineInfo &FI);
 
 } // namespace gsym
 } // namespace llvm
 
 #endif // #ifndef LLVM_DEBUGINFO_GSYM_INLINEINFO_H

include/llvm/DebugInfo/GSYM/Range.h

 class AddressRanges {
 protected:
   using Collection = std::vector<AddressRange>;
   Collection Ranges;
 public:
   void clear() { Ranges.clear(); }
   bool empty() const { return Ranges.empty(); }
   bool contains(uint64_t Addr) const;
+  bool contains(AddressRange Range) const;
   void insert(AddressRange Range);
   size_t size() const { return Ranges.size(); }
   bool operator==(const AddressRanges &RHS) const {
     return Ranges == RHS.Ranges;
   }
   const AddressRange &operator[](size_t i) const {
     assert(i < Ranges.size());
     return Ranges[i];

lib/DebugInfo/GSYM/InlineInfo.cpp

 //===- InlineInfo.cpp -------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/GSYM/FileEntry.h"
+#include "llvm/DebugInfo/GSYM/FileWriter.h"
 #include "llvm/DebugInfo/GSYM/InlineInfo.h"
+#include "llvm/Support/DataExtractor.h"
 #include <algorithm>
 #include <inttypes.h>
 
 using namespace llvm;
 using namespace gsym;
 
 
 raw_ostream &llvm::gsym::operator<<(raw_ostream &OS, const InlineInfo &II) {

 }
 
 llvm::Optional<InlineInfo::InlineArray> InlineInfo::getInlineStack(uint64_t Addr) const {
   InlineArray Result;
   if (getInlineStackHelper(*this, Addr, Result))
     return Result;
   return llvm::None;
 }
+
+/// Decode an InlineInfo in Data at the specified offset.
+///
+/// A local helper function to decode InlineInfo objects. This function is
+/// called recursively when parsing child InlineInfo objects.
+///
+/// \param Inline The InlineInfo object to decode into.
+/// \param Data The data extractor to decode from.
+/// \param Offset The offset within \a Data to decode from.
+/// \param BaseAddr The base address to use when decoding address ranges.
+/// \returns An InlineInfo or an error describing the issue that was
+/// encountered during decoding.
+static llvm::Expected<InlineInfo> decode(DataExtractor &Data, uint64_t &Offset,
+                                         uint64_t BaseAddr) {
+  InlineInfo Inline;
+  if (!Data.isValidOffset(Offset))
+    return createStringError(std::errc::io_error,
+        "0x%8.8" PRIx64 ": missing InlineInfo address ranges data", Offset);
+  Inline.Ranges.decode(Data, BaseAddr, Offset);
+  if (Inline.Ranges.empty())
+    return Inline;
+  if (!Data.isValidOffsetForDataOfSize(Offset, 1))
+    return createStringError(std::errc::io_error,
+        "0x%8.8" PRIx64 ": missing InlineInfo uint8_t indicating children",
+        Offset);
+  bool HasChildren = Data.getU8(&Offset) != 0;
+  if (!Data.isValidOffsetForDataOfSize(Offset, 4))
+    return createStringError(std::errc::io_error,
+        "0x%8.8" PRIx64 ": missing InlineInfo uint32_t for name", Offset);
+  Inline.Name = Data.getU32(&Offset);
+  if (!Data.isValidOffset(Offset))
+    return createStringError(std::errc::io_error,
+        "0x%8.8" PRIx64 ": missing ULEB128 for InlineInfo call file", Offset);
+  Inline.CallFile = (uint32_t)Data.getULEB128(&Offset);
+  if (!Data.isValidOffset(Offset))
+    return createStringError(std::errc::io_error,
+        "0x%8.8" PRIx64 ": missing ULEB128 for InlineInfo call line", Offset);
+  Inline.CallLine = (uint32_t)Data.getULEB128(&Offset);
+  if (HasChildren) {
+    // Child address ranges are encoded relative to the first address in the
+    // parent InlineInfo object.
+    const auto ChildBaseAddr = Inline.Ranges[0].Start;
+    while (true) {
+      llvm::Expected<InlineInfo> Child = decode(Data, Offset, ChildBaseAddr);
+      if (!Child)
+        return Child.takeError();
+      // InlineInfo with empty Ranges termintes a child sibling chain.
+      if (Child.get().Ranges.empty())
+        break;
+      Inline.Children.emplace_back(std::move(*Child));
+    }
+  }
+  return Inline;
+}
+
+llvm::Expected<InlineInfo> InlineInfo::decode(DataExtractor &Data,
+                                              uint64_t BaseAddr) {
+  uint64_t Offset = 0;
+  return ::decode(Data, Offset, BaseAddr);
+}
+
+llvm::Error InlineInfo::encode(FileWriter &O, uint64_t BaseAddr) const {
+  // Users must verify the InlineInfo is valid prior to calling this funtion.
+  // We don't want to emit any InlineInfo objects if they are not valid since
+  // it will waste space in the GSYM file.
+  if (!isValid())
+    return createStringError(std::errc::invalid_argument,
+                             "attempted to encode invalid InlineInfo object");
+  Ranges.encode(O, BaseAddr);
+  bool HasChildren = !Children.empty();
+  O.writeU8(HasChildren);
+  O.writeU32(Name);
+  O.writeULEB(CallFile);
+  O.writeULEB(CallLine);
+  if (HasChildren) {
+    // Child address ranges are encoded as relative to the first
+    // address in the Ranges for this object. This keeps the offsets
+    // small and allows for efficient encoding using ULEB offsets.
+    const uint64_t ChildBaseAddr = Ranges[0].Start;
+    for (const auto &Child : Children) {
+      // Make sure all child address ranges are contained in the parent address
+      // ranges.
+      for (const auto &ChildRange: Child.Ranges) {
+        if (!Ranges.contains(ChildRange))
+          return createStringError(std::errc::invalid_argument,
+                                   "child range not contained in parent");
+      }
+      llvm::Error Error = Child.encode(O, ChildBaseAddr);
+      if (Error)
+        return Error;
+    }
+
+    // Terminate child sibling chain by emitting a zero. This zero will cause
+    // the decodeAll() function above to return false and stop the decoding
+    // of child InlineInfo objects that are siblings.
+    O.writeULEB(0);
+  }
+  return Error::success();
+}

lib/DebugInfo/GSYM/Range.cpp

 
 bool AddressRanges::contains(uint64_t Addr) const {
   auto It = std::partition_point(
       Ranges.begin(), Ranges.end(),
       [=](const AddressRange &R) { return R.Start <= Addr; });
   return It != Ranges.begin() && Addr < It[-1].End;
 }
 
+bool AddressRanges::contains(AddressRange Range) const {
+  if (Range.size() == 0)
+    return false;
+  auto It = std::partition_point(
+      Ranges.begin(), Ranges.end(),
+      [=](const AddressRange &R) { return R.Start <= Range.Start; });
+  if (It == Ranges.begin())
+    return false;
+  return Range.Start < It[-1].End && Range.End <= It[-1].End;
+}
+
 raw_ostream &llvm::gsym::operator<<(raw_ostream &OS, const AddressRange &R) {
   return OS << '[' << HEX64(R.Start) << " - " << HEX64(R.End) << ")";
 }
 
 raw_ostream &llvm::gsym::operator<<(raw_ostream &OS, const AddressRanges &AR) {
   size_t Size = AR.size();
   for (size_t I = 0; I < Size; ++I) {
     if (I)

unittests/DebugInfo/GSYM/GSYMTest.cpp

TEST(GSYMTest, TestFunctionInfo) {
 
   // Test that if we have the same number of lines we compare the line entries
   // in the FunctionInfo.Lines vector.
   FunctionInfo FIWithLinesWithHigherAddress = FIWithLines;
   FIWithLinesWithHigherAddress.Lines[0].Addr += 0x10;
   EXPECT_LT(FIWithLines, FIWithLinesWithHigherAddress);
 }
 
+void checkError(ArrayRef<std::string> ExpectedMsgs, Error Err) {
+  ASSERT_TRUE(Err.operator bool());
+  size_t WhichMsg = 0;
+  Error Remaining =
+      handleErrors(std::move(Err), [&](const ErrorInfoBase &Actual) {
+        ASSERT_LT(WhichMsg, ExpectedMsgs.size());
+        // Use .str(), because googletest doesn't visualise a StringRef
+        // properly.
+        EXPECT_EQ(Actual.message(), ExpectedMsgs[WhichMsg++]);
+      });
+  EXPECT_EQ(WhichMsg, ExpectedMsgs.size());
+  EXPECT_FALSE(Remaining);
+}
+
+void checkError(std::string ExpectedMsg, Error Err) {
+  checkError(ArrayRef<std::string>{ExpectedMsg}, std::move(Err));
+}
+
+static void TestInlineInfoEncodeDecode(llvm::support::endianness ByteOrder,
+                                       const InlineInfo &Inline) {
+  // Test encoding and decoding InlineInfo objects
+  SmallString<512> Str;
+  raw_svector_ostream OutStrm(Str);
+  FileWriter FW(OutStrm, ByteOrder);
+  const uint64_t BaseAddr = Inline.Ranges[0].Start;
+  llvm::Error Err = Inline.encode(FW, BaseAddr);
+  ASSERT_FALSE(Err);
+  std::string Bytes(OutStrm.str());
+  uint8_t AddressSize = 4;
+  DataExtractor Data(Bytes, ByteOrder == llvm::support::little, AddressSize);
+  llvm::Expected<InlineInfo> Decoded = InlineInfo::decode(Data, BaseAddr);
+  // Make sure decoding succeeded.
+  ASSERT_TRUE((bool)Decoded);
+  // Make sure decoded object is the same as the one we encoded.
+  EXPECT_EQ(Inline, Decoded.get());
+}
+
+static void TestInlineInfoDecodeError(llvm::support::endianness ByteOrder,
+                                      std::string Bytes,
+                                      const uint64_t BaseAddr,
+                                      std::string ExpectedErrorMsg) {
+  uint8_t AddressSize = 4;
+  DataExtractor Data(Bytes, ByteOrder == llvm::support::little, AddressSize);
+  llvm::Expected<InlineInfo> Decoded = InlineInfo::decode(Data, BaseAddr);
+  // Make sure decoding fails.
+  ASSERT_FALSE((bool)Decoded);
+  // Make sure decoded object is the same as the one we encoded.
+  checkError(ExpectedErrorMsg, Decoded.takeError());
+}
+
+static void TestInlineInfoEncodeError(llvm::support::endianness ByteOrder,
+                                      const InlineInfo &Inline,
+                                      std::string ExpectedErrorMsg) {
+  SmallString<512> Str;
+  raw_svector_ostream OutStrm(Str);
+  FileWriter FW(OutStrm, ByteOrder);
+  const uint64_t BaseAddr = Inline.Ranges.empty() ? 0 : Inline.Ranges[0].Start;
+  llvm::Error Err = Inline.encode(FW, BaseAddr);
+  checkError(ExpectedErrorMsg, std::move(Err));
+}
+
 TEST(GSYMTest, TestInlineInfo) {
   // Test InlineInfo structs.
   InlineInfo II;
   EXPECT_FALSE(II.isValid());
   II.Ranges.insert(AddressRange(0x1000, 0x2000));
   // Make sure InlineInfo in valid with just an address range since
   // top level InlineInfo objects have ranges with no name, call file
   // or call line
TEST(GSYMTest, TestInlineInfo) {
   ASSERT_EQ(InlineInfos->size(), 2u);
   ASSERT_EQ(*InlineInfos->at(0), Inline1Sub2);
   ASSERT_EQ(*InlineInfos->at(1), Inline1);
   InlineInfos = Root.getInlineStack(Inline1Sub2.Ranges[0].End - 1);
   EXPECT_TRUE(InlineInfos);
   ASSERT_EQ(InlineInfos->size(), 2u);
   ASSERT_EQ(*InlineInfos->at(0), Inline1Sub2);
   ASSERT_EQ(*InlineInfos->at(1), Inline1);
+
+  // Test encoding and decoding InlineInfo objects
+  TestInlineInfoEncodeDecode(llvm::support::little, Root);
+  TestInlineInfoEncodeDecode(llvm::support::big, Root);
+}
+
+TEST(GSYMTest, TestInlineInfoEncodeErrors) {
+  // Test InlineInfo encoding errors.
+
+  // Test that we get an error when trying to encode an InlineInfo object
+  // that has no ranges.
+  InlineInfo Empty;
+  std::string EmptyErr("attempted to encode invalid InlineInfo object");
+  TestInlineInfoEncodeError(llvm::support::little, Empty, EmptyErr);
+  TestInlineInfoEncodeError(llvm::support::big, Empty, EmptyErr);
+
+  // Verify that we get an error trying to encode an InlineInfo object that has
+  // a child InlineInfo that has no ranges.
+  InlineInfo ContainsEmpty;
+  ContainsEmpty.Ranges.insert({0x100,200});
+  ContainsEmpty.Children.push_back(Empty);
+  TestInlineInfoEncodeError(llvm::support::little, ContainsEmpty, EmptyErr);
+  TestInlineInfoEncodeError(llvm::support::big, ContainsEmpty, EmptyErr);
+
+  // Verify that we get an error trying to encode an InlineInfo object that has
+  // a child whose address range is not contained in the parent address range.
+  InlineInfo ChildNotContained;
+  std::string ChildNotContainedErr("child range not contained in parent");
+  ChildNotContained.Ranges.insert({0x100,200});
+  InlineInfo ChildNotContainedChild;
+  ChildNotContainedChild.Ranges.insert({0x200,300});
+  ChildNotContained.Children.push_back(ChildNotContainedChild);
+  TestInlineInfoEncodeError(llvm::support::little, ChildNotContained,
+                            ChildNotContainedErr);
+  TestInlineInfoEncodeError(llvm::support::big, ChildNotContained,
+                            ChildNotContainedErr);
+
+}
+
+TEST(GSYMTest, TestInlineInfoDecodeErrors) {
+  // Test decoding InlineInfo objects that ensure we report an appropriate
+  // error message.
+  const llvm::support::endianness ByteOrder = llvm::support::little;
+  SmallString<512> Str;
+  raw_svector_ostream OutStrm(Str);
+  FileWriter FW(OutStrm, ByteOrder);
+  const uint64_t BaseAddr = 0x100;
+  TestInlineInfoDecodeError(ByteOrder, OutStrm.str(), BaseAddr,
+      "0x00000000: missing InlineInfo address ranges data");
+  AddressRanges Ranges;
+  Ranges.insert({BaseAddr, BaseAddr+0x100});
+  Ranges.encode(FW, BaseAddr);
+  TestInlineInfoDecodeError(ByteOrder, OutStrm.str(), BaseAddr,
+      "0x00000004: missing InlineInfo uint8_t indicating children");
+  FW.writeU8(0);
+  TestInlineInfoDecodeError(ByteOrder, OutStrm.str(), BaseAddr,
+      "0x00000005: missing InlineInfo uint32_t for name");
+  FW.writeU32(0);
+  TestInlineInfoDecodeError(ByteOrder, OutStrm.str(), BaseAddr,
+      "0x00000009: missing ULEB128 for InlineInfo call file");
+  FW.writeU8(0);
+  TestInlineInfoDecodeError(ByteOrder, OutStrm.str(), BaseAddr,
+      "0x0000000a: missing ULEB128 for InlineInfo call line");
 }
 
 TEST(GSYMTest, TestLineEntry) {
   // test llvm::gsym::LineEntry structs.
   const uint64_t ValidAddr = 0x1000;
   const uint64_t InvalidFileIdx = 0;
   const uint32_t ValidFileIdx = 1;
   const uint32_t ValidLine = 5;
TEST(GSYMTest, TestRanges) {
   EXPECT_TRUE(Ranges.contains(0x4000));
   EXPECT_TRUE(Ranges.contains(0x2000 - 1));
   EXPECT_TRUE(Ranges.contains(0x3000 - 1));
   EXPECT_FALSE(Ranges.contains(0x3000 + 1));
   EXPECT_TRUE(Ranges.contains(0x5000 - 1));
   EXPECT_FALSE(Ranges.contains(0x5000 + 1));
   EXPECT_FALSE(Ranges.contains(UINT64_MAX));
 
+  EXPECT_FALSE(Ranges.contains(AddressRange()));
+  EXPECT_FALSE(Ranges.contains(AddressRange(0x1000-1, 0x1000)));
+  EXPECT_FALSE(Ranges.contains(AddressRange(0x1000, 0x1000)));
+  EXPECT_TRUE(Ranges.contains(AddressRange(0x1000, 0x1000+1)));
+  EXPECT_TRUE(Ranges.contains(AddressRange(0x1000, 0x2000)));
+  EXPECT_FALSE(Ranges.contains(AddressRange(0x1000, 0x2001)));
+  EXPECT_TRUE(Ranges.contains(AddressRange(0x2000, 0x3000)));
+  EXPECT_FALSE(Ranges.contains(AddressRange(0x2000, 0x3001)));
+  EXPECT_FALSE(Ranges.contains(AddressRange(0x3000, 0x3001)));
+  EXPECT_FALSE(Ranges.contains(AddressRange(0x1500, 0x4500)));
+  EXPECT_FALSE(Ranges.contains(AddressRange(0x5000, 0x5001)));
+
   // Verify that intersecting ranges get combined
   Ranges.clear();
   Ranges.insert(AddressRange(0x1100, 0x1F00));
   // Verify a wholy contained range that is added doesn't do anything.
   Ranges.insert(AddressRange(0x1500, 0x1F00));
   EXPECT_EQ(Ranges.size(), 1u);
   EXPECT_EQ(Ranges[0], AddressRange(0x1100, 0x1F00));