Merged main:602e47c5f9fd into amd-gfx:f337c8eadcf3

Local branch amd-gfx f337c8e Merged main:f8f934e22c4a into amd-gfx:bd63dc7b6e97
Remote branch main 602e47c [lldb] Format Python files in scripts and utils (llvm#66053)

Author: SC llvm team

.github/workflows/pr-subscriber-wait.py

@@ -0,0 +1,27 @@
+import github
+import os
+import sys
+import time
+
+
+def needs_to_wait(repo):
+    workflow_name = os.environ.get("GITHUB_WORKFLOW")
+    run_number = os.environ.get("GITHUB_RUN_NUMBER")
+    print("Workflow Name:", workflow_name, "Run Number:", run_number)
+    for status in ["in_progress", "queued"]:
+        for workflow in repo.get_workflow_runs(status=status):
+            print("Looking at ", workflow.name, "#", workflow.run_number)
+            if workflow.name != workflow_name:
+                continue
+            if workflow.run_number < int(run_number):
+                print("Workflow {} still {} ".format(workflow.run_number, status))
+                return True
+    return False
+
+
+repo_name = os.environ.get("GITHUB_REPOSITORY")
+token = os.environ.get("GITHUB_TOKEN")
+gh = github.Github(token)
+repo = gh.get_repo(repo_name)
+while needs_to_wait(repo):
+    time.sleep(30)

.github/workflows/pr-subscriber.yml

@@ -7,16 +7,9 @@ on:
       - completed
 
 permissions:
+  actions: read
   contents: read
 
-concurrency:
-  # Ideally, we would use the PR number in the concurrency group, but we don't
-  # have access to it here.  We need to ensure only one job is running for
-  # each PR at a time, because there is a potential race condition when
-  # updating the issue comment.
-  group: "PR Subscriber"
-  cancel-in-progress: false
-
 jobs:
   auto-subscribe:
     runs-on: ubuntu-latest
@@ -25,6 +18,23 @@ jobs:
       github.event.workflow_run.event == 'pull_request' &&
       github.event.workflow_run.conclusion == 'success'
     steps:
+      - name: Setup Automation Script
+        run: |
+          curl -O -L https://raw.githubusercontent.com/"$GITHUB_REPOSITORY"/main/llvm/utils/git/github-automation.py
+          curl -O -L https://raw.githubusercontent.com/"$GITHUB_REPOSITORY"/main/llvm/utils/git/requirements.txt
+          curl -O -L https://raw.githubusercontent.com/"$GITHUB_REPOSITORY"/main/.github/workflows/pr-subscriber-wait.py
+          chmod a+x github-automation.py
+          pip install -r requirements.txt
+
+      - name: 'Wait for other actions'
+        # We can't use the concurrency tag for these jobs, because it will
+        # cancel pending jobs if another job is running.
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          python3 pr-subscriber-wait.py
+
+
       # From: https://securitylab.github.com/research/github-actions-preventing-pwn-requests/
       # Updated version here: https://docs.github.com/en/actions/using-workflows/events-that-trigger-workflows#using-data-from-the-triggering-workflow
       - name: 'Download artifact'
@@ -50,13 +60,6 @@ jobs:
 
       - run: unzip pr.zip
 
-      - name: Setup Automation Script
-        run: |
-          curl -O -L https://raw.githubusercontent.com/"$GITHUB_REPOSITORY"/main/llvm/utils/git/github-automation.py
-          curl -O -L https://raw.githubusercontent.com/"$GITHUB_REPOSITORY"/main/llvm/utils/git/requirements.txt
-          chmod a+x github-automation.py
-          pip install -r requirements.txt
-
       - name: Update watchers
         # https://docs.github.com/en/actions/security-guides/security-hardening-for-github-actions#using-an-intermediate-environment-variable
         run: |

clang/lib/AST/ExprConstant.cpp

@@ -6062,8 +6062,9 @@ const AccessKinds StartLifetimeOfUnionMemberHandler::AccessKind;
 /// operator whose left-hand side might involve a union member access. If it
 /// does, implicitly start the lifetime of any accessed union elements per
 /// C++20 [class.union]5.
-static bool HandleUnionActiveMemberChange(EvalInfo &Info, const Expr *LHSExpr,
-                                          const LValue &LHS) {
+static bool MaybeHandleUnionActiveMemberChange(EvalInfo &Info,
+                                               const Expr *LHSExpr,
+                                               const LValue &LHS) {
   if (LHS.InvalidBase || LHS.Designator.Invalid)
     return false;
 
@@ -6118,8 +6119,14 @@ static bool HandleUnionActiveMemberChange(EvalInfo &Info, const Expr *LHSExpr,
         break;
       // Walk path backwards as we walk up from the base to the derived class.
       for (const CXXBaseSpecifier *Elt : llvm::reverse(ICE->path())) {
+        if (Elt->isVirtual()) {
+          // A class with virtual base classes never has a trivial default
+          // constructor, so S(E) is empty in this case.
+          E = nullptr;
+          break;
+        }
+
         --PathLength;
-        (void)Elt;
         assert(declaresSameEntity(Elt->getType()->getAsCXXRecordDecl(),
                                   LHS.Designator.Entries[PathLength]
                                       .getAsBaseOrMember().getPointer()));
@@ -7806,7 +7813,7 @@ class ExprEvaluatorBase
         // per C++20 [class.union]5.
         if (Info.getLangOpts().CPlusPlus20 && OCE &&
             OCE->getOperator() == OO_Equal && MD->isTrivial() &&
-            !HandleUnionActiveMemberChange(Info, Args[0], ThisVal))
+            !MaybeHandleUnionActiveMemberChange(Info, Args[0], ThisVal))
           return false;
 
         Args = Args.slice(1);
@@ -8679,7 +8686,7 @@ bool LValueExprEvaluator::VisitBinAssign(const BinaryOperator *E) {
     return false;
 
   if (Info.getLangOpts().CPlusPlus20 &&
-      !HandleUnionActiveMemberChange(Info, E->getLHS(), Result))
+      !MaybeHandleUnionActiveMemberChange(Info, E->getLHS(), Result))
     return false;
 
   return handleAssignment(this->Info, E, Result, E->getLHS()->getType(),

clang/lib/AST/Interp/ByteCodeExprGen.cpp

@@ -634,8 +634,14 @@ bool ByteCodeExprGen<Emitter>::VisitSubstNonTypeTemplateParmExpr(
 
 template <class Emitter>
 bool ByteCodeExprGen<Emitter>::VisitConstantExpr(const ConstantExpr *E) {
-  // TODO: Check if the ConstantExpr already has a value set and if so,
-  //   use that instead of evaluating it again.
+  // Try to emit the APValue directly, without visiting the subexpr.
+  // This will only fail if we can't emit the APValue, so won't emit any
+  // diagnostics or any double values.
+  std::optional<PrimType> T = classify(E->getType());
+  if (T && E->hasAPValueResult() &&
+      this->visitAPValue(E->getAPValueResult(), *T, E))
+    return true;
+
   return this->delegate(E->getSubExpr());
 }
 

clang/lib/Format/TokenAnnotator.cpp

@@ -2598,9 +2598,12 @@ class AnnotatingParser {
     if (InTemplateArgument && NextToken->Tok.isAnyIdentifier())
       return TT_BinaryOperator;
 
-    // "&&(" is quite unlikely to be two successive unary "&".
-    if (Tok.is(tok::ampamp) && NextToken->is(tok::l_paren))
+    // "&&" followed by "(", "*", or "&" is quite unlikely to be two successive
+    // unary "&".
+    if (Tok.is(tok::ampamp) &&
+        NextToken->isOneOf(tok::l_paren, tok::star, tok::amp)) {
       return TT_BinaryOperator;
+    }
 
     // This catches some cases where evaluation order is used as control flow:
     //   aaa && aaa->f();

clang/test/Preprocessor/riscv-target-features.c

@@ -643,7 +643,7 @@
 // RUN: %clang -target riscv64-unknown-linux-gnu \
 // RUN: -march=rv64izicntr -x c -E -dM %s \
 // RUN: -o - | FileCheck --check-prefix=CHECK-ZICNTR-EXT %s
-// CHECK-ZICNTR-EXT: __riscv_zicntr 1000000{{$}}
+// CHECK-ZICNTR-EXT: __riscv_zicntr 2000000{{$}}
 
 // RUN: %clang -target riscv32-unknown-linux-gnu \
 // RUN: -march=rv32izicsr2p0 -x c -E -dM %s \
@@ -677,6 +677,14 @@
 // RUN: -o - | FileCheck --check-prefix=CHECK-ZIHINTPAUSE-EXT %s
 // CHECK-ZIHINTPAUSE-EXT: __riscv_zihintpause 2000000{{$}}
 
+// RUN: %clang -target riscv32-unknown-linux-gnu \
+// RUN: -march=rv32izihpm -x c -E -dM %s \
+// RUN: -o - | FileCheck --check-prefix=CHECK-ZIHPM-EXT %s
+// RUN: %clang -target riscv64-unknown-linux-gnu \
+// RUN: -march=rv64izihpm -x c -E -dM %s \
+// RUN: -o - | FileCheck --check-prefix=CHECK-ZIHPM-EXT %s
+// CHECK-ZIHPM-EXT: __riscv_zihpm 2000000{{$}}
+
 // RUN: %clang -target riscv32-unknown-linux-gnu \
 // RUN: -march=rv32izk1p0 -x c -E -dM %s \
 // RUN: -o - | FileCheck --check-prefix=CHECK-ZK-EXT %s

clang/test/SemaCXX/cxx2a-virtual-base-used.cpp

@@ -0,0 +1,13 @@
+// RUN: %clang_cc1 -std=c++2a -verify -triple=x86_64-linux-gnu %s
+// expected-no-diagnostics
+
+// Fixes assertion triggered by https://github.com/llvm/llvm-project/issues/65982
+
+struct A { int y; };
+struct B : virtual public A {};
+struct X : public B {};
+
+void member_with_virtual_inheritance() {
+  X x;
+  x.B::y = 1;
+}

clang/unittests/Format/TokenAnnotatorTest.cpp

@@ -280,6 +280,12 @@ TEST_F(TokenAnnotatorTest, UnderstandsUsesOfStarAndAmp) {
   EXPECT_TOKEN(Tokens[12], tok::ampamp, TT_BinaryOperator);
   EXPECT_TOKEN(Tokens[27], tok::ampamp, TT_BinaryOperator);
 
+  Tokens = annotate("foo = *i < *j && *j > *k;");
+  EXPECT_EQ(Tokens.size(), 15u) << Tokens;
+  EXPECT_TOKEN(Tokens[4], tok::less, TT_BinaryOperator);
+  EXPECT_TOKEN(Tokens[7], tok::ampamp, TT_BinaryOperator);
+  EXPECT_TOKEN(Tokens[10], tok::greater, TT_BinaryOperator);
+
   FormatStyle Style = getLLVMStyle();
   Style.TypeNames.push_back("MYI");
   Tokens = annotate("if (MYI *p{nullptr})", Style);

lldb/scripts/analyze-project-deps.py

@@ -10,12 +10,21 @@
 from use_lldb_suite import lldb_root
 
 parser = argparse.ArgumentParser(
-    description='Analyze LLDB project #include dependencies.')
-parser.add_argument('--show-counts', default=False, action='store_true', 
-    help='When true, show the number of dependencies from each subproject')
-parser.add_argument('--discover-cycles', default=False, action='store_true',
-    help='When true, find and display all project dependency cycles.  Note,'
-         'this option is very slow')
+    description="Analyze LLDB project #include dependencies."
+)
+parser.add_argument(
+    "--show-counts",
+    default=False,
+    action="store_true",
+    help="When true, show the number of dependencies from each subproject",
+)
+parser.add_argument(
+    "--discover-cycles",
+    default=False,
+    action="store_true",
+    help="When true, find and display all project dependency cycles.  Note,"
+    "this option is very slow",
+)
 
 args = parser.parse_args()
 
@@ -24,12 +33,14 @@
 
 src_map = {}
 
-include_regex = re.compile('#include \"((lldb|Plugins|clang)(.*/)+).*\"')
+include_regex = re.compile('#include "((lldb|Plugins|clang)(.*/)+).*"')
+
 
 def is_sublist(small, big):
     it = iter(big)
     return all(c in it for c in small)
 
+
 def normalize_host(str):
     if str.startswith("lldb/Host"):
         return "lldb/Host"
@@ -39,6 +50,7 @@ def normalize_host(str):
         return str.replace("lldb/../../source", "lldb")
     return str
 
+
 def scan_deps(this_dir, file):
     global src_map
     deps = {}
@@ -62,7 +74,8 @@ def scan_deps(this_dir, file):
     if this_dir not in src_map and len(deps) > 0:
         src_map[this_dir] = deps
 
-for (base, dirs, files) in os.walk(inc_dir):
+
+for base, dirs, files in os.walk(inc_dir):
     dir = os.path.basename(base)
     relative = os.path.relpath(base, inc_dir)
     inc_files = [x for x in files if os.path.splitext(x)[1] in [".h"]]
@@ -71,7 +84,7 @@ def scan_deps(this_dir, file):
         inc_path = os.path.join(base, inc)
         scan_deps(relative, inc_path)
 
-for (base, dirs, files) in os.walk(src_dir):
+for base, dirs, files in os.walk(src_dir):
     dir = os.path.basename(base)
     relative = os.path.relpath(base, src_dir)
     src_files = [x for x in files if os.path.splitext(x)[1] in [".cpp", ".h", ".mm"]]
@@ -82,6 +95,7 @@ def scan_deps(this_dir, file):
         scan_deps(norm_base_path, src_path)
     pass
 
+
 def is_existing_cycle(path, cycles):
     # If we have a cycle like # A -> B -> C (with an implicit -> A at the end)
     # then we don't just want to check for an occurrence of A -> B -> C in the
@@ -90,12 +104,13 @@ def is_existing_cycle(path, cycles):
     # at the end), then A -> B -> C is also a cycle.  This is an important
     # optimization which reduces the search space by multiple orders of
     # magnitude.
-    for i in range(0,len(path)):
+    for i in range(0, len(path)):
         if any(is_sublist(x, path) for x in cycles):
             return True
         path = [path[-1]] + path[0:-1]
     return False
 
+
 def expand(path_queue, path_lengths, cycles, src_map):
     # We do a breadth first search, to make sure we visit all paths in order
     # of ascending length.  This is an important optimization to make sure that
@@ -127,54 +142,57 @@ def expand(path_queue, path_lengths, cycles, src_map):
             path_queue.append(cur_path + [item])
     pass
 
+
 cycles = []
 
 path_queue = [[x] for x in iter(src_map)]
 path_lens = [1] * len(path_queue)
 
 items = list(src_map.items())
-items.sort(key = lambda A : A[0])
+items.sort(key=lambda A: A[0])
 
-for (path, deps) in items:
+for path, deps in items:
     print(path + ":")
     sorted_deps = list(deps.items())
     if args.show_counts:
-        sorted_deps.sort(key = lambda A: (A[1], A[0]))
+        sorted_deps.sort(key=lambda A: (A[1], A[0]))
         for dep in sorted_deps:
             print("\t{} [{}]".format(dep[0], dep[1]))
     else:
-        sorted_deps.sort(key = lambda A: A[0])
+        sorted_deps.sort(key=lambda A: A[0])
         for dep in sorted_deps:
             print("\t{}".format(dep[0]))
 
+
 def iter_cycles(cycles):
     global src_map
     for cycle in cycles:
         cycle.append(cycle[0])
         zipper = list(zip(cycle[0:-1], cycle[1:]))
-        result = [(x, src_map[x][y], y) for (x,y) in zipper]
+        result = [(x, src_map[x][y], y) for (x, y) in zipper]
         total = 0
         smallest = result[0][1]
-        for (first, value, last) in result:
+        for first, value, last in result:
             total += value
             smallest = min(smallest, value)
         yield (total, smallest, result)
 
+
 if args.discover_cycles:
     print("Analyzing cycles...")
 
     expand(path_queue, path_lens, cycles, src_map)
 
-    average = sum([len(x)+1 for x in cycles]) / len(cycles)
+    average = sum([len(x) + 1 for x in cycles]) / len(cycles)
 
     print("Found {} cycles.  Average cycle length = {}.".format(len(cycles), average))
     counted = list(iter_cycles(cycles))
     if args.show_counts:
-        counted.sort(key = lambda A: A[0])
-        for (total, smallest, cycle) in counted:
+        counted.sort(key=lambda A: A[0])
+        for total, smallest, cycle in counted:
             sys.stdout.write("{} deps to break: ".format(total))
             sys.stdout.write(cycle[0][0])
-            for (first, count, last) in cycle:
+            for first, count, last in cycle:
                 sys.stdout.write(" [{}->] {}".format(count, last))
             sys.stdout.write("\n")
     else:
@@ -186,8 +204,8 @@ def iter_cycles(cycles):
     islands = []
     outgoing_counts = defaultdict(int)
     incoming_counts = defaultdict(int)
-    for (total, smallest, cycle) in counted:
-        for (first, count, last) in cycle:
+    for total, smallest, cycle in counted:
+        for first, count, last in cycle:
             outgoing_counts[first] += count
             incoming_counts[last] += count
     for cycle in cycles:
@@ -201,8 +219,8 @@ def iter_cycles(cycles):
         sorted = []
         for node in island:
             sorted.append((node, incoming_counts[node], outgoing_counts[node]))
-        sorted.sort(key = lambda x: x[1]+x[2])
-        for (node, inc, outg) in sorted:
+        sorted.sort(key=lambda x: x[1] + x[2])
+        for node, inc, outg in sorted:
             print("  {} [{} in, {} out]".format(node, inc, outg))
     sys.stdout.flush()
 pass