--- /dev/null
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+extern void __assert_fail(const char*, const char*, int, const char*);
+namespace Eigen {
+enum { AutoAlign };
+template <int, typename>
+struct conditional;
+template <typename Else>
+struct conditional<false, Else> {
+ typedef Else type;
+};
+template <typename T>
+struct remove_reference {
+ typedef T type;
+};
+struct is_arithmetic {
+ enum { value };
+};
+template <typename>
+struct traits;
+template <typename T>
+struct traits<const T> : traits<T> {};
+template <typename>
+struct evaluator;
+template <typename>
+struct EigenBase;
+template <typename>
+class PlainObjectBase;
+template <typename, int _Rows, int _Cols, int = AutoAlign, int = _Rows,
+ int = _Cols>
+class Matrix;
+template <typename>
+class MatrixBase;
+template <typename, typename>
+class CwiseNullaryOp;
+template <typename, typename, typename>
+class CwiseBinaryOp;
+template <typename>
+struct scalar_constant_op;
+template <int _Rows>
+struct size_at_compile_time {
+ enum { ret = _Rows };
+};
+struct ref_selector {
+ typedef const Matrix<float, 3, 1>& type;
+};
+template <typename Derived>
+struct dense_xpr_base {
+ typedef MatrixBase<Derived> type;
+};
+template <typename Derived, typename = typename traits<Derived>::XprKind>
+struct generic_xpr_base {
+ typedef typename dense_xpr_base<Derived>::type type;
+};
+template <typename Expr, typename Scalar = typename Expr::Scalar>
+struct plain_constant_type {
+ ;
+ typedef CwiseNullaryOp<scalar_constant_op<Scalar>,
+ Matrix<Scalar, traits<Expr>::ColsAtCompileTime,
+ traits<Expr>::MaxRowsAtCompileTime,
+ traits<Expr>::MaxColsAtCompileTime>>
+ type;
+};
+struct scalar_product_op {
+ float operator()(float a, float b) { return a * b; }
+};
+template <typename>
+struct scalar_constant_op {
+ scalar_constant_op(float other) : m_other(other) {}
+ float operator()() { return m_other; }
+ float m_other;
+};
+struct assign_op {
+ void assignCoeff(float& a, float b) { a = b; }
+};
+template <typename Derived>
+class DenseCoeffsBase : public EigenBase<Derived> {
+ public:
+ typedef typename traits<Derived>::Scalar Scalar;
+ typedef
+ typename conditional<is_arithmetic::value, Scalar>::type CoeffReturnType;
+};
+template <typename Derived>
+class DenseBase : public DenseCoeffsBase<Derived> {
+ public:
+ enum {
+ RowsAtCompileTime = traits<Derived>::RowsAtCompileTime,
+ SizeAtCompileTime = size_at_compile_time<RowsAtCompileTime>::ret,
+ MaxSizeAtCompileTime
+ };
+};
+template <typename Derived>
+class MatrixBase : public DenseBase<Derived> {
+ public:
+ using DenseBase<Derived>::derived;
+ template <typename T>
+ CwiseBinaryOp<scalar_product_op, const Derived,
+ const typename plain_constant_type<Derived, T>::type>
+ operator*(T& scalar) {
+ return CwiseBinaryOp<scalar_product_op, const Derived,
+ const typename plain_constant_type<Derived>::type>(
+ derived(), typename plain_constant_type<Derived>::type(derived().rows(),
+ 0, scalar));
+ }
+};
+template <typename Derived>
+struct EigenBase {
+ const Derived& derived() const { return *static_cast<const Derived*>(this); }
+ Derived& const_cast_derived() const {
+ return *static_cast<Derived*>(const_cast<EigenBase*>(this));
+ }
+};
+template <typename>
+struct binary_evaluator;
+template <typename T>
+struct evaluator<const T> : evaluator<T> {
+ evaluator(const T& xpr) : evaluator<T>(xpr) {}
+};
+template <typename Derived>
+struct evaluator {
+ typedef Derived PlainObjectType;
+ typedef typename PlainObjectType::Scalar Scalar;
+ evaluator(const PlainObjectType& m) : m_data(m.data()) {}
+ typename PlainObjectType::CoeffReturnType coeff(long row, long) {
+ return m_data[row];
+ }
+ Scalar& coeffRef(long row, long) { return const_cast<Scalar*>(m_data)[row]; }
+ const Scalar* m_data;
+};
+template <typename Scalar, int Rows, int Cols, int Options, int MaxRows,
+ int MaxCols>
+struct evaluator<Matrix<Scalar, Rows, Cols, Options, MaxRows, MaxCols>>
+ : evaluator<PlainObjectBase<Matrix<Scalar, Rows, Cols>>> {
+ typedef Matrix<Scalar, Rows, Cols> XprType;
+ evaluator(const XprType& m) : evaluator<PlainObjectBase<XprType>>(m) {}
+};
+struct nullary_wrapper {
+ template <typename IndexType>
+ float operator()(scalar_constant_op<float> op, IndexType, IndexType) const {
+ return op();
+ }
+};
+template <typename NullaryOp, typename PlainObjectType>
+struct evaluator<CwiseNullaryOp<NullaryOp, PlainObjectType>> {
+ typedef CwiseNullaryOp<NullaryOp, PlainObjectType> XprType;
+ evaluator(XprType n) : m_functor(n.functor()) {}
+ template <typename IndexType>
+ typename XprType::CoeffReturnType coeff(IndexType row, IndexType col) {
+ return m_wrapper(m_functor, row, col);
+ }
+ NullaryOp m_functor;
+ nullary_wrapper m_wrapper;
+};
+template <typename BinaryOp, typename Lhs, typename Rhs>
+struct evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>>
+ : binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>> {
+ evaluator(CwiseBinaryOp<BinaryOp, Lhs, Rhs> xpr)
+ : binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>>(xpr) {}
+};
+template <typename BinaryOp, typename Lhs, typename Rhs>
+struct binary_evaluator<CwiseBinaryOp<BinaryOp, Lhs, Rhs>> {
+ typedef CwiseBinaryOp<BinaryOp, Lhs, Rhs> XprType;
+ binary_evaluator(XprType xpr) : m_lhsImpl(xpr.lhs()), m_rhsImpl(xpr.rhs()) {}
+ typename XprType::CoeffReturnType coeff(long row, long col) {
+ return m_functor(m_lhsImpl.coeff(row, col), m_rhsImpl.coeff(row, col));
+ }
+ BinaryOp m_functor;
+ evaluator<Lhs> m_lhsImpl;
+ evaluator<Rhs> m_rhsImpl;
+};
+template <typename Kernel, int Index, int Stop>
+struct copy_using_evaluator_DefaultTraversal_CompleteUnrolling {
+ enum { outer, inner = Index };
+ static void run(Kernel kernel) {
+ kernel.assignCoeffByOuterInner(outer, inner);
+ copy_using_evaluator_DefaultTraversal_CompleteUnrolling<Kernel, Index + 1,
+ Stop>::run(kernel);
+ }
+};
+template <typename Kernel, int Stop>
+struct copy_using_evaluator_DefaultTraversal_CompleteUnrolling<Kernel, Stop,
+ Stop> {
+ static void run(Kernel) {}
+};
+template <typename Kernel>
+struct dense_assignment_loop {
+ static void run(Kernel kernel) {
+ typedef typename Kernel::DstEvaluatorType::XprType DstXprType;
+ enum { size = DstXprType::SizeAtCompileTime, alignedSize = 0 };
+ copy_using_evaluator_DefaultTraversal_CompleteUnrolling<Kernel, alignedSize,
+ size>::run(kernel);
+ }
+};
+template <typename DstEvaluatorTypeT, typename SrcEvaluatorTypeT,
+ typename Functor>
+class generic_dense_assignment_kernel {
+ typedef typename DstEvaluatorTypeT::XprType DstXprType;
+
+ public:
+ typedef DstEvaluatorTypeT DstEvaluatorType;
+ typedef SrcEvaluatorTypeT SrcEvaluatorType;
+ generic_dense_assignment_kernel(DstEvaluatorType dst, SrcEvaluatorType src,
+ Functor, DstXprType& dstExpr)
+ : m_dst(dst), m_src(src), m_dstExpr(dstExpr) {}
+ long assignCoeff_col;
+ void assignCoeffByOuterInner(long, long inner) {
+ long __trans_tmp_1 = inner;
+ m_functor.assignCoeff(m_dst.coeffRef(__trans_tmp_1, assignCoeff_col),
+ m_src.coeff(__trans_tmp_1, assignCoeff_col));
+ }
+ DstEvaluatorType m_dst;
+ SrcEvaluatorType m_src;
+ Functor m_functor;
+ DstXprType& m_dstExpr;
+};
+template <typename DstXprType, typename SrcXprType, typename Functor>
+void call_dense_assignment_loop(DstXprType& dst, SrcXprType src, Functor func) {
+ typedef evaluator<DstXprType> DstEvaluatorType;
+ typedef evaluator<SrcXprType> SrcEvaluatorType;
+ SrcEvaluatorType srcEvaluator(src);
+ DstEvaluatorType dstEvaluator(dst);
+ typedef generic_dense_assignment_kernel<DstEvaluatorType, SrcEvaluatorType,
+ Functor>
+ Kernel;
+ Kernel kernel(dstEvaluator, srcEvaluator, func, dst.const_cast_derived());
+ dense_assignment_loop<Kernel>::run(kernel);
+}
+template <typename Dst, typename Src, typename Func>
+void call_assignment_no_alias(Dst& dst, Src src, Func func) {
+ enum { NeedToTranspose };
+ typename conditional<NeedToTranspose, Dst&>::type actualDst(dst);
+ CwiseBinaryOp<scalar_product_op, const Matrix<float, 3, 1>,
+ const CwiseNullaryOp<scalar_constant_op<float>,
+ const Matrix<float, 3, 1, 0, 2, 3>>>
+ __trans_tmp_4 = src;
+ call_dense_assignment_loop(actualDst, __trans_tmp_4, func);
+}
+template <int Size>
+struct plain_array {
+ float array[Size];
+};
+template <int Size, int _Rows>
+class DenseStorage {
+ plain_array<Size> m_data;
+
+ public:
+ DenseStorage() {}
+ DenseStorage(const DenseStorage&);
+ static long rows() { return _Rows; }
+ const float* data() const { return m_data.array; }
+ float* data() { return m_data.array; }
+};
+template <typename Derived>
+class PlainObjectBase : public dense_xpr_base<Derived>::type {
+ public:
+ typedef typename dense_xpr_base<Derived>::type Base;
+ typedef typename traits<Derived>::Scalar Scalar;
+ DenseStorage<Base::MaxSizeAtCompileTime, Base::RowsAtCompileTime> m_storage;
+ long rows() const { return m_storage.rows(); }
+ const Scalar* data() const { return m_storage.data(); }
+ PlainObjectBase() {}
+ template <typename OtherDerived>
+ PlainObjectBase(const DenseBase<OtherDerived>& other) {
+ _set_noalias(other);
+ }
+ template <typename OtherDerived>
+ void _set_noalias(const DenseBase<OtherDerived>& other) {
+ call_assignment_no_alias(this->derived(), other.derived(), assign_op());
+ }
+};
+template <typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows,
+ int _MaxCols>
+struct traits<Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>> {
+ typedef _Scalar Scalar;
+ typedef int XprKind;
+ enum {
+ RowsAtCompileTime = _Rows,
+ ColsAtCompileTime,
+ MaxRowsAtCompileTime,
+ MaxColsAtCompileTime,
+ };
+};
+template <typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows,
+ int _MaxCols>
+class Matrix
+ : public PlainObjectBase<
+ Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>> {
+ public:
+ typedef PlainObjectBase<Matrix> Base;
+ typedef typename traits<Matrix>::Scalar Scalar;
+ Matrix(Scalar& x, Scalar& y, Scalar& z) {
+ m_storage.data()[0] = x;
+ m_storage.data()[1] = y;
+ m_storage.data()[2] = z;
+ }
+ template <typename OtherDerived>
+ Matrix(const EigenBase<OtherDerived>& other) : Base(other.derived()) {}
+ using Base::m_storage;
+};
+template <typename BinaryOp, typename Lhs, typename Rhs>
+struct traits<CwiseBinaryOp<BinaryOp, Lhs, Rhs>> {
+ typedef typename traits<Lhs>::XprKind XprKind;
+ enum { RowsAtCompileTime };
+ typedef float Scalar;
+};
+template <typename>
+class CwiseBinaryOpImpl;
+template <typename, typename, typename RhsType>
+class CwiseBinaryOp : public CwiseBinaryOpImpl<RhsType> {
+ public:
+ typedef ref_selector::type LhsNested;
+ typedef RhsType RhsNested;
+ CwiseBinaryOp(const Matrix<float, 3, 1>& aLhs, RhsType& aRhs)
+ : m_lhs(aLhs), m_rhs(aRhs) {}
+ remove_reference<LhsNested>::type& lhs() { return m_lhs; }
+ typename remove_reference<RhsNested>::type& rhs() { return m_rhs; }
+ LhsNested m_lhs;
+ RhsNested m_rhs;
+};
+template <typename>
+class CwiseBinaryOpImpl
+ : public generic_xpr_base<CwiseBinaryOp<
+ scalar_product_op, const Matrix<float, 3, 1>,
+ const CwiseNullaryOp<scalar_constant_op<float>,
+ const Matrix<float, 3, 1, 0, 2, 3>>>>::type {};
+template <typename NullaryOp, typename PlainObjectType>
+struct traits<CwiseNullaryOp<NullaryOp, PlainObjectType>>
+ : traits<PlainObjectType> {};
+template <typename, typename PlainObjectType>
+class CwiseNullaryOp
+ : public dense_xpr_base<CwiseNullaryOp<int, PlainObjectType>>::type {
+ public:
+ CwiseNullaryOp(long rows, long, scalar_constant_op<float> func)
+ : m_functor(func) {
+ rows ? void() : __assert_fail("", "", 1, __PRETTY_FUNCTION__);
+ }
+ scalar_constant_op<float> functor() { return m_functor; }
+ scalar_constant_op<float> m_functor;
+};
+} // namespace Eigen
+Eigen::Matrix<float, 3, 1> should_inline(float x, float y, float z,
+ float scale) {
+ return Eigen::Matrix<float, 3, 1>(x, y, z) * scale;
+}
+
+// We should inline everything to should_inline
+
+/* { dg-final { scan-tree-dump-times "Function" "optimized" } } */
projects / platform / upstream / gcc.git / commitdiff