Revert "Force inline with GCC"

This reverts commit 8ec5d05.

Author: OliverRietmann

GPU/Common/MemLayout.h

@@ -21,56 +21,56 @@ template <class SF>
 struct RandomAccessAt {
     MemLayout::size_t i;
     template <class... Args>
-    [[gnu::always_inline]] constexpr SF operator()(Args& ...args) const { return {args[i]...}; }
+    constexpr SF operator()(Args& ...args) const { return {args[i]...}; }
     template <class... Args>
-    [[gnu::always_inline]] constexpr SF operator()(const Args& ...args) const { return {args[i]...}; }
+    constexpr SF operator()(const Args& ...args) const { return {args[i]...}; }
 };
 
 template <class SF>
 struct GetPointer {
     template <class... Args>
-    [[gnu::always_inline]] constexpr SF operator()(Args& ...args) const { return {&args...}; }
+    constexpr SF operator()(Args& ...args) const { return {&args...}; }
     template <class... Args>
-    [[gnu::always_inline]] constexpr SF operator()(const Args& ...args) const { return {&args...}; }
+    constexpr SF operator()(const Args& ...args) const { return {&args...}; }
 };
 
 template <class SF>
 struct AggregateConstructor {
     template <class... Args>
-    [[gnu::always_inline]] constexpr SF operator()(Args& ...args) const { return {args...}; }
+    constexpr SF operator()(Args& ...args) const { return {args...}; }
     template <class... Args>
-    [[gnu::always_inline]] constexpr SF operator()(const Args& ...args) const { return {args...}; }
+    constexpr SF operator()(const Args& ...args) const { return {args...}; }
 };
 
 struct FirstMember {
     template <class T, class... Args>
-    [[gnu::always_inline]] constexpr T& operator()(T& t, Args& ...args) const { return t; }
+    constexpr T& operator()(T& t, Args& ...args) const { return t; }
     template <class T, class... Args>
-    [[gnu::always_inline]] constexpr const T& operator()(const T& t, const Args& ...args) const { return t; }
+    constexpr const T& operator()(const T& t, const Args& ...args) const { return t; }
 };
 
 template <class SF>
 struct PreIncrement {
     template <class... Args>
-    [[gnu::always_inline]] constexpr SF operator()(Args& ...args) const { return {++args...}; }
+    constexpr SF operator()(Args& ...args) const { return {++args...}; }
 };
 
 template <class SF>
 struct PreDecrement {
     template <class... Args>
-    [[gnu::always_inline]] constexpr SF operator()(Args& ...args) const { return {--args...}; }
+    constexpr SF operator()(Args& ...args) const { return {--args...}; }
 };
 
 template <class SF>
 struct Advance {
     ptrdiff_t i;
     template <class... Args>
-    [[gnu::always_inline]] constexpr SF operator()(const Args& ...args) const { return {(args + i)...}; }
+    constexpr SF operator()(const Args& ...args) const { return {(args + i)...}; }
 };
 
 struct CopyAssignment {
     template <class Left, class Right>
-    [[gnu::always_inline]] constexpr Left& operator()(Left& left, const Right& right) const { return left = right; }
+    constexpr Left& operator()(Left& left, const Right& right) const { return left = right; }
 };
 
 template <
@@ -87,11 +87,11 @@ struct wrapper : public S<F> {
     template <template <class> class F_other>
     constexpr wrapper(const S<F_other>& other) : Base{other.apply(AggregateConstructor<Base>{})} {}
 
-    [[gnu::always_inline]] constexpr wrapper<S, reference> operator[] (size_t i) { return Base::apply(RandomAccessAt<S<reference>>{i}); }
-    [[gnu::always_inline]] constexpr wrapper<S, const_reference> operator[] (size_t i) const { return Base::apply(RandomAccessAt<S<const_reference>>{i}); }
+    constexpr wrapper<S, reference> operator[] (size_t i) { return Base::apply(RandomAccessAt<S<reference>>{i}); }
+    constexpr wrapper<S, const_reference> operator[] (size_t i) const { return Base::apply(RandomAccessAt<S<const_reference>>{i}); }
 
-    [[gnu::always_inline]] constexpr wrapper<S, reference> operator*() { return operator[](0); }
-    [[gnu::always_inline]] constexpr wrapper<S, const_reference> operator*(ptrdiff_t) const { return operator[](0); }
+    constexpr wrapper<S, reference> operator*() { return operator[](0); }
+    constexpr wrapper<S, const_reference> operator*(ptrdiff_t) const { return operator[](0); }
 };
 
 template <template <template <class> class> class S>
@@ -226,13 +226,13 @@ struct wrapper<S, pointer> : public S<pointer> {
     constexpr wrapper() = default;
     constexpr wrapper(Base b) : Base{static_cast<Base&&>(b)} {}
 
-    [[gnu::always_inline]] constexpr wrapper<S, reference> operator[] (size_t i) { return Base::apply(RandomAccessAt<S<reference>>{i}); }
-    [[gnu::always_inline]] constexpr const wrapper<S, const_reference> operator[] (size_t i) const { return Base::apply(RandomAccessAt<S<const_reference>>{i}); }
+    constexpr wrapper<S, reference> operator[] (size_t i) { return Base::apply(RandomAccessAt<S<reference>>{i}); }
+    constexpr const wrapper<S, const_reference> operator[] (size_t i) const { return Base::apply(RandomAccessAt<S<const_reference>>{i}); }
 
-    [[gnu::always_inline]] constexpr wrapper<S, reference> operator*() { return operator[](0); }
-    [[gnu::always_inline]] constexpr wrapper<S, const_reference> operator*() const { return operator[](0); }
-    [[gnu::always_inline]] constexpr wrapper<S, reference> operator->() { return operator[](0); }
-    [[gnu::always_inline]] constexpr wrapper<S, const_reference> operator->() const { return operator[](0); }
+    constexpr wrapper<S, reference> operator*() { return operator[](0); }
+    constexpr wrapper<S, const_reference> operator*() const { return operator[](0); }
+    constexpr wrapper<S, reference> operator->() { return operator[](0); }
+    constexpr wrapper<S, const_reference> operator->() const { return operator[](0); }
 
     constexpr bool operator==(const wrapper& other) const { return Base::apply(FirstMember{}) == other.apply(FirstMember{}); }
     constexpr bool operator!=(const wrapper& other) const { return !this->operator==(other); }
@@ -259,9 +259,9 @@ struct wrapper<S, const_pointer> : public S<const_pointer> {
     constexpr wrapper(Base b) : Base{static_cast<Base&&>(b)} {}
     constexpr wrapper(const S<pointer>& other) : Base(other.apply(AggregateConstructor<Base>{})) {}
 
-    [[gnu::always_inline]] constexpr wrapper<S, const_reference> operator[] (size_t i) const { return Base::apply(RandomAccessAt<S<const_reference>>{i}); }
-    [[gnu::always_inline]] constexpr wrapper<S, const_reference> operator*() const { return operator[](0); }
-    [[gnu::always_inline]] constexpr wrapper<S, const_reference> operator->() const { return operator[](0); }
+    constexpr wrapper<S, const_reference> operator[] (size_t i) const { return Base::apply(RandomAccessAt<S<const_reference>>{i}); }
+    constexpr wrapper<S, const_reference> operator*() const { return operator[](0); }
+    constexpr wrapper<S, const_reference> operator->() const { return operator[](0); }
 
     constexpr bool operator==(const wrapper& other) const { return Base::apply(FirstMember{}) == other.apply(FirstMember{}); }
     constexpr bool operator!=(const wrapper& other) const { return !this->operator==(other); }
@@ -292,20 +292,20 @@ struct interface<S, F, Flag::soa> { using type = wrapper<S, F>; };
 
 #define MEMLAYOUT_APPLY_UNARY(...)\
     template <class Function>\
-    [[gnu::always_inline]] constexpr auto apply(Function&& f) { return f(__VA_ARGS__); }\
+    constexpr auto apply(Function&& f) { return f(__VA_ARGS__); }\
     template <class Function>\
-    [[gnu::always_inline]] constexpr auto apply(Function&& f) const { return f(__VA_ARGS__); }\
+    constexpr auto apply(Function&& f) const { return f(__VA_ARGS__); }\
 
 #define MEMLAYOUT_EXPAND(m) f(m, other.m)
 
 #define MEMLAYOUT_APPLY_BINARY(STRUCT_NAME, ...)\
     template <template <class> class F_other, class Function>\
-    [[gnu::always_inline]] constexpr STRUCT_NAME apply(STRUCT_NAME<F_other>& other, Function&& f) { return {__VA_ARGS__}; }\
+    constexpr STRUCT_NAME apply(STRUCT_NAME<F_other>& other, Function&& f) { return {__VA_ARGS__}; }\
     template <template <class> class F_other, class Function>\
-    [[gnu::always_inline]] constexpr STRUCT_NAME apply(STRUCT_NAME<F_other>& other, Function&& f) const { return {__VA_ARGS__}; }\
+    constexpr STRUCT_NAME apply(STRUCT_NAME<F_other>& other, Function&& f) const { return {__VA_ARGS__}; }\
     template <template <class> class F_other, class Function>\
-    [[gnu::always_inline]] constexpr STRUCT_NAME apply(const STRUCT_NAME<F_other>& other, Function&& f) { return {__VA_ARGS__}; }\
+    constexpr STRUCT_NAME apply(const STRUCT_NAME<F_other>& other, Function&& f) { return {__VA_ARGS__}; }\
     template <template <class> class F_other, class Function>\
-    [[gnu::always_inline]] constexpr STRUCT_NAME apply(const STRUCT_NAME<F_other>& other, Function&& f) const { return {__VA_ARGS__}; }\
+    constexpr STRUCT_NAME apply(const STRUCT_NAME<F_other>& other, Function&& f) const { return {__VA_ARGS__}; }\
 
 #endif // MEMLAYOUT_H