<table border="1" cellspacing="0" cellpadding="8">
    <tr>
        <th>Issue</th>
        <td>
            <a href=https://github.com/llvm/llvm-project/issues/64253>64253</a>
        </td>
    </tr>

    <tr>
        <th>Summary</th>
        <td>
            Miscompiled C++ code for mingw/x86_64 target
        </td>
    </tr>

    <tr>
      <th>Labels</th>
      <td>
            regression,
            miscompilation
      </td>
    </tr>

    <tr>
      <th>Assignees</th>
      <td>
      </td>
    </tr>

    <tr>
      <th>Reporter</th>
      <td>
          mstorsjo
      </td>
    </tr>
</table>

<pre>
    Since c65b4d64d4b09795fe237b62a4226121c5b13248, https://reviews.llvm.org/D135462, some C++ code is miscompiled for the mingw/x86_64 target.

This breaks the libcxx testcase `libcxx/test/std/ranges/range.factories/range.repeat.view/ctor.piecewise.pass.cpp`.

Noticing the issue is somewhat tricky since this testcase is rather new; the libcxx CI uses a prebuilt release with Clang 16 (where the testcase passes correctly). At the point of the regression, the testcase didn't exist yet (so a configuration that tests libcxx with latest git Clang didn't catch it immediately until long after the miscompilation was introduced); the test (and corresponding libc++ implementation) was added only later.

The issue can be reproduced with a reduced testcase like this:
```c++
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <wchar.h>
#include <ctype.h>
#include <wctype.h>
#include <stdio.h>

namespace std {
template <class, int b> struct c { static const bool f = b; };
template <bool d> using e = c<bool, d>;
template <class a, class g> using h = e<__is_same(a, g)>;
void ab();
inline namespace ad {
template <class, class> concept i = requires { ab; };
template <class a, class g> concept aa = h<a, g>::f;
template <class a, class g> concept j = aa<g, a>;
template <bool, class, class> using ah = int;
template <class, class> using ae = int;
template <class, class> using af = decltype(0);
template <class, class, class, class> struct ag;
template <class aj, class ai> using aq = af<ae<aj, ai>, ae<ai, aj>>;
template <class ak, class al, class aj, class ai> requires requires {
  typename aq<aj, ai>;
}
struct ag<ak, al, aj, ai>;
template <class a> concept am = requires { a{}; };
template <class a> concept an = i<a, a>;
template <class a> concept ao = i<a, a>;
template <class a> constexpr bool ap = __is_object(a);
} // namespace ad
struct n {
  template <class g> using k = g;
};
template <class, class g> using ar = n::k<g>;
template <class a> concept as = am<a>;
namespace ad {
template <class a> a *addressof(a &);
template <class at> concept au = requires(at aw) { aw; };
template <class at> concept ax = requires(at aw) { aw; };
struct {
  template <class a> auto operator()(a &&ay) { return ay.az(); }
} az;
template <size_t...> struct o;
template <class ba, ba... bb> struct bc {
 template <size_t> using l = o<bb...>;
};
template <size_t bd, size_t be>
using m = __make_integer_seq<bc, size_t, bd>::template l<be>;
template <class...> class tuple;
template <size_t...> struct o {};
template <size_t bd, size_t be = 0> struct q { typedef m<bd, be> ac; };
template <class...> struct bf {};
template <class> struct bg;
template <class... a> struct bg<tuple<a...>> : c<size_t, sizeof...(a)> {};
template <class, class> struct bh;
template <template <class...> class s, class... av, size_t... bi>
struct bh<s<av...>, o<bi...>> {
 template <class a> using p = bf<ar<a, __type_pack_element<bi, av>>...>;
};
template <class a, size_t bd = bg<a>::f> struct bj {
 using bk = a;
  using r = bh<bk, typename q<bd>::ac>;
  using ac = r::template p<a>;
};
int piecewise_construct;
template <size_t, class> class v {
public:
  template <class a> v(a) {}
};
template <class...> struct w;
template <size_t... t, class... a> struct w<o<t...>, a...> : v<t, a>... {
  template <size_t... x, class... y> w(o<x...>, bf<y...>) : v<x, y>(0)... {}
};
template <class... a> class tuple {
 w<typename q<sizeof...(a)>::ac, a...> bl;

public:
  template <class... g>
  tuple(g...) : bl(typename q<sizeof...(g)>::ac(), typename bj<tuple>::ac()) {}
};
template <class... a> tuple(a...) -> tuple<a...>;
template <class a, class s> a bm(s) { return a(); }
template <class a, class s> a bn(s ay) { return bm<a>(ay); }
template <class a> concept bo = ax<a>;
template <class z> class bp {
  z u() { return static_cast<z &>(*this); }

public:
  template <bo bq> auto operator[](bq br) { return az(u())[br]; }
};
struct bs {
} unreachable_sentinel;
template <class a> concept bt = ap<a>;
namespace ranges {
template <bt> class bu;
template <class a> concept bv = ao<a>;
template <bt a> requires bv<a> class bu<a> {
  a bw;

public:
  bu(...) {}
  a &operator*() { return bw; }
};
template <class a> concept bx = au<a>;
template <an a, as by = bs>
requires(ap<a> &&j<a, a> && (bx<by> || j<by, bs>)) class repeat_view
    : public bp<repeat_view<a>> {
  class bz;

public:
  template <class... ca>
  repeat_view(int, tuple<> cb, tuple<ca...> cc)
      : ce(bn<a>(cb)), cf(bn<by>(cc)) {}
  bz az() { return addressof(*ce); }
  bu<a> ce;
  [[__no_unique_address__]] by cf;
};
template <an a, as by>
requires(ap<a> &&j<a, a> &&
 (bx<by> || j<by, bs>)) class repeat_view<a, by>::bz {
  friend repeat_view;
  using cg = ah<j<by, bs>, ptrdiff_t, by>;
  bz(a *ch) : ce(ch) {}

public:
  using cd = cg;
  a operator*() { return *ce; }
  a operator[](cd) { return **this; }
  a *ce;
};
} // namespace ranges
} // namespace ad
} // namespace std


struct A {
  int x = 111;
  int y = 222;

  constexpr A() = default;
 constexpr A(int _x, int _y) : x(_x), y(_y) {}
};

int main(int, char**) {
  std::ranges::repeat_view<A> rv(std::piecewise_construct, std::tuple{}, std::tuple{std::unreachable_sentinel});
  printf("rv[0].x = %d - %s\n", rv[0].x, rv[0].x == 111 ? "ok" : "incorrect");
  if (rv[0].x != 111)
    return 1;

  return 0;
}
```
[misopt.zip](https://github.com/llvm/llvm-project/files/12214381/misopt.zip)

(I'll rerun the reduction to try to retain the libc++ header names to keep it slightly more readable.)

If compiled with `clang -target x86_64-w64-mingw32 -std=c++2b misopt.cpp -o misopt.exe`, the resulting binary outputs `rv[0].x = 0 - incorrect`. If optimization is added with e.g. `-O2`, it correctly outputs `rv[0].x = 111 - ok` instead. If compiled with Clang 16, it runs correctly in both cases.

CC @asavonic 
</pre>
<img width="1px" height="1px" alt="" src="http://email.email.llvm.org/o/eJykWktz4j4S_zTKpSsUyGDgkAMhk6o57O5h905JsjBKjO1IMoR8-q2WZFsGApn5V01NbD36-euHLJgxKi-lfCKzZzJ7eWCN3VX6aW9spc1b9cCr7PT0X1UKCSKd8WmWTrMpHy_ny9lW0mTOU8qmlKYTOhEzPknodEHoGnbW1oYkK0JfCX3V8qDk0YyK4rAfVTon9PVlksymKcW1ptpLWBP6TOgziCqToAzslRHVvlaFzGBbabA7CXtV5kdCXz8X6SadgmU6l3ZExi9kvPL__2-nDHAt2btxOwrFxecnWGmsYEYCScd-iNBXHCT01dgMJWRlLk37MNoyYSutohEta8nsCPUg9BVnR7WSQh6VkaOaGTMSdU3S8UCcf1dWCVXmThZlTONUQ32PO2bBaiXeT2CcdS2K3gmqDGhmd1JDKY8keY61Wf-GxkgDDGoteaMKC1oWErcdld3BumBlDpMUCF0cd1JLt7kjjcJKA6LSWgpbnAhdjmBl3aK6UqWFautetMy1NEZVJXppQCNTWUno3IL8VMbCSVpkZipgIKpyq_JGM6uqEqzTUxprWumdiAXDMciVDdJ2BAWzYgfKgtrvZaaYlcUJmtKqAoqqzIFtrWzREBDiOR2ZAVVaXWWNkBmhy9ZqjhOhC1ZmXmlTV2WGXkGJAuzUvi7kXpbWESN06eixLJMZVGVxchLrM6y1PhWsBI72qgN3ryQDLf1rZ7dCvXtPY2h4WunY_wuShFGaqFIUTSaBJGtjM1Xa0Y4kv76ZLhS_Ma1VmX87fRQ7pr-dFfZUyxt7b06j3FU86_4v2V6amgkJxmZA5kFlK_c1GtlxLZgxCDpEIyfJLzBWN8KCwPVg0EsCkWYs8KoqYAskecGVz0DmLyS5QtOty5BWY9D50m0RYQaZ4eTVrU4cYLjGP-Y9mZ0jI0my3myU2Ri2l4g1XJs7EPYkD5XKgHFCFx6dflSVhSol9FZh94ziH5JfaAAhawvKyaDlR6O0NM5E7KYtrivUkmPM0duRZB30QCVWJFlt_4LamyPGGEnWOS5h31m5dcOlnt7SzJtalfZ7Ka5tk3-3zUMqk6JAjBO6GMdeu0HiqgoBvyy_ZcG33oRMRaJ8eBNu0SGINL_QLXEPbky5xzdn3Zswfo-4FNHzBfcOUDGyPFkANApiFtjHmUQtawSfe4h0X3vunu-1TddwFUNzfwXqKJUD-l28x5RKD4sW5N_C8tre6q_2Gis_a-0TFqsdCZczKv4mhfVZYxmbD3z3NMgNA5OWA49cMI7S1Ltjlw-ccx_LMQWmHYnSZ4J3F85_YDLjMbx3Nov2_TDveWoMCF2xLMO2pNqixYDQ9GZcArMDOZoBgJCEBXbEgu-wdPwBjIYEP_-QYHDdTcd5ZRtbQVVLzWylQ9HoNE7ZqWWhpW10Cew0Yl9dbYEu-hBH7OuqPkZ9yY0djUZRhqpuaM4d2jkbjUbA47LMRaTPJYceRIUzVoXZnnu-dxHpSQDP3FEhvMiup_B09yGa9uxdblRpZS71xkhMTdjitRud-FlXzjo2Ba6TN-EcrOQNYZu6kD83KXQZ6qfqOXXGEY0P52pMupncAkaR3-GkBibuwnYoEt_ekum8avEbVQuxwM7WroN91qz18S8gyco1W70j8Kna4oo28_26L9SVmsp3V9ff9mBPySlw6K3vwK06fEVM1gZVOgSd6NrjWEU6Xo2BKKQ9WH3q566c67aGbDbo3E3NxPtG-qOIo-7qy8Ez-GHERP1Yhy7PMu-yb-jmeiO-RdJ7MbmvGazjAWHCFwJnEe7KedcLfHhctgwQlr8utjPhM-ZZDNbnlSFWD88B3XF742opin0jooaNsrPIoVexbnihRHcI-zYHHwI2W2Det_swzo63kwTYIQyHO9eIL9vDLUSTC6UDTrW9B-79pp70rD4HrE5I6EjoAnl89jwcKk_t-7Lj5Xaf3KBrhFuWP7VJ6Ab67BkJjKoOIHQlM3SAiuzAix4rP_QqSpJ3sQ0hkdNF7ph5dXlB6OJbefJzeXxdjoKAv_UZ8GLdnyHJW60VkgUhH_vBKMX-5GBmfBPF94QuzHn_cKV3-BGxEonBRT_Cu1aPLtzkXcpRV8V9h80-z5PC5b6vHli8jsPgCxqvUiyV_3SwEcxgev1yzZQTkdCV-y5z3j3dBxavgH9cNmzucyqhC_4BXJ_bGhu1psMEmT1zjavP-rbznpFHJzBs65pSSyZ2jBdyY2RpVSmLnzbk3HoLX6TdviH330SvN-XcRmZvfsz04JlWt9zKrd_UHfL4ISyP-Pn3yNsM-PFeOuBo8jbSozAEd7BI-157dQkcfvzWO_eU9icE1txSmpU-tJgBfvL11XR5Kj5c1J3u7hjwFp9Bwxgg6jBy-MkbaU3ma3jzA5jjjU_uqKGX13_c3riP28Ei4HKhNyFw5BovajUZuCB45-uvsrJgUVqOWdGFKl2lazOesy2PR0RbEYRAtToNvA4Ccycv-2yEm5cha4ttO8lDdfM0LhDCv6A9Xg0iOTqMErpCXsMEAhFchYyaIZcgnjebsto0pfpo5CbQ2mwwFcxeEAhie7fbGyDnbyEThPpHwAlUvRCu7PGvGB5brWSZDbectYYi96GCreUF2zXUVmdquw3nuNOwueRf4XS8Eru2lDvXh9e47F7HZZDB98oij2gzuJkbvOOHXmeXlUBkl_vasnO-uSV56fur34XC9dX9D0dXJ43NYsMMas4qdiG24T6bTSaTyD447rMWpfQs_CH69NXZzn1Z3bKm6Fv4s2VIcvPZ3gFsTq1LPwld4PjSN6R0sTnd6qr648OeqbJPJmLHvC9X7e4gLNrCgTeY1D8PYL5y1QmPBt3ia2cTPH618z5TeRmvjXcDV0s6blpG5q61Kq3POFQfyOx5TGYvI-8YQmcZPOIfQ2brklB3xRqtOnvFTcGhQJJXIJRW74RSZ2xCqSrDRaGjFEuhtpgvBqTopMVGnIYD2icXwAgT48tPxt2tWHidPe-VqWo7-lK1D6bhBXOu7K7hI1HtCX0tikP757HWlf-4-rpVhbvOnVA6mSaLCaGvEc1W3vA_XfwmdF4UoKVuynAbmjXC32lWYPUJ_2hpmSq7u9lwl7iTLJPaxxeuepeyBmXBFCrf2eIE-0ojPZahm0dnvH9vobv4dteIJB0Ld0f66C-8wV9_Px7T6aO7EU8oPDoAvQQJKIegmqhreKzaN_kp0aThMldL0xTWnfRVyfQJqsbWjTXI8BxVY3iEHgnpeAS_t1DVVu3Vl79-Ve1tqZNZjvIR0nn8Dw0cle1vnG9xQhw-QvVO0jEoTAgsc8yGNmmvuANl3ZTRhTaoEnhldyCYkWZwZ7teA5mOmWGHqlQCHrKnJFsmS_YgnybpcrwYT5Y0fdg9JfNkLmaST9J0ns6nIqHJLM3mC05Tukzn_EE90TFNxvNkMplM6Hg2StMJW0g6nm3nPJmMJZmO5Z6povvNw4O7K35Kp3SWPBSMy8K431xQGt-zY7QSSod32zg8e3nQTw7SvMkNmY4LZWz_i4oHq2whn_4V_Wpi8IuKbaWv_3ziodHF0x8Hk9MFo8mp8_8AAAD__9V4BeE">