[DebugInfo] Report unsupported maximum_operations_per_instruction values

[jhenderson]

Summary

This patch adds a check which reports an unsupported value of the maximum_operations_per_instruction field in a debug line table header. This is reported once per line table, at most, and only if the table would otherwise need to use it (i.e. never for tables with version 3 or less, or for tables which don't use DW_LNS_const_add_pc or special opcodes). Unsupported values are currently any apart from 1.

See also D43470, which takes a similar approach for bad line_range values (i.e. 0). I may refactor the pair of them to avoid the code duplication.

Depends on D75188.

[jhenderson]

There are a couple of issues in this change, and I also want to refactor it and D43470 to share some code.

[probinson]

llvm/unittests/DebugInfo/DWARF/DWARFDebugLineTest.cpp

9

Should not have moved this; it's not the header for this module.

[jhenderson]

llvm/unittests/DebugInfo/DWARF/DWARFDebugLineTest.cpp

9

Weird. I don't know how that happened. I certainly wouldn't have deliberately moved it.

[jhenderson]

Rewrite to allow for other similar checks to be added in subsequent changes. See D43470 and another patch TBD. See the full patch series for why the test unit test is written the way it is (the other two patches reuse the fixture).

[ikudrin]

llvm/unittests/DebugInfo/DWARF/DWARFDebugLineTest.cpp

752

clang-9 shows a warning here:

DWARFDebugLineTest.cpp:752:8: warning: '(anonymous namespace)::AdjustAddressFixtureBase' has virtual functions but non-virtual destructor [-Wnon-virtual-dtor]

928

Yet another warning:

DWARFDebugLineTest.cpp:928:8: warning: 'SetUp' overrides a member function but is not marked 'override' [-Winconsistent-missing-override]

The similar warnings are also shown for SetUp methods in the dependent patches.

[jhenderson]

llvm/unittests/DebugInfo/DWARF/DWARFDebugLineTest.cpp

928

Does this SetUp warning also apply for the DebugLineParameterisedFixture or DebugLineUnsupportedVersionFixture classes? They aren't new, but are missing overrides on their SetUp functions.

[ikudrin]

llvm/unittests/DebugInfo/DWARF/DWARFDebugLineTest.cpp

928

Nope. The warning appears if some methods in a class are missing override.

[jhenderson]

Rebase and move some of the parameters to the ParsingState class to reduce the number of arguments required in the functions. Also fix warnings mentioned by @ikudrin.

[probinson]

DWARFDebugLine.h has a pre-merge clang-format note, did you miss that?

[jhenderson]

In D74819#1903147, @probinson wrote:

DWARFDebugLine.h has a pre-merge clang-format note, did you miss that?

Oops, my bad (a result of a bad rebase/merge that was). I'll fix it.

[jhenderson]

Fix formatting.

[probinson]

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugLine.h

374 ↗

(On Diff #248136)

As a future API simplification, think about using dwarf::LNStandardName() to compute the names as needed, instead of passing around strings. LNStandardName() would need an opcode_base parameter to know which ones are special for a particular line-number program, but it's used in only one place that I can find, so that should be an easy update.
I know there's the weird case of DW_LNS_const_add_pc where you're basing the advance on 255 but want to use the real opcode for reporting; but the weird cases are why we pay you the big bucks.

llvm/unittests/DebugInfo/DWARF/DWARFDebugLineTest.cpp

9

Did it move again? If you ran clang-format, I wonder if there's a bug in it (it might think it's moving the "module's" header to the top, but have incorrect module-header detection).

[jhenderson]

Fix formatting again. I blame Visual Studio...!

[jhenderson]

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugLine.h

374 ↗

(On Diff #248136)

I had a play around with this, and LNStandardName isnt't suitable for passing in opcode_base with directly, as it needs to share the interface with the equivalent functions for other DWARF enum types. I can workaround this with a little extra logic though, I think.

llvm/unittests/DebugInfo/DWARF/DWARFDebugLineTest.cpp

9

Weird...

[jhenderson]

Redo name handling to remove the need for specifying it explicitly.

[probinson]

Thanks for simplifying the API. One more bit of code tidying and I think I will be happy.

llvm/lib/DebugInfo/DWARF/DWARFDebugLine.cpp

581

Sink this under the if as you don't need the name unless you're reporting the warning.

595

After sinking the getOpcodeName call, you have a block under the if instead of just a single statement, in which case you might as well move ReportAdvanceAddrProblem = false into that block as well.
These moves help distinguish the error-reporting stuff from the functional stuff as well.

[jhenderson]

llvm/lib/DebugInfo/DWARF/DWARFDebugLine.cpp

581

It's used in the second error added in D75189, so I don't think sinking it inside the if makes much sense.

595

Same response as above. Given the additional error message in D75189, I can't put it inside the if.

[jhenderson]

Fix formatting.

[probinson]

LGTM

[MaskRay]

llvm/lib/DebugInfo/DWARF/DWARFDebugLine.cpp

515

struct can be omitted (and conventional in C++).

llvm/unittests/DebugInfo/DWARF/DWARFDebugLineTest.cpp

928

public can be omitted for struct.

[jhenderson]

Get rid of some unnecessary public usage.

[jhenderson]

llvm/lib/DebugInfo/DWARF/DWARFDebugLine.cpp

515

I took a look at this, but LineTable is both a member name and struct name here. We'd have to explicitly qualify the type name to be DWARFDebugLine::LineTable. There are several similar maybe unnecessary struct specifiers in the header too, but these are all because various members have the same name as their type. I'd recommend leaving this until the variable case changes are made in this code, after which there should be no ambiguity.

llvm/lib/DebugInfo/DWARF/DWARFDebugLine.cpp

 void DWARFDebugLine::LineTable::clear() {
   Prologue.clear();
   Rows.clear();
   Sequences.clear();
 }
 
 DWARFDebugLine::ParsingState::ParsingState(struct LineTable *LT)
     : LineTable(LT) {
   resetRowAndSequence();
 }
 
 void DWARFDebugLine::ParsingState::resetRowAndSequence() {
   Row.reset(LineTable->Prologue.DefaultIsStmt);
   Sequence.reset();
 }
 
 void DWARFDebugLine::ParsingState::appendRowToMatrix() {
struct AdvanceAddrProperties {
   uint8_t AdjustedOpcode;
   uint8_t OperationAdvance;
 };
 
 static AdvanceAddrProperties
 getOperationAdvance(uint8_t Opcode, uint8_t OpcodeBase, uint8_t LineRange) {
   AdvanceAddrProperties Result;
   Result.AdjustedOpcode = Opcode - OpcodeBase;
   Result.OperationAdvance = Result.AdjustedOpcode / LineRange;
   return Result;
 }
 
 static uint64_t advanceAddr(uint64_t OperationAdvance,
-                            const DWARFDebugLine::Prologue &Prologue) {
+                            const DWARFDebugLine::Prologue &Prologue,
+                            uint64_t OpcodeOffset, StringRef OpcodeName,
+                            uint64_t TableOffset,
+                            bool &ReportAdvanceAddrProblem,
+                            function_ref<void(Error)> ErrorHandler) {
+  // For versions less than 4, the MaxOpsPerInst member is set to 0, as the
+  // maximum_operations_per_instruction field wasn't introduced until DWARFv4.
+  // Don't warn about bad values in this situation.
+  if (ReportAdvanceAddrProblem && Prologue.getVersion() >= 4 &&
+      Prologue.MaxOpsPerInst != 1)
+    ErrorHandler(createStringError(
+        errc::not_supported,
+        "line table program at offset 0x%8.8" PRIx64
+        " contains a %s opcode at offset 0x%8.8" PRIx64
+        ", but the prologue maximum_operations_per_instruction value is %" PRId8
+        ", which is unsupported. Assuming a value of 1 instead",
+        TableOffset, OpcodeName.data(), OpcodeOffset, Prologue.MaxOpsPerInst));
+  ReportAdvanceAddrProblem = false;
   return OperationAdvance * Prologue.MinInstLength;
 }
 
 Error DWARFDebugLine::LineTable::parse(
     DWARFDataExtractor &DebugLineData, uint64_t *OffsetPtr,
     const DWARFContext &Ctx, const DWARFUnit *U,
     function_ref<void(Error)> RecoverableErrorHandler, raw_ostream *OS) {
   const uint64_t DebugLineOffset = *OffsetPtr;
Error DWARFDebugLine::LineTable::parse(
   if (DebugLineData.getAddressSize() == 0)
     DebugLineData.setAddressSize(Prologue.getAddressSize());
   else
     assert(Prologue.getAddressSize() == 0 ||
            Prologue.getAddressSize() == DebugLineData.getAddressSize());
 
   ParsingState State(this);
 
+  bool ReportAdvanceAddrProblem = true;
+
   while (*OffsetPtr < EndOffset) {
     if (OS)
       *OS << format("0x%08.08" PRIx64 ": ", *OffsetPtr);
 
+    uint64_t OpcodeOffset = *OffsetPtr;
     uint8_t Opcode = DebugLineData.getU8(OffsetPtr);
 
     if (OS)
       *OS << format("%02.02" PRIx8 " ", Opcode);
 
     if (Opcode == 0) {
       // Extended Opcodes always start with a zero opcode followed by
       // a uleb128 length so you can skip ones you don't know about
if (Opcode == 0) {
         State.appendRowToMatrix();
         break;
 
       case DW_LNS_advance_pc:
         // Takes a single unsigned LEB128 operand, multiplies it by the
         // min_inst_length field of the prologue, and adds the
         // result to the address register of the state machine.
         {
-          uint64_t AddrOffset =
-              advanceAddr(DebugLineData.getULEB128(OffsetPtr), Prologue);
+          uint64_t AddrOffset = advanceAddr(
+              DebugLineData.getULEB128(OffsetPtr), Prologue, OpcodeOffset,
+              "DW_LNS_advance_pc", DebugLineOffset, ReportAdvanceAddrProblem,
+              RecoverableErrorHandler);
           State.Row.Address.Address += AddrOffset;
           if (OS)
             *OS << " (" << AddrOffset << ")";
         }
         break;
 
       case DW_LNS_advance_line:
         // Takes a single signed LEB128 operand and adds that value to
if (Opcode == 0) {
         // DW_LNS_const_add_pc followed by a special opcode, for a total
         // of two bytes. Only if it needs to advance the address by more
         // than twice that range will it need to use both DW_LNS_advance_pc
         // and a special opcode, requiring three or more bytes.
         {
           AdvanceAddrProperties AdvanceAddr =
               getOperationAdvance(255, Prologue.OpcodeBase, Prologue.LineRange);
           uint64_t AddrOffset =
-              advanceAddr(AdvanceAddr.OperationAdvance, Prologue);
+              advanceAddr(AdvanceAddr.OperationAdvance, Prologue, OpcodeOffset,
+                          "DW_LNS_const_add_pc", DebugLineOffset,
+                          ReportAdvanceAddrProblem, RecoverableErrorHandler);
           State.Row.Address.Address += AddrOffset;
           if (OS)
             *OS << format(" (0x%16.16" PRIx64 ")", AddrOffset);
         }
         break;
 
       case DW_LNS_fixed_advance_pc:
         // Takes a single uhalf operand. Add to the address register of
if (Opcode == 0) {
       //
       // The amount to increment the line register is the line_base plus
       // the result of the adjusted opcode modulo the line_range. That is:
       //
       // line increment = line_base + (adjusted opcode % line_range)
 
       AdvanceAddrProperties AdvanceAddr =
           getOperationAdvance(Opcode, Prologue.OpcodeBase, Prologue.LineRange);
-      uint64_t AddrOffset = advanceAddr(AdvanceAddr.OperationAdvance, Prologue);
+      uint64_t AddrOffset = advanceAddr(
+          AdvanceAddr.OperationAdvance, Prologue, OpcodeOffset, "special",
+          DebugLineOffset, ReportAdvanceAddrProblem, RecoverableErrorHandler);
       int32_t LineOffset =
           Prologue.LineBase + (AdvanceAddr.AdjustedOpcode % Prologue.LineRange);
       State.Row.Line += LineOffset;
       State.Row.Address.Address += AddrOffset;
 
       if (OS) {
         *OS << "address += " << AddrOffset << ",  line += " << LineOffset
             << "\n";

llvm/unittests/DebugInfo/DWARF/DWARFDebugLineTest.cpp

 //===- DWARFDebugLineTest.cpp ---------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "DwarfGenerator.h"
 #include "DwarfUtils.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFDebugLine.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Testing/Support/Error.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
EXPECT_THAT_ERROR(std::move(Recoverable),
                     FailedWithMessage("last sequence in debug line table at "
                                       "offset 0x00000000 is not terminated"));
   ASSERT_THAT_EXPECTED(ExpectedLineTable, Succeeded());
   EXPECT_EQ((*ExpectedLineTable)->Rows.size(), 6u);
   // The unterminated sequence is not added to the sequence list.
   EXPECT_EQ((*ExpectedLineTable)->Sequences.size(), 1u);
 }
 
+struct AdjustAddressFixtureBase : public CommonFixture {
+  // Create and update the prologue as specified by the subclass, then return
+  // the length of the table.
+  virtual uint64_t editPrologue(LineTable &LT) = 0;
+
+  virtual uint64_t getAdjustedAddr(uint64_t Base, uint64_t ConstIncrs,
+                                   uint64_t SpecialIncrs,
+                                   uint64_t AdvanceIncrs) {
+    return Base + ConstIncrs + SpecialIncrs + AdvanceIncrs;
+  }
+
+  virtual uint64_t getAdjustedLine(uint64_t Base, uint64_t Incr) {
+    return Base + Incr;
+  }
+
+  uint64_t setupNoProblemTable() {
+    LineTable &NoProblem = Gen->addLineTable();
+    NoProblem.addExtendedOpcode(9, DW_LNE_set_address,
+                                {{0xabcd, LineTable::Quad}});
+    NoProblem.addExtendedOpcode(1, DW_LNE_end_sequence, {});
+    return editPrologue(NoProblem);
+  }
+
+  uint64_t setupConstAddPcFirstTable() {
+    LineTable &ConstAddPCFirst = Gen->addLineTable();
+    ConstAddPCFirst.addExtendedOpcode(9, DW_LNE_set_address,
+                                      {{ConstAddPCAddr, LineTable::Quad}});
+    ConstAddPCFirst.addStandardOpcode(DW_LNS_const_add_pc, {});
+    ConstAddPCFirst.addStandardOpcode(DW_LNS_const_add_pc, {});
+    ConstAddPCFirst.addStandardOpcode(DW_LNS_advance_pc,
+                                      {{0x10, LineTable::ULEB}});
+    ConstAddPCFirst.addByte(0x21); // Special opcode, +1 op, +1 line.
+    ConstAddPCFirst.addExtendedOpcode(1, DW_LNE_end_sequence, {});
+    return editPrologue(ConstAddPCFirst);
+  }
+
+  uint64_t setupSpecialFirstTable() {
+    LineTable &SpecialFirst = Gen->addLineTable();
+    SpecialFirst.addExtendedOpcode(9, DW_LNE_set_address,
+                                   {{SpecialAddr, LineTable::Quad}});
+    SpecialFirst.addByte(0x22); // Special opcode, +1 op, +2 line.
+    SpecialFirst.addStandardOpcode(DW_LNS_const_add_pc, {});
+    SpecialFirst.addStandardOpcode(DW_LNS_advance_pc,
+                                   {{0x20, LineTable::ULEB}});
+    SpecialFirst.addByte(0x23); // Special opcode, +1 op, +3 line.
+    SpecialFirst.addExtendedOpcode(1, DW_LNE_end_sequence, {});
+    return editPrologue(SpecialFirst);
+  }
+
+  uint64_t setupAdvancePcFirstTable() {
+    LineTable &AdvancePCFirst = Gen->addLineTable();
+    AdvancePCFirst.addExtendedOpcode(9, DW_LNE_set_address,
+                                     {{AdvancePCAddr, LineTable::Quad}});
+    AdvancePCFirst.addStandardOpcode(DW_LNS_advance_pc,
+                                     {{0x30, LineTable::ULEB}});
+    AdvancePCFirst.addStandardOpcode(DW_LNS_const_add_pc, {});
+    AdvancePCFirst.addStandardOpcode(DW_LNS_advance_pc,
+                                     {{0x40, LineTable::ULEB}});
+    AdvancePCFirst.addByte(0x24); // Special opcode, +1 op, +4 line.
+    AdvancePCFirst.addExtendedOpcode(1, DW_LNE_end_sequence, {});
+    return editPrologue(AdvancePCFirst);
+  }
+
+  void setupTables(bool AddAdvancePCFirstTable) {
+    LineTable &Padding = Gen->addLineTable();
+    Padding.setCustomPrologue({{0, LineTable::Byte}});
+    NoProblemOffset = 1;
+
+    // Show that no warning is generated for the case where no
+    // DW_LNS_const_add_pc or special opcode is used.
+    ConstAddPCOffset = setupNoProblemTable() + NoProblemOffset;
+
+    // Show that the warning is emitted for the first DW_LNS_const_add_pc opcode
+    // and then not again.
+    SpecialOffset = setupConstAddPcFirstTable() + ConstAddPCOffset;
+
+    // Show that the warning is emitted for the first special opcode and then
+    // not again.
+    AdvancePCOffset = setupSpecialFirstTable() + SpecialOffset;
+
+    // Show that the warning is emitted for the first DW_LNS_advance_pc opcode
+    // (if requested) and then not again.
+    if (AddAdvancePCFirstTable)
+      setupAdvancePcFirstTable();
+  }
+
+  Expected<const DWARFDebugLine::LineTable *>
+  checkTable(uint64_t Offset, StringRef OpcodeType, const Twine &MsgSuffix) {
+    auto ExpectedTable = Line.getOrParseLineTable(LineData, Offset, *Context,
+                                                  nullptr, RecordRecoverable);
+    EXPECT_THAT_ERROR(std::move(Unrecoverable), Succeeded());
+    if (!IsErrorExpected) {
+      EXPECT_THAT_ERROR(std::move(Recoverable), Succeeded());
+    } else {
+      if (!ExpectedTable)
+        return ExpectedTable;
+      uint64_t ExpectedOffset = Offset +
+                                (*ExpectedTable)->Prologue.getLength() +
+                                11; // 11 == size of DW_LNE_set_address.
+      std::string OffsetHex = Twine::utohexstr(Offset).str();
+      std::string OffsetZeroes = std::string(8 - OffsetHex.size(), '0');
+      std::string ExpectedHex = Twine::utohexstr(ExpectedOffset).str();
+      std::string ExpectedZeroes = std::string(8 - ExpectedHex.size(), '0');
+      EXPECT_THAT_ERROR(
+          std::move(Recoverable),
+          FailedWithMessage(("line table program at offset 0x" + OffsetZeroes +
+                             OffsetHex + " contains a " + OpcodeType +
+                             " opcode at offset 0x" + ExpectedZeroes +
+                             ExpectedHex + ", " + MsgSuffix)
+                                .str()));
+    }
+    return ExpectedTable;
+  }
+
+  void runTest(bool CheckAdvancePC, Twine MsgSuffix) {
+    if (!setupGenerator(Version))
+      return;
+
+    setupTables(/*AddAdvancePCFirstTable=*/CheckAdvancePC);
+
+    generate();
+
+    auto ExpectedNoProblem = Line.getOrParseLineTable(
+        LineData, NoProblemOffset, *Context, nullptr, RecordRecoverable);
+    EXPECT_THAT_ERROR(std::move(Recoverable), Succeeded());
+    EXPECT_THAT_ERROR(std::move(Unrecoverable), Succeeded());
+    ASSERT_THAT_EXPECTED(ExpectedNoProblem, Succeeded());
+
+    auto ExpectedConstAddPC =
+        checkTable(ConstAddPCOffset, "DW_LNS_const_add_pc", MsgSuffix);
+    ASSERT_THAT_EXPECTED(ExpectedConstAddPC, Succeeded());
+    ASSERT_EQ((*ExpectedConstAddPC)->Rows.size(), 2u);
+    EXPECT_EQ((*ExpectedConstAddPC)->Rows[0].Address.Address,
+              getAdjustedAddr(ConstAddPCAddr, ConstIncr * 2, 0x1, 0x10));
+    EXPECT_EQ((*ExpectedConstAddPC)->Rows[0].Line, getAdjustedLine(1, 1));
+    EXPECT_THAT_ERROR(std::move(Unrecoverable), Succeeded());
+
+    auto ExpectedSpecial = checkTable(SpecialOffset, "special", MsgSuffix);
+    ASSERT_THAT_EXPECTED(ExpectedSpecial, Succeeded());
+    ASSERT_EQ((*ExpectedSpecial)->Rows.size(), 3u);
+    EXPECT_EQ((*ExpectedSpecial)->Rows[0].Address.Address,
+              getAdjustedAddr(SpecialAddr, 0, 1, 0));
+    EXPECT_EQ((*ExpectedSpecial)->Rows[0].Line, getAdjustedLine(1, 2));
+    EXPECT_EQ((*ExpectedSpecial)->Rows[1].Address.Address,
+              getAdjustedAddr(SpecialAddr, ConstIncr, 2, 0x20));
+    EXPECT_EQ((*ExpectedSpecial)->Rows[1].Line, getAdjustedLine(1, 5));
+    EXPECT_THAT_ERROR(std::move(Unrecoverable), Succeeded());
+
+    if (!CheckAdvancePC)
+      return;
+
+    auto ExpectedAdvancePC =
+        checkTable(AdvancePCOffset, "DW_LNS_advance_pc", MsgSuffix);
+    ASSERT_THAT_EXPECTED(ExpectedAdvancePC, Succeeded());
+    ASSERT_EQ((*ExpectedAdvancePC)->Rows.size(), 2u);
+    EXPECT_EQ((*ExpectedAdvancePC)->Rows[0].Address.Address,
+              getAdjustedAddr(AdvancePCAddr, ConstIncr, 0x1, 0x70));
+    EXPECT_EQ((*ExpectedAdvancePC)->Rows[0].Line, getAdjustedLine(1, 4));
+  }
+
+  uint64_t ConstIncr = 0x11;
+  uint64_t ConstAddPCAddr = 0x1234;
+  uint64_t SpecialAddr = 0x5678;
+  uint64_t AdvancePCAddr = 0xabcd;
+  uint64_t NoProblemOffset;
+  uint64_t ConstAddPCOffset;
+  uint64_t SpecialOffset;
+  uint64_t AdvancePCOffset;
+
+  uint16_t Version = 4;
+  bool IsErrorExpected;
+};
+
+struct MaxOpsPerInstFixture
+    : public TestWithParam<std::tuple<uint16_t, uint8_t, bool>>,
+      public AdjustAddressFixtureBase {
+  void SetUp() {
+    std::tie(Version, MaxOpsPerInst, IsErrorExpected) = GetParam();
+  }
+
+  uint64_t editPrologue(LineTable &LT) override {
+    DWARFDebugLine::Prologue Prologue = LT.createBasicPrologue();
+    Prologue.MaxOpsPerInst = MaxOpsPerInst;
+    LT.setPrologue(Prologue);
+    return Prologue.TotalLength + Prologue.sizeofTotalLength();
+  }
+
+  uint8_t MaxOpsPerInst;
+};
+
+TEST_P(MaxOpsPerInstFixture, MaxOpsPerInstProblemsReportedCorrectly) {
+  runTest(/*CheckAdvancePC=*/true,
+          "but the prologue maximum_operations_per_instruction value is " +
+              Twine(unsigned(MaxOpsPerInst)) +
+              ", which is unsupported. Assuming a value of 1 instead");
+}
+
+INSTANTIATE_TEST_CASE_P(
+    MaxOpsPerInstParams, MaxOpsPerInstFixture,
+    Values(std::make_tuple(3, 0, false), // Test for version < 4 (no error).
+           std::make_tuple(4, 0, true),  // Test zero value for V4 (error).
+           std::make_tuple(4, 1, false), // Test good value for V4 (no error).
+           std::make_tuple(
+               4, 2, true)), ); // Test one higher than permitted V4 (error).
+
 TEST_F(DebugLineBasicFixture, ParserParsesCorrectly) {
   if (!setupGenerator())
     return;
 
   DWARFDebugLine::SectionParser Parser = setupParser();
 
   EXPECT_EQ(Parser.getOffset(), 0u);
   ASSERT_FALSE(Parser.done());