This patch corrects commit 165126 by using an integer bit width instead of

a pointer to a type, in order to remove the uses of getGlobalContext().

Patch by Tyler Nowicki.



git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165255 91177308-0d34-0410-b5e6-96231b3b80d8

include/llvm/Target/TargetLowering.h

@@ -157,12 +157,12 @@ public:
 
   /// isSlowDivBypassed - Returns true if target has indicated at least one
   /// type should be bypassed.
-  bool isSlowDivBypassed() const { return !BypassSlowDivTypes.empty(); }
+  bool isSlowDivBypassed() const { return !BypassSlowDivWidths.empty(); }
 
   /// getBypassSlowDivTypes - Returns map of slow types for division or
   /// remainder with corresponding fast types
-  const DenseMap<Type *, Type *> &getBypassSlowDivTypes() const {
-    return BypassSlowDivTypes;
+  const DenseMap<unsigned int, unsigned int> &getBypassSlowDivWidths() const {
+    return BypassSlowDivWidths;
   }
 
   /// isPow2DivCheap() - Return true if pow2 div is cheaper than a chain of
@@ -1083,9 +1083,9 @@ protected:
   /// of instructions not containing an integer divide.
   void setIntDivIsCheap(bool isCheap = true) { IntDivIsCheap = isCheap; }
 
-  /// addBypassSlowDivType - Tells the code generator which types to bypass.
-  void addBypassSlowDivType(Type *slow_type, Type *fast_type) {
-    BypassSlowDivTypes[slow_type] = fast_type;
+  /// addBypassSlowDiv - Tells the code generator which bitwidths to bypass.
+  void addBypassSlowDiv(unsigned int SlowBitWidth, unsigned int FastBitWidth) {
+    BypassSlowDivWidths[SlowBitWidth] = FastBitWidth;
   }
 
   /// setPow2DivIsCheap - Tells the code generator that it shouldn't generate
@@ -1810,11 +1810,11 @@ private:
   /// set to true unconditionally.
   bool IntDivIsCheap;
 
-  /// BypassSlowDivTypes - Tells the code generator to bypass slow divide or
-  /// remainder instructions. For example, SlowDivBypass[i32,u8] tells the code
-  /// generator to bypass 32-bit signed integer div/rem with an 8-bit unsigned
+  /// BypassSlowDivMap - Tells the code generator to bypass slow divide or
+  /// remainder instructions. For example, BypassSlowDivWidths[32,8] tells the
+  /// code generator to bypass 32-bit integer div/rem with an 8-bit unsigned
   /// integer div/rem when the operands are positive and less than 256.
-  DenseMap <Type *, Type *> BypassSlowDivTypes;
+  DenseMap <unsigned int, unsigned int> BypassSlowDivWidths;
 
   /// Pow2DivIsCheap - Tells the code generator that it shouldn't generate
   /// srl/add/sra for a signed divide by power of two, and let the target handle

include/llvm/Transforms/Utils/BypassSlowDivision.h

@@ -26,7 +26,7 @@ namespace llvm {
 /// profitably bypassed and carried out with a shorter, faster divide.
 bool bypassSlowDivision(Function &F,
                         Function::iterator &I,
-                        const DenseMap<Type*, Type*> &BypassTypeMap);
+                        const DenseMap<unsigned int, unsigned int> &BypassWidth);
 
 } // End llvm namespace
 

lib/Target/X86/X86ISelLowering.cpp

@@ -184,7 +184,7 @@ X86TargetLowering::X86TargetLowering(X86TargetMachine &TM)
 
   // Bypass i32 with i8 on Atom when compiling with O2
   if (Subtarget->hasSlowDivide() && TM.getOptLevel() >= CodeGenOpt::Default)
-    addBypassSlowDivType(Type::getInt32Ty(getGlobalContext()), Type::getInt8Ty(getGlobalContext()));
+    addBypassSlowDiv(32, 8);
 
   if (Subtarget->isTargetWindows() && !Subtarget->isTargetCygMing()) {
     // Setup Windows compiler runtime calls.

lib/Transforms/Scalar/CodeGenPrepare.cpp

@@ -154,9 +154,10 @@ bool CodeGenPrepare::runOnFunction(Function &F) {
   /// This optimization identifies DIV instructions that can be
   /// profitably bypassed and carried out with a shorter, faster divide.
   if (TLI && TLI->isSlowDivBypassed()) {
-    const DenseMap<Type*, Type*> &BypassTypeMap = TLI->getBypassSlowDivTypes();
+    const DenseMap<unsigned int, unsigned int> &BypassWidths =
+       TLI->getBypassSlowDivWidths();
     for (Function::iterator I = F.begin(); I != F.end(); I++)
-      EverMadeChange |= bypassSlowDivision(F, I, BypassTypeMap);
+      EverMadeChange |= bypassSlowDivision(F, I, BypassWidths);
   }
 
   // Eliminate blocks that contain only PHI nodes and an

lib/Transforms/Utils/BypassSlowDivision.cpp

@@ -221,7 +221,7 @@ static bool reuseOrInsertFastDiv(Function &F,
 // be profitably bypassed and carried out with a shorter, faster divide.
 bool llvm::bypassSlowDivision(Function &F,
                               Function::iterator &I,
-                              const DenseMap<Type*, Type*> &BypassTypeMap) {
+                              const DenseMap<unsigned int, unsigned int> &BypassWidths) {
   DivCacheTy DivCache;
 
   bool MadeChange = false;
@@ -242,18 +242,17 @@ bool llvm::bypassSlowDivision(Function &F,
     if (!J->getType()->isIntegerTy())
       continue;
 
-    // Get same type in global context
+    // Get bitwidth of div/rem instruction
     IntegerType *T = cast<IntegerType>(J->getType());
-    IntegerType *GT = IntegerType::get(getGlobalContext(), T->getBitWidth());
+    int bitwidth = T->getBitWidth();
 
-    // Continue if div/rem type is not bypassed
-    DenseMap<Type *, Type *>::const_iterator BI = BypassTypeMap.find(GT);
-    if (BI == BypassTypeMap.end())
+    // Continue if bitwidth is not bypassed
+    DenseMap<unsigned int, unsigned int>::const_iterator BI = BypassWidths.find(bitwidth);
+    if (BI == BypassWidths.end())
       continue;
 
-    // Get the bypass type in the original context
-    IntegerType *GBT = cast<IntegerType>(BI->second);
-    IntegerType *BT = IntegerType::get(J->getContext(), GBT->getBitWidth());
+    // Get type for div/rem instruction with bypass bitwidth
+    IntegerType *BT = IntegerType::get(J->getContext(), BI->second);
 
     MadeChange |= reuseOrInsertFastDiv(F, I, J, BT, UseDivOp,
                                        UseSignedOp, DivCache);