Lower a few basic ARM binops for i{8,16,32,64}.

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.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file declares the InstARM32 and OperandARM32 classes and
@@ skipping 227 matching lines @@
 };
 
 class InstARM32 : public InstTarget {
   InstARM32() = delete;
   InstARM32(const InstARM32 &) = delete;
   InstARM32 &operator=(const InstARM32 &) = delete;
 
 public:
   enum InstKindARM32 {
     k__Start = Inst::Target,
+    Adc,
+    Add,
+    And,
+    Eor,
+    Ldr,
+    Mla,
     Mov,
     Movt,
     Movw,
+    Mul,
     Mvn,
+    Orr,
     Ret,
-    Ldr
+    Sbc,
+    Sub,
+    Umull
   };
 
   static const char *getWidthString(Type Ty);
 
   void dump(const Cfg *Func) const override;
 
 protected:
   InstARM32(Cfg *Func, InstKindARM32 Kind, SizeT Maxsrcs, Variable *Dest)
       : InstTarget(Func, static_cast<InstKind>(Kind), Maxsrcs, Dest) {}
   ~InstARM32() override {}
   static bool isClassof(const Inst *Inst, InstKindARM32 MyKind) {
     return Inst->getKind() == static_cast<InstKind>(MyKind);
   }
 };
 
 void emitTwoAddr(const char *Opcode, const Inst *Inst, const Cfg *Func);
+void emitThreeAddr(const char *Opcode, const Inst *Inst, const Cfg *Func,
+                   bool SetFlags);
 
 // TODO(jvoung): add condition codes if instruction can be predicated.
 
 // Instructions of the form x := op(y).
 template <InstARM32::InstKindARM32 K>
 class InstARM32UnaryopGPR : public InstARM32 {
   InstARM32UnaryopGPR() = delete;
   InstARM32UnaryopGPR(const InstARM32UnaryopGPR &) = delete;
   InstARM32UnaryopGPR &operator=(const InstARM32UnaryopGPR &) = delete;
 
@@ skipping 110 matching lines @@
 private:
   InstARM32Movlike(Cfg *Func, Variable *Dest, Operand *Source)
       : InstARM32(Func, K, 1, Dest) {
     addSource(Source);
   }
   ~InstARM32Movlike() override {}
 
   static const char *Opcode;
 };
 
+// Instructions of the form x := y op z. May have the side-effect of setting
+// status flags.
+template <InstARM32::InstKindARM32 K>
+class InstARM32ThreeAddrGPR : public InstARM32 {
+  InstARM32ThreeAddrGPR() = delete;
+  InstARM32ThreeAddrGPR(const InstARM32ThreeAddrGPR &) = delete;
+  InstARM32ThreeAddrGPR &operator=(const InstARM32ThreeAddrGPR &) = delete;
+
+public:
+  // Create an ordinary binary-op instruction like add, and sub.
+  // Dest and Src1 must be registers.
+  static InstARM32ThreeAddrGPR *create(Cfg *Func, Variable *Dest,
+                                       Variable *Src1, Operand *Src2,
+                                       bool SetFlags = false) {
+    return new (Func->allocate<InstARM32ThreeAddrGPR>())
+        InstARM32ThreeAddrGPR(Func, Dest, Src1, Src2, SetFlags);
+  }
+  void emit(const Cfg *Func) const override {
+    if (!ALLOW_DUMP)
+      return;
+    emitThreeAddr(Opcode, this, Func, SetFlags);
+  }
+  void emitIAS(const Cfg *Func) const override {
+    (void)Func;
+    llvm::report_fatal_error("Not yet implemented");
+  }
+  void dump(const Cfg *Func) const override {
+    if (!ALLOW_DUMP)
+      return;
+    Ostream &Str = Func->getContext()->getStrDump();
+    dumpDest(Func);
+    Str << " = " << Opcode << (SetFlags ? "s" : "") << "."
+        << getDest()->getType() << " ";
+    dumpSources(Func);
+  }
+  static bool classof(const Inst *Inst) { return isClassof(Inst, K); }
+
+private:
+  InstARM32ThreeAddrGPR(Cfg *Func, Variable *Dest, Variable *Src1,
+                        Operand *Src2, bool SetFlags)
+      : InstARM32(Func, K, 2, Dest), SetFlags(SetFlags) {
+    addSource(Src1);
+    addSource(Src2);
+  }
+  ~InstARM32ThreeAddrGPR() override {}
+  static const char *Opcode;
+  bool SetFlags;
+};
+
+typedef InstARM32ThreeAddrGPR<InstARM32::Adc> InstARM32Adc;
+typedef InstARM32ThreeAddrGPR<InstARM32::Add> InstARM32Add;
+typedef InstARM32ThreeAddrGPR<InstARM32::And> InstARM32And;
+typedef InstARM32ThreeAddrGPR<InstARM32::Eor> InstARM32Eor;
+typedef InstARM32ThreeAddrGPR<InstARM32::Mul> InstARM32Mul;
+typedef InstARM32ThreeAddrGPR<InstARM32::Orr> InstARM32Orr;
+typedef InstARM32ThreeAddrGPR<InstARM32::Sbc> InstARM32Sbc;
+typedef InstARM32ThreeAddrGPR<InstARM32::Sub> InstARM32Sub;
 // Move instruction (variable <- flex). This is more of a pseudo-inst.
 // If var is a register, then we use "mov". If var is stack, then we use
 // "str" to store to the stack.
 typedef InstARM32Movlike<InstARM32::Mov> InstARM32Mov;
 // MovT leaves the bottom bits alone so dest is also a source.
 // This helps indicate that a previous MovW setting dest is not dead code.
 typedef InstARM32TwoAddrGPR<InstARM32::Movt> InstARM32Movt;
 typedef InstARM32UnaryopGPR<InstARM32::Movw> InstARM32Movw;
 typedef InstARM32UnaryopGPR<InstARM32::Mvn> InstARM32Mvn;
 
@@ skipping 11 matching lines @@
   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, Ldr); }
 
 private:
   InstARM32Ldr(Cfg *Func, Variable *Dest, OperandARM32Mem *Mem);
   ~InstARM32Ldr() override {}
 };
 
+// Multiply Accumulate: d := x * y + a
+class InstARM32Mla : public InstARM32 {
+  InstARM32Mla() = delete;
+  InstARM32Mla(const InstARM32Mla &) = delete;
+  InstARM32Mla &operator=(const InstARM32Mla &) = delete;
+
+public:
+  // Everything must be a register.
+  static InstARM32Mla *create(Cfg *Func, Variable *Dest, Variable *Src0,
+                              Variable *Src1, Variable *Acc) {
+    return new (Func->allocate<InstARM32Mla>())
+        InstARM32Mla(Func, Dest, Src0, Src1, Acc);
+  }
+  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, Mla); }
+
+private:
+  InstARM32Mla(Cfg *Func, Variable *Dest, Variable *Src0, Variable *Src1,
+               Variable *Acc);
+  ~InstARM32Mla() override {}
+};
+
 // 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 returning functions) for liveness analysis, though
 // a FakeUse before the ret would do just as well.
 class InstARM32Ret : public InstARM32 {
   InstARM32Ret() = delete;
   InstARM32Ret(const InstARM32Ret &) = delete;
   InstARM32Ret &operator=(const InstARM32Ret &) = delete;
 
 public:
   static InstARM32Ret *create(Cfg *Func, Variable *LR,
                               Variable *Source = nullptr) {
     return new (Func->allocate<InstARM32Ret>()) InstARM32Ret(Func, LR, Source);
   }
   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, Ret); }
 
 private:
   InstARM32Ret(Cfg *Func, Variable *LR, Variable *Source);
   ~InstARM32Ret() override {}
 };
 
+// Unsigned Multiply Long: d.lo, d.hi := x * y
+class InstARM32Umull : public InstARM32 {
+  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) {
+    return new (Func->allocate<InstARM32Umull>())
+        InstARM32Umull(Func, DestLo, DestHi, Src0, Src1);
+  }
+  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);
+  ~InstARM32Umull() override {}
+  Variable *DestHi;
+};
+
 // 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 InstARM32Movw::emit(const Cfg *Func) const;
 template <> void InstARM32Movt::emit(const Cfg *Func) const;
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEINSTARM32_H