gisel-ab 0.9.0__py3-none-any.whl

gisel_ab/cpp/query-recovery.h

@@ -0,0 +1,229 @@
+//===- query-recovery.h - keep a batch alive across per-query aborts ------===//
+//
+// A legalizer query can trip an LLVM assertion (report_fatal_error, or a bare
+// assert), which aborts the process.  The obvious recovery -- restart the
+// runner after the offending query -- costs a process start (load the shared
+// libraries, build every subtarget and legalizer) per abort.  The AArch64
+// domain aborts on ~4% of its 936,960 points per config, and restarting there
+// drops throughput from ~4,500 queries/s to ~380 queries/s.
+//
+// The runner is single threaded and builds its legalizers before it answers,
+// so an aborted getAction() can only leak memory allocated during that call.
+// Catching the abort with siglongjmp keeps the batch going and lets the answer
+// file carry exactly one row per query.  run-queries.py still restarts on a
+// real crash (SIGSEGV), so a broken legalizer cannot silently produce rows.
+//
+// The process is also made non-dumpable: on hosts whose core_pattern pipes
+// every core to a handler (apport on Ubuntu), a core costs ~80 ms even though
+// the runner never reads it.
+//===----------------------------------------------------------------------===//
+
+#ifndef AB_QUERY_RECOVERY_H
+#define AB_QUERY_RECOVERY_H
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/raw_ostream.h"
+
+#include <cctype>
+#include <csetjmp>
+#include <csignal>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <dlfcn.h>
+
+#if defined(__linux__)
+#include <sys/prctl.h>
+#endif
+
+namespace ab {
+
+inline void disableCoreDumps() {
+#if defined(__linux__)
+  (void)prctl(PR_SET_DUMPABLE, 0);
+#endif
+}
+
+namespace detail {
+inline sigjmp_buf Jump;
+inline volatile sig_atomic_t InQuery = 0;
+// Where the last aborted query died.  `writeUnanswerable` puts this in the
+// answer row, so "both sides assert" becomes "both sides assert at the same
+// place" -- otherwise two different upstream bugs look like one class.
+inline char Site[256] = {0};
+
+inline const char *baseName(const char *Path) {
+  const char *Slash = std::strrchr(Path, '/');
+  return Slash ? Slash + 1 : Path;
+}
+
+inline void recordSite(const char *File, unsigned Line) {
+  if (!InQuery || !File)
+    return;
+  std::snprintf(Site, sizeof(Site), "%s:%u", baseName(File), Line);
+}
+
+// `llvm_unreachable` / `report_fatal_error` reach us as
+// "UNREACHABLE executed at /path/LowLevelType.h:151!" (or "LLVM ERROR: ...").
+// Keep the trailing file:line candidate.
+inline void recordFatal(const char *Reason) {
+  Site[0] = 0;
+  if (!InQuery || !Reason)
+    return;
+  size_t Len = std::strlen(Reason);
+  for (size_t P = Len; P-- > 2;) {
+    if (Reason[P] != ':' || !std::isdigit((unsigned char)Reason[P + 1]))
+      continue;
+    size_t B = P;
+    while (B > 0 && P - B < 64 && Reason[B - 1] != '/' && Reason[B - 1] != ' ' &&
+           Reason[B - 1] != '(' && Reason[B - 1] != '\'' )
+      --B;
+    size_t E = P + 1;
+    while (E < Len && std::isdigit((unsigned char)Reason[E]))
+      ++E;
+    if (E > P + 1) {
+      std::snprintf(Site, sizeof(Site), "%.*s", (int)(E - B), Reason + B);
+      return;
+    }
+  }
+  // `report_fatal_error("...")` carries no location.  Keep a short, stable
+  // prefix of the message instead, so two different calls stay distinguishable
+  // and the answer row never loses the class of failure.
+  char Text[64] = {0};
+  size_t N = 0;
+  for (const char *P = Reason; *P && N + 1 < sizeof(Text); ++P) {
+    unsigned char C = (unsigned char)*P;
+    if (std::isalnum(C) || C == ' ' || C == '_' || C == '-')
+      Text[N++] = (char)C;
+    else if (N && Text[N - 1] != ' ')
+      Text[N++] = ' ';
+  }
+  while (N && Text[N - 1] == ' ')
+    --N;
+  Text[N] = 0;
+  std::snprintf(Site, sizeof(Site), "fatal:%s", Text);
+}
+
+inline void onFatalError(void *, const char *Reason, bool) {
+  const char *Text = Reason ? Reason : "fatal error";
+  if (InQuery)
+    recordFatal(Text);
+  // Installing a handler supersedes LLVM's default printer, so print the same
+  // shape ourselves: one "LLVM ERROR: ..." line on stderr.
+  std::fprintf(stderr, "LLVM ERROR: %s%s", Text,
+               (Text[0] && Text[std::strlen(Text) - 1] == '\n') ? "" : "\n");
+  std::fflush(stderr);
+}
+
+inline void onAbort(int Sig) {
+  if (InQuery) {
+    InQuery = 0;
+    siglongjmp(Jump, 1);
+  }
+  // Not inside a query: restore the default disposition and re-raise, so the
+  // process still dies with the signal a caller expects.
+  std::signal(Sig, SIG_DFL);
+  std::raise(Sig);
+}
+
+inline void install() {
+  static bool Done = false;
+  if (Done)
+    return;
+  Done = true;
+  std::signal(SIGABRT, onAbort);
+  llvm::install_fatal_error_handler(onFatalError);
+}
+} // namespace detail
+
+/// Run one query under the recovery point.  Returns false when it aborted;
+/// the caller then writes the unanswerable row itself.
+///
+/// The sigsetjmp frame must stay alive while the query runs, which is why the
+/// query is a callback rather than a separate enter/leave pair: a setjmp in a
+/// helper that has already returned would jump into a dead frame.
+template <typename Fn>
+inline bool runQuery(Fn &&Query) {
+  detail::install();
+  detail::Site[0] = 0;
+  detail::InQuery = 1;
+  if (sigsetjmp(detail::Jump, 1) == 0) {
+    Query();
+    detail::InQuery = 0;
+    return true;
+  }
+  detail::InQuery = 0;
+  return false;
+}
+
+inline void leaveQuery() { detail::InQuery = 0; }
+
+inline void writeJsonString(llvm::raw_ostream &Out, const char *Text) {
+  Out << '"';
+  for (const char *P = Text; *P; ++P) {
+    if (*P == '"' || *P == '\\')
+      Out << '\\';
+    Out << *P;
+  }
+  Out << '"';
+}
+
+/// One answer row for a query that died: the query itself, plus the same
+/// status/reason fields run-queries.py writes, plus where it died when the
+/// abort carried a file:line.
+inline void writeUnanswerable(llvm::StringRef Line, llvm::raw_ostream &Out) {
+  size_t End = Line.rfind('}');
+  if (End == llvm::StringRef::npos) {
+    Out << "{\"status\":\"unanswerable\",\"reason\":\"asserted\"";
+  } else {
+    Out << Line.substr(0, End)
+        << ",\"status\":\"unanswerable\",\"reason\":\"asserted\"";
+  }
+  if (detail::Site[0]) {
+    Out << ",\"assert_site\":";
+    writeJsonString(Out, detail::Site);
+  }
+  Out << "}\n";
+}
+
+// Overriding `__assert_fail` is what turns a bare `assert()` into a site we
+// can report.  The runner is linked with -rdynamic so this definition
+// interposes calls made from the LLVM shared libraries.
+} // namespace ab
+
+// `llvm_unreachable` does not go through the fatal-error handler: it prints
+// "UNREACHABLE executed at file:line!" and calls abort() itself.  Taking the
+// symbol over is the only way to keep that location; same -rdynamic rule.
+namespace llvm {
+[[noreturn]] void llvm_unreachable_internal(const char *Msg, const char *File,
+                                            unsigned Line) {
+  ab::detail::recordSite(File, Line);
+  if (Msg)
+    std::fprintf(stderr, "%s\n", Msg);
+  if (File)
+    std::fprintf(stderr, "UNREACHABLE executed at %s:%u!\n", File, Line);
+  else
+    std::fprintf(stderr, "UNREACHABLE executed!\n");
+  std::fflush(stderr);
+  std::abort();
+}
+} // namespace llvm
+
+extern "C" void __assert_fail(const char *Assertion, const char *File,
+                              unsigned Line, const char *Function)
+    __attribute__((noreturn, visibility("default")));
+
+extern "C" void __assert_fail(const char *Assertion, const char *File,
+                              unsigned Line, const char *Function) {
+  ab::detail::recordSite(File, Line);
+  using Fn = void (*)(const char *, const char *, unsigned, const char *);
+  static Fn Real = reinterpret_cast<Fn>(dlsym(RTLD_NEXT, "__assert_fail"));
+  if (Real)
+    Real(Assertion, File, Line, Function);
+  std::fprintf(stderr, "%s:%u: Assertion `%s' failed.\n",
+               File ? File : "?", Line, Assertion ? Assertion : "?");
+  std::abort();
+}
+
+#endif

gisel_ab/cpp/query_runner.cpp

@@ -0,0 +1,419 @@
+//===- query_runner.cpp - answer a JSONL query file with one X86 legalizer -==//
+//
+// A/B harness for the generated legalizer .inc.  The query file is the
+// answerless enumeration produced by `gisel domain`; this program answers it
+// with either the shipping X86LegalizerInfo (the .inc under test) or the
+// frozen X86LegalizerInfoReference (the baseline oracle).
+//
+// Build with -DAB_REFERENCE to select the reference class.  Everything else
+// (configs, type spelling, output shape) is identical, so two builds differ
+// only in the legalizer implementation.
+//
+//===----------------------------------------------------------------------===//
+
+#include "X86Subtarget.h"
+#include "X86TargetMachine.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/StringSwitch.h"
+#include "llvm/CodeGen/GlobalISel/LegalizerInfo.h"
+#include "llvm/CodeGen/TargetOpcodes.h"
+#include "llvm/IR/Function.h"
+#include "llvm/IR/LLVMContext.h"
+#include "llvm/IR/Module.h"
+#include "llvm/MC/TargetRegistry.h"
+#include "llvm/Support/AtomicOrdering.h"
+#include "llvm/Support/JSON.h"
+#include "llvm/Support/TargetSelect.h"
+#include "llvm/Support/raw_ostream.h"
+#include "llvm/Target/TargetMachine.h"
+#include "llvm/Target/TargetOptions.h"
+#include "llvm/TargetParser/Triple.h"
+
+#include <fstream>
+#include <optional>
+#include <vector>
+
+#include "query-recovery.h"
+using namespace llvm;
+
+static std::optional<AtomicOrdering> parseOrdering(StringRef Text) {
+  return StringSwitch<std::optional<AtomicOrdering>>(Text)
+      .Case("NotAtomic", AtomicOrdering::NotAtomic)
+      .Case("Unordered", AtomicOrdering::Unordered)
+      .Case("Monotonic", AtomicOrdering::Monotonic)
+      .Case("Acquire", AtomicOrdering::Acquire)
+      .Case("Release", AtomicOrdering::Release)
+      .Case("AcquireRelease", AtomicOrdering::AcquireRelease)
+      .Case("SequentiallyConsistent", AtomicOrdering::SequentiallyConsistent)
+      .Default(std::nullopt);
+}
+
+#ifdef AB_REFERENCE
+#include "X86LegalizerInfoReference.h"
+using Legalizer = X86LegalizerInfoReference;
+#else
+#include "GISel/X86LegalizerInfo.h"
+using Legalizer = X86LegalizerInfo;
+#endif
+
+using namespace TargetOpcode;
+using namespace LegalizeActions;
+
+namespace {
+
+struct Config {
+  const char *ID;
+  const char *Triple;
+  const char *FS;
+};
+
+// The same four full-corpus configurations the frozen oracle uses.
+static const Config Configs[] = {
+    {"C0", "i386", "-x87"},
+    {"C1", "x86_64", ""},
+    {"C2", "x86_64",
+     "+sse,+sse2,+sse4.1,+avx,+avx2,+avx512f,+avx512dq,+avx512bw,+avx512vl,"
+     "+popcnt,+avx512vpopcntdq,+lzcnt,+bmi,+cmov"},
+    {"C3", "i386", "+x87,+popcnt,+lzcnt,+bmi,+cmov"},
+};
+
+struct Sigma {
+  std::unique_ptr<TargetMachine> TM;
+  const X86Subtarget *STI = nullptr;
+  std::unique_ptr<Legalizer> L;
+};
+
+static std::string jsonString(StringRef S) {
+  std::string O = "\"";
+  for (char C : S) {
+    if (C == '"' || C == '\\') { O += '\\'; O += C; }
+    else if (C == '\n') O += "\\n";
+    else O += C;
+  }
+  O += "\"";
+  return O;
+}
+
+// Core IR spelling, kind-preserving: s32 / i32 / f32 / bf16 / p0:32 /
+// v4s32 / nxv4s32.  LLT::print drops the pointer width ("p0"), which would
+// make i386 and x86_64 indistinguishable at p0.
+static std::string lltStr(LLT Ty) {
+  if (!Ty.isValid())
+    return "LLT_invalid";
+  if (Ty.isPointer())
+    return "p" + std::to_string(Ty.getAddressSpace()) + ":" +
+           std::to_string(Ty.getSizeInBits());
+  if (Ty.isVector()) {
+    std::string Elem = lltStr(Ty.getElementType());
+    return (Ty.isScalable() ? "nxv" : "v") +
+           std::to_string(Ty.getNumElements()) + Elem;
+  }
+  if (Ty.isBFloat16())
+    return "bf16";
+  if (Ty.isFloat())
+    return "f" + std::to_string(Ty.getScalarSizeInBits());
+  if (Ty.isInteger())
+    return "i" + std::to_string(Ty.getScalarSizeInBits());
+  return "s" + std::to_string(Ty.getScalarSizeInBits());
+}
+
+static const char *actionName(LegalizeAction A) {
+  switch (A) {
+  case Legal: return "Legal";
+  case NarrowScalar: return "NarrowScalar";
+  case WidenScalar: return "WidenScalar";
+  case FewerElements: return "FewerElements";
+  case MoreElements: return "MoreElements";
+  case Bitcast: return "Bitcast";
+  case Lower: return "Lower";
+  case Libcall: return "Libcall";
+  case Unsupported: return "Unsupported";
+  case Custom: return "Custom";
+  default: return "?";
+  }
+}
+
+static unsigned opcodeFor(StringRef Name) {
+  return StringSwitch<unsigned>(Name)
+#undef HANDLE_TARGET_OPCODE
+#undef HANDLE_TARGET_OPCODE_MARKER
+#define HANDLE_TARGET_OPCODE(OPC) .Case(#OPC, TargetOpcode::OPC)
+#define HANDLE_TARGET_OPCODE_MARKER(IDENT, OPC)
+#include "llvm/Support/TargetOpcodes.def"
+#undef HANDLE_TARGET_OPCODE
+#undef HANDLE_TARGET_OPCODE_MARKER
+      .Default(0);
+}
+
+static std::optional<LLT> parseLLT(StringRef S, unsigned PtrBits) {
+  if (S == "bf16")
+    return LLT::scalar(16);
+  // Vector spellings: vN<elem> / nxvN<elem>.
+  if (S.starts_with("nxv") || S.starts_with("v")) {
+    bool Scalable = S.starts_with("nxv");
+    S = S.drop_front(Scalable ? 3 : 1);
+    size_t I = 0;
+    while (I < S.size() && S[I] >= '0' && S[I] <= '9')
+      ++I;
+    unsigned N = 0;
+    if (I == 0 || S.substr(0, I).getAsInteger(10, N))
+      return std::nullopt;
+    auto Elem = parseLLT(S.drop_front(I), PtrBits);
+    if (!Elem)
+      return std::nullopt;
+    return LLT::vector(Scalable ? ElementCount::getScalable(N)
+                                : ElementCount::getFixed(N),
+                       *Elem);
+  }
+  if (S.starts_with("p")) {
+    size_t Colon = S.find(':');
+    if (Colon == StringRef::npos)
+      return LLT::pointer(0, PtrBits);
+    unsigned AS = 0;
+    if (S.substr(1, Colon - 1).getAsInteger(10, AS))
+      return std::nullopt;
+    StringRef W = S.drop_front(Colon + 1);
+    unsigned Bits = PtrBits;
+    if (W != "*" && W.getAsInteger(10, Bits))
+      return std::nullopt;
+    return LLT::pointer(AS, Bits);
+  }
+  char Kind = S.empty() ? '?' : S[0];
+  unsigned Bits = 0;
+  if (S.drop_front().getAsInteger(10, Bits))
+    return std::nullopt;
+  switch (Kind) {
+  case 's': return LLT::scalar(Bits);
+  case 'i': return LLT::integer(Bits);
+  case 'f': return LLT::floatIEEE(Bits);
+  default: return std::nullopt;
+  }
+}
+
+static bool makeSigma(const Config &C, Sigma &S) {
+  Triple TT(C.Triple);
+  std::string Err;
+  const Target *T = TargetRegistry::lookupTarget("", TT, Err);
+  if (!T) {
+    errs() << "no target: " << Err << "\n";
+    return false;
+  }
+  TargetOptions Opts;
+  S.TM.reset(T->createTargetMachine(TT, "generic", C.FS, Opts,
+                                    /*RM=*/std::nullopt));
+  if (!S.TM) {
+    errs() << "no target machine for " << C.ID << "\n";
+    return false;
+  }
+  static LLVMContext Ctx;
+  static Module M("t", Ctx);
+  if (!M.getFunction("f"))
+    Function::Create(FunctionType::get(Type::getVoidTy(Ctx), false),
+                     Function::ExternalLinkage, "f", &M);
+  S.STI = static_cast<const X86Subtarget *>(
+      S.TM->getSubtargetImpl(*M.getFunction("f")));
+  if (!S.STI) {
+    errs() << "no subtarget for " << C.ID << "\n";
+    return false;
+  }
+  S.L = std::make_unique<Legalizer>(
+      *S.STI, *static_cast<const X86TargetMachine *>(S.TM.get()));
+  return true;
+}
+
+static int answerLine(StringRef Line, const StringMap<Sigma *> &Sigmas,
+                      raw_ostream &Out) {
+  Expected<json::Value> Parsed = json::parse(Line);
+  if (!Parsed) {
+    errs() << "bad query JSON: " << toString(Parsed.takeError()) << "\n";
+    return 2;
+  }
+  json::Object *Obj = Parsed->getAsObject();
+  if (!Obj) {
+    errs() << "query is not an object\n";
+    return 2;
+  }
+  auto ConfigName = Obj->getString("config");
+  auto Name = Obj->getString("name");
+  json::Array *TypeArr = Obj->getArray("types");
+  if (!ConfigName || !Name || !TypeArr) {
+    errs() << "query needs config/name/types\n";
+    return 2;
+  }
+  auto It = Sigmas.find(*ConfigName);
+  if (It == Sigmas.end()) {
+    errs() << "unknown config " << *ConfigName << "\n";
+    return 2;
+  }
+  Sigma &S = *It->second;
+  unsigned PtrBits = S.STI->isTarget64BitLP64() ? 64 : 32;
+  SmallVector<LLT, 4> Types;
+  SmallVector<std::string, 4> TypeText;
+  for (const json::Value &V : *TypeArr) {
+    auto Text = V.getAsString();
+    if (!Text) {
+      errs() << "type is not a string\n";
+      return 2;
+    }
+    auto Ty = parseLLT(*Text, PtrBits);
+    if (!Ty) {
+      errs() << "bad type spelling " << *Text << "\n";
+      return 2;
+    }
+    Types.push_back(*Ty);
+    TypeText.push_back(Text->str());
+  }
+
+  // Immediate operands are part of the query: a rule may read Q.Immediates
+  // (e.g. LegalizePredicates::immIs).  Dropping them makes the rule index the
+  // empty array and abort, which would look like an answer difference.
+  SmallVector<int64_t, 2> Imms;
+  if (json::Array *ImmArr = Obj->getArray("imms"))
+    for (const json::Value &V : *ImmArr) {
+      auto I = V.getAsInteger();
+      if (!I)
+        return 2;
+      Imms.push_back(*I);
+    }
+  std::string ImmsText = "[";
+  for (size_t I = 0; I != Imms.size(); ++I) {
+    if (I)
+      ImmsText += ",";
+    ImmsText += std::to_string(Imms[I]);
+  }
+  ImmsText += "]";
+
+  SmallVector<LegalityQuery::MemDesc, 1> MMOs;
+  std::string MemText = "null";
+  if (json::Array *Mem = Obj->getArray("mem")) {
+    if (Mem->size() != 2 && Mem->size() != 4) {
+      errs() << "mem must be [type, align] or "
+                "[type, align, ordering, failure_ordering]\n";
+      return 2;
+    }
+    auto TyText = (*Mem)[0].getAsString();
+    auto Align = (*Mem)[1].getAsInteger();
+    if (!TyText || !Align) {
+      errs() << "mem needs string type and integer align\n";
+      return 2;
+    }
+    auto Ty = parseLLT(*TyText, PtrBits);
+    if (!Ty) {
+      errs() << "bad mem type " << *TyText << "\n";
+      return 2;
+    }
+    AtomicOrdering Ordering = AtomicOrdering::NotAtomic;
+    AtomicOrdering Failure = AtomicOrdering::NotAtomic;
+    std::optional<StringRef> OrderingText;
+    std::optional<StringRef> FailureText;
+    if (Mem->size() == 4) {
+      OrderingText = (*Mem)[2].getAsString();
+      FailureText = (*Mem)[3].getAsString();
+      auto ParsedOrdering = OrderingText ? parseOrdering(*OrderingText)
+                                         : std::nullopt;
+      auto ParsedFailure = FailureText ? parseOrdering(*FailureText)
+                                       : std::nullopt;
+      if (!ParsedOrdering || !ParsedFailure) {
+        errs() << "bad memory ordering\n";
+        return 2;
+      }
+      Ordering = *ParsedOrdering;
+      Failure = *ParsedFailure;
+    }
+    MMOs.push_back(LegalityQuery::MemDesc(*Ty, *Align, Ordering, Failure));
+    MemText = "[" + jsonString(*TyText) + "," + std::to_string(*Align);
+    if (Mem->size() == 4)
+      MemText += "," + jsonString(*OrderingText) + "," +
+                 jsonString(*FailureText);
+    MemText += "]";
+  }
+
+  unsigned Opcode = opcodeFor(*Name);
+  if (!Opcode) {
+    errs() << "unknown opcode " << *Name << "\n";
+    return 2;
+  }
+  std::string Tj = "[";
+  for (size_t I = 0; I != Types.size(); ++I) {
+    if (I)
+      Tj += ",";
+    Tj += jsonString(TypeText[I]);
+  }
+  Tj += "]";
+
+  LegalityQuery Q(Opcode, Types, MMOs, Imms);
+  LegalizeActionStep Step = S.L->getAction(Q);
+
+  Out << "{\"config\":" << jsonString(*ConfigName)
+      << ",\"name\":" << jsonString(*Name)
+      << ",\"types\":" << Tj
+      << ",\"mem\":" << MemText
+      << ",\"imms\":" << ImmsText
+      << ",\"action\":" << jsonString(actionName(Step.Action))
+      << ",\"type_idx\":" << (unsigned)Step.TypeIdx
+      << ",\"new_type\":" << jsonString(lltStr(Step.NewType))
+      << "}\n";
+  return 0;
+}
+
+} // namespace
+
+int main(int Argc, char **Argv) {
+  ab::disableCoreDumps();
+  StringRef Queries;
+  for (int I = 1; I < Argc; ++I) {
+    StringRef A(Argv[I]);
+    if (A == "--queries" && I + 1 < Argc)
+      Queries = Argv[++I];
+    else if (A == "-h" || A == "--help") {
+      outs() << "usage: query_runner --queries FILE\n";
+      return 0;
+    } else {
+      errs() << "unknown argument " << A << "\n";
+      return 2;
+    }
+  }
+  if (Queries.empty()) {
+    errs() << "usage: query_runner --queries FILE\n";
+    return 2;
+  }
+
+  LLVMInitializeX86TargetInfo();
+  LLVMInitializeX86Target();
+  LLVMInitializeX86TargetMC();
+
+  StringMap<Sigma *> Sigmas;
+  std::vector<std::unique_ptr<Sigma>> Storage;
+  for (const Config &C : Configs) {
+    auto S = std::make_unique<Sigma>();
+    if (!makeSigma(C, *S))
+      return 2;
+    Sigmas[C.ID] = S.get();
+    Storage.push_back(std::move(S));
+  }
+
+  std::ifstream In(Queries.str());
+  if (!In) {
+    errs() << "cannot open " << Queries << "\n";
+    return 2;
+  }
+  std::string Line;
+  unsigned N = 0;
+  while (std::getline(In, Line)) {
+    if (Line.empty())
+      continue;
+    int Rc = 0;
+    if (!ab::runQuery([&] { Rc = answerLine(Line, Sigmas, outs()); })) {
+      ab::writeUnanswerable(Line, outs());
+      outs().flush();
+      ++N;
+      continue;
+    }
+    if (Rc)
+      return Rc;
+    ++N;
+  }
+  errs() << "answered " << N << " queries\n";
+  return 0;
+}