[LoongArch] Use tablegen size for getInstSizeInBytes

[XiaodongLoong]

Summary

Correct the pseudo atomic instruction size for branch
relaxation and branch folding passes.

Inspired by D118175, D118009 and D117970.

Depends on D138481

[SixWeining]

LGTM. But tt's better be checked by @gonglingqin who wrote most of the AMO pseudos.

llvm/unittests/Target/LoongArch/InstSizes.cpp

118–130

This is less readable. Could you write each instruction in one line. If clang-format fail, clang-format off/on may help.

[xry111]

And maybe this need to be sequenced after D138481?

[XiaodongLoong]

More readable.

[XiaodongLoong]

In D138469#3943679, @xry111 wrote:

And maybe this need to be sequenced after D138481?

Yes, you are right.

[gonglingqin]

LGTM.

[XiaodongLoong]

Update for AMMax and AMMin

[XiaodongLoong]

Rebase code.

[thakis]

llvm/unittests/Target/LoongArch/CMakeLists.txt

11

Do you need all these dependencies? From a quick look, InstSizes.cpp seems to not include files from most of these.

[thakis]

The test added in this change fails:

[ RUN      ] InstSizes.AtomicPseudo

# Machine code for function sizes: IsSSA, NoPHIs, NoVRegs
Jump Tables:
%jump-table.0: %bb.0


bb.0:
  dead early-clobber renamable $r10, dead early-clobber renamable $r11 = PseudoMaskedAtomicLoadAdd32 renamable $r7, renamable $r6, renamable $r8, 4
  dead early-clobber renamable $r10, dead early-clobber renamable $r11 = PseudoAtomicLoadAdd32 renamable $r7, renamable $r6
  dead early-clobber renamable $r5, dead early-clobber renamable $r9, dead early-clobber renamable $r10 = PseudoMaskedAtomicLoadUMax32 renamable $r7, renamable $r6, renamable $r8, 4
  early-clobber renamable $r9, dead early-clobber renamable $r10, dead early-clobber renamable $r11 = PseudoMaskedAtomicLoadMax32 killed renamable $r6, killed renamable $r5, killed renamable $r7, killed renamable $r8, 4
  dead early-clobber renamable $r5, dead early-clobber renamable $r9 = PseudoCmpXchg32 renamable $r7, renamable $r4, renamable $r6
  dead early-clobber renamable $r5, dead early-clobber renamable $r9 = PseudoMaskedCmpXchg32 killed renamable $r7, killed renamable $r4, killed renamable $r6, killed renamable $r8, 4

# End machine code for function sizes.

*** Bad machine code: Too few operands ***
- function:    sizes
- basic block: %bb.0  (0x14181e4c8)
- instruction: dead early-clobber renamable $r10, dead early-clobber renamable $r11 = PseudoAtomicLoadAdd32 renamable $r7, renamable $r6
5 operands expected, but 4 given.
LLVM ERROR: Found 1 machine code errors.

Please take a look and revert for now if it takes a while to fix.

[thakis]

I reverted this for now in d4c5c7e0acc4372b5686e453c4dc0a59e4b83058.

[XiaodongLoong]

@thakis OK, Thank you a lot.

[XiaodongLoong]

Fix the test error.

[XiaodongLoong]

llvm/unittests/Target/LoongArch/CMakeLists.txt

11

Thanks, I delete the redundant dependencies.

[XiaodongLoong]

Rebase code.

llvm/lib/Target/LoongArch/LoongArchInstrInfo.cpp

for (auto &Inst : Seq) {
     }
 
     // Only the first instruction has $zero as its source.
     SrcReg = DstReg;
   }
 }
 
 unsigned LoongArchInstrInfo::getInstSizeInBytes(const MachineInstr &MI) const {
-  if (MI.getOpcode() == TargetOpcode::INLINEASM) {
+  unsigned Opcode = MI.getOpcode();
+
+  if (Opcode == TargetOpcode::INLINEASM ||
+      Opcode == TargetOpcode::INLINEASM_BR) {
     const MachineFunction *MF = MI.getParent()->getParent();
     const MCAsmInfo *MAI = MF->getTarget().getMCAsmInfo();
     return getInlineAsmLength(MI.getOperand(0).getSymbolName(), *MAI);
   }
   return MI.getDesc().getSize();
 }
 
 MachineBasicBlock *

llvm/lib/Target/LoongArch/LoongArchInstrInfo.td

 
 class PseudoMaskedAM
     : Pseudo<(outs GPR:$res, GPR:$scratch),
              (ins GPR:$addr, GPR:$incr, GPR:$mask, grlenimm:$ordering)> {
   let Constraints = "@earlyclobber $res,@earlyclobber $scratch";
   let mayLoad = 1;
   let mayStore = 1;
   let hasSideEffects = 0;
+  let Size = 36;
 }
 
 def PseudoMaskedAtomicSwap32 : PseudoMaskedAM;
 def PseudoMaskedAtomicLoadAdd32 : PseudoMaskedAM;
 def PseudoMaskedAtomicLoadSub32 : PseudoMaskedAM;
 def PseudoMaskedAtomicLoadNand32 : PseudoMaskedAM;
 
 class PseudoAM : Pseudo<(outs GPR:$res, GPR:$scratch),
                         (ins GPR:$addr, GPR:$incr, grlenimm:$ordering)> {
   let Constraints = "@earlyclobber $res,@earlyclobber $scratch";
   let mayLoad = 1;
   let mayStore = 1;
   let hasSideEffects = 0;
+  let Size = 24;
 }
 
 def PseudoAtomicSwap32 : PseudoAM;
 def PseudoAtomicLoadNand32 : PseudoAM;
 def PseudoAtomicLoadNand64 : PseudoAM;
 def PseudoAtomicLoadAdd32 : PseudoAM;
 def PseudoAtomicLoadSub32 : PseudoAM;
 def PseudoAtomicLoadAnd32 : PseudoAM;

 class PseudoMaskedAMUMinUMax
     : Pseudo<(outs GPR:$res, GPR:$scratch1, GPR:$scratch2),
              (ins GPR:$addr, GPR:$incr, GPR:$mask, grlenimm:$ordering)> {
   let Constraints = "@earlyclobber $res,@earlyclobber $scratch1,"
                     "@earlyclobber $scratch2";
   let mayLoad = 1;
   let mayStore = 1;
   let hasSideEffects = 0;
+  let Size = 48;
 }
 
 def PseudoMaskedAtomicLoadUMax32 : PseudoMaskedAMUMinUMax;
 def PseudoMaskedAtomicLoadUMin32 : PseudoMaskedAMUMinUMax;
 
 class PseudoMaskedAMMinMax
     : Pseudo<(outs GPR:$res, GPR:$scratch1, GPR:$scratch2),
              (ins GPR:$addr, GPR:$incr, GPR:$mask, grlenimm:$sextshamt,
               grlenimm:$ordering)> {
   let Constraints = "@earlyclobber $res,@earlyclobber $scratch1,"
                     "@earlyclobber $scratch2";
   let mayLoad = 1;
   let mayStore = 1;
   let hasSideEffects = 0;
+  let Size = 56;
 }
 
 def PseudoMaskedAtomicLoadMax32 : PseudoMaskedAMMinMax;
 def PseudoMaskedAtomicLoadMin32 : PseudoMaskedAMMinMax;
 
 /// Compare and exchange
 
 class PseudoCmpXchg
     : Pseudo<(outs GPR:$res, GPR:$scratch),
              (ins GPR:$addr, GPR:$cmpval, GPR:$newval)> {
   let Constraints = "@earlyclobber $res,@earlyclobber $scratch";
   let mayLoad = 1;
   let mayStore = 1;
   let hasSideEffects = 0;
+  let Size = 36;
 }
 
 def PseudoCmpXchg32 : PseudoCmpXchg;
 def PseudoCmpXchg64 : PseudoCmpXchg;
 
 def PseudoMaskedCmpXchg32
     : Pseudo<(outs GPR:$res, GPR:$scratch),
              (ins GPR:$addr, GPR:$cmpval, GPR:$newval, GPR:$mask,
               grlenimm:$ordering)> {
   let Constraints = "@earlyclobber $res,@earlyclobber $scratch";
   let mayLoad = 1;
   let mayStore = 1;
   let hasSideEffects = 0;
+  let Size = 44;
 }
 
 class PseudoMaskedAMMinMaxPat<Intrinsic intrin, Pseudo AMInst>
     : Pat<(intrin GPR:$addr, GPR:$incr, GPR:$mask, GPR:$shiftamt,
            timm:$ordering),
           (AMInst GPR:$addr, GPR:$incr, GPR:$mask, GPR:$shiftamt,
            timm:$ordering)>;
 

llvm/unittests/Target/LoongArch/CMakeLists.txt

+include_directories(
+  ${LLVM_MAIN_SRC_DIR}/lib/Target/LoongArch
+  ${LLVM_BINARY_DIR}/lib/Target/LoongArch
+  )
+
+set(LLVM_LINK_COMPONENTS
+  LoongArchCodeGen
+  LoongArchDesc
+  LoongArchInfo
+  MC
+  MIRParser
+  Support
+  )
+
+add_llvm_target_unittest(LoongArchTests
+  InstSizes.cpp
+  )
+
+set_property(TARGET LoongArchTests PROPERTY FOLDER "Tests/UnitTests/TargetTests")

llvm/unittests/Target/LoongArch/InstSizes.cpp

+#include "LoongArchSubtarget.h"
+#include "LoongArchTargetMachine.h"
+#include "llvm/CodeGen/MIRParser/MIRParser.h"
+#include "llvm/CodeGen/MachineModuleInfo.h"
+#include "llvm/MC/TargetRegistry.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/TargetSelect.h"
+
+#include "gtest/gtest.h"
+
+using namespace llvm;
+
+namespace {
+std::unique_ptr<LLVMTargetMachine> createTargetMachine() {
+  auto TT(Triple::normalize("loongarch64--"));
+  std::string CPU("generic-la64");
+  std::string FS("+64bit");
+
+  LLVMInitializeLoongArchTargetInfo();
+  LLVMInitializeLoongArchTarget();
+  LLVMInitializeLoongArchTargetMC();
+
+  std::string Error;
+  const Target *TheTarget = TargetRegistry::lookupTarget(TT, Error);
+
+  return std::unique_ptr<LLVMTargetMachine>(
+      static_cast<LLVMTargetMachine *>(TheTarget->createTargetMachine(
+          TT, CPU, FS, TargetOptions(), None, None, CodeGenOpt::Default)));
+}
+
+std::unique_ptr<LoongArchInstrInfo> createInstrInfo(TargetMachine *TM) {
+  LoongArchSubtarget ST(TM->getTargetTriple(), std::string(TM->getTargetCPU()),
+                        std::string(TM->getTargetCPU()),
+                        std::string(TM->getTargetFeatureString()), "lp64d",
+                        *TM);
+  return std::make_unique<LoongArchInstrInfo>(ST);
+}
+
+/// The \p InputIRSnippet is only needed for things that can't be expressed in
+/// the \p InputMIRSnippet (global variables etc)
+/// Inspired by AArch64
+void runChecks(
+    LLVMTargetMachine *TM, LoongArchInstrInfo *II,
+    const StringRef InputIRSnippet, const StringRef InputMIRSnippet,
+    std::function<void(LoongArchInstrInfo &, MachineFunction &)> Checks) {
+  LLVMContext Context;
+
+  auto MIRString = "--- |\n"
+                   "  declare void @sizes()\n" +
+                   InputIRSnippet.str() +
+                   "...\n"
+                   "---\n"
+                   "name: sizes\n"
+                   "jumpTable:\n"
+                   "  kind:            block-address\n"
+                   "  entries:\n"
+                   "    - id:              0\n"
+                   "      blocks:          [ '%bb.0' ]\n"
+                   "body: |\n"
+                   "  bb.0:\n" +
+                   InputMIRSnippet.str();
+
+  std::unique_ptr<MemoryBuffer> MBuffer = MemoryBuffer::getMemBuffer(MIRString);
+  std::unique_ptr<MIRParser> MParser =
+      createMIRParser(std::move(MBuffer), Context);
+  ASSERT_TRUE(MParser);
+
+  std::unique_ptr<Module> M = MParser->parseIRModule();
+  ASSERT_TRUE(M);
+
+  M->setTargetTriple(TM->getTargetTriple().getTriple());
+  M->setDataLayout(TM->createDataLayout());
+
+  MachineModuleInfo MMI(TM);
+  bool Res = MParser->parseMachineFunctions(*M, MMI);
+  ASSERT_FALSE(Res);
+
+  auto F = M->getFunction("sizes");
+  ASSERT_TRUE(F != nullptr);
+  auto &MF = MMI.getOrCreateMachineFunction(*F);
+
+  Checks(*II, MF);
+}
+
+} // anonymous namespace
+
+TEST(InstSizes, INLINEASM_BR) {
+  std::unique_ptr<LLVMTargetMachine> TM = createTargetMachine();
+  std::unique_ptr<LoongArchInstrInfo> II = createInstrInfo(TM.get());
+
+  runChecks(TM.get(), II.get(), "",
+            // clang-format off
+            "  INLINEASM_BR &nop, 1 /* sideeffect attdialect */, 13 /* imm */, %jump-table.0\n",
+            // clang-format on
+            [](LoongArchInstrInfo &II, MachineFunction &MF) {
+              auto I = MF.begin()->begin();
+              EXPECT_EQ(4u, II.getInstSizeInBytes(*I));
+            });
+}
+
+TEST(InstSizes, SPACE) {
+  std::unique_ptr<LLVMTargetMachine> TM = createTargetMachine();
+  std::unique_ptr<LoongArchInstrInfo> II = createInstrInfo(TM.get());
+
+  runChecks(TM.get(), II.get(), "", "  INLINEASM &\".space 1024\", 1\n",
+            [](LoongArchInstrInfo &II, MachineFunction &MF) {
+              auto I = MF.begin()->begin();
+              EXPECT_EQ(1024u, II.getInstSizeInBytes(*I));
+            });
+}
+
+TEST(InstSizes, AtomicPseudo) {
+  std::unique_ptr<LLVMTargetMachine> TM = createTargetMachine();
+  std::unique_ptr<LoongArchInstrInfo> II = createInstrInfo(TM.get());
+
+  runChecks(
+      TM.get(), II.get(), "",
+      // clang-format off
+      "    dead early-clobber renamable $r10, dead early-clobber renamable $r11 = PseudoMaskedAtomicLoadAdd32 renamable $r7, renamable $r6, renamable $r8, 4\n"
+      "    dead early-clobber renamable $r10, dead early-clobber renamable $r11 = PseudoAtomicLoadAdd32 renamable $r7, renamable $r6, renamable $r8\n"
+      "    dead early-clobber renamable $r5, dead early-clobber renamable $r9, dead early-clobber renamable $r10 = PseudoMaskedAtomicLoadUMax32 renamable $r7, renamable $r6, renamable $r8, 4\n"
+      "    early-clobber renamable $r9, dead early-clobber renamable $r10, dead early-clobber renamable $r11 = PseudoMaskedAtomicLoadMax32 killed renamable $r6, killed renamable $r5, killed renamable $r7, killed renamable $r8, 4\n"
+      "    dead early-clobber renamable $r5, dead early-clobber renamable $r9 = PseudoCmpXchg32 renamable $r7, renamable $r4, renamable $r6\n"
+      "    dead early-clobber renamable $r5, dead early-clobber renamable $r9 = PseudoMaskedCmpXchg32 killed renamable $r7, killed renamable $r4, killed renamable $r6, killed renamable $r8, 4\n",
+      // clang-format on
+      [](LoongArchInstrInfo &II, MachineFunction &MF) {
+        auto I = MF.begin()->begin();
+        EXPECT_EQ(36u, II.getInstSizeInBytes(*I));
+        ++I;
+        EXPECT_EQ(24u, II.getInstSizeInBytes(*I));
+        ++I;
+        EXPECT_EQ(48u, II.getInstSizeInBytes(*I));
+        ++I;
+        EXPECT_EQ(56u, II.getInstSizeInBytes(*I));
+        ++I;
+        EXPECT_EQ(36u, II.getInstSizeInBytes(*I));
+        ++I;
+        EXPECT_EQ(44u, II.getInstSizeInBytes(*I));
+      });
+}