initial commit

Author: bruteforceboy

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

@@ -3991,7 +3991,8 @@ class CIR_CallOp<string mnemonic, list<Trait> extra_traits = []>
     DefaultValuedAttr<CIR_CallingConv, "CallingConv::C">:$calling_conv,
     DefaultValuedAttr<CIR_SideEffect, "SideEffect::All">:$side_effect,
     CIR_ExtraFuncAttr:$extra_attrs,
-    OptionalAttr<ASTCallExprInterface>:$ast
+    OptionalAttr<ASTCallExprInterface>:$ast,
+    OptionalAttr<ASTRecordDeclInterface>:$ast_record
   );
 }
 

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

@@ -61,5 +61,11 @@ def CIR_IterBeginOp: CIR_StdOp<"begin",
 def CIR_IterEndOp: CIR_StdOp<"end",
   (ins CIR_AnyType:$container),
   (outs CIR_AnyType:$result)>;
+def CIR_StdVectorCtorOp: CIR_StdOp<"vector_ctor",
+  (ins CIR_AnyType:$first),
+  (outs Optional<CIR_AnyType>:$result)>;
+def CIR_StdVectorDtorOp: CIR_StdOp<"vector_dtor",
+  (ins CIR_AnyType:$first),
+  (outs Optional<CIR_AnyType>:$result)>;
 
 #endif

clang/lib/CIR/CodeGen/CIRGenCall.cpp

@@ -424,7 +424,8 @@ RValue CIRGenFunction::emitCall(const CIRGenFunctionInfo &CallInfo,
                                 const CallArgList &CallArgs,
                                 cir::CIRCallOpInterface *callOrTryCall,
                                 bool IsMustTail, mlir::Location loc,
-                                std::optional<const clang::CallExpr *> E) {
+                                std::optional<const clang::CallExpr *> E,
+                                std::optional<const clang::RecordDecl *> RD) {
   auto builder = CGM.getBuilder();
   // FIXME: We no longer need the types from CallArgs; lift up and simplify
 
@@ -653,6 +654,10 @@ RValue CIRGenFunction::emitCall(const CIRGenFunctionInfo &CallInfo,
       callLikeOp->setAttr("ast",
                           cir::ASTCallExprAttr::get(&getMLIRContext(), *E));
 
+    if (RD)
+      callLikeOp->setAttr("ast_record",
+                          cir::ASTRecordDeclAttr::get(&getMLIRContext(), *RD));
+
     if (callOrTryCall)
       *callOrTryCall = callLikeOp;
     return callLikeOp;

clang/lib/CIR/CodeGen/CIRGenClass.cpp

@@ -2012,7 +2012,8 @@ void CIRGenFunction::emitCXXConstructorCall(
       Args, D, Type, ExtraArgs.Prefix, ExtraArgs.Suffix, PassPrototypeArgs);
   CIRGenCallee Callee = CIRGenCallee::forDirect(CalleePtr, GlobalDecl(D, Type));
   cir::CIRCallOpInterface C;
-  emitCall(Info, Callee, ReturnValueSlot(), Args, &C, false, getLoc(Loc));
+  emitCall(Info, Callee, ReturnValueSlot(), Args, &C, false, getLoc(Loc),
+           nullptr, ClassDecl);
 
   assert(CGM.getCodeGenOpts().OptimizationLevel == 0 ||
          ClassDecl->isDynamicClass() || Type == Ctor_Base ||

clang/lib/CIR/CodeGen/CIRGenExprCXX.cpp

@@ -1575,7 +1575,8 @@ RValue CIRGenFunction::emitCXXDestructorCall(GlobalDecl Dtor,
   return emitCall(CGM.getTypes().arrangeCXXStructorDeclaration(Dtor), Callee,
                   ReturnValueSlot(), Args, nullptr, CE && CE == MustTailCall,
                   CE ? getLoc(CE->getExprLoc())
-                     : getLoc(Dtor.getDecl()->getSourceRange()));
+                     : getLoc(Dtor.getDecl()->getSourceRange()),
+                  CE, DtorDecl->getParent());
 }
 
 /// Emit a call to an operator new or operator delete function, as implicitly

clang/lib/CIR/CodeGen/CIRGenFunction.h

@@ -1865,7 +1865,8 @@ class CIRGenFunction : public CIRGenTypeCache {
                   const CallArgList &Args,
                   cir::CIRCallOpInterface *callOrTryCall, bool IsMustTail,
                   mlir::Location loc,
-                  std::optional<const clang::CallExpr *> E = std::nullopt);
+                  std::optional<const clang::CallExpr *> E = std::nullopt,
+                  std::optional<const clang::RecordDecl *> RD = std::nullopt);
   RValue emitCall(const CIRGenFunctionInfo &CallInfo,
                   const CIRGenCallee &Callee, ReturnValueSlot ReturnValue,
                   const CallArgList &Args,

clang/lib/CIR/Dialect/Transforms/IdiomRecognizer.cpp

@@ -42,28 +42,66 @@ template <typename TargetOp> class StdRecognizer {
   template <size_t... Indices>
   static TargetOp buildCall(CIRBaseBuilderTy &builder, CallOp call,
                             std::index_sequence<Indices...>) {
-    return builder.create<TargetOp>(call.getLoc(), call.getResult().getType(),
-                                    call.getCalleeAttr(),
-                                    call.getOperand(Indices)...);
+    return builder.create<TargetOp>(
+        call.getLoc(),
+        (call.getResult() ? call.getResult().getType() : mlir::TypeRange{}),
+        call.getCalleeAttr(), call.getOperand(Indices)...);
   }
 
 public:
-  static bool raise(CallOp call, mlir::MLIRContext &context, bool remark) {
+  static FuncOp getCalleeFromSymbol(mlir::ModuleOp theModule,
+                                    llvm::StringRef name) {
+    auto global = mlir::SymbolTable::lookupSymbolIn(theModule, name);
+    assert(global && "expected to find symbol for function");
+    return dyn_cast<FuncOp>(global);
+  }
+
+  static bool isStdVector(const clang::CXXRecordDecl *RD) {
+    if (!RD || !RD->getDeclContext()->isStdNamespace())
+      return false;
+
+    if (RD->getDeclName().isIdentifier()) {
+      StringRef Name = RD->getName();
+      return Name == "vector";
+    }
+
+    return false;
+  }
+
+  static bool raise(mlir::ModuleOp theModule, CallOp call,
+                    mlir::MLIRContext &context, bool remark) {
     constexpr int numArgs = TargetOp::getNumArgs();
     if (call.getNumOperands() != numArgs)
       return false;
 
-    auto callExprAttr = call.getAstAttr();
-    llvm::StringRef stdFuncName = TargetOp::getFunctionName();
-    if (!callExprAttr || !callExprAttr.isStdFunctionCall(stdFuncName))
-      return false;
+    llvm::StringRef name = *call.getCallee();
+    auto calleeFunc = getCalleeFromSymbol(theModule, name);
 
-    if (!checkArguments(call.getArgOperands()))
-      return false;
+    llvm::StringRef stdFuncName = TargetOp::getFunctionName();
 
-    if (remark)
-      mlir::emitRemark(call.getLoc())
-          << "found call to std::" << stdFuncName << "()";
+    if (auto specialMember = calleeFunc.getCxxSpecialMemberAttr()) {
+      auto matches =
+          (stdFuncName == "vector_ctor" && isa<CXXCtorAttr>(specialMember)) ||
+          (stdFuncName == "vector_dtor" && isa<CXXDtorAttr>(specialMember));
+      if (!matches)
+        return false;
+
+      auto recordDeclAttr = call.getAstRecordAttr();
+      if (!recordDeclAttr ||
+          !isStdVector(cast<clang::CXXRecordDecl>(recordDeclAttr.getRawDecl())))
+        return false;
+    } else {
+      auto callExprAttr = call.getAstAttr();
+      if (!callExprAttr || !callExprAttr.isStdFunctionCall(stdFuncName))
+        return false;
+
+      if (!checkArguments(call.getArgOperands()))
+        return false;
+
+      if (remark)
+        mlir::emitRemark(call.getLoc())
+            << "found call to std::" << stdFuncName << "()";
+    }
 
     CIRBaseBuilderTy builder(context);
     builder.setInsertionPointAfter(call.getOperation());
@@ -194,12 +232,16 @@ void IdiomRecognizerPass::recognizeCall(CallOp call) {
 
   bool remark = opts.emitRemarkFoundCalls();
 
-  using StdFunctionsRecognizer = std::tuple<StdRecognizer<StdFindOp>>;
+  using StdFunctionsRecognizer =
+      std::tuple<StdRecognizer<StdFindOp>, StdRecognizer<StdVectorCtorOp>,
+                 StdRecognizer<StdVectorDtorOp>>;
 
   // MSVC requires explicitly capturing these variables.
   std::apply(
       [&, call, remark, this](auto... recognizers) {
-        (decltype(recognizers)::raise(call, this->getContext(), remark) || ...);
+        (decltype(recognizers)::raise(theModule, call, this->getContext(),
+                                      remark) ||
+         ...);
       },
       StdFunctionsRecognizer());
 }