Fixed compilation with older clang versions.

src/base/division-by-constant.cc

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/base/division-by-constant.h"
 
 #include <stdint.h>
 
 #include "src/base/logging.h"
 #include "src/base/macros.h"
@@ skipping 34 matching lines @@
     }
     q2 = 2 * q2;     // Update q2 = 2**p/|d|.
     r2 = 2 * r2;     // Update r2 = rem(2**p, |d|).
     if (r2 >= ad) {  // Must be an unsigned comparison here.
       q2 = q2 + 1;
       r2 = r2 - ad;
     }
     delta = ad - r2;
   } while (q1 < delta || (q1 == delta && r1 == 0));
   T mul = q2 + 1;
-  return {neg ? (0 - mul) : mul, p - bits, false};
+  return MagicNumbersForDivision<T>(neg ? (0 - mul) : mul, p - bits, false);
 }
 
 
 template <class T>
 MagicNumbersForDivision<T> UnsignedDivisionByConstant(T d,
                                                       unsigned leading_zeros) {
   STATIC_ASSERT(static_cast<T>(0) < static_cast<T>(-1));
   DCHECK(d != 0);
   const unsigned bits = static_cast<unsigned>(sizeof(T)) * 8;
   const T ones = ~static_cast<T>(0) >> leading_zeros;
@@ skipping 20 matching lines @@
       if (q2 >= max) a = true;
       q2 = 2 * q2 + 1;
       r2 = 2 * r2 + 1 - d;
     } else {
       if (q2 >= min) a = true;
       q2 = 2 * q2;
       r2 = 2 * r2 + 1;
     }
     delta = d - 1 - r2;
   } while (p < bits * 2 && (q1 < delta || (q1 == delta && r1 == 0)));
-  return {q2 + 1, p - bits, a};
+  return MagicNumbersForDivision<T>(q2 + 1, p - bits, a);
 }
 
 
 // -----------------------------------------------------------------------------
 // Instantiations.
 
 template struct MagicNumbersForDivision<uint32_t>;
 template struct MagicNumbersForDivision<uint64_t>;
 
 template MagicNumbersForDivision<uint32_t> SignedDivisionByConstant(uint32_t d);
 template MagicNumbersForDivision<uint64_t> SignedDivisionByConstant(uint64_t d);
 
 template MagicNumbersForDivision<uint32_t> UnsignedDivisionByConstant(
     uint32_t d, unsigned leading_zeros);
 template MagicNumbersForDivision<uint64_t> UnsignedDivisionByConstant(
     uint64_t d, unsigned leading_zeros);
 
 }  // namespace base
 }  // namespace v8