Follow-up and cleanup of simple function upstreaming

Author: dkolsen-pgi

clang/lib/CIR/CodeGen/CIRGenFunction.cpp

@@ -102,11 +102,10 @@ mlir::Location CIRGenFunction::getLoc(SourceLocation srcLoc) {
     StringRef filename = pLoc.getFilename();
     return mlir::FileLineColLoc::get(builder.getStringAttr(filename),
                                      pLoc.getLine(), pLoc.getColumn());
-  } else {
-    // Do our best...
-    assert(currSrcLoc && "expected to inherit some source location");
-    return *currSrcLoc;
   }
+  // Do our best...
+  assert(currSrcLoc && "expected to inherit some source location");
+  return *currSrcLoc;
 }
 
 mlir::Location CIRGenFunction::getLoc(SourceRange srcLoc) {
@@ -118,10 +117,10 @@ mlir::Location CIRGenFunction::getLoc(SourceRange srcLoc) {
     SmallVector<mlir::Location, 2> locs = {beg, end};
     mlir::Attribute metadata;
     return mlir::FusedLoc::get(locs, metadata, &getMLIRContext());
-  } else if (currSrcLoc) {
+  }
+  if (currSrcLoc) {
     return *currSrcLoc;
   }
-
   // We're brave, but time to give up.
   return builder.getUnknownLoc();
 }
@@ -168,15 +167,33 @@ cir::FuncOp CIRGenFunction::generateCode(clang::GlobalDecl gd, cir::FuncOp fn,
   SourceLocRAIIObject fnLoc{*this, loc.isValid() ? getLoc(loc)
                                                  : builder.getUnknownLoc()};
 
-  mlir::Block *entryBB = fn.addEntryBlock();
-  builder.setInsertionPointToStart(entryBB);
+  // This will be used once more code is upstreamed.
+  [[maybe_unused]] mlir::Block *entryBB = fn.addEntryBlock();
 
   startFunction(gd, funcDecl->getReturnType(), fn, funcType, loc,
                 bodyRange.getBegin());
-  if (mlir::failed(emitFunctionBody(body))) {
-    fn.erase();
-    return nullptr;
-  }
+
+  if (isa<CXXDestructorDecl>(funcDecl))
+    getCIRGenModule().errorNYI(bodyRange, "C++ destructor definition");
+  else if (isa<CXXConstructorDecl>(funcDecl))
+    getCIRGenModule().errorNYI(bodyRange, "C++ constructor definition");
+  else if (getLangOpts().CUDA && !getLangOpts().CUDAIsDevice &&
+           funcDecl->hasAttr<CUDAGlobalAttr>())
+    getCIRGenModule().errorNYI(bodyRange, "CUDA kernel");
+  else if (isa<CXXMethodDecl>(funcDecl) &&
+           cast<CXXMethodDecl>(funcDecl)->isLambdaStaticInvoker())
+    getCIRGenModule().errorNYI(bodyRange, "Lambda static invoker");
+  else if (funcDecl->isDefaulted() && isa<CXXMethodDecl>(funcDecl) &&
+           (cast<CXXMethodDecl>(funcDecl)->isCopyAssignmentOperator() ||
+            cast<CXXMethodDecl>(funcDecl)->isMoveAssignmentOperator()))
+    getCIRGenModule().errorNYI(bodyRange, "Default assignment operator");
+  else if (body) {
+    if (mlir::failed(emitFunctionBody(body))) {
+      fn.erase();
+      return nullptr;
+    }
+  } else
+    llvm_unreachable("no definition for normal function");
 
   // This code to insert a cir.return or cir.trap at the end of the function is
   // temporary until the function return code, including

clang/lib/CIR/CodeGen/CIRGenFunction.h

@@ -10,8 +10,8 @@
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLVM_CLANG_LIB_CIR_CODEGEN_CIRGENFUNCTION_H
-#define LLVM_CLANG_LIB_CIR_CODEGEN_CIRGENFUNCTION_H
+#ifndef CLANG_LIB_CIR_CODEGEN_CIRGENFUNCTION_H
+#define CLANG_LIB_CIR_CODEGEN_CIRGENFUNCTION_H
 
 #include "CIRGenBuilder.h"
 #include "CIRGenModule.h"
@@ -25,13 +25,18 @@
 
 #include "llvm/ADT/ScopedHashTable.h"
 
+namespace {
+class ScalarExprEmitter;
+} // namespace
+
 namespace clang::CIRGen {
 
 class CIRGenFunction : public CIRGenTypeCache {
 public:
   CIRGenModule &cgm;
 
 private:
+  friend class ::ScalarExprEmitter;
   /// The builder is a helper class to create IR inside a function. The
   /// builder is stateful, in particular it keeps an "insertion point": this
   /// is where the next operations will be introduced.
@@ -58,11 +63,11 @@ class CIRGenFunction : public CIRGenTypeCache {
     return convertType(getContext().getTypeDeclType(T));
   }
 
-  ///  Return the cir::TypeEvaluationKind of QualType \c T.
-  static cir::TypeEvaluationKind getEvaluationKind(clang::QualType T);
+  ///  Return the cir::TypeEvaluationKind of QualType \c type.
+  static cir::TypeEvaluationKind getEvaluationKind(clang::QualType type);
 
-  static bool hasScalarEvaluationKind(clang::QualType T) {
-    return getEvaluationKind(T) == cir::TEK_Scalar;
+  static bool hasScalarEvaluationKind(clang::QualType type) {
+    return getEvaluationKind(type) == cir::TEK_Scalar;
   }
 
   CIRGenFunction(CIRGenModule &cgm, CIRGenBuilderTy &builder,
@@ -94,12 +99,14 @@ class CIRGenFunction : public CIRGenTypeCache {
   };
 
   /// Helpers to convert Clang's SourceLocation to a MLIR Location.
-  mlir::Location getLoc(clang::SourceLocation SLoc);
-  mlir::Location getLoc(clang::SourceRange SLoc);
+  mlir::Location getLoc(clang::SourceLocation srcLoc);
+  mlir::Location getLoc(clang::SourceRange srcLoc);
   mlir::Location getLoc(mlir::Location lhs, mlir::Location rhs);
 
-  void finishFunction(SourceLocation EndLoc);
-  mlir::LogicalResult emitFunctionBody(const clang::Stmt *Body);
+  const clang::LangOptions &getLangOpts() const { return cgm.getLangOpts(); }
+
+  void finishFunction(SourceLocation endLoc);
+  mlir::LogicalResult emitFunctionBody(const clang::Stmt *body);
 
   // Build CIR for a statement. useCurrentScope should be true if no
   // new scopes need be created when finding a compound statement.
@@ -122,8 +129,8 @@ class CIRGenFunction : public CIRGenTypeCache {
                            cir::FuncType funcType);
 
   /// Emit code for the start of a function.
-  /// \param Loc       The location to be associated with the function.
-  /// \param StartLoc  The location of the function body.
+  /// \param loc       The location to be associated with the function.
+  /// \param startLoc  The location of the function body.
   void startFunction(clang::GlobalDecl gd, clang::QualType retTy,
                      cir::FuncOp fn, cir::FuncType funcType,
                      clang::SourceLocation loc, clang::SourceLocation startLoc);

clang/lib/CIR/CodeGen/CIRGenModule.h

@@ -73,6 +73,7 @@ class CIRGenModule : public CIRGenTypeCache {
   CIRGenBuilderTy &getBuilder() { return builder; }
   clang::ASTContext &getASTContext() const { return astContext; }
   CIRGenTypes &getTypes() { return genTypes; }
+  const clang::LangOptions &getLangOpts() const { return langOpts; }
   mlir::MLIRContext &getMLIRContext() { return *builder.getContext(); }
 
   /// Helpers to convert the presumed location of Clang's SourceLocation to an