[llvm-exegesis] Skip codegen of known-invalid snippets

[kpdev42]

Summary

On some targets, not all types of instruction operands are currently
handled. Instead of stopping the whole llvm-exegesis run because of any
instruction opcode that is not fully supported, write a per-opcode error
message and proceed to other opcodes. This improves the reliability of
--opcode-index=-1 sweep on partially supported targets.

Depends on: D146302, D146303

~~

Huawei RRI, OS Lab

[kpdev42]

ping

[kpdev42]

Rebase patch

llvm/test/tools/llvm-exegesis/AArch64/all-opcodes.test

+# Test that we can just use --opcode-index=-1 to generate snippets for
+# all supported opcodes and gracefully handle unsupported ones.
+
+# RUN: llvm-exegesis --mtriple=aarch64-linux-gnu --mcpu=cortex-a55 --benchmark-phase=prepare-and-assemble-snippet \
+# RUN:               --mode=latency --opcode-index=-1 | FileCheck %s
+# RUN: llvm-exegesis --mtriple=aarch64-linux-gnu --mcpu=cortex-a55 --benchmark-phase=prepare-and-assemble-snippet \
+# RUN:               --mode=uops --opcode-index=-1 | FileCheck %s
+
+# 100 means "quite a lot"
+# CHECK-COUNT-100: assembled_snippet: {{.*}}

llvm/tools/llvm-exegesis/lib/SnippetGenerator.h

void setRandomAliasing(const AliasingConfigurations &AliasingConfigurations,
                        InstructionTemplate &DefIB, InstructionTemplate &UseIB);
 
 // Assigns a Random Value to all Variables in IT that are still Invalid.
 // Do not use any of the registers in `ForbiddenRegs`.
 Error randomizeUnsetVariables(const LLVMState &State,
                               const BitVector &ForbiddenRegs,
                               InstructionTemplate &IT);
 
+// Sanity check generated instruction.
+Error validateGeneratedInstruction(const LLVMState &State, const MCInst &Inst);
+
 } // namespace exegesis
 } // namespace llvm
 
 #endif // LLVM_TOOLS_LLVM_EXEGESIS_SNIPPETGENERATOR_H

llvm/tools/llvm-exegesis/lib/SnippetGenerator.cpp

 #include "Assembler.h"
 #include "Error.h"
 #include "MCInstrDescView.h"
 #include "SnippetGenerator.h"
 #include "Target.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Twine.h"
+#include "llvm/Support/Error.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/Program.h"
 
 namespace llvm {
 namespace exegesis {
 
 std::vector<CodeTemplate> getSingleton(CodeTemplate &&CT) {
if (auto E = generateCodeTemplates(Variant, ForbiddenRegs)) {
     Benchmarks.reserve(Benchmarks.size() + Templates.size());
     for (CodeTemplate &CT : Templates) {
       // TODO: Generate as many BenchmarkCode as needed.
       {
         BenchmarkCode BC;
         BC.Info = CT.Info;
         BC.Key.Instructions.reserve(CT.Instructions.size());
         for (InstructionTemplate &IT : CT.Instructions) {
-          if (auto error = randomizeUnsetVariables(State, ForbiddenRegs, IT))
-            return error;
-          BC.Key.Instructions.push_back(IT.build());
+          if (auto Error = randomizeUnsetVariables(State, ForbiddenRegs, IT))
+            return Error;
+          MCInst Inst = IT.build();
+          if (auto Error = validateGeneratedInstruction(State, Inst))
+            return Error;
+          BC.Key.Instructions.push_back(Inst);
         }
         if (CT.ScratchSpacePointerInReg)
           BC.LiveIns.push_back(CT.ScratchSpacePointerInReg);
         BC.Key.RegisterInitialValues =
             computeRegisterInitialValues(CT.Instructions);
         BC.Key.Config = CT.Config;
         Benchmarks.emplace_back(std::move(BC));
         if (Benchmarks.size() >= Opts.MaxConfigsPerOpcode) {
for (const Variable &Var : IT.getInstr().Variables) {
     if (!AssignedValue.isValid())
       if (auto Err = randomizeMCOperand(State, IT.getInstr(), Var,
                                         AssignedValue, ForbiddenRegs))
         return Err;
   }
   return Error::success();
 }
 
+Error validateGeneratedInstruction(const LLVMState &State, const MCInst &Inst) {
+  for (const auto &Operand : Inst) {
+    if (!Operand.isValid()) {
+      // Mention the particular opcode - it is not necessarily the "main"
+      // opcode being benchmarked by this snippet. For example, serial snippet
+      // generator uses one more opcode when in SERIAL_VIA_NON_MEMORY_INSTR
+      // execution mode.
+      const auto OpcodeName = State.getInstrInfo().getName(Inst.getOpcode());
+      return make_error<Failure>("Not all operands were initialized by the "
+                                 "snippet generator for " +
+                                 OpcodeName + " opcode.");
+    }
+  }
+  return Error::success();
+}
+
 } // namespace exegesis
 } // namespace llvm