Do not use xor-ing on aarch64

Summary: In most x86_64 microarchitectures, xor reg, reg has an optimization to make it faster. On most aarch64, it does not. Instead, the idiom is to use the zero-register and mov it, as in mov reg, xzr. This commit does that instead.

Reviewed By: alexmalyshev

Differential Revision: D94685862

fbshipit-source-id: 9648b9839d01558937d96edbb59de545b9191ab2

Author: kddnewton

cinderx/Jit/codegen/autogen.cpp

@@ -2058,14 +2058,21 @@ void translateMove(Environ* env, const Instruction* instr) {
           loadToReg(as, output, ptr);
           break;
         }
-        case lir::OperandType::kImm:
+        case lir::OperandType::kImm: {
           // Loading a constant immediate into a register.
+          auto constant = input->getConstant();
+
           if (output->isVecD()) {
-            as->fmov(AT::getVecD(output), input->getConstant());
+            as->fmov(AT::getVecD(output), constant);
+          } else if (constant == 0) {
+            as->mov(
+                AT::getGpWiden(output),
+                AT::getGpWiden(output->dataType(), a64::xzr.id()));
           } else {
-            as->mov(AT::getGpWiden(output), input->getConstant());
+            as->mov(AT::getGpWiden(output), constant);
           }
           break;
+        }
         case lir::OperandType::kNone:
         case lir::OperandType::kVreg:
         case lir::OperandType::kLabel:

cinderx/Jit/lir/postalloc.cpp

@@ -456,7 +456,7 @@ RewriteResult rewriteBranchInstrs(Function* function) {
 // rewrite move instructions
 // optimize move instruction in the following cases:
 //   1. remove the move instruction when source and destination are the same
-//   2. rewrite move instruction to xor when the source operand is 0.
+//   2. rewrite move instruction to xor when the source operand is 0 on x86_64.
 RewriteResult optimizeMoveInstrs(instr_iter_t instr_iter) {
   auto instr = instr_iter->get();
   auto instr_opcode = instr->opcode();
@@ -474,6 +474,7 @@ RewriteResult optimizeMoveInstrs(instr_iter_t instr_iter) {
     return kRemoved;
   }
 
+#if defined(CINDER_X86_64)
   if (in->isImm() && !in->isFp() && in->getConstant() == 0 && out->isReg()) {
     auto in_opnd = dynamic_cast<Operand*>(in);
     JIT_CHECK(
@@ -488,6 +489,7 @@ RewriteResult optimizeMoveInstrs(instr_iter_t instr_iter) {
     instr->addOperands(PhyReg{reg, data_type}, PhyReg{reg, data_type});
     return kChanged;
   }
+#endif
 
   return kUnchanged;
 }