Subzero. Introduces a new LoweringContext::insert() method.

src/IceTargetLoweringARM32.h

 //===- subzero/src/IceTargetLoweringARM32.h - ARM32 lowering ----*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 259 matching lines @@
   void lowerIDivRem(Variable *Dest, Variable *T, Variable *Src0R, Operand *Src1,
                     ExtInstr ExtFunc, DivInstr DivFunc, bool IsRemainder);
 
   void lowerCLZ(Variable *Dest, Variable *ValLo, Variable *ValHi);
 
   // The following are helpers that insert lowered ARM32 instructions with
   // minimal syntactic overhead, so that the lowering code can look as close to
   // assembly as practical.
   void _add(Variable *Dest, Variable *Src0, Operand *Src1,
             CondARM32::Cond Pred = CondARM32::AL) {
-    Context.insert(InstARM32Add::create(Func, Dest, Src0, Src1, Pred));
+    Context.insert<InstARM32Add>(Dest, Src0, Src1, Pred);
   }
   void _adds(Variable *Dest, Variable *Src0, Operand *Src1,
              CondARM32::Cond Pred = CondARM32::AL) {
     constexpr bool SetFlags = true;
-    Context.insert(
-        InstARM32Add::create(Func, Dest, Src0, Src1, Pred, SetFlags));
+    Context.insert<InstARM32Add>(Dest, Src0, Src1, Pred, SetFlags);
   }
   void _adc(Variable *Dest, Variable *Src0, Operand *Src1,
             CondARM32::Cond Pred = CondARM32::AL) {
-    Context.insert(InstARM32Adc::create(Func, Dest, Src0, Src1, Pred));
+    Context.insert<InstARM32Adc>(Dest, Src0, Src1, Pred);
   }
   void _and(Variable *Dest, Variable *Src0, Operand *Src1,
             CondARM32::Cond Pred = CondARM32::AL) {
-    Context.insert(InstARM32And::create(Func, Dest, Src0, Src1, Pred));
+    Context.insert<InstARM32And>(Dest, Src0, Src1, Pred);
   }
   void _asr(Variable *Dest, Variable *Src0, Operand *Src1,
             CondARM32::Cond Pred = CondARM32::AL) {
-    Context.insert(InstARM32Asr::create(Func, Dest, Src0, Src1, Pred));
+    Context.insert<InstARM32Asr>(Dest, Src0, Src1, Pred);
   }
   void _bic(Variable *Dest, Variable *Src0, Operand *Src1,
             CondARM32::Cond Pred = CondARM32::AL) {
-    Context.insert(InstARM32Bic::create(Func, Dest, Src0, Src1, Pred));
+    Context.insert<InstARM32Bic>(Dest, Src0, Src1, Pred);
   }
   void _br(CfgNode *TargetTrue, CfgNode *TargetFalse,
            CondARM32::Cond Condition) {
-    Context.insert(
-        InstARM32Br::create(Func, TargetTrue, TargetFalse, Condition));
+    Context.insert<InstARM32Br>(TargetTrue, TargetFalse, Condition);
   }
-  void _br(CfgNode *Target) {
-    Context.insert(InstARM32Br::create(Func, Target));
-  }
+  void _br(CfgNode *Target) { Context.insert<InstARM32Br>(Target); }
   void _br(CfgNode *Target, CondARM32::Cond Condition) {
-    Context.insert(InstARM32Br::create(Func, Target, Condition));
+    Context.insert<InstARM32Br>(Target, Condition);
   }
   void _br(InstARM32Label *Label, CondARM32::Cond Condition) {
-    Context.insert(InstARM32Br::create(Func, Label, Condition));
+    Context.insert<InstARM32Br>(Label, Condition);
   }
   void _cmn(Variable *Src0, Operand *Src1,
             CondARM32::Cond Pred = CondARM32::AL) {
-    Context.insert(InstARM32Cmn::create(Func, Src0, Src1, Pred));
+    Context.insert<InstARM32Cmn>(Src0, Src1, Pred);
   }
   void _cmp(Variable *Src0, Operand *Src1,
             CondARM32::Cond Pred = CondARM32::AL) {
-    Context.insert(InstARM32Cmp::create(Func, Src0, Src1, Pred));
+    Context.insert<InstARM32Cmp>(Src0, Src1, Pred);
   }
   void _clz(Variable *Dest, Variable *Src0,
             CondARM32::Cond Pred = CondARM32::AL) {
-    Context.insert(InstARM32Clz::create(Func, Dest, Src0, Pred));
+    Context.insert<InstARM32Clz>(Dest, Src0, Pred);
   }
-  void _dmb() { Context.insert(InstARM32Dmb::create(Func)); }
+  void _dmb() { Context.insert<InstARM32Dmb>(); }
   void _eor(Variable *Dest, Variable *Src0, Operand *Src1,
             CondARM32::Cond Pred = CondARM32::AL) {
-    Context.insert(InstARM32Eor::create(Func, Dest, Src0, Src1, Pred));
+    Context.insert<InstARM32Eor>(Dest, Src0, Src1, Pred);
   }
   /// _ldr, for all your memory to Variable data moves. It handles all types
   /// (integer, floating point, and vectors.) Addr needs to be valid for Dest's
   /// type (e.g., no immediates for vector loads, and no index registers for fp
   /// loads.)
   void _ldr(Variable *Dest, OperandARM32Mem *Addr,
             CondARM32::Cond Pred = CondARM32::AL) {
-    Context.insert(InstARM32Ldr::create(Func, Dest, Addr, Pred));
+    Context.insert<InstARM32Ldr>(Dest, Addr, Pred);
   }
   void _ldrex(Variable *Dest, OperandARM32Mem *Addr,
               CondARM32::Cond Pred = CondARM32::AL) {
-    Context.insert(InstARM32Ldrex::create(Func, Dest, Addr, Pred));
+    Context.insert<InstARM32Ldrex>(Dest, Addr, Pred);
     if (auto *Dest64 = llvm::dyn_cast<Variable64On32>(Dest)) {
-      Context.insert(InstFakeDef::create(Func, Dest64->getLo(), Dest));
-      Context.insert(InstFakeDef::create(Func, Dest64->getHi(), Dest));
+      Context.insert<InstFakeDef>(Dest64->getLo(), Dest);
+      Context.insert<InstFakeDef>(Dest64->getHi(), Dest);
     }
   }
   void _lsl(Variable *Dest, Variable *Src0, Operand *Src1,
             CondARM32::Cond Pred = CondARM32::AL) {
-    Context.insert(InstARM32Lsl::create(Func, Dest, Src0, Src1, Pred));
+    Context.insert<InstARM32Lsl>(Dest, Src0, Src1, Pred);
   }
   void _lsls(Variable *Dest, Variable *Src0, Operand *Src1,
              CondARM32::Cond Pred = CondARM32::AL) {
     constexpr bool SetFlags = true;
-    Context.insert(
-        InstARM32Lsl::create(Func, Dest, Src0, Src1, Pred, SetFlags));
+    Context.insert<InstARM32Lsl>(Dest, Src0, Src1, Pred, SetFlags);
   }
   void _lsr(Variable *Dest, Variable *Src0, Operand *Src1,
             CondARM32::Cond Pred = CondARM32::AL) {
-    Context.insert(InstARM32Lsr::create(Func, Dest, Src0, Src1, Pred));
+    Context.insert<InstARM32Lsr>(Dest, Src0, Src1, Pred);
   }
   void _mla(Variable *Dest, Variable *Src0, Variable *Src1, Variable *Acc,
             CondARM32::Cond Pred = CondARM32::AL) {
-    Context.insert(InstARM32Mla::create(Func, Dest, Src0, Src1, Acc, Pred));
+    Context.insert<InstARM32Mla>(Dest, Src0, Src1, Acc, Pred);
   }
   void _mls(Variable *Dest, Variable *Src0, Variable *Src1, Variable *Acc,
             CondARM32::Cond Pred = CondARM32::AL) {
-    Context.insert(InstARM32Mls::create(Func, Dest, Src0, Src1, Acc, Pred));
+    Context.insert<InstARM32Mls>(Dest, Src0, Src1, Acc, Pred);
   }
   /// _mov, for all your Variable to Variable data movement needs. It handles
   /// all types (integer, floating point, and vectors), as well as moves between
   /// Core and VFP registers. This is not a panacea: you must obey the (weird,
   /// confusing, non-uniform) rules for data moves in ARM.
   void _mov(Variable *Dest, Operand *Src0,
             CondARM32::Cond Pred = CondARM32::AL) {
     // _mov used to be unique in the sense that it would create a temporary
     // automagically if Dest was nullptr. It won't do that anymore, so we keep
     // an assert around just in case there is some untested code path where Dest
     // is nullptr.
     assert(Dest != nullptr);
     assert(!llvm::isa<OperandARM32Mem>(Src0));
-    auto *Instr = InstARM32Mov::create(Func, Dest, Src0, Pred);
+    auto *Instr = Context.insert<InstARM32Mov>(Dest, Src0, Pred);
 
-    Context.insert(Instr);
     if (Instr->isMultiDest()) {
       // If Instr is multi-dest, then Dest must be a Variable64On32. We add a
       // fake-def for Instr.DestHi here.
       assert(llvm::isa<Variable64On32>(Dest));
-      Context.insert(InstFakeDef::create(Func, Instr->getDestHi()));
+      Context.insert<InstFakeDef>(Instr->getDestHi());
     }
   }
 
   void _mov_redefined(Variable *Dest, Operand *Src0,
                       CondARM32::Cond Pred = CondARM32::AL) {
-    auto *Instr = InstARM32Mov::create(Func, Dest, Src0, Pred);
+    auto *Instr = Context.insert<InstARM32Mov>(Dest, Src0, Pred);
     Instr->setDestRedefined();
-    Context.insert(Instr);
     if (Instr->isMultiDest()) {
       // If Instr is multi-dest, then Dest must be a Variable64On32. We add a
       // fake-def for Instr.DestHi here.
       assert(llvm::isa<Variable64On32>(Dest));
-      Context.insert(InstFakeDef::create(Func, Instr->getDestHi()));
+      Context.insert<InstFakeDef>(Instr->getDestHi());
     }
   }
 
   // --------------------------------------------------------------------------
   // Begin bool folding machinery.
   //
   // There are three types of boolean lowerings handled by this target:
   //
   // 1) Boolean expressions leading to a boolean Variable definition
   // ---------------------------------------------------------------
@@ skipping 214 matching lines @@
       _br(Target, Cond.WhenTrue0);
     }
   }
   // End of bool folding machinery
   // --------------------------------------------------------------------------
 
   /// The Operand can only be a 16-bit immediate or a ConstantRelocatable (with
   /// an upper16 relocation).
   void _movt(Variable *Dest, Operand *Src0,
              CondARM32::Cond Pred = CondARM32::AL) {
-    Context.insert(InstARM32Movt::create(Func, Dest, Src0, Pred));
+    Context.insert<InstARM32Movt>(Dest, Src0, Pred);
   }
   void _movw(Variable *Dest, Operand *Src0,
              CondARM32::Cond Pred = CondARM32::AL) {
-    Context.insert(InstARM32Movw::create(Func, Dest, Src0, Pred));
+    Context.insert<InstARM32Movw>(Dest, Src0, Pred);
   }
   void _mul(Variable *Dest, Variable *Src0, Variable *Src1,
             CondARM32::Cond Pred = CondARM32::AL) {
-    Context.insert(InstARM32Mul::create(Func, Dest, Src0, Src1, Pred));
+    Context.insert<InstARM32Mul>(Dest, Src0, Src1, Pred);
   }
   void _mvn(Variable *Dest, Operand *Src0,
             CondARM32::Cond Pred = CondARM32::AL) {
-    Context.insert(InstARM32Mvn::create(Func, Dest, Src0, Pred));
+    Context.insert<InstARM32Mvn>(Dest, Src0, Pred);
   }
   void _orr(Variable *Dest, Variable *Src0, Operand *Src1,
             CondARM32::Cond Pred = CondARM32::AL) {
-    Context.insert(InstARM32Orr::create(Func, Dest, Src0, Src1, Pred));
+    Context.insert<InstARM32Orr>(Dest, Src0, Src1, Pred);
   }
   void _orrs(Variable *Dest, Variable *Src0, Operand *Src1,
              CondARM32::Cond Pred = CondARM32::AL) {
     constexpr bool SetFlags = true;
-    Context.insert(
-        InstARM32Orr::create(Func, Dest, Src0, Src1, Pred, SetFlags));
+    Context.insert<InstARM32Orr>(Dest, Src0, Src1, Pred, SetFlags);
   }
-  void _push(const VarList &Sources) {
-    Context.insert(InstARM32Push::create(Func, Sources));
-  }
+  void _push(const VarList &Sources) { Context.insert<InstARM32Push>(Sources); }
   void _pop(const VarList &Dests) {
-    Context.insert(InstARM32Pop::create(Func, Dests));
+    Context.insert<InstARM32Pop>(Dests);
     // Mark dests as modified.
     for (Variable *Dest : Dests)
-      Context.insert(InstFakeDef::create(Func, Dest));
+      Context.insert<InstFakeDef>(Dest);
   }
   void _rbit(Variable *Dest, Variable *Src0,
              CondARM32::Cond Pred = CondARM32::AL) {
-    Context.insert(InstARM32Rbit::create(Func, Dest, Src0, Pred));
+    Context.insert<InstARM32Rbit>(Dest, Src0, Pred);
   }
   void _rev(Variable *Dest, Variable *Src0,
             CondARM32::Cond Pred = CondARM32::AL) {
-    Context.insert(InstARM32Rev::create(Func, Dest, Src0, Pred));
+    Context.insert<InstARM32Rev>(Dest, Src0, Pred);
   }
   void _ret(Variable *LR, Variable *Src0 = nullptr) {
-    Context.insert(InstARM32Ret::create(Func, LR, Src0));
+    Context.insert<InstARM32Ret>(LR, Src0);
   }
   void _rscs(Variable *Dest, Variable *Src0, Operand *Src1,
              CondARM32::Cond Pred = CondARM32::AL) {
     constexpr bool SetFlags = true;
-    Context.insert(
-        InstARM32Rsc::create(Func, Dest, Src0, Src1, Pred, SetFlags));
+    Context.insert<InstARM32Rsc>(Dest, Src0, Src1, Pred, SetFlags);
   }
   void _rsc(Variable *Dest, Variable *Src0, Operand *Src1,
             CondARM32::Cond Pred = CondARM32::AL) {
-    Context.insert(InstARM32Rsc::create(Func, Dest, Src0, Src1, Pred));
+    Context.insert<InstARM32Rsc>(Dest, Src0, Src1, Pred);
   }
   void _rsbs(Variable *Dest, Variable *Src0, Operand *Src1,
              CondARM32::Cond Pred = CondARM32::AL) {
     constexpr bool SetFlags = true;
-    Context.insert(
-        InstARM32Rsb::create(Func, Dest, Src0, Src1, Pred, SetFlags));
+    Context.insert<InstARM32Rsb>(Dest, Src0, Src1, Pred, SetFlags);
   }
   void _rsb(Variable *Dest, Variable *Src0, Operand *Src1,
             CondARM32::Cond Pred = CondARM32::AL) {
-    Context.insert(InstARM32Rsb::create(Func, Dest, Src0, Src1, Pred));
+    Context.insert<InstARM32Rsb>(Dest, Src0, Src1, Pred);
   }
   void _sbc(Variable *Dest, Variable *Src0, Operand *Src1,
             CondARM32::Cond Pred = CondARM32::AL) {
-    Context.insert(InstARM32Sbc::create(Func, Dest, Src0, Src1, Pred));
+    Context.insert<InstARM32Sbc>(Dest, Src0, Src1, Pred);
   }
   void _sbcs(Variable *Dest, Variable *Src0, Operand *Src1,
              CondARM32::Cond Pred = CondARM32::AL) {
     constexpr bool SetFlags = true;
-    Context.insert(
-        InstARM32Sbc::create(Func, Dest, Src0, Src1, Pred, SetFlags));
+    Context.insert<InstARM32Sbc>(Dest, Src0, Src1, Pred, SetFlags);
   }
   void _sdiv(Variable *Dest, Variable *Src0, Variable *Src1,
              CondARM32::Cond Pred = CondARM32::AL) {
-    Context.insert(InstARM32Sdiv::create(Func, Dest, Src0, Src1, Pred));
+    Context.insert<InstARM32Sdiv>(Dest, Src0, Src1, Pred);
   }
   /// _str, for all your Variable to memory transfers. Addr has the same
   /// restrictions that it does in _ldr.
   void _str(Variable *Value, OperandARM32Mem *Addr,
             CondARM32::Cond Pred = CondARM32::AL) {
-    Context.insert(InstARM32Str::create(Func, Value, Addr, Pred));
+    Context.insert<InstARM32Str>(Value, Addr, Pred);
   }
   void _strex(Variable *Dest, Variable *Value, OperandARM32Mem *Addr,
               CondARM32::Cond Pred = CondARM32::AL) {
     // strex requires Dest to be a register other than Value or Addr. This
     // restriction is cleanly represented by adding an "early" definition of
     // Dest (or a latter use of all the sources.)
-    Context.insert(InstFakeDef::create(Func, Dest));
+    Context.insert<InstFakeDef>(Dest);
     if (auto *Value64 = llvm::dyn_cast<Variable64On32>(Value)) {
-      Context.insert(InstFakeUse::create(Func, Value64->getLo()));
-      Context.insert(InstFakeUse::create(Func, Value64->getHi()));
+      Context.insert<InstFakeUse>(Value64->getLo());
+      Context.insert<InstFakeUse>(Value64->getHi());
     }
-    auto *Instr = InstARM32Strex::create(Func, Dest, Value, Addr, Pred);
-    Context.insert(Instr);
+    auto *Instr = Context.insert<InstARM32Strex>(Dest, Value, Addr, Pred);
     Instr->setDestRedefined();
   }
   void _sub(Variable *Dest, Variable *Src0, Operand *Src1,
             CondARM32::Cond Pred = CondARM32::AL) {
-    Context.insert(InstARM32Sub::create(Func, Dest, Src0, Src1, Pred));
+    Context.insert<InstARM32Sub>(Dest, Src0, Src1, Pred);
   }
   void _subs(Variable *Dest, Variable *Src0, Operand *Src1,
              CondARM32::Cond Pred = CondARM32::AL) {
     constexpr bool SetFlags = true;
-    Context.insert(
-        InstARM32Sub::create(Func, Dest, Src0, Src1, Pred, SetFlags));
+    Context.insert<InstARM32Sub>(Dest, Src0, Src1, Pred, SetFlags);
   }
   void _sxt(Variable *Dest, Variable *Src0,
             CondARM32::Cond Pred = CondARM32::AL) {
-    Context.insert(InstARM32Sxt::create(Func, Dest, Src0, Pred));
+    Context.insert<InstARM32Sxt>(Dest, Src0, Pred);
   }
   void _tst(Variable *Src0, Operand *Src1,
             CondARM32::Cond Pred = CondARM32::AL) {
-    Context.insert(InstARM32Tst::create(Func, Src0, Src1, Pred));
+    Context.insert<InstARM32Tst>(Src0, Src1, Pred);
   }
-  void _trap() { Context.insert(InstARM32Trap::create(Func)); }
+  void _trap() { Context.insert<InstARM32Trap>(); }
   void _udiv(Variable *Dest, Variable *Src0, Variable *Src1,
              CondARM32::Cond Pred = CondARM32::AL) {
-    Context.insert(InstARM32Udiv::create(Func, Dest, Src0, Src1, Pred));
+    Context.insert<InstARM32Udiv>(Dest, Src0, Src1, Pred);
   }
   void _umull(Variable *DestLo, Variable *DestHi, Variable *Src0,
               Variable *Src1, CondARM32::Cond Pred = CondARM32::AL) {
-    Context.insert(
-        InstARM32Umull::create(Func, DestLo, DestHi, Src0, Src1, Pred));
+    Context.insert<InstARM32Umull>(DestLo, DestHi, Src0, Src1, Pred);
     // Model the modification to the second dest as a fake def. Note that the
     // def is not predicated.
-    Context.insert(InstFakeDef::create(Func, DestHi, DestLo));
+    Context.insert<InstFakeDef>(DestHi, DestLo);
   }
   void _uxt(Variable *Dest, Variable *Src0,
             CondARM32::Cond Pred = CondARM32::AL) {
-    Context.insert(InstARM32Uxt::create(Func, Dest, Src0, Pred));
+    Context.insert<InstARM32Uxt>(Dest, Src0, Pred);
   }
   void _vabs(Variable *Dest, Variable *Src,
              CondARM32::Cond Pred = CondARM32::AL) {
-    Context.insert(InstARM32Vabs::create(Func, Dest, Src, Pred));
+    Context.insert<InstARM32Vabs>(Dest, Src, Pred);
   }
   void _vadd(Variable *Dest, Variable *Src0, Variable *Src1) {
-    Context.insert(InstARM32Vadd::create(Func, Dest, Src0, Src1));
+    Context.insert<InstARM32Vadd>(Dest, Src0, Src1);
   }
   void _vcvt(Variable *Dest, Variable *Src, InstARM32Vcvt::VcvtVariant Variant,
              CondARM32::Cond Pred = CondARM32::AL) {
-    Context.insert(InstARM32Vcvt::create(Func, Dest, Src, Variant, Pred));
+    Context.insert<InstARM32Vcvt>(Dest, Src, Variant, Pred);
   }
   void _vdiv(Variable *Dest, Variable *Src0, Variable *Src1) {
-    Context.insert(InstARM32Vdiv::create(Func, Dest, Src0, Src1));
+    Context.insert<InstARM32Vdiv>(Dest, Src0, Src1);
   }
   void _vcmp(Variable *Src0, Variable *Src1,
              CondARM32::Cond Pred = CondARM32::AL) {
-    Context.insert(InstARM32Vcmp::create(Func, Src0, Src1, Pred));
+    Context.insert<InstARM32Vcmp>(Src0, Src1, Pred);
   }
   void _vcmp(Variable *Src0, OperandARM32FlexFpZero *FpZero,
              CondARM32::Cond Pred = CondARM32::AL) {
-    Context.insert(InstARM32Vcmp::create(Func, Src0, FpZero, Pred));
+    Context.insert<InstARM32Vcmp>(Src0, FpZero, Pred);
   }
   void _veor(Variable *Dest, Variable *Src0, Variable *Src1) {
-    Context.insert(InstARM32Veor::create(Func, Dest, Src0, Src1));
+    Context.insert<InstARM32Veor>(Dest, Src0, Src1);
   }
   void _vmrs(CondARM32::Cond Pred = CondARM32::AL) {
-    Context.insert(InstARM32Vmrs::create(Func, Pred));
+    Context.insert<InstARM32Vmrs>(Pred);
   }
   void _vmla(Variable *Dest, Variable *Src0, Variable *Src1) {
-    Context.insert(InstARM32Vmla::create(Func, Dest, Src0, Src1));
+    Context.insert<InstARM32Vmla>(Dest, Src0, Src1);
   }
   void _vmls(Variable *Dest, Variable *Src0, Variable *Src1) {
-    Context.insert(InstARM32Vmls::create(Func, Dest, Src0, Src1));
+    Context.insert<InstARM32Vmls>(Dest, Src0, Src1);
   }
   void _vmul(Variable *Dest, Variable *Src0, Variable *Src1) {
-    Context.insert(InstARM32Vmul::create(Func, Dest, Src0, Src1));
+    Context.insert<InstARM32Vmul>(Dest, Src0, Src1);
   }
   void _vsqrt(Variable *Dest, Variable *Src,
               CondARM32::Cond Pred = CondARM32::AL) {
-    Context.insert(InstARM32Vsqrt::create(Func, Dest, Src, Pred));
+    Context.insert<InstARM32Vsqrt>(Dest, Src, Pred);
   }
   void _vsub(Variable *Dest, Variable *Src0, Variable *Src1) {
-    Context.insert(InstARM32Vsub::create(Func, Dest, Src0, Src1));
+    Context.insert<InstARM32Vsub>(Dest, Src0, Src1);
   }
 
   // Iterates over the CFG and determines the maximum outgoing stack arguments
   // bytes. This information is later used during addProlog() to pre-allocate
   // the outargs area.
   // TODO(jpp): This could live in the Parser, if we provided a Target-specific
   // method that the Parser could call.
   void findMaxStackOutArgsSize();
 
   /// Returns true if the given Offset can be represented in a Load/Store Mem
@@ skipping 383 matching lines @@
 
 private:
   ~TargetHeaderARM32() = default;
 
   TargetARM32Features CPUFeatures;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICETARGETLOWERINGARM32_H