apply suggestions

Author: el-ev

clang/include/clang/CIR/MissingFeatures.h

@@ -159,6 +159,8 @@ struct MissingFeatures {
   static bool bitfields() { return false; }
   static bool typeChecks() { return false; }
   static bool lambdaFieldToName() { return false; }
+  static bool paramInfo() { return false; }
+  static bool funcTypeExtInfo() { return false; }
 
   // Missing types
   static bool dataMemberType() { return false; }

clang/lib/CIR/CodeGen/CIRGenCall.cpp

@@ -25,57 +25,71 @@ CIRGenFunctionInfo::create(CanQualType resultType,
                            RequiredArgs required) {
   void *buffer = operator new(totalSizeToAlloc<ArgInfo>(argTypes.size() + 1));
 
+  assert(!cir::MissingFeatures::paramInfo());
+  assert(!cir::MissingFeatures::funcTypeExtInfo());
+
   CIRGenFunctionInfo *fi = new (buffer) CIRGenFunctionInfo();
 
   fi->required = required;
   fi->numArgs = argTypes.size();
-  fi->getArgsBuffer()[0].type = resultType;
-  for (unsigned i = 0; i < argTypes.size(); ++i)
-    fi->getArgsBuffer()[i + 1].type = argTypes[i];
+
+  // ArgsBuffer contains the return type at index 0, and the argument types
+  // starting at index 1, so there are argTypes.size() + 1 elements in total.
+  unsigned idx = 1;
+  ArgInfo *argsBuffer = fi->getArgsBuffer();
+  argsBuffer[0].type = resultType;
+  for (const auto &argType : argTypes)
+    argsBuffer[idx++].type = argType;
 
   return fi;
 }
 
 cir::FuncType CIRGenTypes::getFunctionType(const CIRGenFunctionInfo &fi) {
   bool inserted = functionsBeingProcessed.insert(&fi).second;
+  (void)inserted;
   assert(inserted && "Recursively being processed?");
 
-  mlir::Type resultType = nullptr;
-  const cir::ABIArgInfo &retAI = fi.getReturnInfo();
+  mlir::Type resultType;
+  const cir::ABIArgInfo &retInfo = fi.getReturnInfo();
 
-  switch (retAI.getKind()) {
+  switch (retInfo.getKind()) {
   case cir::ABIArgInfo::Ignore:
     // TODO(CIR): This should probably be the None type from the builtin
     // dialect.
     resultType = nullptr;
     break;
 
   case cir::ABIArgInfo::Direct:
-    resultType = retAI.getCoerceToType();
+    resultType = retInfo.getCoerceToType();
     break;
 
   default:
-    assert(false && "NYI");
+    cgm.errorNYI("getFunctionType: unhandled return kind");
   }
 
-  SmallVector<mlir::Type, 8> argTypes;
-  unsigned argNo = 0;
-  CIRGenFunctionInfo::const_arg_iterator it = fi.arg_begin(),
-                                         ie = it + fi.getNumRequiredArgs();
-  for (; it != ie; ++it, ++argNo) {
-    const auto &argInfo = it->info;
+  // TODO(cir): ClangToCIRArgMapping
 
-    switch (argInfo.getKind()) {
-    default:
-      llvm_unreachable("NYI");
-    case cir::ABIArgInfo::Direct:
-      mlir::Type argType = argInfo.getCoerceToType();
-      argTypes.push_back(argType);
+  SmallVector<mlir::Type, 8> argTypes(fi.getNumRequiredArgs());
+
+  unsigned argNo = 0;
+  llvm::ArrayRef<CIRGenFunctionInfoArgInfo> argInfos(fi.argInfoBegin(),
+                                                     fi.getNumRequiredArgs());
+  for (const auto &argInfo : argInfos) {
+    const auto &abiArgInfo = argInfo.info;
+
+    switch (abiArgInfo.getKind()) {
+    case cir::ABIArgInfo::Direct: {
+      mlir::Type argType = abiArgInfo.getCoerceToType();
+      argTypes[argNo++] = argType;
       break;
     }
+    default:
+      cgm.errorNYI("getFunctionType: unhandled argument kind");
+    }
   }
 
   bool erased = functionsBeingProcessed.erase(&fi);
+  (void)erased;
   assert(erased && "Not in set?");
 
   return cir::FuncType::get(argTypes,

clang/lib/CIR/CodeGen/CIRGenFunctionInfo.h

@@ -103,16 +103,16 @@ class CIRGenFunctionInfo final
                       llvm::ArrayRef<CanQualType> argTypes) {
     id.AddBoolean(required.getOpaqueData());
     resultType.Profile(id);
-    for (const auto &arg : argTypes)
+    for (const CanQualType &arg : argTypes)
       arg.Profile(id);
   }
 
   // NOLINTNEXTLINE(readability-identifier-naming)
   void Profile(llvm::FoldingSetNodeID &id) {
     id.AddBoolean(required.getOpaqueData());
     getReturnType().Profile(id);
-    for (const auto &i : arguments())
-      i.type.Profile(id);
+    for (const ArgInfo &argInfo : argInfos())
+      argInfo.type.Profile(id);
   }
 
   CanQualType getReturnType() const { return getArgsBuffer()[0].type; }
@@ -124,24 +124,27 @@ class CIRGenFunctionInfo final
   using const_arg_iterator = const ArgInfo *;
   using arg_iterator = ArgInfo *;
 
-  const_arg_iterator arg_begin() const { return getArgsBuffer() + 1; }
-  const_arg_iterator arg_end() const { return getArgsBuffer() + 1 + numArgs; }
-  arg_iterator arg_begin() { return getArgsBuffer() + 1; }
-  arg_iterator arg_end() { return getArgsBuffer() + 1 + numArgs; }
+  const_arg_iterator argInfoBegin() const { return getArgsBuffer() + 1; }
+  const_arg_iterator argInfoEnd() const {
+    return getArgsBuffer() + 1 + numArgs;
+  }
+  arg_iterator argInfoBegin() { return getArgsBuffer() + 1; }
+  arg_iterator argInfoEnd() { return getArgsBuffer() + 1 + numArgs; }
 
-  unsigned arg_size() const { return numArgs; }
+  unsigned argInfoSize() const { return numArgs; }
 
-  llvm::MutableArrayRef<ArgInfo> arguments() {
-    return llvm::MutableArrayRef<ArgInfo>(arg_begin(), numArgs);
+  llvm::MutableArrayRef<ArgInfo> argInfos() {
+    return llvm::MutableArrayRef<ArgInfo>(argInfoBegin(), numArgs);
   }
-  llvm::ArrayRef<ArgInfo> arguments() const {
-    return llvm::ArrayRef<ArgInfo>(arg_begin(), numArgs);
+  llvm::ArrayRef<ArgInfo> argInfos() const {
+    return llvm::ArrayRef<ArgInfo>(argInfoBegin(), numArgs);
   }
 
   bool isVariadic() const { return required.allowsOptionalArgs(); }
   RequiredArgs getRequiredArgs() const { return required; }
   unsigned getNumRequiredArgs() const {
-    return isVariadic() ? getRequiredArgs().getNumRequiredArgs() : arg_size();
+    return isVariadic() ? getRequiredArgs().getNumRequiredArgs()
+                        : argInfoSize();
   }
 };
 

clang/lib/CIR/CodeGen/CIRGenModule.cpp

@@ -22,6 +22,7 @@
 #include "clang/CIR/Dialect/IR/CIRDialect.h"
 #include "clang/CIR/MissingFeatures.h"
 
+#include "CIRGenFunctionInfo.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/Location.h"
 #include "mlir/IR/MLIRContext.h"
@@ -222,8 +223,8 @@ void CIRGenModule::emitGlobalFunctionDefinition(clang::GlobalDecl gd,
           funcDecl->getType()
               ->getCanonicalTypeUnqualified()
               .getAs<FunctionNoProtoType>()) {
-    auto &fi = getTypes().arrangeCIRFunctionInfo(noProto->getReturnType(), {},
-                                                 RequiredArgs::All);
+    const CIRGenFunctionInfo &fi = getTypes().arrangeCIRFunctionInfo(
+        noProto->getReturnType(), {}, RequiredArgs::All);
     funcType = getTypes().getFunctionType(fi);
   } else
     funcType = cast<cir::FuncType>(convertType(funcDecl->getType()));

clang/lib/CIR/CodeGen/CIRGenTypes.cpp

@@ -1,5 +1,6 @@
 #include "CIRGenTypes.h"
 
+#include "CIRGenFunctionInfo.h"
 #include "CIRGenModule.h"
 
 #include "clang/AST/ASTContext.h"
@@ -523,7 +524,7 @@ CIRGenTypes::arrangeCIRFunctionInfo(CanQualType returnType,
   if (retInfo.canHaveCoerceToType() && retInfo.getCoerceToType() == nullptr)
     retInfo.setCoerceToType(convertType(fi->getReturnType()));
 
-  for (auto &i : fi->arguments())
+  for (CIRGenFunctionInfoArgInfo &i : fi->argInfos())
     if (i.info.canHaveCoerceToType() && i.info.getCoerceToType() == nullptr)
       i.info.setCoerceToType(convertType(i.type));
 

clang/lib/CIR/CodeGen/TargetInfo.cpp

@@ -32,13 +32,11 @@ void X8664ABIInfo::computeInfo(CIRGenFunctionInfo &funcInfo) const {
   // Top level CIR has unlimited arguments and return types. Lowering for ABI
   // specific concerns should happen during a lowering phase. Assume everything
   // is direct for now.
-  for (CIRGenFunctionInfo::arg_iterator it = funcInfo.arg_begin(),
-                                        ie = funcInfo.arg_end();
-       it != ie; ++it) {
-    if (testIfIsVoidTy(it->type))
-      it->info = cir::ABIArgInfo::getIgnore();
+  for (CIRGenFunctionInfoArgInfo &argInfo : funcInfo.argInfos()) {
+    if (testIfIsVoidTy(argInfo.type))
+      argInfo.info = cir::ABIArgInfo::getIgnore();
     else
-      it->info = cir::ABIArgInfo::getDirect(cgt.convertType(it->type));
+      argInfo.info = cir::ABIArgInfo::getDirect(cgt.convertType(argInfo.type));
   }
   CanQualType retTy = funcInfo.getReturnType();
   if (testIfIsVoidTy(retTy))