2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* "Optimize" a list of dependencies as spit out by gcc -MD
|
|
|
|
* for the kernel build
|
|
|
|
* ===========================================================================
|
|
|
|
*
|
|
|
|
* Author Kai Germaschewski
|
|
|
|
* Copyright 2002 by Kai Germaschewski <kai.germaschewski@gmx.de>
|
|
|
|
*
|
|
|
|
* This software may be used and distributed according to the terms
|
|
|
|
* of the GNU General Public License, incorporated herein by reference.
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* Introduction:
|
|
|
|
*
|
|
|
|
* gcc produces a very nice and correct list of dependencies which
|
|
|
|
* tells make when to remake a file.
|
|
|
|
*
|
|
|
|
* To use this list as-is however has the drawback that virtually
|
2009-10-17 22:49:24 +00:00
|
|
|
* every file in the kernel includes autoconf.h.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2009-10-17 22:49:24 +00:00
|
|
|
* If the user re-runs make *config, autoconf.h will be
|
2005-04-16 22:20:36 +00:00
|
|
|
* regenerated. make notices that and will rebuild every file which
|
|
|
|
* includes autoconf.h, i.e. basically all files. This is extremely
|
|
|
|
* annoying if the user just changed CONFIG_HIS_DRIVER from n to m.
|
|
|
|
*
|
|
|
|
* So we play the same trick that "mkdep" played before. We replace
|
2009-10-17 22:49:24 +00:00
|
|
|
* the dependency on autoconf.h by a dependency on every config
|
2017-08-08 13:20:50 +00:00
|
|
|
* option which is mentioned in any of the listed prerequisites.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2007-03-29 09:27:14 +00:00
|
|
|
* kconfig populates a tree in include/config/ with an empty file
|
|
|
|
* for each config symbol and when the configuration is updated
|
|
|
|
* the files representing changed config options are touched
|
|
|
|
* which then let make pick up the changes and the files that use
|
|
|
|
* the config symbols are rebuilt.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
|
|
|
* So if the user changes his CONFIG_HIS_DRIVER option, only the objects
|
2021-04-15 17:36:07 +00:00
|
|
|
* which depend on "include/config/HIS_DRIVER" will be rebuilt,
|
2005-04-16 22:20:36 +00:00
|
|
|
* so most likely only his driver ;-)
|
|
|
|
*
|
|
|
|
* The idea above dates, by the way, back to Michael E Chastain, AFAIK.
|
|
|
|
*
|
|
|
|
* So to get dependencies right, there are two issues:
|
|
|
|
* o if any of the files the compiler read changed, we need to rebuild
|
|
|
|
* o if the command line given to the compile the file changed, we
|
|
|
|
* better rebuild as well.
|
|
|
|
*
|
|
|
|
* The former is handled by using the -MD output, the later by saving
|
|
|
|
* the command line used to compile the old object and comparing it
|
|
|
|
* to the one we would now use.
|
|
|
|
*
|
|
|
|
* Again, also this idea is pretty old and has been discussed on
|
|
|
|
* kbuild-devel a long time ago. I don't have a sensibly working
|
|
|
|
* internet connection right now, so I rather don't mention names
|
|
|
|
* without double checking.
|
|
|
|
*
|
|
|
|
* This code here has been based partially based on mkdep.c, which
|
|
|
|
* says the following about its history:
|
|
|
|
*
|
|
|
|
* Copyright abandoned, Michael Chastain, <mailto:mec@shout.net>.
|
|
|
|
* This is a C version of syncdep.pl by Werner Almesberger.
|
|
|
|
*
|
|
|
|
*
|
|
|
|
* It is invoked as
|
|
|
|
*
|
|
|
|
* fixdep <depfile> <target> <cmdline>
|
|
|
|
*
|
|
|
|
* and will read the dependency file <depfile>
|
|
|
|
*
|
|
|
|
* The transformed dependency snipped is written to stdout.
|
|
|
|
*
|
|
|
|
* It first generates a line
|
|
|
|
*
|
|
|
|
* cmd_<target> = <cmdline>
|
|
|
|
*
|
|
|
|
* and then basically copies the .<target>.d file to stdout, in the
|
2009-10-17 22:49:24 +00:00
|
|
|
* process filtering out the dependency on autoconf.h and adding
|
2021-04-15 17:36:07 +00:00
|
|
|
* dependencies on include/config/MY_OPTION for every
|
2017-08-08 13:20:50 +00:00
|
|
|
* CONFIG_MY_OPTION encountered in any of the prerequisites.
|
2005-04-16 22:20:36 +00:00
|
|
|
*
|
2016-08-24 18:03:05 +00:00
|
|
|
* We don't even try to really parse the header files, but
|
2005-04-16 22:20:36 +00:00
|
|
|
* merely grep, i.e. if CONFIG_FOO is mentioned in a comment, it will
|
|
|
|
* be picked up as well. It's not a problem with respect to
|
|
|
|
* correctness, since that can only give too many dependencies, thus
|
|
|
|
* we cannot miss a rebuild. Since people tend to not mention totally
|
|
|
|
* unrelated CONFIG_ options all over the place, it's not an
|
|
|
|
* efficiency problem either.
|
|
|
|
*
|
|
|
|
* (Note: it'd be easy to port over the complete mkdep state machine,
|
|
|
|
* but I don't think the added complexity is worth it)
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <ctype.h>
|
|
|
|
|
2009-09-18 19:49:23 +00:00
|
|
|
static void usage(void)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2018-11-30 01:05:26 +00:00
|
|
|
fprintf(stderr, "Usage: fixdep <depfile> <target> <cmdline>\n");
|
2005-04-16 22:20:36 +00:00
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
2010-11-09 15:29:27 +00:00
|
|
|
struct item {
|
|
|
|
struct item *next;
|
|
|
|
unsigned int len;
|
|
|
|
unsigned int hash;
|
modpost,fixdep: Replace zero-length array with flexible-array
The current codebase makes use of the zero-length array language
extension to the C90 standard, but the preferred mechanism to declare
variable-length types such as these ones is a flexible array member[1][2],
introduced in C99:
struct foo {
int stuff;
struct boo array[];
};
By making use of the mechanism above, we will get a compiler warning
in case the flexible array does not occur last in the structure, which
will help us prevent some kind of undefined behavior bugs from being
inadvertently introduced[3] to the codebase from now on.
Also, notice that, dynamic memory allocations won't be affected by
this change:
"Flexible array members have incomplete type, and so the sizeof operator
may not be applied. As a quirk of the original implementation of
zero-length arrays, sizeof evaluates to zero."[1]
sizeof(flexible-array-member) triggers a warning because flexible array
members have incomplete type[1]. There are some instances of code in
which the sizeof operator is being incorrectly/erroneously applied to
zero-length arrays and the result is zero. Such instances may be hiding
some bugs. So, this work (flexible-array member conversions) will also
help to get completely rid of those sorts of issues.
This issue was found with the help of Coccinelle.
[1] https://gcc.gnu.org/onlinedocs/gcc/Zero-Length.html
[2] https://github.com/KSPP/linux/issues/21
[3] commit 76497732932f ("cxgb3/l2t: Fix undefined behaviour")
Signed-off-by: Gustavo A. R. Silva <gustavoars@kernel.org>
Signed-off-by: Masahiro Yamada <masahiroy@kernel.org>
2020-05-07 18:56:01 +00:00
|
|
|
char name[];
|
2010-11-09 15:29:27 +00:00
|
|
|
};
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-11-09 15:29:27 +00:00
|
|
|
#define HASHSZ 256
|
|
|
|
static struct item *hashtab[HASHSZ];
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-11-09 15:29:27 +00:00
|
|
|
static unsigned int strhash(const char *str, unsigned int sz)
|
|
|
|
{
|
|
|
|
/* fnv32 hash */
|
|
|
|
unsigned int i, hash = 2166136261U;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-11-09 15:29:27 +00:00
|
|
|
for (i = 0; i < sz; i++)
|
|
|
|
hash = (hash ^ str[i]) * 0x01000193;
|
|
|
|
return hash;
|
|
|
|
}
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Lookup a value in the configuration string.
|
|
|
|
*/
|
2010-11-09 15:29:27 +00:00
|
|
|
static int is_defined_config(const char *name, int len, unsigned int hash)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2010-11-09 15:29:27 +00:00
|
|
|
struct item *aux;
|
|
|
|
|
|
|
|
for (aux = hashtab[hash % HASHSZ]; aux; aux = aux->next) {
|
|
|
|
if (aux->hash == hash && aux->len == len &&
|
|
|
|
memcmp(aux->name, name, len) == 0)
|
2005-04-16 22:20:36 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Add a new value to the configuration string.
|
|
|
|
*/
|
2010-11-09 15:29:27 +00:00
|
|
|
static void define_config(const char *name, int len, unsigned int hash)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2010-11-09 15:29:27 +00:00
|
|
|
struct item *aux = malloc(sizeof(*aux) + len);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-11-09 15:29:27 +00:00
|
|
|
if (!aux) {
|
|
|
|
perror("fixdep:malloc");
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
memcpy(aux->name, name, len);
|
|
|
|
aux->len = len;
|
|
|
|
aux->hash = hash;
|
|
|
|
aux->next = hashtab[hash % HASHSZ];
|
|
|
|
hashtab[hash % HASHSZ] = aux;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Record the use of a CONFIG_* word.
|
|
|
|
*/
|
2010-11-09 15:29:27 +00:00
|
|
|
static void use_config(const char *m, int slen)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2010-11-09 15:29:27 +00:00
|
|
|
unsigned int hash = strhash(m, slen);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2010-11-09 15:29:27 +00:00
|
|
|
if (is_defined_config(m, slen, hash))
|
2005-04-16 22:20:36 +00:00
|
|
|
return;
|
|
|
|
|
2010-11-09 15:29:27 +00:00
|
|
|
define_config(m, slen, hash);
|
2021-04-15 17:36:07 +00:00
|
|
|
/* Print out a dependency path from a symbol name. */
|
fixdep: use fflush() and ferror() to ensure successful write to files
Currently, fixdep checks the return value from (v)printf(), but it does
not ensure the complete write to the .cmd file.
printf() just writes data to the internal buffer, which usually succeeds.
(Of course, it may fail for another reason, for example when the file
descriptor is closed, but that is another story.)
When the buffer (4k?) is full, an actual write occurs, and printf() may
really fail. One of typical cases is "No space left on device" when the
disk is full.
The data remaining in the buffer will be pushed out to the file when
the program exits, but we never know if it is successful.
One straight-forward fix would be to add the following code at the end
of the program.
ret = fflush(stdout);
if (ret < 0) {
/* error handling */
}
However, it is tedious to check the return code in all the call sites
of printf(), fflush(), fclose(), and whatever can cause actual writes
to the end device. Doing that lets the program bail out at the first
failure but is usually not worth the effort.
Instead, let's check the error status from ferror(). This is 'sticky',
so you need to check it just once. You still need to call fflush().
Signed-off-by: Masahiro Yamada <masahiroy@kernel.org>
Reviewed-by: David Laight <david.laight@aculab.com>
Reviewed-by: Nick Desaulniers <ndesaulniers@google.com>
2022-03-06 07:25:35 +00:00
|
|
|
printf(" $(wildcard include/config/%.*s) \\\n", slen, m);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2018-01-11 13:05:46 +00:00
|
|
|
/* test if s ends in sub */
|
|
|
|
static int str_ends_with(const char *s, int slen, const char *sub)
|
|
|
|
{
|
|
|
|
int sublen = strlen(sub);
|
|
|
|
|
|
|
|
if (sublen > slen)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return !memcmp(s + slen - sublen, sub, sublen);
|
|
|
|
}
|
|
|
|
|
2016-08-24 18:03:05 +00:00
|
|
|
static void parse_config_file(const char *p)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2016-08-24 18:03:05 +00:00
|
|
|
const char *q, *r;
|
2018-02-28 19:17:36 +00:00
|
|
|
const char *start = p;
|
2016-08-24 18:03:05 +00:00
|
|
|
|
|
|
|
while ((p = strstr(p, "CONFIG_"))) {
|
2018-02-28 19:17:36 +00:00
|
|
|
if (p > start && (isalnum(p[-1]) || p[-1] == '_')) {
|
|
|
|
p += 7;
|
|
|
|
continue;
|
|
|
|
}
|
2015-07-24 05:18:45 +00:00
|
|
|
p += 7;
|
2016-08-24 18:03:05 +00:00
|
|
|
q = p;
|
2020-02-18 10:00:31 +00:00
|
|
|
while (isalnum(*q) || *q == '_')
|
2016-08-24 18:03:05 +00:00
|
|
|
q++;
|
2018-01-11 13:05:46 +00:00
|
|
|
if (str_ends_with(p, q - p, "_MODULE"))
|
2016-08-24 18:03:05 +00:00
|
|
|
r = q - 7;
|
|
|
|
else
|
|
|
|
r = q;
|
|
|
|
if (r > p)
|
|
|
|
use_config(p, r - p);
|
|
|
|
p = q;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-01-11 13:05:42 +00:00
|
|
|
static void *read_file(const char *filename)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
struct stat st;
|
|
|
|
int fd;
|
2018-01-11 13:05:42 +00:00
|
|
|
char *buf;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
fd = open(filename, O_RDONLY);
|
|
|
|
if (fd < 0) {
|
2018-01-11 13:05:42 +00:00
|
|
|
fprintf(stderr, "fixdep: error opening file: ");
|
2005-04-16 22:20:36 +00:00
|
|
|
perror(filename);
|
|
|
|
exit(2);
|
|
|
|
}
|
2015-12-07 21:26:08 +00:00
|
|
|
if (fstat(fd, &st) < 0) {
|
2018-01-11 13:05:42 +00:00
|
|
|
fprintf(stderr, "fixdep: error fstat'ing file: ");
|
2015-12-07 21:26:08 +00:00
|
|
|
perror(filename);
|
|
|
|
exit(2);
|
|
|
|
}
|
2018-01-11 13:05:42 +00:00
|
|
|
buf = malloc(st.st_size + 1);
|
|
|
|
if (!buf) {
|
2016-08-24 18:03:05 +00:00
|
|
|
perror("fixdep: malloc");
|
2018-01-08 10:04:01 +00:00
|
|
|
exit(2);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2018-01-11 13:05:42 +00:00
|
|
|
if (read(fd, buf, st.st_size) != st.st_size) {
|
2016-08-24 18:03:05 +00:00
|
|
|
perror("fixdep: read");
|
2018-01-08 10:04:01 +00:00
|
|
|
exit(2);
|
2016-08-24 18:03:05 +00:00
|
|
|
}
|
2018-01-11 13:05:42 +00:00
|
|
|
buf[st.st_size] = '\0';
|
2016-08-24 18:03:05 +00:00
|
|
|
close(fd);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2018-01-11 13:05:42 +00:00
|
|
|
return buf;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2018-01-11 13:05:45 +00:00
|
|
|
/* Ignore certain dependencies */
|
|
|
|
static int is_ignored_file(const char *s, int len)
|
|
|
|
{
|
|
|
|
return str_ends_with(s, len, "include/generated/autoconf.h") ||
|
2020-02-18 09:58:59 +00:00
|
|
|
str_ends_with(s, len, "include/generated/autoksyms.h");
|
2018-01-11 13:05:45 +00:00
|
|
|
}
|
|
|
|
|
2011-03-11 21:34:47 +00:00
|
|
|
/*
|
|
|
|
* Important: The below generated source_foo.o and deps_foo.o variable
|
|
|
|
* assignments are parsed not only by make, but also by the rather simple
|
|
|
|
* parser in scripts/mod/sumversion.c.
|
|
|
|
*/
|
2018-11-30 01:05:26 +00:00
|
|
|
static void parse_dep_file(char *m, const char *target)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2005-06-25 21:59:22 +00:00
|
|
|
char *p;
|
2018-01-11 13:05:41 +00:00
|
|
|
int is_last, is_target;
|
kbuild: fixdep: support concatenated dep files
The current use-case for fixdep is: a source file is run through a single
processing step, which creates a single dependency file as a side-effect,
which fixdep transforms into the file used by the kernel build process.
In order to transparently run the C pre-processor on device-tree files,
we wish to run both gcc -E and dtc on a source file in a single rule.
This generates two dependency files, which must be transformed together
into the file used by the kernel build process. This change modifies
fixdep so it can process the concatenation of multiple separate input
dependency files, and produce a correct unified output.
The code changes have the slight benefit of transforming the loop in
parse_dep_file() into more of a lexer/tokenizer, with the loop body being
more of a parser. Previously, some of this logic was mixed together
before the loop. I also added some comments, which I hope are useful.
Benchmarking shows that on a cross-compiled ARM tegra_defconfig build,
there is less than 0.5 seconds speed decrease with this change, on top
of a build time of ~2m24s. This is probably within the noise.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Acked-by: Rob Herring <rob.herring@calxeda.com>
2013-03-06 17:27:45 +00:00
|
|
|
int saw_any_target = 0;
|
|
|
|
int is_first_dep = 0;
|
2018-01-11 13:05:42 +00:00
|
|
|
void *buf;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2018-01-11 13:05:41 +00:00
|
|
|
while (1) {
|
kbuild: fixdep: support concatenated dep files
The current use-case for fixdep is: a source file is run through a single
processing step, which creates a single dependency file as a side-effect,
which fixdep transforms into the file used by the kernel build process.
In order to transparently run the C pre-processor on device-tree files,
we wish to run both gcc -E and dtc on a source file in a single rule.
This generates two dependency files, which must be transformed together
into the file used by the kernel build process. This change modifies
fixdep so it can process the concatenation of multiple separate input
dependency files, and produce a correct unified output.
The code changes have the slight benefit of transforming the loop in
parse_dep_file() into more of a lexer/tokenizer, with the loop body being
more of a parser. Previously, some of this logic was mixed together
before the loop. I also added some comments, which I hope are useful.
Benchmarking shows that on a cross-compiled ARM tegra_defconfig build,
there is less than 0.5 seconds speed decrease with this change, on top
of a build time of ~2m24s. This is probably within the noise.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Acked-by: Rob Herring <rob.herring@calxeda.com>
2013-03-06 17:27:45 +00:00
|
|
|
/* Skip any "white space" */
|
2018-01-11 13:05:41 +00:00
|
|
|
while (*m == ' ' || *m == '\\' || *m == '\n')
|
2005-04-16 22:20:36 +00:00
|
|
|
m++;
|
2018-01-11 13:05:41 +00:00
|
|
|
|
|
|
|
if (!*m)
|
|
|
|
break;
|
|
|
|
|
kbuild: fixdep: support concatenated dep files
The current use-case for fixdep is: a source file is run through a single
processing step, which creates a single dependency file as a side-effect,
which fixdep transforms into the file used by the kernel build process.
In order to transparently run the C pre-processor on device-tree files,
we wish to run both gcc -E and dtc on a source file in a single rule.
This generates two dependency files, which must be transformed together
into the file used by the kernel build process. This change modifies
fixdep so it can process the concatenation of multiple separate input
dependency files, and produce a correct unified output.
The code changes have the slight benefit of transforming the loop in
parse_dep_file() into more of a lexer/tokenizer, with the loop body being
more of a parser. Previously, some of this logic was mixed together
before the loop. I also added some comments, which I hope are useful.
Benchmarking shows that on a cross-compiled ARM tegra_defconfig build,
there is less than 0.5 seconds speed decrease with this change, on top
of a build time of ~2m24s. This is probably within the noise.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Acked-by: Rob Herring <rob.herring@calxeda.com>
2013-03-06 17:27:45 +00:00
|
|
|
/* Find next "white space" */
|
2005-04-16 22:20:36 +00:00
|
|
|
p = m;
|
2018-01-11 13:05:41 +00:00
|
|
|
while (*p && *p != ' ' && *p != '\\' && *p != '\n')
|
2005-04-16 22:20:36 +00:00
|
|
|
p++;
|
2018-01-11 13:05:41 +00:00
|
|
|
is_last = (*p == '\0');
|
kbuild: fixdep: support concatenated dep files
The current use-case for fixdep is: a source file is run through a single
processing step, which creates a single dependency file as a side-effect,
which fixdep transforms into the file used by the kernel build process.
In order to transparently run the C pre-processor on device-tree files,
we wish to run both gcc -E and dtc on a source file in a single rule.
This generates two dependency files, which must be transformed together
into the file used by the kernel build process. This change modifies
fixdep so it can process the concatenation of multiple separate input
dependency files, and produce a correct unified output.
The code changes have the slight benefit of transforming the loop in
parse_dep_file() into more of a lexer/tokenizer, with the loop body being
more of a parser. Previously, some of this logic was mixed together
before the loop. I also added some comments, which I hope are useful.
Benchmarking shows that on a cross-compiled ARM tegra_defconfig build,
there is less than 0.5 seconds speed decrease with this change, on top
of a build time of ~2m24s. This is probably within the noise.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Acked-by: Rob Herring <rob.herring@calxeda.com>
2013-03-06 17:27:45 +00:00
|
|
|
/* Is the token we found a target name? */
|
|
|
|
is_target = (*(p-1) == ':');
|
|
|
|
/* Don't write any target names into the dependency file */
|
|
|
|
if (is_target) {
|
|
|
|
/* The /next/ file is the first dependency */
|
|
|
|
is_first_dep = 1;
|
2018-01-11 13:05:45 +00:00
|
|
|
} else if (!is_ignored_file(m, p - m)) {
|
2018-01-11 13:05:43 +00:00
|
|
|
*p = '\0';
|
kbuild: fixdep: support concatenated dep files
The current use-case for fixdep is: a source file is run through a single
processing step, which creates a single dependency file as a side-effect,
which fixdep transforms into the file used by the kernel build process.
In order to transparently run the C pre-processor on device-tree files,
we wish to run both gcc -E and dtc on a source file in a single rule.
This generates two dependency files, which must be transformed together
into the file used by the kernel build process. This change modifies
fixdep so it can process the concatenation of multiple separate input
dependency files, and produce a correct unified output.
The code changes have the slight benefit of transforming the loop in
parse_dep_file() into more of a lexer/tokenizer, with the loop body being
more of a parser. Previously, some of this logic was mixed together
before the loop. I also added some comments, which I hope are useful.
Benchmarking shows that on a cross-compiled ARM tegra_defconfig build,
there is less than 0.5 seconds speed decrease with this change, on top
of a build time of ~2m24s. This is probably within the noise.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Acked-by: Rob Herring <rob.herring@calxeda.com>
2013-03-06 17:27:45 +00:00
|
|
|
|
2018-01-11 13:05:45 +00:00
|
|
|
/*
|
|
|
|
* Do not list the source file as dependency, so that
|
|
|
|
* kbuild is not confused if a .c file is rewritten
|
|
|
|
* into .S or vice versa. Storing it in source_* is
|
|
|
|
* needed for modpost to compute srcversions.
|
|
|
|
*/
|
|
|
|
if (is_first_dep) {
|
kbuild: fixdep: support concatenated dep files
The current use-case for fixdep is: a source file is run through a single
processing step, which creates a single dependency file as a side-effect,
which fixdep transforms into the file used by the kernel build process.
In order to transparently run the C pre-processor on device-tree files,
we wish to run both gcc -E and dtc on a source file in a single rule.
This generates two dependency files, which must be transformed together
into the file used by the kernel build process. This change modifies
fixdep so it can process the concatenation of multiple separate input
dependency files, and produce a correct unified output.
The code changes have the slight benefit of transforming the loop in
parse_dep_file() into more of a lexer/tokenizer, with the loop body being
more of a parser. Previously, some of this logic was mixed together
before the loop. I also added some comments, which I hope are useful.
Benchmarking shows that on a cross-compiled ARM tegra_defconfig build,
there is less than 0.5 seconds speed decrease with this change, on top
of a build time of ~2m24s. This is probably within the noise.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Acked-by: Rob Herring <rob.herring@calxeda.com>
2013-03-06 17:27:45 +00:00
|
|
|
/*
|
2018-01-11 13:05:45 +00:00
|
|
|
* If processing the concatenation of multiple
|
|
|
|
* dependency files, only process the first
|
|
|
|
* target name, which will be the original
|
|
|
|
* source name, and ignore any other target
|
|
|
|
* names, which will be intermediate temporary
|
|
|
|
* files.
|
kbuild: fixdep: support concatenated dep files
The current use-case for fixdep is: a source file is run through a single
processing step, which creates a single dependency file as a side-effect,
which fixdep transforms into the file used by the kernel build process.
In order to transparently run the C pre-processor on device-tree files,
we wish to run both gcc -E and dtc on a source file in a single rule.
This generates two dependency files, which must be transformed together
into the file used by the kernel build process. This change modifies
fixdep so it can process the concatenation of multiple separate input
dependency files, and produce a correct unified output.
The code changes have the slight benefit of transforming the loop in
parse_dep_file() into more of a lexer/tokenizer, with the loop body being
more of a parser. Previously, some of this logic was mixed together
before the loop. I also added some comments, which I hope are useful.
Benchmarking shows that on a cross-compiled ARM tegra_defconfig build,
there is less than 0.5 seconds speed decrease with this change, on top
of a build time of ~2m24s. This is probably within the noise.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Acked-by: Rob Herring <rob.herring@calxeda.com>
2013-03-06 17:27:45 +00:00
|
|
|
*/
|
2018-01-11 13:05:45 +00:00
|
|
|
if (!saw_any_target) {
|
|
|
|
saw_any_target = 1;
|
fixdep: use fflush() and ferror() to ensure successful write to files
Currently, fixdep checks the return value from (v)printf(), but it does
not ensure the complete write to the .cmd file.
printf() just writes data to the internal buffer, which usually succeeds.
(Of course, it may fail for another reason, for example when the file
descriptor is closed, but that is another story.)
When the buffer (4k?) is full, an actual write occurs, and printf() may
really fail. One of typical cases is "No space left on device" when the
disk is full.
The data remaining in the buffer will be pushed out to the file when
the program exits, but we never know if it is successful.
One straight-forward fix would be to add the following code at the end
of the program.
ret = fflush(stdout);
if (ret < 0) {
/* error handling */
}
However, it is tedious to check the return code in all the call sites
of printf(), fflush(), fclose(), and whatever can cause actual writes
to the end device. Doing that lets the program bail out at the first
failure but is usually not worth the effort.
Instead, let's check the error status from ferror(). This is 'sticky',
so you need to check it just once. You still need to call fflush().
Signed-off-by: Masahiro Yamada <masahiroy@kernel.org>
Reviewed-by: David Laight <david.laight@aculab.com>
Reviewed-by: Nick Desaulniers <ndesaulniers@google.com>
2022-03-06 07:25:35 +00:00
|
|
|
printf("source_%s := %s\n\n",
|
|
|
|
target, m);
|
|
|
|
printf("deps_%s := \\\n", target);
|
2018-01-11 13:05:45 +00:00
|
|
|
}
|
|
|
|
is_first_dep = 0;
|
|
|
|
} else {
|
fixdep: use fflush() and ferror() to ensure successful write to files
Currently, fixdep checks the return value from (v)printf(), but it does
not ensure the complete write to the .cmd file.
printf() just writes data to the internal buffer, which usually succeeds.
(Of course, it may fail for another reason, for example when the file
descriptor is closed, but that is another story.)
When the buffer (4k?) is full, an actual write occurs, and printf() may
really fail. One of typical cases is "No space left on device" when the
disk is full.
The data remaining in the buffer will be pushed out to the file when
the program exits, but we never know if it is successful.
One straight-forward fix would be to add the following code at the end
of the program.
ret = fflush(stdout);
if (ret < 0) {
/* error handling */
}
However, it is tedious to check the return code in all the call sites
of printf(), fflush(), fclose(), and whatever can cause actual writes
to the end device. Doing that lets the program bail out at the first
failure but is usually not worth the effort.
Instead, let's check the error status from ferror(). This is 'sticky',
so you need to check it just once. You still need to call fflush().
Signed-off-by: Masahiro Yamada <masahiroy@kernel.org>
Reviewed-by: David Laight <david.laight@aculab.com>
Reviewed-by: Nick Desaulniers <ndesaulniers@google.com>
2022-03-06 07:25:35 +00:00
|
|
|
printf(" %s \\\n", m);
|
kbuild: fixdep: support concatenated dep files
The current use-case for fixdep is: a source file is run through a single
processing step, which creates a single dependency file as a side-effect,
which fixdep transforms into the file used by the kernel build process.
In order to transparently run the C pre-processor on device-tree files,
we wish to run both gcc -E and dtc on a source file in a single rule.
This generates two dependency files, which must be transformed together
into the file used by the kernel build process. This change modifies
fixdep so it can process the concatenation of multiple separate input
dependency files, and produce a correct unified output.
The code changes have the slight benefit of transforming the loop in
parse_dep_file() into more of a lexer/tokenizer, with the loop body being
more of a parser. Previously, some of this logic was mixed together
before the loop. I also added some comments, which I hope are useful.
Benchmarking shows that on a cross-compiled ARM tegra_defconfig build,
there is less than 0.5 seconds speed decrease with this change, on top
of a build time of ~2m24s. This is probably within the noise.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Acked-by: Rob Herring <rob.herring@calxeda.com>
2013-03-06 17:27:45 +00:00
|
|
|
}
|
2018-01-11 13:05:45 +00:00
|
|
|
|
|
|
|
buf = read_file(m);
|
|
|
|
parse_config_file(buf);
|
|
|
|
free(buf);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
2018-01-11 13:05:41 +00:00
|
|
|
|
|
|
|
if (is_last)
|
|
|
|
break;
|
|
|
|
|
kbuild: fixdep: support concatenated dep files
The current use-case for fixdep is: a source file is run through a single
processing step, which creates a single dependency file as a side-effect,
which fixdep transforms into the file used by the kernel build process.
In order to transparently run the C pre-processor on device-tree files,
we wish to run both gcc -E and dtc on a source file in a single rule.
This generates two dependency files, which must be transformed together
into the file used by the kernel build process. This change modifies
fixdep so it can process the concatenation of multiple separate input
dependency files, and produce a correct unified output.
The code changes have the slight benefit of transforming the loop in
parse_dep_file() into more of a lexer/tokenizer, with the loop body being
more of a parser. Previously, some of this logic was mixed together
before the loop. I also added some comments, which I hope are useful.
Benchmarking shows that on a cross-compiled ARM tegra_defconfig build,
there is less than 0.5 seconds speed decrease with this change, on top
of a build time of ~2m24s. This is probably within the noise.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Acked-by: Rob Herring <rob.herring@calxeda.com>
2013-03-06 17:27:45 +00:00
|
|
|
/*
|
|
|
|
* Start searching for next token immediately after the first
|
|
|
|
* "whitespace" character that follows this token.
|
|
|
|
*/
|
2005-04-16 22:20:36 +00:00
|
|
|
m = p + 1;
|
|
|
|
}
|
kbuild: fixdep: support concatenated dep files
The current use-case for fixdep is: a source file is run through a single
processing step, which creates a single dependency file as a side-effect,
which fixdep transforms into the file used by the kernel build process.
In order to transparently run the C pre-processor on device-tree files,
we wish to run both gcc -E and dtc on a source file in a single rule.
This generates two dependency files, which must be transformed together
into the file used by the kernel build process. This change modifies
fixdep so it can process the concatenation of multiple separate input
dependency files, and produce a correct unified output.
The code changes have the slight benefit of transforming the loop in
parse_dep_file() into more of a lexer/tokenizer, with the loop body being
more of a parser. Previously, some of this logic was mixed together
before the loop. I also added some comments, which I hope are useful.
Benchmarking shows that on a cross-compiled ARM tegra_defconfig build,
there is less than 0.5 seconds speed decrease with this change, on top
of a build time of ~2m24s. This is probably within the noise.
Signed-off-by: Stephen Warren <swarren@nvidia.com>
Acked-by: Rob Herring <rob.herring@calxeda.com>
2013-03-06 17:27:45 +00:00
|
|
|
|
|
|
|
if (!saw_any_target) {
|
|
|
|
fprintf(stderr, "fixdep: parse error; no targets found\n");
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
fixdep: use fflush() and ferror() to ensure successful write to files
Currently, fixdep checks the return value from (v)printf(), but it does
not ensure the complete write to the .cmd file.
printf() just writes data to the internal buffer, which usually succeeds.
(Of course, it may fail for another reason, for example when the file
descriptor is closed, but that is another story.)
When the buffer (4k?) is full, an actual write occurs, and printf() may
really fail. One of typical cases is "No space left on device" when the
disk is full.
The data remaining in the buffer will be pushed out to the file when
the program exits, but we never know if it is successful.
One straight-forward fix would be to add the following code at the end
of the program.
ret = fflush(stdout);
if (ret < 0) {
/* error handling */
}
However, it is tedious to check the return code in all the call sites
of printf(), fflush(), fclose(), and whatever can cause actual writes
to the end device. Doing that lets the program bail out at the first
failure but is usually not worth the effort.
Instead, let's check the error status from ferror(). This is 'sticky',
so you need to check it just once. You still need to call fflush().
Signed-off-by: Masahiro Yamada <masahiroy@kernel.org>
Reviewed-by: David Laight <david.laight@aculab.com>
Reviewed-by: Nick Desaulniers <ndesaulniers@google.com>
2022-03-06 07:25:35 +00:00
|
|
|
printf("\n%s: $(deps_%s)\n\n", target, target);
|
|
|
|
printf("$(deps_%s):\n", target);
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int main(int argc, char *argv[])
|
|
|
|
{
|
2018-01-11 13:05:44 +00:00
|
|
|
const char *depfile, *target, *cmdline;
|
2018-01-11 13:05:42 +00:00
|
|
|
void *buf;
|
|
|
|
|
2018-11-30 01:05:26 +00:00
|
|
|
if (argc != 4)
|
2005-04-16 22:20:36 +00:00
|
|
|
usage();
|
|
|
|
|
|
|
|
depfile = argv[1];
|
|
|
|
target = argv[2];
|
|
|
|
cmdline = argv[3];
|
|
|
|
|
fixdep: use fflush() and ferror() to ensure successful write to files
Currently, fixdep checks the return value from (v)printf(), but it does
not ensure the complete write to the .cmd file.
printf() just writes data to the internal buffer, which usually succeeds.
(Of course, it may fail for another reason, for example when the file
descriptor is closed, but that is another story.)
When the buffer (4k?) is full, an actual write occurs, and printf() may
really fail. One of typical cases is "No space left on device" when the
disk is full.
The data remaining in the buffer will be pushed out to the file when
the program exits, but we never know if it is successful.
One straight-forward fix would be to add the following code at the end
of the program.
ret = fflush(stdout);
if (ret < 0) {
/* error handling */
}
However, it is tedious to check the return code in all the call sites
of printf(), fflush(), fclose(), and whatever can cause actual writes
to the end device. Doing that lets the program bail out at the first
failure but is usually not worth the effort.
Instead, let's check the error status from ferror(). This is 'sticky',
so you need to check it just once. You still need to call fflush().
Signed-off-by: Masahiro Yamada <masahiroy@kernel.org>
Reviewed-by: David Laight <david.laight@aculab.com>
Reviewed-by: Nick Desaulniers <ndesaulniers@google.com>
2022-03-06 07:25:35 +00:00
|
|
|
printf("cmd_%s := %s\n\n", target, cmdline);
|
2018-01-11 13:05:42 +00:00
|
|
|
|
|
|
|
buf = read_file(depfile);
|
2018-11-30 01:05:26 +00:00
|
|
|
parse_dep_file(buf, target);
|
2018-01-11 13:05:42 +00:00
|
|
|
free(buf);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
fixdep: use fflush() and ferror() to ensure successful write to files
Currently, fixdep checks the return value from (v)printf(), but it does
not ensure the complete write to the .cmd file.
printf() just writes data to the internal buffer, which usually succeeds.
(Of course, it may fail for another reason, for example when the file
descriptor is closed, but that is another story.)
When the buffer (4k?) is full, an actual write occurs, and printf() may
really fail. One of typical cases is "No space left on device" when the
disk is full.
The data remaining in the buffer will be pushed out to the file when
the program exits, but we never know if it is successful.
One straight-forward fix would be to add the following code at the end
of the program.
ret = fflush(stdout);
if (ret < 0) {
/* error handling */
}
However, it is tedious to check the return code in all the call sites
of printf(), fflush(), fclose(), and whatever can cause actual writes
to the end device. Doing that lets the program bail out at the first
failure but is usually not worth the effort.
Instead, let's check the error status from ferror(). This is 'sticky',
so you need to check it just once. You still need to call fflush().
Signed-off-by: Masahiro Yamada <masahiroy@kernel.org>
Reviewed-by: David Laight <david.laight@aculab.com>
Reviewed-by: Nick Desaulniers <ndesaulniers@google.com>
2022-03-06 07:25:35 +00:00
|
|
|
fflush(stdout);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* In the intended usage, the stdout is redirected to .*.cmd files.
|
|
|
|
* Call ferror() to catch errors such as "No space left on device".
|
|
|
|
*/
|
|
|
|
if (ferror(stdout)) {
|
|
|
|
fprintf(stderr, "fixdep: not all data was written to the output\n");
|
|
|
|
exit(1);
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
return 0;
|
|
|
|
}
|