Add hybrid assembler concept to ARM assembler.

src/IceInstARM32.h

 //===- subzero/src/IceInstARM32.h - ARM32 machine instructions --*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 326 matching lines @@
   static const char *getWidthString(Type Ty);
   static const char *getVecWidthString(Type Ty);
   static CondARM32::Cond getOppositeCondition(CondARM32::Cond Cond);
 
   /// Shared emit routines for common forms of instructions.
   static void emitThreeAddrFP(const char *Opcode, const InstARM32 *Inst,
                               const Cfg *Func);
 
   void dump(const Cfg *Func) const override;
 
+  void emitIAS(const Cfg *Func) const override;
+
 protected:
   InstARM32(Cfg *Func, InstKindARM32 Kind, SizeT Maxsrcs, Variable *Dest)
       : InstTarget(Func, static_cast<InstKind>(Kind), Maxsrcs, Dest) {}
 
   static bool isClassof(const Inst *Inst, InstKindARM32 MyKind) {
     return Inst->getKind() == static_cast<InstKind>(MyKind);
   }
+
+  // Generates text of assembly instruction using method emit(), and then adds
+  // to the assembly buffer as a Fixup.
+  void emitUsingTextFixup(const Cfg *Func) const;
 };
 
 /// A predicable ARM instruction.
 class InstARM32Pred : public InstARM32 {
   InstARM32Pred() = delete;
   InstARM32Pred(const InstARM32Pred &) = delete;
   InstARM32Pred &operator=(const InstARM32Pred &) = delete;
 
 public:
   InstARM32Pred(Cfg *Func, InstKindARM32 Kind, SizeT Maxsrcs, Variable *Dest,
@@ skipping 41 matching lines @@
   static InstARM32UnaryopGPR *create(Cfg *Func, Variable *Dest, Operand *Src,
                                      CondARM32::Cond Predicate) {
     return new (Func->allocate<InstARM32UnaryopGPR>())
         InstARM32UnaryopGPR(Func, Dest, Src, Predicate);
   }
   void emit(const Cfg *Func) const override {
     if (!BuildDefs::dump())
       return;
     emitUnaryopGPR(Opcode, this, Func, NeedsWidthSuffix);
   }
-  void emitIAS(const Cfg *Func) const override {
-    (void)Func;
-    llvm_unreachable("Not yet implemented");
-  }
   void dump(const Cfg *Func) const override {
     if (!BuildDefs::dump())
       return;
     Ostream &Str = Func->getContext()->getStrDump();
     dumpDest(Func);
     Str << " = ";
     dumpOpcodePred(Str, Opcode, getDest()->getType());
     Str << " ";
     dumpSources(Func);
   }
@@ skipping 20 matching lines @@
   static InstARM32UnaryopFP *create(Cfg *Func, Variable *Dest, Variable *Src,
                                     CondARM32::Cond Predicate) {
     return new (Func->allocate<InstARM32UnaryopFP>())
         InstARM32UnaryopFP(Func, Dest, Src, Predicate);
   }
   void emit(const Cfg *Func) const override {
     if (!BuildDefs::dump())
       return;
     emitUnaryopFP(Opcode, this, Func);
   }
-  void emitIAS(const Cfg *Func) const override {
-    (void)Func;
-    llvm::report_fatal_error("Not yet implemented");
-  }
   void dump(const Cfg *Func) const override {
     if (!BuildDefs::dump())
       return;
     Ostream &Str = Func->getContext()->getStrDump();
     dumpDest(Func);
     Str << " = ";
     dumpOpcodePred(Str, Opcode, getDest()->getType());
     Str << " ";
     dumpSources(Func);
   }
@@ skipping 21 matching lines @@
   static InstARM32TwoAddrGPR *create(Cfg *Func, Variable *Dest, Operand *Src,
                                      CondARM32::Cond Predicate) {
     return new (Func->allocate<InstARM32TwoAddrGPR>())
         InstARM32TwoAddrGPR(Func, Dest, Src, Predicate);
   }
   void emit(const Cfg *Func) const override {
     if (!BuildDefs::dump())
       return;
     emitTwoAddr(Opcode, this, Func);
   }
-  void emitIAS(const Cfg *Func) const override {
-    (void)Func;
-    llvm::report_fatal_error("Not yet implemented");
-  }
+  void emitIAS(const Cfg *Func) const override;
   void dump(const Cfg *Func) const override {
     if (!BuildDefs::dump())
       return;
     Ostream &Str = Func->getContext()->getStrDump();
     dumpDest(Func);
     Str << " = ";
     dumpOpcodePred(Str, Opcode, getDest()->getType());
     Str << " ";
     dumpSources(Func);
   }
@@ skipping 17 matching lines @@
   InstARM32LoadBase(const InstARM32LoadBase &) = delete;
   InstARM32LoadBase &operator=(const InstARM32LoadBase &) = delete;
 
 public:
   static InstARM32LoadBase *create(Cfg *Func, Variable *Dest, Operand *Source,
                                    CondARM32::Cond Predicate) {
     return new (Func->allocate<InstARM32LoadBase>())
         InstARM32LoadBase(Func, Dest, Source, Predicate);
   }
   void emit(const Cfg *Func) const override;
-  void emitIAS(const Cfg *Func) const override;
   void dump(const Cfg *Func) const override {
     if (!BuildDefs::dump())
       return;
     Ostream &Str = Func->getContext()->getStrDump();
     dumpOpcodePred(Str, Opcode, getDest()->getType());
     Str << " ";
     dumpDest(Func);
     Str << ", ";
     dumpSources(Func);
   }
@@ skipping 73 matching lines @@
   static InstARM32ThreeAddrFP *create(Cfg *Func, Variable *Dest, Variable *Src0,
                                       Variable *Src1) {
     return new (Func->allocate<InstARM32ThreeAddrFP>())
         InstARM32ThreeAddrFP(Func, Dest, Src0, Src1);
   }
   void emit(const Cfg *Func) const override {
     if (!BuildDefs::dump())
       return;
     emitThreeAddrFP(Opcode, this, Func);
   }
-  void emitIAS(const Cfg *Func) const override {
-    (void)Func;
-    llvm::report_fatal_error("Not yet implemented");
-  }
   void dump(const Cfg *Func) const override {
     if (!BuildDefs::dump())
       return;
     Ostream &Str = Func->getContext()->getStrDump();
     dumpDest(Func);
     Str << " = ";
     Str << Opcode << "." << getDest()->getType() << " ";
     dumpSources(Func);
   }
   static bool classof(const Inst *Inst) { return isClassof(Inst, K); }
@@ skipping 22 matching lines @@
                                       Variable *Src1, Variable *Src2,
                                       CondARM32::Cond Predicate) {
     return new (Func->allocate<InstARM32FourAddrGPR>())
         InstARM32FourAddrGPR(Func, Dest, Src0, Src1, Src2, Predicate);
   }
   void emit(const Cfg *Func) const override {
     if (!BuildDefs::dump())
       return;
     emitFourAddr(Opcode, this, Func);
   }
-  void emitIAS(const Cfg *Func) const override {
-    (void)Func;
-    llvm::report_fatal_error("Not yet implemented");
-  }
   void dump(const Cfg *Func) const override {
     if (!BuildDefs::dump())
       return;
     Ostream &Str = Func->getContext()->getStrDump();
     dumpDest(Func);
     Str << " = ";
     dumpOpcodePred(Str, Opcode, getDest()->getType());
     Str << " ";
     dumpSources(Func);
   }
@@ skipping 23 matching lines @@
   static InstARM32CmpLike *create(Cfg *Func, Variable *Src0, Operand *Src1,
                                   CondARM32::Cond Predicate) {
     return new (Func->allocate<InstARM32CmpLike>())
         InstARM32CmpLike(Func, Src0, Src1, Predicate);
   }
   void emit(const Cfg *Func) const override {
     if (!BuildDefs::dump())
       return;
     emitCmpLike(Opcode, this, Func);
   }
-  void emitIAS(const Cfg *Func) const override {
-    (void)Func;
-    llvm_unreachable("Not yet implemented");
-  }
   void dump(const Cfg *Func) const override {
     if (!BuildDefs::dump())
       return;
     Ostream &Str = Func->getContext()->getStrDump();
     dumpOpcodePred(Str, Opcode, getSrc(0)->getType());
     Str << " ";
     dumpSources(Func);
   }
   static bool classof(const Inst *Inst) { return isClassof(Inst, K); }
 
@@ skipping 57 matching lines @@
   InstARM32Label &operator=(const InstARM32Label &) = delete;
 
 public:
   static InstARM32Label *create(Cfg *Func, TargetARM32 *Target) {
     return new (Func->allocate<InstARM32Label>()) InstARM32Label(Func, Target);
   }
   uint32_t getEmitInstCount() const override { return 0; }
   IceString getName(const Cfg *Func) const;
   SizeT getNumber() const { return Number; }
   void emit(const Cfg *Func) const override;
-  void emitIAS(const Cfg *Func) const override;
   void dump(const Cfg *Func) const override;
 
 private:
   InstARM32Label(Cfg *Func, TargetARM32 *Target);
 
   SizeT Number; // used for unique label generation.
 };
 
 /// Direct branch instruction.
 class InstARM32Br : public InstARM32Pred {
@@ skipping 48 matching lines @@
       ++Sum;
     if (getTargetFalse())
       ++Sum;
     return Sum;
   }
   bool isUnconditionalBranch() const override {
     return getPredicate() == CondARM32::AL;
   }
   bool repointEdges(CfgNode *OldNode, CfgNode *NewNode) override;
   void emit(const Cfg *Func) const override;
-  void emitIAS(const Cfg *Func) const override;
   void dump(const Cfg *Func) const override;
   static bool classof(const Inst *Inst) { return isClassof(Inst, Br); }
 
 private:
   InstARM32Br(Cfg *Func, const CfgNode *TargetTrue, const CfgNode *TargetFalse,
               const InstARM32Label *Label, CondARM32::Cond Predicate);
 
   const CfgNode *TargetTrue;
   const CfgNode *TargetFalse;
   const InstARM32Label *Label; // Intra-block branch target
@@ skipping 10 matching lines @@
   /// Note: We need both Amount and SrcAmount. If Amount is too large then it
   /// needs to be copied to a register (so SrcAmount could be a register).
   /// However, we also need the numeric Amount for bookkeeping, and it's hard to
   /// pull that from the generic SrcAmount operand.
   static InstARM32AdjustStack *create(Cfg *Func, Variable *SP, SizeT Amount,
                                       Operand *SrcAmount) {
     return new (Func->allocate<InstARM32AdjustStack>())
         InstARM32AdjustStack(Func, SP, Amount, SrcAmount);
   }
   void emit(const Cfg *Func) const override;
-  void emitIAS(const Cfg *Func) const override;
   void dump(const Cfg *Func) const override;
   static bool classof(const Inst *Inst) { return isClassof(Inst, Adjuststack); }
   SizeT getAmount() const { return Amount; }
 
 private:
   InstARM32AdjustStack(Cfg *Func, Variable *SP, SizeT Amount,
                        Operand *SrcAmount);
   const SizeT Amount;
 };
 
 /// Call instruction (bl/blx). Arguments should have already been pushed.
 /// Technically bl and the register form of blx can be predicated, but we'll
 /// leave that out until needed.
 class InstARM32Call : public InstARM32 {
   InstARM32Call() = delete;
   InstARM32Call(const InstARM32Call &) = delete;
   InstARM32Call &operator=(const InstARM32Call &) = delete;
 
 public:
   static InstARM32Call *create(Cfg *Func, Variable *Dest, Operand *CallTarget) {
     return new (Func->allocate<InstARM32Call>())
         InstARM32Call(Func, Dest, CallTarget);
   }
   Operand *getCallTarget() const { return getSrc(0); }
   void emit(const Cfg *Func) const override;
-  void emitIAS(const Cfg *Func) const override;
   void dump(const Cfg *Func) const override;
   static bool classof(const Inst *Inst) { return isClassof(Inst, Call); }
 
 private:
   InstARM32Call(Cfg *Func, Variable *Dest, Operand *CallTarget);
 };
 
 /// Pop into a list of GPRs. Technically this can be predicated, but we don't
 /// need that functionality.
 class InstARM32Pop : public InstARM32 {
   InstARM32Pop() = delete;
   InstARM32Pop(const InstARM32Pop &) = delete;
   InstARM32Pop &operator=(const InstARM32Pop &) = delete;
 
 public:
   static InstARM32Pop *create(Cfg *Func, const VarList &Dests) {
     return new (Func->allocate<InstARM32Pop>()) InstARM32Pop(Func, Dests);
   }
   void emit(const Cfg *Func) const override;
-  void emitIAS(const Cfg *Func) const override;
   void dump(const Cfg *Func) const override;
   static bool classof(const Inst *Inst) { return isClassof(Inst, Pop); }
 
 private:
   InstARM32Pop(Cfg *Func, const VarList &Dests);
 
   VarList Dests;
 };
 
 /// Push a list of GPRs. Technically this can be predicated, but we don't need
 /// that functionality.
 class InstARM32Push : public InstARM32 {
   InstARM32Push() = delete;
   InstARM32Push(const InstARM32Push &) = delete;
   InstARM32Push &operator=(const InstARM32Push &) = delete;
 
 public:
   static InstARM32Push *create(Cfg *Func, const VarList &Srcs) {
     return new (Func->allocate<InstARM32Push>()) InstARM32Push(Func, Srcs);
   }
   void emit(const Cfg *Func) const override;
-  void emitIAS(const Cfg *Func) const override;
   void dump(const Cfg *Func) const override;
   static bool classof(const Inst *Inst) { return isClassof(Inst, Push); }
 
 private:
   InstARM32Push(Cfg *Func, const VarList &Srcs);
 };
 
 /// Ret pseudo-instruction. This is actually a "bx" instruction with an "lr"
 /// register operand, but epilogue lowering will search for a Ret instead of a
 /// generic "bx". This instruction also takes a Source operand (for non-void
@@ skipping 30 matching lines @@
   InstARM32Str &operator=(const InstARM32Str &) = delete;
 
 public:
   /// Value must be a register.
   static InstARM32Str *create(Cfg *Func, Variable *Value, OperandARM32Mem *Mem,
                               CondARM32::Cond Predicate) {
     return new (Func->allocate<InstARM32Str>())
         InstARM32Str(Func, Value, Mem, Predicate);
   }
   void emit(const Cfg *Func) const override;
-  void emitIAS(const Cfg *Func) const override;
   void dump(const Cfg *Func) const override;
   static bool classof(const Inst *Inst) { return isClassof(Inst, Str); }
 
 private:
   InstARM32Str(Cfg *Func, Variable *Value, OperandARM32Mem *Mem,
                CondARM32::Cond Predicate);
 };
 
 /// Exclusive Store instruction. Like its non-exclusive sibling, it's important
 /// for liveness that there is no Dest operand (OperandARM32Mem instead of Dest
 /// Variable).
 class InstARM32Strex final : public InstARM32Pred {
   InstARM32Strex() = delete;
   InstARM32Strex(const InstARM32Strex &) = delete;
   InstARM32Strex &operator=(const InstARM32Strex &) = delete;
 
 public:
   /// Value must be a register.
   static InstARM32Strex *create(Cfg *Func, Variable *Dest, Variable *Value,
                                 OperandARM32Mem *Mem,
                                 CondARM32::Cond Predicate) {
     return new (Func->allocate<InstARM32Strex>())
         InstARM32Strex(Func, Dest, Value, Mem, Predicate);
   }
   void emit(const Cfg *Func) const override;
-  void emitIAS(const Cfg *Func) const override;
   void dump(const Cfg *Func) const override;
   static bool classof(const Inst *Inst) { return isClassof(Inst, Strex); }
 
 private:
   InstARM32Strex(Cfg *Func, Variable *Dest, Variable *Value,
                  OperandARM32Mem *Mem, CondARM32::Cond Predicate);
 };
 
 class InstARM32Trap : public InstARM32 {
   InstARM32Trap() = delete;
   InstARM32Trap(const InstARM32Trap &) = delete;
   InstARM32Trap &operator=(const InstARM32Trap &) = delete;
 
 public:
   static InstARM32Trap *create(Cfg *Func) {
     return new (Func->allocate<InstARM32Trap>()) InstARM32Trap(Func);
   }
   void emit(const Cfg *Func) const override;
-  void emitIAS(const Cfg *Func) const override;
   void dump(const Cfg *Func) const override;
   static bool classof(const Inst *Inst) { return isClassof(Inst, Trap); }
 
 private:
   explicit InstARM32Trap(Cfg *Func);
 };
 
 /// Unsigned Multiply Long: d.lo, d.hi := x * y
 class InstARM32Umull : public InstARM32Pred {
   InstARM32Umull() = delete;
   InstARM32Umull(const InstARM32Umull &) = delete;
   InstARM32Umull &operator=(const InstARM32Umull &) = delete;
 
 public:
   /// Everything must be a register.
   static InstARM32Umull *create(Cfg *Func, Variable *DestLo, Variable *DestHi,
                                 Variable *Src0, Variable *Src1,
                                 CondARM32::Cond Predicate) {
     return new (Func->allocate<InstARM32Umull>())
         InstARM32Umull(Func, DestLo, DestHi, Src0, Src1, Predicate);
   }
   void emit(const Cfg *Func) const override;
-  void emitIAS(const Cfg *Func) const override;
   void dump(const Cfg *Func) const override;
   static bool classof(const Inst *Inst) { return isClassof(Inst, Umull); }
 
 private:
   InstARM32Umull(Cfg *Func, Variable *DestLo, Variable *DestHi, Variable *Src0,
                  Variable *Src1, CondARM32::Cond Predicate);
 
   Variable *DestHi;
 };
 
 /// Handles fp2int, int2fp, and fp2fp conversions.
 class InstARM32Vcvt final : public InstARM32Pred {
   InstARM32Vcvt() = delete;
   InstARM32Vcvt(const InstARM32Vcvt &) = delete;
   InstARM32Vcvt &operator=(const InstARM32Vcvt &) = delete;
 
 public:
   enum VcvtVariant { S2si, S2ui, Si2s, Ui2s, D2si, D2ui, Si2d, Ui2d, S2d, D2s };
   static InstARM32Vcvt *create(Cfg *Func, Variable *Dest, Variable *Src,
                                VcvtVariant Variant, CondARM32::Cond Predicate) {
     return new (Func->allocate<InstARM32Vcvt>())
         InstARM32Vcvt(Func, Dest, Src, Variant, Predicate);
   }
   void emit(const Cfg *Func) const override;
-  void emitIAS(const Cfg *Func) const override;
   void dump(const Cfg *Func) const override;
   static bool classof(const Inst *Inst) { return isClassof(Inst, Vcvt); }
 
 private:
   InstARM32Vcvt(Cfg *Func, Variable *Dest, Variable *Src, VcvtVariant Variant,
                 CondARM32::Cond Predicate);
 
   const VcvtVariant Variant;
 };
 
@@ skipping 46 matching lines @@
   InstARM32Vcmp(const InstARM32Vcmp &) = delete;
   InstARM32Vcmp &operator=(const InstARM32Vcmp &) = delete;
 
 public:
   static InstARM32Vcmp *create(Cfg *Func, Variable *Src0, Variable *Src1,
                                CondARM32::Cond Predicate) {
     return new (Func->allocate<InstARM32Vcmp>())
         InstARM32Vcmp(Func, Src0, Src1, Predicate);
   }
   void emit(const Cfg *Func) const override;
-  void emitIAS(const Cfg *Func) const override;
   void dump(const Cfg *Func) const override;
   static bool classof(const Inst *Inst) { return isClassof(Inst, Vcmp); }
 
 private:
   InstARM32Vcmp(Cfg *Func, Variable *Src0, Variable *Src1,
                 CondARM32::Cond Predicate);
 };
 
 /// Copies the FP Status and Control Register the core flags.
 class InstARM32Vmrs final : public InstARM32Pred {
   InstARM32Vmrs() = delete;
   InstARM32Vmrs(const InstARM32Vmrs &) = delete;
   InstARM32Vmrs &operator=(const InstARM32Vmrs &) = delete;
 
 public:
   static InstARM32Vmrs *create(Cfg *Func, CondARM32::Cond Predicate) {
     return new (Func->allocate<InstARM32Vmrs>()) InstARM32Vmrs(Func, Predicate);
   }
   void emit(const Cfg *Func) const override;
-  void emitIAS(const Cfg *Func) const override;
   void dump(const Cfg *Func) const override;
   static bool classof(const Inst *Inst) { return isClassof(Inst, Vmrs); }
 
 private:
   InstARM32Vmrs(Cfg *Func, CondARM32::Cond Predicate);
 };
 
 class InstARM32Vabs final : public InstARM32Pred {
   InstARM32Vabs() = delete;
   InstARM32Vabs(const InstARM32Vabs &) = delete;
   InstARM32Vabs &operator=(const InstARM32Vabs &) = delete;
 
 public:
   static InstARM32Vabs *create(Cfg *Func, Variable *Dest, Variable *Src,
                                CondARM32::Cond Predicate) {
     return new (Func->allocate<InstARM32Vabs>())
         InstARM32Vabs(Func, Dest, Src, Predicate);
   }
   void emit(const Cfg *Func) const override;
-  void emitIAS(const Cfg *Func) const override;
   void dump(const Cfg *Func) const override;
   static bool classof(const Inst *Inst) { return isClassof(Inst, Vabs); }
 
 private:
   InstARM32Vabs(Cfg *Func, Variable *Dest, Variable *Src,
                 CondARM32::Cond Predicate);
 };
 
 class InstARM32Dmb final : public InstARM32Pred {
   InstARM32Dmb() = delete;
   InstARM32Dmb(const InstARM32Dmb &) = delete;
   InstARM32Dmb &operator=(const InstARM32Dmb &) = delete;
 
 public:
   static InstARM32Dmb *create(Cfg *Func) {
     return new (Func->allocate<InstARM32Dmb>()) InstARM32Dmb(Func);
   }
   void emit(const Cfg *Func) const override;
-  void emitIAS(const Cfg *Func) const override;
   void dump(const Cfg *Func) const override;
   static bool classof(const Inst *Inst) { return isClassof(Inst, Dmb); }
 
 private:
   explicit InstARM32Dmb(Cfg *Func);
 };
 
 // Declare partial template specializations of emit() methods that already have
 // default implementations. Without this, there is the possibility of ODR
 // violations and link errors.
 
 template <> void InstARM32Ldr::emit(const Cfg *Func) const;
 template <> void InstARM32Movw::emit(const Cfg *Func) const;
 template <> void InstARM32Movt::emit(const Cfg *Func) const;
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEINSTARM32_H