maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Make CodeGenFunction::EmitCallArgs a template function that takes a generic "Type Info" parameter. The type info parameter knows how to iterate over its arguments. 

llvm-svn: 69469
This commit is contained in:
Anders Carlsson 2009-04-18 20:20:22 +00:00
parent 982a65fdb6
commit 603d6aff8b
2 changed files with 37 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
clang/lib/CodeGen/CGCall.cpp
View File

@ -1935,38 +1935,6 @@ RValue CodeGenFunction::EmitCallArg(const Expr *E, QualType ArgType) {
return EmitAnyExprToTemp(E);
}
void CodeGenFunction::EmitCallArgs(CallArgList& Args,
const FunctionProtoType *FPT,
CallExpr::const_arg_iterator ArgBeg,
CallExpr::const_arg_iterator ArgEnd) {
CallExpr::const_arg_iterator Arg = ArgBeg;
// First, use the function argument types.
if (FPT) {
for (FunctionProtoType::arg_type_iterator I = FPT->arg_type_begin(),
E = FPT->arg_type_end(); I != E; ++I, ++Arg) {
assert(getContext().getCanonicalType(I->getNonReferenceType()).
getTypePtr() ==
getContext().getCanonicalType(Arg->getType()).getTypePtr() &&
"type mismatch in call argument!");
QualType ArgType = *I;
Args.push_back(std::make_pair(EmitCallArg(*Arg, ArgType),
ArgType));
}
assert(Arg == ArgEnd || FPT->isVariadic() &&
"Extra arguments in non-variadic function!");
}
// If we still have any arguments, emit them using the type of the argument.
for (; Arg != ArgEnd; ++Arg) {
QualType ArgType = Arg->getType();
Args.push_back(std::make_pair(EmitCallArg(*Arg, ArgType),
ArgType));
}
}
RValue CodeGenFunction::EmitCall(const CGFunctionInfo &CallInfo,
llvm::Value *Callee,
const CallArgList &CallArgs,

42
clang/lib/CodeGen/CodeGenFunction.h
View File

@ -811,14 +811,46 @@ private:
RValue EmitCallArg(const Expr *E, QualType ArgType);
/// EmitCallArgs - Emit call arguments for a function.
/// FIXME: It should be possible to generalize this and pass a generic
/// "argument type container" type instead of the FunctionProtoType. This way
/// it can work on Objective-C methods as well.
void EmitCallArgs(CallArgList& args, const FunctionProtoType *FPT,
/// The CallArgTypeInfo parameter is used for iterating over the known
/// argument types of the function being called.
template<typename T>
void EmitCallArgs(CallArgList& Args, const T* CallArgTypeInfo,
CallExpr::const_arg_iterator ArgBeg,
CallExpr::const_arg_iterator ArgEnd);
CallExpr::const_arg_iterator ArgEnd) {
CallExpr::const_arg_iterator Arg = ArgBeg;
// First, use the argument types that the type info knows about
if (CallArgTypeInfo) {
for (typename T::arg_type_iterator I = CallArgTypeInfo->arg_type_begin(),
E = CallArgTypeInfo->arg_type_end(); I != E; ++I, ++Arg) {
QualType ArgType = *I;
assert(getContext().getCanonicalType(ArgType.getNonReferenceType()).
getTypePtr() ==
getContext().getCanonicalType(Arg->getType()).getTypePtr() &&
"type mismatch in call argument!");
Args.push_back(std::make_pair(EmitCallArg(*Arg, ArgType),
ArgType));
}
// Either we've emitted all the call args, or we have a call to a
// variadic function.
assert(Arg == ArgEnd || CallArgTypeInfo->isVariadic() &&
"Extra arguments in non-variadic function!");
}
// If we still have any arguments, emit them using the type of the argument.
for (; Arg != ArgEnd; ++Arg) {
QualType ArgType = Arg->getType();
Args.push_back(std::make_pair(EmitCallArg(*Arg, ArgType),
ArgType));
}
}
};
} // end namespace CodeGen
} // end namespace clang