However, it seems as though that constructor has been removed. I assume that I'm suppossed to use the following constructor, but I can't figure out what to pass as the Args parameter (the second parameter).
However, it seems as though that constructor has been removed. I assume
that I'm suppossed to use the following constructor, but I can't figure
out what to pass as the Args parameter (the second parameter).
Ryan, I suggest you familiarize yourself with http://llvm.org/doxygen/classes.html and look there for help on the new
API. It is regenerated every night so it should be perpetually up to
date with CVS HEAD.
Args needs to be an array of the arguments and NumArgs needs to be the
size of the array. If you have a std::vector then you can just:
Thanks for the help Reid! I frequently look at the online doxygen, but sometimes its difficult to determine the correct replacement when a method is removed from LLVM. In this particular case, I knew which new CallInst constructor to use, I just couldn't figure out the proper syntax.
Args needs to be an array of the arguments and NumArgs needs to be the
size of the array. If you have a std::vector then you can just:
new CallInst(F, &ArgVec[0], ArgVec.size(), ...)
Doesn't the code above make an assumption about how std::vector is implemented? If ArgVec is defined as
std::vector<Value*> ArgVec;
then &ArgVec[0] returns a Value**. Let us define
Value** Params = &ArgVec[0];
The constructor for CallInst accesses Params using the operator in a for loop. That should only work if the std::vector<Value*> is implemented using an array of Value*s. I looked at the documentation for STL and did not see anything about vector being guaranteed to be implemented as an array.
Am I missing something? If not, why was direct support for a std:vector<Value*> removed from the CallInst constructor?
Thanks for the help Reid! I frequently look at the online doxygen, but
Something else that really helps when you are unsure as how to use a new method is to look at passes in lib, *especially* InstCombine. InstCombine is always up-to-date and uses a good amount of the API.
Args needs to be an array of the arguments and NumArgs needs to be the size of the array. If you have a std::vector then you can just:
new CallInst(F, &ArgVec[0], ArgVec.size(), ...)
Doesn't the code above make an assumption about how std::vector is implemented? That should only work if the std::vector<Value*> is implemented using an array of Value*s. I looked at the documentation for STL and did not see anything about vector being guaranteed to be implemented as an array.
All pertinent implementations of the STL do in fact make this guarantee.
why was direct support for a std:vector<Value*> removed from the CallInst constructor?
To allow the use of SmallVector instead of std::vector, which avoids a temporary heap allocation for a significant speedup.
As of the 2003 revision of the standard, std::vector is guaranteed to
use contiguous storage: &vec[0] + i == &vec[i] for all i in
[0,vec.size()). (See 23.2.4.1)
That said, with the complexity requirements, it'd be difficult to
implement it any other way. And as Gordon said, there are no common
implementations that ever did it differently--and likely never were
any at all.