Merge remote-tracking branch 'ethsnarks/no-exceptional-control-flow' into exceptions-fix

* ethsnarks/no-exceptional-control-flow:
  Removed unnecessary comments
  Don't use empty inline-assembly, removes need to patch libfqfft for emscripten build
  Fixed tests to get evaluation domain
  Do not use try/catch for control flow in get_evaluation_domain

Author: dtebbs

libfqfft/evaluation_domain/domains/arithmetic_sequence_domain.hpp

@@ -28,6 +28,8 @@ namespace libfqfft {
     FieldT arithmetic_generator;
     void do_precomputation();
 
+    static bool valid_for_size(const size_t m);
+
     arithmetic_sequence_domain(const size_t m);
 
     void FFT(std::vector<FieldT> &a);

libfqfft/evaluation_domain/domains/arithmetic_sequence_domain.tcc

@@ -23,6 +23,18 @@
 
 namespace libfqfft {
 
+template<typename FieldT>
+bool arithmetic_sequence_domain<FieldT>::valid_for_size(const size_t m)
+{
+  if (m <=1)
+      return false;
+
+  if (FieldT::arithmetic_generator() == FieldT::zero())
+      return false;
+
+  return true;
+}
+
 template<typename FieldT>
 arithmetic_sequence_domain<FieldT>::arithmetic_sequence_domain(const size_t m) : evaluation_domain<FieldT>(m)
 {

libfqfft/evaluation_domain/domains/basic_radix2_domain.hpp

@@ -26,6 +26,8 @@ class basic_radix2_domain : public evaluation_domain<FieldT> {
 
     FieldT omega;
 
+    static bool valid_for_size(const size_t m);
+
     basic_radix2_domain(const size_t m);
 
     void FFT(std::vector<FieldT> &a);

libfqfft/evaluation_domain/domains/basic_radix2_domain.tcc

@@ -22,6 +22,27 @@
 
 namespace libfqfft {
 
+template<typename FieldT>
+bool basic_radix2_domain<FieldT>::valid_for_size(const size_t m)
+{
+    if ( m <= 1 )
+        return false;
+
+    // Will `get_root_of_unity` throw?
+    if (!std::is_same<FieldT, libff::Double>::value)
+    {
+        const size_t logm = libff::log2(m);
+
+        if (logm > FieldT::s)
+            return false;
+    }
+
+    if( get_root_of_unity_will_throw<FieldT>(m) )
+        return false;
+
+    return true;
+}
+
 template<typename FieldT>
 basic_radix2_domain<FieldT>::basic_radix2_domain(const size_t m) : evaluation_domain<FieldT>(m)
 {

libfqfft/evaluation_domain/domains/basic_radix2_domain_aux.tcc

@@ -61,7 +61,7 @@ void _basic_serial_radix2_FFT(std::vector<GroupT> &a, const FieldT &omega)
         // w_m is 2^s-th root of unity now
         const FieldT w_m = omega^(n/(2*m));
 
-        asm volatile  ("/* pre-inner */");
+        //asm volatile  ("/* pre-inner */");
         for (size_t k = 0; k < n; k += 2*m)
         {
             FieldT w = FieldT::one();
@@ -73,7 +73,7 @@ void _basic_serial_radix2_FFT(std::vector<GroupT> &a, const FieldT &omega)
                 w *= w_m;
             }
         }
-        asm volatile ("/* post-inner */");
+        //asm volatile ("/* post-inner */");
         m *= 2;
     }
 }

libfqfft/evaluation_domain/domains/extended_radix2_domain.hpp

@@ -27,6 +27,8 @@ class extended_radix2_domain : public evaluation_domain<FieldT> {
     FieldT omega;
     FieldT shift;
 
+    static bool valid_for_size(const size_t m);
+
     extended_radix2_domain(const size_t m);
 
     void FFT(std::vector<FieldT> &a);

libfqfft/evaluation_domain/domains/extended_radix2_domain.tcc

@@ -17,6 +17,29 @@
 
 namespace libfqfft {
 
+template<typename FieldT>
+bool extended_radix2_domain<FieldT>::valid_for_size(const size_t m)
+{
+    if ( m <= 1 )
+        return false;
+
+    // Will `get_root_of_unity` throw?
+    if (!std::is_same<FieldT, libff::Double>::value)
+    {
+        const size_t logm = libff::log2(m);
+
+        if (logm != (FieldT::s + 1))
+            return false;
+    }
+
+    size_t small_m = m / 2;
+
+    if( get_root_of_unity_will_throw<FieldT>(small_m) )
+        return false;
+
+    return true;
+}
+
 template<typename FieldT>
 extended_radix2_domain<FieldT>::extended_radix2_domain(const size_t m) : evaluation_domain<FieldT>(m)
 {

libfqfft/evaluation_domain/domains/geometric_sequence_domain.hpp

@@ -27,6 +27,8 @@ namespace libfqfft {
     std::vector<FieldT> geometric_triangular_sequence;
     void do_precomputation();
 
+    static bool valid_for_size(const size_t m);
+
     geometric_sequence_domain(const size_t m);
 
     void FFT(std::vector<FieldT> &a);

libfqfft/evaluation_domain/domains/geometric_sequence_domain.tcc

@@ -23,6 +23,18 @@
 
 namespace libfqfft {
 
+template<typename FieldT>
+bool geometric_sequence_domain<FieldT>::valid_for_size(const size_t m)
+{
+    if ( m <= 1 )
+        return false;
+
+    if (FieldT::geometric_generator() == FieldT::zero())
+        return false;
+
+    return true;
+}
+
 template<typename FieldT>
 geometric_sequence_domain<FieldT>::geometric_sequence_domain(const size_t m) : evaluation_domain<FieldT>(m)
 {

libfqfft/evaluation_domain/domains/step_radix2_domain.hpp

@@ -29,6 +29,8 @@ class step_radix2_domain : public evaluation_domain<FieldT> {
     FieldT big_omega;
     FieldT small_omega;
 
+    static bool valid_for_size(const size_t m);
+
     step_radix2_domain(const size_t m);
 
     void FFT(std::vector<FieldT> &a);