Test failing with "error in backend: Broken function found" after 9d37e61

[dyung]

Recently one of our internal tests started failing with an error:

Instruction does not dominate all uses!
  %49 = shufflevector <8 x float> %47, <8 x float> %48, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 9>, !dbg !1331
  %41 = shufflevector <8 x float> %49, <8 x float> poison, <24 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>, !dbg !1331
in function _Z3runv
fatal error: error in backend: Broken function found, compilation aborted!

I was able to reduce the test to the following (although admittedly still pretty large) repro:

template <bool, class c, class> struct ab {
  using d = c;
};
template <class c, class ac> struct ab<false, c, ac> {
  using d = ac;
};
template <bool aa, class c, class ac> using e = ab<aa, c, ac>::d;
template <class...> using v = void;
template <class f> constexpr bool ai = __is_member_object_pointer(f);
struct ad {
  template <class ae, class... af>
  static auto ag(ae ah, af... aq) -> decltype(ah(aq...));
};
template <class ae, class aj = ae, bool = ai<aj>> struct ak;
template <class ae, class aj> struct ak<ae, aj, false> : ad {};
template <class al> struct am {
  using d = al;
};
template <class...> struct an;
template <class ae, class c, class... ao>
using ap = decltype(ak<ae>::ag(ae(), c(), ao()...));
template <class ae, class c, class... ao>
struct an<v<>, ae, c, ao...> : am<ap<ae, c, ao...>> {};
template <class ae, class... aq> using az = e<0, int, an<void, ae, aq...>>;
template <class ae, class... aq> struct ar : az<ae, aq...> {};
template <class> class at;
struct h {
  float au() { return as[0]; }
  float av() { return as[1]; }
  template <class aw> void ax(aw ay) {
    as[0] = as[0] > ay.au();
    as[1] = as[1] > ay.av();
  }
  float as[2];
};
template <> struct at<float> : h {
  void operator-=(at ay) { ax(ay); }
};
at<float> operator-(at<float> ba, at<float> ay) {
  at bb(ba);
  bb -= ay;
  return bb;
}
enum { bc, bd };
template <typename be> struct bf {
  typedef be d;
};
template <typename be> using bg = bf<be>::d;
struct k {
  enum { l };
};
template <typename> struct n;
template <typename o, typename... bh> struct n<o(bh...)> {
  typedef ar<o, bh...>::d d;
};
template <typename> struct p;
template <typename q> struct r {
  const q &bi() const { return *static_cast<const q *>(this); }
};
template <typename> class s;
template <typename, int t, int bj, int = 0, int = t, int = bj> class bk;
template <typename, int t, int, int bl, int, int>
struct bk : s<bk<at<float>, t, bl>> {};
template <typename> class u;
template <typename, typename> class bm;
template <typename, typename, typename> class bn;
struct w {
  enum { y = 10 };
};
constexpr int z(int bo, int cols) { return bo * cols; }
template <typename bp> struct bq {
  enum { br = z(p<bp>::bs, p<bp>::bt) };
};
template <typename be> struct bu {
  typedef e<bool(be ::bv), be const &, be> d;
};
template <typename q> struct bw {
  typedef u<q> d;
};
template <typename bx> struct by {
  typedef bw<bx>::d d;
};
template <typename> struct bz;
template <typename ca> struct bz<at<ca>> {
  typedef ca cb;
};
float cc(float, float);
struct cd {
  float operator()(float a, float b) { return a + b; }
};
template <typename ce, typename cf> struct cg {
  ce operator()(ce a, cf b) { return a - b; }
};
template <typename ch> struct ci {
  bz<ch>::cb operator()(ch &a) {
    float cj = a.au() * a.au() + a.av() * a.av();
    return cj;
  }
};
template <typename q> struct ck : r<q> {
  typedef p<q>::ch ch;
  typedef e<bool(p<q>::bv), const ch &, e<k::l, ch, ch>> cl;
};
template <typename q> struct DenseBase : ck<q> {
  typedef p<q>::ch ch;
  using ck<q>::bi;
  enum { bs = p<q>::bs, bt, cm = bq<q>::br, cn, bv };
  long co() {
    long __trans_tmp_15 = bi().cols();
    return __trans_tmp_15;
  }
  long innerSize() {
    long cp = bi().bo();
    return cp;
  }
  ch cq() { return cr(cd()); }
  template <typename cs> ch cr(const cs &) const;
};
template <typename q> struct u : DenseBase<q> {
  typedef p<q>::ch ch;
  using DenseBase<q>::bi;
  template <typename ct> bn<cg<ch, ch>, const q, const ct> operator-(ct) {
    return bn<cg<ch, ch>, const q, const ct>(bi(), bi());
  }
  bm<ci<ch>, q> cu() { return bi(); }
};
template <typename> struct cv;
template <typename> struct cw;
template <typename be> struct cx : cw<be> {};
template <int cy> struct cz {
  cz(const at<float> *da, long) : data(da) {}
  long db() { return cy; }
  const at<float> *data;
};
template <typename q> struct cx<s<q>> {
  typedef q dc;
  enum { bs = dc::bs, dd };
  enum { de = bs };
  cx(const dc &m) : m_d(m.data(), 0) {}
  dc::cl coeff(long df, long col) { return m_d.data[df + col * m_d.db()]; }
  cz<de> m_d;
};
template <typename ch, int dg, int dh, int di, int dj, int dk>
struct cx<bk<ch, dg, dh, di, dj, dk>> : cx<s<bk<ch, dg, dh>>> {};
template <typename dl, typename dm> struct cw<bm<dl, dm>> {
  typedef bm<dl, dm> bp;
  enum { dd = cx<dm>::dd };
  cw(bp dn) : m_d(dn) {}
  bp::cl coeff(long df, long col) {
    at __trans_tmp_8 = m_d.argImpl.coeff(df, col);
    ci<at<float>> __trans_tmp_10;
    return __trans_tmp_10(__trans_tmp_8);
  }
  struct Data {
    Data(bp xpr) : argImpl(xpr.nestedExpression()) {}
    cx<dm> argImpl;
  } m_d;
};
template <typename cs, typename Lhs, typename Rhs>
struct cx<bn<cs, Lhs, Rhs>> : cv<bn<cs, Lhs, Rhs>> {};
template <typename cs, typename Lhs, typename Rhs> struct cv<bn<cs, Lhs, Rhs>> {
  typedef bn<cs, Lhs, Rhs> bp;
  enum { dd = w::y };
  cv(bp xpr) : m_d(xpr) {}
  bp::cl coeff(long df, long col) {
    const at<float> &__trans_tmp_9 = m_d.lhsImpl.coeff(df, col);
    cg<at<float>, at<float>> __trans_tmp_17;
    at __trans_tmp_18 = m_d.rhsImpl.coeff(df, col);
    return __trans_tmp_17(__trans_tmp_9, __trans_tmp_18);
  }
  struct Data {
    Data(bp xpr) : lhsImpl(xpr.lhs()), rhsImpl(xpr.rhs()) {}
    cx<Lhs> lhsImpl;
    cx<Rhs> rhsImpl;
  } m_d;
};
template <int Size> struct plain_array {
  at<float> array[Size];
};
template <int Size> struct DenseStorage {
  plain_array<Size> m_data;
  const at<float> *data() const { return m_data.array; }
};
template <typename q> struct s : bw<q>::d {
  typedef bw<q>::d Base;
  DenseStorage<Base::cn> m_storage;
  const p<q>::ch *data() const { return m_storage.data(); }
};
template <typename Scalar_, int t, int bj, int bl, int MaxRows_, int MaxCols_>
struct p<bk<Scalar_, t, bj, bl, MaxRows_, MaxCols_>> {
  typedef Scalar_ ch;
  enum { bs = t, bt, bv };
};
template <typename cs, typename Lhs, typename Rhs> struct p<bn<cs, Lhs, Rhs>> {
  enum { bs = Lhs ::bs, bt };
  typedef n<cs(typename Lhs::ch, typename Rhs::ch)>::d ch;
  enum { bv };
};
template <typename, typename, typename>
struct bn : by<bn<cg<at<float>, at<float>>, bk<at<float>, 3, 0>,
                  bk<at<float>, 3, 0>>>::d {
  typedef bu<bk<at<float>, 3, 0>>::d LhsNested;
  typedef bu<bk<at<float>, 3, 0>>::d RhsNested;
  bn(bg<const bk<at<float>, 3, 0>> &aLhs, bg<bk<at<float>, 3, 0>> aRhs)
      : m_lhs(aLhs), m_rhs(aRhs) {}
  long bo() const { return bs; }
  long cols() const { return bt; }
  LhsNested lhs() { return m_lhs; }
  RhsNested rhs();
  LhsNested m_lhs;
  RhsNested m_rhs;
};
template <typename dl, typename bp> struct p<bm<dl, bp>> : bp {
  typedef n<dl(typename bp::ch)>::d ch;
  enum { bv };
};
template <typename dl, typename bp>
struct CwiseUnaryOpImpl : by<bm<dl, bp>>::d {};
template <typename dl, typename bp> struct bm : CwiseUnaryOpImpl<dl, bp> {
  typedef bu<bp>::d XprTypeNested;
  bm(const bp &xpr) : m_xpr(xpr) {}
  long bo() const { return m_xpr.bo(); }
  long cols() const { return m_xpr.cols(); }
  XprTypeNested nestedExpression() { return m_xpr; }
  XprTypeNested m_xpr;
};
template <typename Evaluator> struct redux_traits {
  enum { y = Evaluator::cm * Evaluator::dd, UnrollingLimit = 110 };
  enum { Unrolling = y <= UnrollingLimit };
};
template <typename Func, typename Evaluator, int Start, int Length>
struct redux_novec_unroller {
  enum { HalfLength = Length / 2 };
  static Evaluator::ch run(Evaluator eval, Func func) {
    auto __trans_tmp_1 =
             redux_novec_unroller<Func, Evaluator, Start, HalfLength>::run(
                 eval, func),
         __trans_tmp_2 =
             redux_novec_unroller<Func, Evaluator, Start + HalfLength,
                                  Length - HalfLength>::run(eval, func);
    return func(__trans_tmp_1, __trans_tmp_2);
  }
};
template <typename Func, typename Evaluator, int Start>
struct redux_novec_unroller<Func, Evaluator, Start, 1> {
  enum { outer, inner = Start };
  static Evaluator::ch run(Evaluator eval, Func) {
    return eval.coeffByOuterInner(outer, inner);
  }
};
template <typename, typename Evaluator,
          int = redux_traits<Evaluator>::Unrolling>
struct redux_impl;
template <typename Func, typename Evaluator>
struct redux_impl<Func, Evaluator, bc> {
  typedef Evaluator::ch ch;
  template <typename bp> static ch run(Evaluator eval, Func func, bp xpr) {
    ch res = 0;
    for (long i = 1; i < xpr.co(); ++i)
      for (long j = 0; j < xpr.innerSize(); ++j) {
        float __trans_tmp_7 = eval.coeffByOuterInner(i, j);
        res = func(res, __trans_tmp_7);
      }
    return res;
  }
};
template <typename Func, typename Evaluator>
struct redux_impl<Func, Evaluator, bd> {
  template <typename bp>
  static Evaluator::ch run(Evaluator eval, Func func, bp) {
    return redux_novec_unroller<Func, Evaluator, 0, Evaluator::cm>::run(eval,
                                                                        func);
  }
};
template <typename XprType_> struct redux_evaluator : cx<XprType_> {
  typedef cx<XprType_> Base;
  typedef XprType_ bp;
  redux_evaluator(bp xpr) : Base(xpr) {}
  typedef bp::ch ch;
  enum { cm = bp::cm };
  bp::cl coeffByOuterInner(long outer, long inner) {
    return Base::coeff(inner, outer);
  }
};
template <typename q>
template <typename Func>
p<q>::ch DenseBase<q>::cr(const Func &func) const {
  typedef redux_evaluator<q> ThisEvaluator;
  ThisEvaluator thisEval(bi());
  q __trans_tmp_16 = bi();
  return redux_impl<Func, ThisEvaluator>::run(thisEval, func, __trans_tmp_16);
}
bk<float, 3, 0> run_y;
bool run() {
  bk<at<float>, 3, 0> x;
  bm<ci<at<float>>, bk<at<float>, 3, 0>> __trans_tmp_5 = x;
  return (x - run_y).cu().cq() <= cc(__trans_tmp_5.cq(), 0);
}

To reproduce the failure, compile using a compiler that contains 9d37e61 and use the following options -O2 -g -ffast-math -std=c++20 --target=x86_64-sie-ps5:

$ ~/src/upstream/9d37e61fc77d3d6de891c30630f1c0227522031d-linux/bin/clang -c -O2 -g -ffast-math repro1.cpp -std=c++20 --target=x86_64-sie-ps5
repro1.cpp:205:28: warning: binding reference member 'm_rhs' to stack allocated parameter 'aRhs' [-Wdangling-field]
  205 |       : m_lhs(aLhs), m_rhs(aRhs) {}
      |                            ^~~~                                                                                                                                               repro1.cpp:211:13: note: reference member declared here                                                                                                                                 211 |   RhsNested m_rhs;
      |             ^
repro1.cpp:205:28: warning: binding reference member 'm_rhs' to stack allocated parameter 'aRhs' [-Wdangling-field]
  205 |       : m_lhs(aLhs), m_rhs(aRhs) {}
      |                            ^~~~
repro1.cpp:123:12: note: in instantiation of member function 'bn<cg<at<float>, at<float>>, const bk<at<float>, 3, 0>, const bk<float, 3, 0>>::bn' requested here
  123 |     return bn<cg<ch, ch>, const q, const ct>(bi(), bi());
      |            ^
repro1.cpp:297:13: note: in instantiation of function template specialization 'u<bk<at<float>, 3, 0>>::operator-<bk<float, 3, 0>>' requested here
  297 |   return (x - run_y).cu().cq() <= cc(__trans_tmp_5.cq(), 0);                                                                                                                        |             ^
repro1.cpp:211:13: note: reference member declared here                                                                                                                                 211 |   RhsNested m_rhs;
      |             ^                                                                                                                                                                 repro1.cpp:228:28: warning: arithmetic between different enumeration types ('redux_evaluator<bm<ci<at<float>>, bn<cg<at<float>, at<float>>, bk<at<float>, 3, 0>, bk<at<float>, 3, 0>>>
>::(unnamed enum at repro1.cpp:280:3)' and 'cw<bm<ci<at<float>>, bn<cg<at<float>, at<float>>, bk<at<float>, 3, 0>, bk<at<float>, 3, 0>>>>::(unnamed enum at repro1.cpp:147:3)') is deprecated [-Wdeprecated-anon-enum-enum-conversion]
  228 |   enum { y = Evaluator::cm * Evaluator::dd, UnrollingLimit = 110 };                                                                                                                 |              ~~~~~~~~~~~~~ ^ ~~~~~~~~~~~~~
repro1.cpp:252:17: note: in instantiation of template class 'redux_traits<redux_evaluator<bm<ci<at<float>>, bn<cg<at<float>, at<float>>, bk<at<float>, 3, 0>, bk<at<float>, 3, 0>>>>>' requested here
  252 |           int = redux_traits<Evaluator>::Unrolling>
      |                 ^
repro1.cpp:291:10: note: in instantiation of default argument for 'redux_impl<cd, ThisEvaluator>' required here
  291 |   return redux_impl<Func, ThisEvaluator>::run(thisEval, func, __trans_tmp_16);
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
repro1.cpp:116:20: note: in instantiation of function template specialization 'DenseBase<bm<ci<at<float>>, bn<cg<at<float>, at<float>>, bk<at<float>, 3, 0>, bk<at<float>, 3, 0>>>>::c
r<cd>' requested here
  116 |   ch cq() { return cr(cd()); }
      |                    ^
repro1.cpp:297:27: note: in instantiation of member function 'DenseBase<bm<ci<at<float>>, bn<cg<at<float>, at<float>>, bk<at<float>, 3, 0>, bk<at<float>, 3, 0>>>>::cq' requested here
  297 |   return (x - run_y).cu().cq() <= cc(__trans_tmp_5.cq(), 0);
      |                           ^
repro1.cpp:228:28: warning: arithmetic between different enumeration types ('redux_evaluator<bm<ci<at<float>>, bk<at<float>, 3, 0>>>::(unnamed enum at repro1.cpp:280:3)' and 'cw<bm<c
i<at<float>>, bk<at<float>, 3, 0>>>::(unnamed enum at repro1.cpp:147:3)') is deprecated [-Wdeprecated-anon-enum-enum-conversion]
  228 |   enum { y = Evaluator::cm * Evaluator::dd, UnrollingLimit = 110 };
      |              ~~~~~~~~~~~~~ ^ ~~~~~~~~~~~~~
repro1.cpp:252:17: note: in instantiation of template class 'redux_traits<redux_evaluator<bm<ci<at<float>>, bk<at<float>, 3, 0>>>>' requested here
  252 |           int = redux_traits<Evaluator>::Unrolling>
      |                 ^
repro1.cpp:291:10: note: in instantiation of default argument for 'redux_impl<cd, ThisEvaluator>' required here                                                               [0/1594]
  291 |   return redux_impl<Func, ThisEvaluator>::run(thisEval, func, __trans_tmp_16);
      |          ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
repro1.cpp:116:20: note: in instantiation of function template specialization 'DenseBase<bm<ci<at<float>>, bk<at<float>, 3, 0>>>::cr<cd>' requested here
  116 |   ch cq() { return cr(cd()); }
      |                    ^
repro1.cpp:297:52: note: in instantiation of member function 'DenseBase<bm<ci<at<float>>, bk<at<float>, 3, 0>>>::cq' requested here
  297 |   return (x - run_y).cu().cq() <= cc(__trans_tmp_5.cq(), 0);
      |                                                    ^
Instruction does not dominate all uses!
  %49 = shufflevector <8 x float> %47, <8 x float> %48, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 9>, !dbg !1331
  %41 = shufflevector <8 x float> %49, <8 x float> poison, <24 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 6, i32 7, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison, i32 poison>, !dbg !1331
in function _Z3runv
fatal error: error in backend: Broken function found, compilation aborted!
PLEASE submit a bug report to https://github.com/llvm/llvm-project/issues/ and include the crash backtrace, preprocessed source, and associated run script.
Stack dump:
0.      Program arguments: /home/dyung/src/upstream/9d37e61fc77d3d6de891c30630f1c0227522031d-linux/bin/clang -c -O2 -g -ffast-math repro1.cpp -std=c++20 --target=x86_64-sie-ps5
1.      <eof> parser at end of file
2.      Code generation
3.      Running pass 'Function Pass Manager' on module 'repro1.cpp'.
4.      Running pass 'Module Verifier' on function '@_Z3runv'
 #0 0x000055885dc766cf llvm::sys::PrintStackTrace(llvm::raw_ostream&, int) (/home/dyung/src/upstream/9d37e61fc77d3d6de891c30630f1c0227522031d-linux/bin/clang+0x22546cf)
 #1 0x000055885dc741e4 llvm::sys::CleanupOnSignal(unsigned long) (/home/dyung/src/upstream/9d37e61fc77d3d6de891c30630f1c0227522031d-linux/bin/clang+0x22521e4)
 #2 0x000055885dbc4e0a llvm::CrashRecoveryContext::HandleExit(int) (/home/dyung/src/upstream/9d37e61fc77d3d6de891c30630f1c0227522031d-linux/bin/clang+0x21a2e0a)
 #3 0x000055885dc6b132 llvm::sys::Process::Exit(int, bool) (/home/dyung/src/upstream/9d37e61fc77d3d6de891c30630f1c0227522031d-linux/bin/clang+0x2249132)
 #4 0x000055885c760a04 LLVMErrorHandler(void*, char const*, bool) cc1_main.cpp:0:0
 #5 0x000055885dbce3ca llvm::report_fatal_error(llvm::Twine const&, bool) (/home/dyung/src/upstream/9d37e61fc77d3d6de891c30630f1c0227522031d-linux/bin/clang+0x21ac3ca)
 #6 0x000055885dbce54e (/home/dyung/src/upstream/9d37e61fc77d3d6de891c30630f1c0227522031d-linux/bin/clang+0x21ac54e)
 #7 0x000055885d77b836 (anonymous namespace)::VerifierLegacyPass::runOnFunction(llvm::Function&) Verifier.cpp:0:0
 #8 0x000055885d6c2697 llvm::FPPassManager::runOnFunction(llvm::Function&) (/home/dyung/src/upstream/9d37e61fc77d3d6de891c30630f1c0227522031d-linux/bin/clang+0x1ca0697)
 #9 0x000055885d6c2a59 llvm::FPPassManager::runOnModule(llvm::Module&) (/home/dyung/src/upstream/9d37e61fc77d3d6de891c30630f1c0227522031d-linux/bin/clang+0x1ca0a59)
#10 0x000055885d6c3361 llvm::legacy::PassManagerImpl::run(llvm::Module&) (/home/dyung/src/upstream/9d37e61fc77d3d6de891c30630f1c0227522031d-linux/bin/clang+0x1ca1361)
#11 0x000055885df1c675 clang::emitBackendOutput(clang::CompilerInstance&, clang::CodeGenOptions&, llvm::StringRef, llvm::Module*, clang::BackendAction, llvm::IntrusiveRefCntPtr<llvm::vfs::FileSystem>, std::unique_ptr<llvm::raw_pwrite_stream, std::default_delete<llvm::raw_pwrite_stream>>, clang::BackendConsumer*) (/home/dyung/src/upstream/9d37e61fc77d3d6de891c30630f1c0227522031d-linux/bin/clang+0x24fa675)
#12 0x000055885e660071 clang::BackendConsumer::HandleTranslationUnit(clang::ASTContext&) (/home/dyung/src/upstream/9d37e61fc77d3d6de891c30630f1c0227522031d-linux/bin/clang+0x2c3e071)
#13 0x000055886008cf4c clang::ParseAST(clang::Sema&, bool, bool) (/home/dyung/src/upstream/9d37e61fc77d3d6de891c30630f1c0227522031d-linux/bin/clang+0x466af4c)
#14 0x000055885e660498 clang::CodeGenAction::ExecuteAction() (/home/dyung/src/upstream/9d37e61fc77d3d6de891c30630f1c0227522031d-linux/bin/clang+0x2c3e498)
#15 0x000055885e9375f9 clang::FrontendAction::Execute() (/home/dyung/src/upstream/9d37e61fc77d3d6de891c30630f1c0227522031d-linux/bin/clang+0x2f155f9)
#16 0x000055885e8b844e clang::CompilerInstance::ExecuteAction(clang::FrontendAction&) (/home/dyung/src/upstream/9d37e61fc77d3d6de891c30630f1c0227522031d-linux/bin/clang+0x2e9644e)
#17 0x000055885ea2c906 clang::ExecuteCompilerInvocation(clang::CompilerInstance*) (/home/dyung/src/upstream/9d37e61fc77d3d6de891c30630f1c0227522031d-linux/bin/clang+0x300a906)
#18 0x000055885c762f8d cc1_main(llvm::ArrayRef<char const*>, char const*, void*) (/home/dyung/src/upstream/9d37e61fc77d3d6de891c30630f1c0227522031d-linux/bin/clang+0xd40f8d)
#19 0x000055885c75a88a ExecuteCC1Tool(llvm::SmallVectorImpl<char const*>&, llvm::ToolContext const&) driver.cpp:0:0
#20 0x000055885e6aa4fd void llvm::function_ref<void ()>::callback_fn<clang::driver::CC1Command::Execute(llvm::ArrayRef<std::optional<llvm::StringRef>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, bool*) const::'lambda'()>(long) Job.cpp:0:0
#21 0x000055885dbc4d40 llvm::CrashRecoveryContext::RunSafely(llvm::function_ref<void ()>) (/home/dyung/src/upstream/9d37e61fc77d3d6de891c30630f1c0227522031d-linux/bin/clang+0x21a2d40)
#22 0x000055885e6aab1f clang::driver::CC1Command::Execute(llvm::ArrayRef<std::optional<llvm::StringRef>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, bool*) const (.part.0) Job.cpp:0:0
#23 0x000055885e66b914 clang::driver::Compilation::ExecuteCommand(clang::driver::Command const&, clang::driver::Command const*&, bool) const (/home/dyung/src/upstream/9d37e61fc77d3d6de891c30630f1c0227522031d-linux/bin/clang+0x2c49914)
#24 0x000055885e66c9ae clang::driver::Compilation::ExecuteJobs(clang::driver::JobList const&, llvm::SmallVectorImpl<std::pair<int, clang::driver::Command const*>>&, bool) const (/home/dyung/src/upstream/9d37e61fc77d3d6de891c30630f1c0227522031d-linux/bin/clang+0x2c4a9ae)
#25 0x000055885e675155 clang::driver::Driver::ExecuteCompilation(clang::driver::Compilation&, llvm::SmallVectorImpl<std::pair<int, clang::driver::Command const*>>&) (/home/dyung/src/upstream/9d37e61fc77d3d6de891c30630f1c0227522031d-linux/bin/clang+0x2c53155)
#26 0x000055885c75fd6b clang_main(int, char**, llvm::ToolContext const&) (/home/dyung/src/upstream/9d37e61fc77d3d6de891c30630f1c0227522031d-linux/bin/clang+0xd3dd6b)
#27 0x000055885c69195b main (/home/dyung/src/upstream/9d37e61fc77d3d6de891c30630f1c0227522031d-linux/bin/clang+0xc6f95b)
#28 0x00007f80fda21083 __libc_start_main /build/glibc-FcRMwW/glibc-2.31/csu/../csu/libc-start.c:342:3
#29 0x000055885c75a31e _start (/home/dyung/src/upstream/9d37e61fc77d3d6de891c30630f1c0227522031d-linux/bin/clang+0xd3831e)
clang: error: clang frontend command failed with exit code 70 (use -v to see invocation)
clang version 21.0.0 (https://github.com/llvm/llvm-project.git 9d37e61fc77d3d6de891c30630f1c0227522031d)
Target: x86_64-sie-ps5
Thread model: posix
InstalledDir: /home/dyung/src/upstream/9d37e61fc77d3d6de891c30630f1c0227522031d-linux/bin
Build config: +assertions

[alexey-bataev]

Fixed in 7de895f