Merge branch 'SYCLomatic' into sorthalf

Author: intwanghao

clang/include/clang/Tooling/Core/Replacement.h

@@ -436,6 +436,8 @@ struct TranslationUnitReplacements {
 #ifdef SYCLomatic_CUSTOMIZATION
   std::vector<MainSourceFileInfo> MainSourceFilesDigest;
   std::string DpctVersion = "";
+  std::string SDKVersionMajor = "";
+  std::string SDKVersionMinor = "";
   std::string MainHelperFileName = "";
   std::string USMLevel = ""; // deprecated
 

clang/include/clang/Tooling/ReplacementsYaml.h

@@ -269,6 +269,8 @@ template <> struct MappingTraits<clang::tooling::TranslationUnitReplacements> {
 #ifdef SYCLomatic_CUSTOMIZATION
     Io.mapOptional("MainSourceFilesDigest", Doc.MainSourceFilesDigest);
     Io.mapOptional("DpctVersion", Doc.DpctVersion);
+    Io.mapOptional("SDKVersionMajor", Doc.SDKVersionMajor);
+    Io.mapOptional("SDKVersionMinor", Doc.SDKVersionMinor);
     Io.mapOptional("MainHelperFileName", Doc.MainHelperFileName);
     Io.mapOptional("USMLevel", Doc.USMLevel);
     // Keep here only for backward compatibility - begin

clang/lib/DPCT/AnalysisInfo.cpp

@@ -2947,7 +2947,7 @@ void MemVarInfo::migrateToDeviceGlobal(const VarDecl *MemVar) {
   auto &Ctx = DpctGlobalInfo::getContext();
   auto &MacroArgMap = DpctGlobalInfo::getMacroArgRecordMap();
   auto TSI = MemVar->getTypeSourceInfo();
-  auto OriginTL = TSI->getTypeLoc();
+  auto OriginTL = TSI->getTypeLoc().getUnqualifiedLoc().getAs<TypeLoc>();
   auto TL = OriginTL;
   auto BegLoc = MemVar->getBeginLoc();
   if (BegLoc.isMacroID()) {

clang/lib/DPCT/DPCT.cpp

@@ -463,6 +463,59 @@ void parseFormatStyle() {
   DpctGlobalInfo::setCodeFormatStyle(Style);
 }
 
+void updateCompatibilityVersionInfo(clang::tooling::UnifiedPath OutRoot,
+                                    std::string Major, std::string Minor) {
+  const std::string CmakeHelpFile =
+      appendPath(OutRoot.getCanonicalPath().str(), "dpct.cmake");
+  std::ifstream InFile(CmakeHelpFile);
+  if (!InFile) {
+    std::string ErrMsg = "Failed to open file: " + CmakeHelpFile;
+    ShowStatus(MigrationErrorReadWriteCMakeHelperFile, std::move(ErrMsg));
+    dpctExit(MigrationErrorReadWriteCMakeHelperFile);
+  }
+
+  const std::string VersionStr = Major + "." + Minor;
+  const int CompatibilityValue = std::stoi(Major) * 10 + std::stoi(Minor);
+  std::vector<std::string> Lines;
+  std::string Line;
+  bool Inserted = false;
+
+  // Constant block of content to insert
+  const std::vector<std::string> CompatibilityBlock = {
+      "set(COMPATIBILITY_VERSION " + VersionStr + ")",
+      "set(COMPATIBILITY_VALUE " + std::to_string(CompatibilityValue) + ")",
+      "set(COMPATIBILITY_VERSION_MAJOR " + Major + ")",
+      "set(COMPATIBILITY_VERSION_MINOR " + Minor + ")",
+      "" // Add an empty line for good format
+  };
+
+  auto isCommentOrEmpty = [](const std::string &Line) {
+    return Line.empty() || Line[0] == '#';
+  };
+
+  while (std::getline(InFile, Line)) {
+    // Insert the compatibility definition block after the first comment section
+    if (!Inserted && !isCommentOrEmpty(Line)) {
+      Lines.insert(Lines.end(), CompatibilityBlock.begin(),
+                   CompatibilityBlock.end());
+      Inserted = true;
+    }
+    Lines.push_back(Line);
+  }
+  InFile.close();
+
+  std::ofstream OutFile(CmakeHelpFile);
+  if (!OutFile) {
+    std::string ErrMsg = "Failed to write to file: " + CmakeHelpFile;
+    ShowStatus(MigrationErrorReadWriteCMakeHelperFile, std::move(ErrMsg));
+    dpctExit(MigrationErrorReadWriteCMakeHelperFile);
+  }
+  for (const auto &Line : Lines) {
+    OutFile << Line << "\n";
+  }
+  OutFile.close();
+}
+
 static void loadMainSrcFileInfo(clang::tooling::UnifiedPath OutRoot) {
   std::string YamlFilePath = appendPath(OutRoot.getCanonicalPath().str(),
                                         DpctGlobalInfo::getYamlFileName());
@@ -471,7 +524,16 @@ static void loadMainSrcFileInfo(clang::tooling::UnifiedPath OutRoot) {
     if (loadFromYaml(YamlFilePath, *PreTU) != 0) {
       llvm::errs() << getLoadYamlFailWarning(YamlFilePath);
     }
+
+    if (MigrateBuildScriptOnly || DpctGlobalInfo::migrateCMakeScripts()) {
+      std::string Major = PreTU->SDKVersionMajor;
+      std::string Minor = PreTU->SDKVersionMinor;
+      if (!Major.empty() && !Minor.empty()) {
+        updateCompatibilityVersionInfo(OutRoot, Major, Minor);
+      }
+    }
   }
+
   for (auto &Entry : PreTU->MainSourceFilesDigest) {
     if (Entry.HasCUDASyntax)
       MainSrcFilesHasCudaSyntex.insert(Entry.MainSourceFile);

clang/lib/DPCT/ErrorHandle/Error.cpp

@@ -220,6 +220,10 @@ void ShowStatus(int Status, std::string Message) {
   case MigrationErrorInvalidInstallPath:
     StatusString = "Error: " + Message + " not found.";
     break;
+  case MigrationErrorReadWriteCMakeHelperFile:
+    StatusString =
+        "Error: " + Message + ". Please check the file access permission.";
+    break;
   default:
     DpctLog() << "Unknown error.\n";
     dpctExit(-1);

clang/lib/DPCT/ErrorHandle/Error.h

@@ -67,6 +67,7 @@ enum ProcessStatus {
   MigrationErrorCannotWrite = -52,
   MigratePythonBuildScriptOnlyNotSpecifed = -53,
   MigratePythonBuildScriptSpecifiedButPythonRuleFileNotSpecified = -54,
+  MigrationErrorReadWriteCMakeHelperFile = -55,
 };
 
 namespace clang {

clang/lib/DPCT/IncMigration/ExternalReplacement.cpp

@@ -62,6 +62,11 @@ int save2Yaml(
   }
 
   TUR.DpctVersion = clang::dpct::getDpctVersionStr();
+
+  auto Ver = clang::getCudaVersionPair(DpctGlobalInfo::getSDKVersion());
+  TUR.SDKVersionMajor = std::to_string(Ver.first);
+  TUR.SDKVersionMinor = std::to_string(Ver.second);
+
   TUR.OptionMap = clang::dpct::DpctGlobalInfo::getCurrentOptMap();
 
   YAMLOut << TUR;

clang/lib/DPCT/RuleInfra/CallExprRewriterCommon.h

@@ -149,6 +149,8 @@ template <class SubExprT> class CastIfNotSameExprPrinter {
     clang::QualType ArgType = InputArg->getType().getCanonicalType();
     ArgType.removeLocalFastQualifiers(clang::Qualifiers::CVRMask);
     bool NeedParen = false;
+    std::cout << "Arg type: " << ArgType.getAsString() << "\n";
+    std::cout << "Given type " << TypeInfo << "\n";
     if (ArgType.getAsString() != TypeInfo) {
       NeedParen = needExtraParens(SubExpr);
       Stream << "(" << TypeInfo << ")";
@@ -2132,6 +2134,16 @@ class IsDefinedInCUDA {
     return isFromCUDA(FD);
   }
 };
+class IsDefinedByUser {
+public:
+  IsDefinedByUser() {}
+  bool operator()(const CallExpr *C) {
+    auto FD = C->getDirectCallee();
+    if (!FD)
+      return false;
+    return DpctGlobalInfo::isInRoot(FD->getLocation());
+  }
+};
 } // namespace math
 } // namespace dpct
 

clang/lib/DPCT/RulesLang/APINamesDriver.inc

@@ -47,7 +47,7 @@ FEATURE_REQUEST_FACTORY(
     ASSIGNABLE_FACTORY(ASSIGN_FACTORY_ENTRY("cuModuleGetFunction", DEREF(0),
                                             CALL(MapNames::getDpctNamespace() +
                                                      "get_kernel_function",
-                                                 ARG(1), ARG(2)))))
+                                                 ARG(1), CAST_IF_NOT_SAME(makeLiteral("const char *"), ARG(2))))))
 
 FEATURE_REQUEST_FACTORY(
     HelperFeatureEnum::device_ext,

clang/lib/DPCT/RulesLang/Math/CallExprRewriterMath.h

@@ -388,29 +388,29 @@ class MathRewriterFactory final : public CallExprRewriterFactoryBase {
             return Rewriter.value();
         }
       }
-      if (math::IsUnresolvedLookupExpr(C)) {
-        if (math::IsDirectCallerPureDevice(C)) {
-          if (Rewriter = getDeviceRewriter(C))
-            return Rewriter.value();
-        }
-      }
       if (math::IsDefinedInCUDA()(C)) {
         if (Rewriter = getDeviceRewriter(C))
           return Rewriter.value();
       }
     }
-
-    // Host and device
-    if (HostDeviceRewriter && HostDeviceRewriter.value().first(C))
-      return HostDeviceRewriter.value().second.second->create(C);
-
-    if (EmulationRewriter && EmulationRewriter.value().first(C))
-      return EmulationRewriter.value().second.second->create(C);
-
-    if (UnsupportedWarningRewriter &&
-        UnsupportedWarningRewriter.value().first(C))
-      return UnsupportedWarningRewriter.value().second.second->create(C);
-
+    if (math::IsUnresolvedLookupExpr(C)) {
+      if (math::IsDirectCallerPureDevice(C)) {
+        if (auto Rewriter = getDeviceRewriter(C))
+          return Rewriter.value();
+      } else if (math::IsDirectCallerPureHost(C)) {
+        return NoRewriteRewriter.value().second.second->create(C);
+      }
+    }
+    if (!math::IsDefinedByUser()(C)) {
+      // Host and device
+      if (HostDeviceRewriter && HostDeviceRewriter.value().first(C))
+        return HostDeviceRewriter.value().second.second->create(C);
+      if (EmulationRewriter && EmulationRewriter.value().first(C))
+        return EmulationRewriter.value().second.second->create(C);
+      if (UnsupportedWarningRewriter &&
+          UnsupportedWarningRewriter.value().first(C))
+        return UnsupportedWarningRewriter.value().second.second->create(C);
+    }
     return NoRewriteRewriter.value().second.second->create(C);
   }
 };