Start incorporating the ARM integrated assembler.

src/IceAssembler.h

 //===- subzero/src/IceAssembler.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 46 matching lines @@
   /// Returns the position of an earlier branch instruction that was linked to
   /// this label (branches that use this are considered forward branches). The
   /// linked instructions form a linked list, of sorts, using the instruction's
   /// displacement field for the location of the next instruction that is also
   /// linked to this label.
   intptr_t getLinkPosition() const {
     assert(isLinked());
     return Position - kWordSize;
   }
 
+  void setPosition(intptr_t NewValue) { Position = NewValue; }
+
   bool isBound() const { return Position < 0; }
   bool isLinked() const { return Position > 0; }
+
   virtual bool isUnused() const { return Position == 0; }
 
-protected:
   void bindTo(intptr_t position) {
     assert(!isBound());
     Position = -position - kWordSize;
     assert(isBound());
   }
 
+protected:
   void linkTo(intptr_t position) {
     assert(!isBound());
     Position = position + kWordSize;
     assert(isLinked());
   }
 
   intptr_t Position = 0;
 
-private:
   // TODO(jvoung): why are labels offset by this?
   static constexpr uint32_t kWordSize = sizeof(uint32_t);
 };
 
 /// Assembler buffers are used to emit binary code. They grow on demand.
 class AssemblerBuffer {
   AssemblerBuffer(const AssemblerBuffer &) = delete;
   AssemblerBuffer &operator=(const AssemblerBuffer &) = delete;
 
 public:
@@ skipping 168 matching lines @@
 
   // 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;
+  void emitIASBytes() const;
   bool getInternal() const { return IsInternal; }
   void setInternal(bool Internal) { IsInternal = Internal; }
   const IceString &getFunctionName() { return FunctionName; }
   void setFunctionName(const IceString &NewName) { FunctionName = NewName; }
   intptr_t getBufferSize() const { return Buffer.size(); }
   /// Roll back to a (smaller) size.
   void setBufferSize(intptr_t NewSize) { Buffer.setSize(NewSize); }
   void setPreliminary(bool Value) { Preliminary = Value; }
   bool getPreliminary() const { return Preliminary; }
 
   AssemblerKind getKind() const { return Kind; }
 
 protected:
-  explicit Assembler(AssemblerKind Kind)
-      : Kind(Kind), Allocator(), Buffer(*this) {}
+  explicit Assembler(AssemblerKind Kind, GlobalContext *Ctx)
+      : Kind(Kind), Allocator(), Ctx(Ctx), Buffer(*this) {}
 
 private:
   const AssemblerKind Kind;
 
   ArenaAllocator<32 * 1024> Allocator;
   /// FunctionName and IsInternal are transferred from the original Cfg object,
   /// since the Cfg object may be deleted by the time the assembler buffer is
   /// emitted.
   IceString FunctionName = "";
   bool IsInternal = false;
   /// Preliminary indicates whether a preliminary pass is being made for
   /// calculating bundle padding (Preliminary=true), versus the final pass where
   /// all changes to label bindings, label links, and relocation fixups are
   /// fully committed (Preliminary=false).
   bool Preliminary = false;
 
 protected:
+  GlobalContext *Ctx;
   // Buffer's constructor uses the Allocator, so it needs to appear after it.
   // TODO(jpp): dependencies on construction order are a nice way of shooting
   // yourself in the foot. Fix this.
   AssemblerBuffer Buffer;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEASSEMBLER_H_