SwitchEmu/breakpad
1
0
Fork 0
mirror of https://git.suyu.dev/suyu/breakpad.git synced 2026-03-13 03:26:27 +00:00
Code Issues Packages Projects Releases Wiki Activity

Move the dwarf2reader objects into google_breakpad namespace to make it consistent with cfi_assembler.cc

Browse Source 
Bug: b/189249305
Change-Id: I3433ff5c41d2f66ab292fbecb969f2cd08d24b29
Reviewed-on: https://chromium-review.googlesource.com/c/breakpad/breakpad/+/2920506
Reviewed-by: Joshua Peraza <jperaza@chromium.org>
This commit is contained in:
Tyrel Russell
2021-05-26 08:35:33 -04:00
committed by Joshua Peraza
parent f7428bc397
commit 0622f68827
30 changed files with 947 additions and 958 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/common/dwarf/bytereader-inl.h
View File

@@ -34,7 +34,7 @@
#include <assert.h>
#include <stdint.h>
namespace dwarf2reader {
namespace google_breakpad {
inline uint8_t ByteReader::ReadOneByte(const uint8_t* buffer) const {
return buffer[0];
@@ -176,6 +176,6 @@ inline void ByteReader::ClearFunctionBase() {
have_function_base_ = false;
}
} // namespace dwarf2reader
} // namespace google_breakpad
#endif // UTIL_DEBUGINFO_BYTEREADER_INL_H__

4
src/common/dwarf/bytereader.cc
View File

@@ -33,7 +33,7 @@
#include "common/dwarf/bytereader-inl.h"
#include "common/dwarf/bytereader.h"
namespace dwarf2reader {
namespace google_breakpad {
ByteReader::ByteReader(enum Endianness endian)
:offset_reader_(NULL), address_reader_(NULL), endian_(endian),
@@ -247,4 +247,4 @@ Endianness ByteReader::GetEndianness() const {
return endian_;
}
} // namespace dwarf2reader
} // namespace google_breakpad

4
src/common/dwarf/bytereader.h
View File

@@ -38,7 +38,7 @@
#include "common/dwarf/types.h"
#include "common/dwarf/dwarf2enums.h"
namespace dwarf2reader {
namespace google_breakpad {
// We can't use the obvious name of LITTLE_ENDIAN and BIG_ENDIAN
// because it conflicts with a macro
@@ -315,6 +315,6 @@ class ByteReader {
const uint8_t* buffer_base_;
};
} // namespace dwarf2reader
} // namespace google_breakpad
#endif // COMMON_DWARF_BYTEREADER_H__

508
src/common/dwarf/bytereader_unittest.cc
View File

@@ -29,7 +29,7 @@
// Original author: Jim Blandy <jimb@mozilla.com> <jimb@red-bean.com>
// bytereader_unittest.cc: Unit tests for dwarf2reader::ByteReader
// bytereader_unittest.cc: Unit tests for google_breakpad::ByteReader
#include <stdint.h>
@@ -41,10 +41,10 @@
#include "common/dwarf/cfi_assembler.h"
#include "common/using_std_string.h"
using dwarf2reader::ByteReader;
using dwarf2reader::DwarfPointerEncoding;
using dwarf2reader::ENDIANNESS_BIG;
using dwarf2reader::ENDIANNESS_LITTLE;
using google_breakpad::ByteReader;
using google_breakpad::DwarfPointerEncoding;
using google_breakpad::ENDIANNESS_BIG;
using google_breakpad::ENDIANNESS_LITTLE;
using google_breakpad::CFISection;
using google_breakpad::test_assembler::Label;
using google_breakpad::test_assembler::kBigEndian;
@@ -91,279 +91,279 @@ TEST_F(Reader, SimpleConstructor) {
TEST_F(Reader, ValidEncodings) {
ByteReader reader(ENDIANNESS_LITTLE);
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_absptr)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_absptr)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_omit)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_omit)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_aligned)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_aligned)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_uleb128)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_uleb128)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_udata2)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_udata2)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_udata4)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_udata4)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_udata8)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_udata8)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_sleb128)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_sleb128)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_sdata2)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_sdata2)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_sdata4)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_sdata4)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_sdata8)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_sdata8)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_absptr |
dwarf2reader::DW_EH_PE_pcrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_absptr |
google_breakpad::DW_EH_PE_pcrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_uleb128 |
dwarf2reader::DW_EH_PE_pcrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_uleb128 |
google_breakpad::DW_EH_PE_pcrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_udata2 |
dwarf2reader::DW_EH_PE_pcrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_udata2 |
google_breakpad::DW_EH_PE_pcrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_udata4 |
dwarf2reader::DW_EH_PE_pcrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_udata4 |
google_breakpad::DW_EH_PE_pcrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_udata8 |
dwarf2reader::DW_EH_PE_pcrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_udata8 |
google_breakpad::DW_EH_PE_pcrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_sleb128 |
dwarf2reader::DW_EH_PE_pcrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_sleb128 |
google_breakpad::DW_EH_PE_pcrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_sdata2 |
dwarf2reader::DW_EH_PE_pcrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_sdata2 |
google_breakpad::DW_EH_PE_pcrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_sdata4 |
dwarf2reader::DW_EH_PE_pcrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_sdata4 |
google_breakpad::DW_EH_PE_pcrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_sdata8 |
dwarf2reader::DW_EH_PE_pcrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_sdata8 |
google_breakpad::DW_EH_PE_pcrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_absptr |
dwarf2reader::DW_EH_PE_textrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_absptr |
google_breakpad::DW_EH_PE_textrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_uleb128 |
dwarf2reader::DW_EH_PE_textrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_uleb128 |
google_breakpad::DW_EH_PE_textrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_udata2 |
dwarf2reader::DW_EH_PE_textrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_udata2 |
google_breakpad::DW_EH_PE_textrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_udata4 |
dwarf2reader::DW_EH_PE_textrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_udata4 |
google_breakpad::DW_EH_PE_textrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_udata8 |
dwarf2reader::DW_EH_PE_textrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_udata8 |
google_breakpad::DW_EH_PE_textrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_sleb128 |
dwarf2reader::DW_EH_PE_textrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_sleb128 |
google_breakpad::DW_EH_PE_textrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_sdata2 |
dwarf2reader::DW_EH_PE_textrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_sdata2 |
google_breakpad::DW_EH_PE_textrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_sdata4 |
dwarf2reader::DW_EH_PE_textrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_sdata4 |
google_breakpad::DW_EH_PE_textrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_sdata8 |
dwarf2reader::DW_EH_PE_textrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_sdata8 |
google_breakpad::DW_EH_PE_textrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_absptr |
dwarf2reader::DW_EH_PE_datarel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_absptr |
google_breakpad::DW_EH_PE_datarel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_uleb128 |
dwarf2reader::DW_EH_PE_datarel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_uleb128 |
google_breakpad::DW_EH_PE_datarel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_udata2 |
dwarf2reader::DW_EH_PE_datarel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_udata2 |
google_breakpad::DW_EH_PE_datarel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_udata4 |
dwarf2reader::DW_EH_PE_datarel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_udata4 |
google_breakpad::DW_EH_PE_datarel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_udata8 |
dwarf2reader::DW_EH_PE_datarel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_udata8 |
google_breakpad::DW_EH_PE_datarel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_sleb128 |
dwarf2reader::DW_EH_PE_datarel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_sleb128 |
google_breakpad::DW_EH_PE_datarel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_sdata2 |
dwarf2reader::DW_EH_PE_datarel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_sdata2 |
google_breakpad::DW_EH_PE_datarel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_sdata4 |
dwarf2reader::DW_EH_PE_datarel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_sdata4 |
google_breakpad::DW_EH_PE_datarel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_sdata8 |
dwarf2reader::DW_EH_PE_datarel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_sdata8 |
google_breakpad::DW_EH_PE_datarel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_absptr |
dwarf2reader::DW_EH_PE_funcrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_absptr |
google_breakpad::DW_EH_PE_funcrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_uleb128 |
dwarf2reader::DW_EH_PE_funcrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_uleb128 |
google_breakpad::DW_EH_PE_funcrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_udata2 |
dwarf2reader::DW_EH_PE_funcrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_udata2 |
google_breakpad::DW_EH_PE_funcrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_udata4 |
dwarf2reader::DW_EH_PE_funcrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_udata4 |
google_breakpad::DW_EH_PE_funcrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_udata8 |
dwarf2reader::DW_EH_PE_funcrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_udata8 |
google_breakpad::DW_EH_PE_funcrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_sleb128 |
dwarf2reader::DW_EH_PE_funcrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_sleb128 |
google_breakpad::DW_EH_PE_funcrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_sdata2 |
dwarf2reader::DW_EH_PE_funcrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_sdata2 |
google_breakpad::DW_EH_PE_funcrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_sdata4 |
dwarf2reader::DW_EH_PE_funcrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_sdata4 |
google_breakpad::DW_EH_PE_funcrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_sdata8 |
dwarf2reader::DW_EH_PE_funcrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_sdata8 |
google_breakpad::DW_EH_PE_funcrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_indirect |
dwarf2reader::DW_EH_PE_absptr |
dwarf2reader::DW_EH_PE_pcrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
google_breakpad::DW_EH_PE_absptr |
google_breakpad::DW_EH_PE_pcrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_indirect |
dwarf2reader::DW_EH_PE_uleb128 |
dwarf2reader::DW_EH_PE_pcrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
google_breakpad::DW_EH_PE_uleb128 |
google_breakpad::DW_EH_PE_pcrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_indirect |
dwarf2reader::DW_EH_PE_udata2 |
dwarf2reader::DW_EH_PE_pcrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
google_breakpad::DW_EH_PE_udata2 |
google_breakpad::DW_EH_PE_pcrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_indirect |
dwarf2reader::DW_EH_PE_udata4 |
dwarf2reader::DW_EH_PE_pcrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
google_breakpad::DW_EH_PE_udata4 |
google_breakpad::DW_EH_PE_pcrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_indirect |
dwarf2reader::DW_EH_PE_udata8 |
dwarf2reader::DW_EH_PE_pcrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
google_breakpad::DW_EH_PE_udata8 |
google_breakpad::DW_EH_PE_pcrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_indirect |
dwarf2reader::DW_EH_PE_sleb128 |
dwarf2reader::DW_EH_PE_pcrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
google_breakpad::DW_EH_PE_sleb128 |
google_breakpad::DW_EH_PE_pcrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_indirect |
dwarf2reader::DW_EH_PE_sdata2 |
dwarf2reader::DW_EH_PE_pcrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
google_breakpad::DW_EH_PE_sdata2 |
google_breakpad::DW_EH_PE_pcrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_indirect |
dwarf2reader::DW_EH_PE_sdata4 |
dwarf2reader::DW_EH_PE_pcrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
google_breakpad::DW_EH_PE_sdata4 |
google_breakpad::DW_EH_PE_pcrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_indirect |
dwarf2reader::DW_EH_PE_sdata8 |
dwarf2reader::DW_EH_PE_pcrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
google_breakpad::DW_EH_PE_sdata8 |
google_breakpad::DW_EH_PE_pcrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_indirect |
dwarf2reader::DW_EH_PE_absptr |
dwarf2reader::DW_EH_PE_textrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
google_breakpad::DW_EH_PE_absptr |
google_breakpad::DW_EH_PE_textrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_indirect |
dwarf2reader::DW_EH_PE_uleb128 |
dwarf2reader::DW_EH_PE_textrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
google_breakpad::DW_EH_PE_uleb128 |
google_breakpad::DW_EH_PE_textrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_indirect |
dwarf2reader::DW_EH_PE_udata2 |
dwarf2reader::DW_EH_PE_textrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
google_breakpad::DW_EH_PE_udata2 |
google_breakpad::DW_EH_PE_textrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_indirect |
dwarf2reader::DW_EH_PE_udata4 |
dwarf2reader::DW_EH_PE_textrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
google_breakpad::DW_EH_PE_udata4 |
google_breakpad::DW_EH_PE_textrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_indirect |
dwarf2reader::DW_EH_PE_udata8 |
dwarf2reader::DW_EH_PE_textrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
google_breakpad::DW_EH_PE_udata8 |
google_breakpad::DW_EH_PE_textrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_indirect |
dwarf2reader::DW_EH_PE_sleb128 |
dwarf2reader::DW_EH_PE_textrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
google_breakpad::DW_EH_PE_sleb128 |
google_breakpad::DW_EH_PE_textrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_indirect |
dwarf2reader::DW_EH_PE_sdata2 |
dwarf2reader::DW_EH_PE_textrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
google_breakpad::DW_EH_PE_sdata2 |
google_breakpad::DW_EH_PE_textrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_indirect |
dwarf2reader::DW_EH_PE_sdata4 |
dwarf2reader::DW_EH_PE_textrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
google_breakpad::DW_EH_PE_sdata4 |
google_breakpad::DW_EH_PE_textrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_indirect |
dwarf2reader::DW_EH_PE_sdata8 |
dwarf2reader::DW_EH_PE_textrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
google_breakpad::DW_EH_PE_sdata8 |
google_breakpad::DW_EH_PE_textrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_indirect |
dwarf2reader::DW_EH_PE_absptr |
dwarf2reader::DW_EH_PE_datarel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
google_breakpad::DW_EH_PE_absptr |
google_breakpad::DW_EH_PE_datarel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_indirect |
dwarf2reader::DW_EH_PE_uleb128 |
dwarf2reader::DW_EH_PE_datarel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
google_breakpad::DW_EH_PE_uleb128 |
google_breakpad::DW_EH_PE_datarel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_indirect |
dwarf2reader::DW_EH_PE_udata2 |
dwarf2reader::DW_EH_PE_datarel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
google_breakpad::DW_EH_PE_udata2 |
google_breakpad::DW_EH_PE_datarel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_indirect |
dwarf2reader::DW_EH_PE_udata4 |
dwarf2reader::DW_EH_PE_datarel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
google_breakpad::DW_EH_PE_udata4 |
google_breakpad::DW_EH_PE_datarel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_indirect |
dwarf2reader::DW_EH_PE_udata8 |
dwarf2reader::DW_EH_PE_datarel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
google_breakpad::DW_EH_PE_udata8 |
google_breakpad::DW_EH_PE_datarel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_indirect |
dwarf2reader::DW_EH_PE_sleb128 |
dwarf2reader::DW_EH_PE_datarel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
google_breakpad::DW_EH_PE_sleb128 |
google_breakpad::DW_EH_PE_datarel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_indirect |
dwarf2reader::DW_EH_PE_sdata2 |
dwarf2reader::DW_EH_PE_datarel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
google_breakpad::DW_EH_PE_sdata2 |
google_breakpad::DW_EH_PE_datarel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_indirect |
dwarf2reader::DW_EH_PE_sdata4 |
dwarf2reader::DW_EH_PE_datarel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
google_breakpad::DW_EH_PE_sdata4 |
google_breakpad::DW_EH_PE_datarel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_indirect |
dwarf2reader::DW_EH_PE_sdata8 |
dwarf2reader::DW_EH_PE_datarel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
google_breakpad::DW_EH_PE_sdata8 |
google_breakpad::DW_EH_PE_datarel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_indirect |
dwarf2reader::DW_EH_PE_absptr |
dwarf2reader::DW_EH_PE_funcrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
google_breakpad::DW_EH_PE_absptr |
google_breakpad::DW_EH_PE_funcrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_indirect |
dwarf2reader::DW_EH_PE_uleb128 |
dwarf2reader::DW_EH_PE_funcrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
google_breakpad::DW_EH_PE_uleb128 |
google_breakpad::DW_EH_PE_funcrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_indirect |
dwarf2reader::DW_EH_PE_udata2 |
dwarf2reader::DW_EH_PE_funcrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
google_breakpad::DW_EH_PE_udata2 |
google_breakpad::DW_EH_PE_funcrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_indirect |
dwarf2reader::DW_EH_PE_udata4 |
dwarf2reader::DW_EH_PE_funcrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
google_breakpad::DW_EH_PE_udata4 |
google_breakpad::DW_EH_PE_funcrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_indirect |
dwarf2reader::DW_EH_PE_udata8 |
dwarf2reader::DW_EH_PE_funcrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
google_breakpad::DW_EH_PE_udata8 |
google_breakpad::DW_EH_PE_funcrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_indirect |
dwarf2reader::DW_EH_PE_sleb128 |
dwarf2reader::DW_EH_PE_funcrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
google_breakpad::DW_EH_PE_sleb128 |
google_breakpad::DW_EH_PE_funcrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_indirect |
dwarf2reader::DW_EH_PE_sdata2 |
dwarf2reader::DW_EH_PE_funcrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
google_breakpad::DW_EH_PE_sdata2 |
google_breakpad::DW_EH_PE_funcrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_indirect |
dwarf2reader::DW_EH_PE_sdata4 |
dwarf2reader::DW_EH_PE_funcrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
google_breakpad::DW_EH_PE_sdata4 |
google_breakpad::DW_EH_PE_funcrel)));
EXPECT_TRUE(reader.ValidEncoding(
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_indirect |
dwarf2reader::DW_EH_PE_sdata8 |
dwarf2reader::DW_EH_PE_funcrel)));
DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect |
google_breakpad::DW_EH_PE_sdata8 |
google_breakpad::DW_EH_PE_funcrel)));
EXPECT_FALSE(reader.ValidEncoding(DwarfPointerEncoding(0x05)));
EXPECT_FALSE(reader.ValidEncoding(DwarfPointerEncoding(0x07)));
@@ -380,7 +380,7 @@ TEST_F(ReaderDeathTest, DW_EH_PE_omit) {
static const uint8_t data[] = { 42 };
ByteReader reader(ENDIANNESS_BIG);
reader.SetAddressSize(4);
EXPECT_DEATH(reader.ReadEncodedPointer(data, dwarf2reader::DW_EH_PE_omit,
EXPECT_DEATH(reader.ReadEncodedPointer(data, google_breakpad::DW_EH_PE_omit,
&pointer_size),
"encoding != DW_EH_PE_omit");
}
@@ -390,7 +390,7 @@ TEST_F(Reader, DW_EH_PE_absptr4) {
ByteReader reader(ENDIANNESS_LITTLE);
reader.SetAddressSize(4);
EXPECT_EQ(0x40ea5727U,
reader.ReadEncodedPointer(data, dwarf2reader::DW_EH_PE_absptr,
reader.ReadEncodedPointer(data, google_breakpad::DW_EH_PE_absptr,
&pointer_size));
EXPECT_EQ(4U, pointer_size);
}
@@ -402,7 +402,7 @@ TEST_F(Reader, DW_EH_PE_absptr8) {
ByteReader reader(ENDIANNESS_LITTLE);
reader.SetAddressSize(8);
EXPECT_EQ(0x010598c240ea5727ULL,
reader.ReadEncodedPointer(data + 1, dwarf2reader::DW_EH_PE_absptr,
reader.ReadEncodedPointer(data + 1, google_breakpad::DW_EH_PE_absptr,
&pointer_size));
EXPECT_EQ(8U, pointer_size);
}
@@ -412,7 +412,7 @@ TEST_F(Reader, DW_EH_PE_uleb128) {
ByteReader reader(ENDIANNESS_LITTLE);
reader.SetAddressSize(4);
EXPECT_EQ(0x130201U,
reader.ReadEncodedPointer(data, dwarf2reader::DW_EH_PE_uleb128,
reader.ReadEncodedPointer(data, google_breakpad::DW_EH_PE_uleb128,
&pointer_size));
EXPECT_EQ(3U, pointer_size);
}
@@ -422,7 +422,7 @@ TEST_F(Reader, DW_EH_PE_udata2) {
ByteReader reader(ENDIANNESS_BIG);
reader.SetAddressSize(4);
EXPECT_EQ(0xf48dU,
reader.ReadEncodedPointer(data, dwarf2reader::DW_EH_PE_udata2,
reader.ReadEncodedPointer(data, google_breakpad::DW_EH_PE_udata2,
&pointer_size));
EXPECT_EQ(2U, pointer_size);
}
@@ -432,7 +432,7 @@ TEST_F(Reader, DW_EH_PE_udata4) {
ByteReader reader(ENDIANNESS_BIG);
reader.SetAddressSize(8);
EXPECT_EQ(0xa5628f8b,
reader.ReadEncodedPointer(data + 2, dwarf2reader::DW_EH_PE_udata4,
reader.ReadEncodedPointer(data + 2, google_breakpad::DW_EH_PE_udata4,
&pointer_size));
EXPECT_EQ(4U, pointer_size);
}
@@ -444,7 +444,7 @@ TEST_F(Reader, DW_EH_PE_udata8Addr8) {
ByteReader reader(ENDIANNESS_LITTLE);
reader.SetAddressSize(8);
EXPECT_EQ(0x8fed199f69047304ULL,
reader.ReadEncodedPointer(data + 1, dwarf2reader::DW_EH_PE_udata8,
reader.ReadEncodedPointer(data + 1, google_breakpad::DW_EH_PE_udata8,
&pointer_size));
EXPECT_EQ(8U, pointer_size);
}
@@ -456,7 +456,7 @@ TEST_F(Reader, DW_EH_PE_udata8Addr4) {
ByteReader reader(ENDIANNESS_LITTLE);
reader.SetAddressSize(4);
EXPECT_EQ(0x69047304ULL,
reader.ReadEncodedPointer(data + 1, dwarf2reader::DW_EH_PE_udata8,
reader.ReadEncodedPointer(data + 1, google_breakpad::DW_EH_PE_udata8,
&pointer_size));
EXPECT_EQ(8U, pointer_size);
}
@@ -466,7 +466,7 @@ TEST_F(Reader, DW_EH_PE_sleb128) {
ByteReader reader(ENDIANNESS_BIG);
reader.SetAddressSize(4);
EXPECT_EQ(-0x030201U & 0xffffffff,
reader.ReadEncodedPointer(data + 1, dwarf2reader::DW_EH_PE_sleb128,
reader.ReadEncodedPointer(data + 1, google_breakpad::DW_EH_PE_sleb128,
&pointer_size));
EXPECT_EQ(3U, pointer_size);
}
@@ -476,7 +476,7 @@ TEST_F(Reader, DW_EH_PE_sdata2) {
ByteReader reader(ENDIANNESS_LITTLE);
reader.SetAddressSize(8);
EXPECT_EQ(0xffffffffffffbfb9ULL,
reader.ReadEncodedPointer(data, dwarf2reader::DW_EH_PE_sdata2,
reader.ReadEncodedPointer(data, google_breakpad::DW_EH_PE_sdata2,
&pointer_size));
EXPECT_EQ(2U, pointer_size);
}
@@ -486,7 +486,7 @@ TEST_F(Reader, DW_EH_PE_sdata4) {
ByteReader reader(ENDIANNESS_LITTLE);
reader.SetAddressSize(8);
EXPECT_EQ(0xffffffffadc2b8f2ULL,
reader.ReadEncodedPointer(data + 2, dwarf2reader::DW_EH_PE_sdata4,
reader.ReadEncodedPointer(data + 2, google_breakpad::DW_EH_PE_sdata4,
&pointer_size));
EXPECT_EQ(4U, pointer_size);
}
@@ -498,7 +498,7 @@ TEST_F(Reader, DW_EH_PE_sdata8) {
ByteReader reader(ENDIANNESS_LITTLE);
reader.SetAddressSize(8);
EXPECT_EQ(0x87269b0ce0795766ULL,
reader.ReadEncodedPointer(data + 1, dwarf2reader::DW_EH_PE_sdata8,
reader.ReadEncodedPointer(data + 1, google_breakpad::DW_EH_PE_sdata8,
&pointer_size));
EXPECT_EQ(8U, pointer_size);
}
@@ -510,8 +510,8 @@ TEST_F(Reader, DW_EH_PE_pcrel) {
ByteReader reader(ENDIANNESS_BIG);
reader.SetAddressSize(4);
DwarfPointerEncoding encoding =
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_pcrel
| dwarf2reader::DW_EH_PE_absptr);
DwarfPointerEncoding(google_breakpad::DW_EH_PE_pcrel
| google_breakpad::DW_EH_PE_absptr);
reader.SetCFIDataBase(0x89951377, data);
EXPECT_EQ(0x89951377 + 3 + 0x14c8c402,
reader.ReadEncodedPointer(data + 3, encoding, &pointer_size));
@@ -526,8 +526,8 @@ TEST_F(Reader, DW_EH_PE_textrel) {
reader.SetAddressSize(4);
reader.SetTextBase(0xb91beaf0);
DwarfPointerEncoding encoding =
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_textrel
| dwarf2reader::DW_EH_PE_sdata2);
DwarfPointerEncoding(google_breakpad::DW_EH_PE_textrel
| google_breakpad::DW_EH_PE_sdata2);
EXPECT_EQ((0xb91beaf0 + 0xffffc917) & 0xffffffff,
reader.ReadEncodedPointer(data + 3, encoding, &pointer_size));
EXPECT_EQ(2U, pointer_size);
@@ -541,8 +541,8 @@ TEST_F(Reader, DW_EH_PE_datarel) {
reader.SetAddressSize(8);
reader.SetDataBase(0xbef308bd25ce74f0ULL);
DwarfPointerEncoding encoding =
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_datarel
| dwarf2reader::DW_EH_PE_sleb128);
DwarfPointerEncoding(google_breakpad::DW_EH_PE_datarel
| google_breakpad::DW_EH_PE_sleb128);
EXPECT_EQ(0xbef308bd25ce74f0ULL + 0xfffffffffffa013bULL,
reader.ReadEncodedPointer(data + 2, encoding, &pointer_size));
EXPECT_EQ(3U, pointer_size);
@@ -556,8 +556,8 @@ TEST_F(Reader, DW_EH_PE_funcrel) {
reader.SetAddressSize(4);
reader.SetFunctionBase(0x823c3520);
DwarfPointerEncoding encoding =
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_funcrel
| dwarf2reader::DW_EH_PE_udata2);
DwarfPointerEncoding(google_breakpad::DW_EH_PE_funcrel
| google_breakpad::DW_EH_PE_udata2);
EXPECT_EQ(0x823c3520 + 0xd148,
reader.ReadEncodedPointer(data + 5, encoding, &pointer_size));
EXPECT_EQ(2U, pointer_size);
@@ -567,48 +567,48 @@ TEST(UsableBase, CFI) {
static const uint8_t data[] = { 0x42 };
ByteReader reader(ENDIANNESS_BIG);
reader.SetCFIDataBase(0xb31cbd20, data);
EXPECT_TRUE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_absptr));
EXPECT_TRUE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_pcrel));
EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_textrel));
EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_datarel));
EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_funcrel));
EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_omit));
EXPECT_TRUE(reader.UsableEncoding(google_breakpad::DW_EH_PE_absptr));
EXPECT_TRUE(reader.UsableEncoding(google_breakpad::DW_EH_PE_pcrel));
EXPECT_FALSE(reader.UsableEncoding(google_breakpad::DW_EH_PE_textrel));
EXPECT_FALSE(reader.UsableEncoding(google_breakpad::DW_EH_PE_datarel));
EXPECT_FALSE(reader.UsableEncoding(google_breakpad::DW_EH_PE_funcrel));
EXPECT_FALSE(reader.UsableEncoding(google_breakpad::DW_EH_PE_omit));
EXPECT_FALSE(reader.UsableEncoding(DwarfPointerEncoding(0x60)));
}
TEST(UsableBase, Text) {
ByteReader reader(ENDIANNESS_BIG);
reader.SetTextBase(0xa899ccb9);
EXPECT_TRUE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_absptr));
EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_pcrel));
EXPECT_TRUE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_textrel));
EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_datarel));
EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_funcrel));
EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_omit));
EXPECT_TRUE(reader.UsableEncoding(google_breakpad::DW_EH_PE_absptr));
EXPECT_FALSE(reader.UsableEncoding(google_breakpad::DW_EH_PE_pcrel));
EXPECT_TRUE(reader.UsableEncoding(google_breakpad::DW_EH_PE_textrel));
EXPECT_FALSE(reader.UsableEncoding(google_breakpad::DW_EH_PE_datarel));
EXPECT_FALSE(reader.UsableEncoding(google_breakpad::DW_EH_PE_funcrel));
EXPECT_FALSE(reader.UsableEncoding(google_breakpad::DW_EH_PE_omit));
EXPECT_FALSE(reader.UsableEncoding(DwarfPointerEncoding(0x60)));
}
TEST(UsableBase, Data) {
ByteReader reader(ENDIANNESS_BIG);
reader.SetDataBase(0xf7b10bcd);
EXPECT_TRUE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_absptr));
EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_pcrel));
EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_textrel));
EXPECT_TRUE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_datarel));
EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_funcrel));
EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_omit));
EXPECT_TRUE(reader.UsableEncoding(google_breakpad::DW_EH_PE_absptr));
EXPECT_FALSE(reader.UsableEncoding(google_breakpad::DW_EH_PE_pcrel));
EXPECT_FALSE(reader.UsableEncoding(google_breakpad::DW_EH_PE_textrel));
EXPECT_TRUE(reader.UsableEncoding(google_breakpad::DW_EH_PE_datarel));
EXPECT_FALSE(reader.UsableEncoding(google_breakpad::DW_EH_PE_funcrel));
EXPECT_FALSE(reader.UsableEncoding(google_breakpad::DW_EH_PE_omit));
EXPECT_FALSE(reader.UsableEncoding(DwarfPointerEncoding(0x60)));
}
TEST(UsableBase, Function) {
ByteReader reader(ENDIANNESS_BIG);
reader.SetFunctionBase(0xc2c0ed81);
EXPECT_TRUE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_absptr));
EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_pcrel));
EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_textrel));
EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_datarel));
EXPECT_TRUE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_funcrel));
EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_omit));
EXPECT_TRUE(reader.UsableEncoding(google_breakpad::DW_EH_PE_absptr));
EXPECT_FALSE(reader.UsableEncoding(google_breakpad::DW_EH_PE_pcrel));
EXPECT_FALSE(reader.UsableEncoding(google_breakpad::DW_EH_PE_textrel));
EXPECT_FALSE(reader.UsableEncoding(google_breakpad::DW_EH_PE_datarel));
EXPECT_TRUE(reader.UsableEncoding(google_breakpad::DW_EH_PE_funcrel));
EXPECT_FALSE(reader.UsableEncoding(google_breakpad::DW_EH_PE_omit));
EXPECT_FALSE(reader.UsableEncoding(DwarfPointerEncoding(0x60)));
}
@@ -616,12 +616,12 @@ TEST(UsableBase, ClearFunction) {
ByteReader reader(ENDIANNESS_BIG);
reader.SetFunctionBase(0xc2c0ed81);
reader.ClearFunctionBase();
EXPECT_TRUE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_absptr));
EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_pcrel));
EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_textrel));
EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_datarel));
EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_funcrel));
EXPECT_FALSE(reader.UsableEncoding(dwarf2reader::DW_EH_PE_omit));
EXPECT_TRUE(reader.UsableEncoding(google_breakpad::DW_EH_PE_absptr));
EXPECT_FALSE(reader.UsableEncoding(google_breakpad::DW_EH_PE_pcrel));
EXPECT_FALSE(reader.UsableEncoding(google_breakpad::DW_EH_PE_textrel));
EXPECT_FALSE(reader.UsableEncoding(google_breakpad::DW_EH_PE_datarel));
EXPECT_FALSE(reader.UsableEncoding(google_breakpad::DW_EH_PE_funcrel));
EXPECT_FALSE(reader.UsableEncoding(google_breakpad::DW_EH_PE_omit));
EXPECT_FALSE(reader.UsableEncoding(DwarfPointerEncoding(0x60)));
}
@@ -641,7 +641,7 @@ class Aligned: public AlignedFixture, public Test { };
TEST_F(Aligned, DW_EH_PE_aligned0) {
reader.SetCFIDataBase(0xb440305c, data);
EXPECT_EQ(0xfe6e93d8U,
reader.ReadEncodedPointer(data, dwarf2reader::DW_EH_PE_aligned,
reader.ReadEncodedPointer(data, google_breakpad::DW_EH_PE_aligned,
&pointer_size));
EXPECT_EQ(4U, pointer_size);
}
@@ -649,7 +649,7 @@ TEST_F(Aligned, DW_EH_PE_aligned0) {
TEST_F(Aligned, DW_EH_PE_aligned1) {
reader.SetCFIDataBase(0xb440305d, data);
EXPECT_EQ(0xd834d51cU,
reader.ReadEncodedPointer(data, dwarf2reader::DW_EH_PE_aligned,
reader.ReadEncodedPointer(data, google_breakpad::DW_EH_PE_aligned,
&pointer_size));
EXPECT_EQ(7U, pointer_size);
}
@@ -657,7 +657,7 @@ TEST_F(Aligned, DW_EH_PE_aligned1) {
TEST_F(Aligned, DW_EH_PE_aligned2) {
reader.SetCFIDataBase(0xb440305e, data);
EXPECT_EQ(0x93d834d5U,
reader.ReadEncodedPointer(data, dwarf2reader::DW_EH_PE_aligned,
reader.ReadEncodedPointer(data, google_breakpad::DW_EH_PE_aligned,
&pointer_size));
EXPECT_EQ(6U, pointer_size);
}
@@ -665,7 +665,7 @@ TEST_F(Aligned, DW_EH_PE_aligned2) {
TEST_F(Aligned, DW_EH_PE_aligned3) {
reader.SetCFIDataBase(0xb440305f, data);
EXPECT_EQ(0x6e93d834U,
reader.ReadEncodedPointer(data, dwarf2reader::DW_EH_PE_aligned,
reader.ReadEncodedPointer(data, google_breakpad::DW_EH_PE_aligned,
&pointer_size));
EXPECT_EQ(5U, pointer_size);
}
@@ -674,7 +674,7 @@ TEST_F(Aligned, DW_EH_PE_aligned11) {
reader.SetCFIDataBase(0xb4403061, data);
EXPECT_EQ(0xd834d51cU,
reader.ReadEncodedPointer(data + 1,
dwarf2reader::DW_EH_PE_aligned,
google_breakpad::DW_EH_PE_aligned,
&pointer_size));
EXPECT_EQ(6U, pointer_size);
}
@@ -683,7 +683,7 @@ TEST_F(Aligned, DW_EH_PE_aligned30) {
reader.SetCFIDataBase(0xb4403063, data);
EXPECT_EQ(0x6e93d834U,
reader.ReadEncodedPointer(data + 1,
dwarf2reader::DW_EH_PE_aligned,
google_breakpad::DW_EH_PE_aligned,
&pointer_size));
EXPECT_EQ(4U, pointer_size);
}
@@ -692,7 +692,7 @@ TEST_F(Aligned, DW_EH_PE_aligned23) {
reader.SetCFIDataBase(0xb4403062, data);
EXPECT_EQ(0x1cd3ac2bU,
reader.ReadEncodedPointer(data + 3,
dwarf2reader::DW_EH_PE_aligned,
google_breakpad::DW_EH_PE_aligned,
&pointer_size));
EXPECT_EQ(7U, pointer_size);
}
@@ -701,7 +701,7 @@ TEST_F(Aligned, DW_EH_PE_aligned03) {
reader.SetCFIDataBase(0xb4403064, data);
EXPECT_EQ(0x34d51cd3U,
reader.ReadEncodedPointer(data + 3,
dwarf2reader::DW_EH_PE_aligned,
google_breakpad::DW_EH_PE_aligned,
&pointer_size));
EXPECT_EQ(5U, pointer_size);
}

42
src/common/dwarf/cfi_assembler.cc
View File

@@ -38,8 +38,6 @@
#include <stdlib.h>
namespace google_breakpad {
using dwarf2reader::DwarfPointerEncoding;
CFISection& CFISection::CIEHeader(uint64_t code_alignment_factor,
int data_alignment_factor,
@@ -115,7 +113,7 @@ CFISection& CFISection::FDEHeader(Label cie_pointer,
CFISection& CFISection::FinishEntry() {
assert(entry_length_);
Align(address_size_, dwarf2reader::DW_CFA_nop);
Align(address_size_, DW_CFA_nop);
entry_length_->length = Here() - entry_length_->start;
delete entry_length_;
entry_length_ = NULL;
@@ -127,24 +125,24 @@ CFISection& CFISection::EncodedPointer(uint64_t address,
DwarfPointerEncoding encoding,
const EncodedPointerBases& bases) {
// Omitted data is extremely easy to emit.
if (encoding == dwarf2reader::DW_EH_PE_omit)
if (encoding == DW_EH_PE_omit)
return *this;
// If (encoding & dwarf2reader::DW_EH_PE_indirect) != 0, then we assume
// If (encoding & DW_EH_PE_indirect) != 0, then we assume
// that ADDRESS is the address at which the pointer is stored --- in
// other words, that bit has no effect on how we write the pointer.
encoding = DwarfPointerEncoding(encoding & ~dwarf2reader::DW_EH_PE_indirect);
encoding = DwarfPointerEncoding(encoding & ~DW_EH_PE_indirect);
// Find the base address to which this pointer is relative. The upper
// nybble of the encoding specifies this.
uint64_t base;
switch (encoding & 0xf0) {
case dwarf2reader::DW_EH_PE_absptr: base = 0; break;
case dwarf2reader::DW_EH_PE_pcrel: base = bases.cfi + Size(); break;
case dwarf2reader::DW_EH_PE_textrel: base = bases.text; break;
case dwarf2reader::DW_EH_PE_datarel: base = bases.data; break;
case dwarf2reader::DW_EH_PE_funcrel: base = fde_start_address_; break;
case dwarf2reader::DW_EH_PE_aligned: base = 0; break;
case DW_EH_PE_absptr: base = 0; break;
case DW_EH_PE_pcrel: base = bases.cfi + Size(); break;
case DW_EH_PE_textrel: base = bases.text; break;
case DW_EH_PE_datarel: base = bases.data; break;
case DW_EH_PE_funcrel: base = fde_start_address_; break;
case DW_EH_PE_aligned: base = 0; break;
default: abort();
};
@@ -153,7 +151,7 @@ CFISection& CFISection::EncodedPointer(uint64_t address,
address -= base;
// Align the pointer, if required.
if ((encoding & 0xf0) == dwarf2reader::DW_EH_PE_aligned)
if ((encoding & 0xf0) == DW_EH_PE_aligned)
Align(AddressSize());
// Append ADDRESS to this section in the appropriate form. For the
@@ -161,30 +159,30 @@ CFISection& CFISection::EncodedPointer(uint64_t address,
// unsigned encodings, because ADDRESS has already been extended to 64
// bits before it was passed to us.
switch (encoding & 0x0f) {
case dwarf2reader::DW_EH_PE_absptr:
case DW_EH_PE_absptr:
Address(address);
break;
case dwarf2reader::DW_EH_PE_uleb128:
case DW_EH_PE_uleb128:
ULEB128(address);
break;
case dwarf2reader::DW_EH_PE_sleb128:
case DW_EH_PE_sleb128:
LEB128(address);
break;
case dwarf2reader::DW_EH_PE_udata2:
case dwarf2reader::DW_EH_PE_sdata2:
case DW_EH_PE_udata2:
case DW_EH_PE_sdata2:
D16(address);
break;
case dwarf2reader::DW_EH_PE_udata4:
case dwarf2reader::DW_EH_PE_sdata4:
case DW_EH_PE_udata4:
case DW_EH_PE_sdata4:
D32(address);
break;
case dwarf2reader::DW_EH_PE_udata8:
case dwarf2reader::DW_EH_PE_sdata8:
case DW_EH_PE_udata8:
case DW_EH_PE_sdata8:
D64(address);
break;

4
src/common/dwarf/dwarf2diehandler.cc
View File

@@ -39,7 +39,7 @@
#include "common/dwarf/dwarf2diehandler.h"
#include "common/using_std_string.h"
namespace dwarf2reader {
namespace google_breakpad {
DIEDispatcher::~DIEDispatcher() {
while (!die_handlers_.empty()) {
@@ -196,4 +196,4 @@ void DIEDispatcher::ProcessAttributeSignature(uint64_t offset,
current.handler_->ProcessAttributeSignature(attr, form, signature);
}
} // namespace dwarf2reader
} // namespace google_breakpad

4
src/common/dwarf/dwarf2diehandler.h
View File

@@ -166,7 +166,7 @@
#include "common/dwarf/dwarf2reader.h"
#include "common/using_std_string.h"
namespace dwarf2reader {
namespace google_breakpad {
// A base class for handlers for specific DIE types. The series of
// calls made on a DIE handler is as follows:
@@ -361,5 +361,5 @@ class DIEDispatcher: public Dwarf2Handler {
RootDIEHandler* root_handler_;
};
} // namespace dwarf2reader
} // namespace google_breakpad
#endif // COMMON_DWARF_DWARF2DIEHANDLER_H__

12
src/common/dwarf/dwarf2diehandler_unittest.cc
View File

@@ -53,12 +53,12 @@ using ::testing::Return;
using ::testing::Sequence;
using ::testing::StrEq;
using dwarf2reader::DIEDispatcher;
using dwarf2reader::DIEHandler;
using dwarf2reader::DwarfAttribute;
using dwarf2reader::DwarfForm;
using dwarf2reader::DwarfTag;
using dwarf2reader::RootDIEHandler;
using google_breakpad::DIEDispatcher;
using google_breakpad::DIEHandler;
using google_breakpad::DwarfAttribute;
using google_breakpad::DwarfForm;
using google_breakpad::DwarfTag;
using google_breakpad::RootDIEHandler;
class MockDIEHandler: public DIEHandler {
public:

4
src/common/dwarf/dwarf2enums.h
View File

@@ -31,7 +31,7 @@
#ifndef COMMON_DWARF_DWARF2ENUMS_H__
#define COMMON_DWARF_DWARF2ENUMS_H__
namespace dwarf2reader {
namespace google_breakpad {
// These enums do not follow the google3 style only because they are
// known universally (specs, other implementations) by the names in
@@ -740,5 +740,5 @@ enum DwarfPointerEncoding
DW_EH_PE_indirect = 0x80
};
} // namespace dwarf2reader
} // namespace google_breakpad
#endif // COMMON_DWARF_DWARF2ENUMS_H__

12
src/common/dwarf/dwarf2reader.cc
View File

@@ -28,8 +28,8 @@
// CFI reader author: Jim Blandy <jimb@mozilla.com> <jimb@red-bean.com>
// Implementation of dwarf2reader::LineInfo, dwarf2reader::CompilationUnit,
// and dwarf2reader::CallFrameInfo. See dwarf2reader.h for details.
// Implementation of LineInfo, CompilationUnit,
// and CallFrameInfo. See dwarf2reader.h for details.
#include "common/dwarf/dwarf2reader.h"
@@ -51,7 +51,7 @@
#include "common/using_std_string.h"
#include "google_breakpad/common/breakpad_types.h"
namespace dwarf2reader {
namespace google_breakpad {
const SectionMap::const_iterator GetSectionByName(const SectionMap&
sections, const char *name) {
@@ -517,8 +517,8 @@ const uint8_t* CompilationUnit::ProcessOffsetBaseAttribute(
// This is the important one here!
case DW_FORM_sec_offset:
if (attr == dwarf2reader::DW_AT_str_offsets_base ||
attr == dwarf2reader::DW_AT_addr_base)
if (attr == DW_AT_str_offsets_base ||
attr == DW_AT_addr_base)
ProcessAttributeUnsigned(dieoffset, attr, form,
reader_->ReadOffset(start));
else
@@ -3414,4 +3414,4 @@ void CallFrameInfo::Reporter::ClearingCFARule(uint64_t offset,
section_.c_str(), insn_offset);
}
} // namespace dwarf2reader
} // namespace google_breakpad

4
src/common/dwarf/dwarf2reader.h
View File

@@ -56,7 +56,7 @@
#include "common/using_std_string.h"
#include "common/dwarf/elf_reader.h"
namespace dwarf2reader {
namespace google_breakpad {
struct LineStateMachine;
class Dwarf2Handler;
class LineInfoHandler;
@@ -1489,6 +1489,6 @@ class CallFrameInfo::Reporter {
string section_;
};
} // namespace dwarf2reader
} // namespace google_breakpad
#endif // UTIL_DEBUGINFO_DWARF2READER_H__

434
src/common/dwarf/dwarf2reader_cfi_unittest.cc
View File

@@ -29,7 +29,7 @@
// Original author: Jim Blandy <jimb@mozilla.com> <jimb@red-bean.com>
// dwarf2reader_cfi_unittest.cc: Unit tests for dwarf2reader::CallFrameInfo
// dwarf2reader_cfi_unittest.cc: Unit tests for google_breakpad::CallFrameInfo
#include <stdint.h>
#include <stdlib.h>
@@ -72,11 +72,11 @@ using google_breakpad::test_assembler::kBigEndian;
using google_breakpad::test_assembler::kLittleEndian;
using google_breakpad::test_assembler::Section;
using dwarf2reader::DwarfPointerEncoding;
using dwarf2reader::ENDIANNESS_BIG;
using dwarf2reader::ENDIANNESS_LITTLE;
using dwarf2reader::ByteReader;
using dwarf2reader::CallFrameInfo;
using google_breakpad::DwarfPointerEncoding;
using google_breakpad::ENDIANNESS_BIG;
using google_breakpad::ENDIANNESS_LITTLE;
using google_breakpad::ByteReader;
using google_breakpad::CallFrameInfo;
using std::vector;
using testing::InSequence;
@@ -306,7 +306,7 @@ TEST_F(CFI, BadId32) {
TEST_F(CFI, SingleCIE) {
CFISection section(kLittleEndian, 4);
section.CIEHeader(0xffe799a8, 0x3398dcdd, 0x6e9683de, 3, "");
section.Append(10, dwarf2reader::DW_CFA_nop);
section.Append(10, google_breakpad::DW_CFA_nop);
section.FinishEntry();
PERHAPS_WRITE_DEBUG_FRAME_FILE("SingleCIE", section);
@@ -763,7 +763,7 @@ struct CFIInsnFixture: public CFIFixture {
.Mark(&cie_label)
.CIEHeader(code_factor, data_factor, return_register, version,
"")
.D8(dwarf2reader::DW_CFA_def_cfa)
.D8(google_breakpad::DW_CFA_def_cfa)
.ULEB128(cfa_base_register)
.ULEB128(cfa_offset)
.FinishEntry();
@@ -788,7 +788,7 @@ struct CFIInsnFixture: public CFIFixture {
void ParseSection(CFISection *section, bool succeeds = true) {
string contents;
EXPECT_TRUE(section->GetContents(&contents));
dwarf2reader::Endianness endianness;
google_breakpad::Endianness endianness;
if (section->endianness() == kBigEndian)
endianness = ENDIANNESS_BIG;
else {
@@ -823,10 +823,10 @@ TEST_F(CFIInsn, DW_CFA_set_loc) {
CFISection section(kBigEndian, 4);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_set_loc).D32(0xb1ee3e7a)
.D8(google_breakpad::DW_CFA_set_loc).D32(0xb1ee3e7a)
// Use DW_CFA_def_cfa to force a handler call that we can use to
// check the effect of the DW_CFA_set_loc.
.D8(dwarf2reader::DW_CFA_def_cfa).ULEB128(0x4defb431).ULEB128(0x6d17b0ee)
.D8(google_breakpad::DW_CFA_def_cfa).ULEB128(0x4defb431).ULEB128(0x6d17b0ee)
.FinishEntry();
PERHAPS_WRITE_DEBUG_FRAME_FILE("DW_CFA_set_loc", section);
@@ -844,10 +844,10 @@ TEST_F(CFIInsn, DW_CFA_advance_loc) {
CFISection section(kBigEndian, 8);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_advance_loc | 0x2a)
.D8(google_breakpad::DW_CFA_advance_loc | 0x2a)
// Use DW_CFA_def_cfa to force a handler call that we can use to
// check the effect of the DW_CFA_advance_loc.
.D8(dwarf2reader::DW_CFA_def_cfa).ULEB128(0x5bbb3715).ULEB128(0x0186c7bf)
.D8(google_breakpad::DW_CFA_def_cfa).ULEB128(0x5bbb3715).ULEB128(0x0186c7bf)
.FinishEntry();
PERHAPS_WRITE_DEBUG_FRAME_FILE("DW_CFA_advance_loc", section);
@@ -866,8 +866,8 @@ TEST_F(CFIInsn, DW_CFA_advance_loc1) {
CFISection section(kLittleEndian, 8);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_advance_loc1).D8(0xd8)
.D8(dwarf2reader::DW_CFA_def_cfa).ULEB128(0x69d5696a).ULEB128(0x1eb7fc93)
.D8(google_breakpad::DW_CFA_advance_loc1).D8(0xd8)
.D8(google_breakpad::DW_CFA_def_cfa).ULEB128(0x69d5696a).ULEB128(0x1eb7fc93)
.FinishEntry();
PERHAPS_WRITE_DEBUG_FRAME_FILE("DW_CFA_advance_loc1", section);
@@ -886,8 +886,8 @@ TEST_F(CFIInsn, DW_CFA_advance_loc2) {
CFISection section(kLittleEndian, 4);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_advance_loc2).D16(0x3adb)
.D8(dwarf2reader::DW_CFA_def_cfa).ULEB128(0x3a368bed).ULEB128(0x3194ee37)
.D8(google_breakpad::DW_CFA_advance_loc2).D16(0x3adb)
.D8(google_breakpad::DW_CFA_def_cfa).ULEB128(0x3a368bed).ULEB128(0x3194ee37)
.FinishEntry();
PERHAPS_WRITE_DEBUG_FRAME_FILE("DW_CFA_advance_loc2", section);
@@ -906,8 +906,8 @@ TEST_F(CFIInsn, DW_CFA_advance_loc4) {
CFISection section(kBigEndian, 8);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_advance_loc4).D32(0x15813c88)
.D8(dwarf2reader::DW_CFA_def_cfa).ULEB128(0x135270c5).ULEB128(0x24bad7cb)
.D8(google_breakpad::DW_CFA_advance_loc4).D32(0x15813c88)
.D8(google_breakpad::DW_CFA_def_cfa).ULEB128(0x135270c5).ULEB128(0x24bad7cb)
.FinishEntry();
PERHAPS_WRITE_DEBUG_FRAME_FILE("DW_CFA_advance_loc4", section);
@@ -927,8 +927,8 @@ TEST_F(CFIInsn, DW_CFA_MIPS_advance_loc8) {
CFISection section(kBigEndian, 8);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_MIPS_advance_loc8).D64(0x3c4f3945b92c14ULL)
.D8(dwarf2reader::DW_CFA_def_cfa).ULEB128(0xe17ed602).ULEB128(0x3d162e7f)
.D8(google_breakpad::DW_CFA_MIPS_advance_loc8).D64(0x3c4f3945b92c14ULL)
.D8(google_breakpad::DW_CFA_def_cfa).ULEB128(0xe17ed602).ULEB128(0x3d162e7f)
.FinishEntry();
PERHAPS_WRITE_DEBUG_FRAME_FILE("DW_CFA_advance_loc8", section);
@@ -947,7 +947,7 @@ TEST_F(CFIInsn, DW_CFA_def_cfa) {
CFISection section(kLittleEndian, 4);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_def_cfa).ULEB128(0x4e363a85).ULEB128(0x815f9aa7)
.D8(google_breakpad::DW_CFA_def_cfa).ULEB128(0x4e363a85).ULEB128(0x815f9aa7)
.FinishEntry();
PERHAPS_WRITE_DEBUG_FRAME_FILE("DW_CFA_def_cfa", section);
@@ -964,8 +964,8 @@ TEST_F(CFIInsn, DW_CFA_def_cfa_sf) {
CFISection section(kBigEndian, 4);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_def_cfa_sf).ULEB128(0x8ccb32b7).LEB128(0x9ea)
.D8(dwarf2reader::DW_CFA_def_cfa_sf).ULEB128(0x9b40f5da).LEB128(-0x40a2)
.D8(google_breakpad::DW_CFA_def_cfa_sf).ULEB128(0x8ccb32b7).LEB128(0x9ea)
.D8(google_breakpad::DW_CFA_def_cfa_sf).ULEB128(0x9b40f5da).LEB128(-0x40a2)
.FinishEntry();
EXPECT_CALL(handler,
@@ -985,7 +985,7 @@ TEST_F(CFIInsn, DW_CFA_def_cfa_register) {
CFISection section(kLittleEndian, 8);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_def_cfa_register).ULEB128(0x3e7e9363)
.D8(google_breakpad::DW_CFA_def_cfa_register).ULEB128(0x3e7e9363)
.FinishEntry();
EXPECT_CALL(handler,
@@ -1002,8 +1002,8 @@ TEST_F(CFIInsn, DW_CFA_def_cfa_registerBadRule) {
CFISection section(kBigEndian, 4);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_def_cfa_expression).Block("needle in a haystack")
.D8(dwarf2reader::DW_CFA_def_cfa_register).ULEB128(0xf1b49e49)
.D8(google_breakpad::DW_CFA_def_cfa_expression).Block("needle in a haystack")
.D8(google_breakpad::DW_CFA_def_cfa_register).ULEB128(0xf1b49e49)
.FinishEntry();
EXPECT_CALL(handler,
@@ -1019,7 +1019,7 @@ TEST_F(CFIInsn, DW_CFA_def_cfa_offset) {
CFISection section(kBigEndian, 4);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_def_cfa_offset).ULEB128(0x1e8e3b9b)
.D8(google_breakpad::DW_CFA_def_cfa_offset).ULEB128(0x1e8e3b9b)
.FinishEntry();
EXPECT_CALL(handler,
@@ -1035,8 +1035,8 @@ TEST_F(CFIInsn, DW_CFA_def_cfa_offset_sf) {
CFISection section(kLittleEndian, 4);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_def_cfa_offset_sf).LEB128(0x970)
.D8(dwarf2reader::DW_CFA_def_cfa_offset_sf).LEB128(-0x2cd)
.D8(google_breakpad::DW_CFA_def_cfa_offset_sf).LEB128(0x970)
.D8(google_breakpad::DW_CFA_def_cfa_offset_sf).LEB128(-0x2cd)
.FinishEntry();
EXPECT_CALL(handler,
@@ -1058,8 +1058,8 @@ TEST_F(CFIInsn, DW_CFA_def_cfa_offsetBadRule) {
CFISection section(kBigEndian, 4);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_def_cfa_expression).Block("six ways to Sunday")
.D8(dwarf2reader::DW_CFA_def_cfa_offset).ULEB128(0x1e8e3b9b)
.D8(google_breakpad::DW_CFA_def_cfa_expression).Block("six ways to Sunday")
.D8(google_breakpad::DW_CFA_def_cfa_offset).ULEB128(0x1e8e3b9b)
.FinishEntry();
EXPECT_CALL(handler,
@@ -1074,7 +1074,7 @@ TEST_F(CFIInsn, DW_CFA_def_cfa_expression) {
CFISection section(kLittleEndian, 8);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_def_cfa_expression).Block("eating crow")
.D8(google_breakpad::DW_CFA_def_cfa_expression).Block("eating crow")
.FinishEntry();
EXPECT_CALL(handler, ValExpressionRule(fde_start, kCFARegister,
@@ -1089,7 +1089,7 @@ TEST_F(CFIInsn, DW_CFA_undefined) {
CFISection section(kLittleEndian, 4);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_undefined).ULEB128(0x300ce45d)
.D8(google_breakpad::DW_CFA_undefined).ULEB128(0x300ce45d)
.FinishEntry();
EXPECT_CALL(handler, UndefinedRule(fde_start, 0x300ce45d))
@@ -1103,7 +1103,7 @@ TEST_F(CFIInsn, DW_CFA_same_value) {
CFISection section(kLittleEndian, 4);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_same_value).ULEB128(0x3865a760)
.D8(google_breakpad::DW_CFA_same_value).ULEB128(0x3865a760)
.FinishEntry();
EXPECT_CALL(handler, SameValueRule(fde_start, 0x3865a760))
@@ -1117,7 +1117,7 @@ TEST_F(CFIInsn, DW_CFA_offset) {
CFISection section(kBigEndian, 4);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_offset | 0x2c).ULEB128(0x9f6)
.D8(google_breakpad::DW_CFA_offset | 0x2c).ULEB128(0x9f6)
.FinishEntry();
EXPECT_CALL(handler,
@@ -1132,7 +1132,7 @@ TEST_F(CFIInsn, DW_CFA_offset_extended) {
CFISection section(kBigEndian, 4);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_offset_extended).ULEB128(0x402b).ULEB128(0xb48)
.D8(google_breakpad::DW_CFA_offset_extended).ULEB128(0x402b).ULEB128(0xb48)
.FinishEntry();
EXPECT_CALL(handler,
@@ -1147,9 +1147,9 @@ TEST_F(CFIInsn, DW_CFA_offset_extended_sf) {
CFISection section(kBigEndian, 8);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_offset_extended_sf)
.D8(google_breakpad::DW_CFA_offset_extended_sf)
.ULEB128(0x997c23ee).LEB128(0x2d00)
.D8(dwarf2reader::DW_CFA_offset_extended_sf)
.D8(google_breakpad::DW_CFA_offset_extended_sf)
.ULEB128(0x9519eb82).LEB128(-0xa77)
.FinishEntry();
@@ -1170,7 +1170,7 @@ TEST_F(CFIInsn, DW_CFA_val_offset) {
CFISection section(kBigEndian, 4);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_val_offset).ULEB128(0x623562fe).ULEB128(0x673)
.D8(google_breakpad::DW_CFA_val_offset).ULEB128(0x623562fe).ULEB128(0x673)
.FinishEntry();
EXPECT_CALL(handler,
@@ -1186,8 +1186,8 @@ TEST_F(CFIInsn, DW_CFA_val_offset_sf) {
CFISection section(kBigEndian, 4);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_val_offset_sf).ULEB128(0x6f4f).LEB128(0xaab)
.D8(dwarf2reader::DW_CFA_val_offset_sf).ULEB128(0x2483).LEB128(-0x8a2)
.D8(google_breakpad::DW_CFA_val_offset_sf).ULEB128(0x6f4f).LEB128(0xaab)
.D8(google_breakpad::DW_CFA_val_offset_sf).ULEB128(0x2483).LEB128(-0x8a2)
.FinishEntry();
EXPECT_CALL(handler,
@@ -1207,7 +1207,7 @@ TEST_F(CFIInsn, DW_CFA_register) {
CFISection section(kLittleEndian, 8);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_register).ULEB128(0x278d18f9).ULEB128(0x1a684414)
.D8(google_breakpad::DW_CFA_register).ULEB128(0x278d18f9).ULEB128(0x1a684414)
.FinishEntry();
EXPECT_CALL(handler, RegisterRule(fde_start, 0x278d18f9, 0x1a684414))
@@ -1221,7 +1221,7 @@ TEST_F(CFIInsn, DW_CFA_expression) {
CFISection section(kBigEndian, 8);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_expression).ULEB128(0xa1619fb2)
.D8(google_breakpad::DW_CFA_expression).ULEB128(0xa1619fb2)
.Block("plus ça change, plus c'est la même chose")
.FinishEntry();
@@ -1238,7 +1238,7 @@ TEST_F(CFIInsn, DW_CFA_val_expression) {
CFISection section(kBigEndian, 4);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_val_expression).ULEB128(0xc5e4a9e3)
.D8(google_breakpad::DW_CFA_val_expression).ULEB128(0xc5e4a9e3)
.Block("he who has the gold makes the rules")
.FinishEntry();
@@ -1265,18 +1265,18 @@ TEST_F(CFIInsn, DW_CFA_restore) {
.CIEHeader(code_factor, data_factor, return_register, version,
"")
// Provide a CFA rule, because register rules require them.
.D8(dwarf2reader::DW_CFA_def_cfa).ULEB128(0x6ca1d50e).ULEB128(0x372e38e8)
.D8(google_breakpad::DW_CFA_def_cfa).ULEB128(0x6ca1d50e).ULEB128(0x372e38e8)
// Provide an offset(N) rule for register 0x3c.
.D8(dwarf2reader::DW_CFA_offset | 0x3c).ULEB128(0xb348)
.D8(google_breakpad::DW_CFA_offset | 0x3c).ULEB128(0xb348)
.FinishEntry()
// In the FDE...
.FDEHeader(cie, fde_start, fde_size)
// At a second address, provide a new offset(N) rule for register 0x3c.
.D8(dwarf2reader::DW_CFA_advance_loc | 0x13)
.D8(dwarf2reader::DW_CFA_offset | 0x3c).ULEB128(0x9a50)
.D8(google_breakpad::DW_CFA_advance_loc | 0x13)
.D8(google_breakpad::DW_CFA_offset | 0x3c).ULEB128(0x9a50)
// At a third address, restore the original rule for register 0x3c.
.D8(dwarf2reader::DW_CFA_advance_loc | 0x01)
.D8(dwarf2reader::DW_CFA_restore | 0x3c)
.D8(google_breakpad::DW_CFA_advance_loc | 0x01)
.D8(google_breakpad::DW_CFA_restore | 0x3c)
.FinishEntry();
{
@@ -1321,16 +1321,16 @@ TEST_F(CFIInsn, DW_CFA_restoreNoRule) {
.Mark(&cie)
.CIEHeader(code_factor, data_factor, return_register, version, "")
// Provide a CFA rule, because register rules require them.
.D8(dwarf2reader::DW_CFA_def_cfa).ULEB128(0x470aa334).ULEB128(0x099ef127)
.D8(google_breakpad::DW_CFA_def_cfa).ULEB128(0x470aa334).ULEB128(0x099ef127)
.FinishEntry()
// In the FDE...
.FDEHeader(cie, fde_start, fde_size)
// At a second address, provide an offset(N) rule for register 0x2c.
.D8(dwarf2reader::DW_CFA_advance_loc | 0x7)
.D8(dwarf2reader::DW_CFA_offset | 0x2c).ULEB128(0x1f47)
.D8(google_breakpad::DW_CFA_advance_loc | 0x7)
.D8(google_breakpad::DW_CFA_offset | 0x2c).ULEB128(0x1f47)
// At a third address, restore the (missing) CIE rule for register 0x2c.
.D8(dwarf2reader::DW_CFA_advance_loc | 0xb)
.D8(dwarf2reader::DW_CFA_restore | 0x2c)
.D8(google_breakpad::DW_CFA_advance_loc | 0xb)
.D8(google_breakpad::DW_CFA_restore | 0x2c)
.FinishEntry();
{
@@ -1371,20 +1371,20 @@ TEST_F(CFIInsn, DW_CFA_restore_extended) {
.CIEHeader(code_factor, data_factor, return_register, version,
"", true /* dwarf64 */ )
// Provide a CFA rule, because register rules require them.
.D8(dwarf2reader::DW_CFA_def_cfa).ULEB128(0x56fa0edd).ULEB128(0x097f78a5)
.D8(google_breakpad::DW_CFA_def_cfa).ULEB128(0x56fa0edd).ULEB128(0x097f78a5)
// Provide an offset(N) rule for register 0x0f9b8a1c.
.D8(dwarf2reader::DW_CFA_offset_extended)
.D8(google_breakpad::DW_CFA_offset_extended)
.ULEB128(0x0f9b8a1c).ULEB128(0xc979)
.FinishEntry()
// In the FDE...
.FDEHeader(cie, fde_start, fde_size)
// At a second address, provide a new offset(N) rule for reg 0x0f9b8a1c.
.D8(dwarf2reader::DW_CFA_advance_loc | 0x3)
.D8(dwarf2reader::DW_CFA_offset_extended)
.D8(google_breakpad::DW_CFA_advance_loc | 0x3)
.D8(google_breakpad::DW_CFA_offset_extended)
.ULEB128(0x0f9b8a1c).ULEB128(0x3b7b)
// At a third address, restore the original rule for register 0x0f9b8a1c.
.D8(dwarf2reader::DW_CFA_advance_loc | 0x04)
.D8(dwarf2reader::DW_CFA_restore_extended).ULEB128(0x0f9b8a1c)
.D8(google_breakpad::DW_CFA_advance_loc | 0x04)
.D8(google_breakpad::DW_CFA_restore_extended).ULEB128(0x0f9b8a1c)
.FinishEntry();
{
@@ -1433,21 +1433,21 @@ TEST_F(CFIInsn, DW_CFA_remember_and_restore_state) {
// 5 offset(N) no rule new "same value" rule
section
// Create the "incoming" state, which we will save and later restore.
.D8(dwarf2reader::DW_CFA_offset | 2).ULEB128(0x9806)
.D8(dwarf2reader::DW_CFA_offset | 3).ULEB128(0x995d)
.D8(dwarf2reader::DW_CFA_offset | 4).ULEB128(0x7055)
.D8(dwarf2reader::DW_CFA_remember_state)
.D8(google_breakpad::DW_CFA_offset | 2).ULEB128(0x9806)
.D8(google_breakpad::DW_CFA_offset | 3).ULEB128(0x995d)
.D8(google_breakpad::DW_CFA_offset | 4).ULEB128(0x7055)
.D8(google_breakpad::DW_CFA_remember_state)
// Advance to a new instruction; an implementation could legitimately
// ignore all but the final rule for a given register at a given address.
.D8(dwarf2reader::DW_CFA_advance_loc | 1)
.D8(google_breakpad::DW_CFA_advance_loc | 1)
// Create the "outgoing" state, which we will discard.
.D8(dwarf2reader::DW_CFA_offset | 1).ULEB128(0xea1a)
.D8(dwarf2reader::DW_CFA_register).ULEB128(2).ULEB128(0x1d2a3767)
.D8(dwarf2reader::DW_CFA_offset | 3).ULEB128(0xdd29)
.D8(dwarf2reader::DW_CFA_offset | 5).ULEB128(0xf1ce)
.D8(google_breakpad::DW_CFA_offset | 1).ULEB128(0xea1a)
.D8(google_breakpad::DW_CFA_register).ULEB128(2).ULEB128(0x1d2a3767)
.D8(google_breakpad::DW_CFA_offset | 3).ULEB128(0xdd29)
.D8(google_breakpad::DW_CFA_offset | 5).ULEB128(0xf1ce)
// At a third address, restore the incoming state.
.D8(dwarf2reader::DW_CFA_advance_loc | 1)
.D8(dwarf2reader::DW_CFA_restore_state)
.D8(google_breakpad::DW_CFA_advance_loc | 1)
.D8(google_breakpad::DW_CFA_restore_state)
.FinishEntry();
uint64_t addr = fde_start;
@@ -1496,11 +1496,11 @@ TEST_F(CFIInsn, DW_CFA_remember_and_restore_stateCFA) {
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_remember_state)
.D8(dwarf2reader::DW_CFA_advance_loc | 1)
.D8(dwarf2reader::DW_CFA_def_cfa_offset).ULEB128(0x90481102)
.D8(dwarf2reader::DW_CFA_advance_loc | 1)
.D8(dwarf2reader::DW_CFA_restore_state)
.D8(google_breakpad::DW_CFA_remember_state)
.D8(google_breakpad::DW_CFA_advance_loc | 1)
.D8(google_breakpad::DW_CFA_def_cfa_offset).ULEB128(0x90481102)
.D8(google_breakpad::DW_CFA_advance_loc | 1)
.D8(google_breakpad::DW_CFA_restore_state)
.FinishEntry();
EXPECT_CALL(handler, ValOffsetRule(fde_start + code_factor, kCFARegister,
@@ -1519,9 +1519,9 @@ TEST_F(CFIInsn, DW_CFA_nop) {
CFISection section(kLittleEndian, 4);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_nop)
.D8(dwarf2reader::DW_CFA_def_cfa).ULEB128(0x3fb8d4f1).ULEB128(0x078dc67b)
.D8(dwarf2reader::DW_CFA_nop)
.D8(google_breakpad::DW_CFA_nop)
.D8(google_breakpad::DW_CFA_def_cfa).ULEB128(0x3fb8d4f1).ULEB128(0x078dc67b)
.D8(google_breakpad::DW_CFA_nop)
.FinishEntry();
EXPECT_CALL(handler,
@@ -1536,7 +1536,7 @@ TEST_F(CFIInsn, DW_CFA_GNU_window_save) {
CFISection section(kBigEndian, 4);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_GNU_window_save)
.D8(google_breakpad::DW_CFA_GNU_window_save)
.FinishEntry();
// Don't include all the rules in any particular sequence.
@@ -1561,9 +1561,9 @@ TEST_F(CFIInsn, DW_CFA_GNU_args_size) {
CFISection section(kLittleEndian, 8);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_GNU_args_size).ULEB128(0xeddfa520)
.D8(google_breakpad::DW_CFA_GNU_args_size).ULEB128(0xeddfa520)
// Verify that we see this, meaning we parsed the above properly.
.D8(dwarf2reader::DW_CFA_offset | 0x23).ULEB128(0x269)
.D8(google_breakpad::DW_CFA_offset | 0x23).ULEB128(0x269)
.FinishEntry();
EXPECT_CALL(handler,
@@ -1578,7 +1578,7 @@ TEST_F(CFIInsn, DW_CFA_GNU_negative_offset_extended) {
CFISection section(kLittleEndian, 4);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_GNU_negative_offset_extended)
.D8(google_breakpad::DW_CFA_GNU_negative_offset_extended)
.ULEB128(0x430cc87a).ULEB128(0x613)
.FinishEntry();
@@ -1599,19 +1599,19 @@ TEST_F(CFIInsn, SkipFDE) {
// CIE, used by all FDEs.
.Mark(&cie)
.CIEHeader(0x010269f2, 0x9177, 0xedca5849, 2, "")
.D8(dwarf2reader::DW_CFA_def_cfa).ULEB128(0x42ed390b).ULEB128(0x98f43aad)
.D8(google_breakpad::DW_CFA_def_cfa).ULEB128(0x42ed390b).ULEB128(0x98f43aad)
.FinishEntry()
// First FDE.
.FDEHeader(cie, 0xa870ebdd, 0x60f6aa4)
.D8(dwarf2reader::DW_CFA_register).ULEB128(0x3a860351).ULEB128(0x6c9a6bcf)
.D8(google_breakpad::DW_CFA_register).ULEB128(0x3a860351).ULEB128(0x6c9a6bcf)
.FinishEntry()
// Second FDE.
.FDEHeader(cie, 0xc534f7c0, 0xf6552e9, true /* dwarf64 */)
.D8(dwarf2reader::DW_CFA_register).ULEB128(0x1b62c234).ULEB128(0x26586b18)
.D8(google_breakpad::DW_CFA_register).ULEB128(0x1b62c234).ULEB128(0x26586b18)
.FinishEntry()
// Third FDE.
.FDEHeader(cie, 0xf681cfc8, 0x7e4594e)
.D8(dwarf2reader::DW_CFA_register).ULEB128(0x26c53934).ULEB128(0x18eeb8a4)
.D8(google_breakpad::DW_CFA_register).ULEB128(0x26c53934).ULEB128(0x18eeb8a4)
.FinishEntry();
{
@@ -1652,8 +1652,8 @@ TEST_F(CFIInsn, QuitMidentry) {
CFISection section(kLittleEndian, 8);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_register).ULEB128(0xe0cf850d).ULEB128(0x15aab431)
.D8(dwarf2reader::DW_CFA_expression).ULEB128(0x46750aa5).Block("meat")
.D8(google_breakpad::DW_CFA_register).ULEB128(0xe0cf850d).ULEB128(0x15aab431)
.D8(google_breakpad::DW_CFA_expression).ULEB128(0x46750aa5).Block("meat")
.FinishEntry();
EXPECT_CALL(handler, RegisterRule(fde_start, 0xe0cf850d, 0x15aab431))
@@ -1670,10 +1670,10 @@ TEST_F(CFIRestore, RestoreUndefinedRuleUnchanged) {
CFISection section(kLittleEndian, 4);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_undefined).ULEB128(0x0bac878e)
.D8(dwarf2reader::DW_CFA_remember_state)
.D8(dwarf2reader::DW_CFA_advance_loc | 1)
.D8(dwarf2reader::DW_CFA_restore_state)
.D8(google_breakpad::DW_CFA_undefined).ULEB128(0x0bac878e)
.D8(google_breakpad::DW_CFA_remember_state)
.D8(google_breakpad::DW_CFA_advance_loc | 1)
.D8(google_breakpad::DW_CFA_restore_state)
.FinishEntry();
EXPECT_CALL(handler, UndefinedRule(fde_start, 0x0bac878e))
@@ -1687,12 +1687,12 @@ TEST_F(CFIRestore, RestoreUndefinedRuleChanged) {
CFISection section(kLittleEndian, 4);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_undefined).ULEB128(0x7dedff5f)
.D8(dwarf2reader::DW_CFA_remember_state)
.D8(dwarf2reader::DW_CFA_advance_loc | 1)
.D8(dwarf2reader::DW_CFA_same_value).ULEB128(0x7dedff5f)
.D8(dwarf2reader::DW_CFA_advance_loc | 1)
.D8(dwarf2reader::DW_CFA_restore_state)
.D8(google_breakpad::DW_CFA_undefined).ULEB128(0x7dedff5f)
.D8(google_breakpad::DW_CFA_remember_state)
.D8(google_breakpad::DW_CFA_advance_loc | 1)
.D8(google_breakpad::DW_CFA_same_value).ULEB128(0x7dedff5f)
.D8(google_breakpad::DW_CFA_advance_loc | 1)
.D8(google_breakpad::DW_CFA_restore_state)
.FinishEntry();
EXPECT_CALL(handler, UndefinedRule(fde_start, 0x7dedff5f))
@@ -1710,10 +1710,10 @@ TEST_F(CFIRestore, RestoreSameValueRuleUnchanged) {
CFISection section(kLittleEndian, 4);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_same_value).ULEB128(0xadbc9b3a)
.D8(dwarf2reader::DW_CFA_remember_state)
.D8(dwarf2reader::DW_CFA_advance_loc | 1)
.D8(dwarf2reader::DW_CFA_restore_state)
.D8(google_breakpad::DW_CFA_same_value).ULEB128(0xadbc9b3a)
.D8(google_breakpad::DW_CFA_remember_state)
.D8(google_breakpad::DW_CFA_advance_loc | 1)
.D8(google_breakpad::DW_CFA_restore_state)
.FinishEntry();
EXPECT_CALL(handler, SameValueRule(fde_start, 0xadbc9b3a))
@@ -1727,12 +1727,12 @@ TEST_F(CFIRestore, RestoreSameValueRuleChanged) {
CFISection section(kLittleEndian, 4);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_same_value).ULEB128(0x3d90dcb5)
.D8(dwarf2reader::DW_CFA_remember_state)
.D8(dwarf2reader::DW_CFA_advance_loc | 1)
.D8(dwarf2reader::DW_CFA_undefined).ULEB128(0x3d90dcb5)
.D8(dwarf2reader::DW_CFA_advance_loc | 1)
.D8(dwarf2reader::DW_CFA_restore_state)
.D8(google_breakpad::DW_CFA_same_value).ULEB128(0x3d90dcb5)
.D8(google_breakpad::DW_CFA_remember_state)
.D8(google_breakpad::DW_CFA_advance_loc | 1)
.D8(google_breakpad::DW_CFA_undefined).ULEB128(0x3d90dcb5)
.D8(google_breakpad::DW_CFA_advance_loc | 1)
.D8(google_breakpad::DW_CFA_restore_state)
.FinishEntry();
EXPECT_CALL(handler, SameValueRule(fde_start, 0x3d90dcb5))
@@ -1750,10 +1750,10 @@ TEST_F(CFIRestore, RestoreOffsetRuleUnchanged) {
CFISection section(kLittleEndian, 4);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_offset | 0x14).ULEB128(0xb6f)
.D8(dwarf2reader::DW_CFA_remember_state)
.D8(dwarf2reader::DW_CFA_advance_loc | 1)
.D8(dwarf2reader::DW_CFA_restore_state)
.D8(google_breakpad::DW_CFA_offset | 0x14).ULEB128(0xb6f)
.D8(google_breakpad::DW_CFA_remember_state)
.D8(google_breakpad::DW_CFA_advance_loc | 1)
.D8(google_breakpad::DW_CFA_restore_state)
.FinishEntry();
EXPECT_CALL(handler, OffsetRule(fde_start, 0x14,
@@ -1768,12 +1768,12 @@ TEST_F(CFIRestore, RestoreOffsetRuleChanged) {
CFISection section(kLittleEndian, 4);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_offset | 0x21).ULEB128(0xeb7)
.D8(dwarf2reader::DW_CFA_remember_state)
.D8(dwarf2reader::DW_CFA_advance_loc | 1)
.D8(dwarf2reader::DW_CFA_undefined).ULEB128(0x21)
.D8(dwarf2reader::DW_CFA_advance_loc | 1)
.D8(dwarf2reader::DW_CFA_restore_state)
.D8(google_breakpad::DW_CFA_offset | 0x21).ULEB128(0xeb7)
.D8(google_breakpad::DW_CFA_remember_state)
.D8(google_breakpad::DW_CFA_advance_loc | 1)
.D8(google_breakpad::DW_CFA_undefined).ULEB128(0x21)
.D8(google_breakpad::DW_CFA_advance_loc | 1)
.D8(google_breakpad::DW_CFA_restore_state)
.FinishEntry();
EXPECT_CALL(handler, OffsetRule(fde_start, 0x21,
@@ -1793,12 +1793,12 @@ TEST_F(CFIRestore, RestoreOffsetRuleChangedOffset) {
CFISection section(kLittleEndian, 4);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_offset | 0x21).ULEB128(0x134)
.D8(dwarf2reader::DW_CFA_remember_state)
.D8(dwarf2reader::DW_CFA_advance_loc | 1)
.D8(dwarf2reader::DW_CFA_offset | 0x21).ULEB128(0xf4f)
.D8(dwarf2reader::DW_CFA_advance_loc | 1)
.D8(dwarf2reader::DW_CFA_restore_state)
.D8(google_breakpad::DW_CFA_offset | 0x21).ULEB128(0x134)
.D8(google_breakpad::DW_CFA_remember_state)
.D8(google_breakpad::DW_CFA_advance_loc | 1)
.D8(google_breakpad::DW_CFA_offset | 0x21).ULEB128(0xf4f)
.D8(google_breakpad::DW_CFA_advance_loc | 1)
.D8(google_breakpad::DW_CFA_restore_state)
.FinishEntry();
EXPECT_CALL(handler, OffsetRule(fde_start, 0x21,
@@ -1819,10 +1819,10 @@ TEST_F(CFIRestore, RestoreValOffsetRuleUnchanged) {
CFISection section(kLittleEndian, 4);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_val_offset).ULEB128(0x829caee6).ULEB128(0xe4c)
.D8(dwarf2reader::DW_CFA_remember_state)
.D8(dwarf2reader::DW_CFA_advance_loc | 1)
.D8(dwarf2reader::DW_CFA_restore_state)
.D8(google_breakpad::DW_CFA_val_offset).ULEB128(0x829caee6).ULEB128(0xe4c)
.D8(google_breakpad::DW_CFA_remember_state)
.D8(google_breakpad::DW_CFA_advance_loc | 1)
.D8(google_breakpad::DW_CFA_restore_state)
.FinishEntry();
EXPECT_CALL(handler, ValOffsetRule(fde_start, 0x829caee6,
@@ -1837,12 +1837,12 @@ TEST_F(CFIRestore, RestoreValOffsetRuleChanged) {
CFISection section(kLittleEndian, 4);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_val_offset).ULEB128(0xf17c36d6).ULEB128(0xeb7)
.D8(dwarf2reader::DW_CFA_remember_state)
.D8(dwarf2reader::DW_CFA_advance_loc | 1)
.D8(dwarf2reader::DW_CFA_undefined).ULEB128(0xf17c36d6)
.D8(dwarf2reader::DW_CFA_advance_loc | 1)
.D8(dwarf2reader::DW_CFA_restore_state)
.D8(google_breakpad::DW_CFA_val_offset).ULEB128(0xf17c36d6).ULEB128(0xeb7)
.D8(google_breakpad::DW_CFA_remember_state)
.D8(google_breakpad::DW_CFA_advance_loc | 1)
.D8(google_breakpad::DW_CFA_undefined).ULEB128(0xf17c36d6)
.D8(google_breakpad::DW_CFA_advance_loc | 1)
.D8(google_breakpad::DW_CFA_restore_state)
.FinishEntry();
EXPECT_CALL(handler, ValOffsetRule(fde_start, 0xf17c36d6,
@@ -1862,12 +1862,12 @@ TEST_F(CFIRestore, RestoreValOffsetRuleChangedValOffset) {
CFISection section(kLittleEndian, 4);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_val_offset).ULEB128(0x2cf0ab1b).ULEB128(0x562)
.D8(dwarf2reader::DW_CFA_remember_state)
.D8(dwarf2reader::DW_CFA_advance_loc | 1)
.D8(dwarf2reader::DW_CFA_val_offset).ULEB128(0x2cf0ab1b).ULEB128(0xe88)
.D8(dwarf2reader::DW_CFA_advance_loc | 1)
.D8(dwarf2reader::DW_CFA_restore_state)
.D8(google_breakpad::DW_CFA_val_offset).ULEB128(0x2cf0ab1b).ULEB128(0x562)
.D8(google_breakpad::DW_CFA_remember_state)
.D8(google_breakpad::DW_CFA_advance_loc | 1)
.D8(google_breakpad::DW_CFA_val_offset).ULEB128(0x2cf0ab1b).ULEB128(0xe88)
.D8(google_breakpad::DW_CFA_advance_loc | 1)
.D8(google_breakpad::DW_CFA_restore_state)
.FinishEntry();
EXPECT_CALL(handler, ValOffsetRule(fde_start, 0x2cf0ab1b,
@@ -1888,10 +1888,10 @@ TEST_F(CFIRestore, RestoreRegisterRuleUnchanged) {
CFISection section(kLittleEndian, 4);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_register).ULEB128(0x77514acc).ULEB128(0x464de4ce)
.D8(dwarf2reader::DW_CFA_remember_state)
.D8(dwarf2reader::DW_CFA_advance_loc | 1)
.D8(dwarf2reader::DW_CFA_restore_state)
.D8(google_breakpad::DW_CFA_register).ULEB128(0x77514acc).ULEB128(0x464de4ce)
.D8(google_breakpad::DW_CFA_remember_state)
.D8(google_breakpad::DW_CFA_advance_loc | 1)
.D8(google_breakpad::DW_CFA_restore_state)
.FinishEntry();
EXPECT_CALL(handler, RegisterRule(fde_start, 0x77514acc, 0x464de4ce))
@@ -1905,12 +1905,12 @@ TEST_F(CFIRestore, RestoreRegisterRuleChanged) {
CFISection section(kLittleEndian, 4);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_register).ULEB128(0xe39acce5).ULEB128(0x095f1559)
.D8(dwarf2reader::DW_CFA_remember_state)
.D8(dwarf2reader::DW_CFA_advance_loc | 1)
.D8(dwarf2reader::DW_CFA_undefined).ULEB128(0xe39acce5)
.D8(dwarf2reader::DW_CFA_advance_loc | 1)
.D8(dwarf2reader::DW_CFA_restore_state)
.D8(google_breakpad::DW_CFA_register).ULEB128(0xe39acce5).ULEB128(0x095f1559)
.D8(google_breakpad::DW_CFA_remember_state)
.D8(google_breakpad::DW_CFA_advance_loc | 1)
.D8(google_breakpad::DW_CFA_undefined).ULEB128(0xe39acce5)
.D8(google_breakpad::DW_CFA_advance_loc | 1)
.D8(google_breakpad::DW_CFA_restore_state)
.FinishEntry();
EXPECT_CALL(handler, RegisterRule(fde_start, 0xe39acce5, 0x095f1559))
@@ -1929,12 +1929,12 @@ TEST_F(CFIRestore, RestoreRegisterRuleChangedRegister) {
CFISection section(kLittleEndian, 4);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_register).ULEB128(0xd40e21b1).ULEB128(0x16607d6a)
.D8(dwarf2reader::DW_CFA_remember_state)
.D8(dwarf2reader::DW_CFA_advance_loc | 1)
.D8(dwarf2reader::DW_CFA_register).ULEB128(0xd40e21b1).ULEB128(0xbabb4742)
.D8(dwarf2reader::DW_CFA_advance_loc | 1)
.D8(dwarf2reader::DW_CFA_restore_state)
.D8(google_breakpad::DW_CFA_register).ULEB128(0xd40e21b1).ULEB128(0x16607d6a)
.D8(google_breakpad::DW_CFA_remember_state)
.D8(google_breakpad::DW_CFA_advance_loc | 1)
.D8(google_breakpad::DW_CFA_register).ULEB128(0xd40e21b1).ULEB128(0xbabb4742)
.D8(google_breakpad::DW_CFA_advance_loc | 1)
.D8(google_breakpad::DW_CFA_restore_state)
.FinishEntry();
EXPECT_CALL(handler, RegisterRule(fde_start, 0xd40e21b1, 0x16607d6a))
@@ -1954,10 +1954,10 @@ TEST_F(CFIRestore, RestoreExpressionRuleUnchanged) {
CFISection section(kLittleEndian, 4);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_expression).ULEB128(0x666ae152).Block("dwarf")
.D8(dwarf2reader::DW_CFA_remember_state)
.D8(dwarf2reader::DW_CFA_advance_loc | 1)
.D8(dwarf2reader::DW_CFA_restore_state)
.D8(google_breakpad::DW_CFA_expression).ULEB128(0x666ae152).Block("dwarf")
.D8(google_breakpad::DW_CFA_remember_state)
.D8(google_breakpad::DW_CFA_advance_loc | 1)
.D8(google_breakpad::DW_CFA_restore_state)
.FinishEntry();
EXPECT_CALL(handler, ExpressionRule(fde_start, 0x666ae152, "dwarf"))
@@ -1971,12 +1971,12 @@ TEST_F(CFIRestore, RestoreExpressionRuleChanged) {
CFISection section(kLittleEndian, 4);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_expression).ULEB128(0xb5ca5c46).Block("elf")
.D8(dwarf2reader::DW_CFA_remember_state)
.D8(dwarf2reader::DW_CFA_advance_loc | 1)
.D8(dwarf2reader::DW_CFA_undefined).ULEB128(0xb5ca5c46)
.D8(dwarf2reader::DW_CFA_advance_loc | 1)
.D8(dwarf2reader::DW_CFA_restore_state)
.D8(google_breakpad::DW_CFA_expression).ULEB128(0xb5ca5c46).Block("elf")
.D8(google_breakpad::DW_CFA_remember_state)
.D8(google_breakpad::DW_CFA_advance_loc | 1)
.D8(google_breakpad::DW_CFA_undefined).ULEB128(0xb5ca5c46)
.D8(google_breakpad::DW_CFA_advance_loc | 1)
.D8(google_breakpad::DW_CFA_restore_state)
.FinishEntry();
EXPECT_CALL(handler, ExpressionRule(fde_start, 0xb5ca5c46, "elf"))
@@ -1995,12 +1995,12 @@ TEST_F(CFIRestore, RestoreExpressionRuleChangedExpression) {
CFISection section(kLittleEndian, 4);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_expression).ULEB128(0x500f5739).Block("smurf")
.D8(dwarf2reader::DW_CFA_remember_state)
.D8(dwarf2reader::DW_CFA_advance_loc | 1)
.D8(dwarf2reader::DW_CFA_expression).ULEB128(0x500f5739).Block("orc")
.D8(dwarf2reader::DW_CFA_advance_loc | 1)
.D8(dwarf2reader::DW_CFA_restore_state)
.D8(google_breakpad::DW_CFA_expression).ULEB128(0x500f5739).Block("smurf")
.D8(google_breakpad::DW_CFA_remember_state)
.D8(google_breakpad::DW_CFA_advance_loc | 1)
.D8(google_breakpad::DW_CFA_expression).ULEB128(0x500f5739).Block("orc")
.D8(google_breakpad::DW_CFA_advance_loc | 1)
.D8(google_breakpad::DW_CFA_restore_state)
.FinishEntry();
EXPECT_CALL(handler, ExpressionRule(fde_start, 0x500f5739, "smurf"))
@@ -2021,11 +2021,11 @@ TEST_F(CFIRestore, RestoreValExpressionRuleUnchanged) {
CFISection section(kLittleEndian, 4);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_val_expression).ULEB128(0x666ae152)
.D8(google_breakpad::DW_CFA_val_expression).ULEB128(0x666ae152)
.Block("hideous")
.D8(dwarf2reader::DW_CFA_remember_state)
.D8(dwarf2reader::DW_CFA_advance_loc | 1)
.D8(dwarf2reader::DW_CFA_restore_state)
.D8(google_breakpad::DW_CFA_remember_state)
.D8(google_breakpad::DW_CFA_advance_loc | 1)
.D8(google_breakpad::DW_CFA_restore_state)
.FinishEntry();
EXPECT_CALL(handler, ValExpressionRule(fde_start, 0x666ae152, "hideous"))
@@ -2039,13 +2039,13 @@ TEST_F(CFIRestore, RestoreValExpressionRuleChanged) {
CFISection section(kLittleEndian, 4);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_val_expression).ULEB128(0xb5ca5c46)
.D8(google_breakpad::DW_CFA_val_expression).ULEB128(0xb5ca5c46)
.Block("revolting")
.D8(dwarf2reader::DW_CFA_remember_state)
.D8(dwarf2reader::DW_CFA_advance_loc | 1)
.D8(dwarf2reader::DW_CFA_undefined).ULEB128(0xb5ca5c46)
.D8(dwarf2reader::DW_CFA_advance_loc | 1)
.D8(dwarf2reader::DW_CFA_restore_state)
.D8(google_breakpad::DW_CFA_remember_state)
.D8(google_breakpad::DW_CFA_advance_loc | 1)
.D8(google_breakpad::DW_CFA_undefined).ULEB128(0xb5ca5c46)
.D8(google_breakpad::DW_CFA_advance_loc | 1)
.D8(google_breakpad::DW_CFA_restore_state)
.FinishEntry();
PERHAPS_WRITE_DEBUG_FRAME_FILE("RestoreValExpressionRuleChanged", section);
@@ -2066,14 +2066,14 @@ TEST_F(CFIRestore, RestoreValExpressionRuleChangedValExpression) {
CFISection section(kLittleEndian, 4);
StockCIEAndFDE(&section);
section
.D8(dwarf2reader::DW_CFA_val_expression).ULEB128(0x500f5739)
.D8(google_breakpad::DW_CFA_val_expression).ULEB128(0x500f5739)
.Block("repulsive")
.D8(dwarf2reader::DW_CFA_remember_state)
.D8(dwarf2reader::DW_CFA_advance_loc | 1)
.D8(dwarf2reader::DW_CFA_val_expression).ULEB128(0x500f5739)
.D8(google_breakpad::DW_CFA_remember_state)
.D8(google_breakpad::DW_CFA_advance_loc | 1)
.D8(google_breakpad::DW_CFA_val_expression).ULEB128(0x500f5739)
.Block("nauseous")
.D8(dwarf2reader::DW_CFA_advance_loc | 1)
.D8(dwarf2reader::DW_CFA_restore_state)
.D8(google_breakpad::DW_CFA_advance_loc | 1)
.D8(google_breakpad::DW_CFA_restore_state)
.FinishEntry();
PERHAPS_WRITE_DEBUG_FRAME_FILE("RestoreValExpressionRuleChangedValExpression",
@@ -2110,7 +2110,7 @@ struct EHFrameFixture: public CFIInsnFixture {
EXPECT_TRUE(section->ContainsEHFrame());
string contents;
EXPECT_TRUE(section->GetContents(&contents));
dwarf2reader::Endianness endianness;
google_breakpad::Endianness endianness;
if (section->endianness() == kBigEndian)
endianness = ENDIANNESS_BIG;
else {
@@ -2142,11 +2142,11 @@ TEST_F(EHFrame, Terminator) {
section
.Mark(&cie)
.CIEHeader(9968, 2466, 67, 1, "")
.D8(dwarf2reader::DW_CFA_def_cfa).ULEB128(3772).ULEB128(1372)
.D8(google_breakpad::DW_CFA_def_cfa).ULEB128(3772).ULEB128(1372)
.FinishEntry()
.FDEHeader(cie, 0x848037a1, 0x7b30475e)
.D8(dwarf2reader::DW_CFA_set_loc).D32(0x17713850)
.D8(dwarf2reader::DW_CFA_undefined).ULEB128(5721)
.D8(google_breakpad::DW_CFA_set_loc).D32(0x17713850)
.D8(google_breakpad::DW_CFA_undefined).ULEB128(5721)
.FinishEntry()
.D32(0) // Terminate the sequence.
// This FDE should be ignored.
@@ -2172,12 +2172,12 @@ TEST_F(EHFrame, Terminator) {
// The parser should recognize the Linux Standards Base 'z' augmentations.
TEST_F(EHFrame, SimpleFDE) {
DwarfPointerEncoding lsda_encoding =
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_indirect
| dwarf2reader::DW_EH_PE_datarel
| dwarf2reader::DW_EH_PE_sdata2);
DwarfPointerEncoding(google_breakpad::DW_EH_PE_indirect
| google_breakpad::DW_EH_PE_datarel
| google_breakpad::DW_EH_PE_sdata2);
DwarfPointerEncoding fde_encoding =
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_textrel
| dwarf2reader::DW_EH_PE_udata2);
DwarfPointerEncoding(google_breakpad::DW_EH_PE_textrel
| google_breakpad::DW_EH_PE_udata2);
section.SetPointerEncoding(fde_encoding);
section.SetEncodedPointerBases(encoded_pointer_bases);
@@ -2187,17 +2187,17 @@ TEST_F(EHFrame, SimpleFDE) {
.CIEHeader(4873, 7012, 100, 1, "zSLPR")
.ULEB128(7) // Augmentation data length
.D8(lsda_encoding) // LSDA pointer format
.D8(dwarf2reader::DW_EH_PE_pcrel) // personality pointer format
.EncodedPointer(0x97baa00, dwarf2reader::DW_EH_PE_pcrel) // and value
.D8(google_breakpad::DW_EH_PE_pcrel) // personality pointer format
.EncodedPointer(0x97baa00, google_breakpad::DW_EH_PE_pcrel) // and value
.D8(fde_encoding) // FDE pointer format
.D8(dwarf2reader::DW_CFA_def_cfa).ULEB128(6706).ULEB128(31)
.D8(google_breakpad::DW_CFA_def_cfa).ULEB128(6706).ULEB128(31)
.FinishEntry()
.FDEHeader(cie, 0x540f6b56, 0xf686)
.ULEB128(2) // Augmentation data length
.EncodedPointer(0xe3eab475, lsda_encoding) // LSDA pointer, signed
.D8(dwarf2reader::DW_CFA_set_loc)
.D8(google_breakpad::DW_CFA_set_loc)
.EncodedPointer(0x540fa4ce, fde_encoding)
.D8(dwarf2reader::DW_CFA_undefined).ULEB128(0x675e)
.D8(google_breakpad::DW_CFA_undefined).ULEB128(0x675e)
.FinishEntry()
.D32(0); // terminator
@@ -2228,12 +2228,12 @@ TEST_F(EHFrame, EmptyZ) {
.Mark(&cie)
.CIEHeader(5955, 5805, 228, 1, "z")
.ULEB128(0) // Augmentation data length
.D8(dwarf2reader::DW_CFA_def_cfa).ULEB128(3629).ULEB128(247)
.D8(google_breakpad::DW_CFA_def_cfa).ULEB128(3629).ULEB128(247)
.FinishEntry()
.FDEHeader(cie, 0xda007738, 0xfb55c641)
.ULEB128(0) // Augmentation data length
.D8(dwarf2reader::DW_CFA_advance_loc1).D8(11)
.D8(dwarf2reader::DW_CFA_undefined).ULEB128(3769)
.D8(google_breakpad::DW_CFA_advance_loc1).D8(11)
.D8(google_breakpad::DW_CFA_undefined).ULEB128(3769)
.FinishEntry();
PERHAPS_WRITE_EH_FRAME_FILE("EHFrame.EmptyZ", section);
@@ -2257,12 +2257,12 @@ TEST_F(EHFrame, BadZ) {
.Mark(&cie)
.CIEHeader(6937, 1045, 142, 1, "zQ")
.ULEB128(0) // Augmentation data length
.D8(dwarf2reader::DW_CFA_def_cfa).ULEB128(9006).ULEB128(7725)
.D8(google_breakpad::DW_CFA_def_cfa).ULEB128(9006).ULEB128(7725)
.FinishEntry()
.FDEHeader(cie, 0x1293efa8, 0x236f53f2)
.ULEB128(0) // Augmentation data length
.D8(dwarf2reader::DW_CFA_advance_loc | 12)
.D8(dwarf2reader::DW_CFA_register).ULEB128(5667).ULEB128(3462)
.D8(google_breakpad::DW_CFA_advance_loc | 12)
.D8(google_breakpad::DW_CFA_register).ULEB128(5667).ULEB128(3462)
.FinishEntry();
PERHAPS_WRITE_EH_FRAME_FILE("EHFrame.BadZ", section);
@@ -2276,8 +2276,8 @@ TEST_F(EHFrame, BadZ) {
TEST_F(EHFrame, zL) {
Label cie;
DwarfPointerEncoding lsda_encoding =
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_funcrel
| dwarf2reader::DW_EH_PE_udata2);
DwarfPointerEncoding(google_breakpad::DW_EH_PE_funcrel
| google_breakpad::DW_EH_PE_udata2);
section
.Mark(&cie)
.CIEHeader(9285, 9959, 54, 1, "zL")
@@ -2306,8 +2306,8 @@ TEST_F(EHFrame, zL) {
TEST_F(EHFrame, zP) {
Label cie;
DwarfPointerEncoding personality_encoding =
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_datarel
| dwarf2reader::DW_EH_PE_udata2);
DwarfPointerEncoding(google_breakpad::DW_EH_PE_datarel
| google_breakpad::DW_EH_PE_udata2);
section
.Mark(&cie)
.CIEHeader(1097, 6313, 17, 1, "zP")
@@ -2335,8 +2335,8 @@ TEST_F(EHFrame, zP) {
TEST_F(EHFrame, zR) {
Label cie;
DwarfPointerEncoding pointer_encoding =
DwarfPointerEncoding(dwarf2reader::DW_EH_PE_textrel
| dwarf2reader::DW_EH_PE_sdata2);
DwarfPointerEncoding(google_breakpad::DW_EH_PE_textrel
| google_breakpad::DW_EH_PE_sdata2);
section.SetPointerEncoding(pointer_encoding);
section
.Mark(&cie)

184
src/common/dwarf/dwarf2reader_die_unittest.cc
View File

@@ -29,7 +29,7 @@
// Original author: Jim Blandy <jimb@mozilla.com> <jimb@red-bean.com>
// dwarf2reader_die_unittest.cc: Unit tests for dwarf2reader::CompilationUnit
// dwarf2reader_die_unittest.cc: Unit tests for google_breakpad::CompilationUnit
#include <stdint.h>
#include <stdlib.h>
@@ -51,16 +51,16 @@ using google_breakpad::test_assembler::Section;
using google_breakpad::test_assembler::kBigEndian;
using google_breakpad::test_assembler::kLittleEndian;
using dwarf2reader::ByteReader;
using dwarf2reader::CompilationUnit;
using dwarf2reader::Dwarf2Handler;
using dwarf2reader::DwarfAttribute;
using dwarf2reader::DwarfForm;
using dwarf2reader::DwarfHasChild;
using dwarf2reader::DwarfTag;
using dwarf2reader::ENDIANNESS_BIG;
using dwarf2reader::ENDIANNESS_LITTLE;
using dwarf2reader::SectionMap;
using google_breakpad::ByteReader;
using google_breakpad::CompilationUnit;
using google_breakpad::Dwarf2Handler;
using google_breakpad::DwarfAttribute;
using google_breakpad::DwarfForm;
using google_breakpad::DwarfHasChild;
using google_breakpad::DwarfTag;
using google_breakpad::ENDIANNESS_BIG;
using google_breakpad::ENDIANNESS_LITTLE;
using google_breakpad::SectionMap;
using std::vector;
using testing::InSequence;
@@ -168,9 +168,9 @@ class DwarfHeader: public DIEFixture,
TEST_P(DwarfHeader, Header) {
Label abbrev_table = abbrevs.Here();
abbrevs.Abbrev(1, dwarf2reader::DW_TAG_compile_unit,
dwarf2reader::DW_children_yes)
.Attribute(dwarf2reader::DW_AT_name, dwarf2reader::DW_FORM_string)
abbrevs.Abbrev(1, google_breakpad::DW_TAG_compile_unit,
google_breakpad::DW_children_yes)
.Attribute(google_breakpad::DW_AT_name, google_breakpad::DW_FORM_string)
.EndAbbrev()
.EndTable();
@@ -178,7 +178,7 @@ TEST_P(DwarfHeader, Header) {
info.set_endianness(GetParam().endianness);
info.Header(GetParam().version, abbrev_table, GetParam().address_size,
dwarf2reader::DW_UT_compile)
google_breakpad::DW_UT_compile)
.ULEB128(1) // DW_TAG_compile_unit, with children
.AppendCString("sam") // DW_AT_name, DW_FORM_string
.D8(0); // end of children
@@ -191,10 +191,10 @@ TEST_P(DwarfHeader, Header) {
GetParam().format_size, _,
GetParam().version))
.WillOnce(Return(true));
EXPECT_CALL(handler, StartDIE(_, dwarf2reader::DW_TAG_compile_unit))
EXPECT_CALL(handler, StartDIE(_, google_breakpad::DW_TAG_compile_unit))
.WillOnce(Return(true));
EXPECT_CALL(handler, ProcessAttributeString(_, dwarf2reader::DW_AT_name,
dwarf2reader::DW_FORM_string,
EXPECT_CALL(handler, ProcessAttributeString(_, google_breakpad::DW_AT_name,
google_breakpad::DW_FORM_string,
"sam"))
.WillOnce(Return());
EXPECT_CALL(handler, EndDIE(_))
@@ -210,9 +210,9 @@ TEST_P(DwarfHeader, Header) {
TEST_P(DwarfHeader, TypeUnitHeader) {
Label abbrev_table = abbrevs.Here();
int version = 5;
abbrevs.Abbrev(1, dwarf2reader::DW_TAG_type_unit,
dwarf2reader::DW_children_yes)
.Attribute(dwarf2reader::DW_AT_name, dwarf2reader::DW_FORM_string)
abbrevs.Abbrev(1, google_breakpad::DW_TAG_type_unit,
google_breakpad::DW_children_yes)
.Attribute(google_breakpad::DW_AT_name, google_breakpad::DW_FORM_string)
.EndAbbrev()
.EndTable();
@@ -220,7 +220,7 @@ TEST_P(DwarfHeader, TypeUnitHeader) {
info.set_endianness(GetParam().endianness);
info.Header(version, abbrev_table, GetParam().address_size,
dwarf2reader::DW_UT_type)
google_breakpad::DW_UT_type)
.ULEB128(0x41) // DW_TAG_type_unit, with children
.AppendCString("sam") // DW_AT_name, DW_FORM_string
.D8(0); // end of children
@@ -234,10 +234,10 @@ TEST_P(DwarfHeader, TypeUnitHeader) {
version))
.WillOnce(Return(true));
// If the type unit is handled properly, these calls will be skipped.
EXPECT_CALL(handler, StartDIE(_, dwarf2reader::DW_TAG_type_unit))
EXPECT_CALL(handler, StartDIE(_, google_breakpad::DW_TAG_type_unit))
.Times(0);
EXPECT_CALL(handler, ProcessAttributeString(_, dwarf2reader::DW_AT_name,
dwarf2reader::DW_FORM_string,
EXPECT_CALL(handler, ProcessAttributeString(_, google_breakpad::DW_AT_name,
google_breakpad::DW_FORM_string,
"sam"))
.Times(0);
EXPECT_CALL(handler, EndDIE(_))
@@ -291,7 +291,7 @@ struct DwarfFormsFixture: public DIEFixture {
DwarfForm form) {
// Create the abbreviation table.
Label abbrev_table = abbrevs.Here();
abbrevs.Abbrev(1, tag, dwarf2reader::DW_children_no)
abbrevs.Abbrev(1, tag, google_breakpad::DW_children_no)
.Attribute(name, form)
.EndAbbrev()
.EndTable();
@@ -300,7 +300,7 @@ struct DwarfFormsFixture: public DIEFixture {
info.set_format_size(params.format_size);
info.set_endianness(params.endianness);
info.Header(params.version, abbrev_table, params.address_size,
dwarf2reader::DW_UT_compile)
google_breakpad::DW_UT_compile)
.ULEB128(1); // abbrev code
}
@@ -342,9 +342,9 @@ struct DwarfForms: public DwarfFormsFixture,
public TestWithParam<DwarfHeaderParams> { };
TEST_P(DwarfForms, addr) {
StartSingleAttributeDIE(GetParam(), dwarf2reader::DW_TAG_compile_unit,
dwarf2reader::DW_AT_low_pc,
dwarf2reader::DW_FORM_addr);
StartSingleAttributeDIE(GetParam(), google_breakpad::DW_TAG_compile_unit,
google_breakpad::DW_AT_low_pc,
google_breakpad::DW_FORM_addr);
uint64_t value;
if (GetParam().address_size == 4) {
value = 0xc8e9ffcc;
@@ -355,9 +355,9 @@ TEST_P(DwarfForms, addr) {
}
info.Finish();
ExpectBeginCompilationUnit(GetParam(), dwarf2reader::DW_TAG_compile_unit);
EXPECT_CALL(handler, ProcessAttributeUnsigned(_, dwarf2reader::DW_AT_low_pc,
dwarf2reader::DW_FORM_addr,
ExpectBeginCompilationUnit(GetParam(), google_breakpad::DW_TAG_compile_unit);
EXPECT_CALL(handler, ProcessAttributeUnsigned(_, google_breakpad::DW_AT_low_pc,
google_breakpad::DW_FORM_addr,
value))
.InSequence(s)
.WillOnce(Return());
@@ -371,19 +371,19 @@ TEST_P(DwarfForms, strx1) {
return;
}
Label abbrev_table = abbrevs.Here();
abbrevs.Abbrev(1, dwarf2reader::DW_TAG_compile_unit,
dwarf2reader::DW_children_no)
.Attribute(dwarf2reader::DW_AT_name, dwarf2reader::DW_FORM_strx1)
.Attribute(dwarf2reader::DW_AT_low_pc, dwarf2reader::DW_FORM_addr)
.Attribute(dwarf2reader::DW_AT_str_offsets_base,
dwarf2reader::DW_FORM_sec_offset)
abbrevs.Abbrev(1, google_breakpad::DW_TAG_compile_unit,
google_breakpad::DW_children_no)
.Attribute(google_breakpad::DW_AT_name, google_breakpad::DW_FORM_strx1)
.Attribute(google_breakpad::DW_AT_low_pc, google_breakpad::DW_FORM_addr)
.Attribute(google_breakpad::DW_AT_str_offsets_base,
google_breakpad::DW_FORM_sec_offset)
.EndAbbrev()
.EndTable();
info.set_format_size(GetParam().format_size);
info.set_endianness(GetParam().endianness);
info.Header(GetParam().version, abbrev_table, GetParam().address_size,
dwarf2reader::DW_UT_compile)
google_breakpad::DW_UT_compile)
.ULEB128(1) // abbrev index
.D8(2); // string index
@@ -435,13 +435,13 @@ TEST_P(DwarfForms, strx1) {
}
ExpectBeginCompilationUnit(GetParam(), dwarf2reader::DW_TAG_compile_unit);
EXPECT_CALL(handler, ProcessAttributeString(_, dwarf2reader::DW_AT_name,
dwarf2reader::DW_FORM_strx1,
ExpectBeginCompilationUnit(GetParam(), google_breakpad::DW_TAG_compile_unit);
EXPECT_CALL(handler, ProcessAttributeString(_, google_breakpad::DW_AT_name,
google_breakpad::DW_FORM_strx1,
"bird"))
.WillOnce(Return());
EXPECT_CALL(handler, ProcessAttributeUnsigned(_, dwarf2reader::DW_AT_low_pc,
dwarf2reader::DW_FORM_addr,
EXPECT_CALL(handler, ProcessAttributeUnsigned(_, google_breakpad::DW_AT_low_pc,
google_breakpad::DW_FORM_addr,
value))
.InSequence(s)
.WillOnce(Return());
@@ -453,13 +453,13 @@ TEST_P(DwarfForms, strx1) {
TEST_P(DwarfForms, block2_empty) {
StartSingleAttributeDIE(GetParam(), (DwarfTag) 0x16e4d2f7,
(DwarfAttribute) 0xe52c4463,
dwarf2reader::DW_FORM_block2);
google_breakpad::DW_FORM_block2);
info.D16(0);
info.Finish();
ExpectBeginCompilationUnit(GetParam(), (DwarfTag) 0x16e4d2f7);
EXPECT_CALL(handler, ProcessAttributeBuffer(_, (DwarfAttribute) 0xe52c4463,
dwarf2reader::DW_FORM_block2,
google_breakpad::DW_FORM_block2,
_, 0))
.InSequence(s)
.WillOnce(Return());
@@ -471,7 +471,7 @@ TEST_P(DwarfForms, block2_empty) {
TEST_P(DwarfForms, block2) {
StartSingleAttributeDIE(GetParam(), (DwarfTag) 0x16e4d2f7,
(DwarfAttribute) 0xe52c4463,
dwarf2reader::DW_FORM_block2);
google_breakpad::DW_FORM_block2);
unsigned char data[258];
memset(data, '*', sizeof(data));
info.D16(sizeof(data))
@@ -480,7 +480,7 @@ TEST_P(DwarfForms, block2) {
ExpectBeginCompilationUnit(GetParam(), (DwarfTag) 0x16e4d2f7);
EXPECT_CALL(handler, ProcessAttributeBuffer(_, (DwarfAttribute) 0xe52c4463,
dwarf2reader::DW_FORM_block2,
google_breakpad::DW_FORM_block2,
Pointee('*'), 258))
.InSequence(s)
.WillOnce(Return());
@@ -492,14 +492,14 @@ TEST_P(DwarfForms, block2) {
TEST_P(DwarfForms, flag_present) {
StartSingleAttributeDIE(GetParam(), (DwarfTag) 0x3e449ac2,
(DwarfAttribute) 0x359d1972,
dwarf2reader::DW_FORM_flag_present);
google_breakpad::DW_FORM_flag_present);
// DW_FORM_flag_present occupies no space in the DIE.
info.Finish();
ExpectBeginCompilationUnit(GetParam(), (DwarfTag) 0x3e449ac2);
EXPECT_CALL(handler,
ProcessAttributeUnsigned(_, (DwarfAttribute) 0x359d1972,
dwarf2reader::DW_FORM_flag_present,
google_breakpad::DW_FORM_flag_present,
1))
.InSequence(s)
.WillOnce(Return());
@@ -511,7 +511,7 @@ TEST_P(DwarfForms, flag_present) {
TEST_P(DwarfForms, sec_offset) {
StartSingleAttributeDIE(GetParam(), (DwarfTag) 0x1d971689,
(DwarfAttribute) 0xa060bfd1,
dwarf2reader::DW_FORM_sec_offset);
google_breakpad::DW_FORM_sec_offset);
uint64_t value;
if (GetParam().format_size == 4) {
value = 0xacc9c388;
@@ -524,7 +524,7 @@ TEST_P(DwarfForms, sec_offset) {
ExpectBeginCompilationUnit(GetParam(), (DwarfTag) 0x1d971689);
EXPECT_CALL(handler, ProcessAttributeUnsigned(_, (DwarfAttribute) 0xa060bfd1,
dwarf2reader::DW_FORM_sec_offset,
google_breakpad::DW_FORM_sec_offset,
value))
.InSequence(s)
.WillOnce(Return());
@@ -536,14 +536,14 @@ TEST_P(DwarfForms, sec_offset) {
TEST_P(DwarfForms, exprloc) {
StartSingleAttributeDIE(GetParam(), (DwarfTag) 0xb6d167bb,
(DwarfAttribute) 0xba3ae5cb,
dwarf2reader::DW_FORM_exprloc);
google_breakpad::DW_FORM_exprloc);
info.ULEB128(29)
.Append(29, 173);
info.Finish();
ExpectBeginCompilationUnit(GetParam(), (DwarfTag) 0xb6d167bb);
EXPECT_CALL(handler, ProcessAttributeBuffer(_, (DwarfAttribute) 0xba3ae5cb,
dwarf2reader::DW_FORM_exprloc,
google_breakpad::DW_FORM_exprloc,
Pointee(173), 29))
.InSequence(s)
.WillOnce(Return());
@@ -555,13 +555,13 @@ TEST_P(DwarfForms, exprloc) {
TEST_P(DwarfForms, ref_sig8) {
StartSingleAttributeDIE(GetParam(), (DwarfTag) 0x253e7b2b,
(DwarfAttribute) 0xd708d908,
dwarf2reader::DW_FORM_ref_sig8);
google_breakpad::DW_FORM_ref_sig8);
info.D64(0xf72fa0cb6ddcf9d6ULL);
info.Finish();
ExpectBeginCompilationUnit(GetParam(), (DwarfTag) 0x253e7b2b);
EXPECT_CALL(handler, ProcessAttributeSignature(_, (DwarfAttribute) 0xd708d908,
dwarf2reader::DW_FORM_ref_sig8,
google_breakpad::DW_FORM_ref_sig8,
0xf72fa0cb6ddcf9d6ULL))
.InSequence(s)
.WillOnce(Return());
@@ -579,13 +579,13 @@ TEST_P(DwarfForms, ref_sig8_not_first) {
info.Append(98, '*');
StartSingleAttributeDIE(GetParam(), (DwarfTag) 0x253e7b2b,
(DwarfAttribute) 0xd708d908,
dwarf2reader::DW_FORM_ref_sig8);
google_breakpad::DW_FORM_ref_sig8);
info.D64(0xf72fa0cb6ddcf9d6ULL);
info.Finish();
ExpectBeginCompilationUnit(GetParam(), (DwarfTag) 0x253e7b2b, 98);
EXPECT_CALL(handler, ProcessAttributeSignature(_, (DwarfAttribute) 0xd708d908,
dwarf2reader::DW_FORM_ref_sig8,
google_breakpad::DW_FORM_ref_sig8,
0xf72fa0cb6ddcf9d6ULL))
.InSequence(s)
.WillOnce(Return());
@@ -599,23 +599,23 @@ TEST_P(DwarfForms, implicit_const) {
const uint64_t implicit_constant_value = 0x1234;
// Create the abbreviation table.
Label abbrev_table = abbrevs.Here();
abbrevs.Abbrev(1, (DwarfTag) 0x253e7b2b, dwarf2reader::DW_children_no)
abbrevs.Abbrev(1, (DwarfTag) 0x253e7b2b, google_breakpad::DW_children_no)
.Attribute((DwarfAttribute) 0xd708d908,
dwarf2reader::DW_FORM_implicit_const)
google_breakpad::DW_FORM_implicit_const)
.ULEB128(implicit_constant_value);
abbrevs.EndAbbrev().EndTable();
info.set_format_size(params.format_size);
info.set_endianness(params.endianness);
info.Header(params.version, abbrev_table, params.address_size,
dwarf2reader::DW_UT_compile)
google_breakpad::DW_UT_compile)
.ULEB128(1); // abbrev code
info.Finish();
ExpectBeginCompilationUnit(GetParam(), (DwarfTag) 0x253e7b2b);
EXPECT_CALL(handler,
ProcessAttributeUnsigned(_, (DwarfAttribute) 0xd708d908,
dwarf2reader::DW_FORM_implicit_const,
google_breakpad::DW_FORM_implicit_const,
implicit_constant_value))
.InSequence(s)
.WillOnce(Return());
@@ -653,15 +653,15 @@ INSTANTIATE_TEST_SUITE_P(
DwarfHeaderParams(kBigEndian, 8, 4, 4, 1),
DwarfHeaderParams(kBigEndian, 8, 4, 8, 1)));
class MockRangeListHandler: public dwarf2reader::RangeListHandler {
class MockRangeListHandler: public google_breakpad::RangeListHandler {
public:
MOCK_METHOD(void, AddRange, (uint64_t begin, uint64_t end));
MOCK_METHOD(void, Finish, ());
};
TEST(RangeList, Dwarf4ReadRangeList) {
using dwarf2reader::RangeListReader;
using dwarf2reader::DW_FORM_sec_offset;
using google_breakpad::RangeListReader;
using google_breakpad::DW_FORM_sec_offset;
// Create a dwarf4 .debug_ranges section.
google_breakpad::test_assembler::Section ranges(kBigEndian);
@@ -688,7 +688,7 @@ TEST(RangeList, Dwarf4ReadRangeList) {
cu_info.size_ = section_contents.size();
MockRangeListHandler handler;
dwarf2reader::RangeListReader range_list_reader(&byte_reader, &cu_info,
google_breakpad::RangeListReader range_list_reader(&byte_reader, &cu_info,
&handler);
EXPECT_CALL(handler, AddRange(2, 3));
EXPECT_CALL(handler, AddRange(4, 5));
@@ -699,17 +699,17 @@ TEST(RangeList, Dwarf4ReadRangeList) {
}
TEST(RangeList, Dwarf5ReadRangeList_rnglists) {
using dwarf2reader::RangeListReader;
using dwarf2reader::DW_RLE_base_addressx;
using dwarf2reader::DW_RLE_startx_endx;
using dwarf2reader::DW_RLE_startx_length;
using dwarf2reader::DW_RLE_offset_pair;
using dwarf2reader::DW_RLE_end_of_list;
using dwarf2reader::DW_RLE_base_address;
using dwarf2reader::DW_RLE_start_end;
using dwarf2reader::DW_RLE_start_length;
using dwarf2reader::DW_FORM_sec_offset;
using dwarf2reader::DW_FORM_rnglistx;
using google_breakpad::RangeListReader;
using google_breakpad::DW_RLE_base_addressx;
using google_breakpad::DW_RLE_startx_endx;
using google_breakpad::DW_RLE_startx_length;
using google_breakpad::DW_RLE_offset_pair;
using google_breakpad::DW_RLE_end_of_list;
using google_breakpad::DW_RLE_base_address;
using google_breakpad::DW_RLE_start_end;
using google_breakpad::DW_RLE_start_length;
using google_breakpad::DW_FORM_sec_offset;
using google_breakpad::DW_FORM_rnglistx;
// Size of header
const uint64_t header_size = 12;
@@ -814,7 +814,7 @@ TEST(RangeList, Dwarf5ReadRangeList_rnglists) {
byte_reader.SetOffsetSize(4);
byte_reader.SetAddressSize(4);
MockRangeListHandler handler;
dwarf2reader::RangeListReader range_list_reader1(&byte_reader, &cu_info,
google_breakpad::RangeListReader range_list_reader1(&byte_reader, &cu_info,
&handler);
EXPECT_CALL(handler, AddRange(2, 3));
EXPECT_CALL(handler, AddRange(4, 5));
@@ -830,7 +830,7 @@ TEST(RangeList, Dwarf5ReadRangeList_rnglists) {
// Set to new ranges_base
cu_info.ranges_base_ = ranges_base_2;
dwarf2reader::RangeListReader range_list_reader2(&byte_reader, &cu_info,
google_breakpad::RangeListReader range_list_reader2(&byte_reader, &cu_info,
&handler);
EXPECT_CALL(handler, AddRange(2, 3));
EXPECT_CALL(handler, AddRange(4, 5));
@@ -846,17 +846,17 @@ TEST(RangeList, Dwarf5ReadRangeList_rnglists) {
}
TEST(RangeList, Dwarf5ReadRangeList_sec_offset) {
using dwarf2reader::RangeListReader;
using dwarf2reader::DW_RLE_base_addressx;
using dwarf2reader::DW_RLE_startx_endx;
using dwarf2reader::DW_RLE_startx_length;
using dwarf2reader::DW_RLE_offset_pair;
using dwarf2reader::DW_RLE_end_of_list;
using dwarf2reader::DW_RLE_base_address;
using dwarf2reader::DW_RLE_start_end;
using dwarf2reader::DW_RLE_start_length;
using dwarf2reader::DW_FORM_sec_offset;
using dwarf2reader::DW_FORM_rnglistx;
using google_breakpad::RangeListReader;
using google_breakpad::DW_RLE_base_addressx;
using google_breakpad::DW_RLE_startx_endx;
using google_breakpad::DW_RLE_startx_length;
using google_breakpad::DW_RLE_offset_pair;
using google_breakpad::DW_RLE_end_of_list;
using google_breakpad::DW_RLE_base_address;
using google_breakpad::DW_RLE_start_end;
using google_breakpad::DW_RLE_start_length;
using google_breakpad::DW_FORM_sec_offset;
using google_breakpad::DW_FORM_rnglistx;
// Size of length field in header
const uint64_t length_size = 4;
@@ -936,7 +936,7 @@ TEST(RangeList, Dwarf5ReadRangeList_sec_offset) {
byte_reader.SetOffsetSize(4);
byte_reader.SetAddressSize(4);
MockRangeListHandler handler;
dwarf2reader::RangeListReader range_list_reader(&byte_reader, &cu_info,
google_breakpad::RangeListReader range_list_reader(&byte_reader, &cu_info,
&handler);
EXPECT_CALL(handler, AddRange(2, 3));
EXPECT_CALL(handler, AddRange(4, 5));

4
src/common/dwarf/dwarf2reader_lineinfo_unittest.cc
View File

@@ -29,7 +29,7 @@
// Original author: Sterling Augustine <saugustine@google.com>
// dwarf2reader_lineinfo_unittest.cc: Unit tests for dwarf2reader::LineInfo
// dwarf2reader_lineinfo_unittest.cc: Unit tests for google_breakpad::LineInfo
#include <stdint.h>
#include <stdlib.h>
@@ -49,7 +49,7 @@ using testing::Sequence;
using testing::Test;
using testing::_;
using namespace dwarf2reader;
using namespace google_breakpad;
namespace {

2
src/common/dwarf/dwarf2reader_splitfunctions_unittest.cc
View File

@@ -44,7 +44,7 @@
#include "google_breakpad/common/breakpad_types.h"
using testing::_;
using namespace dwarf2reader;
using namespace google_breakpad;
namespace {

16
src/common/dwarf/dwarf2reader_test_common.h
View File

@@ -45,9 +45,9 @@
// DWARF compilation units.
class TestCompilationUnit: public google_breakpad::test_assembler::Section {
public:
typedef dwarf2reader::DwarfTag DwarfTag;
typedef dwarf2reader::DwarfAttribute DwarfAttribute;
typedef dwarf2reader::DwarfForm DwarfForm;
typedef google_breakpad::DwarfTag DwarfTag;
typedef google_breakpad::DwarfAttribute DwarfAttribute;
typedef google_breakpad::DwarfForm DwarfForm;
typedef google_breakpad::test_assembler::Label Label;
// Set the section's DWARF format size (the 32-bit DWARF format or the
@@ -87,7 +87,7 @@ class TestCompilationUnit: public google_breakpad::test_assembler::Section {
D8(header_type); // DW_UT_compile, DW_UT_type, etc.
D8(address_size);
SectionOffset(abbrev_offset);
if (header_type == dwarf2reader::DW_UT_type) {
if (header_type == google_breakpad::DW_UT_type) {
uint64_t dummy_type_signature = 0xdeadbeef;
uint64_t dummy_type_offset = 0x2b;
D64(dummy_type_signature);
@@ -122,10 +122,10 @@ class TestCompilationUnit: public google_breakpad::test_assembler::Section {
// abbreviation tables.
class TestAbbrevTable: public google_breakpad::test_assembler::Section {
public:
typedef dwarf2reader::DwarfTag DwarfTag;
typedef dwarf2reader::DwarfAttribute DwarfAttribute;
typedef dwarf2reader::DwarfForm DwarfForm;
typedef dwarf2reader::DwarfHasChild DwarfHasChild;
typedef google_breakpad::DwarfTag DwarfTag;
typedef google_breakpad::DwarfAttribute DwarfAttribute;
typedef google_breakpad::DwarfForm DwarfForm;
typedef google_breakpad::DwarfHasChild DwarfHasChild;
typedef google_breakpad::test_assembler::Label Label;
// Start a new abbreviation table entry for abbreviation code |code|,

4
src/common/dwarf/elf_reader.cc
View File

@@ -108,7 +108,7 @@ const char kPLTFunctionSuffix[] = "@plt";
} // namespace
namespace dwarf2reader {
namespace google_breakpad {
template <class ElfArch> class ElfReaderImpl;
@@ -1271,4 +1271,4 @@ bool ElfReader::IsNonStrippedELFBinary(const string& path) {
bool ElfReader::IsNonDebugStrippedELFBinary(const string& path) {
return IsNonStrippedELFBinaryHelper(path, true);
}
} // namespace dwarf2reader
} // namespace google_breakpad

4
src/common/dwarf/elf_reader.h
View File

@@ -24,7 +24,7 @@
using std::vector;
using std::pair;
namespace dwarf2reader {
namespace google_breakpad {
class SymbolMap;
class Elf32;
@@ -162,6 +162,6 @@ class ElfReader {
ElfReaderImpl<Elf64>* impl64_;
};
} // namespace dwarf2reader
} // namespace google_breakpad
#endif // COMMON_DWARF_ELF_READER_H__

6
src/common/dwarf/functioninfo.cc
View File

@@ -42,9 +42,7 @@
#include "common/scoped_ptr.h"
#include "common/using_std_string.h"
using google_breakpad::scoped_ptr;
namespace dwarf2reader {
namespace google_breakpad {
CULineInfoHandler::CULineInfoHandler(std::vector<SourceFileInfo>* files,
std::vector<string>* dirs,
@@ -227,4 +225,4 @@ void CUFunctionInfoHandler::EndDIE(uint64_t offset) {
current_function_info_));
}
} // namespace dwarf2reader
} // namespace google_breakpad

4
src/common/dwarf/functioninfo.h
View File

@@ -43,7 +43,7 @@
#include "common/using_std_string.h"
namespace dwarf2reader {
namespace google_breakpad {
struct FunctionInfo {
// Name of the function
@@ -187,5 +187,5 @@ class CUFunctionInfoHandler: public Dwarf2Handler {
uint64_t current_compilation_unit_offset_;
};
} // namespace dwarf2reader
} // namespace google_breakpad
#endif // COMMON_DWARF_FUNCTIONINFO_H__

4
src/common/dwarf/line_state_machine.h
View File

@@ -32,7 +32,7 @@
#include <stdint.h>
namespace dwarf2reader {
namespace google_breakpad {
// This is the format of a DWARF2/3 line state machine that we process
// opcodes using. There is no need for anything outside the lineinfo
@@ -57,7 +57,7 @@ struct LineStateMachine {
bool end_sequence;
};
} // namespace dwarf2reader
} // namespace google_breakpad
#endif // COMMON_DWARF_LINE_STATE_MACHINE_H__