michael@0: // Copyright (c) 2012, Google Inc.
michael@0: // All rights reserved.
michael@0: //
michael@0: // Redistribution and use in source and binary forms, with or without
michael@0: // modification, are permitted provided that the following conditions are
michael@0: // met:
michael@0: //
michael@0: //     * Redistributions of source code must retain the above copyright
michael@0: // notice, this list of conditions and the following disclaimer.
michael@0: //     * Redistributions in binary form must reproduce the above
michael@0: // copyright notice, this list of conditions and the following disclaimer
michael@0: // in the documentation and/or other materials provided with the
michael@0: // distribution.
michael@0: //     * Neither the name of Google Inc. nor the names of its
michael@0: // contributors may be used to endorse or promote products derived from
michael@0: // this software without specific prior written permission.
michael@0: //
michael@0: // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
michael@0: // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
michael@0: // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
michael@0: // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
michael@0: // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
michael@0: // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
michael@0: // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
michael@0: // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
michael@0: // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
michael@0: // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
michael@0: // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
michael@0: 
michael@0: // Original author: Jim Blandy <jimb@mozilla.com> <jimb@red-bean.com>
michael@0: 
michael@0: // dwarf2reader_die_unittest.cc: Unit tests for dwarf2reader::CompilationUnit
michael@0: 
michael@0: #include <stdlib.h>
michael@0: 
michael@0: #include <iostream>
michael@0: #include <string>
michael@0: #include <vector>
michael@0: 
michael@0: #include "breakpad_googletest_includes.h"
michael@0: #include "common/dwarf/bytereader-inl.h"
michael@0: #include "common/dwarf/dwarf2reader_test_common.h"
michael@0: #include "common/dwarf/dwarf2reader.h"
michael@0: #include "common/using_std_string.h"
michael@0: #include "google_breakpad/common/breakpad_types.h"
michael@0: 
michael@0: using google_breakpad::test_assembler::Endianness;
michael@0: using google_breakpad::test_assembler::Label;
michael@0: using google_breakpad::test_assembler::Section;
michael@0: using google_breakpad::test_assembler::kBigEndian;
michael@0: using google_breakpad::test_assembler::kLittleEndian;
michael@0: 
michael@0: using dwarf2reader::ByteReader;
michael@0: using dwarf2reader::CompilationUnit;
michael@0: using dwarf2reader::Dwarf2Handler;
michael@0: using dwarf2reader::DwarfAttribute;
michael@0: using dwarf2reader::DwarfForm;
michael@0: using dwarf2reader::DwarfHasChild;
michael@0: using dwarf2reader::DwarfTag;
michael@0: using dwarf2reader::ENDIANNESS_BIG;
michael@0: using dwarf2reader::ENDIANNESS_LITTLE;
michael@0: using dwarf2reader::SectionMap;
michael@0: 
michael@0: using std::vector;
michael@0: using testing::InSequence;
michael@0: using testing::Pointee;
michael@0: using testing::Return;
michael@0: using testing::Sequence;
michael@0: using testing::Test;
michael@0: using testing::TestWithParam;
michael@0: using testing::_;
michael@0: 
michael@0: class MockDwarf2Handler: public Dwarf2Handler {
michael@0:  public:
michael@0:   MOCK_METHOD5(StartCompilationUnit, bool(uint64 offset, uint8 address_size,
michael@0:                                           uint8 offset_size, uint64 cu_length,
michael@0:                                           uint8 dwarf_version));
michael@0:   MOCK_METHOD2(StartDIE, bool(uint64 offset, enum DwarfTag tag));
michael@0:   MOCK_METHOD4(ProcessAttributeUnsigned, void(uint64 offset,
michael@0:                                               DwarfAttribute attr,
michael@0:                                               enum DwarfForm form,
michael@0:                                               uint64 data));
michael@0:   MOCK_METHOD4(ProcessAttributeSigned, void(uint64 offset,
michael@0:                                             enum DwarfAttribute attr,
michael@0:                                             enum DwarfForm form,
michael@0:                                             int64 data));
michael@0:   MOCK_METHOD4(ProcessAttributeReference, void(uint64 offset,
michael@0:                                                enum DwarfAttribute attr,
michael@0:                                                enum DwarfForm form,
michael@0:                                                uint64 data));
michael@0:   MOCK_METHOD5(ProcessAttributeBuffer, void(uint64 offset,
michael@0:                                             enum DwarfAttribute attr,
michael@0:                                             enum DwarfForm form,
michael@0:                                             const char* data,
michael@0:                                             uint64 len));
michael@0:   MOCK_METHOD4(ProcessAttributeString, void(uint64 offset,
michael@0:                                             enum DwarfAttribute attr,
michael@0:                                             enum DwarfForm form,
michael@0:                                             const string& data));
michael@0:   MOCK_METHOD4(ProcessAttributeSignature, void(uint64 offset,
michael@0:                                                DwarfAttribute attr,
michael@0:                                                enum DwarfForm form,
michael@0:                                                uint64 signature));
michael@0:   MOCK_METHOD1(EndDIE, void(uint64 offset));
michael@0: };
michael@0: 
michael@0: struct DIEFixture {
michael@0: 
michael@0:   DIEFixture() {
michael@0:     // Fix the initial offset of the .debug_info and .debug_abbrev sections.
michael@0:     info.start() = 0;
michael@0:     abbrevs.start() = 0;
michael@0: 
michael@0:     // Default expectations for the data handler.
michael@0:     EXPECT_CALL(handler, StartCompilationUnit(_, _, _, _, _)).Times(0);
michael@0:     EXPECT_CALL(handler, StartDIE(_, _)).Times(0);
michael@0:     EXPECT_CALL(handler, ProcessAttributeUnsigned(_, _, _, _)).Times(0);
michael@0:     EXPECT_CALL(handler, ProcessAttributeSigned(_, _, _, _)).Times(0);
michael@0:     EXPECT_CALL(handler, ProcessAttributeReference(_, _, _, _)).Times(0);
michael@0:     EXPECT_CALL(handler, ProcessAttributeBuffer(_, _, _, _, _)).Times(0);
michael@0:     EXPECT_CALL(handler, ProcessAttributeString(_, _, _, _)).Times(0);
michael@0:     EXPECT_CALL(handler, EndDIE(_)).Times(0);
michael@0:   }
michael@0: 
michael@0:   // Return a reference to a section map whose .debug_info section refers
michael@0:   // to |info|, and whose .debug_abbrev section refers to |abbrevs|. This
michael@0:   // function returns a reference to the same SectionMap each time; new
michael@0:   // calls wipe out maps established by earlier calls.
michael@0:   const SectionMap &MakeSectionMap() {
michael@0:     // Copy the sections' contents into strings that will live as long as
michael@0:     // the map itself.
michael@0:     assert(info.GetContents(&info_contents));
michael@0:     assert(abbrevs.GetContents(&abbrevs_contents));
michael@0:     section_map.clear();
michael@0:     section_map[".debug_info"].first  = info_contents.data();
michael@0:     section_map[".debug_info"].second = info_contents.size();
michael@0:     section_map[".debug_abbrev"].first  = abbrevs_contents.data();
michael@0:     section_map[".debug_abbrev"].second = abbrevs_contents.size();
michael@0:     return section_map;
michael@0:   }
michael@0: 
michael@0:   TestCompilationUnit info;
michael@0:   TestAbbrevTable abbrevs;
michael@0:   MockDwarf2Handler handler;
michael@0:   string abbrevs_contents, info_contents;
michael@0:   SectionMap section_map;
michael@0: };
michael@0: 
michael@0: struct DwarfHeaderParams {
michael@0:   DwarfHeaderParams(Endianness endianness, size_t format_size,
michael@0:                    int version, size_t address_size)
michael@0:       : endianness(endianness), format_size(format_size),
michael@0:         version(version), address_size(address_size) { }
michael@0:   Endianness endianness;
michael@0:   size_t format_size;                   // 4-byte or 8-byte DWARF offsets
michael@0:   int version;
michael@0:   size_t address_size;
michael@0: };
michael@0: 
michael@0: class DwarfHeader: public DIEFixture,
michael@0:                    public TestWithParam<DwarfHeaderParams> { };
michael@0: 
michael@0: TEST_P(DwarfHeader, Header) {
michael@0:   Label abbrev_table = abbrevs.Here();
michael@0:   abbrevs.Abbrev(1, dwarf2reader::DW_TAG_compile_unit,
michael@0:                  dwarf2reader::DW_children_yes)
michael@0:       .Attribute(dwarf2reader::DW_AT_name, dwarf2reader::DW_FORM_string)
michael@0:       .EndAbbrev()
michael@0:       .EndTable();
michael@0: 
michael@0:   info.set_format_size(GetParam().format_size);
michael@0:   info.set_endianness(GetParam().endianness);
michael@0: 
michael@0:   info.Header(GetParam().version, abbrev_table, GetParam().address_size)
michael@0:       .ULEB128(1)                     // DW_TAG_compile_unit, with children
michael@0:       .AppendCString("sam")           // DW_AT_name, DW_FORM_string
michael@0:       .D8(0);                         // end of children
michael@0:   info.Finish();
michael@0: 
michael@0:   {
michael@0:     InSequence s;
michael@0:     EXPECT_CALL(handler,
michael@0:                 StartCompilationUnit(0, GetParam().address_size,
michael@0:                                      GetParam().format_size, _,
michael@0:                                      GetParam().version))
michael@0:         .WillOnce(Return(true));
michael@0:     EXPECT_CALL(handler, StartDIE(_, dwarf2reader::DW_TAG_compile_unit))
michael@0:         .WillOnce(Return(true));
michael@0:     EXPECT_CALL(handler, ProcessAttributeString(_, dwarf2reader::DW_AT_name, 
michael@0:                                                 dwarf2reader::DW_FORM_string,
michael@0:                                                 "sam"))
michael@0:         .WillOnce(Return());
michael@0:     EXPECT_CALL(handler, EndDIE(_))
michael@0:         .WillOnce(Return());
michael@0:   }
michael@0: 
michael@0:   ByteReader byte_reader(GetParam().endianness == kLittleEndian ?
michael@0:                          ENDIANNESS_LITTLE : ENDIANNESS_BIG);
michael@0:   CompilationUnit parser(MakeSectionMap(), 0, &byte_reader, &handler);
michael@0:   EXPECT_EQ(parser.Start(), info_contents.size());
michael@0: }
michael@0: 
michael@0: INSTANTIATE_TEST_CASE_P(
michael@0:     HeaderVariants, DwarfHeader,
michael@0:     ::testing::Values(DwarfHeaderParams(kLittleEndian, 4, 2, 4),
michael@0:                       DwarfHeaderParams(kLittleEndian, 4, 2, 8),
michael@0:                       DwarfHeaderParams(kLittleEndian, 4, 3, 4),
michael@0:                       DwarfHeaderParams(kLittleEndian, 4, 3, 8),
michael@0:                       DwarfHeaderParams(kLittleEndian, 4, 4, 4),
michael@0:                       DwarfHeaderParams(kLittleEndian, 4, 4, 8),
michael@0:                       DwarfHeaderParams(kLittleEndian, 8, 2, 4),
michael@0:                       DwarfHeaderParams(kLittleEndian, 8, 2, 8),
michael@0:                       DwarfHeaderParams(kLittleEndian, 8, 3, 4),
michael@0:                       DwarfHeaderParams(kLittleEndian, 8, 3, 8),
michael@0:                       DwarfHeaderParams(kLittleEndian, 8, 4, 4),
michael@0:                       DwarfHeaderParams(kLittleEndian, 8, 4, 8),
michael@0:                       DwarfHeaderParams(kBigEndian,    4, 2, 4),
michael@0:                       DwarfHeaderParams(kBigEndian,    4, 2, 8),
michael@0:                       DwarfHeaderParams(kBigEndian,    4, 3, 4),
michael@0:                       DwarfHeaderParams(kBigEndian,    4, 3, 8),
michael@0:                       DwarfHeaderParams(kBigEndian,    4, 4, 4),
michael@0:                       DwarfHeaderParams(kBigEndian,    4, 4, 8),
michael@0:                       DwarfHeaderParams(kBigEndian,    8, 2, 4),
michael@0:                       DwarfHeaderParams(kBigEndian,    8, 2, 8),
michael@0:                       DwarfHeaderParams(kBigEndian,    8, 3, 4),
michael@0:                       DwarfHeaderParams(kBigEndian,    8, 3, 8),
michael@0:                       DwarfHeaderParams(kBigEndian,    8, 4, 4),
michael@0:                       DwarfHeaderParams(kBigEndian,    8, 4, 8)));
michael@0: 
michael@0: struct DwarfFormsFixture: public DIEFixture {
michael@0:   // Start a compilation unit, as directed by |params|, containing one
michael@0:   // childless DIE of the given tag, with one attribute of the given name
michael@0:   // and form. The 'info' fixture member is left just after the abbrev
michael@0:   // code, waiting for the attribute value to be appended.
michael@0:   void StartSingleAttributeDIE(const DwarfHeaderParams &params,
michael@0:                                DwarfTag tag, DwarfAttribute name,
michael@0:                                DwarfForm form) {
michael@0:     // Create the abbreviation table.
michael@0:     Label abbrev_table = abbrevs.Here();
michael@0:     abbrevs.Abbrev(1, tag, dwarf2reader::DW_children_no)
michael@0:         .Attribute(name, form)
michael@0:         .EndAbbrev()
michael@0:         .EndTable();
michael@0: 
michael@0:     // Create the compilation unit, up to the attribute value.
michael@0:     info.set_format_size(params.format_size);
michael@0:     info.set_endianness(params.endianness);
michael@0:     info.Header(params.version, abbrev_table, params.address_size)
michael@0:         .ULEB128(1);                    // abbrev code
michael@0:   }
michael@0: 
michael@0:   // Set up handler to expect a compilation unit matching |params|,
michael@0:   // containing one childless DIE of the given tag, in the sequence s. Stop
michael@0:   // just before the expectations.
michael@0:   void ExpectBeginCompilationUnit(const DwarfHeaderParams &params,
michael@0:                                   DwarfTag tag, uint64 offset=0) {
michael@0:     EXPECT_CALL(handler,
michael@0:                 StartCompilationUnit(offset, params.address_size,
michael@0:                                      params.format_size, _,
michael@0:                                      params.version))
michael@0:         .InSequence(s)
michael@0:         .WillOnce(Return(true));
michael@0:     EXPECT_CALL(handler, StartDIE(_, tag))
michael@0:         .InSequence(s)
michael@0:         .WillOnce(Return(true));
michael@0:   }
michael@0: 
michael@0:   void ExpectEndCompilationUnit() {
michael@0:     EXPECT_CALL(handler, EndDIE(_))
michael@0:         .InSequence(s)
michael@0:         .WillOnce(Return());
michael@0:   }
michael@0: 
michael@0:   void ParseCompilationUnit(const DwarfHeaderParams &params, uint64 offset=0) {
michael@0:     ByteReader byte_reader(params.endianness == kLittleEndian ?
michael@0:                            ENDIANNESS_LITTLE : ENDIANNESS_BIG);
michael@0:     CompilationUnit parser(MakeSectionMap(), offset, &byte_reader, &handler);
michael@0:     EXPECT_EQ(offset + parser.Start(), info_contents.size());
michael@0:   }
michael@0: 
michael@0:   // The sequence to which the fixture's methods append expectations.
michael@0:   Sequence s;
michael@0: };
michael@0: 
michael@0: struct DwarfForms: public DwarfFormsFixture,
michael@0:                    public TestWithParam<DwarfHeaderParams> { };
michael@0: 
michael@0: TEST_P(DwarfForms, addr) {
michael@0:   StartSingleAttributeDIE(GetParam(), dwarf2reader::DW_TAG_compile_unit,
michael@0:                           dwarf2reader::DW_AT_low_pc,
michael@0:                           dwarf2reader::DW_FORM_addr);
michael@0:   uint64_t value;
michael@0:   if (GetParam().address_size == 4) {
michael@0:     value = 0xc8e9ffcc;
michael@0:     info.D32(value);
michael@0:   } else {
michael@0:     value = 0xe942517fc2768564ULL;
michael@0:     info.D64(value);
michael@0:   }
michael@0:   info.Finish();
michael@0: 
michael@0:   ExpectBeginCompilationUnit(GetParam(), dwarf2reader::DW_TAG_compile_unit);
michael@0:   EXPECT_CALL(handler, ProcessAttributeUnsigned(_, dwarf2reader::DW_AT_low_pc, 
michael@0:                                                 dwarf2reader::DW_FORM_addr,
michael@0:                                                 value))
michael@0:       .InSequence(s)
michael@0:       .WillOnce(Return());
michael@0:   ExpectEndCompilationUnit();
michael@0: 
michael@0:   ParseCompilationUnit(GetParam());
michael@0: }
michael@0: 
michael@0: TEST_P(DwarfForms, block2_empty) {
michael@0:   StartSingleAttributeDIE(GetParam(), (DwarfTag) 0x16e4d2f7,
michael@0:                           (DwarfAttribute) 0xe52c4463,
michael@0:                           dwarf2reader::DW_FORM_block2);
michael@0:   info.D16(0);
michael@0:   info.Finish();
michael@0: 
michael@0:   ExpectBeginCompilationUnit(GetParam(), (DwarfTag) 0x16e4d2f7);
michael@0:   EXPECT_CALL(handler, ProcessAttributeBuffer(_, (DwarfAttribute) 0xe52c4463,
michael@0:                                               dwarf2reader::DW_FORM_block2,
michael@0:                                               _, 0))
michael@0:       .InSequence(s)
michael@0:       .WillOnce(Return());
michael@0:   ExpectEndCompilationUnit();
michael@0: 
michael@0:   ParseCompilationUnit(GetParam());
michael@0: }
michael@0: 
michael@0: TEST_P(DwarfForms, block2) {
michael@0:   StartSingleAttributeDIE(GetParam(), (DwarfTag) 0x16e4d2f7,
michael@0:                           (DwarfAttribute) 0xe52c4463,
michael@0:                           dwarf2reader::DW_FORM_block2);
michael@0:   unsigned char data[258];
michael@0:   memset(data, '*', sizeof(data));
michael@0:   info.D16(sizeof(data))
michael@0:       .Append(data, sizeof(data));
michael@0:   info.Finish();
michael@0: 
michael@0:   ExpectBeginCompilationUnit(GetParam(), (DwarfTag) 0x16e4d2f7);
michael@0:   EXPECT_CALL(handler, ProcessAttributeBuffer(_, (DwarfAttribute) 0xe52c4463,
michael@0:                                               dwarf2reader::DW_FORM_block2,
michael@0:                                               Pointee('*'), 258))
michael@0:       .InSequence(s)
michael@0:       .WillOnce(Return());
michael@0:   ExpectEndCompilationUnit();
michael@0: 
michael@0:   ParseCompilationUnit(GetParam());
michael@0: }
michael@0: 
michael@0: TEST_P(DwarfForms, flag_present) {
michael@0:   StartSingleAttributeDIE(GetParam(), (DwarfTag) 0x3e449ac2,
michael@0:                           (DwarfAttribute) 0x359d1972,
michael@0:                           dwarf2reader::DW_FORM_flag_present);
michael@0:   // DW_FORM_flag_present occupies no space in the DIE.
michael@0:   info.Finish();
michael@0: 
michael@0:   ExpectBeginCompilationUnit(GetParam(), (DwarfTag) 0x3e449ac2);
michael@0:   EXPECT_CALL(handler,
michael@0:               ProcessAttributeUnsigned(_, (DwarfAttribute) 0x359d1972,
michael@0:                                        dwarf2reader::DW_FORM_flag_present,
michael@0:                                        1))
michael@0:       .InSequence(s)
michael@0:       .WillOnce(Return());
michael@0:   ExpectEndCompilationUnit();
michael@0: 
michael@0:   ParseCompilationUnit(GetParam());
michael@0: }
michael@0: 
michael@0: TEST_P(DwarfForms, sec_offset) {
michael@0:   StartSingleAttributeDIE(GetParam(), (DwarfTag) 0x1d971689,
michael@0:                           (DwarfAttribute) 0xa060bfd1,
michael@0:                           dwarf2reader::DW_FORM_sec_offset);
michael@0:   uint64_t value;
michael@0:   if (GetParam().format_size == 4) {
michael@0:     value = 0xacc9c388;
michael@0:     info.D32(value);
michael@0:   } else {
michael@0:     value = 0xcffe5696ffe3ed0aULL;
michael@0:     info.D64(value);
michael@0:   }
michael@0:   info.Finish();
michael@0: 
michael@0:   ExpectBeginCompilationUnit(GetParam(), (DwarfTag) 0x1d971689);
michael@0:   EXPECT_CALL(handler, ProcessAttributeUnsigned(_, (DwarfAttribute) 0xa060bfd1,
michael@0:                                                 dwarf2reader::DW_FORM_sec_offset,
michael@0:                                                 value))
michael@0:       .InSequence(s)
michael@0:       .WillOnce(Return());
michael@0:   ExpectEndCompilationUnit();
michael@0: 
michael@0:   ParseCompilationUnit(GetParam());
michael@0: }
michael@0: 
michael@0: TEST_P(DwarfForms, exprloc) {
michael@0:   StartSingleAttributeDIE(GetParam(), (DwarfTag) 0xb6d167bb,
michael@0:                           (DwarfAttribute) 0xba3ae5cb,
michael@0:                           dwarf2reader::DW_FORM_exprloc);
michael@0:   info.ULEB128(29)
michael@0:       .Append(29, 173);
michael@0:   info.Finish();
michael@0: 
michael@0:   ExpectBeginCompilationUnit(GetParam(), (DwarfTag) 0xb6d167bb);
michael@0:   EXPECT_CALL(handler, ProcessAttributeBuffer(_, (DwarfAttribute) 0xba3ae5cb,
michael@0:                                               dwarf2reader::DW_FORM_exprloc,
michael@0:                                               Pointee(173), 29))
michael@0:       .InSequence(s)
michael@0:       .WillOnce(Return());
michael@0:   ExpectEndCompilationUnit();
michael@0: 
michael@0:   ParseCompilationUnit(GetParam());
michael@0: }
michael@0: 
michael@0: TEST_P(DwarfForms, ref_sig8) {
michael@0:   StartSingleAttributeDIE(GetParam(), (DwarfTag) 0x253e7b2b,
michael@0:                           (DwarfAttribute) 0xd708d908,
michael@0:                           dwarf2reader::DW_FORM_ref_sig8);
michael@0:   info.D64(0xf72fa0cb6ddcf9d6ULL);
michael@0:   info.Finish();
michael@0: 
michael@0:   ExpectBeginCompilationUnit(GetParam(), (DwarfTag) 0x253e7b2b);
michael@0:   EXPECT_CALL(handler, ProcessAttributeSignature(_, (DwarfAttribute) 0xd708d908,
michael@0:                                                  dwarf2reader::DW_FORM_ref_sig8,
michael@0:                                                  0xf72fa0cb6ddcf9d6ULL))
michael@0:       .InSequence(s)
michael@0:       .WillOnce(Return());
michael@0:   ExpectEndCompilationUnit();
michael@0: 
michael@0:   ParseCompilationUnit(GetParam());
michael@0: }
michael@0: 
michael@0: // A value passed to ProcessAttributeSignature is just an absolute number,
michael@0: // not an offset within the compilation unit as most of the other
michael@0: // DW_FORM_ref forms are. Check that the reader doesn't try to apply any
michael@0: // offset to the signature, by reading it from a compilation unit that does
michael@0: // not start at the beginning of the section.
michael@0: TEST_P(DwarfForms, ref_sig8_not_first) {
michael@0:   info.Append(98, '*');
michael@0:   StartSingleAttributeDIE(GetParam(), (DwarfTag) 0x253e7b2b,
michael@0:                           (DwarfAttribute) 0xd708d908,
michael@0:                           dwarf2reader::DW_FORM_ref_sig8);
michael@0:   info.D64(0xf72fa0cb6ddcf9d6ULL);
michael@0:   info.Finish();
michael@0: 
michael@0:   ExpectBeginCompilationUnit(GetParam(), (DwarfTag) 0x253e7b2b, 98);
michael@0:   EXPECT_CALL(handler, ProcessAttributeSignature(_, (DwarfAttribute) 0xd708d908,
michael@0:                                                  dwarf2reader::DW_FORM_ref_sig8,
michael@0:                                                  0xf72fa0cb6ddcf9d6ULL))
michael@0:       .InSequence(s)
michael@0:       .WillOnce(Return());
michael@0:   ExpectEndCompilationUnit();
michael@0: 
michael@0:   ParseCompilationUnit(GetParam(), 98);
michael@0: }
michael@0: 
michael@0: // Tests for the other attribute forms could go here.
michael@0: 
michael@0: INSTANTIATE_TEST_CASE_P(
michael@0:     HeaderVariants, DwarfForms,
michael@0:     ::testing::Values(DwarfHeaderParams(kLittleEndian, 4, 2, 4),
michael@0:                       DwarfHeaderParams(kLittleEndian, 4, 2, 8),
michael@0:                       DwarfHeaderParams(kLittleEndian, 4, 3, 4),
michael@0:                       DwarfHeaderParams(kLittleEndian, 4, 3, 8),
michael@0:                       DwarfHeaderParams(kLittleEndian, 4, 4, 4),
michael@0:                       DwarfHeaderParams(kLittleEndian, 4, 4, 8),
michael@0:                       DwarfHeaderParams(kLittleEndian, 8, 2, 4),
michael@0:                       DwarfHeaderParams(kLittleEndian, 8, 2, 8),
michael@0:                       DwarfHeaderParams(kLittleEndian, 8, 3, 4),
michael@0:                       DwarfHeaderParams(kLittleEndian, 8, 3, 8),
michael@0:                       DwarfHeaderParams(kLittleEndian, 8, 4, 4),
michael@0:                       DwarfHeaderParams(kLittleEndian, 8, 4, 8),
michael@0:                       DwarfHeaderParams(kBigEndian,    4, 2, 4),
michael@0:                       DwarfHeaderParams(kBigEndian,    4, 2, 8),
michael@0:                       DwarfHeaderParams(kBigEndian,    4, 3, 4),
michael@0:                       DwarfHeaderParams(kBigEndian,    4, 3, 8),
michael@0:                       DwarfHeaderParams(kBigEndian,    4, 4, 4),
michael@0:                       DwarfHeaderParams(kBigEndian,    4, 4, 8),
michael@0:                       DwarfHeaderParams(kBigEndian,    8, 2, 4),
michael@0:                       DwarfHeaderParams(kBigEndian,    8, 2, 8),
michael@0:                       DwarfHeaderParams(kBigEndian,    8, 3, 4),
michael@0:                       DwarfHeaderParams(kBigEndian,    8, 3, 8),
michael@0:                       DwarfHeaderParams(kBigEndian,    8, 4, 4),
michael@0:                       DwarfHeaderParams(kBigEndian,    8, 4, 8)));