The linearized code, sparse's IR, have no use of C's complex type system. Those types are checked in previous phases and the pseudos doesn't have a type directly attached to them as all the needed typing info info are conveyed by the instructions. In particular, PSEUDO_VAL (used for integer and address constants) are completely typeless. There is a problem with this when calling a variadic function with a constant argument as in this case there is no type in the function prototype (for the variadic part, of course) and there is no defining instructions holding the type of the argument. Possible but rejected solutions are: * give a full type to all pseudos This is silly as, for example 'int 0' and 'unsigned int 0' are, really, the same constants. * give simply a size to all pseudos This seems to be simple enough but *currently* it negatively impacts CSE (maybe because of some others deficiencies in the type system, especially for casts). * give a type to all function arguments via a new instruction that would mimic argument passing (OP_ARG or OP_PUSH). This solution is interesting, especially as it gives a placeholder for real argument passing at code generation time, but: 0) they can be added, if needed, when some code generation will be done. 1) it creates a superfluous instruction for every argument of every function call 2) these instructions are essentially copy instructions in disguise. So, since the problem only exist for constants used in variadic arguments (and currently, it's only a problem for sparse-llvm), the solution selected is to add to OP_CALLs a list holding the type of all arguments. More exactly, it reuses the field .fntype which was used to store the type of the function, and changes it to a list holding the function type *and* the type of all effective arguments. Reported-by: Dibyendu Majumdar <mobile@majumdar.org.uk> Signed-off-by: Luc Van Oostenryck <luc.vanoostenryck@gmail.com>