Minimize self-contained source using creduce

gcc_p_statistics.txt (text/plain), 12.04 KB, created by Stig Nielsen on 2020-07-30 08:07:08 UTC

### gcc -i ###

Benytter indbyggede specifikationer.
COLLECT_GCC=gcc
COLLECT_LTO_WRAPPER=/usr/libexec/gcc/x86_64-pc-linux-gnu/10.1.0/lto-wrapper
MÃ¥l: x86_64-pc-linux-gnu
Konfigureret med: /tmp/portage/sys-devel/gcc-10.1.0-r2/work/gcc-10.1.0/configure --host=x86_64-pc-linux-gnu --build=x86_64-pc-linux-gnu --prefix=/usr --bindir=/usr/x86_64-pc-linux-gnu/gcc-bin/10.1.0 --includedir=/usr/lib/gcc/x86_64-pc-linux-gnu/10.1.0/include --datadir=/usr/share/gcc-data/x86_64-pc-linux-gnu/10.1.0 --mandir=/usr/share/gcc-data/x86_64-pc-linux-gnu/10.1.0/man --infodir=/usr/share/gcc-data/x86_64-pc-linux-gnu/10.1.0/info --with-gxx-include-dir=/usr/lib/gcc/x86_64-pc-linux-gnu/10.1.0/include/g++-v10 --with-python-dir=/share/gcc-data/x86_64-pc-linux-gnu/10.1.0/python --enable-languages=c,c++,fortran --enable-obsolete --enable-secureplt --disable-werror --with-system-zlib --enable-nls --without-included-gettext --enable-checking=release --with-bugurl=https://bugs.gentoo.org/ --with-pkgversion='Gentoo 10.1.0-r2 p3' --disable-esp --enable-libstdcxx-time --enable-shared --enable-threads=posix --enable-__cxa_atexit --enable-clocale=gnu --enable-multilib --with-multilib-list=m32,m64 --disable-fixed-point --enable-targets=all --enable-libgomp --disable-libmudflap --disable-libssp --disable-libada --disable-systemtap --enable-vtable-verify --without-zstd --enable-lto --without-isl --enable-default-pie --enable-default-ssp
Trådmodel: posix
Supported LTO compression algorithms: zlib
gcc-version 10.1.0 (Gentoo 10.1.0-r2 p3) 


### statistics plus instantiate_cpp_grammar.ii###
pass statistics:
  method pass_balanced :: angles-only worked 1 times and failed 1279 times
  method pass_clang :: replace-dependent-typedef worked 1 times and failed 5 times
  method pass_clang :: remove-ctor-initializer worked 1 times and failed 0 times
  method pass_clang :: param-to-global worked 1 times and failed 87 times
  method pass_clex :: rm-toks-13 worked 1 times and failed 7746 times
  method pass_clang :: param-to-local worked 1 times and failed 86 times
  method pass_blank :: 0 worked 1 times and failed 1 times
  method pass_clex :: rm-toks-12 worked 1 times and failed 7759 times
  method pass_balanced :: parens-only worked 1 times and failed 163 times
  method pass_clang :: callexpr-to-value worked 1 times and failed 66 times
  method pass_line_markers :: 0 worked 1 times and failed 0 times
  method pass_clang :: replace-undefined-function worked 2 times and failed 0 times
  method pass_clex :: rm-toks-9 worked 2 times and failed 7793 times
  method pass_clex :: rm-toks-11 worked 2 times and failed 7771 times
  method pass_balanced :: square worked 2 times and failed 3 times
  method pass_clang :: simplify-callexpr worked 2 times and failed 64 times
  method pass_clex :: rm-toks-15 worked 2 times and failed 7674 times
  method pass_clang :: copy-propagation worked 2 times and failed 2 times
  method pass_ints :: a worked 2 times and failed 83 times
  method pass_clang :: simplify-nested-class worked 2 times and failed 5 times
  method pass_indent :: regular worked 3 times and failed 2 times
  method pass_clex :: rm-toks-14 worked 3 times and failed 7704 times
  method pass_clex :: rm-toks-16 worked 3 times and failed 7626 times
  method pass_clang :: union-to-struct worked 3 times and failed 0 times
  method pass_clang :: remove-unused-field worked 3 times and failed 9 times
  method pass_clang :: remove-nested-function worked 4 times and failed 16 times
  method pass_clex :: rm-toks-6 worked 5 times and failed 7980 times
  method pass_clang :: simplify-recursive-template-instantiation worked 5 times and failed 42 times
  method pass_clex :: rm-toks-8 worked 8 times and failed 7811 times
  method pass_balanced :: curly-only worked 8 times and failed 750 times
  method pass_clang :: remove-unused-function worked 8 times and failed 22 times
  method pass_balanced :: angles worked 8 times and failed 1395 times
  method pass_clang :: return-void worked 9 times and failed 48 times
  method pass_clang :: replace-dependent-name worked 10 times and failed 7 times
  method pass_clang :: replace-derived-class worked 11 times and failed 10 times
  method pass_clang :: remove-base-class worked 11 times and failed 11 times
  method pass_clang :: simplify-dependent-typedef worked 12 times and failed 51 times
  method pass_clang :: template-non-type-arg-to-int worked 12 times and failed 1 times
  method pass_clex :: rm-toks-5 worked 12 times and failed 8010 times
  method pass_balanced :: parens worked 15 times and failed 359 times
  method pass_clex :: rm-toks-7 worked 15 times and failed 7875 times
  method pass_clex :: rm-toks-4 worked 17 times and failed 8070 times
  method pass_peep :: a worked 17 times and failed 18553 times
  method pass_clang :: instantiate-template-param worked 20 times and failed 148 times
  method pass_balanced :: angles-inside worked 20 times and failed 1235 times
  method pass_clang :: replace-one-level-typedef-type worked 25 times and failed 32 times
  method pass_clang :: remove-namespace worked 28 times and failed 45 times
  method pass_clang :: replace-class-with-base-template-spec worked 29 times and failed 43 times
  method pass_balanced :: curly2 worked 30 times and failed 1406 times
  method pass_clang :: remove-unused-outer-class worked 30 times and failed 9 times
  method pass_balanced :: parens-inside worked 30 times and failed 245 times
  method pass_clang :: replace-simple-typedef worked 31 times and failed 36 times
  method pass_clang :: remove-unresolved-base worked 33 times and failed 19 times
  method pass_clang :: empty-struct-to-int worked 38 times and failed 15 times
  method pass_clang :: template-arg-to-int worked 39 times and failed 216 times
  method pass_clang :: remove-trivial-base-template worked 46 times and failed 32 times
  method pass_clang :: remove-enum-member-value worked 66 times and failed 86 times
  method pass_clex :: rm-toks-3 worked 68 times and failed 8139 times
  method pass_clang :: instantiate-template-type-param-to-int worked 72 times and failed 242 times
  method pass_clex :: rename-toks worked 82 times and failed 259 times
  method pass_clex :: rm-toks-2 worked 85 times and failed 8343 times
  method pass_clex :: rm-tok-pattern-4 worked 106 times and failed 59120 times
  method pass_clang :: class-template-to-class worked 108 times and failed 99 times
  method pass_balanced :: curly worked 110 times and failed 1438 times
  method pass_clang :: reduce-class-template-param worked 122 times and failed 204 times
  method pass_clang_binsrch :: replace-function-def-with-decl worked 125 times and failed 429 times
  method pass_lines :: 1 worked 176 times and failed 2295 times
  method pass_balanced :: curly-inside worked 178 times and failed 547 times
  method pass_clang :: remove-unused-enum-member worked 202 times and failed 175 times
  method pass_lines :: 10 worked 206 times and failed 5973 times
  method pass_clex :: rm-toks-1 worked 244 times and failed 8513 times
  method pass_balanced :: parens-to-zero worked 254 times and failed 554 times
  method pass_lines :: 0 worked 267 times and failed 3327 times
  method pass_clang_binsrch :: remove-unused-function worked 340 times and failed 1452 times
  method pass_lines :: 6 worked 624 times and failed 8947 times
  method pass_lines :: 8 worked 1046 times and failed 8611 times
  method pass_lines :: 4 worked 1487 times and failed 15218 times
  method pass_lines :: 3 worked 1788 times and failed 19491 times
  method pass_lines :: 2 worked 1986 times and failed 18209 times

          ******** /home/sman/Kode/Boost_grammar/instantiate_cpp_grammar.ii ********

template < int a > struct integral_constant {
   static const int value = a;
   };
   template < class, class > struct c : integral_constant< false > {
  };
   template < class T > struct c< T, T > : integral_constant< true > {
  };
  class f {
  };
    namespace cpplexer {
   class v {
   public:   typedef int position_type;
   };
   class lex_iterator {
   public:   typedef cpplexer::v token_type;
   };
   }
  template < typename aa > class h {
   public:   h(aa, aa);
   };
   struct cpp_grammar;
   template < typename , typename > struct parser_result {
     typedef cpp_grammar d;
   };
   template < typename e > struct parser {
     typedef e ac;
     e derived();
   };
   template < int > struct s {
   static const int value = 0;
   };
   template <> struct s< true > {
   static const int value = 5;
   };
   template < class, class, int > class i;
   template < class T1, class b > class i< T1, b, 0 > {
     T1 ab;
     b j;
   };
   template < class T1, class b > class i< T1, b, 5 > {
  };
   template < class T1, class b > class m : i< T1, b, s< c< T1, b >::value >::value > {
  };
   template < typename t, typename o, typename ae > class binary : ae {
     m< typename t::ac, typename o::ac > subj;
   };
   class rule;
   template <  typename > class k : public parser< rule > {
     int ac;
   };
   class rule : public k<  int > {
  };
   template < class T > struct l {
   typedef T *d;
   };
   template < class T > class ai {
   public:   typename l< T >::d operator->();
   };
   template < class T > class weak_ptr {
   public:   ai< T > lock();
   };
   template < typename, typename > struct grammar;
   template < typename GrammarT, typename > struct grammar_definition {
     typedef typename GrammarT::definition< int > d;
   };
   template < typename GrammarT, typename e, typename  > struct aq {
     typedef typename grammar_definition< e, int >::d ar;
     typedef aq helper_t;
     typedef weak_ptr< helper_t > r;
     void define(GrammarT *as) {
     movelib:     ar(as->derived());
     }
   };
   template < typename e, typename ContextT, typename ScannerT > void  at() {
     typename aq<grammar<e, ContextT>, e, ScannerT>::r av;
     av.lock()->define(0);
   }
   template < int, typename e, typename ContextT, typename ScannerT > void grammar_parser_parse(grammar< e, ContextT > const *, ScannerT) {
     at< e, ContextT, ScannerT >();
   }
   template < typename e, typename = int > struct grammar : parser< e > {
     typedef e au;
     template < typename ScannerT >   typename parser_result< au, ScannerT >::d ay(ScannerT az) const {
       grammar_parser_parse< 0 >(this, az);
     }
     template < typename ScannerT >   typename parser_result< au, ScannerT >::d parse(ScannerT az) {
       typename parser_result< au, ScannerT >::d hit = ay(az);
     }
   };
   template < typename > struct sequence {
  };
   template < typename t, typename o > void  operator>>(t, o);
   template < typename t, typename o > struct alternative : binary< t, o, parser< alternative< t, o > > > {
  };
   template < typename t, typename o > alternative< t, o > operator|( t ,  o );
   template < typename LexIteratorT, typename bf > struct bg {
     typedef LexIteratorT bh;
     typedef typename LexIteratorT::token_type token_type;
     typedef f bi;
     typedef typename token_type::position_type position_type;
     int parse_cpp_grammar(bh const &, bh const &, position_type const &, bool &,                         token_type &, bi &);
   };
   struct bj : parser< int > {
  }
   w;
   struct cpp_grammar : grammar< cpp_grammar > {
     template < typename > struct definition {
       typedef rule n       ;
       n illformed;
       definition(cpp_grammar) {
        alternative< alternative< rule, rule >, rule > __trans_tmp_1;
      boost:       alternative<           alternative< alternative< alternative< rule, rule >,                                            rule >,                        rule >,           rule >           __trans_tmp_4 ;
        (__trans_tmp_4 | illformed) >> w;
      }
     };
     cpp_grammar(bool, cpplexer::v, f);
   };
   template < typename, typename aa, typename q > void u(aa, aa last, parser< q > p) {
     aa first;
     h< aa > az(first, last);
     p.derived().parse(az);
   }
   template < typename LexIteratorT, typename bf > int bg< LexIteratorT, bf >::parse_cpp_grammar(     LexIteratorT const &first, LexIteratorT const &last, position_type const &,     bool &found_eof, token_type &found_directive, bi &found_eoltokens) {
     cpp_grammar g(found_eof, found_directive, found_eoltokens);
     u< int >(first, last, g);
   }
      template struct bg< cpplexer::lex_iterator, f >