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 12 matching lines @@
 
 #ifndef SUBZERO_SRC_ICEASSEMBLER_H
 #define SUBZERO_SRC_ICEASSEMBLER_H
 
 #include "IceDefs.h"
 #include "IceFixups.h"
 #include "IceUtils.h"
 
 namespace Ice {
 
+class GlobalContext;

[Jim Stichnoth, 2015/10/08 23:50:41]

GlobalContext is already forward-declared in IceDefs.h.

[John, 2015/10/09 12:12:23]

ah, the beauty of forward decs and cyclic includes!...

I tend to side with Karl here: if we need to forward declare something (i.e.,
Somehow there's a cycle between the #includes in IceGlobalcontext.h and
IceAssembler.h) then that should be done in the file that needs it.

[Jim Stichnoth, 2015/10/09 13:36:30]

Well, I tried out the patch and everything compiles without this forward
declaration.  Also note the preexisting declaration below:
  void emitIASBytes(GlobalContext *Ctx) const;
So this wasn't a problem that needed fixing.

[Karl, 2015/10/09 19:08:18]

Removed.

+
 /// A Label can be in one of three states:
 ///  - Unused.
 ///  - Linked, unplaced and tracking the position of branches to the label.
 ///  - Bound, placed and tracking its position.
 class Label {
   Label(const Label &) = delete;
   Label &operator=(const Label &) = delete;
 
 public:
   Label() = default;
@@ skipping 14 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);
   }
 
+  // TODO(kschimpf): Remove Ctx argument, no longer needed.

[Jim Stichnoth, 2015/10/08 23:50:41]

Can you just do it now, and not leave a TODO?

   void emitIASBytes(GlobalContext *Ctx) const;

[John, 2015/10/09 12:12:23]

Just a personal preference, but I would not introduce this GlobalContext member.
I hate that (because LLVM Style Guide) parameters, locals, and class members all
look the same. I try to have local declarations (locals and/or parameters) as
much as I can. Feel free to ignore.

[Karl, 2015/10/09 19:08:17]

While I agree with this comment in general, the global context had to be added
to fix other issues (which would require major changes to many functions to pass
as parameters). Hence, having to pass something that is local appears to
introduce another set of issues. Changing to remove argument Ctx.

   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_