[CIR][NFC] Eliminate ArgInfo structure (#1629)

A previous refactoring had reduced the ArgInfo structure to contain a
single member, the argument type. This change eliminates the ArgInfo
structure entirely, instead just storing the argument type directly in
places where ArgInfo had previously been used.

Author: andykaylor

clang/lib/CIR/CodeGen/CIRGenCall.cpp

@@ -47,8 +47,9 @@ CIRGenFunctionInfo *CIRGenFunctionInfo::create(
   assert(!required.allowsOptionalArgs() ||
          required.getNumRequiredArgs() <= argTypes.size());
 
-  void *buffer = operator new(totalSizeToAlloc<ArgInfo, ExtParameterInfo>(
-      argTypes.size() + 1, paramInfos.size()));
+  void *buffer = operator new(
+      totalSizeToAlloc<clang::CanQualType, ExtParameterInfo>(
+          argTypes.size() + 1, paramInfos.size()));
 
   CIRGenFunctionInfo *FI = new (buffer) CIRGenFunctionInfo();
   FI->CallingConvention = cirCC;
@@ -68,9 +69,9 @@ CIRGenFunctionInfo *CIRGenFunctionInfo::create(
   FI->ArgRecordAlign = 0;
   FI->NumArgs = argTypes.size();
   FI->HasExtParameterInfos = !paramInfos.empty();
-  FI->getArgsBuffer()[0].type = resultType;
+  FI->getArgTypes()[0] = resultType;
   for (unsigned i = 0; i < argTypes.size(); ++i)
-    FI->getArgsBuffer()[i + 1].type = argTypes[i];
+    FI->getArgTypes()[i + 1] = argTypes[i];
   for (unsigned i = 0; i < paramInfos.size(); ++i)
     FI->getExtParameterInfosBuffer()[i] = paramInfos[i];
 
@@ -100,8 +101,8 @@ cir::FuncType CIRGenTypes::GetFunctionType(const CIRGenFunctionInfo &FI) {
   ArgTypes.reserve(FI.getNumRequiredArgs());
 
   // Add in all of the required arguments.
-  for (const CIRGenFunctionInfoArgInfo &argInfo : FI.requiredArguments())
-    ArgTypes.push_back(convertType(argInfo.type));
+  for (const clang::CanQualType &argType : FI.requiredArguments())
+    ArgTypes.push_back(convertType(argType));
 
   bool Erased = FunctionsBeingProcessed.erase(&FI);
   (void)Erased;
@@ -469,11 +470,11 @@ RValue CIRGenFunction::emitCall(const CIRGenFunctionInfo &CallInfo,
   CIRCallArgs.reserve(CallArgs.size());
 
   unsigned ArgNo = 0;
-  CIRGenFunctionInfo::const_arg_iterator info_it = CallInfo.arg_begin();
+  CIRGenFunctionInfo::const_arg_iterator type_it = CallInfo.arg_begin();
   for (CallArgList::const_iterator I = CallArgs.begin(), E = CallArgs.end();
-       I != E; ++I, ++info_it, ++ArgNo) {
+       I != E; ++I, ++type_it, ++ArgNo) {
 
-    mlir::Type argType = convertType(info_it->type);
+    mlir::Type argType = convertType(*type_it);
     if (!mlir::isa<cir::RecordType>(argType)) {
       mlir::Value V;
       assert(!I->isAggregate() && "Aggregate NYI");

clang/lib/CIR/CodeGen/CIRGenFunctionInfo.h

@@ -16,18 +16,13 @@
 #define LLVM_CLANG_CIR_CIRGENFUNCTIONINFO_H
 
 #include "clang/AST/CanonicalType.h"
-#include "clang/CIR/ABIArgInfo.h"
 #include "clang/CIR/Dialect/IR/CIRTypes.h"
 
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/Support/TrailingObjects.h"
 
 namespace clang::CIRGen {
 
-struct CIRGenFunctionInfoArgInfo {
-  clang::CanQualType type;
-};
-
 /// A class for recording the number of arguments that a function signature
 /// requires.
 class RequiredArgs {
@@ -80,10 +75,9 @@ class RequiredArgs {
 class CIRGenFunctionInfo final
     : public llvm::FoldingSetNode,
       private llvm::TrailingObjects<
-          CIRGenFunctionInfo, CIRGenFunctionInfoArgInfo,
+          CIRGenFunctionInfo, clang::CanQualType,
           clang::FunctionProtoType::ExtParameterInfo> {
 
-  typedef CIRGenFunctionInfoArgInfo ArgInfo;
   typedef clang::FunctionProtoType::ExtParameterInfo ExtParameterInfo;
 
   /// The cir::CallingConv to use for this function (as specified by the user).
@@ -134,9 +128,13 @@ class CIRGenFunctionInfo final
 
   unsigned NumArgs;
 
-  ArgInfo *getArgsBuffer() { return getTrailingObjects<ArgInfo>(); }
+  clang::CanQualType *getArgTypes() {
+    return getTrailingObjects<clang::CanQualType>();
+  }
 
-  const ArgInfo *getArgsBuffer() const { return getTrailingObjects<ArgInfo>(); }
+  const clang::CanQualType *getArgTypes() const {
+    return getTrailingObjects<clang::CanQualType>();
+  }
 
   ExtParameterInfo *getExtParameterInfosBuffer() {
     return getTrailingObjects<ExtParameterInfo>();
@@ -161,15 +159,15 @@ class CIRGenFunctionInfo final
   // Friending class TrailingObjects is apparantly not good enough for MSVC, so
   // these have to be public.
   friend class TrailingObjects;
-  size_t numTrailingObjects(OverloadToken<ArgInfo>) const {
+  size_t numTrailingObjects(OverloadToken<clang::CanQualType>) const {
     return NumArgs + 1;
   }
   size_t numTrailingObjects(OverloadToken<ExtParameterInfo>) const {
     return (HasExtParameterInfos ? NumArgs : 0);
   }
 
-  using const_arg_iterator = const ArgInfo *;
-  using arg_iterator = ArgInfo *;
+  using const_arg_iterator = const clang::CanQualType *;
+  using arg_iterator = clang::CanQualType *;
 
   static void Profile(llvm::FoldingSetNodeID &ID, bool InstanceMethod,
                       bool ChainCall, const clang::FunctionType::ExtInfo &info,
@@ -220,27 +218,29 @@ class CIRGenFunctionInfo final
     }
     getReturnType().Profile(ID);
     for (const auto &I : arguments())
-      I.type.Profile(ID);
+      I.Profile(ID);
   }
 
-  llvm::MutableArrayRef<ArgInfo> arguments() {
-    return llvm::MutableArrayRef<ArgInfo>(arg_begin(), NumArgs);
+  llvm::MutableArrayRef<clang::CanQualType> arguments() {
+    return llvm::MutableArrayRef<clang::CanQualType>(arg_begin(), NumArgs);
   }
-  llvm::ArrayRef<ArgInfo> arguments() const {
-    return llvm::ArrayRef<ArgInfo>(arg_begin(), NumArgs);
+  llvm::ArrayRef<clang::CanQualType> arguments() const {
+    return llvm::ArrayRef<clang::CanQualType>(arg_begin(), NumArgs);
   }
 
-  llvm::MutableArrayRef<ArgInfo> requiredArguments() {
-    return llvm::MutableArrayRef<ArgInfo>(arg_begin(), getNumRequiredArgs());
+  llvm::MutableArrayRef<clang::CanQualType> requiredArguments() {
+    return llvm::MutableArrayRef<clang::CanQualType>(arg_begin(),
+                                                     getNumRequiredArgs());
   }
-  llvm::ArrayRef<ArgInfo> requiredArguments() const {
-    return llvm::ArrayRef<ArgInfo>(arg_begin(), getNumRequiredArgs());
+  llvm::ArrayRef<clang::CanQualType> requiredArguments() const {
+    return llvm::ArrayRef<clang::CanQualType>(arg_begin(),
+                                              getNumRequiredArgs());
   }
 
-  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 arg_begin() const { return getArgTypes() + 1; }
+  const_arg_iterator arg_end() const { return getArgTypes() + 1 + NumArgs; }
+  arg_iterator arg_begin() { return getArgTypes() + 1; }
+  arg_iterator arg_end() { return getArgTypes() + 1 + NumArgs; }
 
   unsigned arg_size() const { return NumArgs; }
 
@@ -266,7 +266,7 @@ class CIRGenFunctionInfo final
     return EffectiveCallingConvention;
   }
 
-  clang::CanQualType getReturnType() const { return getArgsBuffer()[0].type; }
+  clang::CanQualType getReturnType() const { return getArgTypes()[0]; }
 
   bool isChainCall() const { return ChainCall; }
 

clang/lib/CIR/CodeGen/TargetInfo.cpp

@@ -6,6 +6,7 @@
 #include "CIRGenTypes.h"
 
 #include "clang/Basic/TargetInfo.h"
+#include "clang/CIR/ABIArgInfo.h"
 #include "clang/CIR/MissingFeatures.h"
 #include "clang/CIR/Target/x86.h"