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..eaf008c4a8b8702b10abd2b09ac27357fa83d47b
--- /dev/null
+++ b/test/unittests/eh-frame-writer-unittest.cc
@@ -0,0 +1,339 @@
+// 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;
+};
+
+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, SaveRegisterUnsignedOffset) {
+  Register test_register = Register::from_code(kTestRegisterCode);
+  static const int kOffset =
+      EhFrameWriter::kDataAlignmentFactor > 0 ? 12344 : -12344;
+
+  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 / EhFrameWriter::kDataAlignmentFactor,
+            iterator.GetNextULEB128());
+}
+
+TEST_F(EhFrameWriterTest, SaveRegisterSignedOffset) {
+  Register test_register = Register::from_code(kTestRegisterCode);
+  static const int kOffset =
+      EhFrameWriter::kDataAlignmentFactor < 0 ? 12344 : -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 / EhFrameWriter::kDataAlignmentFactor,
+            iterator.GetNextSLEB128());
+}
+
+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