[CIR] Backport UnaryExtension for AggregateExpr (#1948)

Backporting UnaryExtension for AggregateExpr from the upstream

Author: AmrDeveloper

clang/include/clang/Basic/LangOptions.def

@@ -400,6 +400,7 @@ LANGOPT(APINotesModules, 1, 0, NotCompatible, "use module-based external API not
 LANGOPT(SwiftVersionIndependentAPINotes, 1, 0, NotCompatible, "use external API notes capturing all versions")
 
 LANGOPT(CIRWarnings, 1, 0, NotCompatible, "emit warnings with ClangIR")
+LANGOPT(EmitCIRToFile, 1, 0, NotCompatible, "emit Clang IR to disk")
 
 LANGOPT(SanitizeAddressFieldPadding, 2, 0, NotCompatible, "controls how aggressive is ASan "
                                                       "field padding (0: none, 1:least "

clang/include/clang/Driver/Options.td

@@ -2933,6 +2933,7 @@ defm gnu89_inline : BoolFOption<"gnu89-inline",
           "Use the gnu89 inline semantics">,
   NegFlag<SetFalse>>, ShouldParseIf<!strconcat("!", cplusplus.KeyPath)>;
 def fgnu_runtime : Flag<["-"], "fgnu-runtime">, Group<f_Group>,
+  Visibility<[ClangOption, CC1Option]>,
   HelpText<"Generate output compatible with the standard GNU Objective-C runtime">;
 // This used to be a standalone flag but is now mapped to
 // -Wno-error=invalid-gnu-asm-cast, which is the only thing the flag used to
@@ -3155,13 +3156,16 @@ defm clangir : BoolFOption<"clangir",
   PosFlag<SetTrue, [], [ClangOption, CC1Option], "Use the ClangIR pipeline to compile">,
   NegFlag<SetFalse, [], [ClangOption, CC1Option], "Use the AST -> LLVM pipeline to compile">,
   BothFlags<[], [ClangOption, CC1Option], "">>;
-def fcir_output_EQ : Joined<["-"], "fcir-output=">,
+def fcir_output_EQ : Joined<["-"], "fcir-output=">, Group<f_Group>,
   Visibility<[ClangOption, CC1Option]>,
+  Flags<[NoArgumentUnused]>,
   HelpText<"Write Clang IR output to <file>">,
   MarshallingInfoString<LangOpts<"CIRFile">>;
-def fcir_output : Flag<["-"], "fcir-output">,
+def fcir_output : Flag<["-"], "fcir-output">, Group<f_Group>,
   Visibility<[ClangOption, CC1Option]>,
-  HelpText<"Write Clang IR output to <input>.cir">;
+  Flags<[NoArgumentUnused]>,
+  HelpText<"Write Clang IR output to <input>.cir">,
+  MarshallingInfoFlag<LangOpts<"EmitCIRToFile">>;
 defm cir_warnings : BoolFOption<"cir-warnings",
   LangOpts<"CIRWarnings">, DefaultFalse,
   PosFlag<SetTrue, [], [ClangOption, CC1Option], "Use">,

clang/include/clang/Frontend/CompilerInstance.h

@@ -22,6 +22,7 @@
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/BuryPointer.h"
 #include "llvm/Support/FileSystem.h"
@@ -193,6 +194,11 @@ class CompilerInstance : public ModuleLoader {
   /// Force an output buffer.
   std::unique_ptr<llvm::raw_pwrite_stream> OutputStream;
 
+  /// Diagnostics about VFS overlays that should be emitted after executing
+  /// the frontend action.
+  llvm::SmallVector<std::pair<diag::kind, std::string>, 4>
+      PendingVFSDiagnostics;
+
   CompilerInstance(const CompilerInstance &) = delete;
   void operator=(const CompilerInstance &) = delete;
 public:

clang/include/clang/Frontend/CompilerInvocation.h

@@ -391,12 +391,16 @@ createVFSFromCompilerInvocation(const CompilerInvocation &CI,
 
 IntrusiveRefCntPtr<llvm::vfs::FileSystem> createVFSFromCompilerInvocation(
     const CompilerInvocation &CI, DiagnosticsEngine &Diags,
-    IntrusiveRefCntPtr<llvm::vfs::FileSystem> BaseFS);
+    IntrusiveRefCntPtr<llvm::vfs::FileSystem> BaseFS,
+    llvm::SmallVectorImpl<std::pair<diag::kind, std::string>> *DelayedDiags =
+        nullptr);
 
 IntrusiveRefCntPtr<llvm::vfs::FileSystem>
 createVFSFromOverlayFiles(ArrayRef<std::string> VFSOverlayFiles,
                           DiagnosticsEngine &Diags,
-                          IntrusiveRefCntPtr<llvm::vfs::FileSystem> BaseFS);
+                          IntrusiveRefCntPtr<llvm::vfs::FileSystem> BaseFS,
+                          llvm::SmallVectorImpl<std::pair<diag::kind, std::string>>
+                              *DelayedDiags = nullptr);
 
 } // namespace clang
 

clang/include/clang/Frontend/FrontendOptions.h

@@ -443,6 +443,8 @@ class FrontendOptions {
   // Enable Clang IR analysis only pipeline that uses traditional codegen
   // pipeline.
   unsigned ClangIRAnalysisOnly : 1;
+  // Emit Clang IR to a side file.
+  unsigned EmitClangIRFile : 1;
   CodeCompleteOptions CodeCompleteOpts;
 
   /// Specifies the output format of the AST.
@@ -451,6 +453,7 @@ class FrontendOptions {
   std::string ClangIRLifetimeCheckOpts;
   std::string ClangIRIdiomRecognizerOpts;
   std::string ClangIRLibOptOpts;
+  std::string ClangIRFile;
 
   frontend::MLIRDialectKind MLIRTargetDialect = frontend::MLIR_CORE;
 
@@ -581,9 +584,10 @@ class FrontendOptions {
         EmitPrettySymbolGraphs(false), GenReducedBMI(false),
         UseClangIRPipeline(false), ClangIRDirectLowering(false),
         ClangIRDisablePasses(false), ClangIRDisableCIRVerifier(false),
-        ClangIRLifetimeCheck(false), ClangIRIdiomRecognizer(false),
-        ClangIRLibOpt(false), ClangIRCallConvLowering(true),
-        ClangIREnableMem2Reg(false), ClangIRAnalysisOnly(false),
+        ClangIRVerifyDiags(false), ClangIRLifetimeCheck(false),
+        ClangIRIdiomRecognizer(false), ClangIRLibOpt(false),
+        ClangIRCallConvLowering(true), ClangIREnableMem2Reg(false),
+        ClangIRAnalysisOnly(false), EmitClangIRFile(false),
         TimeTraceGranularity(500), TimeTraceVerbose(false) {}
 
   /// getInputKindForExtension - Return the appropriate input kind for a file

clang/lib/CIR/CodeGen/CIRGenExpr.cpp

@@ -2042,7 +2042,8 @@ LValue CIRGenFunction::emitCastLValue(const CastExpr *E) {
     assert(0 && "NYI");
   case CK_BaseToDerived: {
     const auto *derivedClassTy = E->getType()->castAs<RecordType>();
-    auto *derivedClassDecl = cast<CXXRecordDecl>(derivedClassTy->getDecl());
+    auto *derivedClassDecl =
+        cast<CXXRecordDecl>(derivedClassTy->getOriginalDecl());
 
     LValue lv = emitLValue(E->getSubExpr());
 

clang/lib/CIR/CodeGen/CIRGenExprAgg.cpp

@@ -186,7 +186,7 @@ class AggExprEmitter : public StmtVisitor<AggExprEmitter> {
   }
   void VisitCoyieldExpr(CoyieldExpr *E) { llvm_unreachable("NYI"); }
   void VisitUnaryCoawait(UnaryOperator *E) { llvm_unreachable("NYI"); }
-  void VisitUnaryExtension(UnaryOperator *E) { llvm_unreachable("NYI"); }
+  void VisitUnaryExtension(UnaryOperator *E) { Visit(E->getSubExpr()); }
   void VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E) {
     llvm_unreachable("NYI");
   }

clang/lib/CIR/FrontendAction/CIRGenAction.cpp

@@ -47,9 +47,11 @@
 #include "llvm/LTO/LTOBackend.h"
 #include "llvm/Linker/Linker.h"
 #include "llvm/Pass.h"
+#include "llvm/ADT/SmallString.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/SourceMgr.h"
+#include "llvm/Support/Path.h"
 #include "llvm/Support/TimeProfiler.h"
 #include "llvm/Support/Timer.h"
 #include "llvm/Support/ToolOutputFile.h"
@@ -118,6 +120,7 @@ class CIRGenConsumer : public clang::ASTConsumer {
   [[maybe_unused]] const LangOptions &langOptions;
   const FrontendOptions &feOptions;
 
+  std::string InputFileName;
   std::unique_ptr<raw_pwrite_stream> outputStream;
 
   ASTContext *astContext{nullptr};
@@ -133,13 +136,14 @@ class CIRGenConsumer : public clang::ASTConsumer {
                  CodeGenOptions &codeGenOptions,
                  const TargetOptions &targetOptions,
                  const LangOptions &langOptions,
-                 const FrontendOptions &feOptions,
+                 const FrontendOptions &feOptions, StringRef InputFile,
                  std::unique_ptr<raw_pwrite_stream> os)
       : action(action), compilerInstance(compilerInstance),
         diagnosticsEngine(diagnosticsEngine),
         headerSearchOptions(headerSearchOptions),
         codeGenOptions(codeGenOptions), targetOptions(targetOptions),
         langOptions(langOptions), feOptions(feOptions),
+        InputFileName(InputFile.str()),
         outputStream(std::move(os)), FS(VFS),
         gen(std::make_unique<CIRGenerator>(diagnosticsEngine, std::move(VFS),
                                            codeGenOptions)) {}
@@ -265,6 +269,50 @@ class CIRGenConsumer : public clang::ASTConsumer {
       }
     }
 
+    bool EmitCIR = langOptions.EmitCIRToFile || feOptions.EmitClangIRFile ||
+                   !langOptions.CIRFile.empty() ||
+                   !feOptions.ClangIRFile.empty();
+    if (EmitCIR) {
+      std::unique_ptr<raw_pwrite_stream> CIRStream;
+      llvm::SmallString<128> DefaultPath;
+      if (!feOptions.ClangIRFile.empty()) {
+        CIRStream = compilerInstance.createOutputFile(
+            feOptions.ClangIRFile,
+            /*Binary=*/false,
+            /*RemoveFileOnSignal=*/true,
+            /*UseTemporary=*/true);
+      } else if (!langOptions.CIRFile.empty()) {
+        CIRStream = compilerInstance.createOutputFile(
+            langOptions.CIRFile,
+            /*Binary=*/false,
+            /*RemoveFileOnSignal=*/true,
+            /*UseTemporary=*/true);
+      } else {
+        if (!feOptions.OutputFile.empty() && feOptions.OutputFile != "-") {
+          DefaultPath = feOptions.OutputFile;
+        } else if (!InputFileName.empty() && InputFileName != "-") {
+          DefaultPath = InputFileName;
+        } else if (!feOptions.Inputs.empty() && feOptions.Inputs[0].isFile() &&
+                   feOptions.Inputs[0].getFile() != "-") {
+          DefaultPath = feOptions.Inputs[0].getFile();
+        } else {
+          DefaultPath = "clangir-output";
+        }
+        llvm::sys::path::replace_extension(DefaultPath, "cir");
+        CIRStream = compilerInstance.createOutputFile(
+            DefaultPath,
+            /*Binary=*/false,
+            /*RemoveFileOnSignal=*/true,
+            /*UseTemporary=*/true);
+      }
+
+      if (CIRStream) {
+        mlir::OpPrintingFlags Flags;
+        Flags.enableDebugInfo(/*enable=*/true, /*prettyForm=*/false);
+        mlirMod->print(*CIRStream, Flags);
+      }
+    }
+
     auto emitMLIR = [&](mlir::Operation *mlirMod, bool verify) {
       assert(mlirMod &&
              "MLIR module does not exist, but lowering did not fail?");
@@ -399,7 +447,7 @@ CIRGenAction::CreateASTConsumer(CompilerInstance &ci, StringRef inputFile) {
   auto Result = std::make_unique<cir::CIRGenConsumer>(
       action, ci, ci.getDiagnostics(), &ci.getVirtualFileSystem(),
       ci.getHeaderSearchOpts(), ci.getCodeGenOpts(), ci.getTargetOpts(),
-      ci.getLangOpts(), ci.getFrontendOpts(), std::move(out));
+      ci.getLangOpts(), ci.getFrontendOpts(), inputFile, std::move(out));
   cgConsumer = Result.get();
 
   // Enable generating macro debug info only when debug info is not disabled and
@@ -507,7 +555,8 @@ AnalysisOnlyActionBase::CreateASTConsumer(clang::CompilerInstance &ci,
   Consumers.push_back(std::make_unique<cir::CIRGenConsumer>(
       CIRGenAction::OutputType::None, ci, ci.getDiagnostics(),
       &ci.getVirtualFileSystem(), ci.getHeaderSearchOpts(), ci.getCodeGenOpts(),
-      ci.getTargetOpts(), ci.getLangOpts(), ci.getFrontendOpts(), nullptr));
+      ci.getTargetOpts(), ci.getLangOpts(), ci.getFrontendOpts(), inFile,
+      nullptr));
   return std::make_unique<MultiplexConsumer>(std::move(Consumers));
 }
 

clang/lib/CodeGen/CGBuiltin.cpp

@@ -134,9 +134,28 @@ static Value *EmitTargetArchBuiltinExpr(CodeGenFunction *CGF,
   }
 }
 
+static bool isNonTSBuiltinDispatchedToTarget(unsigned BuiltinID) {
+  switch (BuiltinID) {
+  case Builtin::BI__builtin_cpu_supports:
+  case Builtin::BI__builtin_cpu_is:
+  case Builtin::BI__builtin_cpu_init:
+  case Builtin::BI__builtin_logbf:
+  case Builtin::BI__builtin_logb:
+  case Builtin::BI__builtin_scalbnf:
+  case Builtin::BI__builtin_scalbn:
+    return true;
+  default:
+    return false;
+  }
+}
+
 Value *CodeGenFunction::EmitTargetBuiltinExpr(unsigned BuiltinID,
                                               const CallExpr *E,
                                               ReturnValueSlot ReturnValue) {
+  if (!getContext().BuiltinInfo.isTSBuiltin(BuiltinID) &&
+      !isNonTSBuiltinDispatchedToTarget(BuiltinID))
+    return nullptr;
+
   if (getContext().BuiltinInfo.isAuxBuiltinID(BuiltinID)) {
     assert(getContext().getAuxTargetInfo() && "Missing aux target info");
     return EmitTargetArchBuiltinExpr(
@@ -2628,9 +2647,31 @@ RValue CodeGenFunction::EmitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
   // disable the specialized emitting below. Ideally we should communicate the
   // rename in IR, or at least avoid generating the intrinsic calls that are
   // likely to get lowered to the renamed library functions.
-  const unsigned BuiltinIDIfNoAsmLabel =
+  unsigned BuiltinIDIfNoAsmLabel =
       FD->hasAttr<AsmLabelAttr>() ? 0 : BuiltinID;
 
+  if (BuiltinIDIfNoAsmLabel) {
+    bool HasCustomTypeChecking =
+        llvm::StringRef(getContext().BuiltinInfo.getAttributesString(
+                            BuiltinIDIfNoAsmLabel))
+            .contains('t');
+    ASTContext::GetBuiltinTypeError Error;
+    QualType BuiltinTy =
+        getContext().GetBuiltinType(BuiltinIDIfNoAsmLabel, Error);
+    if (!Error && !HasCustomTypeChecking) {
+      if (const auto *Proto = BuiltinTy->getAs<FunctionProtoType>()) {
+        unsigned MinRequiredArgs = Proto->getNumParams();
+        unsigned GivenArgs = E->getNumArgs();
+        bool HasVariadic = Proto->isVariadic();
+        if ((!HasVariadic && GivenArgs != MinRequiredArgs) ||
+            (HasVariadic && GivenArgs < MinRequiredArgs)) {
+          BuiltinIDIfNoAsmLabel = 0;
+          BuiltinID = 0;
+        }
+      }
+    }
+  }
+
   std::optional<bool> ErrnoOverriden;
   // ErrnoOverriden is true if math-errno is overriden via the
   // '#pragma float_control(precise, on)'. This pragma disables fast-math,

clang/lib/CodeGen/CGExpr.cpp

@@ -6063,6 +6063,21 @@ static CGCallee EmitDirectCallee(CodeGenFunction &CGF, GlobalDecl GD) {
     }
   }
 
+  if (builtinID) {
+    ASTContext &Ctx = CGF.getContext();
+    if (Ctx.BuiltinInfo.isPredefinedLibFunction(builtinID) &&
+        !FD->getDeclContext()->isStdNamespace()) {
+      ASTContext::GetBuiltinTypeError Error;
+      QualType BuiltinTy = Ctx.GetBuiltinType(builtinID, Error);
+      if (!Error &&
+          !Ctx.hasSameFunctionTypeIgnoringExceptionSpec(
+              Ctx.getCanonicalType(BuiltinTy),
+              Ctx.getCanonicalType(FD->getType()))) {
+        builtinID = 0;
+      }
+    }
+  }
+
   if (builtinID) {
     std::string NoBuiltinFD = ("no-builtin-" + FD->getName()).str();
     std::string NoBuiltins = "no-builtins";