[NVPTXFavorNonGeneric] canonicalize global variable initializers

[jingyue]

Summary

This patch hoists addrspacecast in a global variable initializer to the
outermost possible level, so that NVPTXAsmPrinter can print it more likely
correctly.

[jingyue]

ptxas does not accept generic(g+8)

[hfinkel]

outermost possible level, so that NVPTXAsmPrinter can print it more likely correctly.

You're just hiding a bug?

[jingyue]

Justin and I discussed this issue in http://reviews.llvm.org/D9063. The
conclusion is that, while Justin is working on a comprehensive fix which
can take a few days, I can workaround it by canonicalization as implemented
in this patch.

Anyway, this patch is incorrect because generic(<global var>+<const
offset>) is unacceptable by the NVIDIA driver. I already abandoned it.

Jingyue

lib/Target/NVPTX/NVPTXFavorNonGenericAddrSpaces.cpp

 
 namespace {
 /// \brief NVPTXFavorNonGenericAddrSpaces
 class NVPTXFavorNonGenericAddrSpaces : public FunctionPass {
 public:
   static char ID;
   NVPTXFavorNonGenericAddrSpaces() : FunctionPass(ID) {}
 
+  bool doInitialization(Module &M) override;
   bool runOnFunction(Function &F) override;
 
   /// Optimizes load/store instructions. Idx is the index of the pointer operand
   /// (0 for load, and 1 for store). Returns true if it changes anything.
   bool optimizeMemoryInstruction(Instruction *I, unsigned Idx);
   /// Transforms "gep (addrspacecast X), indices" into "addrspacecast (gep X,
-  /// indices)".  This reordering exposes to optimizeMemoryInstruction more
+  /// indices)". This reordering exposes to optimizeMemoryInstruction more
   /// optimization opportunities on loads and stores. Returns true if it changes
   /// the program.
   bool hoistAddrSpaceCastFromGEP(GEPOperator *GEP);
+  /// Run hoistAddrSpaceCastFromGEP on all the recursive elements of
+  /// \c Initializer.
+  bool canonicalizeInitializer(Constant *Initializer);
 };
 }
 
 char NVPTXFavorNonGenericAddrSpaces::ID = 0;
 
 namespace llvm {
 void initializeNVPTXFavorNonGenericAddrSpacesPass(PassRegistry &);
 }
GEP->replaceAllUsesWith(
         ConstantExpr::getAddrSpaceCast(NewGEPCE, GEP->getType()));
   }
 
   return true;
 }
 
 bool NVPTXFavorNonGenericAddrSpaces::optimizeMemoryInstruction(Instruction *MI,
                                                                unsigned Idx) {
+  bool Changed = false;
   // If the pointer operand is a GEP, hoist the addrspacecast if any from the
   // GEP to expose more optimization opportunites.
   if (GEPOperator *GEP = dyn_cast<GEPOperator>(MI->getOperand(Idx))) {
-    hoistAddrSpaceCastFromGEP(GEP);
+    Changed |= hoistAddrSpaceCastFromGEP(GEP);
   }
 
   // load/store (addrspacecast X) => load/store X if shortcutting the
   // addrspacecast is valid and can improve performance.
   //
   // e.g.,
   // %1 = addrspacecast float addrspace(3)* %0 to float*
   // %2 = load float* %1
   // ->
   // %2 = load float addrspace(3)* %0
   //
   // Note: the addrspacecast can also be a constant expression.
   if (Operator *Cast = dyn_cast<Operator>(MI->getOperand(Idx))) {
     if (IsEliminableAddrSpaceCast(Cast)) {
       MI->setOperand(Idx, Cast->getOperand(0));
-      return true;
-    }
+      Changed = true;
+    }
+  }
+  return Changed;
+}
+
+bool NVPTXFavorNonGenericAddrSpaces::doInitialization(Module &M) {
+  bool Changed = false;
+  // Canonicalizes all global variable initializers to hoist addrspacecast to
+  // the outermost possible level. This enables NVPTXAsmPrinter to correctly
+  // print more global variables.
+  for (auto &GV : M.globals()) {
+    if (GV.hasInitializer())
+      Changed |= canonicalizeInitializer(GV.getInitializer());
+  }
+  return Changed;
+
+bool NVPTXFavorNonGenericAddrSpaces::canonicalizeInitializer(Constant *
+                                                             Initializer) {
+  if (GEPOperator *GEP = dyn_cast<GEPOperator>(Initializer)) {
+    return hoistAddrSpaceCastFromGEP(GEP);
   }
 
+  bool Changed = false;
+  if (Initializer->getType()->isStructTy() ||
+      Initializer->getType()->isArrayTy() ||
+      Initializer->getType()->isVectorTy()) {
+    // Trace into the elements of Initializer if it is a struct, array, or
+    // vector.
+    for (unsigned I = 0; I != Initializer->getNumOperands(); ++I) {
+      Changed |=
+          canonicalizeInitializer(cast<Constant>(Initializer->getOperand(I)));
+    }
+  }
   return false;
 }
 
 bool NVPTXFavorNonGenericAddrSpaces::runOnFunction(Function &F) {
   if (DisableFavorNonGeneric)
     return false;
 
   bool Changed = false;

test/CodeGen/NVPTX/addrspacecast-gvar.ll

 ; RUN: llc < %s -march=nvptx -mcpu=sm_20 | FileCheck %s
 
 ; CHECK: .visible .global .align 4 .u32 g = 42;
 ; CHECK: .visible .global .align 4 .u32 g2 = generic(g);
 ; CHECK: .visible .global .align 4 .u32 g3 = g;
 ; CHECK: .visible .global .align 8 .u32 g4[2] = {0, generic(g)};
 ; CHECK: .visible .global .align 8 .u32 g5[2] = {0, generic(g+8)};
+; CHECK: .visible .global .align 8 .u32 g6[2] = {0, generic(g+8)};
 
 @g = addrspace(1) global i32 42
 @g2 = addrspace(1) global i32* addrspacecast (i32 addrspace(1)* @g to i32*)
 @g3 = addrspace(1) global i32 addrspace(1)* @g
 @g4 = constant {i32*, i32*} {i32* null, i32* addrspacecast (i32 addrspace(1)* @g to i32*)}
 @g5 = constant {i32*, i32*} {i32* null, i32* addrspacecast (i32 addrspace(1)* getelementptr (i32, i32 addrspace(1)* @g, i32 2) to i32*)}
+@g6 = constant {i32*, i32*} {i32* null, i32* getelementptr (i32, i32* addrspacecast (i32 addrspace(1)* @g to i32*), i32 2)}