merge main into amd-staging

Author: ronlieb

clang-tools-extra/clang-tidy/google/TodoCommentCheck.cpp

@@ -11,42 +11,102 @@
 #include "clang/Lex/Preprocessor.h"
 #include <optional>
 
-namespace clang::tidy::google::readability {
+namespace clang::tidy {
+
+namespace google::readability {
+
+enum class StyleKind { Parentheses, Hyphen };
+
+} // namespace google::readability
+
+template <> struct OptionEnumMapping<google::readability::StyleKind> {
+  static ArrayRef<std::pair<google::readability::StyleKind, StringRef>>
+  getEnumMapping() {
+    static constexpr std::pair<google::readability::StyleKind, StringRef>
+        Mapping[] = {
+            {google::readability::StyleKind::Hyphen, "Hyphen"},
+            {google::readability::StyleKind::Parentheses, "Parentheses"},
+        };
+    return {Mapping};
+  }
+};
+
+} // namespace clang::tidy
 
+namespace clang::tidy::google::readability {
 class TodoCommentCheck::TodoCommentHandler : public CommentHandler {
 public:
   TodoCommentHandler(TodoCommentCheck &Check, std::optional<std::string> User)
       : Check(Check), User(User ? *User : "unknown"),
-        TodoMatch("^// *TODO *(\\(.*\\))?:?( )?(.*)$") {}
+        TodoMatch(R"(^// *TODO *((\((.*)\))?:?( )?|: *(.*) *- *)?(.*)$)") {
+    const llvm::StringRef TodoStyleString =
+        Check.Options.get("Style", "Hyphen");
+    for (const auto &[Value, Name] :
+         OptionEnumMapping<StyleKind>::getEnumMapping()) {
+      if (Name == TodoStyleString) {
+        TodoStyle = Value;
+        return;
+      }
+    }
+    Check.configurationDiag(
+        "invalid value '%0' for "
+        "google-readability-todo.Style; valid values are "
+        "'Parentheses' and 'Hyphen'. Defaulting to 'Hyphen'")
+        << TodoStyleString;
+  }
 
   bool HandleComment(Preprocessor &PP, SourceRange Range) override {
     const StringRef Text =
         Lexer::getSourceText(CharSourceRange::getCharRange(Range),
                              PP.getSourceManager(), PP.getLangOpts());
 
-    SmallVector<StringRef, 4> Matches;
+    SmallVector<StringRef, 7> Matches;
     if (!TodoMatch.match(Text, &Matches))
       return false;
 
-    const StringRef Username = Matches[1];
-    const StringRef Comment = Matches[3];
+    const StyleKind ParsedStyle =
+        !Matches[3].empty() ? StyleKind::Parentheses : StyleKind::Hyphen;
+    const StringRef Username =
+        ParsedStyle == StyleKind::Parentheses ? Matches[3] : Matches[5];
+    const StringRef Comment = Matches[6];
 
-    if (!Username.empty())
+    if (!Username.empty() &&
+        (ParsedStyle == StyleKind::Parentheses || !Comment.empty())) {
       return false;
+    }
 
-    const std::string NewText =
-        ("// TODO(" + Twine(User) + "): " + Comment).str();
+    if (Username.empty()) {
+      Check.diag(Range.getBegin(), "missing username/bug in TODO")
+          << FixItHint::CreateReplacement(
+                 CharSourceRange::getCharRange(Range),
+                 createReplacementString(Username, Comment));
+    }
+
+    if (Comment.empty())
+      Check.diag(Range.getBegin(), "missing details in TODO");
 
-    Check.diag(Range.getBegin(), "missing username/bug in TODO")
-        << FixItHint::CreateReplacement(CharSourceRange::getCharRange(Range),
-                                        NewText);
     return false;
   }
 
+  std::string createReplacementString(const StringRef Username,
+                                      const StringRef Comment) const {
+    if (TodoStyle == StyleKind::Parentheses) {
+      return ("// TODO(" + Twine(User) +
+              "): " + (Comment.empty() ? "some details" : Comment))
+          .str();
+    }
+    return ("// TODO: " + Twine(User) + " - " +
+            (Comment.empty() ? "some details" : Comment))
+        .str();
+  }
+
+  StyleKind getTodoStyle() const { return TodoStyle; }
+
 private:
   TodoCommentCheck &Check;
   std::string User;
   llvm::Regex TodoMatch;
+  StyleKind TodoStyle = StyleKind::Hyphen;
 };
 
 TodoCommentCheck::TodoCommentCheck(StringRef Name, ClangTidyContext *Context)
@@ -62,4 +122,8 @@ void TodoCommentCheck::registerPPCallbacks(const SourceManager &SM,
   PP->addCommentHandler(Handler.get());
 }
 
+void TodoCommentCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
+  Options.store(Opts, "Style", Handler->getTodoStyle());
+}
+
 } // namespace clang::tidy::google::readability

clang-tools-extra/clang-tidy/google/TodoCommentCheck.h

@@ -27,6 +27,8 @@ class TodoCommentCheck : public ClangTidyCheck {
   void registerPPCallbacks(const SourceManager &SM, Preprocessor *PP,
                            Preprocessor *ModuleExpanderPP) override;
 
+  void storeOptions(ClangTidyOptions::OptionMap &Opts) override;
+
 private:
   class TodoCommentHandler;
   std::unique_ptr<TodoCommentHandler> Handler;

clang-tools-extra/docs/ReleaseNotes.rst

@@ -406,6 +406,10 @@ Changes in existing checks
   <clang-tidy/checks/google/readability-casting>` check by adding fix-it
   notes for downcasts.
 
+- Improved :doc:`google-readability-todo
+  <clang-tidy/checks/google/readability-todo>` check to accept the new TODO
+  format from the Google Style Guide.
+
 - Improved :doc:`llvm-prefer-isa-or-dyn-cast-in-conditionals
   <clang-tidy/checks/llvm/prefer-isa-or-dyn-cast-in-conditionals>` check:
 

clang-tools-extra/docs/clang-tidy/checks/google/readability-todo.rst

@@ -9,3 +9,14 @@ The relevant style guide section is
 https://google.github.io/styleguide/cppguide.html#TODO_Comments.
 
 Corresponding cpplint.py check: `readability/todo`
+
+Options
+-------
+
+.. option:: Style
+
+   A string specifying the TODO style for fix-it hints. Accepted values are
+   `Hyphen` and `Parentheses`. Default is `Hyphen`.
+
+   * `Hyphen` will format the fix-it as: ``// TODO: username - details``.
+   * `Parentheses` will format the fix-it as: ``// TODO(username): details``.

clang-tools-extra/test/clang-tidy/checkers/google/readability-todo-hyphen.cpp

@@ -0,0 +1,40 @@
+// RUN: %check_clang_tidy %s google-readability-todo %t -- -config="{User: 'some user'}" --
+
+//   TODOfix this1
+// CHECK-MESSAGES: [[@LINE-1]]:1: warning: missing username/bug in TODO
+// CHECK-FIXES: // TODO: some user - fix this1
+
+//   TODO fix this2
+// CHECK-MESSAGES: [[@LINE-1]]:1: warning: missing username/bug in TODO
+// CHECK-FIXES: // TODO: some user - fix this2
+
+// TODO fix this3
+// CHECK-MESSAGES: [[@LINE-1]]:1: warning: missing username/bug in TODO
+// CHECK-FIXES: // TODO: some user - fix this3
+
+// TODO: fix this4
+// CHECK-MESSAGES: [[@LINE-1]]:1: warning: missing username/bug in TODO
+// CHECK-FIXES: // TODO: some user - fix this4
+
+// TODO: bug 12345 -
+// CHECK-MESSAGES: [[@LINE-1]]:1: warning: missing details in TODO
+
+// TODO: a message without a reference
+// CHECK-MESSAGES: [[@LINE-1]]:1: warning: missing username/bug in TODO
+// CHECK-FIXES: // TODO: some user - a message without a reference
+
+//   TODO(clang)fix this5
+
+// TODO: foo - shave yaks
+// TODO:foo - no space bewteen semicolon and username
+// TODO: foo- no space bewteen username and dash
+// TODO:    foo - extra spaces between semicolon and username
+// TODO: foo   - extra spaces between username and dash
+// TODO: b/12345 - use a b/ prefix
+// TODO: bug 12345 - use a space in username/bug reference
+// TODO(foo):shave yaks
+// TODO(bar):
+// TODO(foo): paint bikeshed
+// TODO(b/12345): find the holy grail
+// TODO (b/12345): allow spaces before parentheses
+// TODO(asdf) allow missing semicolon

clang-tools-extra/test/clang-tidy/checkers/google/readability-todo.cpp renamed to clang-tools-extra/test/clang-tidy/checkers/google/readability-todo-parentheses.cpp

@@ -1,4 +1,4 @@
-// RUN: %check_clang_tidy %s google-readability-todo %t -- -config="{User: 'some user'}" --
+// RUN: %check_clang_tidy %s google-readability-todo %t -- -config="{User: 'some user', CheckOptions: {google-readability-todo.Style: 'Parentheses'}}" --
 
 //   TODOfix this1
 // CHECK-MESSAGES: [[@LINE-1]]:1: warning: missing username/bug in TODO
@@ -16,8 +16,22 @@
 // CHECK-MESSAGES: [[@LINE-1]]:1: warning: missing username/bug in TODO
 // CHECK-FIXES: // TODO(some user): fix this4
 
+// TODO: bug 12345 -
+// CHECK-MESSAGES: [[@LINE-1]]:1: warning: missing details in TODO
+
+// TODO: a message without a reference
+// CHECK-MESSAGES: [[@LINE-1]]:1: warning: missing username/bug in TODO
+// CHECK-FIXES: // TODO(some user): a message without a reference
+
 //   TODO(clang)fix this5
 
+// TODO: foo - shave yaks
+// TODO:foo - no space bewteen semicolon and username
+// TODO: foo- no space bewteen username and dash
+// TODO:    foo - extra spaces between semicolon and username
+// TODO: foo   - extra spaces between username and dash
+// TODO: b/12345 - use a b/ prefix
+// TODO: bug 12345 - use a space in username/bug reference
 // TODO(foo):shave yaks
 // TODO(bar):
 // TODO(foo): paint bikeshed

clang/include/clang/CIR/Dialect/IR/CIROps.td

@@ -413,6 +413,18 @@ def CIR_ConstantOp : CIR_Op<"const", [
 
     template <typename T>
     T getValueAttr() { return mlir::dyn_cast<T>(getValue()); }
+
+    llvm::APInt getIntValue() {
+      if (const auto intAttr = getValueAttr<cir::IntAttr>())
+        return intAttr.getValue();
+      llvm_unreachable("Expected an IntAttr in ConstantOp");
+    }
+
+    bool getBoolValue() {
+      if (const auto boolAttr = getValueAttr<cir::BoolAttr>())
+        return boolAttr.getValue();
+      llvm_unreachable("Expected a BoolAttr in ConstantOp");
+    }
   }];
 
   let hasFolder = 1;
@@ -2579,6 +2591,39 @@ def CIR_FuncOp : CIR_Op<"func", [
   }];
 }
 
+//===----------------------------------------------------------------------===//
+// LLVMIntrinsicCallOp
+//===----------------------------------------------------------------------===//
+
+def CIR_LLVMIntrinsicCallOp : CIR_Op<"call_llvm_intrinsic"> {
+  let summary = "Call to llvm intrinsic functions that is not defined in CIR";
+  let description = [{
+    `cir.call_llvm_intrinsic` operation represents a call-like expression which has
+    return type and arguments that maps directly to a llvm intrinsic.
+    It only records intrinsic `intrinsic_name`.
+  }];
+
+  let results = (outs Optional<CIR_AnyType>:$result);
+  let arguments = (ins
+                   StrAttr:$intrinsic_name, Variadic<CIR_AnyType>:$arg_ops);
+
+  let skipDefaultBuilders = 1;
+
+  let assemblyFormat = [{
+    $intrinsic_name $arg_ops `:` functional-type($arg_ops, $result) attr-dict
+  }];
+
+  let builders = [
+    OpBuilder<(ins "mlir::StringAttr":$intrinsic_name, "mlir::Type":$resType,
+              CArg<"mlir::ValueRange", "{}">:$operands), [{
+      $_state.addAttribute("intrinsic_name", intrinsic_name);
+      $_state.addOperands(operands);
+      if (resType)
+        $_state.addTypes(resType);
+    }]>,
+  ];
+}
+
 //===----------------------------------------------------------------------===//
 // CallOp
 //===----------------------------------------------------------------------===//

clang/include/clang/CIR/MissingFeatures.h

@@ -274,6 +274,7 @@ struct MissingFeatures {
   static bool innermostEHScope() { return false; }
   static bool insertBuiltinUnpredictable() { return false; }
   static bool instrumentation() { return false; }
+  static bool intrinsicElementTypeSupport() { return false; }
   static bool intrinsics() { return false; }
   static bool isMemcpyEquivalentSpecialMember() { return false; }
   static bool isTrivialCtorOrDtor() { return false; }

clang/lib/CIR/CodeGen/CIRGenBuiltinX86.cpp

@@ -21,6 +21,19 @@
 using namespace clang;
 using namespace clang::CIRGen;
 
+template <typename... Operands>
+static mlir::Value emitIntrinsicCallOp(CIRGenFunction &cgf, const CallExpr *e,
+                                       const std::string &str,
+                                       const mlir::Type &resTy,
+                                       Operands &&...op) {
+  CIRGenBuilderTy &builder = cgf.getBuilder();
+  mlir::Location location = cgf.getLoc(e->getExprLoc());
+  return cir::LLVMIntrinsicCallOp::create(builder, location,
+                                          builder.getStringAttr(str), resTy,
+                                          std::forward<Operands>(op)...)
+      .getResult();
+}
+
 mlir::Value CIRGenFunction::emitX86BuiltinExpr(unsigned builtinID,
                                                const CallExpr *e) {
   if (builtinID == Builtin::BI__builtin_cpu_is) {
@@ -43,15 +56,37 @@ mlir::Value CIRGenFunction::emitX86BuiltinExpr(unsigned builtinID,
   // Find out if any arguments are required to be integer constant expressions.
   assert(!cir::MissingFeatures::handleBuiltinICEArguments());
 
+  // The operands of the builtin call
+  llvm::SmallVector<mlir::Value> ops;
+
+  // `ICEArguments` is a bitmap indicating whether the argument at the i-th bit
+  // is required to be a constant integer expression.
+  unsigned iceArguments = 0;
+  ASTContext::GetBuiltinTypeError error;
+  getContext().GetBuiltinType(builtinID, error, &iceArguments);
+  assert(error == ASTContext::GE_None && "Error while getting builtin type.");
+
+  for (auto [idx, arg] : llvm::enumerate(e->arguments())) {
+    ops.push_back(emitScalarOrConstFoldImmArg(iceArguments, idx, arg));
+  }
+
+  CIRGenBuilderTy &builder = getBuilder();
+  mlir::Type voidTy = builder.getVoidTy();
+
   switch (builtinID) {
   default:
     return {};
-  case X86::BI_mm_prefetch:
   case X86::BI_mm_clflush:
+    return emitIntrinsicCallOp(*this, e, "x86.sse2.clflush", voidTy, ops[0]);
   case X86::BI_mm_lfence:
+    return emitIntrinsicCallOp(*this, e, "x86.sse2.lfence", voidTy);
   case X86::BI_mm_pause:
+    return emitIntrinsicCallOp(*this, e, "x86.sse2.pause", voidTy);
   case X86::BI_mm_mfence:
+    return emitIntrinsicCallOp(*this, e, "x86.sse2.mfence", voidTy);
   case X86::BI_mm_sfence:
+    return emitIntrinsicCallOp(*this, e, "x86.sse.sfence", voidTy);
+  case X86::BI_mm_prefetch:
   case X86::BI__rdtsc:
   case X86::BI__builtin_ia32_rdtscp:
   case X86::BI__builtin_ia32_lzcnt_u16:

clang/lib/CIR/CodeGen/CIRGenExprCXX.cpp

@@ -708,6 +708,13 @@ void CIRGenFunction::emitCXXDeleteExpr(const CXXDeleteExpr *e) {
   deleteTy = getContext().getBaseElementType(deleteTy);
   ptr = ptr.withElementType(builder, convertTypeForMem(deleteTy));
 
+  if (e->isArrayForm() &&
+      cgm.getASTContext().getTargetInfo().emitVectorDeletingDtors(
+          cgm.getASTContext().getLangOpts())) {
+    cgm.errorNYI(e->getSourceRange(),
+                 "emitCXXDeleteExpr: emitVectorDeletingDtors");
+  }
+
   if (e->isArrayForm()) {
     assert(!cir::MissingFeatures::deleteArray());
     cgm.errorNYI(e->getSourceRange(), "emitCXXDeleteExpr: array delete");