Reland Implement .eh_frame writer and disassembler.

src/eh-frame.h

 // 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.
 
 #ifndef V8_EH_FRAME_H_
 #define V8_EH_FRAME_H_
 
-#include <cstdint>
+#include "src/list.h"
 
 namespace v8 {
 namespace internal {
 
 class Code;
+struct CodeDesc;
+
+class EhFrameWriter {
+ public:
+  static const int kCIESize;
+
+  EhFrameWriter();
+
+  void AdvanceLocation(int pc_offset);
+  void DefineCFARegister(int code);

[rmcilroy, 2016/06/28 10:37:33]

Could you use Register instead of "int code"? (and below)

[Stefano Sanfilippo, 2016/06/29 15:16:21]

Yes, done. I added a RegisterToDwarfCode function used that is used internally
to retrieve the correct code, as indexes in the Register::Code enum do not
necessarily match DWARF register codes as specified by the ABI.

+  void DefineCFAOffset(int cfa_offset);
+  void IncreaseCFAOffset(int cfa_delta) {
+    DefineCFAOffset(cfa_offset_ + cfa_delta);
+  }
+  void DefineCFARegisterOffset(int code, int cfa_offset);
+  void SaveRegisterToStack(int code, int offset);
+  void SaveRegisterToStack(int code) { SaveRegisterToStack(code, cfa_offset_); }
+  void RegisterHasInitialValue(int code);
+
+  void Finish(int code_size);
+  void GetEhFrame(CodeDesc* desc);
+
+  int last_pc_offset() const { return last_pc_offset_; }
+  int cfa_register() const { return cfa_register_; }
+  int cfa_offset() const { return cfa_offset_; }
+
+  static void DisassembleToStream(std::ostream& stream,  // NOLINT
+                                  const byte* start, const byte* end);
+
+ protected:
+  void WriteByte(byte value) { unwinding_info_.Add(value); }
+
+  void WriteBytes(const byte* value, int size) {
+    unwinding_info_.AddAll(Vector<byte>(const_cast<byte*>(value), size));
+  }
+
+  void WriteInt16(uint16_t value) {
+    unwinding_info_.AddAll(
+        Vector<byte>(reinterpret_cast<byte*>(&value), sizeof(value)));
+  }
+
+  void WriteInt32(uint32_t value) {
+    unwinding_info_.AddAll(
+        Vector<byte>(reinterpret_cast<byte*>(&value), sizeof(value)));
+  }
+
+  void WriteULEB128(uint32_t value);
+
+  void PatchInt32(int base_offset, uint32_t value) {
+    MemCopy(unwinding_info_.begin() + base_offset, &value, sizeof(value));
+  }
+
+ private:
+  void WriteFDEHeader();
+
+  int last_pc_offset_;
+  int cfa_register_;
+  int cfa_offset_;
+  List<byte> unwinding_info_;
+};
 
 class EhFrameHdr final {
  public:
   static const int kRecordSize = 20;
-  static const int kCIESize;
 
   explicit EhFrameHdr(Code* code);
 
   int32_t offset_to_eh_frame() const { return offset_to_eh_frame_; }
   uint32_t lut_entries_number() const { return lut_entries_number_; }
   int32_t offset_to_procedure() const { return offset_to_procedure_; }
   int32_t offset_to_fde() const { return offset_to_fde_; }
 
  private:
   uint8_t version_;
   uint8_t eh_frame_ptr_encoding_;
   uint8_t lut_size_encoding_;
   uint8_t lut_entries_encoding_;
   int32_t offset_to_eh_frame_;
   uint32_t lut_entries_number_;
   int32_t offset_to_procedure_;
   int32_t offset_to_fde_;
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif