From a26730485a4c1de5c0600a00fe7de3a247ce268a Mon Sep 17 00:00:00 2001
From: Alex Malyshev <alexanderm@meta.com>
Date: Thu, 13 Jul 2023 05:52:32 -0700
Subject: [PATCH] Simplify PrimitiveCompare LIR generation

Summary:
If we cut out the stringification layer, we no longer need to do the check for
doubles.  The HIR type gets autotranslated to an LIR DataType, and everything
just works.

Reviewed By: swtaarrs

Differential Revision: D47294146

fbshipit-source-id: af626db7e65972e90135526df49b459af8c43b76
---
 Jit/lir/generator.cpp | 44 +++++++++++++------------------------------
 1 file changed, 13 insertions(+), 31 deletions(-)

diff --git a/Jit/lir/generator.cpp b/Jit/lir/generator.cpp
index cbca8f9c244..0a52ff95927 100644
--- a/Jit/lir/generator.cpp
+++ b/Jit/lir/generator.cpp
@@ -890,61 +890,43 @@ LIRGenerator::TranslatedBlock LIRGenerator::TranslateOneBasicBlock(
       }
       case Opcode::kPrimitiveCompare: {
         auto instr = static_cast<const PrimitiveCompare*>(&i);
-        std::string op;
+        Instruction::Opcode op;
         switch (instr->op()) {
           case PrimitiveCompareOp::kEqual:
-            op = "Equal";
+            op = Instruction::kEqual;
             break;
           case PrimitiveCompareOp::kNotEqual:
-            op = "NotEqual";
+            op = Instruction::kNotEqual;
             break;
           case PrimitiveCompareOp::kGreaterThanUnsigned:
-            op = "GreaterThanUnsigned";
+            op = Instruction::kGreaterThanUnsigned;
             break;
           case PrimitiveCompareOp::kGreaterThan:
-            op = "GreaterThanSigned";
+            op = Instruction::kGreaterThanSigned;
             break;
           case PrimitiveCompareOp::kLessThanUnsigned:
-            op = "LessThanUnsigned";
+            op = Instruction::kLessThanUnsigned;
             break;
           case PrimitiveCompareOp::kLessThan:
-            op = "LessThanSigned";
+            op = Instruction::kLessThanSigned;
             break;
           case PrimitiveCompareOp::kGreaterThanEqualUnsigned:
-            op = "GreaterThanEqualUnsigned";
+            op = Instruction::kGreaterThanEqualUnsigned;
             break;
           case PrimitiveCompareOp::kGreaterThanEqual:
-            op = "GreaterThanEqualSigned";
+            op = Instruction::kGreaterThanEqualSigned;
             break;
           case PrimitiveCompareOp::kLessThanEqualUnsigned:
-            op = "LessThanEqualUnsigned";
+            op = Instruction::kLessThanEqualUnsigned;
             break;
           case PrimitiveCompareOp::kLessThanEqual:
-            op = "LessThanEqualSigned";
+            op = Instruction::kLessThanEqualSigned;
             break;
           default:
-            JIT_ABORT("not implemented %d", (int)instr->op());
+            JIT_ABORT("Not implemented %d", static_cast<int>(instr->op()));
             break;
         }
-
-        if (instr->left()->type() <= TCDouble ||
-            instr->right()->type() <= TCDouble) {
-          // Manually format the code string, otherwise registers with literal
-          // values end up being treated as immediates, and there's no way to
-          // load immediates in an XMM register.
-          auto codestr = fmt::format(
-              "{} {}, {}:{}, {}:{}",
-              op,
-              instr->dst(),
-              instr->left()->name(),
-              instr->left()->type().unspecialized(),
-              instr->right()->name(),
-              instr->right()->type().unspecialized());
-          bbb.AppendCode(codestr);
-        } else {
-          bbb.AppendCode(
-              "{} {} {} {}", op, instr->dst(), instr->left(), instr->right());
-        }
+        bbb.appendInstr(instr->dst(), op, instr->left(), instr->right());
         break;
       }
       case Opcode::kPrimitiveBoxBool: {