Add hybrid assembler concept to ARM assembler.

src/IceInstMIPS32.h

 //===- subzero/src/IceInstMIPS32.h - MIPS32 machine instrs --*- C++ -*-===    //
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 26 matching lines @@
   enum OperandKindMIPS32 {
     k__Start = Operand::kTarget,
     kMem,
   };
 
   using Operand::dump;
   void dump(const Cfg *, Ostream &Str) const override {
     if (BuildDefs::dump())
       Str << "<OperandMIPS32>";
   }
+
 protected:
   OperandMIPS32(OperandKindMIPS32 Kind, Type Ty)
       : Operand(static_cast<OperandKind>(Kind), Ty) {}
 };
 
 class OperandMIPS32Mem : public OperandMIPS32 {
   OperandMIPS32Mem() = delete;
   OperandMIPS32Mem(const OperandMIPS32Mem &) = delete;
   OperandMIPS32Mem &operator=(const OperandMIPS32Mem &) = delete;
 
@@ skipping 208 matching lines @@
       Str << (int32_t)Imm;
     else
       Str << Imm;
     Str << "\n";
   }
 
   static bool classof(const Inst *Inst) { return isClassof(Inst, K); }
 
 private:
   InstMIPS32Imm16(Cfg *Func, Variable *Dest, Operand *Source, uint32_t Imm)
-      : InstMIPS32(Func, K, 1, Dest), Imm(Imm){
+      : InstMIPS32(Func, K, 1, Dest), Imm(Imm) {
     addSource(Source);
   }
 
   InstMIPS32Imm16(Cfg *Func, Variable *Dest, uint32_t Imm)
-      : InstMIPS32(Func, K, 0, Dest), Imm(Imm) {
-  }
+      : InstMIPS32(Func, K, 0, Dest), Imm(Imm) {}
 
   static const char *Opcode;
 
   const uint32_t Imm;
 };
 
 typedef InstMIPS32Imm16<InstMIPS32::Addiu, true> InstMIPS32Addiu;
 typedef InstMIPS32Imm16<InstMIPS32::Lui> InstMIPS32Lui;
 typedef InstMIPS32UnaryopGPR<InstMIPS32::La> InstMIPS32La;
 typedef InstMIPS32Imm16<InstMIPS32::Ori> InstMIPS32Ori;
 
 /// Handles (some of) vmov's various formats.
 class InstMIPS32Mov final : public InstMIPS32 {
   InstMIPS32Mov() = delete;
   InstMIPS32Mov(const InstMIPS32Mov &) = delete;
   InstMIPS32Mov &operator=(const InstMIPS32Mov &) = delete;
 
 public:
   static InstMIPS32Mov *create(Cfg *Func, Variable *Dest, Operand *Src) {
     return new (Func->allocate<InstMIPS32Mov>()) InstMIPS32Mov(Func, Dest, Src);
   }
   bool isRedundantAssign() const override {
     return !isMultiDest() && !isMultiSource() &&
            checkForRedundantAssign(getDest(), getSrc(0));
   }
-  //bool isSimpleAssign() const override { return true; }
+  // bool isSimpleAssign() const override { return true; }
   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, Mov); }
 
   bool isMultiDest() const { return DestHi != nullptr; }
 
   bool isMultiSource() const {
     assert(getSrcSize() == 1 || getSrcSize() == 2);
     return getSrcSize() == 2;
   }
 
   Variable *getDestHi() const { return DestHi; }
 
 private:
   InstMIPS32Mov(Cfg *Func, Variable *Dest, Operand *Src);
 
   void emitMultiDestSingleSource(const Cfg *Func) const;
   void emitSingleDestMultiSource(const Cfg *Func) const;
   void emitSingleDestSingleSource(const Cfg *Func) const;
 
   Variable *DestHi = nullptr;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEINSTMIPS32_H