If you’ve worked on a large build system you’ve probably bumped into this error, or one like this:
gmake: execvp: /bin/sh: Argument list too long
This error means the length of some command-line in your makefile has grown past the system limit, which is typically in the 32 to 256 kilobyte range. It's surprisingly easy to hit that limit. You start with a small list of object files to be linked together. Over time you add more, and the command-line gets a little longer. Add a few more and it gets longer still. Before you know it you have a monster command-line and your build starts failing.
The solution to this problem is simple: split the long command-line into several shorter command-lines. For example, ar r libraries/lib.a objects/foo.o objects/bar.o objects/baz.o objects/boo.o objects/bang.o becomes something like this:
ar r libraries/lib.a objects/foo.o objects/bar.o ar r libraries/lib.a objects/baz.o objects/boo.o ar r libraries/lib.a objects/bang.o
Simple in theory, but tedious to do by hand. And doing it manually is like putting a ticking time-bomb into your makefile — it's only a matter of time before your build grows enough that you have to go through this exercise again.
I recently ran across a clever solution that exploits the $(eval) function in GNU make to split long command-lines automatically, eliminating the tedium and the time-bomb. After I show you the solution, I'll explain it piece-by-piece.
The max_args function
The solution is a user-defined function called max_args that splits long command-lines into equal-length chunks:
And an example of its use:
The max_args function takes three parameters: the base command-line, the number of arguments per "chunk", and the complete list of arguments. It expands to a series of command-lines — one for each chunk of arguments.
The trick behind max_args is the use of $(eval) to update a variable as a side-effect of gmake's regular variable expansion activity. If you're not familiar with gmake variable expansion, here's a quick rundown: when gmake finds a variable or function reference, like $(something), it replace the entire reference with an expanded value. In the case of a variable that's just the value of the variable. Most variables in gmake are recursive which means that if the variable value itself contains embedded variable references, those will be expanded as well, recursively. In the case of a function, gmake evaluates the function, and replaces the reference with the computed value.
The meat of max_args is on line 3. It starts with the $(foreach) function, which evaluates its third argument, the body of the loop, once for each word in its second argument — in this case, the list of objects passed in the call to max_args.
In max_args, the loop body has two components. The first is a call to $(eval), which simply appends the current value of the loop variable to an accumulator called _args.
The second component of the loop body uses $(if) and $(word) to check the length of _args. The $(word) function returns the nth word from a list, or an empty string if there are fewer than n words in the list. The $(if) function expands its second argument (the then clause) only if its first argument (the condition) expands to a non-empty string, so together these functions check if _args has the desired number of words, and if so the then clause of the $(if) is expanded.
The then clause of this $(if) has two components. The first constructs a completed command-line by concatenating the base command-line, here given by $1, the first argument to the original max_args call; the accumulated arguments; and a newline character. Thanks to the rules of gmake expansion, this command-line is added to the overall expansion result for the max_args function. The second part of the then clause uses $(eval) to reset the accumulator
If the chunk size does not evenly divide the number of arguments, the stragglers are emitted in a final command-line on the last line of max_args.
max_args is handy but it has one significant limitation: command-line length limits are based on the number of bytes in the command-line, not the number of words, in it. Unfortunately, gmake has no built-in way to count the number of characters in a string. gmake does provide the $(words) built-in, so that's what max_args uses. That just means that to use it effectively you have to take a guess at the number of arguments that will fit in a single command-line, for example by dividing the length limit by the average number of characters in each argument, then subtracting some to allow some buffer for outliers.