Kill off CGCallInfo, always use CGFunctionInfo for encapsulating

function/call info.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@63466 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/lib/CodeGen/CGCall.cpp b/lib/CodeGen/CGCall.cpp
index 0807caff9beafe482e0d30db8a3ec0a80e35ce4b..e282980d13a2dc3cea040d8a775a1ad6d1930b6c 100644 (file)
--- a/lib/CodeGen/CGCall.cpp
+++ b/lib/CodeGen/CGCall.cpp
@@ -73,27 +73,21 @@ CGFunctionInfo::CGFunctionInfo(const ObjCMethodDecl *MD,
     ArgTypes.push_back((*i)->getType());
 }
 
-ArgTypeIterator CGFunctionInfo::argtypes_begin() const {
-  return ArgTypes.begin();
-}
-
-ArgTypeIterator CGFunctionInfo::argtypes_end() const {
-  return ArgTypes.end();
-}
-
-/***/
-
-CGCallInfo::CGCallInfo(QualType _ResultType, const CallArgList &_Args) {
-  ArgTypes.push_back(_ResultType);
-  for (CallArgList::const_iterator i = _Args.begin(), e = _Args.end(); i!=e; ++i)
+CGFunctionInfo::CGFunctionInfo(QualType ResTy, const CallArgList &Args, 
+                               bool _IsVariadic)
+  : IsVariadic(_IsVariadic)
+{
+  ArgTypes.push_back(ResTy);
+  for (CallArgList::const_iterator i = Args.begin(), e = Args.end(); 
+       i != e; ++i)
     ArgTypes.push_back(i->second);
 }
 
-ArgTypeIterator CGCallInfo::argtypes_begin() const {
+ArgTypeIterator CGFunctionInfo::argtypes_begin() const {
   return ArgTypes.begin();
 }
 
-ArgTypeIterator CGCallInfo::argtypes_end() const {
+ArgTypeIterator CGFunctionInfo::argtypes_end() const {
   return ArgTypes.end();
 }
 
@@ -878,14 +872,10 @@ CodeGenFunction::ExpandTypeToArgs(QualType Ty, RValue RV,
 
 /***/
 
-const llvm::FunctionType *
-CodeGenTypes::GetFunctionType(const CGCallInfo &CI, bool IsVariadic) {
-  return GetFunctionType(CI.argtypes_begin(), CI.argtypes_end(), IsVariadic);
-}
-
 const llvm::FunctionType *
 CodeGenTypes::GetFunctionType(const CGFunctionInfo &FI) {
-  return GetFunctionType(FI.argtypes_begin(), FI.argtypes_end(), FI.isVariadic());
+  return GetFunctionType(FI.argtypes_begin(), FI.argtypes_end(), 
+                         FI.isVariadic());
 }
 
 const llvm::FunctionType *
@@ -962,8 +952,7 @@ bool CodeGenModule::ReturnTypeUsesSret(QualType RetTy) {
 }
 
 void CodeGenModule::ConstructAttributeList(const Decl *TargetDecl,
-                                           ArgTypeIterator begin,
-                                           ArgTypeIterator end,
+                                           const CGFunctionInfo &Info,
                                            AttributeListType &PAL) {
   unsigned FuncAttrs = 0;
   unsigned RetAttrs = 0;
@@ -979,6 +968,7 @@ void CodeGenModule::ConstructAttributeList(const Decl *TargetDecl,
       FuncAttrs |= llvm::Attribute::ReadNone;
   }
 
+  ArgTypeIterator begin = Info.argtypes_begin(), end = Info.argtypes_end();
   QualType RetTy = *begin;
   unsigned Index = 1;
   ABIArgInfo RetAI = getABIReturnInfo(RetTy, getTypes());
@@ -995,8 +985,8 @@ void CodeGenModule::ConstructAttributeList(const Decl *TargetDecl,
 
   case ABIArgInfo::StructRet:
     PAL.push_back(llvm::AttributeWithIndex::get(Index, 
-                                                  llvm::Attribute::StructRet|
-                                                  llvm::Attribute::NoAlias));
+                                                llvm::Attribute::StructRet |
+                                                llvm::Attribute::NoAlias));
     ++Index;
     break;
 
@@ -1294,16 +1284,15 @@ RValue CodeGenFunction::EmitCall(llvm::Value *Callee,
   }
   
   llvm::CallInst *CI = Builder.CreateCall(Callee,&Args[0],&Args[0]+Args.size());
-  CGCallInfo CallInfo(RetTy, CallArgs);
+  bool isVariadic = cast<llvm::FunctionType>(Callee->getType())->isVarArg();
+  CGFunctionInfo CallInfo(RetTy, CallArgs, isVariadic);
 
   // FIXME: Provide TargetDecl so nounwind, noreturn, etc, etc get set.
   CodeGen::AttributeListType AttributeList;
-  CGM.ConstructAttributeList(0, 
-                             CallInfo.argtypes_begin(), CallInfo.argtypes_end(),
-                             AttributeList);
+  CGM.ConstructAttributeList(0, CallInfo, AttributeList);
   CI->setAttributes(llvm::AttrListPtr::get(AttributeList.begin(), 
-                                         AttributeList.size()));  
-
+                                           AttributeList.size()));  
+  
   if (const llvm::Function *F = dyn_cast<llvm::Function>(Callee))
     CI->setCallingConv(F->getCallingConv());
   if (CI->getType() != llvm::Type::VoidTy)

diff --git a/lib/CodeGen/CGCall.h b/lib/CodeGen/CGCall.h
index 744344a7acc5ca6f413cd874ee03897043fd5882..fd6eb481598e16dc21a73fe0b831c9c26369e93d 100644 (file)
--- a/lib/CodeGen/CGCall.h
+++ b/lib/CodeGen/CGCall.h
@@ -64,24 +64,14 @@ namespace CodeGen {
     CGFunctionInfo(const FunctionDecl *FD);
     CGFunctionInfo(const ObjCMethodDecl *MD,
                    const ASTContext &Context);
+    CGFunctionInfo(QualType ResTy, const CallArgList &Args, 
+                   bool _IsVariadic);
 
     bool isVariadic() const { return IsVariadic; }
 
     ArgTypeIterator argtypes_begin() const;
     ArgTypeIterator argtypes_end() const;
   };
-
-  /// CGCallInfo - Class to encapsulate the arguments and clang types
-  /// used in a call.
-  class CGCallInfo {
-    llvm::SmallVector<QualType, 16> ArgTypes;
-
-  public:
-    CGCallInfo(QualType _ResultType, const CallArgList &Args);
-
-    ArgTypeIterator argtypes_begin() const;
-    ArgTypeIterator argtypes_end() const;
-  };
 }  // end namespace CodeGen
 }  // end namespace clang
 

diff --git a/lib/CodeGen/CGObjCMac.cpp b/lib/CodeGen/CGObjCMac.cpp
index 6c35041b97146b52de6ec1142e33e2b5e98409f4..4e6611bc554bbcf5d76604b214d9067db53ac860 100644 (file)
--- a/lib/CodeGen/CGObjCMac.cpp
+++ b/lib/CodeGen/CGObjCMac.cpp
@@ -799,8 +799,8 @@ CodeGen::RValue CGObjCMac::EmitMessageSend(CodeGen::CodeGenFunction &CGF,
   ActualArgs.insert(ActualArgs.end(), CallArgs.begin(), CallArgs.end());
 
   const llvm::FunctionType *FTy = 
-    CGM.getTypes().GetFunctionType(CGCallInfo(ResultType, ActualArgs),
-                                   false);
+    CGM.getTypes().GetFunctionType(CGFunctionInfo(ResultType, ActualArgs,
+                                                  false));
 
   llvm::Constant *Fn;
   if (CGM.ReturnTypeUsesSret(ResultType)) {

diff --git a/lib/CodeGen/CodeGenModule.cpp b/lib/CodeGen/CodeGenModule.cpp
index 6e1321f4d6c677e7b21b8b136bcf205059f832dc..bdb99d6439b7fe21f151b7486ba557788ab98fd1 100644 (file)
--- a/lib/CodeGen/CodeGenModule.cpp
+++ b/lib/CodeGen/CodeGenModule.cpp
@@ -265,8 +265,7 @@ void CodeGenModule::SetFunctionAttributes(const Decl *D,
                                           const CGFunctionInfo &Info, 
                                           llvm::Function *F) {
   AttributeListType AttributeList;
-  ConstructAttributeList(D, Info.argtypes_begin(), Info.argtypes_end(),
-                         AttributeList);
+  ConstructAttributeList(D, Info, AttributeList);
 
   F->setAttributes(llvm::AttrListPtr::get(AttributeList.begin(),
                                         AttributeList.size()));

diff --git a/lib/CodeGen/CodeGenModule.h b/lib/CodeGen/CodeGenModule.h
index 0bd0e2c724fd7406a1be3c5ecd0e401316d53cee..724ca28b886fcefd502fa376583585fd79dc7483 100644 (file)
--- a/lib/CodeGen/CodeGenModule.h
+++ b/lib/CodeGen/CodeGenModule.h
@@ -247,8 +247,7 @@ public:
   bool ReturnTypeUsesSret(QualType RetTy);
 
   void ConstructAttributeList(const Decl *TargetDecl,
-                              const ArgTypeIterator begin,
-                              const ArgTypeIterator end,
+                              const CGFunctionInfo &Info,
                               AttributeListType &PAL);
 
 private:

diff --git a/lib/CodeGen/CodeGenTypes.h b/lib/CodeGen/CodeGenTypes.h
index 2fe7c89fadac60039b97768a23886a9459784207..46ca79a3caa15f7eab27782e018c09ca469e25e3 100644 (file)
--- a/lib/CodeGen/CodeGenTypes.h
+++ b/lib/CodeGen/CodeGenTypes.h
@@ -145,10 +145,6 @@ public:
 
   /// GetFunctionType - Get the LLVM function type from Info.
   const llvm::FunctionType *GetFunctionType(const CGFunctionInfo &Info);
-  /// GetFunctionType - Get the LLVM function type from Info. 
-  /// \param IsVariadic Should the resulting type be variadic?
-  const llvm::FunctionType *GetFunctionType(const CGCallInfo &Info,
-                                            bool IsVariadic);
 
   /// GetFunctionType - Get the LLVM function type for the given types
   /// and variadicness.