Subzero: Start writing out some relocation sections (text)

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 10 matching lines @@
 //===----------------------------------------------------------------------===//
 
 #ifndef SUBZERO_SRC_ASSEMBLER_H
 #define SUBZERO_SRC_ASSEMBLER_H
 
 #include "IceDefs.h"
 #include "IceFixups.h"
 
 namespace Ice {
 
-// Forward declarations.
-class Assembler;
-class AssemblerFixup;
-class AssemblerBuffer;
-class ConstantRelocatable;
-
-// 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:
-
-  // 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_; }
-
-  RelocOffsetT offset() const;
-
-  IceString symbol(GlobalContext *Ctx) const;
-
-  void emit(GlobalContext *Ctx) const;
-
-protected:
-  AssemblerFixup(FixupKind Kind, const Constant *Value)
-      : position_(0), kind_(Kind), value_(Value) {}
-
-private:
-  intptr_t position_;
-  FixupKind kind_;
-  const Constant *value_;
-
-  void set_position(intptr_t position) { position_ = position; }
-
-  friend class AssemblerBuffer;
-};
-
 // Assembler buffers are used to emit binary code. They grow on demand.
 class AssemblerBuffer {
   AssemblerBuffer(const AssemblerBuffer &) = delete;
   AssemblerBuffer &operator=(const AssemblerBuffer &) = delete;
 
 public:
   AssemblerBuffer(Assembler &);
   ~AssemblerBuffer();
 
   // Basic support for emitting, loading, and storing.
@@ skipping 11 matching lines @@
 
   template <typename T> void Store(intptr_t position, T value) {
     assert(position >= 0 &&
            position <= (Size() - static_cast<intptr_t>(sizeof(T))));
     *reinterpret_cast<T *>(contents_ + position) = value;
   }
 
   // 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_; }
 
 // 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:
 //
@@ skipping 33 matching lines @@
 
   // When building the C++ tests, assertion code is enabled. To allow
   // asserting that the user of the assembler buffer has ensured the
   // capacity needed for emitting, we add a dummy method in non-debug mode.
   bool HasEnsuredCapacity() const { return true; }
 #endif // NDEBUG
 
   // Returns the position in the instruction stream.
   intptr_t GetPosition() const { return cursor_ - contents_; }
 
-  // List of pool-allocated fixups.
-  typedef std::vector<AssemblerFixup *> FixupList;
-  FixupList::const_iterator fixups_begin() const { return fixups_.begin(); }
-  FixupList::const_iterator fixups_end() const { return fixups_.end(); }
+  // Create and track a fixup in the current function.
+  AssemblerFixup *createFixup(FixupKind Kind, const Constant *Value);
+
+  const FixupRefList &fixups() const { return fixups_; }
 
 private:
   // The limit is set to kMinimumGap bytes before the end of the data area.
   // This leaves enough space for the longest possible instruction and allows
   // for a single, fast space check per instruction.
   static const intptr_t kMinimumGap = 32;
 
   uintptr_t contents_;
   uintptr_t cursor_;
   uintptr_t limit_;
   Assembler &assembler_;
-  FixupList fixups_;
-#ifndef NDEBUG
-  bool fixups_processed_;
-#endif // !NDEBUG
+  // List of pool-allocated fixups relative to the current function.
+  FixupRefList fixups_;
 
   uintptr_t cursor() const { return cursor_; }
   uintptr_t limit() const { return limit_; }
   intptr_t Capacity() const {
     assert(limit_ >= contents_);
     return (limit_ - contents_) + kMinimumGap;
   }
 
   // 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;
 };
 
 class Assembler {
   Assembler(const Assembler &) = delete;
   Assembler &operator=(const Assembler &) = delete;
 
 public:
   Assembler() : buffer_(*this) {}
   virtual ~Assembler() {}
 
@@ skipping 16 matching lines @@
   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;
 
+  virtual bool fixupIsPCRel(FixupKind Kind) const = 0;
+
   // Return a view of all the bytes of code for the current function.
   llvm::StringRef getBufferView() const;
 
+  const FixupRefList &fixups() const { return buffer_.fixups(); }
+
+  AssemblerFixup *createFixup(FixupKind Kind, const Constant *Value) {
+    return buffer_.createFixup(Kind, Value);
+  }
+
   void emitIASBytes(GlobalContext *Ctx) const;
 
 private:
   ArenaAllocator<32 * 1024> Allocator;
 
 protected:
   AssemblerBuffer buffer_;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ASSEMBLER_H_