[AMDGPU][Attributor] Stop inferring amdgpu-no-flat-scratch-init in sanitized functions. (#161319)

.azuredevops/rocm-ci.yml

@@ -23,5 +23,7 @@ trigger:
     - '**/*.md'
     - LICENSE.TXT
 
+pr: none
+
 jobs:
   - template: ${{ variables.CI_COMPONENT_PATH }}/llvm-project.yml@pipelines_repo

.github/workflows/PSDB-amd-mainline.yml

@@ -0,0 +1,106 @@
+name: Compiler CI PSDB trigger on amd-mainline branch
+
+# Controls when the workflow will run
+on:
+  pull_request:
+    branches: [amd-mainline]
+    types: [opened, reopened, synchronize, ready_for_review]
+  workflow_dispatch:
+
+# A workflow run is made up of one or more jobs that can run sequentially or in parallel, below is a single job called invoke jenkins jobs
+jobs:
+  # This workflow contains a single job called "invoke_jenkins_PSDB"
+  invoke_jenkins_PSDB:
+    if: github.event.pull_request.draft == false
+    runs-on: 
+      group: compiler-generic-runners
+    env:
+        svc_acc_org_secret: ${{secrets.CI_GITHUB_TOKEN}}
+        input_sha: ${{ github.event.pull_request.head.sha != '' && github.event.pull_request.head.sha || github.sha }}
+        input_pr_num: ${{ github.event.pull_request.number != '' && github.event.pull_request.number || 0 }}
+        input_pr_url: ${{ github.event.pull_request.html_url != '' && github.event.pull_request.html_url || '' }}
+        input_pr_title: ${{ github.event.pull_request.title != '' && github.event.pull_request.title || '' }}
+        # set the pipeline name here based on branch name
+        pipeline_name:  ${{secrets.CI_JENKINS_MAINLINE_JOB_NAME}}
+        JENKINS_URL: ${{secrets.CI_JENKINS_URL}}
+        CONTAINER_IMAGE: ${{ secrets.JENKINS_TRIGGER_DOCKER_IMAGE }}
+
+    # Steps represent a sequence of tasks that will be executed as part of the job
+    steps:    
+
+      # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
+      - name: Set environment variable for container image
+        run: |
+         echo "CONTAINER_IMAGE=${{ secrets.JENKINS_TRIGGER_DOCKER_IMAGE }}" >> $GITHUB_ENV
+         echo "CONTAINER_NAME=my_container_${{ github.run_id }}" >> $GITHUB_ENV
+
+
+      - name: Pull container image
+        run: docker pull "${{env.CONTAINER_IMAGE}}"      
+
+
+      - name: Run container
+        run: |
+          docker run -d --name "${{env.CONTAINER_NAME}}" $CONTAINER_IMAGE sleep infinity
+          #docker exec "${{env.CONTAINER_NAME}}" /bin/bash -c  "git clone ${{secrets.CI_UTILS_REPO}} ."
+          docker exec "${{env.CONTAINER_NAME}}" /bin/bash -c "echo 'Running commands inside the container'"
+
+      - name: Escape pull request title
+        run: |
+          import json
+          import os
+          import shlex
+          with open('${{ github.event_path }}') as fh:
+              event = json.load(fh)         
+          escaped = event['pull_request']['title']
+          with open(os.environ['GITHUB_ENV'], 'a') as fh:
+              print(f'PR_TITLE={escaped}', file=fh)
+        shell: python3 {0}          
+
+      - name: Run Jenkins Cancel Script
+        env:
+          JENKINS_URL: ${{secrets.CI_JENKINS_URL}}
+          JENKINS_USER:  ${{secrets.CI_JENKINS_USER}}
+          JENKINS_API_TOKEN: ${{secrets.CI_JENKINS_TOKEN}}
+          JENKINS_JOB_NAME: ${{secrets.CI_JENKINS_JOB_NAME}}
+          PR_NUMBER: ${{ github.event.pull_request.number }}
+          COMMIT_HASH: ${{ github.event.after }}
+        run: |
+          docker exec -e JENKINS_JOB_NAME=${{secrets.CI_JENKINS_JOB_NAME}}  -e PR_NUMBER=${{ github.event.pull_request.number }}  -e COMMIT_HASH=${{ github.event.after }} -e JENKINS_URL=${{secrets.CI_JENKINS_URL}} -e JENKINS_USER=${{secrets.CI_JENKINS_USER}} -e JENKINS_API_TOKEN=${{secrets.CI_JENKINS_TOKEN}}  "${{env.CONTAINER_NAME}}" /bin/bash -c "PYTHONHTTPSVERIFY=0 python3 cancel_previous_build.py"
+
+
+      # Runs a set of commands using the runners shell
+      - name: Getting Event Details  
+        run: |
+          echo $(pwd)
+          echo $GITHUB_ENV
+          echo $GITHUB_REPOSITORY
+          echo $GITHUB_SERVER_URL
+          echo "GITHUB_SHA is: $GITHUB_SHA"
+          echo "GITHUB_WORKFLOW_SHA is: $GITHUB_WORKFLOW_SHA"
+          echo "GITHUB_BASE_REF is: $GITHUB_BASE_REF"
+          echo "GITHUB_REF_NAME is: $GITHUB_REF_NAME"
+          echo "github.event.pull_request.id is: ${{github.event.pull_request.id}}"
+          echo "github.event.pull_request.html_url is: ${{github.event.pull_request.html_url}}"
+          echo "github.event.pull_request.number is: ${{github.event.pull_request.number}}"
+          echo "github.event.pull_request.url is: ${{github.event.pull_request.url}}"
+          echo "github.event.pull_request.issue_url is: ${{github.event.pull_request.issue_url}}"
+          echo "github.event.pull_request.head.sha is: ${{github.event.pull_request.head.sha}}"
+          echo "github.event.pull_request.base.ref is: ${{github.event.pull_request.base.ref}}"
+          echo "github.event.pull_request.merge_commit_sha is: ${{github.event.pull_request.merge_commit_sha}}"
+          echo "github.event.pull_request is: ${{github.event.pull_request}}"
+
+
+      - name: Trigger Jenkins Pipeline
+        if: steps.check_changes.outcome != 'failure'
+        run: |
+          echo "--Running jenkins_api.py with input sha - $input_sha for pull request - $input_pr_url" 
+          docker exec -e GITHUB_REPOSITORY="$GITHUB_REPOSITORY" -e svc_acc_org_secret="$svc_acc_org_secret" -e input_sha="$input_sha" -e input_pr_url="$input_pr_url" -e pipeline_name="$pipeline_name" \
+                     -e input_pr_num="$input_pr_num" -e PR_TITLE="$PR_TITLE" -e JENKINS_URL="$JENKINS_URL" -e GITHUB_PAT="$svc_acc_org_secret" "${{env.CONTAINER_NAME}}"  \
+                     /bin/bash -c 'echo \"PR NUM: "$input_pr_num"\" && PYTHONHTTPSVERIFY=0 python3 jenkins_api.py -s \"${JENKINS_URL}\" -jn "$pipeline_name" -ghr "$GITHUB_REPOSITORY" -ghsha "$input_sha" -ghprn "$input_pr_num" -ghpru "$input_pr_url" -ghprt "$PR_TITLE" -ghpat="$svc_acc_org_secret"'
+
+      - name: Stop and remove container
+        if: always()
+        run: |
+          docker stop "${{env.CONTAINER_NAME}}"
+          docker rm "${{env.CONTAINER_NAME}}"

amd/comgr/src/comgr-compiler.cpp

@@ -810,16 +810,11 @@ amd_comgr_status_t AMDGPUCompiler::createTmpDirs() {
   return AMD_COMGR_STATUS_SUCCESS;
 }
 
-amd_comgr_status_t AMDGPUCompiler::removeTmpDirs() {
-  if (TmpDir.empty()) {
-    return AMD_COMGR_STATUS_SUCCESS;
-  }
-  ProfilePoint Point("RemoveDir");
-
-#ifdef _WIN32
 // On windows fs::remove_directories takes huge time so use fs::remove.
+#ifdef _WIN32
+amd_comgr_status_t removeDirectory(const StringRef DirName) {
   std::error_code EC;
-  for (fs::directory_iterator Dir(TmpDir, EC), DirEnd; Dir != DirEnd && !EC;
+  for (fs::directory_iterator Dir(DirName, EC), DirEnd; Dir != DirEnd && !EC;
        Dir.increment(EC)) {
     const StringRef Path = Dir->path();
 
@@ -849,16 +844,26 @@ amd_comgr_status_t AMDGPUCompiler::removeTmpDirs() {
     }
   }
 
-  if (fs::remove(TmpDir)) {
+  if (fs::remove(DirName)) {
     return AMD_COMGR_STATUS_ERROR;
   }
 
   return AMD_COMGR_STATUS_SUCCESS;
-#else
+}
+#endif
+
+amd_comgr_status_t AMDGPUCompiler::removeTmpDirs() {
+  if (TmpDir.empty()) {
+    return AMD_COMGR_STATUS_SUCCESS;
+  }
+  ProfilePoint Point("RemoveDir");
+#ifndef _WIN32
   if (fs::remove_directories(TmpDir)) {
     return AMD_COMGR_STATUS_ERROR;
   }
   return AMD_COMGR_STATUS_SUCCESS;
+#else
+  return removeDirectory(TmpDir);
 #endif
 }
 

amd/comgr/src/comgr.cpp

@@ -310,7 +310,8 @@ amd_comgr_status_t COMGR::parseTargetIdentifier(StringRef IdentStr,
 
 
   // TODO: Add a LIT test for this
-  if (IdentStr == "amdgcn-amd-amdhsa--amdgcnspirv") {
+  if (IdentStr == "amdgcn-amd-amdhsa--amdgcnspirv" ||
+      IdentStr == "amdgcn-amd-amdhsa-unknown-amdgcnspirv") {
     // Features not supported for SPIR-V
     if (!Ident.Features.empty())
       return AMD_COMGR_STATUS_ERROR_INVALID_ARGUMENT;
@@ -2110,6 +2111,8 @@ amd_comgr_populate_name_expression_map(amd_comgr_data_t Data, size_t *Count) {
     if (!RelaRangeOrError) {
       llvm::logAllUnhandledErrors(RelaRangeOrError.takeError(), llvm::errs(),
                                   "RelaRange creation error: ");
+      for (auto *Ptr : NameExpDataVec)
+        delete Ptr;
       return AMD_COMGR_STATUS_ERROR;
     }
     auto RelaRange = std::move(RelaRangeOrError.get());
@@ -2130,6 +2133,8 @@ amd_comgr_populate_name_expression_map(amd_comgr_data_t Data, size_t *Count) {
     if (!RodataOrError) {
       llvm::logAllUnhandledErrors(RodataOrError.takeError(), llvm::errs(),
                                   "Rodata creation error: ");
+      for (auto *Ptr : NameExpDataVec)
+        delete Ptr;
       return AMD_COMGR_STATUS_ERROR;
     }
     auto Rodata = std::move(RodataOrError.get());
@@ -2160,6 +2165,8 @@ amd_comgr_populate_name_expression_map(amd_comgr_data_t Data, size_t *Count) {
       }
     }
 
+    for (auto *Ptr : NameExpDataVec)
+      delete Ptr;
   } // end AMD_COMGR_DATA_KIND_EXECUTABLE conditional
 
   *Count = DataP->NameExpressionMap.size();

amd/comgr/test-lit/CMakeLists.txt

@@ -21,10 +21,7 @@ if (NOT DEFINED LLVM_LIT_PATH)
 endif()
 message("-- LLVM_LIT_PATH: ${LLVM_LIT_PATH}")
 
-# TODO: Re-enable target once nPSDB issue with llvm-lit is fixed
-#add_custom_target(test-lit COMMAND "${LLVM_LIT_PATH}"
-#                  "${CMAKE_CURRENT_BINARY_DIR}" -v)
-add_custom_target(test-lit COMMAND echo "${LLVM_LIT_PATH}"
+add_custom_target(test-lit COMMAND "${LLVM_LIT_PATH}"
                   "${CMAKE_CURRENT_BINARY_DIR}" -v)
 
 macro(add_comgr_lit_binary name lang)

clang/docs/ClangOffloadBundler.rst

@@ -525,15 +525,15 @@ The compressed offload bundle begins with a header followed by the compressed bi
     This is a unique identifier to distinguish compressed offload bundles. The value is the string 'CCOB' (Compressed Clang Offload Bundle).
 
 - **Version Number (16-bit unsigned int)**:
-    This denotes the version of the compressed offload bundle format. The current version is `2`.
+    This denotes the version of the compressed offload bundle format. The current version is `3`.
 
 - **Compression Method (16-bit unsigned int)**:
     This field indicates the compression method used. The value corresponds to either `zlib` or `zstd`, represented as a 16-bit unsigned integer cast from the LLVM compression enumeration.
 
-- **Total File Size (32-bit unsigned int)**:
+- **Total File Size (unsigned int, 32-bit in v2, 64-bit in v3)**:
     This is the total size (in bytes) of the file, including the header. Available in version 2 and above.
 
-- **Uncompressed Binary Size (32-bit unsigned int)**:
+- **Uncompressed Binary Size (unsigned int, 32-bit in v2, 64-bit in v3)**:
     This is the size (in bytes) of the binary data before it was compressed.
 
 - **Hash (64-bit unsigned int)**:
@@ -542,4 +542,4 @@ The compressed offload bundle begins with a header followed by the compressed bi
 - **Compressed Data**:
     The actual compressed binary data follows the header. Its size can be inferred from the total size of the file minus the header size.
 
-    > **Note**: Version 3 of the format is under development. It uses 64-bit fields for Total File Size and Uncompressed Binary Size to support files larger than 4GB. To experiment with version 3, set the environment variable `COMPRESSED_BUNDLE_FORMAT_VERSION=3`. This support is experimental and not recommended for production use.
+    > **Note**: Version 3 is now the default format. For backward compatibility with older HIP runtimes that support version 2 only, set the environment variable `COMPRESSED_BUNDLE_FORMAT_VERSION=2`.

clang/include/clang/Driver/OffloadBundler.h

@@ -120,7 +120,7 @@ class CompressedOffloadBundle {
     static llvm::Expected<CompressedBundleHeader> tryParse(llvm::StringRef);
   };
 
-  static inline const uint16_t DefaultVersion = 2;
+  static inline const uint16_t DefaultVersion = 3;
 
   static llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>>
   compress(llvm::compression::Params P, const llvm::MemoryBuffer &Input,

clang/lib/CodeGen/TargetBuiltins/AMDGPU.cpp

@@ -304,7 +304,7 @@ static Value *GetOrInsertAMDGPUPredicate(CodeGenFunction &CGF, Twine Name) {
   P->setExternallyInitialized(true);
 
   return CGF.Builder.CreateLoad(
-      RawAddress(P, PTy, CharUnits::One(), KnownNonNull), true);
+      RawAddress(P, PTy, CharUnits::One(), KnownNonNull));
 }
 
 Value *CodeGenFunction::EmitAMDGPUBuiltinExpr(unsigned BuiltinID,

clang/lib/Driver/ToolChain.cpp

@@ -483,7 +483,23 @@ ParsedClangName
 ToolChain::getTargetAndModeFromProgramName(StringRef PN) {
   std::string ProgName = normalizeProgramName(PN);
   size_t SuffixPos;
+  bool FlangNew = false;
   const DriverSuffix *DS = parseDriverSuffix(ProgName, SuffixPos);
+
+  // Part II: Warn if invocation happens with flang-new (for Flang); this is for
+  // the time being and should be removed once AMD Classic Flang has been
+  // removed from ROCm.
+  if (FlangNew) {
+    // flang-new warning is overwarning, disabling until fixed.
+    if (false && !::getenv("AMD_NOWARN_FLANG_NEW")) {
+      // The solution with "llvm::errs()" is not ideal, but the driver object
+      // is not been constructed yet, so we cannot use the Diag() infrastructure
+      // for this.
+      llvm::errs() << "warning: the 'amdflang-new' and 'flang-new' commmands "
+                      "have been deprecated; please use 'amdflang' instead\n";
+    }
+  }
+
   if (!DS)
     return {};
   size_t SuffixEnd = SuffixPos + strlen(DS->Suffix);

clang/lib/Driver/ToolChains/CommonArgs.cpp

@@ -68,6 +68,23 @@ using namespace clang::driver::tools;
 using namespace clang;
 using namespace llvm::opt;
 
+static bool addRPathCmdArg(const llvm::opt::ArgList &Args,
+                           ArgStringList &CmdArgs,
+                           const std::string pathCandidate,
+                           bool onlyIfPathExists = true) {
+  SmallString<0> simplifiedPathCandidate(pathCandidate);
+  llvm::sys::path::remove_dots(simplifiedPathCandidate, true);
+
+  bool pathExists = llvm::sys::fs::exists(simplifiedPathCandidate);
+
+  if (onlyIfPathExists && !pathExists)
+    return false;
+
+  CmdArgs.push_back("-rpath");
+  CmdArgs.push_back(Args.MakeArgString(simplifiedPathCandidate));
+  return pathExists;
+}
+
 static bool useFramePointerForTargetByDefault(const llvm::opt::ArgList &Args,
                                               const llvm::Triple &Triple) {
   if (Args.hasArg(clang::driver::options::OPT_pg) &&
@@ -1351,12 +1368,8 @@ void tools::addOpenMPRuntimeSpecificRPath(const ToolChain &TC,
   // one of the LIBRARY_PATH directories.
   ArgStringList EnvLibraryPaths;
   addDirectoryList(Args, EnvLibraryPaths, "", "LIBRARY_PATH");
-  for (auto &EnvLibraryPath : EnvLibraryPaths) {
-    if (llvm::sys::fs::exists(EnvLibraryPath)) {
-      CmdArgs.push_back("-rpath");
-      CmdArgs.push_back(Args.MakeArgString(EnvLibraryPath));
-    }
-  }
+  for (auto &EnvLibraryPath : EnvLibraryPaths)
+    addRPathCmdArg(Args, CmdArgs, EnvLibraryPath);
 
   if (Args.hasFlag(options::OPT_fopenmp_implicit_rpath,
                    options::OPT_fno_openmp_implicit_rpath, true)) {
@@ -1365,46 +1378,33 @@ void tools::addOpenMPRuntimeSpecificRPath(const ToolChain &TC,
     SmallString<256> DefaultLibPath =
         llvm::sys::path::parent_path(TC.getDriver().Dir);
     llvm::sys::path::append(DefaultLibPath, CLANG_INSTALL_LIBDIR_BASENAME);
-    if (TC.getSanitizerArgs(Args).needsAsanRt()) {
-      CmdArgs.push_back("-rpath");
-      CmdArgs.push_back(Args.MakeArgString(TC.getCompilerRTPath()));
-    }
+    if (TC.getSanitizerArgs(Args).needsAsanRt())
+      addRPathCmdArg(Args, CmdArgs, TC.getCompilerRTPath(),
+                     /*onlyIfPathExists=*/false);
 
     // In case LibSuffix was not built, try lib
     std::string CandidateRPath_suf = D.Dir + "/../" + LibSuffix;
-    CmdArgs.push_back("-rpath");
-    CmdArgs.push_back(Args.MakeArgString(CandidateRPath_suf.c_str()));
-
     // Add lib directory in case LibSuffix does not exist
     std::string CandidateRPath_lib = D.Dir + "/../lib";
-    if ((!llvm::sys::fs::exists(CandidateRPath_suf)) &&
-        (llvm::sys::fs::exists(CandidateRPath_lib))) {
-      CmdArgs.push_back("-rpath");
-      CmdArgs.push_back(Args.MakeArgString(CandidateRPath_lib.c_str()));
-    }
+    if (!addRPathCmdArg(Args, CmdArgs, CandidateRPath_suf,
+                        /*onlyIfPathExists=*/false))
+      addRPathCmdArg(Args, CmdArgs, CandidateRPath_lib);
 
     std::string rocmPath =
         Args.getLastArgValue(clang::driver::options::OPT_rocm_path_EQ).str();
     if (rocmPath.size() != 0) {
       std::string rocmPath_lib = rocmPath + "/lib";
       std::string rocmPath_suf = rocmPath + "/" + LibSuffix;
-      if (llvm::sys::fs::exists(rocmPath_suf)) {
-        CmdArgs.push_back("-rpath");
-        CmdArgs.push_back(Args.MakeArgString(rocmPath_suf.c_str()));
-      } else if (llvm::sys::fs::exists(rocmPath_lib)) {
-        CmdArgs.push_back("-rpath");
-        CmdArgs.push_back(Args.MakeArgString(rocmPath_lib.c_str()));
-      }
+      if (!addRPathCmdArg(Args, CmdArgs, rocmPath_suf))
+        addRPathCmdArg(Args, CmdArgs, rocmPath_lib);
     }
 
     // Add Default lib path to ensure llvm dynamic library is picked up for
     // lib-debug/lib-perf
-    if (LibSuffix != "lib" && llvm::sys::fs::exists(DefaultLibPath)){
-      CmdArgs.push_back("-rpath");
-      CmdArgs.push_back(Args.MakeArgString(DefaultLibPath.c_str()));
-    }
+    if (LibSuffix != "lib")
+      addRPathCmdArg(Args, CmdArgs, DefaultLibPath.c_str());
 
-     if (llvm::find_if(CmdArgs, [](StringRef str) {
+    if (llvm::find_if(CmdArgs, [](StringRef str) {
           return !str.compare("--enable-new-dtags");
         }) == CmdArgs.end())
       CmdArgs.push_back("--disable-new-dtags");
@@ -1444,10 +1444,8 @@ void tools::addArchSpecificRPath(const ToolChain &TC, const ArgList &Args,
     CandidateRPaths.emplace_back(*CandidateRPath);
 
   for (const auto &CandidateRPath : CandidateRPaths) {
-    if (TC.getVFS().exists(CandidateRPath)) {
-      CmdArgs.push_back("-rpath");
-      CmdArgs.push_back(Args.MakeArgString(CandidateRPath));
-    }
+    if (TC.getVFS().exists(CandidateRPath))
+      addRPathCmdArg(Args, CmdArgs, CandidateRPath, /*onlyIfPathExists=*/false);
   }
 }
 

clang/test/CodeGen/amdgpu-builtin-is-invocable.c

@@ -28,7 +28,7 @@
 // AMDGCNSPIRV-LABEL: define spir_func void @foo(
 // AMDGCNSPIRV-SAME: ) addrspace(4) #[[ATTR0:[0-9]+]] {
 // AMDGCNSPIRV-NEXT:  [[ENTRY:.*:]]
-// AMDGCNSPIRV-NEXT:    [[TMP0:%.*]] = load volatile i1, ptr addrspace(1) @llvm.amdgcn.has.gfx10-insts, align 1
+// AMDGCNSPIRV-NEXT:    [[TMP0:%.*]] = load i1, ptr addrspace(1) @llvm.amdgcn.has.gfx10-insts, align 1
 // AMDGCNSPIRV-NEXT:    [[TOBOOL:%.*]] = icmp ne i1 [[TMP0]], false
 // AMDGCNSPIRV-NEXT:    br i1 [[TOBOOL]], label %[[IF_THEN:.*]], label %[[IF_END:.*]]
 // AMDGCNSPIRV:       [[IF_THEN]]: