[Polly] [PPCGCodeGeneration] [NFC] PPCGCodeGen has a multitude of places it bails out. Log all of these occruences

[grosser]

LGTM.

lib/CodeGen/PPCGCodeGeneration.cpp

128 ↗

(On Diff #109753)

This probably fits better in ScopInfo, no?

[bollu]

lib/CodeGen/PPCGCodeGeneration.cpp

128 ↗

(On Diff #109753)

ScopInfo is a dumping ground :) Since this is localised here, I'd like to keep it here till I spot a use somewhere else.

[grosser]

lib/CodeGen/PPCGCodeGeneration.cpp

128 ↗

(On Diff #109753)

The problem is that nobody except you will know to look here for such a functionality.

polly/trunk/lib/CodeGen/PPCGCodeGeneration.cpp

CudaVersion("polly-acc-cuda-version",
                 cl::desc("The CUDA version to compile for"), cl::Hidden,
                 cl::init("sm_30"), cl::ZeroOrMore, cl::cat(PollyCategory));
 
 static cl::opt<int>
     MinCompute("polly-acc-mincompute",
                cl::desc("Minimal number of compute statements to run on GPU."),
                cl::Hidden, cl::init(10 * 512 * 512));
 
+/// Return  a unique name for a Scop, which is the scop region with the
+/// function name.
+std::string getUniqueScopName(const Scop *S) {
+  return "Scop Region: " + S->getNameStr() +
+         " | Function: " + std::string(S->getFunction().getName());
+}
+
 /// Used to store information PPCG wants for kills. This information is
 /// used by live range reordering.
 ///
 /// @see computeLiveRangeReordering
 /// @see GPUNodeBuilder::createPPCGScop
 /// @see GPUNodeBuilder::createPPCGProg
 struct MustKillsInfo {
   /// Collection of all kill statements that will be sequenced at the end of
for (long i = 0; i < Kernel->n_array; i++) {
     Value *TypedArgPtr = Builder.CreatePointerCast(ArgPtr, TypePtr);
     Value *Val = Builder.CreateLoad(Alloca);
     Builder.CreateStore(Val, TypedArgPtr);
     StoredScalar = true;
 
     Arg++;
   }
 
-  if (StoredScalar)
+  if (StoredScalar) {
     /// In case more than one thread contains scalar stores, the generated
     /// code might be incorrect, if we only store at the end of the kernel.
     /// To support this case we need to store these scalars back at each
     /// memory store or at least before each kernel barrier.
-    if (Kernel->n_block != 0 || Kernel->n_grid != 0)
+    if (Kernel->n_block != 0 || Kernel->n_grid != 0) {
       BuildSuccessful = 0;
+      DEBUG(
+          dbgs() << getUniqueScopName(&S)
+                 << " has a store to a scalar value that"
+                    " would be undefined to run in parallel. Bailing out.\n";);
+    }
+  }
 }
 
 void GPUNodeBuilder::createKernelVariables(ppcg_kernel *Kernel, Function *FN) {
   Module *M = Builder.GetInsertBlock()->getParent()->getParent();
 
   for (int i = 0; i < Kernel->n_var; ++i) {
     struct ppcg_kernel_var &Var = Kernel->var[i];
     isl_id *Id = isl_space_get_tuple_id(Var.array->space, isl_dim_set);
gpu_gen *generateGPU(ppcg_scop *PPCGScop, gpu_prog *PPCGProg) {
 
     int has_permutable = has_any_permutable_node(Schedule);
 
     Schedule =
         isl_schedule_align_params(Schedule, S->getFullParamSpace().release());
 
     if (!has_permutable || has_permutable < 0) {
       Schedule = isl_schedule_free(Schedule);
+      DEBUG(dbgs() << getUniqueScopName(S)
+                   << " does not have permutable bands. Bailing out\n";);
     } else {
       Schedule = map_to_device(PPCGGen, Schedule);
       PPCGGen->tree = generate_code(PPCGGen, isl_schedule_copy(Schedule));
     }
 
     if (DumpSchedule) {
       isl_printer *P = isl_printer_to_str(S->getIslCtx());
       P = isl_printer_set_yaml_style(P, ISL_YAML_STYLE_BLOCK);
bool runOnScop(Scop &CurrentScop) override {
     // We currently do not support functions other than intrinsics inside
     // kernels, as code generation will need to offload function calls to the
     // kernel. This may lead to a kernel trying to call a function on the host.
     // This also allows us to prevent codegen from trying to take the
     // address of an intrinsic function to send to the kernel.
     if (containsInvalidKernelFunction(CurrentScop,
                                       Architecture == GPUArch::NVPTX64)) {
       DEBUG(
-          dbgs()
-              << "Scop contains function which cannot be materialised in a GPU "
+          dbgs() << getUniqueScopName(S)
+                 << " contains function which cannot be materialised in a GPU "
                     "kernel. Bailing out.\n";);
       return false;
     }
 
     auto PPCGScop = createPPCGScop();
     auto PPCGProg = createPPCGProg(PPCGScop);
     auto PPCGGen = generateGPU(PPCGScop, PPCGProg);
 
     if (PPCGGen->tree) {
       generateCode(isl_ast_node_copy(PPCGGen->tree), PPCGProg);
       CurrentScop.markAsToBeSkipped();
+    } else {
+      DEBUG(dbgs() << getUniqueScopName(S)
+                   << " has empty PPCGGen->tree. Bailing out.\n");
     }
 
     freeOptions(PPCGScop);
     freePPCGGen(PPCGGen);
     gpu_prog_free(PPCGProg);
     ppcg_scop_free(PPCGScop);
 
     return true;