linux/scripts/basic/fixdep.c at master · flexbed/linux · GitHub

History

400 lines (356 loc) · 9.84 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

* "Optimize" a list of dependencies as spit out by gcc -MD

* for the kernel build

* ===========================================================================

* Author Kai Germaschewski

* 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

* every file in the kernel includes autoconf.h.

* If the user re-runs make *config, autoconf.h will be

* 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

* the dependency on autoconf.h by a dependency on every config

* option which is mentioned in any of the listed prerequisites.

* 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.

* So if the user changes his CONFIG_HIS_DRIVER option, only the objects

* which depend on "include/config/his/driver.h" will be rebuilt,

* 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

* process filtering out the dependency on autoconf.h and adding

* dependencies on include/config/my/option.h for every

* CONFIG_MY_OPTION encountered in any of the prerequisites.

* It will also filter out all the dependencies on *.ver. We need

* to make sure that the generated version checksum are globally up

* to date before even starting the recursive build, so it's too late

* at this point anyway.

* We don't even try to really parse the header files, but

* 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>

static void usage(void)

{

fprintf(stderr, "Usage: fixdep [-e] <depfile> <target> <cmdline>\n");

fprintf(stderr, " -e insert extra dependencies given on stdin\n");

exit(1);

}

* Print out a dependency path from a symbol name

static void print_dep(const char *m, int slen, const char *dir)

{

int c, i;

printf(" $(wildcard %s/", dir);

for (i = 0; i < slen; i++) {

c = m[i];

if (c == '_')

c = '/';

else

c = tolower(c);

putchar(c);

}

printf(".h) \\\n");

}

static void do_extra_deps(void)

{

char buf[80];

while (fgets(buf, sizeof(buf), stdin)) {

int len = strlen(buf);

if (len < 2 || buf[len - 1] != '\n') {

fprintf(stderr, "fixdep: bad data on stdin\n");

exit(1);

}

print_dep(buf, len - 1, "include/ksym");

}

struct item {

struct item *next;

unsigned int len;

unsigned int hash;

char name[0];

};

#define HASHSZ 256

static struct item *hashtab[HASHSZ];

static unsigned int strhash(const char *str, unsigned int sz)

{

/* fnv32 hash */

unsigned int i, hash = 2166136261U;

for (i = 0; i < sz; i++)

hash = (hash ^ str[i]) * 0x01000193;

return hash;

}

* Lookup a value in the configuration string.

static int is_defined_config(const char *name, int len, unsigned int hash)

{

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)

return 1;

}

return 0;

}

* Add a new value to the configuration string.

static void define_config(const char *name, int len, unsigned int hash)

{

struct item *aux = malloc(sizeof(*aux) + len);

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;

}

* Record the use of a CONFIG_* word.

static void use_config(const char *m, int slen)

{

unsigned int hash = strhash(m, slen);

if (is_defined_config(m, slen, hash))

return;

define_config(m, slen, hash);

print_dep(m, slen, "include/config");

}

/* 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);

}

static void parse_config_file(const char *p)

{

const char *q, *r;

const char *start = p;

while ((p = strstr(p, "CONFIG_"))) {

if (p > start && (isalnum(p[-1]) || p[-1] == '_')) {

p += 7;

continue;

}

p += 7;

q = p;

while (*q && (isalnum(*q) || *q == '_'))

q++;

if (str_ends_with(p, q - p, "_MODULE"))

r = q - 7;

else

r = q;

if (r > p)

use_config(p, r - p);

p = q;

}

static void *read_file(const char *filename)

{

struct stat st;

int fd;

char *buf;

fd = open(filename, O_RDONLY);

if (fd < 0) {

fprintf(stderr, "fixdep: error opening file: ");

perror(filename);

exit(2);

}

if (fstat(fd, &st) < 0) {

fprintf(stderr, "fixdep: error fstat'ing file: ");

perror(filename);

exit(2);

}

buf = malloc(st.st_size + 1);

if (!buf) {

perror("fixdep: malloc");

exit(2);

}

if (read(fd, buf, st.st_size) != st.st_size) {

perror("fixdep: read");

exit(2);

}

buf[st.st_size] = '\0';

close(fd);

return buf;

}

/* Ignore certain dependencies */

static int is_ignored_file(const char *s, int len)

{

return str_ends_with(s, len, "include/generated/autoconf.h") ||

str_ends_with(s, len, "include/generated/autoksyms.h") ||

str_ends_with(s, len, ".ver");

}

* 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.

static void parse_dep_file(char *m, const char *target, int insert_extra_deps)

{

char *p;

int is_last, is_target;

int saw_any_target = 0;

int is_first_dep = 0;

void *buf;

while (1) {

/* Skip any "white space" */

while (*m == ' ' || *m == '\\' || *m == '\n')

m++;

if (!*m)

break;

/* Find next "white space" */

p = m;

while (*p && *p != ' ' && *p != '\\' && *p != '\n')

p++;

is_last = (*p == '\0');

/* 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;

} else if (!is_ignored_file(m, p - m)) {

*p = '\0';

* 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) {

* 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.

if (!saw_any_target) {

saw_any_target = 1;

printf("source_%s := %s\n\n",

target, m);

printf("deps_%s := \\\n", target);

}

is_first_dep = 0;

} else {

printf(" %s \\\n", m);

}

buf = read_file(m);

parse_config_file(buf);

free(buf);

}

if (is_last)

break;

* Start searching for next token immediately after the first

* "whitespace" character that follows this token.

m = p + 1;

}

if (!saw_any_target) {

fprintf(stderr, "fixdep: parse error; no targets found\n");

exit(1);

}

if (insert_extra_deps)

do_extra_deps();

printf("\n%s: $(deps_%s)\n\n", target, target);

printf("$(deps_%s):\n", target);

}

int main(int argc, char *argv[])

{

const char *depfile, *target, *cmdline;

int insert_extra_deps = 0;

void *buf;

if (argc == 5 && !strcmp(argv[1], "-e")) {

insert_extra_deps = 1;

argv++;

} else if (argc != 4)

usage();

depfile = argv[1];

target = argv[2];

cmdline = argv[3];

printf("cmd_%s := %s\n\n", target, cmdline);

buf = read_file(depfile);

parse_dep_file(buf, target, insert_extra_deps);

free(buf);

return 0;

}

linux/scripts/basic/fixdep.c at master · flexbed/linux · GitHub

Expand file tree

Breadcrumbs

fixdep.c

Latest commit

History

Breadcrumbs

fixdep.c

File metadata and controls