Assertion failure in clang::Sema::tryCaptureVariable: isa<To>(Val) && "cast<Ty>() argument of incompatible type!") #64045
Labels
Comments
|
If I rewrite as: the crash goes away |
|
@llvm/issue-subscribers-clang-codegen |
|
@llvm/issue-subscribers-c-20 |
|
I can reproduce (though with some tweaks to the shell script) with relatively recent main. It's an assertion: Btw, note that Apple clang bugs should also be reported in Apple's bug tracker. |
fhahn
changed the title
|
This turned out to be difficult to reduce; I couldn't get it much further down than the following: // working: clang -cc1 -triple x86_64-- -S -std=c++20 -DALTERNATIVE canonical_shuffle_adapter-min.cpp
// failing: clang -cc1 -triple x86_64-- -S -std=c++20 canonical_shuffle_adapter-min.cpp
namespace std {
namespace {
template <class _Tp, _Tp __v> struct integral_constant {
static const _Tp value = __v;
};
typedef integral_constant<bool, 1> true_type;
} // namespace
} // namespace std
typedef int ptrdiff_t;
typedef int size_t;
namespace std {
namespace {
template <class _Tp> using remove_cvref_t = _Tp;
template <class> struct __libcpp_is_floating_point : true_type {};
template <class _Tp>
struct is_floating_point : __libcpp_is_floating_point<_Tp> {};
template <class _Tp>
constexpr int is_floating_point_v = is_floating_point<_Tp>::value;
typedef int string;
template <class _Tp> struct __unwrap_reference {
typedef _Tp type;
};
template <class _Tp> struct unwrap_reference : __unwrap_reference<_Tp> {};
template <class _Tp> struct unwrap_ref_decay : unwrap_reference<_Tp> {};
template <class> struct tuple_size;
template <class _Tp, _Tp...> struct integer_sequence {};
template <size_t... _Ip>
using index_sequence = integer_sequence<size_t, _Ip...>;
template <class _Tp, _Tp _Ep>
using __make_integer_sequence = __make_integer_seq<integer_sequence, _Tp, _Ep>;
template <class _Tp, _Tp _Np>
using make_integer_sequence = __make_integer_sequence<_Tp, _Np>;
template <size_t _Np>
using make_index_sequence = make_integer_sequence<size_t, _Np>;
template <class _Tp, size_t> struct array {
typedef _Tp reference;
typedef size_t size_type;
constexpr reference operator[](size_type __n) { return __n; }
};
} // namespace
} // namespace std
namespace tts {
struct callable {
template <typename Function> callable(Function) {}
};
struct test {
static bool acknowledge(test);
std::string name;
callable behaviour;
};
template <typename...> struct types {};
template <typename... Ls> struct concatenate {
using type = decltype((Ls{} + ...));
};
template <typename... Ls>
using concatenate_t = typename concatenate<Ls...>::type;
template <typename> struct type {};
using real_types = types<float>;
using arithmetic_types = real_types;
} // namespace tts
namespace tts::detail {
template <typename... Types> struct test_captures {
auto operator+(auto body) {
return test::acknowledge({name, [=] { (body(type<Types>()), ...); }});
}
std::string name;
};
template <typename... Types>
struct test_captures<types<Types...>> : test_captures<Types...> {};
} // namespace tts::detail
namespace {
template <ptrdiff_t Cardinal>
struct fixed : std::integral_constant<ptrdiff_t, Cardinal> {};
template <ptrdiff_t Cardinal> fixed<Cardinal> lane;
} // namespace
namespace _ {
template <int, typename T> struct leaf {
T value;
};
template <int I, typename T> T get_leaf(leaf<I, T>);
template <typename...> struct binder;
template <int... Is, typename... Ts>
struct binder<std::integer_sequence<int, Is...>, Ts...> : leaf<Is, Ts>... {};
template <typename ISeq, typename... Ts> struct make_binder {
using type = binder<ISeq, Ts...>;
};
template <typename ISeq, typename... Ts>
using make_binder_t = typename make_binder<ISeq, Ts...>::type;
} // namespace _
namespace kumi {
template <size_t> struct index_t {};
template <size_t N> index_t<N> index;
template <typename> struct is_product_type : std::true_type {};
template <typename T> struct size : std::tuple_size<T> {};
template <typename...> struct tuple;
template <typename T>
concept product_type = is_product_type<std::remove_cvref_t<T>>::value;
template <typename Function, product_type Tuple>
auto apply(Function f, Tuple t) {
[&]<size_t... I>(std::index_sequence<I...>) {
f(get<I>(t)...);
}(std::make_index_sequence<size<Tuple>::value>());
}
} // namespace kumi
template <typename... Ts>
struct std::tuple_size<kumi::tuple<Ts...>>
: integral_constant<size_t, sizeof...(Ts)> {};
namespace kumi {
template <typename... Ts> struct tuple {
using binder_t =
_::make_binder_t<std::make_integer_sequence<int, sizeof...(Ts)>, Ts...>;
binder_t impl;
template <size_t I> auto operator[](index_t<I>) { return get_leaf<I>(impl); }
};
template <typename... Ts>
tuple(Ts...) -> tuple<typename std::unwrap_ref_decay<Ts>::type...>;
template <typename... Ts>
tuple<typename std::unwrap_ref_decay<Ts>::type...> make_tuple(Ts...);
template <size_t I, typename... Ts> auto get(tuple<Ts...> arg) {
return arg[index<I>];
}
template <product_type Tuple> auto reverse(Tuple t) {
return [&]<size_t... I>(std::index_sequence<I...>) {
return make_tuple(get<1 - I>(t)...);
}(std::make_index_sequence<size<Tuple>::value>());
}
} // namespace kumi
namespace eve::detail {
template <typename, template <typename> class>
struct instance_of_impl : std::true_type {};
template <typename T, template <typename> class Templ>
concept instance_of = instance_of_impl<T, Templ>::value;
} // namespace eve::detail
namespace eve {
template <typename> struct logical;
}
namespace eve::detail {
template <typename T> constexpr bool is_plain() {
return std::is_floating_point_v<T>;
}
} // namespace eve::detail
namespace eve {
template <typename T>
concept plain_scalar_value = detail::is_plain<T>();
template <typename T>
concept arithmetic_scalar_value = plain_scalar_value<T>;
//inline namespace arm_abi_v0 {
template <arithmetic_scalar_value, typename> struct wide;
//}
template <typename T>
concept logical_simd_value = detail::instance_of<T, logical>;
template <typename T>
concept simd_value = logical_simd_value<T>;
namespace detail {
template <typename, typename = void> struct callable_object;
}
template <typename Type, typename Size> struct as_wide {
using type = wide<Type, Size>;
};
template <typename Type, typename Size>
using as_wide_t = typename as_wide<Type, Size>::type;
template <ptrdiff_t...> struct pattern_t {};
template <ptrdiff_t...> auto pattern = pattern_t{};
template <typename F>
concept pattern_formula = !requires { F::size0; };
template <ptrdiff_t, pattern_formula F> auto fix_pattern(F) {
return pattern<>;
}
//namespace arm_abi_v0 {
template <arithmetic_scalar_value, typename Cardinal> struct wide {
using size_type = ptrdiff_t;
static constexpr size_type size() { return Cardinal::value; }
};
//} // namespace arm_abi_v0
template <arithmetic_scalar_value Type, typename Cardinal>
struct logical<wide<Type, Cardinal>> {};
namespace tag {
struct canonical_shuffle_adapter_impl_;
}
namespace detail {
template <typename Dummy> struct callable_object<Dummy> {
template <typename Arg> auto call(Arg d) { d(); }
template <typename... Args> auto operator()(Args... args) { call(args...); }
};
callable_object<tag::canonical_shuffle_adapter_impl_>
canonical_shuffle_adapter_impl;
} // namespace detail
} // namespace eve
namespace eve::detail {
template <typename InternalShuffle> struct canocical_shuffle_adapter_bound {
InternalShuffle internalShuffle;
template <ptrdiff_t G, simd_value T>
auto operator()(pattern_t<>, fixed<G>, T) {
canonical_shuffle_adapter_impl(internalShuffle);
}
auto operator()(pattern_t<> p, auto x) -> decltype(operator()(p, lane<1>, x));
};
template <typename Internal> struct reverse_arguments {
Internal internal;
template <typename... Ts> auto impl(Ts... args) {
apply(internal, reverse(kumi::tuple{args...}));
}
auto operator()(auto... args) { impl(args...); }
};
template <typename Internal>
reverse_arguments(Internal) -> reverse_arguments<Internal>;
template <typename InternalShuffle> auto as_canonical_shuffle(InternalShuffle) {
return reverse_arguments{canocical_shuffle_adapter_bound<InternalShuffle>{}};
}
} // namespace eve::detail
namespace eve {
template <typename, typename> struct to_wide;
template <typename T, size_t... N>
struct to_wide<T, std::index_sequence<N...>> {
using type = tts::types<as_wide_t<T, fixed<N>>...>;
};
template <typename T, typename I>
using to_wide_t = typename to_wide<T, I>::type;
template <typename> struct wides;
template <typename... Ts> struct wides<tts::types<Ts...>> {
static constexpr std::array<size_t, 9> cardinals() { return {}; }
using type = tts::concatenate_t<
to_wide_t<Ts, std::make_index_sequence<cardinals()[sizeof(Ts)]>>...>;
};
} // namespace eve
namespace eve::test::simd {
using all_types = wides<tts::arithmetic_types>::type;
}
namespace {
template <typename T, ptrdiff_t>
auto some_pattern = eve::fix_pattern<T::size()>([] {});
template <typename T, ptrdiff_t G = 1>
using some_p_t = decltype(some_pattern<T, G>);
#if ALTERNATIVE
template <typename Selector> auto just_shuffle_test(Selector) {
return [](...) {};
}
#else
template <typename Selector> auto just_shuffle_test(Selector selector) {
auto add_index = [](auto... args) -> kumi::tuple<decltype(selector(args))> {
} auto canonical = eve : detailas_canonical_shuffle(add_index);
return [](auto... args) -> decltype(canonical(args...)) {}
}
#endif
bool case_tts_function2 =
tts::detail::test_captures<eve::test::simd::all_types>{} +
[]<typename T>(tts::type<T>) {
auto hasShuffle = just_shuffle_test([] {});
using P = some_p_t<T>;
hasShuffle(eve::logical<T>{}, P{});
};
} // namespace |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Unfortunately,
diagnosticfolder does not have clang files. Attaching .cpp and .shOutput:
Files:
https://drive.google.com/file/d/1MrKoY80U3xQ6rGJ6cvMMvuhIEma3H8Ev/view?usp=sharing
The text was updated successfully, but these errors were encountered: