clang generates symbol name which we can't demangle

[zmodem]

With the attached source code a.ii.gz, Clang generates a symbol which LLVM can't demangle:

$ clang -cc1 -triple x86_64-unknown-linux-gnu -emit-obj -std=c++20 -w a.ii -S -emit-llvm -o - | grep declare.*__to_address_helper
declare noundef i32 @_ZNSt2Cr12__to_addressINS_16reverse_iteratorIPNS_4pairIjmEEEEvEEu7__decayIDTclsr19__to_address_helperIT_EE6__callclsr3stdE7declvalIRKS6_EEEEES8_(ptr noundef nonnull align 1 dereferenceable(1)) #1

$ llvm-cxxfilt _ZNSt2Cr12__to_addressINS_16reverse_iteratorIPNS_4pairIjmEEEEvEEu7__decayIDTclsr19__to_address_helperIT_EE6__callclsr3stdE7declvalIRKS6_EEEEES8_
_ZNSt2Cr12__to_addressINS_16reverse_iteratorIPNS_4pairIjmEEEEvEEu7__decayIDTclsr19__to_address_helperIT_EE6__callclsr3stdE7declvalIRKS6_EEEEES8_

(Originally from https://crbug.com/1078788#c22)

[shafik]

Confirmed: https://godbolt.org/z/efTsxhrxW

    R_X86_64_PLT32 _ZNSt2Cr12__to_addressINS_16reverse_iteratorIPNS_4pairIjmEEEEvEEu7__decayIDTclsr19__to_address_helperIT_EE6__callclsr3stdE7declvalIRKS6_EEEEES8_-0x4

Source:

template <int a> struct b { static const int c = a; };
template <bool> using f = void;
namespace std {
template <class d> decltype(d(0)) declval();
template <class d> using g = __decay(d);
template <class> struct h;
template <class d> struct h<d *> { typedef d ac; };
inline namespace Cr {
template <class...> using ad = b<true>;
ad<> i;
template <class...> using j = decltype(i);
struct C {
  template <class k> using af = k *;
};
template <class> struct __to_address_helper;
template <class l, class = f<j<>::c>>
g<decltype(__to_address_helper<l>::__call(std::declval<const l &>()))>
__to_address(const l &);
template <class l> struct __to_address_helper { static decltype(0) __call(l); };
template <class ah> class reverse_iterator {
public:
  reverse_iterator(ah);
};
template <class d> struct o { using e = d *; };
template <class d> struct p { using e = C::af<d>; };
template <class ao> struct G {
  using aq = ao;
  using ar = aq::ar;
  using as = o<ar>::e;
  using at = p<ar>::e;
};
template <class> class q;
template <class d, class = q<d>> class r;
template <class d> class q {
public:
  typedef d ar;
};
template <class, class> struct pair { int ay; };
template <class ao, class ai, class az, class aj> void ba(ao, ai, az, aj s) {
  __to_address(s);
}
template <class ah> class J {
public:
  h<ah>::ac operator*();
  void operator++();
};
template <class ai> bool operator==(ai, ai);
template <class, class be> class r {
public:
  typedef G<be> bh;
  typedef bh::as as;
  typedef J<as> bi;
  typedef J<typename bh::at> bj;
  template <class...> constexpr bi bl();
  as bm;
  constexpr as bn(as);
};
template <class d, class be> constexpr r<d, be>::as r<d, be>::bn(as t) {
  using bp = reverse_iterator<as>;
  ba(0, t, bm, bp(bm));
}
template <class d, class be>
template <class...>
constexpr r<d, be>::bi r<d, be>::bl() {
  as m;
  bn(m);
}
} // namespace Cr
} // namespace std
template <class, class, class, class br> class K {
public:
  using bt = int;
  using bi = br::bi;
  using bj = br::bj;
  using bu = br;
  bj begin();
  bj end();
  template <class...> bi bx(bj);
  bu by;
};
template <class bz, class ca, class cb, class br>
template <class...>
auto K<bz, ca, cb, br>::bx(bj) -> bi {
  by.bl();
}
template <class bz, class cd, class br = std::r<std::pair<bz, cd>>>
class L : public K<bz, int, int, br> {
  using cf = K<bz, int, int, br>;

public:
  using bt = cf::bt;
  using cg = cd;
  using bi = cf::bi;
  cg &operator[](const bt &);
};
template <class bz, class cd, class br>
auto L<bz, cd, br>::operator[](const bt &) -> cg & {
  bi ch = cf::bx(ch);
}
using ci = L<unsigned, unsigned long>;
using cj = L<int, int>;
void ck() {
  cj cl;
  ci n;
  for (auto cm : cl) {
    auto cn = cm.ay;
    n[cn];
  }
}

[shafik]

CC @erichkeane

I was trying to see what gcc does for this but it does not recognize __decay and I could not find a workaround.

[shafik]

It looks like __decay is the problem, if I redefine it like this:

#define __decay(...) d

we can demangle it. A simpler test case like this also does not demangle:

template <typename T> void f5(T, __decay(T)) {}
template void f5<int>(int, __decay(int));

[shafik]

It looks like @cjdb brought in this mangling in e9ef456

[HerrCai0907]

https://reviews.llvm.org/D148465