Subzero: Add basic ELFObjectWriter (text section, symtab, strtab, headers)

src/assembler.h

 //===- subzero/src/assembler.h - Integrated assembler -----------*- C++ -*-===//
 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 //
 // Modified by the Subzero authors.
 //
 //===----------------------------------------------------------------------===//
 //
 //                        The Subzero Code Generator
@@ skipping 17 matching lines @@
 #include "IceFixups.h"
 #include "llvm/Support/Allocator.h"
 
 namespace Ice {
 
 // Forward declarations.
 class Assembler;
 class AssemblerFixup;
 class AssemblerBuffer;
 class ConstantRelocatable;
-class MemoryRegion;
 
 // Assembler fixups are positions in generated code that hold relocation
 // information that needs to be processed before finalizing the code
 // into executable memory.
 class AssemblerFixup {
   AssemblerFixup(const AssemblerFixup &) = delete;
   AssemblerFixup &operator=(const AssemblerFixup &) = delete;
 
 public:
-  virtual void Process(const MemoryRegion &region, intptr_t position) = 0;
 
   // It would be ideal if the destructor method could be made private,
   // but the g++ compiler complains when this is subclassed.
   virtual ~AssemblerFixup() { llvm_unreachable("~AssemblerFixup used"); }
 
   intptr_t position() const { return position_; }
 
   FixupKind kind() const { return kind_; }
 
   const ConstantRelocatable *value() const { return value_; }
@@ skipping 43 matching lines @@
   // Emit a fixup at the current location.
   void EmitFixup(AssemblerFixup *fixup) {
     fixup->set_position(Size());
     fixups_.push_back(fixup);
   }
 
   // Get the size of the emitted code.
   intptr_t Size() const { return cursor_ - contents_; }
   uintptr_t contents() const { return contents_; }
 
-  // Copy the assembled instructions into the specified memory block
-  // and apply all fixups.
-  // TODO(jvoung): This will be different. We'll be writing the text
-  // and reloc section to a file?
-  void FinalizeInstructions(const MemoryRegion &region);
-
 // To emit an instruction to the assembler buffer, the EnsureCapacity helper
 // must be used to guarantee that the underlying data area is big enough to
 // hold the emitted instruction. Usage:
 //
 //     AssemblerBuffer buffer;
 //     AssemblerBuffer::EnsureCapacity ensured(&buffer);
 //     ... emit bytes for single instruction ...
 
 #ifndef NDEBUG
   class EnsureCapacity {
@@ skipping 54 matching lines @@
   bool fixups_processed_;
 #endif // !NDEBUG
 
   uintptr_t cursor() const { return cursor_; }
   uintptr_t limit() const { return limit_; }
   intptr_t Capacity() const {
     assert(limit_ >= contents_);
     return (limit_ - contents_) + kMinimumGap;
   }
 
-  // Process the fixup chain.
-  void ProcessFixups(const MemoryRegion &region);
-
   // Compute the limit based on the data area and the capacity. See
   // description of kMinimumGap for the reasoning behind the value.
   static uintptr_t ComputeLimit(uintptr_t data, intptr_t capacity) {
     return data + capacity - kMinimumGap;
   }
 
   void ExtendCapacity();
 
   friend class AssemblerFixup;
 };
@@ skipping 14 matching lines @@
     // will be copied out to a ".text" section (or an in memory-buffer
     // that can be mprotect'ed with executable permission), and that
     // second buffer should be aligned for NaCl.
     const size_t Alignment = 16;
     return reinterpret_cast<uintptr_t>(Allocator.Allocate(bytes, Alignment));
   }
 
   // Allocate data of type T using the per-Assembler allocator.
   template <typename T> T *Allocate() { return Allocator.Allocate<T>(); }
 
+  // Align the tail end of the function to the required target alignment.
+  virtual void alignFunction() = 0;
+
+  virtual SizeT getBundleAlignLog2Bytes() const = 0;
+
+  virtual llvm::ArrayRef<uint8_t> getNonExecBundlePadding() const = 0;
+
+  // Mark the current text location as the start of a CFG node
+  // (represented by NodeNumber).
   virtual void BindCfgNodeLabel(SizeT NodeNumber) = 0;
 
+  // Return a view of all the bytes of code for the current function.
+  llvm::StringRef getBufferView() const;
+
   void emitIASBytes(GlobalContext *Ctx) const;
 
 private:
   llvm::BumpPtrAllocator Allocator;
 
 protected:
   AssemblerBuffer buffer_;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ASSEMBLER_H_