Reland Implement .eh_frame writer and disassembler.

test/unittests/eh-frame-writer-unittest.cc

Index: test/unittests/eh-frame-writer-unittest.cc
diff --git a/test/unittests/eh-frame-writer-unittest.cc b/test/unittests/eh-frame-writer-unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..c0739700b646991a06a146e7b10381cb9420926b
--- /dev/null
+++ b/test/unittests/eh-frame-writer-unittest.cc
@@ -0,0 +1,352 @@
+// Copyright 2016 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "src/eh-frame.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+// Test enabled only on supported architectures.
+#if defined(V8_TARGET_ARCH_X64) || defined(V8_TARGET_ARCH_ARM) || \
+    defined(V8_TARGET_ARCH_ARM64)
+
+namespace {
+
+class EhFrameWriterTest : public testing::Test {
+ protected:
+  // Being a 7bit positive integer, this also serves as its ULEB128 encoding.
+  static const int kTestRegisterCode = 0;

[Stefano Sanfilippo, 2016/07/05 19:53:56]

The problem with using different values here is that the register code must be
valid and known to EhFrameWriter::GetDwarfRegisterCode, or the writer will
crash. 

In order to support this case, I am handling the register having code 0 on all
supported platforms, rax for x64, r0 for arm and x0 for arm64. 

We might do the same for another register code, provided that it is valid on all
architectures, or we could add a #ifdef chain to provide a different register on
each arch. Wdyt?

[rmcilroy, 2016/07/06 13:59:30]

I guess this is fine then, thanks for the explination.

+};
+
+STATIC_CONST_MEMBER_DEFINITION const int EhFrameWriterTest::kTestRegisterCode;
+
+}  // namespace
+
+using namespace v8::internal;
+
+TEST_F(EhFrameWriterTest, Alignment) {
+  EhFrameWriter writer;
+  writer.AdvanceLocation(42);
+  writer.Finish(100);
+
+  EhFrameIterator iterator(&writer);
+  ASSERT_EQ(0, EhFrameHdr::kRecordSize % 4);
+  ASSERT_EQ(0, EhFrameWriter::kEhFrameTerminatorSize % 4);
+  EXPECT_EQ(0, (iterator.GetBufferSize() - EhFrameHdr::kRecordSize -
+                EhFrameWriter::kEhFrameTerminatorSize) %
+                   8);
+}
+
+TEST_F(EhFrameWriterTest, FDEHeader) {
+  static const int kProcedureSize = 0x5678abcd;
+
+  EhFrameWriter writer;
+  writer.Finish(kProcedureSize);
+
+  EhFrameIterator iterator(&writer);
+  int cie_size = iterator.GetNextUInt32();
+  iterator.Skip(cie_size);
+
+  int fde_size = iterator.GetNextUInt32();
+  EXPECT_EQ(iterator.GetBufferSize(),
+            fde_size + cie_size + EhFrameWriter::kEhFrameTerminatorSize +
+                EhFrameHdr::kRecordSize + 2 * kInt32Size);
+
+  int backwards_offset_to_cie_offset = iterator.GetCurrentOffset();
+  int backwards_offset_to_cie = iterator.GetNextUInt32();
+  EXPECT_EQ(backwards_offset_to_cie_offset, backwards_offset_to_cie);
+
+  int procedure_address_offset = iterator.GetCurrentOffset();
+  int procedure_address = iterator.GetNextUInt32();
+  EXPECT_EQ(-(procedure_address_offset + RoundUp(kProcedureSize, 8)),
+            procedure_address);
+
+  int procedure_size = iterator.GetNextUInt32();
+  EXPECT_EQ(kProcedureSize, procedure_size);
+}
+
+TEST_F(EhFrameWriterTest, SetOffset) {
+  static const int kOffset = 0x0badc0de;
+
+  EhFrameWriter writer;
+  writer.SetBaseAddressOffset(kOffset);
+  writer.Finish(100);
+
+  EhFrameIterator iterator(&writer);
+  iterator.SkipToFDEDirectives();
+
+  EXPECT_EQ(EhFrameWriter::DwarfOpcodes::kDefCfaOffset,
+            iterator.GetNextOpcode());
+  EXPECT_EQ(kOffset, iterator.GetNextULEB128());
+}
+
+TEST_F(EhFrameWriterTest, IncreaseOffset) {
+  static const int kFirstOffset = 121;
+  static const int kSecondOffset = 16;
+
+  EhFrameWriter writer;
+  writer.SetBaseAddressOffset(kFirstOffset);
+  writer.IncreaseBaseAddressOffset(kSecondOffset);
+  writer.Finish(100);
+
+  EhFrameIterator iterator(&writer);
+  iterator.SkipToFDEDirectives();
+
+  EXPECT_EQ(EhFrameWriter::DwarfOpcodes::kDefCfaOffset,
+            iterator.GetNextOpcode());
+  EXPECT_EQ(kFirstOffset, iterator.GetNextULEB128());
+
+  EXPECT_EQ(EhFrameWriter::DwarfOpcodes::kDefCfaOffset,
+            iterator.GetNextOpcode());
+  EXPECT_EQ(kFirstOffset + kSecondOffset, iterator.GetNextULEB128());
+}
+
+TEST_F(EhFrameWriterTest, SetRegister) {
+  Register test_register = Register::from_code(kTestRegisterCode);
+
+  EhFrameWriter writer;
+  writer.SetBaseAddressRegister(test_register);
+  writer.Finish(100);
+
+  EhFrameIterator iterator(&writer);
+  iterator.SkipToFDEDirectives();
+
+  EXPECT_EQ(EhFrameWriter::DwarfOpcodes::kDefCfaRegister,
+            iterator.GetNextOpcode());
+  EXPECT_EQ(kTestRegisterCode, iterator.GetNextULEB128());
+}
+
+TEST_F(EhFrameWriterTest, SetRegisterAndOffset) {
+  Register test_register = Register::from_code(kTestRegisterCode);
+  static const int kOffset = 0x0badc0de;
+
+  EhFrameWriter writer;
+  writer.SetBaseAddressRegisterAndOffset(test_register, kOffset);
+  writer.Finish(100);
+
+  EhFrameIterator iterator(&writer);
+  iterator.SkipToFDEDirectives();
+
+  EXPECT_EQ(EhFrameWriter::DwarfOpcodes::kDefCfa, iterator.GetNextOpcode());
+  EXPECT_EQ(kTestRegisterCode, iterator.GetNextULEB128());
+  EXPECT_EQ(kOffset, iterator.GetNextULEB128());
+}
+
+TEST_F(EhFrameWriterTest, PcOffsetEncoding6bit) {
+  static const int kOffset = 42;
+
+  EhFrameWriter writer;
+  writer.AdvanceLocation(kOffset);
+  writer.Finish(100);
+
+  EhFrameIterator iterator(&writer);
+  iterator.SkipToFDEDirectives();
+
+  EXPECT_EQ((1 << 6) | kOffset, iterator.GetNextByte());
+}
+
+TEST_F(EhFrameWriterTest, PcOffsetEncoding6bitDelta) {
+  static const int kFirstOffset = 42;
+  static const int kSecondOffset = 62;
+
+  EhFrameWriter writer;
+  writer.AdvanceLocation(kFirstOffset);
+  writer.AdvanceLocation(kSecondOffset);
+  writer.Finish(100);
+
+  EhFrameIterator iterator(&writer);
+  iterator.SkipToFDEDirectives();
+
+  EXPECT_EQ((1 << 6) | kFirstOffset, iterator.GetNextByte());
+  EXPECT_EQ((1 << 6) | (kSecondOffset - kFirstOffset), iterator.GetNextByte());
+}
+
+TEST_F(EhFrameWriterTest, PcOffsetEncoding8bit) {
+  static const int kOffset = 0x42;
+
+  EhFrameWriter writer;
+  writer.AdvanceLocation(kOffset);
+  writer.Finish(100);
+
+  EhFrameIterator iterator(&writer);
+  iterator.SkipToFDEDirectives();
+
+  EXPECT_EQ(EhFrameWriter::DwarfOpcodes::kAdvanceLoc1,
+            iterator.GetNextOpcode());
+  EXPECT_EQ(kOffset, iterator.GetNextByte());
+}
+
+TEST_F(EhFrameWriterTest, PcOffsetEncoding8bitDelta) {
+  static const int kFirstOffset = 0x10;
+  static const int kSecondOffset = 0x70;
+  static const int kThirdOffset = 0xb5;
+
+  EhFrameWriter writer;
+  writer.AdvanceLocation(kFirstOffset);
+  writer.AdvanceLocation(kSecondOffset);
+  writer.AdvanceLocation(kThirdOffset);
+  writer.Finish(100);
+
+  EhFrameIterator iterator(&writer);
+  iterator.SkipToFDEDirectives();
+
+  EXPECT_EQ((1 << 6) | kFirstOffset, iterator.GetNextByte());
+
+  EXPECT_EQ(EhFrameWriter::DwarfOpcodes::kAdvanceLoc1,
+            iterator.GetNextOpcode());
+  EXPECT_EQ(kSecondOffset - kFirstOffset, iterator.GetNextByte());
+
+  EXPECT_EQ(EhFrameWriter::DwarfOpcodes::kAdvanceLoc1,
+            iterator.GetNextOpcode());
+  EXPECT_EQ(kThirdOffset - kSecondOffset, iterator.GetNextByte());
+}
+
+TEST_F(EhFrameWriterTest, PcOffsetEncoding16bit) {
+  static const int kOffset = kMaxUInt8 + 42;
+  ASSERT_LT(kOffset, kMaxUInt16);
+
+  EhFrameWriter writer;
+  writer.AdvanceLocation(kOffset);
+  writer.Finish(100);
+
+  EhFrameIterator iterator(&writer);
+  iterator.SkipToFDEDirectives();
+
+  EXPECT_EQ(EhFrameWriter::DwarfOpcodes::kAdvanceLoc2,
+            iterator.GetNextOpcode());
+  EXPECT_EQ(kOffset, iterator.GetNextUInt16());
+}
+
+TEST_F(EhFrameWriterTest, PcOffsetEncoding16bitDelta) {
+  static const int kFirstOffset = 0x41;
+  static const int kSecondOffset = kMaxUInt8 + 0x42;
+
+  EhFrameWriter writer;
+  writer.AdvanceLocation(kFirstOffset);
+  writer.AdvanceLocation(kSecondOffset);
+  writer.Finish(100);
+
+  EhFrameIterator iterator(&writer);
+  iterator.SkipToFDEDirectives();
+
+  EXPECT_EQ(EhFrameWriter::DwarfOpcodes::kAdvanceLoc1,
+            iterator.GetNextOpcode());
+  EXPECT_EQ(kFirstOffset, iterator.GetNextByte());
+
+  EXPECT_EQ(EhFrameWriter::DwarfOpcodes::kAdvanceLoc2,
+            iterator.GetNextOpcode());
+  EXPECT_EQ(kSecondOffset - kFirstOffset, iterator.GetNextUInt16());
+}
+
+TEST_F(EhFrameWriterTest, PcOffsetEncoding32bit) {
+  static const int kOffset = kMaxUInt16 + 42;
+
+  EhFrameWriter writer;
+  writer.AdvanceLocation(kOffset);
+  writer.Finish(100);
+
+  EhFrameIterator iterator(&writer);
+  iterator.SkipToFDEDirectives();
+
+  EXPECT_EQ(EhFrameWriter::DwarfOpcodes::kAdvanceLoc4,
+            iterator.GetNextOpcode());
+  EXPECT_EQ(kOffset, iterator.GetNextUInt32());
+}
+
+TEST_F(EhFrameWriterTest, PcOffsetEncoding32bitDelta) {
+  static const int kFirstOffset = kMaxUInt16 + 0x42;
+  static const int kSecondOffset = kMaxUInt16 + 0x67;
+
+  EhFrameWriter writer;
+  writer.AdvanceLocation(kFirstOffset);
+  writer.AdvanceLocation(kSecondOffset);
+  writer.Finish(100);
+
+  EhFrameIterator iterator(&writer);
+  iterator.SkipToFDEDirectives();
+
+  EXPECT_EQ(EhFrameWriter::DwarfOpcodes::kAdvanceLoc4,
+            iterator.GetNextOpcode());
+  EXPECT_EQ(kFirstOffset, iterator.GetNextUInt32());
+
+  EXPECT_EQ((1 << 6) | (kSecondOffset - kFirstOffset), iterator.GetNextByte());
+}
+
+TEST_F(EhFrameWriterTest, SaveRegisterPositiveOffset) {
+  Register test_register = Register::from_code(kTestRegisterCode);
+  static const int kOffset = 16;
+
+  EhFrameWriter writer;
+  writer.RecordRegisterSavedToStack(test_register, kOffset);
+  writer.Finish(100);
+
+  EhFrameIterator iterator(&writer);
+  iterator.SkipToFDEDirectives();
+
+  EXPECT_EQ((2 << 6) | kTestRegisterCode, iterator.GetNextByte());
+  EXPECT_EQ(kOffset / std::abs(EhFrameWriter::kDataAlignmentFactor),
+            iterator.GetNextULEB128());
+}
+
+TEST_F(EhFrameWriterTest, SaveRegisterNegativeOffset) {
+  Register test_register = Register::from_code(kTestRegisterCode);
+  static const int kOffset = -12344;
+  ASSERT_EQ(kOffset % EhFrameWriter::kDataAlignmentFactor, 0);
+
+  EhFrameWriter writer;
+  writer.RecordRegisterSavedToStack(test_register, kOffset);
+  writer.Finish(100);
+
+  EhFrameIterator iterator(&writer);
+  iterator.SkipToFDEDirectives();
+
+  EXPECT_EQ(EhFrameWriter::DwarfOpcodes::kOffsetExtendedSf,
+            iterator.GetNextOpcode());
+  EXPECT_EQ(kTestRegisterCode, iterator.GetNextULEB128());
+  EXPECT_EQ(kOffset / std::abs(EhFrameWriter::kDataAlignmentFactor),
+            iterator.GetNextSLEB128());
+}
+
+TEST_F(EhFrameWriterTest, SaveRegisterToTop) {
+  Register test_register = Register::from_code(kTestRegisterCode);
+
+  EhFrameWriter writer;
+  int initial_base_offset = writer.base_offset();
+  writer.RecordRegisterSavedToStack(test_register);
+  writer.Finish(100);
+
+  EhFrameIterator iterator(&writer);
+  iterator.SkipToFDEDirectives();
+
+  EXPECT_EQ((2 << 6) | kTestRegisterCode, iterator.GetNextByte());
+  EXPECT_EQ(initial_base_offset / std::abs(EhFrameWriter::kDataAlignmentFactor),
+            iterator.GetNextULEB128());
+}
+
+TEST_F(EhFrameWriterTest, RegisterIsValid) {
+  Register test_register = Register::from_code(kTestRegisterCode);
+
+  EhFrameWriter writer;
+  writer.RecordRegisterIsValid(test_register);
+  writer.Finish(100);
+
+  EhFrameIterator iterator(&writer);
+  iterator.SkipToFDEDirectives();
+
+  EXPECT_EQ(EhFrameWriter::DwarfOpcodes::kSameValue, iterator.GetNextOpcode());
+  EXPECT_EQ(kTestRegisterCode, iterator.GetNextULEB128());
+}
+
+TEST_F(EhFrameWriterTest, RegisterFollowsInitialRule) {
+  Register test_register = Register::from_code(kTestRegisterCode);
+
+  EhFrameWriter writer;
+  writer.RecordRegisterFollowsInitialRule(test_register);
+  writer.Finish(100);
+
+  EhFrameIterator iterator(&writer);
+  iterator.SkipToFDEDirectives();
+
+  EXPECT_EQ((3 << 6) | kTestRegisterCode, iterator.GetNextByte());
+}
+
+#endif