Address review feedback

Author: andykaylor

clang/include/clang/CIR/MissingFeatures.h

@@ -98,7 +98,6 @@ struct MissingFeatures {
   static bool opCallReturn() { return false; }
   static bool opCallArgEvaluationOrder() { return false; }
   static bool opCallCallConv() { return false; }
-  static bool opCallNoPrototypeFunc() { return false; }
   static bool opCallMustTail() { return false; }
   static bool opCallVirtual() { return false; }
   static bool opCallInAlloca() { return false; }

clang/lib/CIR/CodeGen/CIRGenCall.cpp

@@ -582,15 +582,14 @@ RValue CIRGenFunction::emitCall(const CIRGenFunctionInfo &funcInfo,
   cir::FuncOp directFuncOp;
   if (auto fnOp = dyn_cast<cir::FuncOp>(calleePtr)) {
     directFuncOp = fnOp;
-  } else if (auto getGlobalOp = dyn_cast<cir::GetGlobalOp>(calleePtr)) {
+  } else if (auto getGlobalOp = mlir::dyn_cast<cir::GetGlobalOp>(calleePtr)) {
     // FIXME(cir): This peephole optimization avoids indirect calls for
     // builtins. This should be fixed in the builtin declaration instead by
     // not emitting an unecessary get_global in the first place.
     // However, this is also used for no-prototype functions.
     mlir::Operation *globalOp = cgm.getGlobalValue(getGlobalOp.getName());
     assert(globalOp && "undefined global function");
-    directFuncOp = llvm::dyn_cast<cir::FuncOp>(globalOp);
-    assert(directFuncOp && "operation is not a function");
+    directFuncOp = mlir::cast<cir::FuncOp>(globalOp);
   } else {
     [[maybe_unused]] mlir::ValueTypeRange<mlir::ResultRange> resultTypes =
         calleePtr->getResultTypes();

clang/lib/CIR/CodeGen/CIRGenExpr.cpp

@@ -1324,7 +1324,7 @@ RValue CIRGenFunction::emitCall(clang::QualType calleeTy,
 
     mlir::Operation *fn = callee.getFunctionPointer();
     mlir::Value addr;
-    if (auto funcOp = llvm::dyn_cast<cir::FuncOp>(fn)) {
+    if (auto funcOp = mlir::dyn_cast<cir::FuncOp>(fn)) {
       addr = builder.create<cir::GetGlobalOp>(
           getLoc(e->getSourceRange()),
           cir::PointerType::get(funcOp.getFunctionType()), funcOp.getSymName());
@@ -1336,7 +1336,6 @@ RValue CIRGenFunction::emitCall(clang::QualType calleeTy,
     callee.setFunctionPointer(fn);
   }
 
-  assert(!cir::MissingFeatures::opCallNoPrototypeFunc());
   assert(!cir::MissingFeatures::opCallFnInfoOpts());
   assert(!cir::MissingFeatures::hip());
   assert(!cir::MissingFeatures::opCallMustTail());

clang/lib/CIR/CodeGen/CIRGenModule.cpp

@@ -1127,7 +1127,7 @@ void CIRGenModule::replaceUsesOfNonProtoTypeWithRealFunction(
              "replaceUsesOfNonProtoTypeWithRealFunction: Attribute forwarding");
 
   // Mark new function as originated from a no-proto declaration.
-  newFn.setNoProtoAttr(oldFn.getNoProtoAttr());
+  newFn.setNoProto(oldFn.getNoProto());
 
   // Iterate through all calls of the no-proto function.
   std::optional<mlir::SymbolTable::UseRange> symUses =
@@ -1746,8 +1746,7 @@ cir::FuncOp CIRGenModule::getOrCreateCIRFunction(
   // Lookup the entry, lazily creating it if necessary.
   mlir::Operation *entry = getGlobalValue(mangledName);
   if (entry) {
-    if (!isa<cir::FuncOp>(entry))
-      errorNYI(d->getSourceRange(), "getOrCreateCIRFunction: non-FuncOp");
+    assert(mlir::isa<cir::FuncOp>(entry));
 
     assert(!cir::MissingFeatures::weakRefReference());
 
@@ -1794,10 +1793,6 @@ cir::FuncOp CIRGenModule::getOrCreateCIRFunction(
     // Fetch a generic symbol-defining operation and its uses.
     auto symbolOp = mlir::cast<mlir::SymbolOpInterface>(entry);
 
-    // TODO(cir): When can this symbol be something other than a function?
-    if (!isa<cir::FuncOp>(entry))
-      errorNYI(d->getSourceRange(), "getOrCreateCIRFunction: non-FuncOp");
-
     // This might be an implementation of a function without a prototype, in
     // which case, try to do special replacement of calls which match the new
     // prototype. The really key thing here is that we also potentially drop
@@ -1889,7 +1884,7 @@ CIRGenModule::createCIRFunction(mlir::Location loc, StringRef name,
     assert(!cir::MissingFeatures::opFuncAstDeclAttr());
 
     if (funcDecl && !funcDecl->hasPrototype())
-      func.setNoProtoAttr(builder.getUnitAttr());
+      func.setNoProto(true);
 
     assert(func.isDeclaration() && "expected empty body");