[Polly] Remove isConstCall.

The function was intended to catch OpenMP functions such as
get_thread_id(). If matched, the call would be considered synthesizable.

There were a few problems with this:

 * get_thread_id() is not 'const' in the sense of have the gcc manual
   defines it: "do not examine any values except their arguments".
   get_thread_id() reads OpenCL runtime libreary global state.
   What was inteded was probably 'speculable'.

 * isConstCall was implemented using mayReadOrWriteMemory(). 'const' is
   stricter than that, mayReadOrWriteMemory is e.g. true for malloc(),
   since it may only read/write addresses that are considered
   inaccessible fro the application. However, malloc is certainly not
   speculable.

 * Values that are isConstCall were not handled consistently throughout
   Polly. In particular, it was not considered for referenced values
   (OpenMP outlining and PollyACC).

Fix by removing special handling for isConstCall entirely.

Author: Meinersbur

polly/include/polly/Support/SCEVValidator.h

@@ -20,24 +20,6 @@ class SCEVConstant;
 namespace polly {
 class ScopDetection;
 
-/// Check if a call is side-effect free and has only constant arguments.
-///
-/// Such calls can be re-generated easily, so we do not need to model them
-/// as scalar dependences.
-///
-/// @param Call The call to check.
-bool isConstCall(llvm::CallInst *Call);
-
-/// Check if some parameters in the affine expression might hide induction
-/// variables. If this is the case, we will try to delinearize the accesses
-/// taking into account this information to possibly obtain a memory access
-/// with more structure. Currently we assume that each parameter that
-/// comes from a function call might depend on a (virtual) induction variable.
-/// This covers calls to 'get_global_id' and 'get_local_id' as they commonly
-/// arise in OpenCL code, while not catching any false-positives in our current
-/// tests.
-bool hasIVParams(const llvm::SCEV *Expr);
-
 /// Find the loops referenced from a SCEV expression.
 ///
 /// @param Expr The SCEV expression to scan for loops.

polly/lib/Analysis/ScopDetection.cpp

@@ -1134,7 +1134,7 @@ bool ScopDetection::isValidAccess(Instruction *Inst, const SCEV *AF,
   } else if (PollyDelinearize && !IsVariantInNonAffineLoop) {
     Context.Accesses[BP].push_back({Inst, AF});
 
-    if (!IsAffine || hasIVParams(AF))
+    if (!IsAffine)
       Context.NonAffineAccesses.insert(
           std::make_pair(BP, LI.getLoopFor(Inst->getParent())));
   } else if (!AllowNonAffine && !IsAffine) {

polly/lib/Analysis/ScopInfo.cpp

@@ -1468,37 +1468,6 @@ const SCEV *Scop::getRepresentingInvariantLoadSCEV(const SCEV *E) const {
   return SCEVSensitiveParameterRewriter::rewrite(E, *SE, InvEquivClassVMap);
 }
 
-// This table of function names is used to translate parameter names in more
-// human-readable names. This makes it easier to interpret Polly analysis
-// results.
-StringMap<std::string> KnownNames = {
-    {"_Z13get_global_idj", "global_id"},
-    {"_Z12get_local_idj", "local_id"},
-    {"_Z15get_global_sizej", "global_size"},
-    {"_Z14get_local_sizej", "local_size"},
-    {"_Z12get_work_dimv", "work_dim"},
-    {"_Z17get_global_offsetj", "global_offset"},
-    {"_Z12get_group_idj", "group_id"},
-    {"_Z14get_num_groupsj", "num_groups"},
-};
-
-static std::string getCallParamName(CallInst *Call) {
-  std::string Result;
-  raw_string_ostream OS(Result);
-  std::string Name = Call->getCalledFunction()->getName().str();
-
-  auto Iterator = KnownNames.find(Name);
-  if (Iterator != KnownNames.end())
-    Name = "__" + Iterator->getValue();
-  OS << Name;
-  for (auto &Operand : Call->arg_operands()) {
-    ConstantInt *Op = cast<ConstantInt>(&Operand);
-    OS << "_" << Op->getValue();
-  }
-  OS.flush();
-  return Result;
-}
-
 void Scop::createParameterId(const SCEV *Parameter) {
   assert(Parameters.count(Parameter));
   assert(!ParameterIds.count(Parameter));
@@ -1507,11 +1476,8 @@ void Scop::createParameterId(const SCEV *Parameter) {
 
   if (const SCEVUnknown *ValueParameter = dyn_cast<SCEVUnknown>(Parameter)) {
     Value *Val = ValueParameter->getValue();
-    CallInst *Call = dyn_cast<CallInst>(Val);
 
-    if (Call && isConstCall(Call)) {
-      ParameterName = getCallParamName(Call);
-    } else if (UseInstructionNames) {
+    if (UseInstructionNames) {
       // If this parameter references a specific Value and this value has a name
       // we use this name as it is likely to be unique and more useful than just
       // a number.

polly/lib/Support/SCEVValidator.cpp

@@ -117,17 +117,6 @@ raw_ostream &operator<<(raw_ostream &OS, class ValidatorResult &VR) {
   return OS;
 }
 
-bool polly::isConstCall(llvm::CallInst *Call) {
-  if (Call->mayReadOrWriteMemory())
-    return false;
-
-  for (auto &Operand : Call->arg_operands())
-    if (!isa<ConstantInt>(&Operand))
-      return false;
-
-  return true;
-}
-
 /// Check if a SCEV is valid in a SCoP.
 struct SCEVValidator
     : public SCEVVisitor<SCEVValidator, class ValidatorResult> {
@@ -353,18 +342,6 @@ struct SCEVValidator
     return ValidatorResult(SCEVType::PARAM, S);
   }
 
-  ValidatorResult visitCallInstruction(Instruction *I, const SCEV *S) {
-    assert(I->getOpcode() == Instruction::Call && "Call instruction expected");
-
-    if (R->contains(I)) {
-      auto Call = cast<CallInst>(I);
-
-      if (!isConstCall(Call))
-        return ValidatorResult(SCEVType::INVALID, S);
-    }
-    return ValidatorResult(SCEVType::PARAM, S);
-  }
-
   ValidatorResult visitLoadInstruction(Instruction *I, const SCEV *S) {
     if (R->contains(I) && ILS) {
       ILS->insert(cast<LoadInst>(I));
@@ -454,8 +431,6 @@ struct SCEVValidator
         return visitSDivInstruction(I, Expr);
       case Instruction::SRem:
         return visitSRemInstruction(I, Expr);
-      case Instruction::Call:
-        return visitCallInstruction(I, Expr);
       default:
         return visitGenericInst(I, Expr);
       }
@@ -470,34 +445,6 @@ struct SCEVValidator
   }
 };
 
-class SCEVHasIVParams {
-  bool HasIVParams = false;
-
-public:
-  SCEVHasIVParams() {}
-
-  bool follow(const SCEV *S) {
-    const SCEVUnknown *Unknown = dyn_cast<SCEVUnknown>(S);
-    if (!Unknown)
-      return true;
-
-    CallInst *Call = dyn_cast<CallInst>(Unknown->getValue());
-
-    if (!Call)
-      return true;
-
-    if (isConstCall(Call)) {
-      HasIVParams = true;
-      return false;
-    }
-
-    return true;
-  }
-
-  bool isDone() { return HasIVParams; }
-  bool hasIVParams() { return HasIVParams; }
-};
-
 /// Check whether a SCEV refers to an SSA name defined inside a region.
 class SCEVInRegionDependences {
   const Region *R;
@@ -515,11 +462,6 @@ class SCEVInRegionDependences {
     if (auto Unknown = dyn_cast<SCEVUnknown>(S)) {
       Instruction *Inst = dyn_cast<Instruction>(Unknown->getValue());
 
-      CallInst *Call = dyn_cast<CallInst>(Unknown->getValue());
-
-      if (Call && isConstCall(Call))
-        return false;
-
       if (Inst) {
         // When we invariant load hoist a load, we first make sure that there
         // can be no dependences created by it in the Scop region. So, we should
@@ -623,13 +565,6 @@ void findValues(const SCEV *Expr, ScalarEvolution &SE,
   ST.visitAll(Expr);
 }
 
-bool hasIVParams(const SCEV *Expr) {
-  SCEVHasIVParams HasIVParams;
-  SCEVTraversal<SCEVHasIVParams> ST(HasIVParams);
-  ST.visitAll(Expr);
-  return HasIVParams.hasIVParams();
-}
-
 bool hasScalarDepsInsideRegion(const SCEV *Expr, const Region *R,
                                llvm::Loop *Scope, bool AllowLoops,
                                const InvariantLoadsSetTy &ILS) {