// 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
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// 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>
// dwarf_cu_to_module.cc: Unit tests for google_breakpad::DwarfCUToModule.
#include <string>
#include <utility>
#include <vector>
#include "breakpad_googletest_includes.h"
#include "common/dwarf_cu_to_module.h"
#include "common/using_std_string.h"
using std::make_pair;
using std::vector;
using dwarf2reader::DIEHandler;
using dwarf2reader::DwarfTag;
using dwarf2reader::DwarfAttribute;
using dwarf2reader::DwarfForm;
using dwarf2reader::DwarfInline;
using dwarf2reader::RootDIEHandler;
using google_breakpad::DwarfCUToModule;
using google_breakpad::Module;
using ::testing::_;
using ::testing::AtMost;
using ::testing::Invoke;
using ::testing::Return;
using ::testing::Test;
using ::testing::TestWithParam;
using ::testing::Values;
using ::testing::ValuesIn;
// Mock classes.
class MockLineToModuleHandler: public DwarfCUToModule::LineToModuleHandler {
public:
MOCK_METHOD1(StartCompilationUnit, void(const string& compilation_dir));
MOCK_METHOD4(ReadProgram, void(const char* program, uint64 length,
Module *module, vector<Module::Line> *lines));
};
class MockWarningReporter: public DwarfCUToModule::WarningReporter {
public:
MockWarningReporter(const string &filename, uint64 cu_offset)
: DwarfCUToModule::WarningReporter(filename, cu_offset) { }
MOCK_METHOD1(SetCUName, void(const string &name));
MOCK_METHOD2(UnknownSpecification, void(uint64 offset, uint64 target));
MOCK_METHOD2(UnknownAbstractOrigin, void(uint64 offset, uint64 target));
MOCK_METHOD1(MissingSection, void(const string §ion_name));
MOCK_METHOD1(BadLineInfoOffset, void(uint64 offset));
MOCK_METHOD1(UncoveredFunction, void(const Module::Function &function));
MOCK_METHOD1(UncoveredLine, void(const Module::Line &line));
MOCK_METHOD1(UnnamedFunction, void(uint64 offset));
MOCK_METHOD2(DemangleError, void(const string &input, int error));
MOCK_METHOD2(UnhandledInterCUReference, void(uint64 offset, uint64 target));
};
// A fixture class including all the objects needed to handle a
// compilation unit, and their entourage. It includes member functions
// for doing common kinds of setup and tests.
class CUFixtureBase {
public:
// If we have:
//
// vector<Module::Line> lines;
// AppendLinesFunctor appender(lines);
//
// then doing:
//
// appender(line_program, length, module, line_vector);
//
// will append lines to the end of line_vector. We can use this with
// MockLineToModuleHandler like this:
//
// MockLineToModuleHandler l2m;
// EXPECT_CALL(l2m, ReadProgram(_,_,_,_))
// .WillOnce(DoAll(Invoke(appender), Return()));
//
// in which case calling l2m with some line vector will append lines.
class AppendLinesFunctor {
public:
explicit AppendLinesFunctor(
const vector<Module::Line> *lines) : lines_(lines) { }
void operator()(const char *program, uint64 length,
Module *module, vector<Module::Line> *lines) {
lines->insert(lines->end(), lines_->begin(), lines_->end());
}
private:
const vector<Module::Line> *lines_;
};
CUFixtureBase()
: module_("module-name", "module-os", "module-arch", "module-id"),
file_context_("dwarf-filename", &module_, true),
language_(dwarf2reader::DW_LANG_none),
language_signed_(false),
appender_(&lines_),
reporter_("dwarf-filename", 0xcf8f9bb6443d29b5LL),
root_handler_(&file_context_, &line_reader_, &reporter_),
functions_filled_(false) {
// By default, expect no warnings to be reported, and expect the
// compilation unit's name to be provided. The test can override
// these expectations.
EXPECT_CALL(reporter_, SetCUName("compilation-unit-name")).Times(1);
EXPECT_CALL(reporter_, UnknownSpecification(_, _)).Times(0);
EXPECT_CALL(reporter_, UnknownAbstractOrigin(_, _)).Times(0);
EXPECT_CALL(reporter_, MissingSection(_)).Times(0);
EXPECT_CALL(reporter_, BadLineInfoOffset(_)).Times(0);
EXPECT_CALL(reporter_, UncoveredFunction(_)).Times(0);
EXPECT_CALL(reporter_, UncoveredLine(_)).Times(0);
EXPECT_CALL(reporter_, UnnamedFunction(_)).Times(0);
EXPECT_CALL(reporter_, UnhandledInterCUReference(_, _)).Times(0);
// By default, expect the line program reader not to be invoked. We
// may override this in StartCU.
EXPECT_CALL(line_reader_, StartCompilationUnit(_)).Times(0);
EXPECT_CALL(line_reader_, ReadProgram(_,_,_,_)).Times(0);
// The handler will consult this section map to decide what to
// pass to our line reader.
file_context_.AddSectionToSectionMap(".debug_line",
dummy_line_program_,
dummy_line_size_);
}
// Add a line with the given address, size, filename, and line
// number to the end of the statement list the handler will receive
// when it invokes its LineToModuleHandler. Call this before calling
// StartCU.
void PushLine(Module::Address address, Module::Address size,
const string &filename, int line_number);
// Use LANGUAGE for the compilation unit. More precisely, arrange
// for StartCU to pass the compilation unit's root DIE a
// DW_AT_language attribute whose value is LANGUAGE.
void SetLanguage(dwarf2reader::DwarfLanguage language) {
language_ = language;
}
// If SIGNED true, have StartCU report DW_AT_language as a signed
// attribute; if false, have it report it as unsigned.
void SetLanguageSigned(bool is_signed) { language_signed_ = is_signed; }
// Call the handler this.root_handler_'s StartCompilationUnit and
// StartRootDIE member functions, passing it appropriate attributes as
// determined by prior calls to PushLine and SetLanguage. Leave
// this.root_handler_ ready to hear about children: call
// this.root_handler_.EndAttributes, but not this.root_handler_.Finish.
void StartCU();
// Have HANDLER process some strange attribute/form/value triples.
void ProcessStrangeAttributes(dwarf2reader::DIEHandler *handler);
// Start a child DIE of PARENT with the given tag and name. Leave
// the handler ready to hear about children: call EndAttributes, but
// not Finish.
DIEHandler *StartNamedDIE(DIEHandler *parent, DwarfTag tag,
const string &name);
// Start a child DIE of PARENT with the given tag and a
// DW_AT_specification attribute whose value is SPECIFICATION. Leave
// the handler ready to hear about children: call EndAttributes, but
// not Finish. If NAME is non-zero, use it as the DW_AT_name
// attribute.
DIEHandler *StartSpecifiedDIE(DIEHandler *parent, DwarfTag tag,
uint64 specification, const char *name = NULL);
// Define a function as a child of PARENT with the given name, address, and
// size. If high_pc_form is DW_FORM_addr then the DW_AT_high_pc attribute
// will be written as an address; otherwise it will be written as the
// function's size. Call EndAttributes and Finish; one cannot define
// children of the defined function's DIE.
void DefineFunction(DIEHandler *parent, const string &name,
Module::Address address, Module::Address size,
const char* mangled_name,
DwarfForm high_pc_form = dwarf2reader::DW_FORM_addr);
// Create a declaration DIE as a child of PARENT with the given
// offset, tag and name. If NAME is the empty string, don't provide
// a DW_AT_name attribute. Call EndAttributes and Finish.
void DeclarationDIE(DIEHandler *parent, uint64 offset,
DwarfTag tag, const string &name,
const string &mangled_name);
// Create a definition DIE as a child of PARENT with the given tag
// that refers to the declaration DIE at offset SPECIFICATION as its
// specification. If NAME is non-empty, pass it as the DW_AT_name
// attribute. If SIZE is non-zero, record ADDRESS and SIZE as
// low_pc/high_pc attributes.
void DefinitionDIE(DIEHandler *parent, DwarfTag tag,
uint64 specification, const string &name,
Module::Address address = 0, Module::Address size = 0);
// Create an inline DW_TAG_subprogram DIE as a child of PARENT. If
// SPECIFICATION is non-zero, then the DIE refers to the declaration DIE at
// offset SPECIFICATION as its specification. If Name is non-empty, pass it
// as the DW_AT_name attribute.
void AbstractInstanceDIE(DIEHandler *parent, uint64 offset,
DwarfInline type, uint64 specification,
const string &name,
DwarfForm form = dwarf2reader::DW_FORM_data1);
// Create a DW_TAG_subprogram DIE as a child of PARENT that refers to
// ORIGIN in its DW_AT_abstract_origin attribute. If NAME is the empty
// string, don't provide a DW_AT_name attribute.
void DefineInlineInstanceDIE(DIEHandler *parent, const string &name,
uint64 origin, Module::Address address,
Module::Address size);
// The following Test* functions should be called after calling
// this.root_handler_.Finish. After that point, no further calls
// should be made on the handler.
// Test that the number of functions defined in the module this.module_ is
// equal to EXPECTED.
void TestFunctionCount(size_t expected);
// Test that the I'th function (ordered by address) in the module
// this.module_ has the given name, address, and size, and that its
// parameter size is zero.
void TestFunction(int i, const string &name,
Module::Address address, Module::Address size);
// Test that the number of source lines owned by the I'th function
// in the module this.module_ is equal to EXPECTED.
void TestLineCount(int i, size_t expected);
// Test that the J'th line (ordered by address) of the I'th function
// (again, by address) has the given address, size, filename, and
// line number.
void TestLine(int i, int j, Module::Address address, Module::Address size,
const string &filename, int number);
// Actual objects under test.
Module module_;
DwarfCUToModule::FileContext file_context_;
// If this is not DW_LANG_none, we'll pass it as a DW_AT_language
// attribute to the compilation unit. This defaults to DW_LANG_none.
dwarf2reader::DwarfLanguage language_;
// If this is true, report DW_AT_language as a signed value; if false,
// report it as an unsigned value.
bool language_signed_;
// If this is not empty, we'll give the CU a DW_AT_comp_dir attribute that
// indicates the path that this compilation unit was compiled in.
string compilation_dir_;
// If this is not empty, we'll give the CU a DW_AT_stmt_list
// attribute that, when passed to line_reader_, adds these lines to the
// provided lines array.
vector<Module::Line> lines_;
// Mock line program reader.
MockLineToModuleHandler line_reader_;
AppendLinesFunctor appender_;
static const char dummy_line_program_[];
static const size_t dummy_line_size_;
MockWarningReporter reporter_;
DwarfCUToModule root_handler_;
private:
// Fill functions_, if we haven't already.
void FillFunctions();
// If functions_filled_ is true, this is a table of functions we've
// extracted from module_, sorted by address.
vector<Module::Function *> functions_;
// True if we have filled the above vector with this.module_'s function list.
bool functions_filled_;
};
const char CUFixtureBase::dummy_line_program_[] = "lots of fun data";
const size_t CUFixtureBase::dummy_line_size_ =
sizeof(CUFixtureBase::dummy_line_program_);
void CUFixtureBase::PushLine(Module::Address address, Module::Address size,
const string &filename, int line_number) {
Module::Line l;
l.address = address;
l.size = size;
l.file = module_.FindFile(filename);
l.number = line_number;
lines_.push_back(l);
}
void CUFixtureBase::StartCU() {
if (!compilation_dir_.empty())
EXPECT_CALL(line_reader_,
StartCompilationUnit(compilation_dir_)).Times(1);
// If we have lines, make the line reader expect to be invoked at
// most once. (Hey, if the handler can pass its tests without
// bothering to read the line number data, that's great.)
// Have it add the lines passed to PushLine. Otherwise, leave the
// initial expectation (no calls) in force.
if (!lines_.empty())
EXPECT_CALL(line_reader_,
ReadProgram(&dummy_line_program_[0], dummy_line_size_,
&module_, _))
.Times(AtMost(1))
.WillOnce(DoAll(Invoke(appender_), Return()));
ASSERT_TRUE(root_handler_
.StartCompilationUnit(0x51182ec307610b51ULL, 0x81, 0x44,
0x4241b4f33720dd5cULL, 3));
{
ASSERT_TRUE(root_handler_.StartRootDIE(0x02e56bfbda9e7337ULL,
dwarf2reader::DW_TAG_compile_unit));
}
root_handler_.ProcessAttributeString(dwarf2reader::DW_AT_name,
dwarf2reader::DW_FORM_strp,
"compilation-unit-name");
if (!compilation_dir_.empty())
root_handler_.ProcessAttributeString(dwarf2reader::DW_AT_comp_dir,
dwarf2reader::DW_FORM_strp,
compilation_dir_);
if (!lines_.empty())
root_handler_.ProcessAttributeUnsigned(dwarf2reader::DW_AT_stmt_list,
dwarf2reader::DW_FORM_ref4,
0);
if (language_ != dwarf2reader::DW_LANG_none) {
if (language_signed_)
root_handler_.ProcessAttributeSigned(dwarf2reader::DW_AT_language,
dwarf2reader::DW_FORM_sdata,
language_);
else
root_handler_.ProcessAttributeUnsigned(dwarf2reader::DW_AT_language,
dwarf2reader::DW_FORM_udata,
language_);
}
ASSERT_TRUE(root_handler_.EndAttributes());
}
void CUFixtureBase::ProcessStrangeAttributes(
dwarf2reader::DIEHandler *handler) {
handler->ProcessAttributeUnsigned((DwarfAttribute) 0xf560dead,
(DwarfForm) 0x4106e4db,
0xa592571997facda1ULL);
handler->ProcessAttributeSigned((DwarfAttribute) 0x85380095,
(DwarfForm) 0x0f16fe87,
0x12602a4e3bf1f446LL);
handler->ProcessAttributeReference((DwarfAttribute) 0xf7f7480f,
(DwarfForm) 0x829e038a,
0x50fddef44734fdecULL);
static const char buffer[10] = "frobynode";
handler->ProcessAttributeBuffer((DwarfAttribute) 0xa55ffb51,
(DwarfForm) 0x2f43b041,
buffer, sizeof(buffer));
handler->ProcessAttributeString((DwarfAttribute) 0x2f43b041,
(DwarfForm) 0x895ffa23,
"strange string");
}
DIEHandler *CUFixtureBase::StartNamedDIE(DIEHandler *parent,
DwarfTag tag,
const string &name) {
dwarf2reader::DIEHandler *handler
= parent->FindChildHandler(0x8f4c783c0467c989ULL, tag);
if (!handler)
return NULL;
handler->ProcessAttributeString(dwarf2reader::DW_AT_name,
dwarf2reader::DW_FORM_strp,
name);
ProcessStrangeAttributes(handler);
if (!handler->EndAttributes()) {
handler->Finish();
delete handler;
return NULL;
}
return handler;
}
DIEHandler *CUFixtureBase::StartSpecifiedDIE(DIEHandler *parent,
DwarfTag tag,
uint64 specification,
const char *name) {
dwarf2reader::DIEHandler *handler
= parent->FindChildHandler(0x8f4c783c0467c989ULL, tag);
if (!handler)
return NULL;
if (name)
handler->ProcessAttributeString(dwarf2reader::DW_AT_name,
dwarf2reader::DW_FORM_strp,
name);
handler->ProcessAttributeReference(dwarf2reader::DW_AT_specification,
dwarf2reader::DW_FORM_ref4,
specification);
if (!handler->EndAttributes()) {
handler->Finish();
delete handler;
return NULL;
}
return handler;
}
void CUFixtureBase::DefineFunction(dwarf2reader::DIEHandler *parent,
const string &name, Module::Address address,
Module::Address size,
const char* mangled_name,
DwarfForm high_pc_form) {
dwarf2reader::DIEHandler *func
= parent->FindChildHandler(0xe34797c7e68590a8LL,
dwarf2reader::DW_TAG_subprogram);
ASSERT_TRUE(func != NULL);
func->ProcessAttributeString(dwarf2reader::DW_AT_name,
dwarf2reader::DW_FORM_strp,
name);
func->ProcessAttributeUnsigned(dwarf2reader::DW_AT_low_pc,
dwarf2reader::DW_FORM_addr,
address);
Module::Address high_pc = size;
if (high_pc_form == dwarf2reader::DW_FORM_addr) {
high_pc += address;
}
func->ProcessAttributeUnsigned(dwarf2reader::DW_AT_high_pc,
high_pc_form,
high_pc);
if (mangled_name)
func->ProcessAttributeString(dwarf2reader::DW_AT_MIPS_linkage_name,
dwarf2reader::DW_FORM_strp,
mangled_name);
ProcessStrangeAttributes(func);
EXPECT_TRUE(func->EndAttributes());
func->Finish();
delete func;
}
void CUFixtureBase::DeclarationDIE(DIEHandler *parent, uint64 offset,
DwarfTag tag,
const string &name,
const string &mangled_name) {
dwarf2reader::DIEHandler *die = parent->FindChildHandler(offset, tag);
ASSERT_TRUE(die != NULL);
if (!name.empty())
die->ProcessAttributeString(dwarf2reader::DW_AT_name,
dwarf2reader::DW_FORM_strp,
name);
if (!mangled_name.empty())
die->ProcessAttributeString(dwarf2reader::DW_AT_MIPS_linkage_name,
dwarf2reader::DW_FORM_strp,
mangled_name);
die->ProcessAttributeUnsigned(dwarf2reader::DW_AT_declaration,
dwarf2reader::DW_FORM_flag,
1);
EXPECT_TRUE(die->EndAttributes());
die->Finish();
delete die;
}
void CUFixtureBase::DefinitionDIE(DIEHandler *parent,
DwarfTag tag,
uint64 specification,
const string &name,
Module::Address address,
Module::Address size) {
dwarf2reader::DIEHandler *die
= parent->FindChildHandler(0x6ccfea031a9e6cc9ULL, tag);
ASSERT_TRUE(die != NULL);
die->ProcessAttributeReference(dwarf2reader::DW_AT_specification,
dwarf2reader::DW_FORM_ref4,
specification);
if (!name.empty())
die->ProcessAttributeString(dwarf2reader::DW_AT_name,
dwarf2reader::DW_FORM_strp,
name);
if (size) {
die->ProcessAttributeUnsigned(dwarf2reader::DW_AT_low_pc,
dwarf2reader::DW_FORM_addr,
address);
die->ProcessAttributeUnsigned(dwarf2reader::DW_AT_high_pc,
dwarf2reader::DW_FORM_addr,
address + size);
}
EXPECT_TRUE(die->EndAttributes());
die->Finish();
delete die;
}
void CUFixtureBase::AbstractInstanceDIE(DIEHandler *parent,
uint64 offset,
DwarfInline type,
uint64 specification,
const string &name,
DwarfForm form) {
dwarf2reader::DIEHandler *die
= parent->FindChildHandler(offset, dwarf2reader::DW_TAG_subprogram);
ASSERT_TRUE(die != NULL);
if (specification != 0ULL)
die->ProcessAttributeReference(dwarf2reader::DW_AT_specification,
dwarf2reader::DW_FORM_ref4,
specification);
if (form == dwarf2reader::DW_FORM_sdata) {
die->ProcessAttributeSigned(dwarf2reader::DW_AT_inline, form, type);
} else {
die->ProcessAttributeUnsigned(dwarf2reader::DW_AT_inline, form, type);
}
if (!name.empty())
die->ProcessAttributeString(dwarf2reader::DW_AT_name,
dwarf2reader::DW_FORM_strp,
name);
EXPECT_TRUE(die->EndAttributes());
die->Finish();
delete die;
}
void CUFixtureBase::DefineInlineInstanceDIE(DIEHandler *parent,
const string &name,
uint64 origin,
Module::Address address,
Module::Address size) {
dwarf2reader::DIEHandler *func
= parent->FindChildHandler(0x11c70f94c6e87ccdLL,
dwarf2reader::DW_TAG_subprogram);
ASSERT_TRUE(func != NULL);
if (!name.empty()) {
func->ProcessAttributeString(dwarf2reader::DW_AT_name,
dwarf2reader::DW_FORM_strp,
name);
}
func->ProcessAttributeUnsigned(dwarf2reader::DW_AT_low_pc,
dwarf2reader::DW_FORM_addr,
address);
func->ProcessAttributeUnsigned(dwarf2reader::DW_AT_high_pc,
dwarf2reader::DW_FORM_addr,
address + size);
func->ProcessAttributeReference(dwarf2reader::DW_AT_abstract_origin,
dwarf2reader::DW_FORM_ref4,
origin);
ProcessStrangeAttributes(func);
EXPECT_TRUE(func->EndAttributes());
func->Finish();
delete func;
}
void CUFixtureBase::FillFunctions() {
if (functions_filled_)
return;
module_.GetFunctions(&functions_, functions_.end());
sort(functions_.begin(), functions_.end(),
Module::Function::CompareByAddress);
functions_filled_ = true;
}
void CUFixtureBase::TestFunctionCount(size_t expected) {
FillFunctions();
ASSERT_EQ(expected, functions_.size());
}
void CUFixtureBase::TestFunction(int i, const string &name,
Module::Address address,
Module::Address size) {
FillFunctions();
ASSERT_LT((size_t) i, functions_.size());
Module::Function *function = functions_[i];
EXPECT_EQ(name, function->name);
EXPECT_EQ(address, function->address);
EXPECT_EQ(size, function->size);
EXPECT_EQ(0U, function->parameter_size);
}
void CUFixtureBase::TestLineCount(int i, size_t expected) {
FillFunctions();
ASSERT_LT((size_t) i, functions_.size());
ASSERT_EQ(expected, functions_[i]->lines.size());
}
void CUFixtureBase::TestLine(int i, int j,
Module::Address address, Module::Address size,
const string &filename, int number) {
FillFunctions();
ASSERT_LT((size_t) i, functions_.size());
ASSERT_LT((size_t) j, functions_[i]->lines.size());
Module::Line *line = &functions_[i]->lines[j];
EXPECT_EQ(address, line->address);
EXPECT_EQ(size, line->size);
EXPECT_EQ(filename, line->file->name.c_str());
EXPECT_EQ(number, line->number);
}
// Include caller locations for our test subroutines.
#define TRACE(call) do { SCOPED_TRACE("called from here"); call; } while (0)
#define PushLine(a,b,c,d) TRACE(PushLine((a),(b),(c),(d)))
#define SetLanguage(a) TRACE(SetLanguage(a))
#define StartCU() TRACE(StartCU())
#define DefineFunction(a,b,c,d,e) TRACE(DefineFunction((a),(b),(c),(d),(e)))
// (DefineFunction) instead of DefineFunction to avoid macro expansion.
#define DefineFunction6(a,b,c,d,e,f) \
TRACE((DefineFunction)((a),(b),(c),(d),(e),(f)))
#define DeclarationDIE(a,b,c,d,e) TRACE(DeclarationDIE((a),(b),(c),(d),(e)))
#define DefinitionDIE(a,b,c,d,e,f) \
TRACE(DefinitionDIE((a),(b),(c),(d),(e),(f)))
#define TestFunctionCount(a) TRACE(TestFunctionCount(a))
#define TestFunction(a,b,c,d) TRACE(TestFunction((a),(b),(c),(d)))
#define TestLineCount(a,b) TRACE(TestLineCount((a),(b)))
#define TestLine(a,b,c,d,e,f) TRACE(TestLine((a),(b),(c),(d),(e),(f)))
class SimpleCU: public CUFixtureBase, public Test {
};
TEST_F(SimpleCU, CompilationDir) {
compilation_dir_ = "/src/build/";
StartCU();
root_handler_.Finish();
}
TEST_F(SimpleCU, OneFunc) {
PushLine(0x938cf8c07def4d34ULL, 0x55592d727f6cd01fLL, "line-file", 246571772);
StartCU();
DefineFunction(&root_handler_, "function1",
0x938cf8c07def4d34ULL, 0x55592d727f6cd01fLL, NULL);
root_handler_.Finish();
TestFunctionCount(1);
TestFunction(0, "function1", 0x938cf8c07def4d34ULL, 0x55592d727f6cd01fLL);
TestLineCount(0, 1);
TestLine(0, 0, 0x938cf8c07def4d34ULL, 0x55592d727f6cd01fLL, "line-file",
246571772);
}
// As above, only DW_AT_high_pc is a length rather than an address.
TEST_F(SimpleCU, OneFuncHighPcIsLength) {
PushLine(0x938cf8c07def4d34ULL, 0x55592d727f6cd01fLL, "line-file", 246571772);
StartCU();
DefineFunction6(&root_handler_, "function1",
0x938cf8c07def4d34ULL, 0x55592d727f6cd01fLL, NULL,
dwarf2reader::DW_FORM_udata);
root_handler_.Finish();
TestFunctionCount(1);
TestFunction(0, "function1", 0x938cf8c07def4d34ULL, 0x55592d727f6cd01fLL);
TestLineCount(0, 1);
TestLine(0, 0, 0x938cf8c07def4d34ULL, 0x55592d727f6cd01fLL, "line-file",
246571772);
}
TEST_F(SimpleCU, MangledName) {
PushLine(0x938cf8c07def4d34ULL, 0x55592d727f6cd01fLL, "line-file", 246571772);
StartCU();
DefineFunction(&root_handler_, "function1",
0x938cf8c07def4d34ULL, 0x55592d727f6cd01fLL, "_ZN1n1fEi");
root_handler_.Finish();
TestFunctionCount(1);
TestFunction(0, "n::f(int)", 0x938cf8c07def4d34ULL, 0x55592d727f6cd01fLL);
}
TEST_F(SimpleCU, IrrelevantRootChildren) {
StartCU();
EXPECT_FALSE(root_handler_
.FindChildHandler(0x7db32bff4e2dcfb1ULL,
dwarf2reader::DW_TAG_lexical_block));
}
TEST_F(SimpleCU, IrrelevantNamedScopeChildren) {
StartCU();
DIEHandler *class_A_handler
= StartNamedDIE(&root_handler_, dwarf2reader::DW_TAG_class_type, "class_A");
EXPECT_TRUE(class_A_handler != NULL);
EXPECT_FALSE(class_A_handler
->FindChildHandler(0x02e55999b865e4e9ULL,
dwarf2reader::DW_TAG_lexical_block));
delete class_A_handler;
}
// Verify that FileContexts can safely be deleted unused.
TEST_F(SimpleCU, UnusedFileContext) {
Module m("module-name", "module-os", "module-arch", "module-id");
DwarfCUToModule::FileContext fc("dwarf-filename", &m, true);
// Kludge: satisfy reporter_'s expectation.
reporter_.SetCUName("compilation-unit-name");
}
TEST_F(SimpleCU, InlineFunction) {
PushLine(0x1758a0f941b71efbULL, 0x1cf154f1f545e146ULL, "line-file", 75173118);
StartCU();
AbstractInstanceDIE(&root_handler_, 0x1e8dac5d507ed7abULL,
dwarf2reader::DW_INL_inlined, 0, "inline-name");
DefineInlineInstanceDIE(&root_handler_, "", 0x1e8dac5d507ed7abULL,
0x1758a0f941b71efbULL, 0x1cf154f1f545e146ULL);
root_handler_.Finish();
TestFunctionCount(1);
TestFunction(0, "inline-name",
0x1758a0f941b71efbULL, 0x1cf154f1f545e146ULL);
}
TEST_F(SimpleCU, InlineFunctionSignedAttribute) {
PushLine(0x1758a0f941b71efbULL, 0x1cf154f1f545e146ULL, "line-file", 75173118);
StartCU();
AbstractInstanceDIE(&root_handler_, 0x1e8dac5d507ed7abULL,
dwarf2reader::DW_INL_inlined, 0, "inline-name",
dwarf2reader::DW_FORM_sdata);
DefineInlineInstanceDIE(&root_handler_, "", 0x1e8dac5d507ed7abULL,
0x1758a0f941b71efbULL, 0x1cf154f1f545e146ULL);
root_handler_.Finish();
TestFunctionCount(1);
TestFunction(0, "inline-name",
0x1758a0f941b71efbULL, 0x1cf154f1f545e146ULL);
}
// Any DIE with an DW_AT_inline attribute can be cited by
// DW_AT_abstract_origin attributes --- even if the value of the
// DW_AT_inline attribute is DW_INL_not_inlined.
TEST_F(SimpleCU, AbstractOriginNotInlined) {
PushLine(0x2805c4531be6ca0eULL, 0x686b52155a8d4d2cULL, "line-file", 6111581);
StartCU();
AbstractInstanceDIE(&root_handler_, 0x93e9cdad52826b39ULL,
dwarf2reader::DW_INL_not_inlined, 0, "abstract-instance");
DefineInlineInstanceDIE(&root_handler_, "", 0x93e9cdad52826b39ULL,
0x2805c4531be6ca0eULL, 0x686b52155a8d4d2cULL);
root_handler_.Finish();
TestFunctionCount(1);
TestFunction(0, "abstract-instance",
0x2805c4531be6ca0eULL, 0x686b52155a8d4d2cULL);
}
TEST_F(SimpleCU, UnknownAbstractOrigin) {
EXPECT_CALL(reporter_, UnknownAbstractOrigin(_, 1ULL)).WillOnce(Return());
EXPECT_CALL(reporter_, UnnamedFunction(0x11c70f94c6e87ccdLL))
.WillOnce(Return());
PushLine(0x1758a0f941b71efbULL, 0x1cf154f1f545e146ULL, "line-file", 75173118);
StartCU();
AbstractInstanceDIE(&root_handler_, 0x1e8dac5d507ed7abULL,
dwarf2reader::DW_INL_inlined, 0, "inline-name");
DefineInlineInstanceDIE(&root_handler_, "", 1ULL,
0x1758a0f941b71efbULL, 0x1cf154f1f545e146ULL);
root_handler_.Finish();
TestFunctionCount(1);
TestFunction(0, "<name omitted>",
0x1758a0f941b71efbULL, 0x1cf154f1f545e146ULL);
}
TEST_F(SimpleCU, UnnamedFunction) {
EXPECT_CALL(reporter_, UnnamedFunction(0xe34797c7e68590a8LL))
.WillOnce(Return());
PushLine(0x72b80e41a0ac1d40ULL, 0x537174f231ee181cULL, "line-file", 14044850);
StartCU();
DefineFunction(&root_handler_, "",
0x72b80e41a0ac1d40ULL, 0x537174f231ee181cULL, NULL);
root_handler_.Finish();
TestFunctionCount(1);
TestFunction(0, "<name omitted>",
0x72b80e41a0ac1d40ULL, 0x537174f231ee181cULL);
}
// An address range.
struct Range {
Module::Address start, end;
};
// Test data for pairing functions and lines.
struct Situation {
// Two function intervals, and two line intervals.
Range functions[2], lines[2];
// The number of lines we expect to be assigned to each of the
// functions, and the address ranges.
int paired_count[2];
Range paired[2][2];
// The number of functions that are not entirely covered by lines,
// and vice versa.
int uncovered_functions, uncovered_lines;
};
#define PAIRING(func1_start, func1_end, func2_start, func2_end, \
line1_start, line1_end, line2_start, line2_end, \
func1_num_lines, func2_num_lines, \
func1_line1_start, func1_line1_end, \
func1_line2_start, func1_line2_end, \
func2_line1_start, func2_line1_end, \
func2_line2_start, func2_line2_end, \
uncovered_functions, uncovered_lines) \
{ { { func1_start, func1_end }, { func2_start, func2_end } }, \
{ { line1_start, line1_end }, { line2_start, line2_end } }, \
{ func1_num_lines, func2_num_lines }, \
{ { { func1_line1_start, func1_line1_end }, \
{ func1_line2_start, func1_line2_end } }, \
{ { func2_line1_start, func2_line1_end }, \
{ func2_line2_start, func2_line2_end } } }, \
uncovered_functions, uncovered_lines },
Situation situations[] = {
#include "common/testdata/func-line-pairing.h"
};
#undef PAIRING
class FuncLinePairing: public CUFixtureBase,
public TestWithParam<Situation> { };
INSTANTIATE_TEST_CASE_P(AllSituations, FuncLinePairing,
ValuesIn(situations));
TEST_P(FuncLinePairing, Pairing) {
const Situation &s = GetParam();
PushLine(s.lines[0].start,
s.lines[0].end - s.lines[0].start,
"line-file", 67636963);
PushLine(s.lines[1].start,
s.lines[1].end - s.lines[1].start,
"line-file", 67636963);
if (s.uncovered_functions)
EXPECT_CALL(reporter_, UncoveredFunction(_))
.Times(s.uncovered_functions)
.WillRepeatedly(Return());
if (s.uncovered_lines)
EXPECT_CALL(reporter_, UncoveredLine(_))
.Times(s.uncovered_lines)
.WillRepeatedly(Return());
StartCU();
DefineFunction(&root_handler_, "function1",
s.functions[0].start,
s.functions[0].end - s.functions[0].start, NULL);
DefineFunction(&root_handler_, "function2",
s.functions[1].start,
s.functions[1].end - s.functions[1].start, NULL);
root_handler_.Finish();
TestFunctionCount(2);
TestFunction(0, "function1",
s.functions[0].start,
s.functions[0].end - s.functions[0].start);
TestLineCount(0, s.paired_count[0]);
for (int i = 0; i < s.paired_count[0]; i++)
TestLine(0, i, s.paired[0][i].start,
s.paired[0][i].end - s.paired[0][i].start,
"line-file", 67636963);
TestFunction(1, "function2",
s.functions[1].start,
s.functions[1].end - s.functions[1].start);
TestLineCount(1, s.paired_count[1]);
for (int i = 0; i < s.paired_count[1]; i++)
TestLine(1, i, s.paired[1][i].start,
s.paired[1][i].end - s.paired[1][i].start,
"line-file", 67636963);
}
TEST_F(FuncLinePairing, EmptyCU) {
StartCU();
root_handler_.Finish();
TestFunctionCount(0);
}
TEST_F(FuncLinePairing, LinesNoFuncs) {
PushLine(40, 2, "line-file", 82485646);
EXPECT_CALL(reporter_, UncoveredLine(_)).WillOnce(Return());
StartCU();
root_handler_.Finish();
TestFunctionCount(0);
}
TEST_F(FuncLinePairing, FuncsNoLines) {
EXPECT_CALL(reporter_, UncoveredFunction(_)).WillOnce(Return());
StartCU();
DefineFunction(&root_handler_, "function1", 0x127da12ffcf5c51fULL, 0x1000U,
NULL);
root_handler_.Finish();
TestFunctionCount(1);
TestFunction(0, "function1", 0x127da12ffcf5c51fULL, 0x1000U);
}
TEST_F(FuncLinePairing, GapThenFunction) {
PushLine(20, 2, "line-file-2", 174314698);
PushLine(10, 2, "line-file-1", 263008005);
StartCU();
DefineFunction(&root_handler_, "function1", 10, 2, NULL);
DefineFunction(&root_handler_, "function2", 20, 2, NULL);
root_handler_.Finish();
TestFunctionCount(2);
TestFunction(0, "function1", 10, 2);
TestLineCount(0, 1);
TestLine(0, 0, 10, 2, "line-file-1", 263008005);
TestFunction(1, "function2", 20, 2);
TestLineCount(1, 1);
TestLine(1, 0, 20, 2, "line-file-2", 174314698);
}
// If GCC emits padding after one function to align the start of
// the next, then it will attribute the padding instructions to
// the last source line of function (to reduce the size of the
// line number info), but omit it from the DW_AT_{low,high}_pc
// range given in .debug_info (since it costs nothing to be
// precise there). If we did use at least some of the line
// we're about to skip, then assume this is what happened, and
// don't warn.
TEST_F(FuncLinePairing, GCCAlignmentStretch) {
PushLine(10, 10, "line-file", 63351048);
PushLine(20, 10, "line-file", 61661044);
StartCU();
DefineFunction(&root_handler_, "function1", 10, 5, NULL);
// five-byte gap between functions, covered by line 63351048.
// This should not elicit a warning.
DefineFunction(&root_handler_, "function2", 20, 10, NULL);
root_handler_.Finish();
TestFunctionCount(2);
TestFunction(0, "function1", 10, 5);
TestLineCount(0, 1);
TestLine(0, 0, 10, 5, "line-file", 63351048);
TestFunction(1, "function2", 20, 10);
TestLineCount(1, 1);
TestLine(1, 0, 20, 10, "line-file", 61661044);
}
// Unfortunately, neither the DWARF parser's handler interface nor the
// DIEHandler interface is capable of expressing a function that abuts
// the end of the address space: the high_pc value looks like zero.
TEST_F(FuncLinePairing, LineAtEndOfAddressSpace) {
PushLine(0xfffffffffffffff0ULL, 16, "line-file", 63351048);
EXPECT_CALL(reporter_, UncoveredLine(_)).WillOnce(Return());
StartCU();
DefineFunction(&root_handler_, "function1", 0xfffffffffffffff0ULL, 6, NULL);
DefineFunction(&root_handler_, "function2", 0xfffffffffffffffaULL, 5, NULL);
root_handler_.Finish();
TestFunctionCount(2);
TestFunction(0, "function1", 0xfffffffffffffff0ULL, 6);
TestLineCount(0, 1);
TestLine(0, 0, 0xfffffffffffffff0ULL, 6, "line-file", 63351048);
TestFunction(1, "function2", 0xfffffffffffffffaULL, 5);
TestLineCount(1, 1);
TestLine(1, 0, 0xfffffffffffffffaULL, 5, "line-file", 63351048);
}
// A function with more than one uncovered area should only be warned
// about once.
TEST_F(FuncLinePairing, WarnOnceFunc) {
PushLine(20, 1, "line-file-2", 262951329);
PushLine(11, 1, "line-file-1", 219964021);
EXPECT_CALL(reporter_, UncoveredFunction(_)).WillOnce(Return());
StartCU();
DefineFunction(&root_handler_, "function", 10, 11, NULL);
root_handler_.Finish();
TestFunctionCount(1);
TestFunction(0, "function", 10, 11);
TestLineCount(0, 2);
TestLine(0, 0, 11, 1, "line-file-1", 219964021);
TestLine(0, 1, 20, 1, "line-file-2", 262951329);
}
// A line with more than one uncovered area should only be warned
// about once.
TEST_F(FuncLinePairing, WarnOnceLine) {
PushLine(10, 20, "filename1", 118581871);
EXPECT_CALL(reporter_, UncoveredLine(_)).WillOnce(Return());
StartCU();
DefineFunction(&root_handler_, "function1", 11, 1, NULL);
DefineFunction(&root_handler_, "function2", 13, 1, NULL);
root_handler_.Finish();
TestFunctionCount(2);
TestFunction(0, "function1", 11, 1);
TestLineCount(0, 1);
TestLine(0, 0, 11, 1, "filename1", 118581871);
TestFunction(1, "function2", 13, 1);
TestLineCount(1, 1);
TestLine(1, 0, 13, 1, "filename1", 118581871);
}
class CXXQualifiedNames: public CUFixtureBase,
public TestWithParam<DwarfTag> { };
INSTANTIATE_TEST_CASE_P(VersusEnclosures, CXXQualifiedNames,
Values(dwarf2reader::DW_TAG_class_type,
dwarf2reader::DW_TAG_structure_type,
dwarf2reader::DW_TAG_union_type,
dwarf2reader::DW_TAG_namespace));
TEST_P(CXXQualifiedNames, TwoFunctions) {
DwarfTag tag = GetParam();
SetLanguage(dwarf2reader::DW_LANG_C_plus_plus);
PushLine(10, 1, "filename1", 69819327);
PushLine(20, 1, "filename2", 95115701);
StartCU();
DIEHandler *enclosure_handler = StartNamedDIE(&root_handler_, tag,
"Enclosure");
EXPECT_TRUE(enclosure_handler != NULL);
DefineFunction(enclosure_handler, "func_B", 10, 1, NULL);
DefineFunction(enclosure_handler, "func_C", 20, 1, NULL);
enclosure_handler->Finish();
delete enclosure_handler;
root_handler_.Finish();
TestFunctionCount(2);
TestFunction(0, "Enclosure::func_B", 10, 1);
TestFunction(1, "Enclosure::func_C", 20, 1);
}
TEST_P(CXXQualifiedNames, FuncInEnclosureInNamespace) {
DwarfTag tag = GetParam();
SetLanguage(dwarf2reader::DW_LANG_C_plus_plus);
PushLine(10, 1, "line-file", 69819327);
StartCU();
DIEHandler *namespace_handler
= StartNamedDIE(&root_handler_, dwarf2reader::DW_TAG_namespace,
"Namespace");
EXPECT_TRUE(namespace_handler != NULL);
DIEHandler *enclosure_handler = StartNamedDIE(namespace_handler, tag,
"Enclosure");
EXPECT_TRUE(enclosure_handler != NULL);
DefineFunction(enclosure_handler, "function", 10, 1, NULL);
enclosure_handler->Finish();
delete enclosure_handler;
namespace_handler->Finish();
delete namespace_handler;
root_handler_.Finish();
TestFunctionCount(1);
TestFunction(0, "Namespace::Enclosure::function", 10, 1);
}
TEST_F(CXXQualifiedNames, FunctionInClassInStructInNamespace) {
SetLanguage(dwarf2reader::DW_LANG_C_plus_plus);
PushLine(10, 1, "filename1", 69819327);
StartCU();
DIEHandler *namespace_handler
= StartNamedDIE(&root_handler_, dwarf2reader::DW_TAG_namespace,
"namespace_A");
EXPECT_TRUE(namespace_handler != NULL);
DIEHandler *struct_handler
= StartNamedDIE(namespace_handler, dwarf2reader::DW_TAG_structure_type,
"struct_B");
EXPECT_TRUE(struct_handler != NULL);
DIEHandler *class_handler
= StartNamedDIE(struct_handler, dwarf2reader::DW_TAG_class_type,
"class_C");
DefineFunction(class_handler, "function_D", 10, 1, NULL);
class_handler->Finish();
delete class_handler;
struct_handler->Finish();
delete struct_handler;
namespace_handler->Finish();
delete namespace_handler;
root_handler_.Finish();
TestFunctionCount(1);
TestFunction(0, "namespace_A::struct_B::class_C::function_D", 10, 1);
}
struct LanguageAndQualifiedName {
dwarf2reader::DwarfLanguage language;
const char *name;
};
const LanguageAndQualifiedName LanguageAndQualifiedNameCases[] = {
{ dwarf2reader::DW_LANG_none, "class_A::function_B" },
{ dwarf2reader::DW_LANG_C, "class_A::function_B" },
{ dwarf2reader::DW_LANG_C89, "class_A::function_B" },
{ dwarf2reader::DW_LANG_C99, "class_A::function_B" },
{ dwarf2reader::DW_LANG_C_plus_plus, "class_A::function_B" },
{ dwarf2reader::DW_LANG_Java, "class_A.function_B" },
{ dwarf2reader::DW_LANG_Cobol74, "class_A::function_B" },
{ dwarf2reader::DW_LANG_Mips_Assembler, NULL }
};
class QualifiedForLanguage
: public CUFixtureBase,
public TestWithParam<LanguageAndQualifiedName> { };
INSTANTIATE_TEST_CASE_P(LanguageAndQualifiedName, QualifiedForLanguage,
ValuesIn(LanguageAndQualifiedNameCases));
TEST_P(QualifiedForLanguage, MemberFunction) {
const LanguageAndQualifiedName ¶m = GetParam();
PushLine(10, 1, "line-file", 212966758);
SetLanguage(param.language);
StartCU();
DIEHandler *class_handler
= StartNamedDIE(&root_handler_, dwarf2reader::DW_TAG_class_type,
"class_A");
DefineFunction(class_handler, "function_B", 10, 1, NULL);
class_handler->Finish();
delete class_handler;
root_handler_.Finish();
if (param.name) {
TestFunctionCount(1);
TestFunction(0, param.name, 10, 1);
} else {
TestFunctionCount(0);
}
}
TEST_P(QualifiedForLanguage, MemberFunctionSignedLanguage) {
const LanguageAndQualifiedName ¶m = GetParam();
PushLine(10, 1, "line-file", 212966758);
SetLanguage(param.language);
SetLanguageSigned(true);
StartCU();
DIEHandler *class_handler
= StartNamedDIE(&root_handler_, dwarf2reader::DW_TAG_class_type,
"class_A");
DefineFunction(class_handler, "function_B", 10, 1, NULL);
class_handler->Finish();
delete class_handler;
root_handler_.Finish();
if (param.name) {
TestFunctionCount(1);
TestFunction(0, param.name, 10, 1);
} else {
TestFunctionCount(0);
}
}
class Specifications: public CUFixtureBase, public Test { };
TEST_F(Specifications, Function) {
PushLine(0x93cd3dfc1aa10097ULL, 0x0397d47a0b4ca0d4ULL, "line-file", 54883661);
StartCU();
DeclarationDIE(&root_handler_, 0xcd3c51b946fb1eeeLL,
dwarf2reader::DW_TAG_subprogram, "declaration-name", "");
DefinitionDIE(&root_handler_, dwarf2reader::DW_TAG_subprogram,
0xcd3c51b946fb1eeeLL, "",
0x93cd3dfc1aa10097ULL, 0x0397d47a0b4ca0d4ULL);
root_handler_.Finish();
TestFunctionCount(1);
TestFunction(0, "declaration-name",
0x93cd3dfc1aa10097ULL, 0x0397d47a0b4ca0d4ULL);
}
TEST_F(Specifications, MangledName) {
PushLine(0x93cd3dfc1aa10097ULL, 0x0397d47a0b4ca0d4ULL, "line-file", 54883661);
StartCU();
DeclarationDIE(&root_handler_, 0xcd3c51b946fb1eeeLL,
dwarf2reader::DW_TAG_subprogram, "declaration-name",
"_ZN1C1fEi");
DefinitionDIE(&root_handler_, dwarf2reader::DW_TAG_subprogram,
0xcd3c51b946fb1eeeLL, "",
0x93cd3dfc1aa10097ULL, 0x0397d47a0b4ca0d4ULL);
root_handler_.Finish();
TestFunctionCount(1);
TestFunction(0, "C::f(int)",
0x93cd3dfc1aa10097ULL, 0x0397d47a0b4ca0d4ULL);
}
TEST_F(Specifications, MemberFunction) {
PushLine(0x3341a248634e7170ULL, 0x5f6938ee5553b953ULL, "line-file", 18116691);
StartCU();
DIEHandler *class_handler
= StartNamedDIE(&root_handler_, dwarf2reader::DW_TAG_class_type, "class_A");
DeclarationDIE(class_handler, 0x7d83028c431406e8ULL,
dwarf2reader::DW_TAG_subprogram, "declaration-name", "");
class_handler->Finish();
delete class_handler;
DefinitionDIE(&root_handler_, dwarf2reader::DW_TAG_subprogram,
0x7d83028c431406e8ULL, "",
0x3341a248634e7170ULL, 0x5f6938ee5553b953ULL);
root_handler_.Finish();
TestFunctionCount(1);
TestFunction(0, "class_A::declaration-name",
0x3341a248634e7170ULL, 0x5f6938ee5553b953ULL);
}
// This case should gather the name from both the definition and the
// declaration's parent.
TEST_F(Specifications, FunctionDeclarationParent) {
PushLine(0x463c9ddf405be227ULL, 0x6a47774af5049680ULL, "line-file", 70254922);
StartCU();
{
DIEHandler *class_handler
= StartNamedDIE(&root_handler_, dwarf2reader::DW_TAG_class_type,
"class_A");
ASSERT_TRUE(class_handler != NULL);
DeclarationDIE(class_handler, 0x0e0e877c8404544aULL,
dwarf2reader::DW_TAG_subprogram, "declaration-name", "");
class_handler->Finish();
delete class_handler;
}
DefinitionDIE(&root_handler_, dwarf2reader::DW_TAG_subprogram,
0x0e0e877c8404544aULL, "definition-name",
0x463c9ddf405be227ULL, 0x6a47774af5049680ULL);
root_handler_.Finish();
TestFunctionCount(1);
TestFunction(0, "class_A::definition-name",
0x463c9ddf405be227ULL, 0x6a47774af5049680ULL);
}
// Named scopes should also gather enclosing name components from
// their declarations.
TEST_F(Specifications, NamedScopeDeclarationParent) {
PushLine(0x5d13433d0df13d00ULL, 0x48ebebe5ade2cab4ULL, "line-file", 77392604);
StartCU();
{
DIEHandler *space_handler
= StartNamedDIE(&root_handler_, dwarf2reader::DW_TAG_namespace,
"space_A");
ASSERT_TRUE(space_handler != NULL);
DeclarationDIE(space_handler, 0x419bb1d12f9a73a2ULL,
dwarf2reader::DW_TAG_class_type, "class-declaration-name",
"");
space_handler->Finish();
delete space_handler;
}
{
DIEHandler *class_handler
= StartSpecifiedDIE(&root_handler_, dwarf2reader::DW_TAG_class_type,
0x419bb1d12f9a73a2ULL, "class-definition-name");
ASSERT_TRUE(class_handler != NULL);
DefineFunction(class_handler, "function",
0x5d13433d0df13d00ULL, 0x48ebebe5ade2cab4ULL, NULL);
class_handler->Finish();
delete class_handler;
}
root_handler_.Finish();
TestFunctionCount(1);
TestFunction(0, "space_A::class-definition-name::function",
0x5d13433d0df13d00ULL, 0x48ebebe5ade2cab4ULL);
}
// This test recreates bug 364.
TEST_F(Specifications, InlineFunction) {
PushLine(0x1758a0f941b71efbULL, 0x1cf154f1f545e146ULL, "line-file", 75173118);
StartCU();
DeclarationDIE(&root_handler_, 0xcd3c51b946fb1eeeLL,
dwarf2reader::DW_TAG_subprogram, "inline-name", "");
AbstractInstanceDIE(&root_handler_, 0x1e8dac5d507ed7abULL,
dwarf2reader::DW_INL_inlined, 0xcd3c51b946fb1eeeLL, "");
DefineInlineInstanceDIE(&root_handler_, "", 0x1e8dac5d507ed7abULL,
0x1758a0f941b71efbULL, 0x1cf154f1f545e146ULL);
root_handler_.Finish();
TestFunctionCount(1);
TestFunction(0, "inline-name",
0x1758a0f941b71efbULL, 0x1cf154f1f545e146ULL);
}
// Check name construction for a long chain containing each combination of:
// - struct, union, class, namespace
// - direct and definition
TEST_F(Specifications, LongChain) {
PushLine(0x5a0dd6bb85db754cULL, 0x3bccb213d08c7fd3ULL, "line-file", 21192926);
SetLanguage(dwarf2reader::DW_LANG_C_plus_plus);
StartCU();
// The structure we're building here is:
// space_A full definition
// space_B declaration
// space_B definition
// struct_C full definition
// struct_D declaration
// struct_D definition
// union_E full definition
// union_F declaration
// union_F definition
// class_G full definition
// class_H declaration
// class_H definition
// func_I declaration
// func_I definition
//
// So:
// - space_A, struct_C, union_E, and class_G don't use specifications;
// - space_B, struct_D, union_F, and class_H do.
// - func_I uses a specification.
//
// The full name for func_I is thus:
//
// space_A::space_B::struct_C::struct_D::union_E::union_F::
// class_G::class_H::func_I
{
DIEHandler *space_A_handler
= StartNamedDIE(&root_handler_, dwarf2reader::DW_TAG_namespace,
"space_A");
DeclarationDIE(space_A_handler, 0x2e111126496596e2ULL,
dwarf2reader::DW_TAG_namespace, "space_B", "");
space_A_handler->Finish();
delete space_A_handler;
}
{
DIEHandler *space_B_handler
= StartSpecifiedDIE(&root_handler_, dwarf2reader::DW_TAG_namespace,
0x2e111126496596e2ULL);
DIEHandler *struct_C_handler
= StartNamedDIE(space_B_handler, dwarf2reader::DW_TAG_structure_type,
"struct_C");
DeclarationDIE(struct_C_handler, 0x20cd423bf2a25a4cULL,
dwarf2reader::DW_TAG_structure_type, "struct_D", "");
struct_C_handler->Finish();
delete struct_C_handler;
space_B_handler->Finish();
delete space_B_handler;
}
{
DIEHandler *struct_D_handler
= StartSpecifiedDIE(&root_handler_, dwarf2reader::DW_TAG_structure_type,
0x20cd423bf2a25a4cULL);
DIEHandler *union_E_handler
= StartNamedDIE(struct_D_handler, dwarf2reader::DW_TAG_union_type,
"union_E");
DeclarationDIE(union_E_handler, 0xe25c84805aa58c32ULL,
dwarf2reader::DW_TAG_union_type, "union_F", "");
union_E_handler->Finish();
delete union_E_handler;
struct_D_handler->Finish();
delete struct_D_handler;
}
{
DIEHandler *union_F_handler
= StartSpecifiedDIE(&root_handler_, dwarf2reader::DW_TAG_union_type,
0xe25c84805aa58c32ULL);
DIEHandler *class_G_handler
= StartNamedDIE(union_F_handler, dwarf2reader::DW_TAG_class_type,
"class_G");
DeclarationDIE(class_G_handler, 0xb70d960dcc173b6eULL,
dwarf2reader::DW_TAG_class_type, "class_H", "");
class_G_handler->Finish();
delete class_G_handler;
union_F_handler->Finish();
delete union_F_handler;
}
{
DIEHandler *class_H_handler
= StartSpecifiedDIE(&root_handler_, dwarf2reader::DW_TAG_class_type,
0xb70d960dcc173b6eULL);
DeclarationDIE(class_H_handler, 0x27ff829e3bf69f37ULL,
dwarf2reader::DW_TAG_subprogram, "func_I", "");
class_H_handler->Finish();
delete class_H_handler;
}
DefinitionDIE(&root_handler_, dwarf2reader::DW_TAG_subprogram,
0x27ff829e3bf69f37ULL, "",
0x5a0dd6bb85db754cULL, 0x3bccb213d08c7fd3ULL);
root_handler_.Finish();
TestFunctionCount(1);
TestFunction(0, "space_A::space_B::struct_C::struct_D::union_E::union_F"
"::class_G::class_H::func_I",
0x5a0dd6bb85db754cULL, 0x3bccb213d08c7fd3ULL);
}
TEST_F(Specifications, InterCU) {
Module m("module-name", "module-os", "module-arch", "module-id");
DwarfCUToModule::FileContext fc("dwarf-filename", &m, true);
EXPECT_CALL(reporter_, UncoveredFunction(_)).WillOnce(Return());
MockLineToModuleHandler lr;
EXPECT_CALL(lr, ReadProgram(_,_,_,_)).Times(0);
// Kludge: satisfy reporter_'s expectation.
reporter_.SetCUName("compilation-unit-name");
// First CU. Declares class_A.
{
DwarfCUToModule root1_handler(&fc, &lr, &reporter_);
ASSERT_TRUE(root1_handler.StartCompilationUnit(0, 1, 2, 3, 3));
ASSERT_TRUE(root1_handler.StartRootDIE(1,
dwarf2reader::DW_TAG_compile_unit));
ProcessStrangeAttributes(&root1_handler);
ASSERT_TRUE(root1_handler.EndAttributes());
DeclarationDIE(&root1_handler, 0xb8fbfdd5f0b26fceULL,
dwarf2reader::DW_TAG_class_type, "class_A", "");
root1_handler.Finish();
}
// Second CU. Defines class_A, declares member_func_B.
{
DwarfCUToModule root2_handler(&fc, &lr, &reporter_);
ASSERT_TRUE(root2_handler.StartCompilationUnit(0, 1, 2, 3, 3));
ASSERT_TRUE(root2_handler.StartRootDIE(1,
dwarf2reader::DW_TAG_compile_unit));
ASSERT_TRUE(root2_handler.EndAttributes());
DIEHandler *class_A_handler
= StartSpecifiedDIE(&root2_handler, dwarf2reader::DW_TAG_class_type,
0xb8fbfdd5f0b26fceULL);
DeclarationDIE(class_A_handler, 0xb01fef8b380bd1a2ULL,
dwarf2reader::DW_TAG_subprogram, "member_func_B", "");
class_A_handler->Finish();
delete class_A_handler;
root2_handler.Finish();
}
// Third CU. Defines member_func_B.
{
DwarfCUToModule root3_handler(&fc, &lr, &reporter_);
ASSERT_TRUE(root3_handler.StartCompilationUnit(0, 1, 2, 3, 3));
ASSERT_TRUE(root3_handler.StartRootDIE(1,
dwarf2reader::DW_TAG_compile_unit));
ASSERT_TRUE(root3_handler.EndAttributes());
DefinitionDIE(&root3_handler, dwarf2reader::DW_TAG_subprogram,
0xb01fef8b380bd1a2ULL, "",
0x2618f00a1a711e53ULL, 0x4fd94b76d7c2caf5ULL);
root3_handler.Finish();
}
vector<Module::Function *> functions;
m.GetFunctions(&functions, functions.end());
EXPECT_EQ(1U, functions.size());
EXPECT_STREQ("class_A::member_func_B", functions[0]->name.c_str());
}
TEST_F(Specifications, UnhandledInterCU) {
Module m("module-name", "module-os", "module-arch", "module-id");
DwarfCUToModule::FileContext fc("dwarf-filename", &m, false);
EXPECT_CALL(reporter_, UncoveredFunction(_)).WillOnce(Return());
MockLineToModuleHandler lr;
EXPECT_CALL(lr, ReadProgram(_,_,_,_)).Times(0);
// Kludge: satisfy reporter_'s expectation.
reporter_.SetCUName("compilation-unit-name");
// First CU. Declares class_A.
{
DwarfCUToModule root1_handler(&fc, &lr, &reporter_);
ASSERT_TRUE(root1_handler.StartCompilationUnit(0, 1, 2, 3, 3));
ASSERT_TRUE(root1_handler.StartRootDIE(1,
dwarf2reader::DW_TAG_compile_unit));
ProcessStrangeAttributes(&root1_handler);
ASSERT_TRUE(root1_handler.EndAttributes());
DeclarationDIE(&root1_handler, 0xb8fbfdd5f0b26fceULL,
dwarf2reader::DW_TAG_class_type, "class_A", "");
root1_handler.Finish();
}
// Second CU. Defines class_A, declares member_func_B.
{
DwarfCUToModule root2_handler(&fc, &lr, &reporter_);
ASSERT_TRUE(root2_handler.StartCompilationUnit(0, 1, 2, 3, 3));
ASSERT_TRUE(root2_handler.StartRootDIE(1,
dwarf2reader::DW_TAG_compile_unit));
ASSERT_TRUE(root2_handler.EndAttributes());
EXPECT_CALL(reporter_, UnhandledInterCUReference(_, _)).Times(1);
DIEHandler *class_A_handler
= StartSpecifiedDIE(&root2_handler, dwarf2reader::DW_TAG_class_type,
0xb8fbfdd5f0b26fceULL);
DeclarationDIE(class_A_handler, 0xb01fef8b380bd1a2ULL,
dwarf2reader::DW_TAG_subprogram, "member_func_B", "");
class_A_handler->Finish();
delete class_A_handler;
root2_handler.Finish();
}
// Third CU. Defines member_func_B.
{
DwarfCUToModule root3_handler(&fc, &lr, &reporter_);
ASSERT_TRUE(root3_handler.StartCompilationUnit(0, 1, 2, 3, 3));
ASSERT_TRUE(root3_handler.StartRootDIE(1,
dwarf2reader::DW_TAG_compile_unit));
ASSERT_TRUE(root3_handler.EndAttributes());
EXPECT_CALL(reporter_, UnhandledInterCUReference(_, _)).Times(1);
EXPECT_CALL(reporter_, UnnamedFunction(_)).Times(1);
DefinitionDIE(&root3_handler, dwarf2reader::DW_TAG_subprogram,
0xb01fef8b380bd1a2ULL, "",
0x2618f00a1a711e53ULL, 0x4fd94b76d7c2caf5ULL);
root3_handler.Finish();
}
}
TEST_F(Specifications, BadOffset) {
PushLine(0xa0277efd7ce83771ULL, 0x149554a184c730c1ULL, "line-file", 56636272);
EXPECT_CALL(reporter_, UnknownSpecification(_, 0x2be953efa6f9a996ULL))
.WillOnce(Return());
StartCU();
DeclarationDIE(&root_handler_, 0xefd7f7752c27b7e4ULL,
dwarf2reader::DW_TAG_subprogram, "", "");
DefinitionDIE(&root_handler_, dwarf2reader::DW_TAG_subprogram,
0x2be953efa6f9a996ULL, "function",
0xa0277efd7ce83771ULL, 0x149554a184c730c1ULL);
root_handler_.Finish();
}
TEST_F(Specifications, FunctionDefinitionHasOwnName) {
PushLine(0xced50b3eea81022cULL, 0x08dd4d301cc7a7d2ULL, "line-file", 56792403);
StartCU();
DeclarationDIE(&root_handler_, 0xc34ff4786cae78bdULL,
dwarf2reader::DW_TAG_subprogram, "declaration-name", "");
DefinitionDIE(&root_handler_, dwarf2reader::DW_TAG_subprogram,
0xc34ff4786cae78bdULL, "definition-name",
0xced50b3eea81022cULL, 0x08dd4d301cc7a7d2ULL);
root_handler_.Finish();
TestFunctionCount(1);
TestFunction(0, "definition-name",
0xced50b3eea81022cULL, 0x08dd4d301cc7a7d2ULL);
}
TEST_F(Specifications, ClassDefinitionHasOwnName) {
PushLine(0x1d0f5e0f6ce309bdULL, 0x654e1852ec3599e7ULL, "line-file", 57119241);
StartCU();
DeclarationDIE(&root_handler_, 0xd0fe467ec2f1a58cULL,
dwarf2reader::DW_TAG_class_type, "class-declaration-name", "");
dwarf2reader::DIEHandler *class_definition
= StartSpecifiedDIE(&root_handler_, dwarf2reader::DW_TAG_class_type,
0xd0fe467ec2f1a58cULL, "class-definition-name");
ASSERT_TRUE(class_definition);
DeclarationDIE(class_definition, 0x6d028229c15623dbULL,
dwarf2reader::DW_TAG_subprogram,
"function-declaration-name", "");
class_definition->Finish();
delete class_definition;
DefinitionDIE(&root_handler_, dwarf2reader::DW_TAG_subprogram,
0x6d028229c15623dbULL, "function-definition-name",
0x1d0f5e0f6ce309bdULL, 0x654e1852ec3599e7ULL);
root_handler_.Finish();
TestFunctionCount(1);
TestFunction(0, "class-definition-name::function-definition-name",
0x1d0f5e0f6ce309bdULL, 0x654e1852ec3599e7ULL);
}
// DIEs that cite a specification should prefer the specification's
// parents over their own when choosing qualified names. In this test,
// we take the name from our definition but the enclosing scope name
// from our declaration. I don't see why they'd ever be different, but
// we want to verify what DwarfCUToModule is looking at.
TEST_F(Specifications, PreferSpecificationParents) {
PushLine(0xbbd9d54dce3b95b7ULL, 0x39188b7b52b0899fULL, "line-file", 79488694);
StartCU();
{
dwarf2reader::DIEHandler *declaration_class_handler =
StartNamedDIE(&root_handler_, dwarf2reader::DW_TAG_class_type,
"declaration-class");
DeclarationDIE(declaration_class_handler, 0x9ddb35517455ef7aULL,
dwarf2reader::DW_TAG_subprogram, "function-declaration",
"");
declaration_class_handler->Finish();
delete declaration_class_handler;
}
{
dwarf2reader::DIEHandler *definition_class_handler
= StartNamedDIE(&root_handler_, dwarf2reader::DW_TAG_class_type,
"definition-class");
DefinitionDIE(definition_class_handler, dwarf2reader::DW_TAG_subprogram,
0x9ddb35517455ef7aULL, "function-definition",
0xbbd9d54dce3b95b7ULL, 0x39188b7b52b0899fULL);
definition_class_handler->Finish();
delete definition_class_handler;
}
root_handler_.Finish();
TestFunctionCount(1);
TestFunction(0, "declaration-class::function-definition",
0xbbd9d54dce3b95b7ULL, 0x39188b7b52b0899fULL);
}
class CUErrors: public CUFixtureBase, public Test { };
TEST_F(CUErrors, BadStmtList) {
EXPECT_CALL(reporter_, BadLineInfoOffset(dummy_line_size_ + 10)).Times(1);
ASSERT_TRUE(root_handler_
.StartCompilationUnit(0xc591d5b037543d7cULL, 0x11, 0xcd,
0x2d7d19546cf6590cULL, 3));
ASSERT_TRUE(root_handler_.StartRootDIE(0xae789dc102cfca54ULL,
dwarf2reader::DW_TAG_compile_unit));
root_handler_.ProcessAttributeString(dwarf2reader::DW_AT_name,
dwarf2reader::DW_FORM_strp,
"compilation-unit-name");
root_handler_.ProcessAttributeUnsigned(dwarf2reader::DW_AT_stmt_list,
dwarf2reader::DW_FORM_ref4,
dummy_line_size_ + 10);
root_handler_.EndAttributes();
root_handler_.Finish();
}
TEST_F(CUErrors, NoLineSection) {
EXPECT_CALL(reporter_, MissingSection(".debug_line")).Times(1);
PushLine(0x88507fb678052611ULL, 0x42c8e9de6bbaa0faULL, "line-file", 64472290);
// Delete the entry for .debug_line added by the fixture class's constructor.
file_context_.ClearSectionMapForTest();
StartCU();
root_handler_.Finish();
}
TEST_F(CUErrors, BadDwarfVersion1) {
// Kludge: satisfy reporter_'s expectation.
reporter_.SetCUName("compilation-unit-name");
ASSERT_FALSE(root_handler_
.StartCompilationUnit(0xadf6e0eb71e2b0d9ULL, 0x4d, 0x90,
0xc9de224ccb99ac3eULL, 1));
}
TEST_F(CUErrors, GoodDwarfVersion2) {
// Kludge: satisfy reporter_'s expectation.
reporter_.SetCUName("compilation-unit-name");
ASSERT_TRUE(root_handler_
.StartCompilationUnit(0xadf6e0eb71e2b0d9ULL, 0x4d, 0x90,
0xc9de224ccb99ac3eULL, 2));
}
TEST_F(CUErrors, GoodDwarfVersion3) {
// Kludge: satisfy reporter_'s expectation.
reporter_.SetCUName("compilation-unit-name");
ASSERT_TRUE(root_handler_
.StartCompilationUnit(0xadf6e0eb71e2b0d9ULL, 0x4d, 0x90,
0xc9de224ccb99ac3eULL, 3));
}
TEST_F(CUErrors, BadCURootDIETag) {
// Kludge: satisfy reporter_'s expectation.
reporter_.SetCUName("compilation-unit-name");
ASSERT_TRUE(root_handler_
.StartCompilationUnit(0xadf6e0eb71e2b0d9ULL, 0x4d, 0x90,
0xc9de224ccb99ac3eULL, 3));
ASSERT_FALSE(root_handler_.StartRootDIE(0x02e56bfbda9e7337ULL,
dwarf2reader::DW_TAG_subprogram));
}
// Tests for DwarfCUToModule::Reporter. These just produce (or fail to
// produce) output, so their results need to be checked by hand.
struct Reporter: public Test {
Reporter()
: reporter("filename", 0x123456789abcdef0ULL),
function("function name", 0x19c45c30770c1eb0ULL),
file("source file name") {
reporter.SetCUName("compilation-unit-name");
function.size = 0x89808a5bdfa0a6a3ULL;
function.parameter_size = 0x6a329f18683dcd51ULL;
line.address = 0x3606ac6267aebeccULL;
line.size = 0x5de482229f32556aULL;
line.file = &file;
line.number = 93400201;
}
DwarfCUToModule::WarningReporter reporter;
Module::Function function;
Module::File file;
Module::Line line;
};
TEST_F(Reporter, UnknownSpecification) {
reporter.UnknownSpecification(0x123456789abcdef1ULL, 0x323456789abcdef2ULL);
}
TEST_F(Reporter, UnknownAbstractOrigin) {
reporter.UnknownAbstractOrigin(0x123456789abcdef1ULL, 0x323456789abcdef2ULL);
}
TEST_F(Reporter, MissingSection) {
reporter.MissingSection("section name");
}
TEST_F(Reporter, BadLineInfoOffset) {
reporter.BadLineInfoOffset(0x123456789abcdef1ULL);
}
TEST_F(Reporter, UncoveredFunctionDisabled) {
reporter.UncoveredFunction(function);
EXPECT_FALSE(reporter.uncovered_warnings_enabled());
}
TEST_F(Reporter, UncoveredFunctionEnabled) {
reporter.set_uncovered_warnings_enabled(true);
reporter.UncoveredFunction(function);
EXPECT_TRUE(reporter.uncovered_warnings_enabled());
}
TEST_F(Reporter, UncoveredLineDisabled) {
reporter.UncoveredLine(line);
EXPECT_FALSE(reporter.uncovered_warnings_enabled());
}
TEST_F(Reporter, UncoveredLineEnabled) {
reporter.set_uncovered_warnings_enabled(true);
reporter.UncoveredLine(line);
EXPECT_TRUE(reporter.uncovered_warnings_enabled());
}
TEST_F(Reporter, UnnamedFunction) {
reporter.UnnamedFunction(0x90c0baff9dedb2d9ULL);
}
// Would be nice to also test:
// - overlapping lines, functions