Merge from 'sycl' to 'sycl-web' (#3)

Author: iclsrc

clang/include/clang/Driver/Job.h

@@ -11,6 +11,7 @@
 
 #include "clang/Basic/LLVM.h"
 #include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
@@ -39,6 +40,10 @@ struct CrashReportInfo {
 /// Command - An executable path/name and argument vector to
 /// execute.
 class Command {
+public:
+  using ErrorCodeDiagMapTy = llvm::DenseMap<int, std::string>;
+
+private:
   /// Source - The action which caused the creation of this job.
   const Action &Source;
 
@@ -48,6 +53,18 @@ class Command {
   /// The executable to run.
   const char *Executable;
 
+  /// The container for custom driver-set diagnostic messages that are
+  /// produced upon particular error codes returned by the command.
+  /// In order to add such a diagnostic for an external tool, consider the
+  /// following criteria:
+  /// 1) Does the command's executable return different codes upon different
+  ///    types of errors?
+  /// 2) If the executable provides a single error code for various error types,
+  ///    is only a certain type of failure expected to occur within the driver
+  ///    flow? E.g. the driver guarantees a valid input to the tool, so any
+  ///    "invalid input" error can be ruled out
+  ErrorCodeDiagMapTy ErrorCodeDiagMap;
+
   /// The list of program arguments (not including the implicit first
   /// argument, which will be the executable).
   llvm::opt::ArgStringList Arguments;
@@ -100,6 +117,15 @@ class Command {
   virtual int Execute(ArrayRef<Optional<StringRef>> Redirects,
                       std::string *ErrMsg, bool *ExecutionFailed) const;
 
+  /// Store a custom driver diagnostic message upon a particular error code
+  /// returned by the command
+  void addDiagForErrorCode(int ErrorCode, StringRef CustomDiag);
+
+  /// Get the custom driver diagnostic message for a particular error code
+  /// if such was stored. Returns an empty string if no diagnostic message
+  /// was found for the given error code.
+  StringRef getDiagForErrorCode(int ErrorCode) const;
+
   /// getSource - Return the Action which caused the creation of this job.
   const Action &getSource() const { return Source; }
 

clang/lib/CodeGen/BackendUtil.cpp

@@ -843,7 +843,7 @@ void EmitAssemblyHelper::EmitAssembly(BackendAction Action,
       createTargetTransformInfoWrapperPass(getTargetIRAnalysis()));
 
   if (LangOpts.SYCLIsDevice)
-    PerModulePasses.add(createSYCLLowerWGScopePass());
+    PerFunctionPasses.add(createSYCLLowerWGScopePass());
 
   CreatePasses(PerModulePasses, PerFunctionPasses);
 

clang/lib/CodeGen/SYCLLowerIR/LowerWGScope.cpp

@@ -190,7 +190,7 @@ enum class MemorySemantics : unsigned {
 
 Instruction *genWGBarrier(Instruction &Before);
 Value *genLinearLocalID(Instruction &Before);
-Value *createWGLocalVariable(Module &M, Type *T, const Twine &Name);
+GlobalVariable *createWGLocalVariable(Module &M, Type *T, const Twine &Name);
 } // namespace spirv
 
 static bool isCallToAFuncMarkedWithMD(const Instruction *I, const char *MD) {
@@ -375,16 +375,25 @@ namespace {
 using LocalsSet = SmallPtrSet<AllocaInst *, 4>;
 }
 
-static void copyBetweenLocalAndShadow(AllocaInst *L, GlobalVariable *Shadow,
-                                      IRBuilder<> &Builder, bool Loc2Shadow) {
-  Type *T = L->getAllocatedType();
+static void copyBetweenPrivateAndShadow(Value *L, GlobalVariable *Shadow,
+                                        IRBuilder<> &Builder, bool Loc2Shadow) {
+  Type *T = nullptr;
+  int LocAlignN = 0;
+
+  if (const auto *AI = dyn_cast<AllocaInst>(L)) {
+    T = AI->getAllocatedType();
+    LocAlignN = AI->getAlignment();
+  } else {
+    T = cast<Argument>(L)->getParamByValType();
+    LocAlignN = cast<Argument>(L)->getParamAlignment();
+  }
 
   if (T->isAggregateType()) {
     // TODO: we should use methods which directly return MaybeAlign once such
     // are added to LLVM for AllocaInst and GlobalVariable
-    auto LocAlign = MaybeAlign(L->getAlignment());
+    auto LocAlign = MaybeAlign(LocAlignN);
     auto ShdAlign = MaybeAlign(Shadow->getAlignment());
-    Module &M = *L->getModule();
+    Module &M = *Shadow->getParent();
     auto SizeVal = M.getDataLayout().getTypeStoreSize(T);
     auto Size = ConstantInt::get(getSizeTTy(M), SizeVal);
     if (Loc2Shadow)
@@ -434,9 +443,9 @@ static void copyBetweenLocalAndShadow(AllocaInst *L, GlobalVariable *Shadow,
 //
 static void materializeLocalsInWIScopeBlocksImpl(
     const DenseMap<BasicBlock *, std::unique_ptr<LocalsSet>> &BB2MatLocals,
-    const DenseMap<AllocaInst *, Value *> &Local2Shadow) {
+    const DenseMap<AllocaInst *, GlobalVariable *> &Local2Shadow) {
   for (auto &P : BB2MatLocals) {
-    // generate LeaderBB and local<->shadow copies in proper BBs
+    // generate LeaderBB and private<->shadow copies in proper BBs
     BasicBlock *LeaderBB = P.first;
     BasicBlock *BB = LeaderBB->splitBasicBlock(&LeaderBB->front(), "LeaderMat");
     // Add a barrier to the original block:
@@ -445,18 +454,19 @@ static void materializeLocalsInWIScopeBlocksImpl(
     for (AllocaInst *L : *P.second.get()) {
       auto MapEntry = Local2Shadow.find(L);
       assert(MapEntry != Local2Shadow.end() && "local must have a shadow");
-      auto *Shadow = dyn_cast<GlobalVariable>(MapEntry->second);
+      auto *Shadow = MapEntry->second;
       LLVMContext &Ctx = L->getContext();
       IRBuilder<> Builder(Ctx);
       // fill the leader BB:
       // fetch data from leader's private copy (which is always up to date) into
       // the corresponding shadow variable
       Builder.SetInsertPoint(&LeaderBB->front());
-      copyBetweenLocalAndShadow(L, Shadow, Builder, true /*local->shadow*/);
+      copyBetweenPrivateAndShadow(L, Shadow, Builder, true /*private->shadow*/);
       // store data to the local variable - effectively "refresh" the value of
       // the local in each work item in the work group
       Builder.SetInsertPoint(At);
-      copyBetweenLocalAndShadow(L, Shadow, Builder, false /*shadow->local*/);
+      copyBetweenPrivateAndShadow(L, Shadow, Builder,
+                                  false /*shadow->private*/);
     }
     // now generate the TestBB and the leader WI guard
     BasicBlock *TestBB =
@@ -528,7 +538,7 @@ void materializeLocalsInWIScopeBlocks(
     SmallPtrSetImpl<AllocaInst *> &Locals,
     SmallPtrSetImpl<BasicBlock *> &WIScopeBBs) {
   // maps local variable to its "shadow" workgroup-shared global:
-  DenseMap<AllocaInst *, Value *> Local2Shadow;
+  DenseMap<AllocaInst *, GlobalVariable *> Local2Shadow;
   // records which locals must be materialized at the beginning of a block:
   DenseMap<BasicBlock *, std::unique_ptr<LocalsSet>> BB2MatLocals;
 
@@ -543,7 +553,7 @@ void materializeLocalsInWIScopeBlocks(
         continue;
       if (Local2Shadow.find(L) == Local2Shadow.end()) {
         // lazily create a "shadow" for current local:
-        Value *Shadow = spirv::createWGLocalVariable(
+        GlobalVariable *Shadow = spirv::createWGLocalVariable(
             *BB->getModule(), L->getAllocatedType(), "WGCopy");
         Local2Shadow.insert(std::make_pair(L, Shadow));
       }
@@ -667,6 +677,47 @@ static void fixupPrivateMemoryPFWILambdaCaptures(CallInst *PFWICall) {
   }
 }
 
+// Go through "byval" parameters which are passed as AS(0) pointers
+// and: (1) create local shadows for them (2) and initialize them from the
+// leader's copy and (3) replace usages with pointer to the shadow
+static void shareByValParams(Function &F) {
+  // split
+  BasicBlock *EntryBB = &F.getEntryBlock();
+  BasicBlock *LeaderBB = EntryBB->splitBasicBlock(&EntryBB->front(), "leader");
+  BasicBlock *MergeBB = LeaderBB->splitBasicBlock(&LeaderBB->front(), "merge");
+
+  // 1) rewire the above basic blocks so that LeaderBB is executed only for the
+  // leader workitem
+  guardBlockWithIsLeaderCheck(EntryBB, LeaderBB, MergeBB,
+                              EntryBB->back().getDebugLoc());
+  Instruction &At = LeaderBB->back();
+
+  for (auto &Arg : F.args()) {
+    if (!Arg.hasByValAttr())
+      continue;
+    assert(Arg.getType()->getPointerAddressSpace() ==
+           asUInt(spirv::AddrSpace::Private));
+    Type *T = Arg.getParamByValType();
+
+    // 2) create the shared copy - "shadow" - for current byval arg
+    GlobalVariable *Shadow =
+        spirv::createWGLocalVariable(*F.getParent(), T, "ArgShadow");
+
+    // 3) replace argument with shadow in all uses
+    for (auto *U : Arg.users())
+      U->replaceUsesOfWith(&Arg, Shadow);
+
+    // 4) fill the shadow from the argument for the leader WI only
+    LLVMContext &Ctx = At.getContext();
+    IRBuilder<> Builder(Ctx);
+    Builder.SetInsertPoint(&LeaderBB->front());
+    copyBetweenPrivateAndShadow(&Arg, Shadow, Builder,
+                                true /*private->shadow*/);
+  }
+  // 5) make sure workers use up-to-date shared values written by the leader
+  spirv::genWGBarrier(MergeBB->front());
+}
+
 PreservedAnalyses SYCLLowerWGScopePass::run(Function &F,
                                             FunctionAnalysisManager &FAM) {
   if (!F.getMetadata(WG_SCOPE_MD))
@@ -729,7 +780,13 @@ PreservedAnalyses SYCLLowerWGScopePass::run(Function &F,
     }
   }
 #ifndef NDEBUG
-  bool HaveChanges = (Ranges.size() > 0) || (Allocas.size() > 0);
+  int NByval = 0;
+  for (const auto &Arg : F.args()) {
+    if (Arg.hasByValAttr())
+      NByval++;
+  }
+
+  bool HaveChanges = (Ranges.size() > 0) || (Allocas.size() > 0) || NByval > 0;
 
   if (HaveChanges && Debug > 1) {
     dumpIR(F, "before");
@@ -762,6 +819,9 @@ PreservedAnalyses SYCLLowerWGScopePass::run(Function &F,
   for (auto *PFWICall : PFWICalls)
     fixupPrivateMemoryPFWILambdaCaptures(PFWICall);
 
+  // Finally, create shadows for and replace usages of byval pointer params
+  shareByValParams(F);
+
 #ifndef NDEBUG
   if (HaveChanges && Debug > 0)
     verifyModule(*F.getParent(), &llvm::errs());
@@ -773,7 +833,8 @@ PreservedAnalyses SYCLLowerWGScopePass::run(Function &F,
   return Changed ? PreservedAnalyses::none() : PreservedAnalyses::all();
 }
 
-Value *spirv::createWGLocalVariable(Module &M, Type *T, const Twine &Name) {
+GlobalVariable *spirv::createWGLocalVariable(Module &M, Type *T,
+                                             const Twine &Name) {
   GlobalVariable *G =
       new GlobalVariable(M,                              // module
                          T,                              // type

clang/lib/Driver/Driver.cpp

@@ -1685,7 +1685,7 @@ int Driver::ExecuteCompilation(
     // diagnostics, so always print the diagnostic there.
     const Tool &FailingTool = FailingCommand->getCreator();
 
-    if (!FailingCommand->getCreator().hasGoodDiagnostics() || CommandRes != 1) {
+    if (!FailingTool.hasGoodDiagnostics() || CommandRes != 1) {
       // FIXME: See FIXME above regarding result code interpretation.
       if (CommandRes < 0)
         Diag(clang::diag::err_drv_command_signalled)
@@ -1694,6 +1694,10 @@ int Driver::ExecuteCompilation(
         Diag(clang::diag::err_drv_command_failed)
             << FailingTool.getShortName() << CommandRes;
     }
+
+    auto CustomDiag = FailingCommand->getDiagForErrorCode(CommandRes);
+    if (!CustomDiag.empty())
+      Diag(clang::diag::note_drv_command_failed_diag_msg) << CustomDiag;
   }
   return Res;
 }

clang/lib/Driver/Job.cpp

@@ -173,6 +173,17 @@ void Command::buildArgvForResponseFile(
   }
 }
 
+void Command::addDiagForErrorCode(int ErrorCode, StringRef CustomDiag) {
+  ErrorCodeDiagMap[ErrorCode] = CustomDiag.str();
+}
+
+StringRef Command::getDiagForErrorCode(int ErrorCode) const {
+  auto ErrorCodeDiagIt = ErrorCodeDiagMap.find(ErrorCode);
+  if (ErrorCodeDiagIt != ErrorCodeDiagMap.end())
+    return ErrorCodeDiagIt->second;
+  return StringRef();
+}
+
 /// Rewrite relative include-like flag paths to absolute ones.
 static void
 rewriteIncludes(const llvm::ArrayRef<const char *> &Args, size_t Idx,

clang/lib/Driver/ToolChains/Clang.cpp

@@ -7440,18 +7440,29 @@ void SPIRCheck::ConstructJob(Compilation &C, const JobAction &JA,
   // we need to exit.  The expected output is the input as this is just an
   // intermediate check with no functional change.
   ArgStringList CheckArgs;
-  for (auto I : Inputs) {
-    CheckArgs.push_back(I.getFilename());
-  }
+  assert(Inputs.size() == 1 && "Unexpected number of inputs to the tool");
+  const InputInfo &InputFile = Inputs.front();
+  CheckArgs.push_back(InputFile.getFilename());
 
   // Add output file, which is just a copy of the input to better fit in the
   // toolchain flow.
   CheckArgs.push_back("-o");
   CheckArgs.push_back(Output.getFilename());
-
-  C.addCommand(std::make_unique<Command>(JA, *this,
+  auto Cmd = std::make_unique<Command>(
+      JA, *this,
       TCArgs.MakeArgString(getToolChain().GetProgramPath(getShortName())),
-      CheckArgs, None));
+      CheckArgs, None);
+
+  if (getToolChain().getTriple().getSubArch() ==
+      llvm::Triple::SPIRSubArch_fpga) {
+    const char *Msg = TCArgs.MakeArgString(
+        Twine("The FPGA image does not include all device kernels from ") +
+        Twine(InputFile.getBaseInput()) +
+        Twine(". Please re-generate the image"));
+    Cmd->addDiagForErrorCode(/*ErrorCode*/ 1, Msg);
+  }
+
+  C.addCommand(std::move(Cmd));
 }
 
 void SYCLPostLink::ConstructJob(Compilation &C, const JobAction &JA,

clang/lib/Driver/ToolChains/Clang.h

@@ -199,6 +199,7 @@ class LLVM_LIBRARY_VISIBILITY SYCLPostLink final : public Tool {
       : Tool("SYCL post link", "sycl-post-link", TC) {}
 
   bool hasIntegratedCPP() const override { return false; }
+  bool hasGoodDiagnostics() const override { return true; }
   void ConstructJob(Compilation &C, const JobAction &JA,
                     const InputInfo &Output, const InputInfoList &Inputs,
                     const llvm::opt::ArgList &TCArgs,

clang/test/CodeGenSYCL/Inputs/sycl.hpp

@@ -23,6 +23,8 @@ class sampler {
 
 template <int dimensions = 1>
 class group {
+public:
+  group() = default; // fake constructor
 };
 
 namespace access {
@@ -251,6 +253,12 @@ kernel_parallel_for(KernelType KernelFunc) {
   KernelFunc(id<Dims>());
 }
 
+template <typename KernelName, typename KernelType, int Dims>
+ATTR_SYCL_KERNEL void
+kernel_parallel_for_work_group(KernelType KernelFunc) {
+  KernelFunc(group<Dims>());
+}
+
 class handler {
 public:
   template <typename KernelName = auto_name, typename KernelType, int Dims>
@@ -263,6 +271,17 @@ class handler {
 #endif
   }
 
+  template <typename KernelName = auto_name, typename KernelType, int Dims>
+  void parallel_for_work_group(range<Dims> numWorkGroups, range<Dims> WorkGroupSize, KernelType kernelFunc) {
+    using NameT = typename get_kernel_name_t<KernelName, KernelType>::name;
+#ifdef __SYCL_DEVICE_ONLY__
+    kernel_parallel_for_work_group<NameT, KernelType, Dims>(kernelFunc);
+#else
+    group<Dims> G;
+    kernelFunc(G);
+#endif
+  }
+
   template <typename KernelName = auto_name, typename KernelType>
   void single_task(KernelType kernelFunc) {
     using NameT = typename get_kernel_name_t<KernelName, KernelType>::name;