Allow LLE/LD and the loop versioning infrastructure to use SCEV predicates

[oota-llvm.git] / include / llvm / Transforms / Utils / IntegerDivision.h

diff --git a/include/llvm/Transforms/Utils/IntegerDivision.h b/include/llvm/Transforms/Utils/IntegerDivision.h
index ff4a31f8e0d2d9dc80f79979ae48dad573624204..0ec3321b9cf8bcfa112a8e160dc2bc72f35959cd 100644 (file)
--- a/include/llvm/Transforms/Utils/IntegerDivision.h
+++ b/include/llvm/Transforms/Utils/IntegerDivision.h
@@ -7,10 +7,10 @@
 //
 //===----------------------------------------------------------------------===//
 //
-// This file contains an implementation of 32bit integer division for targets
-// that don't have native support. It's largely derived from compiler-rt's
-// implementation of __udivsi3, but hand-tuned for targets that prefer less
-// control flow.
+// This file contains an implementation of 32bit and 64bit scalar integer
+// division for targets that don't have native support. It's largely derived
+// from compiler-rt's implementations of __udivsi3 and __udivmoddi4,
+// but hand-tuned for targets that prefer less control flow.
 //
 //===----------------------------------------------------------------------===//
 
@@ -26,9 +26,8 @@ namespace llvm {
   /// Generate code to calculate the remainder of two integers, replacing Rem
   /// with the generated code. This currently generates code using the udiv
   /// expansion, but future work includes generating more specialized code,
-  /// e.g. when more information about the operands are known. Currently only
-  /// implements 32bit scalar division (due to udiv's limitation), but future
-  /// work is removing this limitation.
+  /// e.g. when more information about the operands are known. Implements both
+  /// 32bit and 64bit scalar division.
   ///
   /// @brief Replace Rem with generated code.
   bool expandRemainder(BinaryOperator *Rem);
@@ -36,13 +35,39 @@ namespace llvm {
   /// Generate code to divide two integers, replacing Div with the generated
   /// code. This currently generates code similarly to compiler-rt's
   /// implementations, but future work includes generating more specialized code
-  /// when more information about the operands are known. Currently only
-  /// implements 32bit scalar division, but future work is removing this
-  /// limitation.
+  /// when more information about the operands are known. Implements both
+  /// 32bit and 64bit scalar division.
   ///
   /// @brief Replace Div with generated code.
   bool expandDivision(BinaryOperator* Div);
 
+  /// Generate code to calculate the remainder of two integers, replacing Rem
+  /// with the generated code. Uses ExpandReminder with a 32bit Rem which
+  /// makes it useful for targets with little or no support for less than
+  /// 32 bit arithmetic.
+  ///
+  /// @brief Replace Rem with generated code.
+  bool expandRemainderUpTo32Bits(BinaryOperator *Rem);
+
+  /// Generate code to calculate the remainder of two integers, replacing Rem
+  /// with the generated code. Uses ExpandReminder with a 64bit Rem.
+  ///
+  /// @brief Replace Rem with generated code.
+  bool expandRemainderUpTo64Bits(BinaryOperator *Rem);
+
+  /// Generate code to divide two integers, replacing Div with the generated
+  /// code. Uses ExpandDivision with a 32bit Div which makes it useful for
+  /// targets with little or no support for less than 32 bit arithmetic.
+  ///
+  /// @brief Replace Rem with generated code.
+  bool expandDivisionUpTo32Bits(BinaryOperator *Div);
+
+  /// Generate code to divide two integers, replacing Div with the generated
+  /// code. Uses ExpandDivision with a 64bit Div.
+  ///
+  /// @brief Replace Rem with generated code.
+  bool expandDivisionUpTo64Bits(BinaryOperator *Div);
+
 } // End llvm namespace
 
 #endif