VirtualBox

source: kBuild/trunk/src/kObjCache/kObjCache.c@ 2620

Last change on this file since 2620 was 2620, checked in by bird, 13 years ago

Try hardlink object files.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 159.2 KB
Line 
1/* $Id: kObjCache.c 2620 2012-08-02 04:02:29Z bird $ */
2/** @file
3 * kObjCache - Object Cache.
4 */
5
6/*
7 * Copyright (c) 2007-2012 knut st. osmundsen <[email protected]>
8 *
9 * This file is part of kBuild.
10 *
11 * kBuild is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 3 of the License, or
14 * (at your option) any later version.
15 *
16 * kBuild is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with kBuild. If not, see <http://www.gnu.org/licenses/>
23 *
24 */
25
26/*******************************************************************************
27* Header Files *
28*******************************************************************************/
29#if 0
30# define ELECTRIC_HEAP
31# include "../kmk/electric.h"
32#endif
33#include <string.h>
34#include <stdlib.h>
35#include <stdarg.h>
36#include <stdio.h>
37#include <errno.h>
38#include <assert.h>
39#include <sys/stat.h>
40#include <fcntl.h>
41#include <limits.h>
42#include <ctype.h>
43#ifndef PATH_MAX
44# define PATH_MAX _MAX_PATH /* windows */
45#endif
46#if defined(__OS2__) || defined(__WIN__)
47# include <process.h>
48# include <io.h>
49# ifdef __OS2__
50# include <unistd.h>
51# include <sys/wait.h>
52# include <sys/time.h>
53# endif
54# if defined(_MSC_VER)
55# include <direct.h>
56 typedef intptr_t pid_t;
57# endif
58# ifndef _P_WAIT
59# define _P_WAIT P_WAIT
60# endif
61# ifndef _P_NOWAIT
62# define _P_NOWAIT P_NOWAIT
63# endif
64#else
65# include <unistd.h>
66# include <sys/wait.h>
67# include <sys/time.h>
68# ifndef O_BINARY
69# define O_BINARY 0
70# endif
71#endif
72#if defined(__WIN__)
73# include <Windows.h>
74# include "quoted_spawn.h"
75#endif
76#if defined(__HAIKU__)
77# include <posix/sys/file.h>
78#endif
79
80#include "crc32.h"
81#include "md5.h"
82#include "kDep.h"
83
84
85/*******************************************************************************
86* Defined Constants And Macros *
87*******************************************************************************/
88/** The max line length in a cache file. */
89#define KOBJCACHE_MAX_LINE_LEN 16384
90#if defined(__WIN__)
91# define PATH_SLASH '\\'
92#else
93# define PATH_SLASH '/'
94#endif
95#if defined(__OS2__) || defined(__WIN__)
96# define IS_SLASH(ch) ((ch) == '/' || (ch) == '\\')
97# define IS_SLASH_DRV(ch) ((ch) == '/' || (ch) == '\\' || (ch) == ':')
98#else
99# define IS_SLASH(ch) ((ch) == '/')
100# define IS_SLASH_DRV(ch) ((ch) == '/')
101#endif
102
103#ifndef STDIN_FILENO
104# define STDIN_FILENO 0
105#endif
106#ifndef STDOUT_FILENO
107# define STDOUT_FILENO 1
108#endif
109#ifndef STDERR_FILENO
110# define STDERR_FILENO 2
111#endif
112
113#define MY_IS_BLANK(a_ch) ((a_ch) == ' ' || (a_ch) == '\t')
114
115#define KOC_BUF_MIN KOC_BUF_ALIGNMENT
116#define KOC_BUF_INCR KOC_BUF_ALIGNMENT
117#define KOC_BUF_ALIGNMENT (4U*1024U*1024U)
118
119
120/*******************************************************************************
121* Global Variables *
122*******************************************************************************/
123/** Whether verbose output is enabled. */
124static unsigned g_cVerbosityLevel = 0;
125/** What to prefix the errors with. */
126static char g_szErrorPrefix[128];
127
128/** Read buffer shared by the cache components. */
129static char g_szLine[KOBJCACHE_MAX_LINE_LEN + 16];
130
131/** How many times we've moved memory around. */
132static size_t g_cMemMoves = 0;
133/** How much memory we've moved. */
134static size_t g_cbMemMoved = 0;
135
136
137/*******************************************************************************
138* Internal Functions *
139*******************************************************************************/
140static char *MakePathFromDirAndFile(const char *pszName, const char *pszDir);
141static char *CalcRelativeName(const char *pszPath, const char *pszDir);
142static FILE *FOpenFileInDir(const char *pszName, const char *pszDir, const char *pszMode);
143static int UnlinkFileInDir(const char *pszName, const char *pszDir);
144static int RenameFileInDir(const char *pszOldName, const char *pszNewName, const char *pszDir);
145static int DoesFileInDirExist(const char *pszName, const char *pszDir);
146static void *ReadFileInDir(const char *pszName, const char *pszDir, size_t *pcbFile);
147
148
149void FatalMsg(const char *pszFormat, ...)
150{
151 va_list va;
152
153 if (g_szErrorPrefix[0])
154 fprintf(stderr, "%s - fatal error: ", g_szErrorPrefix);
155 else
156 fprintf(stderr, "fatal error: ");
157
158 va_start(va, pszFormat);
159 vfprintf(stderr, pszFormat, va);
160 va_end(va);
161}
162
163
164void FatalDie(const char *pszFormat, ...)
165{
166 va_list va;
167
168 if (g_szErrorPrefix[0])
169 fprintf(stderr, "%s - fatal error: ", g_szErrorPrefix);
170 else
171 fprintf(stderr, "fatal error: ");
172
173 va_start(va, pszFormat);
174 vfprintf(stderr, pszFormat, va);
175 va_end(va);
176
177 exit(1);
178}
179
180
181#if 0 /* unused */
182static void ErrorMsg(const char *pszFormat, ...)
183{
184 va_list va;
185
186 if (g_szErrorPrefix[0])
187 fprintf(stderr, "%s - error: ", g_szErrorPrefix);
188 else
189 fprintf(stderr, "error: ");
190
191 va_start(va, pszFormat);
192 vfprintf(stderr, pszFormat, va);
193 va_end(va);
194}
195#endif /* unused */
196
197
198static void InfoMsg(unsigned uLevel, const char *pszFormat, ...)
199{
200 if (uLevel <= g_cVerbosityLevel)
201 {
202 va_list va;
203
204 if (g_szErrorPrefix[0])
205 fprintf(stderr, "%s - info: ", g_szErrorPrefix);
206 else
207 fprintf(stderr, "info: ");
208
209 va_start(va, pszFormat);
210 vfprintf(stderr, pszFormat, va);
211 va_end(va);
212 }
213}
214
215
216static void SetErrorPrefix(const char *pszPrefix, ...)
217{
218 int cch;
219 va_list va;
220
221 va_start(va, pszPrefix);
222#if defined(_MSC_VER) || defined(__sun__)
223 cch = vsprintf(g_szErrorPrefix, pszPrefix, va);
224 if (cch >= sizeof(g_szErrorPrefix))
225 FatalDie("Buffer overflow setting error prefix!\n");
226#else
227 vsnprintf(g_szErrorPrefix, sizeof(g_szErrorPrefix), pszPrefix, va);
228#endif
229 va_end(va);
230 (void)cch;
231}
232
233#ifndef ELECTRIC_HEAP
234void *xmalloc(size_t cb)
235{
236 void *pv = malloc(cb);
237 if (!pv)
238 FatalDie("out of memory (%d)\n", (int)cb);
239 return pv;
240}
241
242
243void *xrealloc(void *pvOld, size_t cb)
244{
245 void *pv = realloc(pvOld, cb);
246 if (!pv)
247 FatalDie("out of memory (%d)\n", (int)cb);
248 return pv;
249}
250
251
252char *xstrdup(const char *pszIn)
253{
254 char *psz;
255 if (pszIn)
256 {
257 psz = strdup(pszIn);
258 if (!psz)
259 FatalDie("out of memory (%d)\n", (int)strlen(pszIn));
260 }
261 else
262 psz = NULL;
263 return psz;
264}
265#endif
266
267
268void *xmallocz(size_t cb)
269{
270 void *pv = xmalloc(cb);
271 memset(pv, 0, cb);
272 return pv;
273}
274
275
276
277
278
279/**
280 * Returns a millisecond timestamp.
281 *
282 * @returns Millisecond timestamp.
283 */
284static uint32_t NowMs(void)
285{
286#if defined(__WIN__)
287 return GetTickCount();
288#else
289 int iSavedErrno = errno;
290 struct timeval tv = {0, 0};
291
292 gettimeofday(&tv, NULL);
293 errno = iSavedErrno;
294
295 return tv.tv_sec * 1000 + tv.tv_usec / 1000;
296#endif
297}
298
299
300/**
301 * Gets the absolute path
302 *
303 * @returns A new heap buffer containing the absolute path.
304 * @param pszPath The path to make absolute. (Readonly)
305 */
306static char *AbsPath(const char *pszPath)
307{
308/** @todo this isn't really working as it should... */
309 char szTmp[PATH_MAX];
310#if defined(__OS2__)
311 if ( _fullpath(szTmp, *pszPath ? pszPath : ".", sizeof(szTmp))
312 && !realpath(pszPath, szTmp))
313 return xstrdup(pszPath);
314#elif defined(__WIN__)
315 if (!_fullpath(szTmp, *pszPath ? pszPath : ".", sizeof(szTmp)))
316 return xstrdup(pszPath);
317#else
318 if (!realpath(pszPath, szTmp))
319 return xstrdup(pszPath);
320#endif
321 return xstrdup(szTmp);
322}
323
324
325/**
326 * Utility function that finds the filename part in a path.
327 *
328 * @returns Pointer to the file name part (this may be "").
329 * @param pszPath The path to parse.
330 */
331static const char *FindFilenameInPath(const char *pszPath)
332{
333 const char *pszFilename = strchr(pszPath, '\0') - 1;
334 if (pszFilename < pszPath)
335 return pszPath;
336 while ( pszFilename > pszPath
337 && !IS_SLASH_DRV(pszFilename[-1]))
338 pszFilename--;
339 return pszFilename;
340}
341
342
343/**
344 * Utility function that combines a filename and a directory into a path.
345 *
346 * @returns malloced buffer containing the result.
347 * @param pszName The file name.
348 * @param pszDir The directory path.
349 */
350static char *MakePathFromDirAndFile(const char *pszName, const char *pszDir)
351{
352 size_t cchName = strlen(pszName);
353 size_t cchDir = strlen(pszDir);
354 char *pszBuf = xmalloc(cchName + cchDir + 2);
355 memcpy(pszBuf, pszDir, cchDir);
356 if (cchDir > 0 && !IS_SLASH_DRV(pszDir[cchDir - 1]))
357 pszBuf[cchDir++] = PATH_SLASH;
358 memcpy(pszBuf + cchDir, pszName, cchName + 1);
359 return pszBuf;
360}
361
362
363/**
364 * Compares two path strings to see if they are identical.
365 *
366 * This doesn't do anything fancy, just the case ignoring and
367 * slash unification.
368 *
369 * @returns 1 if equal, 0 otherwise.
370 * @param pszPath1 The first path.
371 * @param pszPath2 The second path.
372 */
373static int ArePathsIdentical(const char *pszPath1, const char *pszPath2)
374{
375#if defined(__OS2__) || defined(__WIN__)
376 if (stricmp(pszPath1, pszPath2))
377 {
378 /* Slashes may differ, compare char by char. */
379 const char *psz1 = pszPath1;
380 const char *psz2 = pszPath2;
381 for (;;)
382 {
383 if (*psz1 != *psz2)
384 {
385 if ( tolower(*psz1) != tolower(*psz2)
386 && toupper(*psz1) != toupper(*psz2)
387 && *psz1 != '/'
388 && *psz1 != '\\'
389 && *psz2 != '/'
390 && *psz2 != '\\')
391 return 0;
392 }
393 if (!*psz1)
394 break;
395 psz1++;
396 psz2++;
397 }
398 }
399 return 1;
400#else
401 return !strcmp(pszPath1, pszPath2);
402#endif
403}
404
405/**
406 * Compares two path strings to see if they are identical.
407 *
408 * This doesn't do anything fancy, just the case ignoring and
409 * slash unification.
410 *
411 * @returns 1 if equal, 0 otherwise.
412 * @param pszPath1 The first path.
413 * @param pszPath2 The second path.
414 * @param cch The number of characters to compare.
415 */
416static int ArePathsIdenticalN(const char *pszPath1, const char *pszPath2, size_t cch)
417{
418#if defined(__OS2__) || defined(__WIN__)
419 if (strnicmp(pszPath1, pszPath2, cch))
420 {
421 /* Slashes may differ, compare char by char. */
422 const char *psz1 = pszPath1;
423 const char *psz2 = pszPath2;
424 for ( ; cch; psz1++, psz2++, cch--)
425 {
426 if (*psz1 != *psz2)
427 {
428 if ( tolower(*psz1) != tolower(*psz2)
429 && toupper(*psz1) != toupper(*psz2)
430 && *psz1 != '/'
431 && *psz1 != '\\'
432 && *psz2 != '/'
433 && *psz2 != '\\')
434 return 0;
435 }
436 }
437 }
438 return 1;
439#else
440 return !strncmp(pszPath1, pszPath2, cch);
441#endif
442}
443
444
445/**
446 * Calculate how to get to pszPath from pszDir.
447 *
448 * @returns The relative path from pszDir to path pszPath.
449 * @param pszPath The path to the object.
450 * @param pszDir The directory it shall be relative to.
451 */
452static char *CalcRelativeName(const char *pszPath, const char *pszDir)
453{
454 char *pszRet = NULL;
455 char *pszAbsPath = NULL;
456 size_t cchDir = strlen(pszDir);
457
458 /*
459 * This is indeed a bit tricky, so we'll try the easy way first...
460 */
461 if (ArePathsIdenticalN(pszPath, pszDir, cchDir))
462 {
463 if (pszPath[cchDir])
464 pszRet = (char *)pszPath + cchDir;
465 else
466 pszRet = "./";
467 }
468 else
469 {
470 pszAbsPath = AbsPath(pszPath);
471 if (ArePathsIdenticalN(pszAbsPath, pszDir, cchDir))
472 {
473 if (pszPath[cchDir])
474 pszRet = pszAbsPath + cchDir;
475 else
476 pszRet = "./";
477 }
478 }
479 if (pszRet)
480 {
481 while (IS_SLASH_DRV(*pszRet))
482 pszRet++;
483 pszRet = xstrdup(pszRet);
484 free(pszAbsPath);
485 return pszRet;
486 }
487
488 /*
489 * Damn, it's gonna be complicated. Deal with that later.
490 */
491 FatalDie("complicated relative path stuff isn't implemented yet. sorry.\n");
492 return NULL;
493}
494
495
496/**
497 * Utility function that combines a filename and directory and passes it onto fopen.
498 *
499 * @returns fopen return value.
500 * @param pszName The file name.
501 * @param pszDir The directory path.
502 * @param pszMode The fopen mode string.
503 */
504static FILE *FOpenFileInDir(const char *pszName, const char *pszDir, const char *pszMode)
505{
506 char *pszPath = MakePathFromDirAndFile(pszName, pszDir);
507 FILE *pFile = fopen(pszPath, pszMode);
508 free(pszPath);
509 return pFile;
510}
511
512
513/**
514 * Utility function that combines a filename and directory and passes it onto open.
515 *
516 * @returns open return value.
517 * @param pszName The file name.
518 * @param pszDir The directory path.
519 * @param fFlags The open flags.
520 * @param fCreateMode The file creation mode.
521 */
522static int OpenFileInDir(const char *pszName, const char *pszDir, int fFlags, int fCreateMode)
523{
524 char *pszPath = MakePathFromDirAndFile(pszName, pszDir);
525 int fd = open(pszPath, fFlags, fCreateMode);
526 free(pszPath);
527 return fd;
528}
529
530
531
532/**
533 * Deletes a file in a directory.
534 *
535 * @returns whatever unlink returns.
536 * @param pszName The file name.
537 * @param pszDir The directory path.
538 */
539static int UnlinkFileInDir(const char *pszName, const char *pszDir)
540{
541 char *pszPath = MakePathFromDirAndFile(pszName, pszDir);
542 int rc = unlink(pszPath);
543 free(pszPath);
544 return rc;
545}
546
547
548/**
549 * Renames a file in a directory.
550 *
551 * @returns whatever rename returns.
552 * @param pszOldName The new file name.
553 * @param pszNewName The old file name.
554 * @param pszDir The directory path.
555 */
556static int RenameFileInDir(const char *pszOldName, const char *pszNewName, const char *pszDir)
557{
558 char *pszOldPath = MakePathFromDirAndFile(pszOldName, pszDir);
559 char *pszNewPath = MakePathFromDirAndFile(pszNewName, pszDir);
560 int rc = rename(pszOldPath, pszNewPath);
561 free(pszOldPath);
562 free(pszNewPath);
563 return rc;
564}
565
566
567/**
568 * Check if a (regular) file exists in a directory.
569 *
570 * @returns 1 if it exists and is a regular file, 0 if not.
571 * @param pszName The file name.
572 * @param pszDir The directory path.
573 */
574static int DoesFileInDirExist(const char *pszName, const char *pszDir)
575{
576 char *pszPath = MakePathFromDirAndFile(pszName, pszDir);
577 struct stat st;
578 int rc = stat(pszPath, &st);
579 free(pszPath);
580#ifdef S_ISREG
581 return !rc && S_ISREG(st.st_mode);
582#elif defined(_MSC_VER)
583 return !rc && (st.st_mode & _S_IFMT) == _S_IFREG;
584#else
585#error "Port me"
586#endif
587}
588
589
590/**
591 * Reads into memory an entire file.
592 *
593 * @returns Pointer to the heap allocation containing the file.
594 * On failure NULL and errno is returned.
595 * @param pszName The file.
596 * @param pszDir The directory the file resides in.
597 * @param pcbFile Where to store the file size.
598 */
599static void *ReadFileInDir(const char *pszName, const char *pszDir, size_t *pcbFile)
600{
601 int SavedErrno;
602 char *pszPath = MakePathFromDirAndFile(pszName, pszDir);
603 int fd = open(pszPath, O_RDONLY | O_BINARY);
604 if (fd >= 0)
605 {
606 off_t cbFile = lseek(fd, 0, SEEK_END);
607 if ( cbFile >= 0
608 && lseek(fd, 0, SEEK_SET) == 0)
609 {
610 char *pb = malloc(cbFile + 1);
611 if (pb)
612 {
613 if (read(fd, pb, cbFile) == cbFile)
614 {
615 close(fd);
616 pb[cbFile] = '\0';
617 *pcbFile = (size_t)cbFile;
618 return pb;
619 }
620 SavedErrno = errno;
621 free(pb);
622 }
623 else
624 SavedErrno = ENOMEM;
625 }
626 else
627 SavedErrno = errno;
628 close(fd);
629 }
630 else
631 SavedErrno = errno;
632 free(pszPath);
633 errno = SavedErrno;
634 return NULL;
635}
636
637
638/**
639 * Creates a directory including all necessary parent directories.
640 *
641 * @returns 0 on success, -1 + errno on failure.
642 * @param pszDir The directory.
643 */
644static int MakePath(const char *pszPath)
645{
646 int iErr = 0;
647 char *pszAbsPath = AbsPath(pszPath);
648 char *psz = pszAbsPath;
649
650 /* Skip to the root slash (PC). */
651 while (!IS_SLASH(*psz) && *psz)
652 psz++;
653/** @todo UNC */
654 for (;;)
655 {
656 char chSaved;
657
658 /* skip slashes */
659 while (IS_SLASH(*psz))
660 psz++;
661 if (!*psz)
662 break;
663
664 /* find the next slash or end and terminate the string. */
665 while (!IS_SLASH(*psz) && *psz)
666 psz++;
667 chSaved = *psz;
668 *psz = '\0';
669
670 /* try create the directory, ignore failure because the directory already exists. */
671 errno = 0;
672#ifdef _MSC_VER
673 if ( _mkdir(pszAbsPath)
674 && errno != EEXIST)
675#else
676 if ( mkdir(pszAbsPath, 0777)
677 && errno != EEXIST
678 && errno != ENOSYS /* Solaris nonsensical mkdir crap. */
679 && errno != EACCES /* Solaris nonsensical mkdir crap. */
680 )
681#endif
682 {
683 iErr = errno;
684 break;
685 }
686
687 /* restore the slash/terminator */
688 *psz = chSaved;
689 }
690
691 free(pszAbsPath);
692 return iErr ? -1 : 0;
693}
694
695
696/**
697 * Adds the arguments found in the pszCmdLine string to argument vector.
698 *
699 * The parsing of the pszCmdLine string isn't very sophisticated, no
700 * escaping or quotes.
701 *
702 * @param pcArgs Pointer to the argument counter.
703 * @param ppapszArgs Pointer to the argument vector pointer.
704 * @param pszCmdLine The command line to parse and append.
705 * @param pszWedgeArg Argument to put infront of anything found in pszCmdLine.
706 */
707static void AppendArgs(int *pcArgs, char ***ppapszArgs, const char *pszCmdLine, const char *pszWedgeArg)
708{
709 int i;
710 int cExtraArgs;
711 const char *psz;
712 char **papszArgs;
713
714 /*
715 * Count the new arguments.
716 */
717 cExtraArgs = 0;
718 psz = pszCmdLine;
719 while (*psz)
720 {
721 while (isspace(*psz))
722 psz++;
723 if (!psz)
724 break;
725 cExtraArgs++;
726 while (!isspace(*psz) && *psz)
727 psz++;
728 }
729 if (!cExtraArgs)
730 return;
731
732 /*
733 * Allocate a new vector that can hold the arguments.
734 * (Reallocating might not work since the argv might not be allocated
735 * from the heap but off the stack or somewhere... )
736 */
737 i = *pcArgs;
738 *pcArgs = i + cExtraArgs + !!pszWedgeArg;
739 papszArgs = xmalloc((*pcArgs + 1) * sizeof(char *));
740 *ppapszArgs = memcpy(papszArgs, *ppapszArgs, i * sizeof(char *));
741
742 if (pszWedgeArg)
743 papszArgs[i++] = xstrdup(pszWedgeArg);
744
745 psz = pszCmdLine;
746 while (*psz)
747 {
748 size_t cch;
749 const char *pszEnd;
750 while (isspace(*psz))
751 psz++;
752 if (!psz)
753 break;
754 pszEnd = psz;
755 while (!isspace(*pszEnd) && *pszEnd)
756 pszEnd++;
757
758 cch = pszEnd - psz;
759 papszArgs[i] = xmalloc(cch + 1);
760 memcpy(papszArgs[i], psz, cch);
761 papszArgs[i][cch] = '\0';
762
763 i++;
764 psz = pszEnd;
765 }
766
767 papszArgs[i] = NULL;
768}
769
770
771/**
772 * Dependency collector state.
773 */
774typedef struct KOCDEP
775{
776 /** The statemachine for processing the preprocessed code stream. */
777 enum KOCDEPSTATE
778 {
779 kOCDepState_Invalid = 0,
780 kOCDepState_NeedNewLine,
781 kOCDepState_NeedHash,
782 kOCDepState_NeedLine_l,
783 kOCDepState_NeedLine_l_HaveSpace,
784 kOCDepState_NeedLine_i,
785 kOCDepState_NeedLine_n,
786 kOCDepState_NeedLine_e,
787 kOCDepState_NeedSpaceBeforeDigit,
788 kOCDepState_NeedFirstDigit,
789 kOCDepState_NeedMoreDigits,
790 kOCDepState_NeedQuote,
791 kOCDepState_NeedEndQuote
792 } enmState;
793 /** Current offset into the filename buffer. */
794 uint32_t offFilename;
795 /** The amount of space currently allocated for the filename buffer. */
796 uint32_t cbFilenameAlloced;
797 /** Pointer to the filename buffer. */
798 char *pszFilename;
799 /** The current dependency file. */
800 PDEP pCurDep;
801} KOCDEP;
802/** Pointer to a KOCDEP. */
803typedef KOCDEP *PKOCDEP;
804
805
806/**
807 * Initializes the dependency collector state.
808 *
809 * @param pDepState The dependency collector state.
810 */
811static void kOCDepInit(PKOCDEP pDepState)
812{
813 pDepState->enmState = kOCDepState_NeedHash;
814 pDepState->offFilename = 0;
815 pDepState->cbFilenameAlloced = 0;
816 pDepState->pszFilename = NULL;
817 pDepState->pCurDep = NULL;
818}
819
820
821/**
822 * Deletes the dependency collector state, releasing all resources.
823 *
824 * @param pDepState The dependency collector state.
825 */
826static void kOCDepDelete(PKOCDEP pDepState)
827{
828 pDepState->enmState = kOCDepState_Invalid;
829 free(pDepState->pszFilename);
830 pDepState->pszFilename = NULL;
831 depCleanup();
832}
833
834
835/**
836 * Unescapes a string in place.
837 *
838 * @returns The new string length.
839 * @param psz The string to unescape (input and output).
840 */
841static size_t kOCDepUnescape(char *psz)
842{
843 char *pszSrc = psz;
844 char *pszDst = psz;
845 char ch;
846
847 while ((ch = *pszSrc++) != '\0')
848 {
849 if (ch == '\\')
850 {
851 char ch2 = *pszSrc;
852 if (ch2)
853 {
854 pszSrc++;
855 ch = ch2;
856 }
857 /* else: cannot happen / just ignore */
858 }
859 *pszDst++ = ch;
860 }
861
862 *pszDst = '\0';
863 return pszDst - psz;
864}
865
866
867/**
868 * Checks if the character at @a offChar is escaped or not.
869 *
870 * @returns 1 if escaped, 0 if not.
871 * @param pach The string (not terminated).
872 * @param offChar The offset of the character in question.
873 */
874static int kOCDepIsEscaped(char *pach, size_t offChar)
875{
876 while (offChar > 0 && pach[offChar - 1] == '\\')
877 {
878 if ( offChar == 1
879 || pach[offChar - 2] != '\\')
880 return 1;
881 offChar -= 2;
882 }
883 return 0;
884}
885
886
887static void kOCDepEnter(PKOCDEP pDepState, const char *pszUnescFilename, size_t cchFilename)
888{
889 if (cchFilename + 1 >= pDepState->cbFilenameAlloced)
890 {
891 pDepState->cbFilenameAlloced = (cchFilename + 1 + 15) & ~15;
892 pDepState->pszFilename = (char *)xrealloc(pDepState->pszFilename, pDepState->cbFilenameAlloced);
893 }
894
895 memcpy(pDepState->pszFilename, pszUnescFilename, cchFilename);
896 pDepState->pszFilename[cchFilename] = '\0';
897 cchFilename = kOCDepUnescape(pDepState->pszFilename);
898
899 if ( !pDepState->pCurDep
900 || cchFilename != pDepState->pCurDep->cchFilename
901 || strcmp(pDepState->pszFilename, pDepState->pCurDep->szFilename))
902 pDepState->pCurDep = depAdd(pDepState->pszFilename, cchFilename);
903}
904
905
906/**
907 * This consumes the preprocessor output and generate dependencies from it.
908 *
909 * The trick is to look at the line directives and which files get listed there.
910 *
911 * @returns The new state. This is a convenience for saving code space and it
912 * isn't really meant to be of any use to the caller.
913 * @param pDepState The dependency collector state.
914 * @param pszInput The input.
915 * @param cchInput The input length.
916 */
917static enum KOCDEPSTATE
918kOCDepConsumer(PKOCDEP pDepState, const char *pszInput, size_t cchInput)
919{
920 enum KOCDEPSTATE enmState = pDepState->enmState;
921 const char *psz;
922
923 while (cchInput > 0)
924 {
925 switch (enmState)
926 {
927 case kOCDepState_NeedNewLine:
928 psz = (const char *)memchr(pszInput, '\n', cchInput);
929 if (!psz)
930 return enmState;
931 psz++;
932 cchInput -= psz - pszInput;
933 pszInput = psz;
934
935 case kOCDepState_NeedHash:
936 while (cchInput > 0 && MY_IS_BLANK(*pszInput))
937 cchInput--, pszInput++;
938 if (!cchInput)
939 return pDepState->enmState = kOCDepState_NeedHash;
940
941 if (*pszInput != '#')
942 break;
943 pszInput++;
944 cchInput--;
945 enmState = kOCDepState_NeedLine_l;
946
947 case kOCDepState_NeedLine_l:
948 case kOCDepState_NeedLine_l_HaveSpace:
949 while (cchInput > 0 && MY_IS_BLANK(*pszInput))
950 {
951 enmState = kOCDepState_NeedLine_l_HaveSpace;
952 cchInput--, pszInput++;
953 }
954 if (!cchInput)
955 return pDepState->enmState = enmState;
956
957 if (*pszInput != 'l')
958 {
959 /* # <digit> "<file>" */
960 if (enmState != kOCDepState_NeedLine_l_HaveSpace || !isdigit(*pszInput))
961 break;
962 pszInput++;
963 cchInput--;
964 enmState = kOCDepState_NeedMoreDigits;
965 continue;
966 }
967 pszInput++;
968 if (!--cchInput)
969 return pDepState->enmState = kOCDepState_NeedLine_i;
970
971 case kOCDepState_NeedLine_i:
972 if (*pszInput != 'i')
973 break;
974 pszInput++;
975 if (!--cchInput)
976 return pDepState->enmState = kOCDepState_NeedLine_n;
977
978 case kOCDepState_NeedLine_n:
979 if (*pszInput != 'n')
980 break;
981 pszInput++;
982 if (!--cchInput)
983 return pDepState->enmState = kOCDepState_NeedLine_e;
984
985 case kOCDepState_NeedLine_e:
986 if (*pszInput != 'e')
987 break;
988 pszInput++;
989 if (!--cchInput)
990 return pDepState->enmState = kOCDepState_NeedSpaceBeforeDigit;
991
992 case kOCDepState_NeedSpaceBeforeDigit:
993 if (!MY_IS_BLANK(*pszInput))
994 break;
995 pszInput++;
996 cchInput--;
997
998 case kOCDepState_NeedFirstDigit:
999 while (cchInput > 0 && MY_IS_BLANK(*pszInput))
1000 cchInput--, pszInput++;
1001 if (!cchInput)
1002 return pDepState->enmState = kOCDepState_NeedFirstDigit;
1003
1004 if (!isdigit(*pszInput))
1005 break;
1006 pszInput++;
1007 cchInput--;
1008
1009 case kOCDepState_NeedMoreDigits:
1010 while (cchInput > 0 && isdigit(*pszInput))
1011 cchInput--, pszInput++;
1012 if (!cchInput)
1013 return pDepState->enmState = kOCDepState_NeedMoreDigits;
1014
1015 case kOCDepState_NeedQuote:
1016 while (cchInput > 0 && MY_IS_BLANK(*pszInput))
1017 cchInput--, pszInput++;
1018 if (!cchInput)
1019 return pDepState->enmState = kOCDepState_NeedQuote;
1020
1021 if (*pszInput != '"')
1022 break;
1023 pszInput++;
1024 cchInput--;
1025
1026 case kOCDepState_NeedEndQuote:
1027 {
1028 uint32_t off = pDepState->offFilename;
1029 for (;;)
1030 {
1031 char ch;
1032
1033 if (!cchInput)
1034 {
1035 pDepState->offFilename = off;
1036 return pDepState->enmState = kOCDepState_NeedEndQuote;
1037 }
1038
1039 if (off + 1 >= pDepState->cbFilenameAlloced)
1040 {
1041 if (!pDepState->cbFilenameAlloced)
1042 pDepState->cbFilenameAlloced = 32;
1043 else
1044 pDepState->cbFilenameAlloced *= 2;
1045 pDepState->pszFilename = (char *)xrealloc(pDepState->pszFilename, pDepState->cbFilenameAlloced);
1046 }
1047 pDepState->pszFilename[off] = ch = *pszInput++;
1048 cchInput--;
1049
1050 if ( ch == '"'
1051 && ( off == 0
1052 || pDepState->pszFilename[off - 1] != '\\'
1053 || !kOCDepIsEscaped(pDepState->pszFilename, off)))
1054 {
1055 /* Done, unescape and add the file. */
1056 size_t cchFilename;
1057
1058 pDepState->pszFilename[off] = '\0';
1059 cchFilename = kOCDepUnescape(pDepState->pszFilename);
1060
1061 if ( !pDepState->pCurDep
1062 || cchFilename != pDepState->pCurDep->cchFilename
1063 || strcmp(pDepState->pszFilename, pDepState->pCurDep->szFilename))
1064 pDepState->pCurDep = depAdd(pDepState->pszFilename, cchFilename);
1065 pDepState->offFilename = 0;
1066 break;
1067 }
1068
1069 off++;
1070 }
1071 }
1072 }
1073
1074 /* next newline */
1075 enmState = kOCDepState_NeedNewLine;
1076 }
1077
1078 return pDepState->enmState = enmState;
1079}
1080
1081
1082/**
1083 * Writes the dependencies to the specified file.
1084 *
1085 * @param pDepState The dependency collector state.
1086 * @param pszFilename The name of the dependency file.
1087 * @param pszObjFile The object file name, relative to @a pszObjDir.
1088 * @param pszObjDir The object file directory.
1089 * @param fFixCase Whether to fix the case of dependency files.
1090 * @param fQuiet Whether to be quiet about the dependencies.
1091 * @param fGenStubs Whether to generate stubs.
1092 */
1093static void kOCDepWriteToFile(PKOCDEP pDepState, const char *pszFilename, const char *pszObjFile, const char *pszObjDir,
1094 int fFixCase, int fQuiet, int fGenStubs)
1095{
1096 char *pszObjFileAbs;
1097 char *psz;
1098 FILE *pFile = fopen(pszFilename, "w");
1099 if (!pFile)
1100 FatalMsg("Failed to open dependency file '%s': %s\n", pszFilename, strerror(errno));
1101
1102 depOptimize(fFixCase, fQuiet);
1103
1104 /* Make object file name with unix slashes. */
1105 pszObjFileAbs = MakePathFromDirAndFile(pszObjFile, pszObjDir);
1106 psz = pszObjFileAbs;
1107 while ((psz = strchr(psz, '\\')) != NULL)
1108 *psz++ = '/';
1109
1110 fprintf(pFile, "%s:", pszObjFileAbs);
1111 free(pszObjFileAbs);
1112 depPrint(pFile);
1113 if (fGenStubs)
1114 depPrintStubs(pFile);
1115
1116 if (fclose(pFile) != 0)
1117 FatalMsg("Failed to write dependency file '%s': %s\n", pszFilename, strerror(errno));
1118}
1119
1120
1121/**
1122 * Preprocessor output reader state.
1123 */
1124typedef struct KOCCPPRD
1125{
1126 /** Pointer to the preprocessor output. */
1127 char *pszBuf;
1128 /** Allocated buffer size. */
1129 size_t cbBufAlloc;
1130 /** Amount preprocessor output that we've completed optimizations for. */
1131 size_t cchDstOptimized;
1132 /** Offset to the start of the unoptimized source. */
1133 size_t offSrcUnoptimized;
1134 /** The offset of the next bits to process. */
1135 size_t offSrcCur;
1136 /** The offset where to put more raw preprocessor output. */
1137 size_t offSrcRead;
1138 /** The line number corresponding to offOptimized. */
1139 uint32_t uOptLineNo;
1140 /** The current line number. */
1141 uint32_t uCurLineNo;
1142 /** Set if we're done, clear if we're expecting more preprocessor output. */
1143 int fDone;
1144 /** The saved character at cchOptimized. */
1145 char chSaved;
1146 /** Whether the optimizations are enabled. */
1147 int fOptimize;
1148
1149 /** Buffer holding the current file name (unescaped). */
1150 char *pszFileNmBuf;
1151 /** The size of the file name buffer. */
1152 size_t cbFileNmBuf;
1153 /** The length of the current file string. */
1154 size_t cchCurFileNm;
1155
1156 /** Line directive / new line sequence buffer. */
1157 char *pszLineBuf;
1158 /** The size of the buffer pointed to by pszLineBuf. */
1159 size_t cbLineBuf;
1160
1161 /** Set if we should work the dependency generator as well. */
1162 PKOCDEP pDepState;
1163} KOCCPPRD;
1164/** Pointer to a preprocessor reader state. */
1165typedef KOCCPPRD *PKOCCPPRD;
1166
1167
1168/**
1169 * Allocate the initial C preprocessor output buffer.
1170 *
1171 * @param pCppRd The C preprocessor reader instance.
1172 * @param cbOldCpp The size of the output the last time. This is 0 if
1173 * there was not previous run.
1174 * @param fOptimize Whether optimizations are enabled.
1175 * @param pDepState Pointer to the dependency generator. Must only be set
1176 * if @a fOptimize is also set.
1177 */
1178static void kOCCppRdInit(PKOCCPPRD pCppRd, size_t cbOldCpp, int fOptimize, PKOCDEP pDepState)
1179{
1180 assert(!pDepState || fOptimize);
1181
1182 pCppRd->cbBufAlloc = cbOldCpp ? (cbOldCpp + KOC_BUF_INCR) & ~(KOC_BUF_ALIGNMENT - 1) : KOC_BUF_MIN;
1183 pCppRd->pszBuf = xmalloc(pCppRd->cbBufAlloc);
1184 pCppRd->cchCurFileNm = 0;
1185 pCppRd->cchDstOptimized = 0;
1186 pCppRd->offSrcUnoptimized = 0;
1187 pCppRd->offSrcCur = 0;
1188 pCppRd->offSrcRead = 0;
1189 pCppRd->uOptLineNo = 1;
1190 pCppRd->uCurLineNo = 1;
1191 pCppRd->fDone = 0;
1192 pCppRd->chSaved = 0;
1193 pCppRd->fOptimize = fOptimize;
1194
1195 pCppRd->pszFileNmBuf = NULL;
1196 pCppRd->cbFileNmBuf = 0;
1197 pCppRd->cchCurFileNm = 0;
1198
1199 pCppRd->pszLineBuf = NULL;
1200 pCppRd->cbLineBuf = 0;
1201
1202 pCppRd->pDepState = pDepState;
1203}
1204
1205
1206static void kOCCppRdDelete(PKOCCPPRD pCppRd)
1207{
1208 free(pCppRd->pszBuf);
1209 pCppRd->pszBuf = NULL;
1210
1211 free(pCppRd->pszFileNmBuf);
1212 pCppRd->pszFileNmBuf = NULL;
1213
1214 free(pCppRd->pszLineBuf);
1215 pCppRd->pszLineBuf = NULL;
1216}
1217
1218
1219/**
1220 * Allocate more buffer space for the C preprocessor output.
1221 *
1222 * @param pCppRd The C preprocessor reader instance.
1223 */
1224static size_t kOCCppRdGrowBuffer(PKOCCPPRD pCppRd)
1225{
1226 pCppRd->cbBufAlloc += KOC_BUF_INCR;
1227 pCppRd->pszBuf = xrealloc(pCppRd->pszBuf, pCppRd->cbBufAlloc);
1228
1229 return pCppRd->cbBufAlloc - pCppRd->offSrcRead;
1230}
1231
1232
1233static size_t kOCCppRdOptInsert(PKOCCPPRD pCppRd, size_t cchSrcReplaced, const char *pchInsert, size_t cchInsert)
1234{
1235 size_t offDelta = 0;
1236 size_t cchAvail;
1237
1238 pCppRd->offSrcUnoptimized += cchSrcReplaced;
1239 assert(pCppRd->offSrcUnoptimized <= pCppRd->offSrcCur);
1240 cchAvail = pCppRd->offSrcUnoptimized - pCppRd->cchDstOptimized;
1241 if (cchAvail < cchInsert)
1242 {
1243 size_t const cbToMove = pCppRd->offSrcRead - pCppRd->offSrcUnoptimized;
1244 assert(cbToMove <= pCppRd->offSrcRead);
1245 offDelta = cchInsert - cchAvail;
1246
1247 while (pCppRd->offSrcRead + offDelta >= pCppRd->cbBufAlloc)
1248 kOCCppRdGrowBuffer(pCppRd);
1249
1250 g_cMemMoves++;
1251 g_cbMemMoved += cbToMove + 1;
1252 memmove(pCppRd->pszBuf + pCppRd->offSrcUnoptimized + offDelta,
1253 pCppRd->pszBuf + pCppRd->offSrcUnoptimized,
1254 cbToMove + 1);
1255
1256 pCppRd->offSrcRead += offDelta;
1257 pCppRd->offSrcUnoptimized += offDelta;
1258 pCppRd->offSrcCur += offDelta;
1259 assert(pCppRd->offSrcRead < 1 || pCppRd->pszBuf[pCppRd->offSrcRead - 1] != '\0');
1260 }
1261
1262 memcpy(pCppRd->pszBuf + pCppRd->cchDstOptimized, pchInsert, cchInsert);
1263 pCppRd->cchDstOptimized += cchInsert;
1264
1265 return offDelta;
1266}
1267
1268
1269static void kOCCppRdOptCommit(PKOCCPPRD pCppRd)
1270{
1271 size_t cchToCommit = pCppRd->offSrcCur - pCppRd->offSrcUnoptimized;
1272 assert(pCppRd->offSrcUnoptimized <= pCppRd->offSrcCur);
1273
1274 if (cchToCommit)
1275 {
1276 memmove(pCppRd->pszBuf + pCppRd->cchDstOptimized, pCppRd->pszBuf + pCppRd->offSrcUnoptimized, cchToCommit);
1277 pCppRd->cchDstOptimized += cchToCommit;
1278 pCppRd->offSrcUnoptimized = pCppRd->offSrcCur;
1279 }
1280
1281 pCppRd->uOptLineNo = pCppRd->uCurLineNo;
1282}
1283
1284
1285
1286static char *kOCCppRdOptGetEol(PKOCCPPRD pCppRd, char *pszCur, size_t cbLeft)
1287{
1288 char *pszEol = memchr(pszCur, '\n', cbLeft);
1289 if (pszEol)
1290 {
1291 if (pszCur != pszEol && pszEol[-1] == '\r')
1292 pszEol--;
1293 }
1294 else if (pCppRd->fDone && cbLeft)
1295 pszEol = pszCur + cbLeft;
1296 return pszEol;
1297}
1298
1299static void kOCCppRdOptSetFile(PKOCCPPRD pCppRd, const char *pchFile, size_t cchFile)
1300{
1301 if (cchFile >= pCppRd->cbFileNmBuf)
1302 {
1303 pCppRd->cbFileNmBuf = (cchFile + 15) & ~(size_t)15;
1304 pCppRd->pszFileNmBuf = xrealloc(pCppRd->pszFileNmBuf, pCppRd->cbFileNmBuf);
1305 }
1306 memcpy(pCppRd->pszFileNmBuf, pchFile, cchFile);
1307 pCppRd->pszFileNmBuf[cchFile] = '\0';
1308 pCppRd->cchCurFileNm = cchFile;
1309}
1310
1311
1312static size_t kOCCppRdOptFmtLine(PKOCCPPRD pCppRd, uint32_t uLine, const char *pchFile, size_t cchFile)
1313{
1314 size_t cchUsed;
1315 size_t cbNeeded;
1316
1317 /* Make sure we've got enough buffer space. */
1318 cbNeeded = sizeof("#line 4888222111 \"\"\n") + cchFile;
1319 if (cbNeeded > pCppRd->cbLineBuf)
1320 {
1321 pCppRd->cbLineBuf = (cbNeeded + 32 + 15) & ~(size_t)15;
1322 pCppRd->pszLineBuf = xrealloc(pCppRd->pszLineBuf, pCppRd->cbLineBuf);
1323 }
1324
1325 /* Do the formatting. */
1326 cchUsed = sprintf(pCppRd->pszLineBuf, "#line %lu", (unsigned long)uLine);
1327 if (cchFile)
1328 {
1329 pCppRd->pszLineBuf[cchUsed++] = ' ';
1330 pCppRd->pszLineBuf[cchUsed++] = '"';
1331 memcpy(&pCppRd->pszLineBuf[cchUsed], pchFile, cchFile);
1332 cchUsed += cchFile;
1333 pCppRd->pszLineBuf[cchUsed++] = '"';
1334 }
1335 pCppRd->pszLineBuf[cchUsed++] = '\n';
1336 pCppRd->pszLineBuf[cchUsed] = '\0';
1337
1338 return cchUsed;
1339}
1340
1341
1342static size_t kOCCppRdOptFmtNewLines(PKOCCPPRD pCppRd, uint32_t cNewLines)
1343{
1344 if (cNewLines + 1 > pCppRd->cbLineBuf)
1345 {
1346 pCppRd->cbLineBuf = (cNewLines + 1 + 32 + 15) & ~(size_t)15;
1347 pCppRd->pszLineBuf = xrealloc(pCppRd->pszLineBuf, pCppRd->cbLineBuf);
1348 }
1349
1350 memset(pCppRd->pszLineBuf, '\n', cNewLines);
1351 pCppRd->pszLineBuf[cNewLines] = '\0';
1352 return cNewLines;
1353}
1354
1355
1356static size_t kOCCppRdOptFlush(PKOCCPPRD pCppRd, size_t offSrcCur, int fLineDirNext)
1357{
1358 size_t offDelta = 0;
1359 size_t const offSrcUnoptimized = pCppRd->offSrcUnoptimized;
1360 assert(offSrcUnoptimized <= offSrcCur);
1361
1362 if (offSrcCur > offSrcUnoptimized)
1363 {
1364 /*
1365 * We've got unflushed whitelines.
1366 */
1367 size_t const cchSrcInQuestion = offSrcCur - offSrcUnoptimized;
1368 uint32_t const cLinesInQuestion = pCppRd->uCurLineNo - pCppRd->uOptLineNo;
1369 size_t cchLineDir;
1370
1371 if ( cLinesInQuestion <= 7
1372 || (cchLineDir = kOCCppRdOptFmtLine(pCppRd, pCppRd->uCurLineNo, NULL, 0)) >= cLinesInQuestion)
1373 cchLineDir = kOCCppRdOptFmtNewLines(pCppRd, cLinesInQuestion);
1374
1375 offDelta = kOCCppRdOptInsert(pCppRd, cchSrcInQuestion, pCppRd->pszLineBuf, cchLineDir);
1376 }
1377
1378 (void)fLineDirNext; /* Use later if required. */
1379 return offDelta;
1380}
1381
1382
1383static int kOCCppRdOptParseLine(PKOCCPPRD pCppRd, char *pszCur, char *pszEol,
1384 uint32_t *puNewLineNo, char **ppszNewFile, size_t *pcchNewFile)
1385{
1386 char *psz = pszCur;
1387 uint32_t uNewLineNo;
1388 int fIsShort;
1389
1390 /*
1391 * Check if it's a #line directive of some kind and parse it.
1392 */
1393 if (*psz != '#')
1394 return 0;
1395 psz++;
1396
1397 fIsShort = MY_IS_BLANK(*psz);
1398 while (MY_IS_BLANK(*psz))
1399 psz++;
1400
1401 if ( psz[0] == 'l'
1402 && psz[1] == 'i'
1403 && psz[2] == 'n'
1404 && psz[3] == 'e'
1405 && MY_IS_BLANK(psz[4]) )
1406 {
1407 fIsShort = 0;
1408 psz += 5;
1409 while (MY_IS_BLANK(*psz))
1410 psz++;
1411 }
1412 else if (fIsShort && isdigit(*psz))
1413 fIsShort = 1;
1414 else
1415 return 0;
1416
1417 /* Parse the line number. */
1418 if (!isdigit(*psz))
1419 return 0;
1420
1421 uNewLineNo = *psz++ - '0';
1422 while (isdigit(*psz))
1423 {
1424 uNewLineNo *= 10;
1425 uNewLineNo += *psz++ - '0';
1426 }
1427 if ( psz != pszEol
1428 && !MY_IS_BLANK(*psz))
1429 return 0;
1430
1431 /*
1432 * The file name part is optional.
1433 */
1434 while (MY_IS_BLANK(*psz))
1435 psz++;
1436
1437 if ( psz != pszEol
1438 && *psz == '"')
1439 {
1440 *ppszNewFile = ++psz;
1441 while ( psz != pszEol
1442 && ( *psz != '"'
1443 || ( psz[-1] == '\\'
1444 && kOCDepIsEscaped(psz, psz - *ppszNewFile)) )
1445 )
1446 psz++;
1447 if (psz == pszEol)
1448 {
1449 /** @todo complain? */
1450 return 0;
1451 }
1452 *pcchNewFile = psz - *ppszNewFile;
1453
1454 do
1455 psz++;
1456 while (psz != pszEol && MY_IS_BLANK(*psz));
1457 }
1458 else
1459 {
1460 /* No file given => Same as the current. */
1461 *ppszNewFile = pCppRd->cchCurFileNm ? pCppRd->pszFileNmBuf : NULL;
1462 *pcchNewFile = pCppRd->cchCurFileNm;
1463 }
1464 if (psz != pszEol)
1465 {
1466 /** @todo complain? */
1467 return 0;
1468 }
1469
1470 *puNewLineNo = uNewLineNo;
1471 return 1;
1472}
1473
1474
1475static char *kOCCppRdOptHandleLine(PKOCCPPRD pCppRd, char *pszCur, size_t *pcbLeft, int *pfEmptyLine, char *pszEol)
1476{
1477 size_t const offSrcLine = pCppRd->offSrcCur;
1478 size_t const cchSrcLine = pszEol - pCppRd->pszBuf - (pCppRd->fOptimize & 2 ? pCppRd->offSrcUnoptimized : pCppRd->offSrcCur);
1479 size_t const cbLeftAssert = *pcbLeft;
1480 char *pszNewFile;
1481 size_t cchNewFile;
1482 uint32_t uNewLineNo;
1483 assert(*pszEol == '\r' || *pszEol == '\n' || *pszEol == '\0');
1484
1485 /* Advance to the end of the line before we do anything. This can be a
1486 little confusing but it saves effort and avoid trouble in the end. */
1487 pCppRd->offSrcCur = pszEol - pCppRd->pszBuf;
1488 *pcbLeft -= pszEol - pszCur;
1489 assert(*pcbLeft <= cbLeftAssert); (void)cbLeftAssert;
1490
1491 /*
1492 * Try parse the directive a '#line' one....
1493 */
1494 if (!kOCCppRdOptParseLine(pCppRd, pszCur, pszEol, &uNewLineNo, &pszNewFile, &cchNewFile))
1495 {
1496 /*
1497 * No line directive. Flush pending optimizations and indicate that
1498 * the line isn't empty and needs to be commited at EOL.
1499 */
1500 kOCCppRdOptFlush(pCppRd, offSrcLine, 0);
1501 *pfEmptyLine = 0;
1502 }
1503 else
1504 {
1505 char *pszCurFile = pCppRd->cchCurFileNm ? pCppRd->pszFileNmBuf : NULL;
1506 if ( pszNewFile == pszCurFile
1507 || ( cchNewFile == pCppRd->cchCurFileNm
1508 && !memcmp(pszNewFile, pszCurFile, cchNewFile)) )
1509 {
1510 /*
1511 * A #line directive specifying the same file.
1512 */
1513 if (uNewLineNo >= pCppRd->uCurLineNo)
1514 *pfEmptyLine = 1;
1515 else
1516 {
1517 /*
1518 * It went backwards, so we need to flush the old section of
1519 * the file and emit another directive for starting the new one.
1520 */
1521 size_t cchLineDir;
1522 if (!(pCppRd->fOptimize & 2))
1523 kOCCppRdOptFlush(pCppRd, offSrcLine, 1);
1524
1525 cchLineDir = kOCCppRdOptFmtLine(pCppRd, uNewLineNo, NULL, 0) - 1; /* sans \n */
1526 kOCCppRdOptInsert(pCppRd, cchSrcLine, pCppRd->pszLineBuf, cchLineDir);
1527
1528 *pfEmptyLine = 0;
1529 }
1530 }
1531 else
1532 {
1533 /*
1534 * The #line directive changed the file.
1535 */
1536 size_t cchLineDir;
1537
1538 kOCCppRdOptSetFile(pCppRd, pszNewFile, cchNewFile); /* save to do this early */
1539 if (!(pCppRd->fOptimize & 2))
1540 kOCCppRdOptFlush(pCppRd, offSrcLine, 1);
1541
1542 cchLineDir = kOCCppRdOptFmtLine(pCppRd, uNewLineNo, pCppRd->pszFileNmBuf, cchNewFile) - 1; /* sans \n */
1543 kOCCppRdOptInsert(pCppRd, cchSrcLine, pCppRd->pszLineBuf, cchLineDir);
1544
1545 if (pCppRd->pDepState)
1546 kOCDepEnter(pCppRd->pDepState, pCppRd->pszFileNmBuf, cchNewFile);
1547
1548 *pfEmptyLine = 0;
1549 }
1550
1551 pCppRd->uCurLineNo = uNewLineNo - 1;
1552 }
1553
1554 return pCppRd->pszBuf + pCppRd->offSrcCur;
1555}
1556
1557
1558static void kOCCppRdOpt(PKOCCPPRD pCppRd)
1559{
1560 size_t cch;
1561 char *pszEol;
1562 char *pszCur = pCppRd->pszBuf + pCppRd->offSrcCur;
1563 size_t cbTodo = pCppRd->offSrcRead - pCppRd->offSrcCur;
1564 int fEmptyLine = 1;
1565
1566 while (cbTodo > 0)
1567 {
1568 switch (*pszCur)
1569 {
1570 case ' ':
1571 case '\t':
1572 break;
1573
1574 case '\n':
1575 pCppRd->offSrcCur = pszCur - pCppRd->pszBuf + 1;
1576 pCppRd->uCurLineNo++;
1577 if (!fEmptyLine)
1578 kOCCppRdOptCommit(pCppRd);
1579 fEmptyLine = 1;
1580 break;
1581
1582 case '\r': /* "\r\n" -> "\n" */
1583 if (cbTodo <= 1 && !pCppRd->fDone)
1584 return;
1585 if (pszCur[1] == '\n' && !fEmptyLine)
1586 {
1587 /* Commit the part up to the '\r' first, replace '\r\n' with '\n'. */
1588 pCppRd->offSrcCur = pszCur - pCppRd->pszBuf;
1589 kOCCppRdOptCommit(pCppRd);
1590
1591 pCppRd->offSrcCur += 2;
1592 kOCCppRdOptInsert(pCppRd, 2, "\n", 1);
1593
1594 assert(cbTodo >= 2);
1595 cbTodo -= 2;
1596 pszCur += 2;
1597
1598 fEmptyLine = 1;
1599 continue;
1600 }
1601 break;
1602
1603 case '#':
1604 pszEol = kOCCppRdOptGetEol(pCppRd, pszCur + 1, cbTodo - 1);
1605 if (!pszEol)
1606 return;
1607 pszCur = kOCCppRdOptHandleLine(pCppRd, pszCur, &cbTodo, &fEmptyLine, pszEol);
1608 continue;
1609
1610 default:
1611 /*
1612 * Some non-white stuff encountered, flush pending white
1613 * line optimizations and skip to the end of the line.
1614 */
1615 fEmptyLine = 0;
1616 pszEol = kOCCppRdOptGetEol(pCppRd, pszCur + 1, cbTodo - 1);
1617 if (!pszEol)
1618 return;
1619 cch = pszEol - pszCur;
1620
1621 pszCur += kOCCppRdOptFlush(pCppRd, pCppRd->offSrcCur, 0);
1622
1623 assert(cch <= cbTodo);
1624 cbTodo -= cch;
1625 pszCur += cch;
1626 continue;
1627 }
1628
1629 cbTodo--;
1630 pszCur++;
1631 }
1632}
1633
1634
1635static void kOCCppRdOptFinalize(PKOCCPPRD pCppRd)
1636{
1637 pCppRd->fDone = 1;
1638 assert(pCppRd->offSrcRead < 1 || pCppRd->pszBuf[pCppRd->offSrcRead - 1] != '\0');
1639 pCppRd->pszBuf[pCppRd->offSrcRead] = '\0';
1640 kOCCppRdOpt(pCppRd);
1641
1642 assert(pCppRd->offSrcCur == pCppRd->offSrcRead);
1643 kOCCppRdOptFlush(pCppRd, pCppRd->offSrcCur, 0);
1644}
1645
1646
1647
1648/**
1649 * Read C preprocessor output from the given file descriptor, optionally
1650 * optimzing it.
1651 *
1652 * @returns Number of bytes read. 0 indicates end of file.
1653 *
1654 * @param pCppRd The C preprocessor reader instance.
1655 * @param fdIn The file descriptor to read the raw preprocessor output
1656 * from.
1657 * @param ppszRet Where to return the pointer to the output.
1658 *
1659 * @remarks Won't return on error, calls FatalDie on those occasions.
1660 */
1661static long kOCCppRdRead(PKOCCPPRD pCppRd, int fdIn, const char **ppszRet)
1662{
1663 size_t cbLeft;
1664 long cbRead;
1665
1666 if (pCppRd->fOptimize)
1667 {
1668 /*
1669 * Optimize the C preprocessor output on the way thru.
1670 */
1671 size_t const cchOldOptimized = pCppRd->cchDstOptimized;
1672 if (pCppRd->chSaved)
1673 pCppRd->pszBuf[pCppRd->cchDstOptimized] = pCppRd->chSaved;
1674
1675 do
1676 {
1677 /* Read more raw C preprocessor output. */
1678 cbLeft = pCppRd->cbBufAlloc - pCppRd->offSrcRead;
1679 if (cbLeft <= 1)
1680 cbLeft = kOCCppRdGrowBuffer(pCppRd);
1681
1682 do
1683 cbRead = read(fdIn, pCppRd->pszBuf + pCppRd->offSrcRead, (long)(cbLeft - 1));
1684 while (cbRead < 0 && errno == EINTR);
1685 if (cbRead < 0)
1686 FatalDie("kOCCppRdRead - read(%d,,%ld) failed: %s\n",
1687 fdIn, (long)(cbLeft - 1), strerror(errno));
1688 pCppRd->offSrcRead += cbRead;
1689
1690 /* Optimize it. */
1691 if (!cbRead)
1692 {
1693 kOCCppRdOptFinalize(pCppRd);
1694 break;
1695 }
1696 kOCCppRdOpt(pCppRd);
1697 } while (pCppRd->cchDstOptimized == cchOldOptimized);
1698
1699 *ppszRet = &pCppRd->pszBuf[cchOldOptimized];
1700 pCppRd->chSaved = pCppRd->pszBuf[pCppRd->cchDstOptimized];
1701 pCppRd->pszBuf[pCppRd->cchDstOptimized] = '\0';
1702 cbRead = (long)(pCppRd->cchDstOptimized - cchOldOptimized);
1703 }
1704 else
1705 {
1706 /*
1707 * Pass thru.
1708 */
1709 char *pszBuf;
1710 cbLeft = pCppRd->cbBufAlloc - pCppRd->offSrcRead;
1711 if (cbLeft <= 1)
1712 cbLeft = kOCCppRdGrowBuffer(pCppRd);
1713 pszBuf = pCppRd->pszBuf + pCppRd->offSrcRead;
1714
1715 do
1716 cbRead = read(fdIn, pszBuf, (long)(cbLeft - 1));
1717 while (cbRead < 0 && errno == EINTR);
1718 if (cbRead < 0)
1719 FatalDie("kOCCppRdRead - read(%d,,%ld) failed: %s\n",
1720 fdIn, (long)(cbLeft - 1), strerror(errno));
1721
1722 *ppszRet = pszBuf;
1723 pCppRd->offSrcRead += cbRead;
1724 pszBuf[cbRead] = '\0';
1725 }
1726
1727 return cbRead;
1728}
1729
1730
1731/**
1732 * Grabs the output buffer from the C preprocessor reader.
1733 *
1734 * @param pCppRd The C preprocessor reader instance.
1735 * @param ppszRet Where to return the pointer to the output.
1736 * @param pcbRet Where to return the size of the output.
1737 */
1738static void kOCCppRdGrabOutput(PKOCCPPRD pCppRd, char **ppszRet, size_t *pcbRet)
1739{
1740 assert(pCppRd->offSrcRead < 1 || pCppRd->pszBuf[pCppRd->offSrcRead - 1] != '\0');
1741 *ppszRet = pCppRd->pszBuf;
1742 *pcbRet = pCppRd->fOptimize ? pCppRd->cchDstOptimized : pCppRd->offSrcRead;
1743 pCppRd->pszBuf = NULL;
1744 pCppRd->offSrcRead = 0;
1745}
1746
1747
1748
1749
1750
1751
1752/** A checksum list entry.
1753 * We keep a list checksums (of preprocessor output) that matches.
1754 *
1755 * The matching algorithm doesn't require the preprocessor output to be
1756 * indentical, only to produce the same object files.
1757 */
1758typedef struct KOCSUM
1759{
1760 /** The next checksum. */
1761 struct KOCSUM *pNext;
1762 /** The crc32 checksum. */
1763 uint32_t crc32;
1764 /** The MD5 digest. */
1765 unsigned char md5[16];
1766 /** Valid or not. */
1767 unsigned fUsed;
1768} KOCSUM;
1769/** Pointer to a KOCSUM. */
1770typedef KOCSUM *PKOCSUM;
1771/** Pointer to a const KOCSUM. */
1772typedef const KOCSUM *PCKOCSUM;
1773
1774
1775/**
1776 * Temporary context record used when calculating the checksum of some data.
1777 */
1778typedef struct KOCSUMCTX
1779{
1780 /** The MD5 context. */
1781 struct MD5Context MD5Ctx;
1782} KOCSUMCTX;
1783/** Pointer to a check context record. */
1784typedef KOCSUMCTX *PKOCSUMCTX;
1785
1786
1787
1788/**
1789 * Initializes a checksum object with an associated context.
1790 *
1791 * @param pSum The checksum object.
1792 * @param pCtx The checksum context.
1793 */
1794static void kOCSumInitWithCtx(PKOCSUM pSum, PKOCSUMCTX pCtx)
1795{
1796 memset(pSum, 0, sizeof(*pSum));
1797 MD5Init(&pCtx->MD5Ctx);
1798}
1799
1800
1801/**
1802 * Updates the checksum calculation.
1803 *
1804 * @param pSum The checksum.
1805 * @param pCtx The checksum calcuation context.
1806 * @param pvBuf The input data to checksum.
1807 * @param cbBuf The size of the input data.
1808 */
1809static void kOCSumUpdate(PKOCSUM pSum, PKOCSUMCTX pCtx, const void *pvBuf, size_t cbBuf)
1810{
1811 /*
1812 * Take in relativly small chunks to try keep it in the cache.
1813 */
1814 const unsigned char *pb = (const unsigned char *)pvBuf;
1815 while (cbBuf > 0)
1816 {
1817 size_t cb = cbBuf >= 128*1024 ? 128*1024 : cbBuf;
1818 pSum->crc32 = crc32(pSum->crc32, pb, cb);
1819 MD5Update(&pCtx->MD5Ctx, pb, (unsigned)cb);
1820 cbBuf -= cb;
1821 }
1822}
1823
1824
1825/**
1826 * Finalizes a checksum calculation.
1827 *
1828 * @param pSum The checksum.
1829 * @param pCtx The checksum calcuation context.
1830 */
1831static void kOCSumFinalize(PKOCSUM pSum, PKOCSUMCTX pCtx)
1832{
1833 MD5Final(&pSum->md5[0], &pCtx->MD5Ctx);
1834 pSum->fUsed = 1;
1835}
1836
1837
1838/**
1839 * Init a check sum chain head.
1840 *
1841 * @param pSumHead The checksum head to init.
1842 */
1843static void kOCSumInit(PKOCSUM pSumHead)
1844{
1845 memset(pSumHead, 0, sizeof(*pSumHead));
1846}
1847
1848
1849/**
1850 * Parses the given string into a checksum head object.
1851 *
1852 * @returns 0 on success, -1 on format error.
1853 * @param pSumHead The checksum head to init.
1854 * @param pszVal The string to initialized it from.
1855 */
1856static int kOCSumInitFromString(PKOCSUM pSumHead, const char *pszVal)
1857{
1858 unsigned i;
1859 char *pszNext;
1860 char *pszMD5;
1861
1862 memset(pSumHead, 0, sizeof(*pSumHead));
1863
1864 pszMD5 = strchr(pszVal, ':');
1865 if (pszMD5 == NULL)
1866 return -1;
1867 *pszMD5++ = '\0';
1868
1869 /* crc32 */
1870 pSumHead->crc32 = (uint32_t)strtoul(pszVal, &pszNext, 16);
1871 if (pszNext && *pszNext)
1872 return -1;
1873
1874 /* md5 */
1875 for (i = 0; i < sizeof(pSumHead->md5) * 2; i++)
1876 {
1877 unsigned char ch = pszMD5[i];
1878 int x;
1879 if ((unsigned char)(ch - '0') <= 9)
1880 x = ch - '0';
1881 else if ((unsigned char)(ch - 'a') <= 5)
1882 x = ch - 'a' + 10;
1883 else if ((unsigned char)(ch - 'A') <= 5)
1884 x = ch - 'A' + 10;
1885 else
1886 return -1;
1887 if (!(i & 1))
1888 pSumHead->md5[i >> 1] = x << 4;
1889 else
1890 pSumHead->md5[i >> 1] |= x;
1891 }
1892
1893 pSumHead->fUsed = 1;
1894 return 0;
1895}
1896
1897
1898/**
1899 * Delete a check sum chain.
1900 *
1901 * @param pSumHead The head of the checksum chain.
1902 */
1903static void kOCSumDeleteChain(PKOCSUM pSumHead)
1904{
1905 PKOCSUM pSum = pSumHead->pNext;
1906 while (pSum)
1907 {
1908 void *pvFree = pSum;
1909 pSum = pSum->pNext;
1910 free(pvFree);
1911 }
1912 memset(pSumHead, 0, sizeof(*pSumHead));
1913}
1914
1915
1916/**
1917 * Insert a check sum into the chain.
1918 *
1919 * @param pSumHead The head of the checksum list.
1920 * @param pSumAdd The checksum to add (duplicate).
1921 */
1922static void kOCSumAdd(PKOCSUM pSumHead, PCKOCSUM pSumAdd)
1923{
1924 if (pSumHead->fUsed)
1925 {
1926 PKOCSUM pNew = xmalloc(sizeof(*pNew));
1927 *pNew = *pSumAdd;
1928 pNew->pNext = pSumHead->pNext;
1929 pNew->fUsed = 1;
1930 pSumHead->pNext = pNew;
1931 }
1932 else
1933 {
1934 *pSumHead = *pSumAdd;
1935 pSumHead->pNext = NULL;
1936 pSumHead->fUsed = 1;
1937 }
1938}
1939
1940
1941/**
1942 * Inserts an entrie chain into the given check sum chain.
1943 *
1944 * @param pSumHead The head of the checksum list.
1945 * @param pSumHeadAdd The head of the checksum list to be added.
1946 */
1947static void kOCSumAddChain(PKOCSUM pSumHead, PCKOCSUM pSumHeadAdd)
1948{
1949 while (pSumHeadAdd)
1950 {
1951 kOCSumAdd(pSumHead, pSumHeadAdd);
1952 pSumHeadAdd = pSumHeadAdd->pNext;
1953 }
1954}
1955
1956
1957
1958/**
1959 * Prints the checksum to the specified stream.
1960 *
1961 * @param pSum The checksum.
1962 * @param pFile The output file stream
1963 */
1964static void kOCSumFPrintf(PCKOCSUM pSum, FILE *pFile)
1965{
1966 fprintf(pFile, "%#x:%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x\n",
1967 pSum->crc32,
1968 pSum->md5[0], pSum->md5[1], pSum->md5[2], pSum->md5[3],
1969 pSum->md5[4], pSum->md5[5], pSum->md5[6], pSum->md5[7],
1970 pSum->md5[8], pSum->md5[9], pSum->md5[10], pSum->md5[11],
1971 pSum->md5[12], pSum->md5[13], pSum->md5[14], pSum->md5[15]);
1972}
1973
1974
1975/**
1976 * Displays the checksum (not chain!) using the InfoMsg() method.
1977 *
1978 * @param pSum The checksum.
1979 * @param uLevel The info message level.
1980 * @param pszMsg Message to prefix the info message with.
1981 */
1982static void kOCSumInfo(PCKOCSUM pSum, unsigned uLevel, const char *pszMsg)
1983{
1984 InfoMsg(uLevel,
1985 "%s: crc32=%#010x md5=%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x\n",
1986 pszMsg,
1987 pSum->crc32,
1988 pSum->md5[0], pSum->md5[1], pSum->md5[2], pSum->md5[3],
1989 pSum->md5[4], pSum->md5[5], pSum->md5[6], pSum->md5[7],
1990 pSum->md5[8], pSum->md5[9], pSum->md5[10], pSum->md5[11],
1991 pSum->md5[12], pSum->md5[13], pSum->md5[14], pSum->md5[15]);
1992}
1993
1994
1995/**
1996 * Compares two check sum entries.
1997 *
1998 * @returns 1 if equal, 0 if not equal.
1999 *
2000 * @param pSum1 The first checksum.
2001 * @param pSum2 The second checksum.
2002 */
2003static int kOCSumIsEqual(PCKOCSUM pSum1, PCKOCSUM pSum2)
2004{
2005 if (pSum1 == pSum2)
2006 return 1;
2007 if (!pSum1 || !pSum2)
2008 return 0;
2009 if (pSum1->crc32 != pSum2->crc32)
2010 return 0;
2011 if (memcmp(&pSum1->md5[0], &pSum2->md5[0], sizeof(pSum1->md5)))
2012 return 0;
2013 return 1;
2014}
2015
2016
2017/**
2018 * Checks if the specified checksum equals one of the
2019 * checksums in the chain.
2020 *
2021 * @returns 1 if equals one of them, 0 if not.
2022 *
2023 * @param pSumHead The checksum chain too look in.
2024 * @param pSum The checksum to look for.
2025 * @todo ugly name. fix.
2026 */
2027static int kOCSumHasEqualInChain(PCKOCSUM pSumHead, PCKOCSUM pSum)
2028{
2029 for (; pSumHead; pSumHead = pSumHead->pNext)
2030 {
2031 if (pSumHead == pSum)
2032 return 1;
2033 if (pSumHead->crc32 != pSum->crc32)
2034 continue;
2035 if (memcmp(&pSumHead->md5[0], &pSum->md5[0], sizeof(pSumHead->md5)))
2036 continue;
2037 return 1;
2038 }
2039 return 0;
2040}
2041
2042
2043/**
2044 * Checks if the checksum (chain) empty.
2045 *
2046 * @returns 1 if empty, 0 if it there is one or more checksums.
2047 * @param pSum The checksum to test.
2048 */
2049static int kOCSumIsEmpty(PCKOCSUM pSum)
2050{
2051 return !pSum->fUsed;
2052}
2053
2054
2055
2056
2057
2058
2059/**
2060 * The representation of a cache entry.
2061 */
2062typedef struct KOCENTRY
2063{
2064 /** The name of the cache entry. */
2065 const char *pszName;
2066 /** The dir that all other names are relative to. */
2067 char *pszDir;
2068 /** The absolute path. */
2069 char *pszAbsPath;
2070 /** Set if the object needs to be (re)compiled. */
2071 unsigned fNeedCompiling;
2072 /** Whether the preprocessor runs in piped mode. If clear it's file
2073 * mode (it could be redirected stdout, but that's essentially the
2074 * same from our point of view). */
2075 unsigned fPipedPreComp;
2076 /** Whether the compiler runs in piped mode (preprocessor output on stdin). */
2077 unsigned fPipedCompile;
2078 /** The name of the pipe that we're feeding the preprocessed output to the
2079 * compiler via. This is a Windows thing. */
2080 char *pszNmPipeCompile;
2081 /** Name of the dependency file (generated from #line statements in the
2082 * preprocessor output). */
2083 char *pszMakeDepFilename;
2084 /** Whether to fix the case of the make depedencies. */
2085 int fMakeDepFixCase;
2086 /** Whether to do the make dependencies quietly. */
2087 int fMakeDepQuiet;
2088 /** Whether to generate stubs for headers files. */
2089 int fMakeDepGenStubs;
2090 /** The dependency collector state. */
2091 KOCDEP DepState;
2092 /** Whether the optimizations are enabled. */
2093 int fOptimizeCpp;
2094 /** Cache entry key that's used for some quick digest validation. */
2095 uint32_t uKey;
2096
2097 /** The file data. */
2098 struct KOCENTRYDATA
2099 {
2100 /** The name of file containing the preprocessor output. */
2101 char *pszCppName;
2102 /** Pointer to the preprocessor output. */
2103 char *pszCppMapping;
2104 /** The size of the preprocessor output. 0 if not determined. */
2105 size_t cbCpp;
2106 /** The preprocessor output checksums that will produce the cached object. */
2107 KOCSUM SumHead;
2108 /** The number of milliseconds spent precompiling. */
2109 uint32_t cMsCpp;
2110
2111 /** The object filename (relative to the cache file). */
2112 char *pszObjName;
2113 /** The compile argument vector used to build the object. */
2114 char **papszArgvCompile;
2115 /** The size of the compile */
2116 unsigned cArgvCompile;
2117 /** The checksum of the compiler argument vector. */
2118 KOCSUM SumCompArgv;
2119 /** The number of milliseconds spent compiling. */
2120 uint32_t cMsCompile;
2121 /** @todo need a list of additional output files for MSC. */
2122 /** @todo need compiler output (warnings). */
2123
2124 /** The target os/arch identifier. */
2125 char *pszTarget;
2126 }
2127 /** The old data.*/
2128 Old,
2129 /** The new data. */
2130 New;
2131} KOCENTRY;
2132/** Pointer to a KOCENTRY. */
2133typedef KOCENTRY *PKOCENTRY;
2134/** Pointer to a const KOCENTRY. */
2135typedef const KOCENTRY *PCKOCENTRY;
2136
2137
2138/**
2139 * Creates a cache entry for the given cache file name.
2140 *
2141 * @returns Pointer to a cache entry.
2142 * @param pszFilename The cache file name.
2143 */
2144static PKOCENTRY kOCEntryCreate(const char *pszFilename)
2145{
2146 PKOCENTRY pEntry;
2147 size_t off;
2148
2149 /*
2150 * Allocate an empty entry.
2151 */
2152 pEntry = xmallocz(sizeof(*pEntry));
2153
2154 kOCDepInit(&pEntry->DepState);
2155
2156 kOCSumInit(&pEntry->New.SumHead);
2157 kOCSumInit(&pEntry->Old.SumHead);
2158
2159 kOCSumInit(&pEntry->New.SumCompArgv);
2160 kOCSumInit(&pEntry->Old.SumCompArgv);
2161
2162 /*
2163 * Setup the directory and cache file name.
2164 */
2165 pEntry->pszAbsPath = AbsPath(pszFilename);
2166 pEntry->pszName = FindFilenameInPath(pEntry->pszAbsPath);
2167 off = pEntry->pszName - pEntry->pszAbsPath;
2168 if (!off)
2169 FatalDie("Failed to find abs path for '%s'!\n", pszFilename);
2170 pEntry->pszDir = xmalloc(off);
2171 memcpy(pEntry->pszDir, pEntry->pszAbsPath, off - 1);
2172 pEntry->pszDir[off - 1] = '\0';
2173
2174 return pEntry;
2175}
2176
2177
2178/**
2179 * Destroys the cache entry freeing up all it's resources.
2180 *
2181 * @param pEntry The entry to free.
2182 */
2183static void kOCEntryDestroy(PKOCENTRY pEntry)
2184{
2185 /** @todo free pEntry->pszName? */
2186 free(pEntry->pszDir);
2187 free(pEntry->pszAbsPath);
2188 free(pEntry->pszNmPipeCompile);
2189 free(pEntry->pszMakeDepFilename);
2190
2191 kOCDepDelete(&pEntry->DepState);
2192
2193 kOCSumDeleteChain(&pEntry->New.SumHead);
2194 kOCSumDeleteChain(&pEntry->Old.SumHead);
2195
2196 kOCSumDeleteChain(&pEntry->New.SumCompArgv);
2197 kOCSumDeleteChain(&pEntry->Old.SumCompArgv);
2198
2199 free(pEntry->New.pszCppName);
2200 free(pEntry->Old.pszCppName);
2201
2202 free(pEntry->New.pszCppMapping);
2203 free(pEntry->Old.pszCppMapping);
2204
2205 free(pEntry->New.pszObjName);
2206 free(pEntry->Old.pszObjName);
2207
2208 free(pEntry->New.pszTarget);
2209 free(pEntry->Old.pszTarget);
2210
2211 while (pEntry->New.cArgvCompile > 0)
2212 free(pEntry->New.papszArgvCompile[--pEntry->New.cArgvCompile]);
2213 while (pEntry->Old.cArgvCompile > 0)
2214 free(pEntry->Old.papszArgvCompile[--pEntry->Old.cArgvCompile]);
2215
2216 free(pEntry->New.papszArgvCompile);
2217 free(pEntry->Old.papszArgvCompile);
2218
2219 free(pEntry);
2220}
2221
2222
2223/**
2224 * Calculates the checksum of an compiler argument vector.
2225 *
2226 * @param pEntry The cache entry.
2227 * @param papszArgv The argument vector.
2228 * @param cArgc The number of entries in the vector.
2229 * @param pszIgnorePath1 Path to ignore when encountered at the end of
2230 * arguments. (Not quite safe for simple file names,
2231 * but what the heck.)
2232 * @param pszIgnorePath2 Path to ignore when encountered at the end of
2233 * arguments. (Not quite safe for simple file names,
2234 * but what the heck.)
2235 * @param pSum Where to store the check sum.
2236 */
2237static void kOCEntryCalcArgvSum(PKOCENTRY pEntry, const char * const *papszArgv, unsigned cArgc,
2238 const char *pszIgnorePath1, const char *pszIgnorePath2, PKOCSUM pSum)
2239{
2240 size_t cchIgnorePath1 = strlen(pszIgnorePath1);
2241 size_t cchIgnorePath2 = pszIgnorePath2 ? strlen(pszIgnorePath2) : ~(size_t)0;
2242 KOCSUMCTX Ctx;
2243 unsigned i;
2244
2245 kOCSumInitWithCtx(pSum, &Ctx);
2246 for (i = 0; i < cArgc; i++)
2247 {
2248 size_t cch = strlen(papszArgv[i]);
2249 if ( ( cch < cchIgnorePath1
2250 || !ArePathsIdenticalN(papszArgv[i] + cch - cchIgnorePath1, pszIgnorePath1, cch))
2251 && ( cch < cchIgnorePath2
2252 || !ArePathsIdenticalN(papszArgv[i] + cch - cchIgnorePath2, pszIgnorePath2, cch)) )
2253 kOCSumUpdate(pSum, &Ctx, papszArgv[i], cch + 1);
2254 }
2255 kOCSumFinalize(pSum, &Ctx);
2256
2257 (void)pEntry;
2258}
2259
2260
2261/**
2262 * Reads and parses the cache file.
2263 *
2264 * @param pEntry The entry to read it into.
2265 */
2266static void kOCEntryRead(PKOCENTRY pEntry)
2267{
2268 FILE *pFile;
2269 pFile = FOpenFileInDir(pEntry->pszName, pEntry->pszDir, "rb");
2270 if (pFile)
2271 {
2272 InfoMsg(4, "reading cache entry...\n");
2273
2274 /*
2275 * Check the magic.
2276 */
2277 if ( !fgets(g_szLine, sizeof(g_szLine), pFile)
2278 || ( strcmp(g_szLine, "magic=kObjCacheEntry-v0.1.0\n")
2279 && strcmp(g_szLine, "magic=kObjCacheEntry-v0.1.1\n"))
2280 )
2281 {
2282 InfoMsg(2, "bad cache file (magic)\n");
2283 pEntry->fNeedCompiling = 1;
2284 }
2285 else
2286 {
2287 /*
2288 * Parse the rest of the file (relaxed order).
2289 */
2290 unsigned i;
2291 int fBad = 0;
2292 int fBadBeforeMissing = 1;
2293 while (fgets(g_szLine, sizeof(g_szLine), pFile))
2294 {
2295 char *pszNl;
2296 char *pszVal;
2297
2298 /* Split the line and drop the trailing newline. */
2299 pszVal = strchr(g_szLine, '=');
2300 if ((fBad = pszVal == NULL))
2301 break;
2302 *pszVal++ = '\0';
2303
2304 pszNl = strchr(pszVal, '\n');
2305 if (pszNl)
2306 *pszNl = '\0';
2307
2308 /* string case on variable name */
2309 if (!strcmp(g_szLine, "obj"))
2310 {
2311 if ((fBad = pEntry->Old.pszObjName != NULL))
2312 break;
2313 pEntry->Old.pszObjName = xstrdup(pszVal);
2314 }
2315 else if (!strcmp(g_szLine, "cpp"))
2316 {
2317 if ((fBad = pEntry->Old.pszCppName != NULL))
2318 break;
2319 pEntry->Old.pszCppName = xstrdup(pszVal);
2320 }
2321 else if (!strcmp(g_szLine, "cpp-size"))
2322 {
2323 char *pszNext;
2324 if ((fBad = pEntry->Old.cbCpp != 0))
2325 break;
2326 pEntry->Old.cbCpp = strtoul(pszVal, &pszNext, 0);
2327 if ((fBad = pszNext && *pszNext))
2328 break;
2329 }
2330 else if (!strcmp(g_szLine, "cpp-sum"))
2331 {
2332 KOCSUM Sum;
2333 if ((fBad = kOCSumInitFromString(&Sum, pszVal)))
2334 break;
2335 kOCSumAdd(&pEntry->Old.SumHead, &Sum);
2336 }
2337 else if (!strcmp(g_szLine, "cpp-ms"))
2338 {
2339 char *pszNext;
2340 if ((fBad = pEntry->Old.cMsCpp != 0))
2341 break;
2342 pEntry->Old.cMsCpp = strtoul(pszVal, &pszNext, 0);
2343 if ((fBad = pszNext && *pszNext))
2344 break;
2345 }
2346 else if (!strcmp(g_szLine, "cc-argc"))
2347 {
2348 if ((fBad = pEntry->Old.papszArgvCompile != NULL))
2349 break;
2350 pEntry->Old.cArgvCompile = atoi(pszVal); /* if wrong, we'll fail below. */
2351 pEntry->Old.papszArgvCompile = xmallocz((pEntry->Old.cArgvCompile + 1) * sizeof(pEntry->Old.papszArgvCompile[0]));
2352 }
2353 else if (!strncmp(g_szLine, "cc-argv-#", sizeof("cc-argv-#") - 1))
2354 {
2355 char *pszNext;
2356 unsigned i = strtoul(&g_szLine[sizeof("cc-argv-#") - 1], &pszNext, 0);
2357 if ((fBad = i >= pEntry->Old.cArgvCompile || pEntry->Old.papszArgvCompile[i] || (pszNext && *pszNext)))
2358 break;
2359 pEntry->Old.papszArgvCompile[i] = xstrdup(pszVal);
2360 }
2361 else if (!strcmp(g_szLine, "cc-argv-sum"))
2362 {
2363 if ((fBad = !kOCSumIsEmpty(&pEntry->Old.SumCompArgv)))
2364 break;
2365 if ((fBad = kOCSumInitFromString(&pEntry->Old.SumCompArgv, pszVal)))
2366 break;
2367 }
2368 else if (!strcmp(g_szLine, "cc-ms"))
2369 {
2370 char *pszNext;
2371 if ((fBad = pEntry->Old.cMsCompile != 0))
2372 break;
2373 pEntry->Old.cMsCompile = strtoul(pszVal, &pszNext, 0);
2374 if ((fBad = pszNext && *pszNext))
2375 break;
2376 }
2377 else if (!strcmp(g_szLine, "target"))
2378 {
2379 if ((fBad = pEntry->Old.pszTarget != NULL))
2380 break;
2381 pEntry->Old.pszTarget = xstrdup(pszVal);
2382 }
2383 else if (!strcmp(g_szLine, "key"))
2384 {
2385 char *pszNext;
2386 if ((fBad = pEntry->uKey != 0))
2387 break;
2388 pEntry->uKey = strtoul(pszVal, &pszNext, 0);
2389 if ((fBad = pszNext && *pszNext))
2390 break;
2391 }
2392 else if (!strcmp(g_szLine, "the-end"))
2393 {
2394 fBadBeforeMissing = fBad = strcmp(pszVal, "fine");
2395 break;
2396 }
2397 else
2398 {
2399 fBad = 1;
2400 break;
2401 }
2402 } /* parse loop */
2403
2404 /*
2405 * Did we find everything and does it add up correctly?
2406 */
2407 if (!fBad && fBadBeforeMissing)
2408 {
2409 InfoMsg(2, "bad cache file (no end)\n");
2410 fBad = 1;
2411 }
2412 else
2413 {
2414 fBadBeforeMissing = fBad;
2415 if ( !fBad
2416 && ( !pEntry->Old.papszArgvCompile
2417 || !pEntry->Old.pszObjName
2418 || !pEntry->Old.pszCppName
2419 || kOCSumIsEmpty(&pEntry->Old.SumHead)))
2420 fBad = 1;
2421 if (!fBad)
2422 for (i = 0; i < pEntry->Old.cArgvCompile; i++)
2423 if ((fBad = !pEntry->Old.papszArgvCompile[i]))
2424 break;
2425 if (!fBad)
2426 {
2427 KOCSUM Sum;
2428 kOCEntryCalcArgvSum(pEntry, (const char * const *)pEntry->Old.papszArgvCompile,
2429 pEntry->Old.cArgvCompile, pEntry->Old.pszObjName, pEntry->Old.pszCppName,
2430 &Sum);
2431 fBad = !kOCSumIsEqual(&pEntry->Old.SumCompArgv, &Sum);
2432 }
2433 if (fBad)
2434 InfoMsg(2, "bad cache file (%s)\n", fBadBeforeMissing ? g_szLine : "missing stuff");
2435 else if (ferror(pFile))
2436 {
2437 InfoMsg(2, "cache file read error\n");
2438 fBad = 1;
2439 }
2440
2441 /*
2442 * Verify the existance of the object file.
2443 */
2444 if (!fBad)
2445 {
2446 struct stat st;
2447 char *pszPath = MakePathFromDirAndFile(pEntry->Old.pszObjName, pEntry->pszDir);
2448 if (stat(pszPath, &st) != 0)
2449 {
2450 InfoMsg(2, "failed to stat object file: %s\n", strerror(errno));
2451 fBad = 1;
2452 }
2453 else
2454 {
2455 /** @todo verify size and the timestamp. */
2456 }
2457 }
2458 }
2459 pEntry->fNeedCompiling = fBad;
2460 }
2461 fclose(pFile);
2462 }
2463 else
2464 {
2465 InfoMsg(2, "no cache file\n");
2466 pEntry->fNeedCompiling = 1;
2467 }
2468}
2469
2470
2471/**
2472 * Writes the cache file.
2473 *
2474 * @param pEntry The entry to write.
2475 */
2476static void kOCEntryWrite(PKOCENTRY pEntry)
2477{
2478 FILE *pFile;
2479 PCKOCSUM pSum;
2480 unsigned i;
2481
2482 InfoMsg(4, "writing cache entry '%s'...\n", pEntry->pszName);
2483 pFile = FOpenFileInDir(pEntry->pszName, pEntry->pszDir, "wb");
2484 if (!pFile)
2485 FatalDie("Failed to open '%s' in '%s': %s\n",
2486 pEntry->pszName, pEntry->pszDir, strerror(errno));
2487
2488#define CHECK_LEN(expr) \
2489 do { int cch = expr; if (cch >= KOBJCACHE_MAX_LINE_LEN) FatalDie("Line too long: %d (max %d)\nexpr: %s\n", cch, KOBJCACHE_MAX_LINE_LEN, #expr); } while (0)
2490
2491 fprintf(pFile, "magic=kObjCacheEntry-v0.1.1\n");
2492 CHECK_LEN(fprintf(pFile, "target=%s\n", pEntry->New.pszTarget ? pEntry->New.pszTarget : pEntry->Old.pszTarget));
2493 CHECK_LEN(fprintf(pFile, "key=%lu\n", (unsigned long)pEntry->uKey));
2494 CHECK_LEN(fprintf(pFile, "obj=%s\n", pEntry->New.pszObjName ? pEntry->New.pszObjName : pEntry->Old.pszObjName));
2495 CHECK_LEN(fprintf(pFile, "cpp=%s\n", pEntry->New.pszCppName ? pEntry->New.pszCppName : pEntry->Old.pszCppName));
2496 CHECK_LEN(fprintf(pFile, "cpp-size=%lu\n", pEntry->New.pszCppName ? pEntry->New.cbCpp : pEntry->Old.cbCpp));
2497 CHECK_LEN(fprintf(pFile, "cpp-ms=%lu\n", pEntry->New.pszCppName ? pEntry->New.cMsCpp : pEntry->Old.cMsCpp));
2498 CHECK_LEN(fprintf(pFile, "cc-ms=%lu\n", pEntry->New.pszCppName ? pEntry->New.cMsCompile : pEntry->Old.cMsCompile));
2499
2500 if (!kOCSumIsEmpty(&pEntry->New.SumCompArgv))
2501 {
2502 CHECK_LEN(fprintf(pFile, "cc-argc=%u\n", pEntry->New.cArgvCompile));
2503 for (i = 0; i < pEntry->New.cArgvCompile; i++)
2504 CHECK_LEN(fprintf(pFile, "cc-argv-#%u=%s\n", i, pEntry->New.papszArgvCompile[i]));
2505 fprintf(pFile, "cc-argv-sum=");
2506 kOCSumFPrintf(&pEntry->New.SumCompArgv, pFile);
2507 }
2508 else
2509 {
2510 CHECK_LEN(fprintf(pFile, "cc-argc=%u\n", pEntry->Old.cArgvCompile));
2511 for (i = 0; i < pEntry->Old.cArgvCompile; i++)
2512 CHECK_LEN(fprintf(pFile, "cc-argv-#%u=%s\n", i, pEntry->Old.papszArgvCompile[i]));
2513 fprintf(pFile, "cc-argv-sum=");
2514 kOCSumFPrintf(&pEntry->Old.SumCompArgv, pFile);
2515 }
2516
2517
2518 for (pSum = !kOCSumIsEmpty(&pEntry->New.SumHead) ? &pEntry->New.SumHead : &pEntry->Old.SumHead;
2519 pSum;
2520 pSum = pSum->pNext)
2521 {
2522 fprintf(pFile, "cpp-sum=");
2523 kOCSumFPrintf(pSum, pFile);
2524 }
2525
2526 fprintf(pFile, "the-end=fine\n");
2527
2528#undef CHECK_LEN
2529
2530 /*
2531 * Flush the file and check for errors.
2532 * On failure delete the file so we won't be seeing any invalid
2533 * files the next time or upset make with new timestamps.
2534 */
2535 errno = 0;
2536 if ( fflush(pFile) < 0
2537 || ferror(pFile))
2538 {
2539 int iErr = errno;
2540 fclose(pFile);
2541 UnlinkFileInDir(pEntry->pszName, pEntry->pszDir);
2542 FatalDie("Stream error occured while writing '%s' in '%s': %s\n",
2543 pEntry->pszName, pEntry->pszDir, strerror(iErr));
2544 }
2545 fclose(pFile);
2546}
2547
2548
2549/**
2550 * Checks that the read cache entry is valid.
2551 * It sets fNeedCompiling if it isn't.
2552 *
2553 * @returns 1 valid, 0 invalid.
2554 * @param pEntry The cache entry.
2555 */
2556static int kOCEntryCheck(PKOCENTRY pEntry)
2557{
2558 return !pEntry->fNeedCompiling;
2559}
2560
2561
2562/**
2563 * Sets the object name and compares it with the old name if present.
2564 *
2565 * @param pEntry The cache entry.
2566 * @param pszObjName The new object name.
2567 */
2568static void kOCEntrySetCompileObjName(PKOCENTRY pEntry, const char *pszObjName)
2569{
2570 assert(!pEntry->New.pszObjName);
2571 pEntry->New.pszObjName = CalcRelativeName(pszObjName, pEntry->pszDir);
2572
2573 if ( !pEntry->fNeedCompiling
2574 && ( !pEntry->Old.pszObjName
2575 || strcmp(pEntry->New.pszObjName, pEntry->Old.pszObjName)))
2576 {
2577 InfoMsg(2, "object file name differs\n");
2578 pEntry->fNeedCompiling = 1;
2579 }
2580
2581 if ( !pEntry->fNeedCompiling
2582 && !DoesFileInDirExist(pEntry->New.pszObjName, pEntry->pszDir))
2583 {
2584 InfoMsg(2, "object file doesn't exist\n");
2585 pEntry->fNeedCompiling = 1;
2586 }
2587}
2588
2589
2590/**
2591 * Set the new compiler args, calc their checksum, and comparing them with any old ones.
2592 *
2593 * @param pEntry The cache entry.
2594 * @param papszArgvCompile The new argument vector for compilation.
2595 * @param cArgvCompile The number of arguments in the vector.
2596 *
2597 * @remark Must call kOCEntrySetCompileObjName before this function!
2598 */
2599static void kOCEntrySetCompileArgv(PKOCENTRY pEntry, const char * const *papszArgvCompile, unsigned cArgvCompile)
2600{
2601 unsigned i;
2602
2603 /* call me only once! */
2604 assert(!pEntry->New.cArgvCompile);
2605 /* call kOCEntrySetCompilerObjName first! */
2606 assert(pEntry->New.pszObjName);
2607
2608 /*
2609 * Copy the argument vector and calculate the checksum.
2610 */
2611 pEntry->New.cArgvCompile = cArgvCompile;
2612 pEntry->New.papszArgvCompile = xmalloc((cArgvCompile + 1) * sizeof(pEntry->New.papszArgvCompile[0]));
2613 for (i = 0; i < cArgvCompile; i++)
2614 pEntry->New.papszArgvCompile[i] = xstrdup(papszArgvCompile[i]);
2615 pEntry->New.papszArgvCompile[i] = NULL; /* for exev/spawnv */
2616
2617 kOCEntryCalcArgvSum(pEntry, papszArgvCompile, cArgvCompile, pEntry->New.pszObjName, pEntry->New.pszCppName,
2618 &pEntry->New.SumCompArgv);
2619 kOCSumInfo(&pEntry->New.SumCompArgv, 4, "comp-argv");
2620
2621 /*
2622 * Compare with the old argument vector.
2623 */
2624 if ( !pEntry->fNeedCompiling
2625 && !kOCSumIsEqual(&pEntry->New.SumCompArgv, &pEntry->Old.SumCompArgv))
2626 {
2627 InfoMsg(2, "compiler args differs\n");
2628 pEntry->fNeedCompiling = 1;
2629 }
2630}
2631
2632
2633/**
2634 * Sets the arch/os target and compares it with the old name if present.
2635 *
2636 * @param pEntry The cache entry.
2637 * @param pszObjName The new object name.
2638 */
2639static void kOCEntrySetTarget(PKOCENTRY pEntry, const char *pszTarget)
2640{
2641 assert(!pEntry->New.pszTarget);
2642 pEntry->New.pszTarget = xstrdup(pszTarget);
2643
2644 if ( !pEntry->fNeedCompiling
2645 && ( !pEntry->Old.pszTarget
2646 || strcmp(pEntry->New.pszTarget, pEntry->Old.pszTarget)))
2647 {
2648 InfoMsg(2, "target differs\n");
2649 pEntry->fNeedCompiling = 1;
2650 }
2651}
2652
2653
2654/**
2655 * Sets the preprocessor output filename. We don't generally care if this
2656 * matches the old name or not.
2657 *
2658 * @param pEntry The cache entry.
2659 * @param pszCppName The preprocessor output filename.
2660 */
2661static void kOCEntrySetCppName(PKOCENTRY pEntry, const char *pszCppName)
2662{
2663 assert(!pEntry->New.pszCppName);
2664 pEntry->New.pszCppName = CalcRelativeName(pszCppName, pEntry->pszDir);
2665}
2666
2667
2668/**
2669 * Sets the piped mode of the preprocessor and compiler.
2670 *
2671 * @param pEntry The cache entry.
2672 * @param fRedirPreCompStdOut Whether the preprocessor is in piped mode.
2673 * @param fRedirCompileStdIn Whether the compiler is in piped mode.
2674 * @param pszNmPipeCompile The name of the named pipe to use to feed
2675 * the microsoft compiler.
2676 */
2677static void kOCEntrySetPipedMode(PKOCENTRY pEntry, int fRedirPreCompStdOut, int fRedirCompileStdIn,
2678 const char *pszNmPipeCompile)
2679{
2680 pEntry->fPipedPreComp = fRedirPreCompStdOut;
2681 pEntry->fPipedCompile = fRedirCompileStdIn || pszNmPipeCompile;
2682 pEntry->pszNmPipeCompile = xstrdup(pszNmPipeCompile);
2683}
2684
2685
2686/**
2687 * Sets the dependency file.
2688 *
2689 * @param pEntry The cache entry.
2690 * @param pszMakeDepFilename The dependency filename.
2691 * @param fMakeDepFixCase Whether to fix the case of dependency files.
2692 * @param fMakeDepQuiet Whether to be quiet about the dependencies.
2693 * @param fMakeDepGenStubs Whether to generate stubs.
2694 */
2695static void kOCEntrySetDepFilename(PKOCENTRY pEntry, const char *pszMakeDepFilename,
2696 int fMakeDepFixCase, int fMakeDepQuiet, int fMakeDepGenStubs)
2697{
2698 pEntry->pszMakeDepFilename = xstrdup(pszMakeDepFilename);
2699 pEntry->fMakeDepFixCase = fMakeDepFixCase;
2700 pEntry->fMakeDepQuiet = fMakeDepQuiet;
2701 pEntry->fMakeDepGenStubs = fMakeDepGenStubs;
2702}
2703
2704
2705/**
2706 * Configures the preprocessor output optimizations.
2707 *
2708 * @param pEntry The cache entry.
2709 * @param fOptimizeCpp The one and only flag, so far.
2710 */
2711static void kOCEntrySetOptimizations(PKOCENTRY pEntry, int fOptimizeCpp)
2712{
2713 pEntry->fOptimizeCpp = fOptimizeCpp;
2714}
2715
2716
2717/**
2718 * Spawns a child in a synchronous fashion.
2719 * Terminating on failure.
2720 *
2721 * @param papszArgv Argument vector. The cArgv element is NULL.
2722 * @param pcMs The cache entry member use for time keeping. This
2723 * will be set to the current timestamp.
2724 * @param cArgv The number of arguments in the vector.
2725 * @param pszMsg Which operation this is, for use in messages.
2726 * @param pszStdOut Where to redirect standard out.
2727 */
2728static void kOCEntrySpawn(PCKOCENTRY pEntry, uint32_t *pcMs, const char * const *papszArgv, unsigned cArgv,
2729 const char *pszMsg, const char *pszStdOut)
2730{
2731#if defined(__OS2__) || defined(__WIN__)
2732 intptr_t rc;
2733 int fdStdOut = -1;
2734 if (pszStdOut)
2735 {
2736 int fdReDir;
2737 fdStdOut = dup(STDOUT_FILENO);
2738 close(STDOUT_FILENO);
2739 fdReDir = open(pszStdOut, O_CREAT | O_TRUNC | O_WRONLY, 0666);
2740 if (fdReDir < 0)
2741 FatalDie("%s - failed to create stdout redirection file '%s': %s\n",
2742 pszMsg, pszStdOut, strerror(errno));
2743
2744 if (fdReDir != STDOUT_FILENO)
2745 {
2746 if (dup2(fdReDir, STDOUT_FILENO) < 0)
2747 FatalDie("%s - dup2 failed: %s\n", pszMsg, strerror(errno));
2748 close(fdReDir);
2749 }
2750 }
2751
2752 *pcMs = NowMs();
2753 errno = 0;
2754# ifdef __WIN__
2755 rc = quoted_spawnvp(_P_WAIT, papszArgv[0], papszArgv);
2756# else
2757 rc = _spawnvp(_P_WAIT, papszArgv[0], papszArgv);
2758# endif
2759 *pcMs = NowMs() - *pcMs;
2760 if (rc < 0)
2761 FatalDie("%s - _spawnvp failed (rc=0x%p): %s\n", pszMsg, rc, strerror(errno));
2762 if (rc > 0)
2763 FatalDie("%s - failed rc=%d\n", pszMsg, (int)rc);
2764 if (fdStdOut != -1)
2765 {
2766 close(STDOUT_FILENO);
2767 fdStdOut = dup2(fdStdOut, STDOUT_FILENO);
2768 close(fdStdOut);
2769 }
2770
2771#else
2772 int iStatus;
2773 pid_t pidWait;
2774 pid_t pid;
2775
2776 *pcMs = NowMs();
2777 pid = fork();
2778 if (!pid)
2779 {
2780 if (pszStdOut)
2781 {
2782 int fdReDir;
2783
2784 close(STDOUT_FILENO);
2785 fdReDir = open(pszStdOut, O_CREAT | O_TRUNC | O_WRONLY, 0666);
2786 if (fdReDir < 0)
2787 FatalDie("%s - failed to create stdout redirection file '%s': %s\n",
2788 pszMsg, pszStdOut, strerror(errno));
2789 if (fdReDir != STDOUT_FILENO)
2790 {
2791 if (dup2(fdReDir, STDOUT_FILENO) < 0)
2792 FatalDie("%s - dup2 failed: %s\n", pszMsg, strerror(errno));
2793 close(fdReDir);
2794 }
2795 }
2796
2797 execvp(papszArgv[0], (char **)papszArgv);
2798 FatalDie("%s - execvp failed: %s\n",
2799 pszMsg, strerror(errno));
2800 }
2801 if (pid == -1)
2802 FatalDie("%s - fork() failed: %s\n", pszMsg, strerror(errno));
2803
2804 pidWait = waitpid(pid, &iStatus, 0);
2805 while (pidWait < 0 && errno == EINTR)
2806 pidWait = waitpid(pid, &iStatus, 0);
2807 *pcMs = NowMs() - *pcMs;
2808 if (pidWait != pid)
2809 FatalDie("%s - waitpid failed rc=%d: %s\n",
2810 pszMsg, pidWait, strerror(errno));
2811 if (!WIFEXITED(iStatus))
2812 FatalDie("%s - abended (iStatus=%#x)\n", pszMsg, iStatus);
2813 if (WEXITSTATUS(iStatus))
2814 FatalDie("%s - failed with rc %d\n", pszMsg, WEXITSTATUS(iStatus));
2815#endif
2816
2817 (void)pEntry; (void)cArgv;
2818}
2819
2820
2821/**
2822 * Spawns child with optional redirection of stdin and stdout.
2823 *
2824 * @param pEntry The cache entry.
2825 * @param pcMs The cache entry member use for time keeping. This
2826 * will be set to the current timestamp.
2827 * @param papszArgv Argument vector. The cArgv element is NULL.
2828 * @param cArgv The number of arguments in the vector.
2829 * @param fdStdIn Child stdin, -1 if it should inherit our stdin. Will be closed.
2830 * @param fdStdOut Child stdout, -1 if it should inherit our stdout. Will be closed.
2831 * @param pszMsg Message to start the info/error messages with.
2832 */
2833static pid_t kOCEntrySpawnChild(PCKOCENTRY pEntry, uint32_t *pcMs, const char * const *papszArgv, unsigned cArgv,
2834 int fdStdIn, int fdStdOut, const char *pszMsg)
2835{
2836 pid_t pid;
2837 int fdSavedStdOut = -1;
2838 int fdSavedStdIn = -1;
2839
2840 /*
2841 * Setup redirection.
2842 */
2843 if (fdStdOut != -1 && fdStdOut != STDOUT_FILENO)
2844 {
2845 fdSavedStdOut = dup(STDOUT_FILENO);
2846 if (dup2(fdStdOut, STDOUT_FILENO) < 0)
2847 FatalDie("%s - dup2(,1) failed: %s\n", pszMsg, strerror(errno));
2848 close(fdStdOut);
2849#ifndef __WIN__
2850 fcntl(fdSavedStdOut, F_SETFD, FD_CLOEXEC);
2851#endif
2852 }
2853 if (fdStdIn != -1 && fdStdIn != STDIN_FILENO)
2854 {
2855 fdSavedStdIn = dup(STDIN_FILENO);
2856 if (dup2(fdStdIn, STDIN_FILENO) < 0)
2857 FatalDie("%s - dup2(,0) failed: %s\n", pszMsg, strerror(errno));
2858 close(fdStdIn);
2859#ifndef __WIN__
2860 fcntl(fdSavedStdIn, F_SETFD, FD_CLOEXEC);
2861#endif
2862 }
2863
2864 /*
2865 * Create the child process.
2866 */
2867 *pcMs = NowMs();
2868#if defined(__OS2__) || defined(__WIN__)
2869 errno = 0;
2870# ifdef __WIN__
2871 pid = quoted_spawnvp(_P_NOWAIT, papszArgv[0], papszArgv);
2872# else
2873 pid = _spawnvp(_P_NOWAIT, papszArgv[0], papszArgv);
2874# endif
2875 if (pid == -1)
2876 FatalDie("preprocess - _spawnvp failed: %s\n", strerror(errno));
2877
2878#else
2879 pid = fork();
2880 if (!pid)
2881 {
2882 execvp(papszArgv[0], (char **)papszArgv);
2883 FatalDie("preprocess - execvp failed: %s\n", strerror(errno));
2884 }
2885 if (pid == -1)
2886 FatalDie("preprocess - fork() failed: %s\n", strerror(errno));
2887#endif
2888
2889 /*
2890 * Restore stdout & stdin.
2891 */
2892 if (fdSavedStdIn != -1)
2893 {
2894 close(STDIN_FILENO);
2895 dup2(fdStdOut, STDIN_FILENO);
2896 close(fdSavedStdIn);
2897 }
2898 if (fdSavedStdOut != -1)
2899 {
2900 close(STDOUT_FILENO);
2901 dup2(fdSavedStdOut, STDOUT_FILENO);
2902 close(fdSavedStdOut);
2903 }
2904
2905 InfoMsg(3, "%s - spawned %ld\n", pszMsg, (long)pid);
2906 (void)cArgv;
2907 (void)pEntry;
2908 return pid;
2909}
2910
2911
2912/**
2913 * Waits for a child and exits fatally if the child failed in any way.
2914 *
2915 * @param pEntry The cache entry.
2916 * @param pcMs The millisecond timestamp that should be convert to
2917 * elapsed time.
2918 * @param pid The child to wait for.
2919 * @param pszMsg Message to start the info/error messages with.
2920 */
2921static void kOCEntryWaitChild(PCKOCENTRY pEntry, uint32_t *pcMs, pid_t pid, const char *pszMsg)
2922{
2923 int iStatus = -1;
2924 pid_t pidWait;
2925 InfoMsg(3, "%s - wait-child %ld\n", pszMsg, (long)pid);
2926
2927#ifdef __WIN__
2928 pidWait = _cwait(&iStatus, pid, _WAIT_CHILD);
2929 *pcMs = NowMs() - *pcMs;
2930 if (pidWait == -1)
2931 FatalDie("%s - waitpid failed: %s\n", pszMsg, strerror(errno));
2932 if (iStatus)
2933 FatalDie("%s - failed with rc %d\n", pszMsg, iStatus);
2934#else
2935 pidWait = waitpid(pid, &iStatus, 0);
2936 while (pidWait < 0 && errno == EINTR)
2937 pidWait = waitpid(pid, &iStatus, 0);
2938 *pcMs = NowMs() - *pcMs;
2939 if (pidWait != pid)
2940 FatalDie("%s - waitpid failed rc=%d: %s\n", pidWait, strerror(errno));
2941 if (!WIFEXITED(iStatus))
2942 FatalDie("%s - abended (iStatus=%#x)\n", pszMsg, iStatus);
2943 if (WEXITSTATUS(iStatus))
2944 FatalDie("%s - failed with rc %d\n", pszMsg, WEXITSTATUS(iStatus));
2945#endif
2946 (void)pEntry;
2947}
2948
2949
2950/**
2951 * Creates a pipe for setting up redirected stdin/stdout.
2952 *
2953 * @param pEntry The cache entry.
2954 * @param paFDs Where to store the two file descriptors.
2955 * @param pszMsg The operation message for info/error messages.
2956 * @param pszPipeName The pipe name if it is supposed to be named. (Windows only.)
2957 * @param fText Whether to read text mode or binary mode.
2958 */
2959static void kOCEntryCreatePipe(PKOCENTRY pEntry, int *paFDs, const char *pszPipeName, const char *pszMsg, int fText)
2960{
2961 paFDs[0] = paFDs[1] = -1;
2962#if defined(__WIN__)
2963 if (pszPipeName)
2964 {
2965 HANDLE hPipe = CreateNamedPipeA(pszPipeName,
2966 /*PIPE_ACCESS_OUTBOUND*/ PIPE_ACCESS_DUPLEX,
2967 PIPE_READMODE_BYTE | PIPE_WAIT,
2968 10 /* nMaxInstances */,
2969 0x10000 /* nOutBuffer */,
2970 0x10000 /* nInBuffer */,
2971 NMPWAIT_WAIT_FOREVER,
2972 NULL /* pSecurityAttributes */);
2973
2974 if (hPipe == INVALID_HANDLE_VALUE)
2975 FatalDie("%s - CreateNamedPipe(%s) failed: %d\n", pszMsg, pszPipeName, GetLastError());
2976
2977 paFDs[1 /* write */] = _open_osfhandle((intptr_t)hPipe, _O_WRONLY | _O_TEXT | _O_NOINHERIT);
2978 if (paFDs[1 /* write */] == -1)
2979 FatalDie("%s - _open_osfhandle failed: %d\n", pszMsg, strerror(errno));
2980 }
2981 else if ( _pipe(paFDs, 256*1024, _O_NOINHERIT | (fText ? _O_TEXT : _O_BINARY)) < 0
2982 && _pipe(paFDs, 0, _O_NOINHERIT | (fText ? _O_TEXT : _O_BINARY)) < 0)
2983#else
2984 if (pipe(paFDs) < 0)
2985#endif
2986 FatalDie("%s - pipe failed: %s\n", pszMsg, strerror(errno));
2987#if !defined(__WIN__)
2988 fcntl(paFDs[0], F_SETFD, FD_CLOEXEC);
2989 fcntl(paFDs[1], F_SETFD, FD_CLOEXEC);
2990#endif
2991
2992 (void)pEntry;
2993}
2994
2995
2996/**
2997 * Spawns a child that produces output to stdout.
2998 *
2999 * @param papszArgv Argument vector. The cArgv element is NULL.
3000 * @param cArgv The number of arguments in the vector.
3001 * @param pszMsg The operation message for info/error messages.
3002 * @param pfnConsumer Pointer to a consumer callback function that is responsible
3003 * for servicing the child output and closing the pipe.
3004 */
3005static void kOCEntrySpawnProducer(PKOCENTRY pEntry, const char * const *papszArgv, unsigned cArgv, const char *pszMsg,
3006 void (*pfnConsumer)(PKOCENTRY, int))
3007{
3008 int fds[2];
3009 pid_t pid;
3010
3011 kOCEntryCreatePipe(pEntry, fds, NULL, pszMsg, pEntry->fOptimizeCpp);
3012 pid = kOCEntrySpawnChild(pEntry, &pEntry->New.cMsCpp, papszArgv, cArgv, -1, fds[1 /* write */], pszMsg);
3013
3014 pfnConsumer(pEntry, fds[0 /* read */]);
3015
3016 kOCEntryWaitChild(pEntry, &pEntry->New.cMsCpp, pid, pszMsg);
3017}
3018
3019
3020/**
3021 * Spawns a child that consumes input on stdin or via a named pipe.
3022 *
3023 * @param papszArgv Argument vector. The cArgv element is NULL.
3024 * @param cArgv The number of arguments in the vector.
3025 * @param pszMsg The operation message for info/error messages.
3026 * @param pfnProducer Pointer to a producer callback function that is responsible
3027 * for serving the child input and closing the pipe.
3028 */
3029static void kOCEntrySpawnConsumer(PKOCENTRY pEntry, const char * const *papszArgv, unsigned cArgv, const char *pszMsg,
3030 void (*pfnProducer)(PKOCENTRY, int))
3031{
3032 int fds[2];
3033 pid_t pid;
3034
3035 kOCEntryCreatePipe(pEntry, fds, pEntry->pszNmPipeCompile, pszMsg, 0 /*fText*/);
3036 pid = kOCEntrySpawnChild(pEntry, &pEntry->New.cMsCompile, papszArgv, cArgv, fds[0 /* read */], -1, pszMsg);
3037#ifdef __WIN__
3038 if (pEntry->pszNmPipeCompile && !ConnectNamedPipe((HANDLE)_get_osfhandle(fds[1 /* write */]), NULL))
3039 FatalDie("compile - ConnectNamedPipe failed: %d\n", GetLastError());
3040#endif
3041
3042 pfnProducer(pEntry, fds[1 /* write */]);
3043
3044 kOCEntryWaitChild(pEntry, &pEntry->New.cMsCompile, pid, pszMsg);
3045}
3046
3047
3048/**
3049 * Spawns two child processes, one producing output and one consuming.
3050 * Terminating on failure.
3051 *
3052 * @param papszArgv Argument vector. The cArgv element is NULL.
3053 * @param cArgv The number of arguments in the vector.
3054 * @param pszMsg The operation message for info/error messages.
3055 * @param pfnConsumer Pointer to a consumer callback function that is responsible
3056 * for servicing the child output and closing the pipe.
3057 */
3058static void kOCEntrySpawnTee(PKOCENTRY pEntry, const char * const *papszProdArgv, unsigned cProdArgv,
3059 const char * const *papszConsArgv, unsigned cConsArgv,
3060 const char *pszMsg, void (*pfnTeeConsumer)(PKOCENTRY, int, int))
3061{
3062 int fds[2];
3063 int fdIn, fdOut;
3064 pid_t pidProducer, pidConsumer;
3065
3066 /*
3067 * The producer.
3068 */
3069 kOCEntryCreatePipe(pEntry, fds, NULL, pszMsg, pEntry->fOptimizeCpp);
3070 pidConsumer = kOCEntrySpawnChild(pEntry, &pEntry->New.cMsCpp, papszProdArgv, cProdArgv, -1, fds[1 /* write */], pszMsg);
3071 fdIn = fds[0 /* read */];
3072
3073 /*
3074 * The consumer.
3075 */
3076 kOCEntryCreatePipe(pEntry, fds, pEntry->pszNmPipeCompile, pszMsg, 0 /*fText*/);
3077 pidProducer = kOCEntrySpawnChild(pEntry, &pEntry->New.cMsCompile, papszConsArgv, cConsArgv, fds[0 /* read */], -1, pszMsg);
3078 fdOut = fds[1 /* write */];
3079
3080 /*
3081 * Hand it on to the tee consumer.
3082 */
3083 pfnTeeConsumer(pEntry, fdIn, fdOut);
3084
3085 /*
3086 * Reap the children.
3087 */
3088 kOCEntryWaitChild(pEntry, &pEntry->New.cMsCpp, pidProducer, pszMsg);
3089 kOCEntryWaitChild(pEntry, &pEntry->New.cMsCompile, pidConsumer, pszMsg);
3090}
3091
3092
3093/**
3094 * Reads the output from the preprocessor.
3095 *
3096 * @param pEntry The cache entry. New.cbCpp and New.pszCppMapping will be updated.
3097 * @param pWhich Specifies what to read (old/new).
3098 * @param fNonFatal Whether failure is fatal or not.
3099 */
3100static int kOCEntryReadCppOutput(PKOCENTRY pEntry, struct KOCENTRYDATA *pWhich, int fNonFatal)
3101{
3102 pWhich->pszCppMapping = ReadFileInDir(pWhich->pszCppName, pEntry->pszDir, &pWhich->cbCpp);
3103 if (!pWhich->pszCppMapping)
3104 {
3105 if (!fNonFatal)
3106 FatalDie("failed to open/read '%s' in '%s': %s\n",
3107 pWhich->pszCppName, pEntry->pszDir, strerror(errno));
3108 InfoMsg(2, "failed to open/read '%s' in '%s': %s\n",
3109 pWhich->pszCppName, pEntry->pszDir, strerror(errno));
3110 return -1;
3111 }
3112
3113 InfoMsg(3, "preprocessed file is %lu bytes long\n", (unsigned long)pWhich->cbCpp);
3114 return 0;
3115}
3116
3117
3118/**
3119 * Worker for kOCEntryPreProcess and calculates the checksum of
3120 * the preprocessor output.
3121 *
3122 * @param pEntry The cache entry. NewSum will be updated.
3123 */
3124static void kOCEntryCalcChecksum(PKOCENTRY pEntry)
3125{
3126 KOCSUMCTX Ctx;
3127 kOCSumInitWithCtx(&pEntry->New.SumHead, &Ctx);
3128 kOCSumUpdate(&pEntry->New.SumHead, &Ctx, pEntry->New.pszCppMapping, pEntry->New.cbCpp);
3129 kOCSumFinalize(&pEntry->New.SumHead, &Ctx);
3130 kOCSumInfo(&pEntry->New.SumHead, 4, "cpp (file)");
3131}
3132
3133
3134/**
3135 * This consumes the preprocessor output and checksums it.
3136 *
3137 * @param pEntry The cache entry.
3138 * @param fdIn The preprocessor output pipe.
3139 * @param fdOut The compiler input pipe, -1 if no compiler.
3140 */
3141static void kOCEntryPreProcessConsumer(PKOCENTRY pEntry, int fdIn)
3142{
3143 KOCSUMCTX Ctx;
3144 KOCCPPRD CppRd;
3145
3146 kOCSumInitWithCtx(&pEntry->New.SumHead, &Ctx);
3147 kOCCppRdInit(&CppRd, pEntry->Old.cbCpp, pEntry->fOptimizeCpp,
3148 pEntry->pszMakeDepFilename ? &pEntry->DepState : NULL);
3149
3150 for (;;)
3151 {
3152 /*
3153 * Read data from the pipe.
3154 */
3155 const char *psz;
3156 long cbRead = kOCCppRdRead(&CppRd, fdIn, &psz);
3157 if (!cbRead)
3158 break;
3159
3160 /*
3161 * Process the data.
3162 */
3163 kOCSumUpdate(&pEntry->New.SumHead, &Ctx, psz, cbRead);
3164 if (pEntry->pszMakeDepFilename && !pEntry->fOptimizeCpp)
3165 kOCDepConsumer(&pEntry->DepState, psz, cbRead);
3166 }
3167
3168 close(fdIn);
3169 kOCCppRdGrabOutput(&CppRd, &pEntry->New.pszCppMapping, &pEntry->New.cbCpp);
3170 kOCCppRdDelete(&CppRd);
3171 kOCSumFinalize(&pEntry->New.SumHead, &Ctx);
3172 kOCSumInfo(&pEntry->New.SumHead, 4, "cpp (pipe)");
3173}
3174
3175
3176
3177
3178/**
3179 * Run the preprocessor and calculate the checksum of the output.
3180 *
3181 * @param pEntry The cache entry.
3182 * @param papszArgvPreComp The argument vector for executing preprocessor.
3183 * The cArgvPreComp'th argument must be NULL.
3184 * @param cArgvPreComp The number of arguments.
3185 */
3186static void kOCEntryPreProcess(PKOCENTRY pEntry, const char * const *papszArgvPreComp, unsigned cArgvPreComp)
3187{
3188 /*
3189 * If we're executing the preprocessor in piped mode, it's relatively simple.
3190 */
3191 if (pEntry->fPipedPreComp)
3192 kOCEntrySpawnProducer(pEntry, papszArgvPreComp, cArgvPreComp, "preprocess",
3193 kOCEntryPreProcessConsumer);
3194 else
3195 {
3196 /*
3197 * Rename the old preprocessed output to '-old' so the preprocessor won't
3198 * overwrite it when we execute it.
3199 */
3200 if ( pEntry->Old.pszCppName
3201 && DoesFileInDirExist(pEntry->Old.pszCppName, pEntry->pszDir))
3202 {
3203 size_t cch = strlen(pEntry->Old.pszCppName);
3204 char *psz = xmalloc(cch + sizeof("-old"));
3205 memcpy(psz, pEntry->Old.pszCppName, cch);
3206 memcpy(psz + cch, "-old", sizeof("-old"));
3207
3208 InfoMsg(3, "renaming '%s' to '%s' in '%s'\n", pEntry->Old.pszCppName, psz, pEntry->pszDir);
3209 UnlinkFileInDir(psz, pEntry->pszDir);
3210 if (RenameFileInDir(pEntry->Old.pszCppName, psz, pEntry->pszDir))
3211 FatalDie("failed to rename '%s' -> '%s' in '%s': %s\n",
3212 pEntry->Old.pszCppName, psz, pEntry->pszDir, strerror(errno));
3213 free(pEntry->Old.pszCppName);
3214 pEntry->Old.pszCppName = psz;
3215 }
3216
3217 /*
3218 * Preprocess it and calculate the checksum on the output.
3219 */
3220 InfoMsg(3, "precompiling -> '%s'...\n", pEntry->New.pszCppName);
3221 kOCEntrySpawn(pEntry, &pEntry->New.cMsCpp, papszArgvPreComp, cArgvPreComp, "preprocess", NULL);
3222 kOCEntryReadCppOutput(pEntry, &pEntry->New, 0 /* fatal */);
3223 kOCEntryCalcChecksum(pEntry);
3224 if (pEntry->pszMakeDepFilename)
3225 kOCDepConsumer(&pEntry->DepState, pEntry->New.pszCppMapping, pEntry->New.cbCpp);
3226 }
3227
3228 if (pEntry->pszMakeDepFilename)
3229 kOCDepWriteToFile(&pEntry->DepState, pEntry->pszMakeDepFilename, pEntry->New.pszObjName, pEntry->pszDir,
3230 pEntry->fMakeDepFixCase, pEntry->fMakeDepQuiet, pEntry->fMakeDepGenStubs);
3231}
3232
3233
3234/**
3235 * Worker function for kOCEntryTeeConsumer and kOCEntryCompileIt that
3236 * writes the preprocessor output to disk.
3237 *
3238 * @param pEntry The cache entry.
3239 * @param fFreeIt Whether we can free it after writing it or not.
3240 */
3241static void kOCEntryWriteCppOutput(PKOCENTRY pEntry, int fFreeIt)
3242{
3243 /*
3244 * Remove old files.
3245 */
3246 if (pEntry->Old.pszCppName)
3247 UnlinkFileInDir(pEntry->Old.pszCppName, pEntry->pszDir);
3248 if (pEntry->New.pszCppName)
3249 UnlinkFileInDir(pEntry->New.pszCppName, pEntry->pszDir);
3250
3251 /*
3252 * Write it to disk if we've got a file name.
3253 */
3254 if (pEntry->New.pszCppName)
3255 {
3256 long cbLeft;
3257 char *psz;
3258 int fd = OpenFileInDir(pEntry->New.pszCppName, pEntry->pszDir,
3259 O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0666);
3260 if (fd == -1)
3261 FatalDie("Failed to create '%s' in '%s': %s\n",
3262 pEntry->New.pszCppName, pEntry->pszDir, strerror(errno));
3263 psz = pEntry->New.pszCppMapping;
3264 cbLeft = (long)pEntry->New.cbCpp;
3265 while (cbLeft > 0)
3266 {
3267 long cbWritten = write(fd, psz, cbLeft);
3268 if (cbWritten < 0)
3269 {
3270 int iErr = errno;
3271 if (iErr == EINTR)
3272 continue;
3273 close(fd);
3274 UnlinkFileInDir(pEntry->New.pszCppName, pEntry->pszDir);
3275 FatalDie("error writing '%s' in '%s': %s\n",
3276 pEntry->New.pszCppName, pEntry->pszDir, strerror(iErr));
3277 }
3278
3279 psz += cbWritten;
3280 cbLeft -= cbWritten;
3281 }
3282 close(fd);
3283 }
3284
3285 /*
3286 * Free it.
3287 */
3288 if (fFreeIt)
3289 {
3290 free(pEntry->New.pszCppMapping);
3291 pEntry->New.pszCppMapping = NULL;
3292 }
3293}
3294
3295
3296/**
3297 * kOCEntrySpawnConsumer callback that passes the preprocessor output to the
3298 * compiler and writes it to the disk (latter only when necesary).
3299 *
3300 * @param pEntry The cache entry.
3301 * @param fdOut The pipe handle connected to the childs stdin.
3302 */
3303static void kOCEntryCompileProducer(PKOCENTRY pEntry, int fdOut)
3304{
3305 const char *psz = pEntry->New.pszCppMapping;
3306 long cbLeft = (long)pEntry->New.cbCpp;
3307 while (cbLeft > 0)
3308 {
3309 long cbWritten = write(fdOut, psz, cbLeft);
3310 if (cbWritten < 0)
3311 {
3312 if (errno == EINTR)
3313 continue;
3314#ifdef __WIN__ /* HACK */
3315 if ( errno == EINVAL
3316 && pEntry->pszNmPipeCompile
3317 && DisconnectNamedPipe((HANDLE)_get_osfhandle(fdOut))
3318 && ConnectNamedPipe((HANDLE)_get_osfhandle(fdOut), NULL))
3319 {
3320 psz = pEntry->New.pszCppMapping;
3321 cbLeft = (long)pEntry->New.cbCpp;
3322 }
3323 FatalDie("compile - write(%d,,%ld) failed: %s - _doserrno=%d\n", fdOut, cbLeft, strerror(errno), _doserrno);
3324#else
3325 FatalDie("compile - write(%d,,%ld) failed: %s\n", fdOut, cbLeft, strerror(errno));
3326#endif
3327 }
3328 psz += cbWritten;
3329 cbLeft -= cbWritten;
3330 }
3331 close(fdOut);
3332
3333 if (pEntry->fPipedPreComp)
3334 kOCEntryWriteCppOutput(pEntry, 1 /* free it */);
3335}
3336
3337
3338/**
3339 * Does the actual compiling.
3340 *
3341 * @param pEntry The cache entry.
3342 */
3343static void kOCEntryCompileIt(PKOCENTRY pEntry)
3344{
3345 /*
3346 * Delete the object files and free old cpp output that's no longer needed.
3347 */
3348 if (pEntry->Old.pszObjName)
3349 UnlinkFileInDir(pEntry->Old.pszObjName, pEntry->pszDir);
3350 UnlinkFileInDir(pEntry->New.pszObjName, pEntry->pszDir);
3351
3352 free(pEntry->Old.pszCppMapping);
3353 pEntry->Old.pszCppMapping = NULL;
3354 if (!pEntry->fPipedPreComp && !pEntry->fPipedCompile)
3355 {
3356 free(pEntry->New.pszCppMapping);
3357 pEntry->New.pszCppMapping = NULL;
3358 }
3359
3360 /*
3361 * Do the (re-)compile job.
3362 */
3363 if (pEntry->fPipedCompile)
3364 {
3365 if ( !pEntry->fPipedPreComp
3366 && !pEntry->New.pszCppMapping)
3367 kOCEntryReadCppOutput(pEntry, &pEntry->New, 0 /* fatal */);
3368 InfoMsg(3, "compiling -> '%s'...\n", pEntry->New.pszObjName);
3369 kOCEntrySpawnConsumer(pEntry, (const char * const *)pEntry->New.papszArgvCompile,
3370 pEntry->New.cArgvCompile, "compile", kOCEntryCompileProducer);
3371 }
3372 else
3373 {
3374 if (pEntry->fPipedPreComp)
3375 kOCEntryWriteCppOutput(pEntry, 1 /* free it */);
3376 InfoMsg(3, "compiling -> '%s'...\n", pEntry->New.pszObjName);
3377 kOCEntrySpawn(pEntry, &pEntry->New.cMsCompile, (const char * const *)pEntry->New.papszArgvCompile,
3378 pEntry->New.cArgvCompile, "compile", NULL);
3379 }
3380}
3381
3382
3383/**
3384 * kOCEntrySpawnTee callback that works sort of like 'tee'.
3385 *
3386 * It will calculate the preprocessed output checksum and
3387 * write it to disk while the compiler is busy compiling it.
3388 *
3389 * @param pEntry The cache entry.
3390 * @param fdIn The input handle (connected to the preprocessor).
3391 * @param fdOut The output handle (connected to the compiler).
3392 */
3393static void kOCEntryTeeConsumer(PKOCENTRY pEntry, int fdIn, int fdOut)
3394{
3395#ifdef __WIN__
3396 unsigned fConnectedToCompiler = fdOut == -1 || pEntry->pszNmPipeCompile == NULL;
3397#endif
3398 KOCSUMCTX Ctx;
3399 KOCCPPRD CppRd;
3400
3401 kOCSumInitWithCtx(&pEntry->New.SumHead, &Ctx);
3402 kOCCppRdInit(&CppRd, pEntry->Old.cbCpp, pEntry->fOptimizeCpp,
3403 pEntry->pszMakeDepFilename ? &pEntry->DepState : NULL);
3404 InfoMsg(3, "preprocessor|compile - starting passhtru...\n");
3405 for (;;)
3406 {
3407 /*
3408 * Read data from the pipe.
3409 */
3410 const char *psz;
3411 long cbRead = kOCCppRdRead(&CppRd, fdIn, &psz);
3412 if (!cbRead)
3413 break;
3414 InfoMsg(3, "preprocessor|compile - read %d\n", cbRead);
3415
3416 /*
3417 * Process the data.
3418 */
3419 kOCSumUpdate(&pEntry->New.SumHead, &Ctx, psz, cbRead);
3420 if (pEntry->pszMakeDepFilename && !pEntry->fOptimizeCpp)
3421 kOCDepConsumer(&pEntry->DepState, psz, cbRead);
3422
3423#ifdef __WIN__
3424 if ( !fConnectedToCompiler
3425 && !(fConnectedToCompiler = ConnectNamedPipe((HANDLE)_get_osfhandle(fdOut), NULL)))
3426 FatalDie("preprocess|compile - ConnectNamedPipe failed: %d\n", GetLastError());
3427#endif
3428 do
3429 {
3430 long cbWritten = write(fdOut, psz, cbRead);
3431 if (cbWritten < 0)
3432 {
3433 if (errno == EINTR)
3434 continue;
3435 FatalDie("preprocess|compile - write(%d,,%ld) failed: %s\n", fdOut, cbRead, strerror(errno));
3436 }
3437 psz += cbWritten;
3438 cbRead -= cbWritten;
3439 } while (cbRead > 0);
3440
3441 }
3442 InfoMsg(3, "preprocessor|compile - done passhtru\n");
3443
3444 close(fdIn);
3445 close(fdOut);
3446 kOCCppRdGrabOutput(&CppRd, &pEntry->New.pszCppMapping, &pEntry->New.cbCpp);
3447 kOCCppRdDelete(&CppRd);
3448 kOCSumFinalize(&pEntry->New.SumHead, &Ctx);
3449 kOCSumInfo(&pEntry->New.SumHead, 4, "cpp (tee)");
3450
3451 /*
3452 * Write the preprocessor output to disk and free the memory it
3453 * occupies while the compiler is busy compiling.
3454 */
3455 kOCEntryWriteCppOutput(pEntry, 1 /* free it */);
3456}
3457
3458
3459/**
3460 * Performs pre-compile and compile in one go (typical clean build scenario).
3461 *
3462 * @param pEntry The cache entry.
3463 * @param papszArgvPreComp The argument vector for executing preprocessor.
3464 * The cArgvPreComp'th argument must be NULL.
3465 * @param cArgvPreComp The number of arguments.
3466 */
3467static void kOCEntryPreProcessAndCompile(PKOCENTRY pEntry, const char * const *papszArgvPreComp, unsigned cArgvPreComp)
3468{
3469 if ( pEntry->fPipedCompile
3470 && pEntry->fPipedPreComp)
3471 {
3472 /*
3473 * Clean up old stuff first.
3474 */
3475 if (pEntry->Old.pszObjName)
3476 UnlinkFileInDir(pEntry->Old.pszObjName, pEntry->pszDir);
3477 if (pEntry->New.pszObjName)
3478 UnlinkFileInDir(pEntry->New.pszObjName, pEntry->pszDir);
3479 if (pEntry->Old.pszCppName)
3480 UnlinkFileInDir(pEntry->Old.pszCppName, pEntry->pszDir);
3481 if (pEntry->New.pszCppName)
3482 UnlinkFileInDir(pEntry->New.pszCppName, pEntry->pszDir);
3483
3484 /*
3485 * Do the actual compile and write the preprocessor output to disk.
3486 */
3487 kOCEntrySpawnTee(pEntry, papszArgvPreComp, cArgvPreComp,
3488 (const char * const *)pEntry->New.papszArgvCompile, pEntry->New.cArgvCompile,
3489 "preprocess|compile", kOCEntryTeeConsumer);
3490 if (pEntry->pszMakeDepFilename)
3491 kOCDepWriteToFile(&pEntry->DepState, pEntry->pszMakeDepFilename, pEntry->New.pszObjName, pEntry->pszDir,
3492 pEntry->fMakeDepFixCase, pEntry->fMakeDepQuiet, pEntry->fMakeDepGenStubs);
3493 }
3494 else
3495 {
3496 kOCEntryPreProcess(pEntry, papszArgvPreComp, cArgvPreComp);
3497 kOCEntryCompileIt(pEntry);
3498 }
3499}
3500
3501
3502/**
3503 * Check whether the string is a '#line' statement.
3504 *
3505 * @returns 1 if it is, 0 if it isn't.
3506 * @param psz The line to examin.
3507 * @parma piLine Where to store the line number.
3508 * @parma ppszFile Where to store the start of the filename.
3509 */
3510static int kOCEntryIsLineStatement(const char *psz, unsigned *piLine, const char **ppszFile)
3511{
3512 unsigned iLine;
3513
3514 /* Expect a hash. */
3515 if (*psz++ != '#')
3516 return 0;
3517
3518 /* Skip blanks between '#' and the line / number */
3519 while (*psz == ' ' || *psz == '\t')
3520 psz++;
3521
3522 /* Skip the 'line' if present. */
3523 if (!strncmp(psz, "line", sizeof("line") - 1))
3524 psz += sizeof("line");
3525
3526 /* Expect a line number now. */
3527 if ((unsigned char)(*psz - '0') > 9)
3528 return 0;
3529 iLine = 0;
3530 do
3531 {
3532 iLine *= 10;
3533 iLine += (*psz - '0');
3534 psz++;
3535 }
3536 while ((unsigned char)(*psz - '0') <= 9);
3537
3538 /* Expect one or more space now. */
3539 if (*psz != ' ' && *psz != '\t')
3540 return 0;
3541 do psz++;
3542 while (*psz == ' ' || *psz == '\t');
3543
3544 /* that's good enough. */
3545 *piLine = iLine;
3546 *ppszFile = psz;
3547 return 1;
3548}
3549
3550
3551/**
3552 * Scan backwards for the previous #line statement.
3553 *
3554 * @returns The filename in the previous statement.
3555 * @param pszStart Where to start.
3556 * @param pszStop Where to stop. Less than pszStart.
3557 * @param piLine The line number count to adjust.
3558 */
3559static const char *kOCEntryFindFileStatement(const char *pszStart, const char *pszStop, unsigned *piLine)
3560{
3561 unsigned iLine = *piLine;
3562 assert(pszStart >= pszStop);
3563 while (pszStart >= pszStop)
3564 {
3565 if (*pszStart == '\n')
3566 iLine++;
3567 else if (*pszStart == '#')
3568 {
3569 unsigned iLineTmp;
3570 const char *pszFile;
3571 const char *psz = pszStart - 1;
3572 while (psz >= pszStop && (*psz == ' ' || *psz =='\t'))
3573 psz--;
3574 if ( (psz < pszStop || *psz == '\n')
3575 && kOCEntryIsLineStatement(pszStart, &iLineTmp, &pszFile))
3576 {
3577 *piLine = iLine + iLineTmp - 1;
3578 return pszFile;
3579 }
3580 }
3581 pszStart--;
3582 }
3583 return NULL;
3584}
3585
3586
3587/**
3588 * Worker for kOCEntryCompareOldAndNewOutput() that compares the
3589 * preprocessed output using a fast but not very good method.
3590 *
3591 * @returns 1 if matching, 0 if not matching.
3592 * @param pEntry The entry containing the names of the files to compare.
3593 * The entry is not updated in any way.
3594 */
3595static int kOCEntryCompareFast(PCKOCENTRY pEntry)
3596{
3597 const char * psz1 = pEntry->New.pszCppMapping;
3598 const char * const pszEnd1 = psz1 + pEntry->New.cbCpp;
3599 const char * psz2 = pEntry->Old.pszCppMapping;
3600 const char * const pszEnd2 = psz2 + pEntry->Old.cbCpp;
3601
3602 assert(*pszEnd1 == '\0');
3603 assert(*pszEnd2 == '\0');
3604
3605 /*
3606 * Iterate block by block and backtrack when we find a difference.
3607 */
3608 for (;;)
3609 {
3610 size_t cch = pszEnd1 - psz1;
3611 if (cch > (size_t)(pszEnd2 - psz2))
3612 cch = pszEnd2 - psz2;
3613 if (cch > 4096)
3614 cch = 4096;
3615 if ( cch
3616 && !memcmp(psz1, psz2, cch))
3617 {
3618 /* no differences */
3619 psz1 += cch;
3620 psz2 += cch;
3621 }
3622 else
3623 {
3624 /*
3625 * Pinpoint the difference exactly and the try find the start
3626 * of that line. Then skip forward until we find something to
3627 * work on that isn't spaces, #line statements or closing curly
3628 * braces.
3629 *
3630 * The closing curly braces are ignored because they are frequently
3631 * found at the end of header files (__END_DECLS) and the worst
3632 * thing that may happen if it isn't one of these braces we're
3633 * ignoring is that the final line in a function block is a little
3634 * bit off in the debug info.
3635 *
3636 * Since we might be skipping a few new empty headers, it is
3637 * possible that we will omit this header from the dependencies
3638 * when using VCC. This might not be a problem, since it seems
3639 * we'll have to use the preprocessor output to generate the deps
3640 * anyway.
3641 */
3642 const char *psz;
3643 const char *pszMismatch1;
3644 const char *pszFile1 = NULL;
3645 unsigned iLine1 = 0;
3646 unsigned cCurlyBraces1 = 0;
3647 const char *pszMismatch2;
3648 const char *pszFile2 = NULL;
3649 unsigned iLine2 = 0;
3650 unsigned cCurlyBraces2 = 0;
3651
3652 /* locate the difference. */
3653 while (cch >= 512 && !memcmp(psz1, psz2, 512))
3654 psz1 += 512, psz2 += 512, cch -= 512;
3655 while (cch >= 64 && !memcmp(psz1, psz2, 64))
3656 psz1 += 64, psz2 += 64, cch -= 64;
3657 while (*psz1 == *psz2 && cch > 0)
3658 psz1++, psz2++, cch--;
3659
3660 /* locate the start of that line. */
3661 psz = psz1;
3662 while ( psz > pEntry->New.pszCppMapping
3663 && psz[-1] != '\n')
3664 psz--;
3665 psz2 -= (psz1 - psz);
3666 pszMismatch2 = psz2;
3667 pszMismatch1 = psz1 = psz;
3668
3669 /* Parse the 1st file line by line. */
3670 while (psz1 < pszEnd1)
3671 {
3672 if (*psz1 == '\n')
3673 {
3674 psz1++;
3675 iLine1++;
3676 }
3677 else
3678 {
3679 psz = psz1;
3680 while (isspace(*psz) && *psz != '\n')
3681 psz++;
3682 if (*psz == '\n')
3683 {
3684 psz1 = psz + 1;
3685 iLine1++;
3686 }
3687 else if (*psz == '#' && kOCEntryIsLineStatement(psz, &iLine1, &pszFile1))
3688 {
3689 psz1 = memchr(psz, '\n', pszEnd1 - psz);
3690 if (!psz1++)
3691 psz1 = pszEnd1;
3692 }
3693 else if (*psz == '}')
3694 {
3695 do psz++;
3696 while (isspace(*psz) && *psz != '\n');
3697 if (*psz == '\n')
3698 iLine1++;
3699 else if (psz != pszEnd1)
3700 break;
3701 cCurlyBraces1++;
3702 psz1 = psz;
3703 }
3704 else if (psz == pszEnd1)
3705 psz1 = psz;
3706 else /* found something that can be compared. */
3707 break;
3708 }
3709 }
3710
3711 /* Ditto for the 2nd file. */
3712 while (psz2 < pszEnd2)
3713 {
3714 if (*psz2 == '\n')
3715 {
3716 psz2++;
3717 iLine2++;
3718 }
3719 else
3720 {
3721 psz = psz2;
3722 while (isspace(*psz) && *psz != '\n')
3723 psz++;
3724 if (*psz == '\n')
3725 {
3726 psz2 = psz + 1;
3727 iLine2++;
3728 }
3729 else if (*psz == '#' && kOCEntryIsLineStatement(psz, &iLine2, &pszFile2))
3730 {
3731 psz2 = memchr(psz, '\n', pszEnd2 - psz);
3732 if (!psz2++)
3733 psz2 = pszEnd2;
3734 }
3735 else if (*psz == '}')
3736 {
3737 do psz++;
3738 while (isspace(*psz) && *psz != '\n');
3739 if (*psz == '\n')
3740 iLine2++;
3741 else if (psz != pszEnd2)
3742 break;
3743 cCurlyBraces2++;
3744 psz2 = psz;
3745 }
3746 else if (psz == pszEnd2)
3747 psz2 = psz;
3748 else /* found something that can be compared. */
3749 break;
3750 }
3751 }
3752
3753 /* Match the number of ignored closing curly braces. */
3754 if (cCurlyBraces1 != cCurlyBraces2)
3755 return 0;
3756
3757 /* Reaching the end of any of them means the return statement can decide. */
3758 if ( psz1 == pszEnd1
3759 || psz2 == pszEnd2)
3760 break;
3761
3762 /* Match the current line. */
3763 psz = memchr(psz1, '\n', pszEnd1 - psz1);
3764 if (!psz++)
3765 psz = pszEnd1;
3766 cch = psz - psz1;
3767 if (psz2 + cch > pszEnd2)
3768 break;
3769 if (memcmp(psz1, psz2, cch))
3770 break;
3771
3772 /* Check that we're at the same location now. */
3773 if (!pszFile1)
3774 pszFile1 = kOCEntryFindFileStatement(pszMismatch1, pEntry->New.pszCppMapping, &iLine1);
3775 if (!pszFile2)
3776 pszFile2 = kOCEntryFindFileStatement(pszMismatch2, pEntry->Old.pszCppMapping, &iLine2);
3777 if (pszFile1 && pszFile2)
3778 {
3779 if (iLine1 != iLine2)
3780 break;
3781 while (*pszFile1 == *pszFile2 && *pszFile1 != '\n' && *pszFile1)
3782 pszFile1++, pszFile2++;
3783 if (*pszFile1 != *pszFile2)
3784 break;
3785 }
3786 else if (pszFile1 || pszFile2)
3787 {
3788 assert(0); /* this shouldn't happen. */
3789 break;
3790 }
3791
3792 /* Advance. We might now have a misaligned buffer, but that's memcmps problem... */
3793 psz1 += cch;
3794 psz2 += cch;
3795 }
3796 }
3797
3798 return psz1 == pszEnd1
3799 && psz2 == pszEnd2;
3800}
3801
3802
3803/**
3804 * Worker for kOCEntryCompileIfNeeded that compares the
3805 * preprocessed output.
3806 *
3807 * @returns 1 if matching, 0 if not matching.
3808 * @param pEntry The entry containing the names of the files to compare.
3809 * This will load the old cpp output (changing pszOldCppName and Old.cbCpp).
3810 */
3811static int kOCEntryCompareOldAndNewOutput(PKOCENTRY pEntry)
3812{
3813 /*
3814 * I may implement a more sophisticated alternative method later... maybe.
3815 */
3816 if (kOCEntryReadCppOutput(pEntry, &pEntry->Old, 1 /* nonfatal */) == -1)
3817 return 0;
3818 /*if ()
3819 return kOCEntryCompareBest(pEntry);*/
3820 return kOCEntryCompareFast(pEntry);
3821}
3822
3823
3824/**
3825 * Check if re-compilation is required.
3826 * This sets the fNeedCompile flag.
3827 *
3828 * @param pEntry The cache entry.
3829 */
3830static void kOCEntryCalcRecompile(PKOCENTRY pEntry)
3831{
3832 if (pEntry->fNeedCompiling)
3833 return;
3834
3835 /*
3836 * Check if the preprocessor output differ in any significant way?
3837 */
3838 if (!kOCSumHasEqualInChain(&pEntry->Old.SumHead, &pEntry->New.SumHead))
3839 {
3840 if (pEntry->fOptimizeCpp & 2)
3841 {
3842 InfoMsg(2, "no checksum match - no need to compare output, -O2.\n");
3843 pEntry->fNeedCompiling = 1;
3844 }
3845 else
3846 {
3847 InfoMsg(2, "no checksum match - comparing output\n");
3848 if (!kOCEntryCompareOldAndNewOutput(pEntry))
3849 pEntry->fNeedCompiling = 1;
3850 else
3851 kOCSumAddChain(&pEntry->New.SumHead, &pEntry->Old.SumHead);
3852 }
3853 }
3854}
3855
3856
3857/**
3858 * Does this cache entry need compiling or what?
3859 *
3860 * @returns 1 if it does, 0 if it doesn't.
3861 * @param pEntry The cache entry in question.
3862 */
3863static int kOCEntryNeedsCompiling(PCKOCENTRY pEntry)
3864{
3865 return pEntry->fNeedCompiling;
3866}
3867
3868
3869/**
3870 * Tries to hardlink a file.
3871 *
3872 * @returns 1 if it succeeded, 0 if it didn't.
3873 * @param pszLink The name of the hardlink.
3874 * @param pszLinkTo The file to hardlinkg @a pszDst to.
3875 */
3876static int kOCEntryTryHardlink(const char *pszLink, const char *pszLinkTo)
3877{
3878#ifdef __WIN__
3879 typedef BOOL (WINAPI *PFNCREATEHARDLINKA)(LPCSTR, LPCSTR, LPSECURITY_ATTRIBUTES);
3880 static PFNCREATEHARDLINKA s_pfnCreateHardLinkA = NULL;
3881 static int s_fTried = FALSE;
3882
3883 /* The API was introduced in Windows 2000, so resolve it dynamically. */
3884 if (!s_pfnCreateHardLinkA)
3885 {
3886 if (!s_fTried)
3887 {
3888 HMODULE hmod = LoadLibrary("KERNEL32.DLL");
3889 if (hmod)
3890 *(FARPROC *)&s_pfnCreateHardLinkA = GetProcAddress(hmod, "CreateHardLinkA");
3891 s_fTried = TRUE;
3892 }
3893 if (!s_pfnCreateHardLinkA)
3894 return 0;
3895 }
3896
3897 if (!s_pfnCreateHardLinkA(pszLink, pszLinkTo, NULL))
3898 return 0;
3899#else
3900 if (link(pszLinkTo, pszLink) != 0)
3901 return 0;
3902#endif
3903 return 1;
3904}
3905
3906
3907
3908/**
3909 * Worker function for kOCEntryCopy.
3910 *
3911 * @param pEntry The entry we're coping to, which pszTo is relative to.
3912 * @param pszTo The destination.
3913 * @param pszFrom The source. This path will be freed.
3914 */
3915static void kOCEntryCopyFile(PCKOCENTRY pEntry, const char *pszTo, char *pszSrc)
3916{
3917 char *pszDst = MakePathFromDirAndFile(pszTo, pEntry->pszDir);
3918 unlink(pszDst);
3919 if (!kOCEntryTryHardlink(pszDst, pszSrc))
3920 {
3921 char *pszBuf = xmalloc(256 * 1024);
3922 char *psz;
3923 int fdSrc;
3924 int fdDst;
3925
3926 /*
3927 * Open the files.
3928 */
3929 fdSrc = open(pszSrc, O_RDONLY | O_BINARY);
3930 if (fdSrc == -1)
3931 FatalDie("failed to open '%s': %s\n", pszSrc, strerror(errno));
3932
3933 fdDst = open(pszDst, O_WRONLY | O_CREAT | O_TRUNC | O_BINARY, 0666);
3934 if (fdDst == -1)
3935 FatalDie("failed to create '%s': %s\n", pszDst, strerror(errno));
3936
3937 /*
3938 * Copy them.
3939 */
3940 for (;;)
3941 {
3942 /* read a chunk. */
3943 long cbRead = read(fdSrc, pszBuf, 256*1024);
3944 if (cbRead < 0)
3945 {
3946 if (errno == EINTR)
3947 continue;
3948 FatalDie("read '%s' failed: %s\n", pszSrc, strerror(errno));
3949 }
3950 if (!cbRead)
3951 break; /* eof */
3952
3953 /* write the chunk. */
3954 psz = pszBuf;
3955 do
3956 {
3957 long cbWritten = write(fdDst, psz, cbRead);
3958 if (cbWritten < 0)
3959 {
3960 if (errno == EINTR)
3961 continue;
3962 FatalDie("write '%s' failed: %s\n", pszSrc, strerror(errno));
3963 }
3964 psz += cbWritten;
3965 cbRead -= cbWritten;
3966 } while (cbRead > 0);
3967 }
3968
3969 /* cleanup */
3970 if (close(fdDst) != 0)
3971 FatalDie("closing '%s' failed: %s\n", pszDst, strerror(errno));
3972 close(fdSrc);
3973 free(pszBuf);
3974 }
3975 free(pszDst);
3976 free(pszSrc);
3977}
3978
3979
3980/**
3981 * Copies the object (and whatever else) from one cache entry to another.
3982 *
3983 * This is called when a matching cache entry has been found and we don't
3984 * need to recompile anything.
3985 *
3986 * @param pEntry The entry to copy to.
3987 * @param pFrom The entry to copy from.
3988 */
3989static void kOCEntryCopy(PKOCENTRY pEntry, PCKOCENTRY pFrom)
3990{
3991 kOCEntryCopyFile(pEntry, pEntry->New.pszObjName,
3992 MakePathFromDirAndFile(pFrom->New.pszObjName
3993 ? pFrom->New.pszObjName : pFrom->Old.pszObjName,
3994 pFrom->pszDir));
3995}
3996
3997
3998/**
3999 * Gets the absolute path to the cache entry.
4000 *
4001 * @returns absolute path to the cache entry.
4002 * @param pEntry The cache entry in question.
4003 */
4004static const char *kOCEntryAbsPath(PCKOCENTRY pEntry)
4005{
4006 return pEntry->pszAbsPath;
4007}
4008
4009
4010
4011
4012
4013
4014/**
4015 * Digest of one cache entry.
4016 *
4017 * This contains all the information required to find a matching
4018 * cache entry without having to open each of the files.
4019 */
4020typedef struct KOCDIGEST
4021{
4022 /** The relative path to the entry. Optional if pszAbsPath is set. */
4023 char *pszRelPath;
4024 /** The absolute path to the entry. Optional if pszRelPath is set. */
4025 char *pszAbsPath;
4026 /** The target os/arch identifier. */
4027 char *pszTarget;
4028 /** A unique number assigned to the entry when it's (re)-inserted
4029 * into the cache. This is used for simple consitency checking. */
4030 uint32_t uKey;
4031 /** The checksum of the compile argument vector. */
4032 KOCSUM SumCompArgv;
4033 /** The list of preprocessor output checksums that's . */
4034 KOCSUM SumHead;
4035} KOCDIGEST;
4036/** Pointer to a file digest. */
4037typedef KOCDIGEST *PKOCDIGEST;
4038/** Pointer to a const file digest. */
4039typedef KOCDIGEST *PCKOCDIGEST;
4040
4041
4042/**
4043 * Initializes the specified digest.
4044 *
4045 * @param pDigest The digest.
4046 */
4047static void kOCDigestInit(PKOCDIGEST pDigest)
4048{
4049 memset(pDigest, 0, sizeof(*pDigest));
4050 kOCSumInit(&pDigest->SumHead);
4051}
4052
4053
4054/**
4055 * Initializes the digest for the specified entry.
4056 *
4057 * @param pDigest The (uninitialized) digest.
4058 * @param pEntry The entry.
4059 */
4060static void kOCDigestInitFromEntry(PKOCDIGEST pDigest, PCKOCENTRY pEntry)
4061{
4062 kOCDigestInit(pDigest);
4063
4064 pDigest->uKey = pEntry->uKey;
4065 pDigest->pszTarget = xstrdup(pEntry->New.pszTarget ? pEntry->New.pszTarget : pEntry->Old.pszTarget);
4066
4067 kOCSumInit(&pDigest->SumCompArgv);
4068 if (!kOCSumIsEmpty(&pEntry->New.SumCompArgv))
4069 kOCSumAdd(&pDigest->SumCompArgv, &pEntry->New.SumCompArgv);
4070 else
4071 kOCSumAdd(&pDigest->SumCompArgv, &pEntry->Old.SumCompArgv);
4072
4073 kOCSumInit(&pDigest->SumHead);
4074 if (!kOCSumIsEmpty(&pEntry->New.SumHead))
4075 kOCSumAddChain(&pDigest->SumHead, &pEntry->New.SumHead);
4076 else
4077 kOCSumAddChain(&pDigest->SumHead, &pEntry->Old.SumHead);
4078
4079 /** @todo implement selective relative path support. */
4080 pDigest->pszRelPath = NULL;
4081 pDigest->pszAbsPath = xstrdup(kOCEntryAbsPath(pEntry));
4082}
4083
4084
4085/**
4086 * Purges a digest, freeing all resources and returning
4087 * it to the initial state.
4088 *
4089 * @param pDigest The digest.
4090 */
4091static void kOCDigestPurge(PKOCDIGEST pDigest)
4092{
4093 free(pDigest->pszRelPath);
4094 free(pDigest->pszAbsPath);
4095 free(pDigest->pszTarget);
4096 pDigest->pszTarget = pDigest->pszAbsPath = pDigest->pszRelPath = NULL;
4097 pDigest->uKey = 0;
4098 kOCSumDeleteChain(&pDigest->SumCompArgv);
4099 kOCSumDeleteChain(&pDigest->SumHead);
4100}
4101
4102
4103/**
4104 * Returns the absolute path to the entry, calculating
4105 * the path if necessary.
4106 *
4107 * @returns absolute path.
4108 * @param pDigest The digest.
4109 * @param pszDir The cache directory that it might be relative to.
4110 */
4111static const char *kOCDigestAbsPath(PCKOCDIGEST pDigest, const char *pszDir)
4112{
4113 if (!pDigest->pszAbsPath)
4114 {
4115 char *pszPath = MakePathFromDirAndFile(pDigest->pszRelPath, pszDir);
4116 ((PKOCDIGEST)pDigest)->pszAbsPath = AbsPath(pszPath);
4117 free(pszPath);
4118 }
4119 return pDigest->pszAbsPath;
4120}
4121
4122
4123/**
4124 * Checks that the digest matches the
4125 *
4126 * @returns 1 if valid, 0 if invalid in some way.
4127 *
4128 * @param pDigest The digest to validate.
4129 * @param pEntry What to validate it against.
4130 */
4131static int kOCDigestIsValid(PCKOCDIGEST pDigest, PCKOCENTRY pEntry)
4132{
4133 PCKOCSUM pSum;
4134 PCKOCSUM pSumEntry;
4135
4136 if (pDigest->uKey != pEntry->uKey)
4137 return 0;
4138
4139 if (!kOCSumIsEqual(&pDigest->SumCompArgv,
4140 kOCSumIsEmpty(&pEntry->New.SumCompArgv)
4141 ? &pEntry->Old.SumCompArgv : &pEntry->New.SumCompArgv))
4142 return 0;
4143
4144 if (strcmp(pDigest->pszTarget, pEntry->New.pszTarget ? pEntry->New.pszTarget : pEntry->Old.pszTarget))
4145 return 0;
4146
4147 /* match the checksums */
4148 pSumEntry = kOCSumIsEmpty(&pEntry->New.SumHead)
4149 ? &pEntry->Old.SumHead : &pEntry->New.SumHead;
4150 for (pSum = &pDigest->SumHead; pSum; pSum = pSum->pNext)
4151 if (!kOCSumHasEqualInChain(pSumEntry, pSum))
4152 return 0;
4153
4154 return 1;
4155}
4156
4157
4158
4159
4160
4161/**
4162 * The structure for the central cache entry.
4163 */
4164typedef struct KOBJCACHE
4165{
4166 /** The entry name. */
4167 const char *pszName;
4168 /** The dir that relative names in the digest are relative to. */
4169 char *pszDir;
4170 /** The absolute path. */
4171 char *pszAbsPath;
4172
4173 /** The cache file descriptor. */
4174 int fd;
4175 /** The stream associated with fd. */
4176 FILE *pFile;
4177 /** Whether it's currently locked or not. */
4178 unsigned fLocked;
4179 /** Whether the cache file is dirty and needs writing back. */
4180 unsigned fDirty;
4181 /** Whether this is a new cache or not. */
4182 unsigned fNewCache;
4183
4184 /** The cache file generation. */
4185 uint32_t uGeneration;
4186 /** The next valid key. (Determin at load time.) */
4187 uint32_t uNextKey;
4188
4189 /** Number of digests in paDigests. */
4190 unsigned cDigests;
4191 /** Array of digests for the KOCENTRY objects in the cache. */
4192 PKOCDIGEST paDigests;
4193
4194} KOBJCACHE;
4195/** Pointer to a cache. */
4196typedef KOBJCACHE *PKOBJCACHE;
4197/** Pointer to a const cache. */
4198typedef KOBJCACHE const *PCKOBJCACHE;
4199
4200
4201/**
4202 * Creates an empty cache.
4203 *
4204 * This doesn't touch the file system, it just create the data structure.
4205 *
4206 * @returns Pointer to a cache.
4207 * @param pszCacheFile The cache file.
4208 */
4209static PKOBJCACHE kObjCacheCreate(const char *pszCacheFile)
4210{
4211 PKOBJCACHE pCache;
4212 size_t off;
4213
4214 /*
4215 * Allocate an empty entry.
4216 */
4217 pCache = xmallocz(sizeof(*pCache));
4218 pCache->fd = -1;
4219
4220 /*
4221 * Setup the directory and cache file name.
4222 */
4223 pCache->pszAbsPath = AbsPath(pszCacheFile);
4224 pCache->pszName = FindFilenameInPath(pCache->pszAbsPath);
4225 off = pCache->pszName - pCache->pszAbsPath;
4226 if (!off)
4227 FatalDie("Failed to find abs path for '%s'!\n", pszCacheFile);
4228 pCache->pszDir = xmalloc(off);
4229 memcpy(pCache->pszDir, pCache->pszAbsPath, off - 1);
4230 pCache->pszDir[off - 1] = '\0';
4231
4232 return pCache;
4233}
4234
4235
4236/**
4237 * Destroys the cache - closing any open files, freeing up heap memory and such.
4238 *
4239 * @param pCache The cache.
4240 */
4241static void kObjCacheDestroy(PKOBJCACHE pCache)
4242{
4243 if (pCache->pFile)
4244 {
4245 errno = 0;
4246 if (fclose(pCache->pFile) != 0)
4247 FatalMsg("fclose failed: %s\n", strerror(errno));
4248 pCache->pFile = NULL;
4249 pCache->fd = -1;
4250 }
4251 free(pCache->paDigests);
4252 free(pCache->pszAbsPath);
4253 free(pCache->pszDir);
4254 free(pCache);
4255}
4256
4257
4258/**
4259 * Purges the data in the cache object.
4260 *
4261 * @param pCache The cache object.
4262 */
4263static void kObjCachePurge(PKOBJCACHE pCache)
4264{
4265 while (pCache->cDigests > 0)
4266 kOCDigestPurge(&pCache->paDigests[--pCache->cDigests]);
4267 free(pCache->paDigests);
4268 pCache->paDigests = NULL;
4269 pCache->uGeneration = 0;
4270 pCache->uNextKey = 0;
4271}
4272
4273
4274/**
4275 * (Re-)reads the file.
4276 *
4277 * @param pCache The cache to (re)-read.
4278 */
4279static void kObjCacheRead(PKOBJCACHE pCache)
4280{
4281 unsigned i;
4282 char szBuf[8192];
4283 int fBad = 0;
4284
4285 InfoMsg(4, "reading cache file...\n");
4286
4287 /*
4288 * Rewind the file & stream, and associate a temporary buffer
4289 * with the stream to speed up reading.
4290 */
4291 if (lseek(pCache->fd, 0, SEEK_SET) == -1)
4292 FatalDie("lseek(cache-fd) failed: %s\n", strerror(errno));
4293 rewind(pCache->pFile);
4294 if (setvbuf(pCache->pFile, szBuf, _IOFBF, sizeof(szBuf)) != 0)
4295 FatalDie("fdopen(cache-fd,rb) failed: %s\n", strerror(errno));
4296
4297 /*
4298 * Read magic and generation.
4299 */
4300 if ( !fgets(g_szLine, sizeof(g_szLine), pCache->pFile)
4301 || strcmp(g_szLine, "magic=kObjCache-v0.1.0\n"))
4302 {
4303 InfoMsg(2, "bad cache file (magic)\n");
4304 fBad = 1;
4305 }
4306 else if ( !fgets(g_szLine, sizeof(g_szLine), pCache->pFile)
4307 || strncmp(g_szLine, "generation=", sizeof("generation=") - 1))
4308 {
4309 InfoMsg(2, "bad cache file (generation)\n");
4310 fBad = 1;
4311 }
4312 else if ( pCache->uGeneration
4313 && (long)pCache->uGeneration == atol(&g_szLine[sizeof("generation=") - 1]))
4314 {
4315 InfoMsg(3, "drop re-read unmodified cache file\n");
4316 fBad = 0;
4317 }
4318 else
4319 {
4320 int fBadBeforeMissing;
4321
4322 /*
4323 * Read everything (anew).
4324 */
4325 kObjCachePurge(pCache);
4326 do
4327 {
4328 PKOCDIGEST pDigest;
4329 char *pszNl;
4330 char *pszVal;
4331 char *psz;
4332
4333 /* Split the line and drop the trailing newline. */
4334 pszVal = strchr(g_szLine, '=');
4335 if ((fBad = pszVal == NULL))
4336 break;
4337 *pszVal++ = '\0';
4338
4339 pszNl = strchr(pszVal, '\n');
4340 if (pszNl)
4341 *pszNl = '\0';
4342
4343 /* digest '#'? */
4344 psz = strchr(g_szLine, '#');
4345 if (psz)
4346 {
4347 char *pszNext;
4348 i = strtoul(++psz, &pszNext, 0);
4349 if ((fBad = pszNext && *pszNext))
4350 break;
4351 if ((fBad = i >= pCache->cDigests))
4352 break;
4353 pDigest = &pCache->paDigests[i];
4354 *psz = '\0';
4355 }
4356 else
4357 pDigest = NULL;
4358
4359
4360 /* string case on value name. */
4361 if (!strcmp(g_szLine, "sum-#"))
4362 {
4363 KOCSUM Sum;
4364 if ((fBad = kOCSumInitFromString(&Sum, pszVal) != 0))
4365 break;
4366 kOCSumAdd(&pDigest->SumHead, &Sum);
4367 }
4368 else if (!strcmp(g_szLine, "digest-abs-#"))
4369 {
4370 if ((fBad = pDigest->pszAbsPath != NULL))
4371 break;
4372 pDigest->pszAbsPath = xstrdup(pszVal);
4373 }
4374 else if (!strcmp(g_szLine, "digest-rel-#"))
4375 {
4376 if ((fBad = pDigest->pszRelPath != NULL))
4377 break;
4378 pDigest->pszRelPath = xstrdup(pszVal);
4379 }
4380 else if (!strcmp(g_szLine, "key-#"))
4381 {
4382 if ((fBad = pDigest->uKey != 0))
4383 break;
4384 pDigest->uKey = strtoul(pszVal, &psz, 0);
4385 if ((fBad = psz && *psz))
4386 break;
4387 if (pDigest->uKey >= pCache->uNextKey)
4388 pCache->uNextKey = pDigest->uKey + 1;
4389 }
4390 else if (!strcmp(g_szLine, "comp-argv-sum-#"))
4391 {
4392 if ((fBad = !kOCSumIsEmpty(&pDigest->SumCompArgv)))
4393 break;
4394 if ((fBad = kOCSumInitFromString(&pDigest->SumCompArgv, pszVal) != 0))
4395 break;
4396 }
4397 else if (!strcmp(g_szLine, "target-#"))
4398 {
4399 if ((fBad = pDigest->pszTarget != NULL))
4400 break;
4401 pDigest->pszTarget = xstrdup(pszVal);
4402 }
4403 else if (!strcmp(g_szLine, "digests"))
4404 {
4405 if ((fBad = pCache->paDigests != NULL))
4406 break;
4407 pCache->cDigests = strtoul(pszVal, &psz, 0);
4408 if ((fBad = psz && *psz))
4409 break;
4410 i = (pCache->cDigests + 4) & ~3;
4411 pCache->paDigests = xmalloc(i * sizeof(pCache->paDigests[0]));
4412 for (i = 0; i < pCache->cDigests; i++)
4413 kOCDigestInit(&pCache->paDigests[i]);
4414 }
4415 else if (!strcmp(g_szLine, "generation"))
4416 {
4417 if ((fBad = pCache->uGeneration != 0))
4418 break;
4419 pCache->uGeneration = strtoul(pszVal, &psz, 0);
4420 if ((fBad = psz && *psz))
4421 break;
4422 }
4423 else if (!strcmp(g_szLine, "the-end"))
4424 {
4425 fBad = strcmp(pszVal, "fine");
4426 break;
4427 }
4428 else
4429 {
4430 fBad = 1;
4431 break;
4432 }
4433 } while (fgets(g_szLine, sizeof(g_szLine), pCache->pFile));
4434
4435 /*
4436 * Did we find everything?
4437 */
4438 fBadBeforeMissing = fBad;
4439 if ( !fBad
4440 && !pCache->uGeneration)
4441 fBad = 1;
4442 if (!fBad)
4443 for (i = 0; i < pCache->cDigests; i++)
4444 {
4445 if ((fBad = kOCSumIsEmpty(&pCache->paDigests[i].SumCompArgv)))
4446 break;
4447 if ((fBad = kOCSumIsEmpty(&pCache->paDigests[i].SumHead)))
4448 break;
4449 if ((fBad = pCache->paDigests[i].uKey == 0))
4450 break;
4451 if ((fBad = pCache->paDigests[i].pszAbsPath == NULL
4452 && pCache->paDigests[i].pszRelPath == NULL))
4453 break;
4454 if ((fBad = pCache->paDigests[i].pszTarget == NULL))
4455 break;
4456 InfoMsg(4, "digest-%u: %s\n", i, pCache->paDigests[i].pszAbsPath
4457 ? pCache->paDigests[i].pszAbsPath : pCache->paDigests[i].pszRelPath);
4458 }
4459 if (fBad)
4460 InfoMsg(2, "bad cache file (%s)\n", fBadBeforeMissing ? g_szLine : "missing stuff");
4461 else if (ferror(pCache->pFile))
4462 {
4463 InfoMsg(2, "cache file read error\n");
4464 fBad = 1;
4465 }
4466 }
4467 if (fBad)
4468 {
4469 kObjCachePurge(pCache);
4470 pCache->fNewCache = 1;
4471 }
4472
4473 /*
4474 * Disassociate the buffer from the stream changing
4475 * it to non-buffered mode.
4476 */
4477 if (setvbuf(pCache->pFile, NULL, _IONBF, 0) != 0)
4478 FatalDie("setvbuf(,0,,0) failed: %s\n", strerror(errno));
4479}
4480
4481
4482/**
4483 * Re-writes the cache file.
4484 *
4485 * @param pCache The cache to commit and unlock.
4486 */
4487static void kObjCacheWrite(PKOBJCACHE pCache)
4488{
4489 unsigned i;
4490 off_t cb;
4491 char szBuf[8192];
4492 assert(pCache->fLocked);
4493 assert(pCache->fDirty);
4494
4495 /*
4496 * Rewind the file & stream, and associate a temporary buffer
4497 * with the stream to speed up the writing.
4498 */
4499 if (lseek(pCache->fd, 0, SEEK_SET) == -1)
4500 FatalDie("lseek(cache-fd) failed: %s\n", strerror(errno));
4501 rewind(pCache->pFile);
4502 if (setvbuf(pCache->pFile, szBuf, _IOFBF, sizeof(szBuf)) != 0)
4503 FatalDie("setvbuf failed: %s\n", strerror(errno));
4504
4505 /*
4506 * Write the header.
4507 */
4508 pCache->uGeneration++;
4509 fprintf(pCache->pFile,
4510 "magic=kObjCache-v0.1.0\n"
4511 "generation=%d\n"
4512 "digests=%d\n",
4513 pCache->uGeneration,
4514 pCache->cDigests);
4515
4516 /*
4517 * Write the digests.
4518 */
4519 for (i = 0; i < pCache->cDigests; i++)
4520 {
4521 PCKOCDIGEST pDigest = &pCache->paDigests[i];
4522 PKOCSUM pSum;
4523
4524 if (pDigest->pszAbsPath)
4525 fprintf(pCache->pFile, "digest-abs-#%u=%s\n", i, pDigest->pszAbsPath);
4526 if (pDigest->pszRelPath)
4527 fprintf(pCache->pFile, "digest-rel-#%u=%s\n", i, pDigest->pszRelPath);
4528 fprintf(pCache->pFile, "key-#%u=%u\n", i, pDigest->uKey);
4529 fprintf(pCache->pFile, "target-#%u=%s\n", i, pDigest->pszTarget);
4530 fprintf(pCache->pFile, "comp-argv-sum-#%u=", i);
4531 kOCSumFPrintf(&pDigest->SumCompArgv, pCache->pFile);
4532 for (pSum = &pDigest->SumHead; pSum; pSum = pSum->pNext)
4533 {
4534 fprintf(pCache->pFile, "sum-#%u=", i);
4535 kOCSumFPrintf(pSum, pCache->pFile);
4536 }
4537 }
4538
4539 /*
4540 * Close the stream and unlock fhe file.
4541 * (Closing the stream shouldn't close the file handle IIRC...)
4542 */
4543 fprintf(pCache->pFile, "the-end=fine\n");
4544 errno = 0;
4545 if ( fflush(pCache->pFile) < 0
4546 || ferror(pCache->pFile))
4547 {
4548 int iErr = errno;
4549 fclose(pCache->pFile);
4550 UnlinkFileInDir(pCache->pszName, pCache->pszDir);
4551 FatalDie("Stream error occured while writing '%s' in '%s': %s\n",
4552 pCache->pszName, pCache->pszDir, strerror(iErr));
4553 }
4554 if (setvbuf(pCache->pFile, NULL, _IONBF, 0) != 0)
4555 FatalDie("setvbuf(,0,,0) failed: %s\n", strerror(errno));
4556
4557 cb = lseek(pCache->fd, 0, SEEK_CUR);
4558 if (cb == -1)
4559 FatalDie("lseek(cache-file,0,CUR) failed: %s\n", strerror(errno));
4560#if defined(__WIN__)
4561 if (_chsize(pCache->fd, cb) == -1)
4562#else
4563 if (ftruncate(pCache->fd, cb) == -1)
4564#endif
4565 FatalDie("file truncation failed: %s\n", strerror(errno));
4566 InfoMsg(4, "wrote '%s' in '%s', %d bytes\n", pCache->pszName, pCache->pszDir, cb);
4567}
4568
4569
4570/**
4571 * Cleans out all invalid digests.s
4572 *
4573 * This is done periodically from the unlock routine to make
4574 * sure we don't accidentally accumulate stale digests.
4575 *
4576 * @param pCache The cache to chek.
4577 */
4578static void kObjCacheClean(PKOBJCACHE pCache)
4579{
4580 unsigned i = pCache->cDigests;
4581 while (i-- > 0)
4582 {
4583 /*
4584 * Try open it and purge it if it's bad.
4585 * (We don't kill the entry file because that's kmk clean's job.)
4586 */
4587 PCKOCDIGEST pDigest = &pCache->paDigests[i];
4588 PKOCENTRY pEntry = kOCEntryCreate(kOCDigestAbsPath(pDigest, pCache->pszDir));
4589 kOCEntryRead(pEntry);
4590 if ( !kOCEntryCheck(pEntry)
4591 || !kOCDigestIsValid(pDigest, pEntry))
4592 {
4593 unsigned cLeft;
4594 kOCDigestPurge(pDigest);
4595
4596 pCache->cDigests--;
4597 cLeft = pCache->cDigests - i;
4598 if (cLeft)
4599 memmove(pDigest, pDigest + 1, cLeft * sizeof(*pDigest));
4600
4601 pCache->fDirty = 1;
4602 }
4603 kOCEntryDestroy(pEntry);
4604 }
4605}
4606
4607
4608/**
4609 * Locks the cache for exclusive access.
4610 *
4611 * This will open the file if necessary and lock the entire file
4612 * using the best suitable platform API (tricky).
4613 *
4614 * @param pCache The cache to lock.
4615 */
4616static void kObjCacheLock(PKOBJCACHE pCache)
4617{
4618 struct stat st;
4619#if defined(__WIN__)
4620 OVERLAPPED OverLapped;
4621#endif
4622
4623 assert(!pCache->fLocked);
4624
4625 /*
4626 * Open it?
4627 */
4628 if (pCache->fd < 0)
4629 {
4630 pCache->fd = OpenFileInDir(pCache->pszName, pCache->pszDir, O_CREAT | O_RDWR | O_BINARY, 0666);
4631 if (pCache->fd == -1)
4632 {
4633 MakePath(pCache->pszDir);
4634 pCache->fd = OpenFileInDir(pCache->pszName, pCache->pszDir, O_CREAT | O_RDWR | O_BINARY, 0666);
4635 if (pCache->fd == -1)
4636 FatalDie("Failed to create '%s' in '%s': %s\n", pCache->pszName, pCache->pszDir, strerror(errno));
4637 }
4638
4639 pCache->pFile = fdopen(pCache->fd, "r+b");
4640 if (!pCache->pFile)
4641 FatalDie("fdopen failed: %s\n", strerror(errno));
4642 if (setvbuf(pCache->pFile, NULL, _IONBF, 0) != 0)
4643 FatalDie("setvbuf(,0,,0) failed: %s\n", strerror(errno));
4644 }
4645
4646 /*
4647 * Lock it.
4648 */
4649#if defined(__WIN__)
4650 memset(&OverLapped, 0, sizeof(OverLapped));
4651 if (!LockFileEx((HANDLE)_get_osfhandle(pCache->fd), LOCKFILE_EXCLUSIVE_LOCK, 0, ~0, 0, &OverLapped))
4652 FatalDie("Failed to lock the cache file: Windows Error %d\n", GetLastError());
4653#elif defined(__sun__)
4654 {
4655 struct flock fl;
4656 fl.l_whence = 0;
4657 fl.l_start = 0;
4658 fl.l_len = 0;
4659 fl.l_type = F_WRLCK;
4660 if (fcntl(pCache->fd, F_SETLKW, &fl) != 0)
4661 FatalDie("Failed to lock the cache file: %s\n", strerror(errno));
4662 }
4663#else
4664 if (flock(pCache->fd, LOCK_EX) != 0)
4665 FatalDie("Failed to lock the cache file: %s\n", strerror(errno));
4666#endif
4667 pCache->fLocked = 1;
4668
4669 /*
4670 * Check for new cache and read it it's an existing cache.
4671 *
4672 * There is no point in initializing a new cache until we've finished
4673 * compiling and has something to put into it, so we'll leave it as a
4674 * 0 byte file.
4675 */
4676 if (fstat(pCache->fd, &st) == -1)
4677 FatalDie("fstat(cache-fd) failed: %s\n", strerror(errno));
4678 if (st.st_size)
4679 kObjCacheRead(pCache);
4680 else
4681 {
4682 pCache->fNewCache = 1;
4683 InfoMsg(2, "the cache file is empty\n");
4684 }
4685}
4686
4687
4688/**
4689 * Unlocks the cache (without writing anything back).
4690 *
4691 * @param pCache The cache to unlock.
4692 */
4693static void kObjCacheUnlock(PKOBJCACHE pCache)
4694{
4695#if defined(__WIN__)
4696 OVERLAPPED OverLapped;
4697#endif
4698 assert(pCache->fLocked);
4699
4700 /*
4701 * Write it back if it's dirty.
4702 */
4703 if (pCache->fDirty)
4704 {
4705 if ( pCache->cDigests >= 16
4706 && (pCache->uGeneration % 19) == 19)
4707 kObjCacheClean(pCache);
4708 kObjCacheWrite(pCache);
4709 pCache->fDirty = 0;
4710 }
4711
4712 /*
4713 * Lock it.
4714 */
4715#if defined(__WIN__)
4716 memset(&OverLapped, 0, sizeof(OverLapped));
4717 if (!UnlockFileEx((HANDLE)_get_osfhandle(pCache->fd), 0, ~0U, 0, &OverLapped))
4718 FatalDie("Failed to unlock the cache file: Windows Error %d\n", GetLastError());
4719#elif defined(__sun__)
4720 {
4721 struct flock fl;
4722 fl.l_whence = 0;
4723 fl.l_start = 0;
4724 fl.l_len = 0;
4725 fl.l_type = F_UNLCK;
4726 if (fcntl(pCache->fd, F_SETLKW, &fl) != 0)
4727 FatalDie("Failed to lock the cache file: %s\n", strerror(errno));
4728 }
4729#else
4730 if (flock(pCache->fd, LOCK_UN) != 0)
4731 FatalDie("Failed to unlock the cache file: %s\n", strerror(errno));
4732#endif
4733 pCache->fLocked = 0;
4734}
4735
4736
4737/**
4738 * Removes the entry from the cache.
4739 *
4740 * The entry doesn't need to be in the cache.
4741 * The cache entry (file) itself is not touched.
4742 *
4743 * @param pCache The cache.
4744 * @param pEntry The entry.
4745 */
4746static void kObjCacheRemoveEntry(PKOBJCACHE pCache, PCKOCENTRY pEntry)
4747{
4748 unsigned i = pCache->cDigests;
4749 while (i-- > 0)
4750 {
4751 PKOCDIGEST pDigest = &pCache->paDigests[i];
4752 if (ArePathsIdentical(kOCDigestAbsPath(pDigest, pCache->pszDir),
4753 kOCEntryAbsPath(pEntry)))
4754 {
4755 unsigned cLeft;
4756 kOCDigestPurge(pDigest);
4757
4758 pCache->cDigests--;
4759 cLeft = pCache->cDigests - i;
4760 if (cLeft)
4761 memmove(pDigest, pDigest + 1, cLeft * sizeof(*pDigest));
4762
4763 pCache->fDirty = 1;
4764 InfoMsg(3, "removing entry '%s'; %d left.\n", kOCEntryAbsPath(pEntry), pCache->cDigests);
4765 }
4766 }
4767}
4768
4769
4770/**
4771 * Inserts the entry into the cache.
4772 *
4773 * The cache entry (file) itself is not touched by this operation,
4774 * the pEntry object otoh is.
4775 *
4776 * @param pCache The cache.
4777 * @param pEntry The entry.
4778 */
4779static void kObjCacheInsertEntry(PKOBJCACHE pCache, PKOCENTRY pEntry)
4780{
4781 unsigned i;
4782
4783 /*
4784 * Find a new key.
4785 */
4786 pEntry->uKey = pCache->uNextKey++;
4787 if (!pEntry->uKey)
4788 pEntry->uKey = pCache->uNextKey++;
4789 i = pCache->cDigests;
4790 while (i-- > 0)
4791 if (pCache->paDigests[i].uKey == pEntry->uKey)
4792 {
4793 pEntry->uKey = pCache->uNextKey++;
4794 if (!pEntry->uKey)
4795 pEntry->uKey = pCache->uNextKey++;
4796 i = pCache->cDigests;
4797 }
4798
4799 /*
4800 * Reallocate the digest array?
4801 */
4802 if ( !(pCache->cDigests & 3)
4803 && (pCache->cDigests || !pCache->paDigests))
4804 pCache->paDigests = xrealloc(pCache->paDigests, sizeof(pCache->paDigests[0]) * (pCache->cDigests + 4));
4805
4806 /*
4807 * Create a new digest.
4808 */
4809 kOCDigestInitFromEntry(&pCache->paDigests[pCache->cDigests], pEntry);
4810 pCache->cDigests++;
4811 InfoMsg(4, "Inserted digest #%u: %s\n", pCache->cDigests - 1, kOCEntryAbsPath(pEntry));
4812
4813 pCache->fDirty = 1;
4814}
4815
4816
4817/**
4818 * Find a matching cache entry.
4819 */
4820static PKOCENTRY kObjCacheFindMatchingEntry(PKOBJCACHE pCache, PCKOCENTRY pEntry)
4821{
4822 unsigned i = pCache->cDigests;
4823
4824 assert(pEntry->fNeedCompiling);
4825 assert(!kOCSumIsEmpty(&pEntry->New.SumCompArgv));
4826 assert(!kOCSumIsEmpty(&pEntry->New.SumHead));
4827
4828 while (i-- > 0)
4829 {
4830 /*
4831 * Matching?
4832 */
4833 PCKOCDIGEST pDigest = &pCache->paDigests[i];
4834 if ( kOCSumIsEqual(&pDigest->SumCompArgv, &pEntry->New.SumCompArgv)
4835 && kOCSumHasEqualInChain(&pDigest->SumHead, &pEntry->New.SumHead))
4836 {
4837 /*
4838 * Try open it.
4839 */
4840 unsigned cLeft;
4841 PKOCENTRY pRetEntry = kOCEntryCreate(kOCDigestAbsPath(pDigest, pCache->pszDir));
4842 kOCEntryRead(pRetEntry);
4843 if ( kOCEntryCheck(pRetEntry)
4844 && kOCDigestIsValid(pDigest, pRetEntry))
4845 return pRetEntry;
4846 kOCEntryDestroy(pRetEntry);
4847
4848 /* bad entry, purge it. */
4849 InfoMsg(3, "removing bad digest '%s'\n", kOCDigestAbsPath(pDigest, pCache->pszDir));
4850 kOCDigestPurge(pDigest);
4851
4852 pCache->cDigests--;
4853 cLeft = pCache->cDigests - i;
4854 if (cLeft)
4855 memmove(pDigest, pDigest + 1, cLeft * sizeof(*pDigest));
4856
4857 pCache->fDirty = 1;
4858 }
4859 }
4860
4861 return NULL;
4862}
4863
4864
4865/**
4866 * Is this a new cache?
4867 *
4868 * @returns 1 if new, 0 if not new.
4869 * @param pEntry The entry.
4870 */
4871static int kObjCacheIsNew(PKOBJCACHE pCache)
4872{
4873 return pCache->fNewCache;
4874}
4875
4876
4877/**
4878 * Prints a syntax error and returns the appropriate exit code
4879 *
4880 * @returns approriate exit code.
4881 * @param pszFormat The syntax error message.
4882 * @param ... Message args.
4883 */
4884static int SyntaxError(const char *pszFormat, ...)
4885{
4886 va_list va;
4887 fprintf(stderr, "kObjCache: syntax error: ");
4888 va_start(va, pszFormat);
4889 vfprintf(stderr, pszFormat, va);
4890 va_end(va);
4891 return 1;
4892}
4893
4894
4895/**
4896 * Prints the usage.
4897 * @returns 0.
4898 */
4899static int usage(FILE *pOut)
4900{
4901 fprintf(pOut,
4902 "syntax: kObjCache [--kObjCache-options] [-v|--verbose]\n"
4903 " < [-c|--cache-file <cache-file>]\n"
4904 " | [-n|--name <name-in-cache>] [[-d|--cache-dir <cache-dir>]] >\n"
4905 " <-f|--file <local-cache-file>>\n"
4906 " <-t|--target <target-name>>\n"
4907 " [-r|--redir-stdout] [-p|--passthru] [--named-pipe-compile <pipename>]\n"
4908 " --kObjCache-cpp <filename> <preprocessor + args>\n"
4909 " --kObjCache-cc <object> <compiler + args>\n"
4910 " [--kObjCache-both [args]]\n"
4911 );
4912 fprintf(pOut,
4913 " [--kObjCache-cpp|--kObjCache-cc [more args]]\n"
4914 " kObjCache <-V|--version>\n"
4915 " kObjCache [-?|/?|-h|/h|--help|/help]\n"
4916 "\n"
4917 "The env.var. KOBJCACHE_DIR sets the default cache diretory (-d).\n"
4918 "The env.var. KOBJCACHE_OPTS allow you to specifie additional options\n"
4919 "without having to mess with the makefiles. These are appended with "
4920 "a --kObjCache-options between them and the command args.\n"
4921 "\n");
4922 return 0;
4923}
4924
4925
4926int main(int argc, char **argv)
4927{
4928 PKOBJCACHE pCache;
4929 PKOCENTRY pEntry;
4930
4931 const char *pszCacheDir = getenv("KOBJCACHE_DIR");
4932 const char *pszCacheName = NULL;
4933 const char *pszCacheFile = NULL;
4934 const char *pszEntryFile = NULL;
4935
4936 const char **papszArgvPreComp = NULL;
4937 unsigned cArgvPreComp = 0;
4938 const char *pszPreCompName = NULL;
4939 int fRedirPreCompStdOut = 0;
4940
4941 const char **papszArgvCompile = NULL;
4942 unsigned cArgvCompile = 0;
4943 const char *pszObjName = NULL;
4944 int fRedirCompileStdIn = 0;
4945 const char *pszNmPipeCompile = NULL;
4946
4947 const char *pszMakeDepFilename = NULL;
4948 int fMakeDepFixCase = 0;
4949 int fMakeDepGenStubs = 0;
4950 int fMakeDepQuiet = 0;
4951 int fOptimizePreprocessorOutput = 0;
4952
4953 const char *pszTarget = NULL;
4954
4955 enum { kOC_Options, kOC_CppArgv, kOC_CcArgv, kOC_BothArgv } enmMode = kOC_Options;
4956
4957 size_t cch;
4958 char *psz;
4959 int i;
4960
4961 SetErrorPrefix("kObjCache");
4962
4963 /*
4964 * Arguments passed in the environmnet?
4965 */
4966 psz = getenv("KOBJCACHE_OPTS");
4967 if (psz)
4968 AppendArgs(&argc, &argv, psz, "--kObjCache-options");
4969
4970 /*
4971 * Parse the arguments.
4972 */
4973 if (argc <= 1)
4974 return usage(stderr);
4975 for (i = 1; i < argc; i++)
4976 {
4977 if (!strcmp(argv[i], "--kObjCache-cpp"))
4978 {
4979 enmMode = kOC_CppArgv;
4980 if (!pszPreCompName)
4981 {
4982 if (++i >= argc)
4983 return SyntaxError("--kObjCache-cpp requires an object filename!\n");
4984 pszPreCompName = argv[i];
4985 }
4986 }
4987 else if (!strcmp(argv[i], "--kObjCache-cc"))
4988 {
4989 enmMode = kOC_CcArgv;
4990 if (!pszObjName)
4991 {
4992 if (++i >= argc)
4993 return SyntaxError("--kObjCache-cc requires an preprocessor output filename!\n");
4994 pszObjName = argv[i];
4995 }
4996 }
4997 else if (!strcmp(argv[i], "--kObjCache-both"))
4998 enmMode = kOC_BothArgv;
4999 else if (!strcmp(argv[i], "--kObjCache-options"))
5000 enmMode = kOC_Options;
5001 else if (!strcmp(argv[i], "--help"))
5002 return usage(stderr);
5003 else if (enmMode != kOC_Options)
5004 {
5005 if (enmMode == kOC_CppArgv || enmMode == kOC_BothArgv)
5006 {
5007 if (!(cArgvPreComp % 16))
5008 papszArgvPreComp = xrealloc((void *)papszArgvPreComp, (cArgvPreComp + 17) * sizeof(papszArgvPreComp[0]));
5009 papszArgvPreComp[cArgvPreComp++] = argv[i];
5010 papszArgvPreComp[cArgvPreComp] = NULL;
5011 }
5012 if (enmMode == kOC_CcArgv || enmMode == kOC_BothArgv)
5013 {
5014 if (!(cArgvCompile % 16))
5015 papszArgvCompile = xrealloc((void *)papszArgvCompile, (cArgvCompile + 17) * sizeof(papszArgvCompile[0]));
5016 papszArgvCompile[cArgvCompile++] = argv[i];
5017 papszArgvCompile[cArgvCompile] = NULL;
5018 }
5019 }
5020 else if (!strcmp(argv[i], "-f") || !strcmp(argv[i], "--entry-file"))
5021 {
5022 if (i + 1 >= argc)
5023 return SyntaxError("%s requires a cache entry filename!\n", argv[i]);
5024 pszEntryFile = argv[++i];
5025 }
5026 else if (!strcmp(argv[i], "-c") || !strcmp(argv[i], "--cache-file"))
5027 {
5028 if (i + 1 >= argc)
5029 return SyntaxError("%s requires a cache filename!\n", argv[i]);
5030 pszCacheFile = argv[++i];
5031 }
5032 else if (!strcmp(argv[i], "-n") || !strcmp(argv[i], "--name"))
5033 {
5034 if (i + 1 >= argc)
5035 return SyntaxError("%s requires a cache name!\n", argv[i]);
5036 pszCacheName = argv[++i];
5037 }
5038 else if (!strcmp(argv[i], "-d") || !strcmp(argv[i], "--cache-dir"))
5039 {
5040 if (i + 1 >= argc)
5041 return SyntaxError("%s requires a cache directory!\n", argv[i]);
5042 pszCacheDir = argv[++i];
5043 }
5044 else if (!strcmp(argv[i], "-t") || !strcmp(argv[i], "--target"))
5045 {
5046 if (i + 1 >= argc)
5047 return SyntaxError("%s requires a target platform/arch name!\n", argv[i]);
5048 pszTarget = argv[++i];
5049 }
5050 else if (!strcmp(argv[i], "--named-pipe-compile"))
5051 {
5052 if (i + 1 >= argc)
5053 return SyntaxError("%s requires a pipe name!\n", argv[i]);
5054 pszNmPipeCompile = argv[++i];
5055 fRedirCompileStdIn = 0;
5056 }
5057 else if (!strcmp(argv[i], "-m") || !strcmp(argv[i], "--make-dep-file"))
5058 {
5059 if (i + 1 >= argc)
5060 return SyntaxError("%s requires a filename!\n", argv[i]);
5061 pszMakeDepFilename = argv[++i];
5062 }
5063 else if (!strcmp(argv[i], "--make-dep-fix-case"))
5064 fMakeDepFixCase = 1;
5065 else if (!strcmp(argv[i], "--make-dep-gen-stubs"))
5066 fMakeDepGenStubs = 1;
5067 else if (!strcmp(argv[i], "--make-dep-quiet"))
5068 fMakeDepQuiet = 1;
5069 else if (!strcmp(argv[i], "-O1") || !strcmp(argv[i], "--optimize-1"))
5070 fOptimizePreprocessorOutput = 1;
5071 else if (!strcmp(argv[i], "-O2") || !strcmp(argv[i], "--optimize-2"))
5072 fOptimizePreprocessorOutput = 1 | 2;
5073 else if (!strcmp(argv[i], "-p") || !strcmp(argv[i], "--passthru"))
5074 fRedirPreCompStdOut = fRedirCompileStdIn = 1;
5075 else if (!strcmp(argv[i], "-r") || !strcmp(argv[i], "--redir-stdout"))
5076 fRedirPreCompStdOut = 1;
5077 else if (!strcmp(argv[i], "-v") || !strcmp(argv[i], "--verbose"))
5078 g_cVerbosityLevel++;
5079 else if (!strcmp(argv[i], "-q") || !strcmp(argv[i], "--quiet"))
5080 g_cVerbosityLevel = 0;
5081 else if (!strcmp(argv[i], "-h") || !strcmp(argv[i], "-?")
5082 || !strcmp(argv[i], "/h") || !strcmp(argv[i], "/?") || !strcmp(argv[i], "/help"))
5083 {
5084 usage(stdout);
5085 return 0;
5086 }
5087 else if (!strcmp(argv[i], "-V") || !strcmp(argv[i], "--version"))
5088 {
5089 printf("kObjCache - kBuild version %d.%d.%d ($Revision: 2620 $)\n"
5090 "Copyright (c) 2007-2012 knut st. osmundsen\n",
5091 KBUILD_VERSION_MAJOR, KBUILD_VERSION_MINOR, KBUILD_VERSION_PATCH);
5092 return 0;
5093 }
5094 else
5095 return SyntaxError("Doesn't grok '%s'!\n", argv[i]);
5096 }
5097 if (!pszEntryFile)
5098 return SyntaxError("No cache entry filename (-f)!\n");
5099 if (!pszTarget)
5100 return SyntaxError("No target name (-t)!\n");
5101 if (!cArgvCompile)
5102 return SyntaxError("No compiler arguments (--kObjCache-cc)!\n");
5103 if (!cArgvPreComp)
5104 return SyntaxError("No preprocessor arguments (--kObjCache-cc)!\n");
5105
5106 /*
5107 * Calc the cache file name.
5108 * It's a bit messy since the extension has to be replaced.
5109 */
5110 if (!pszCacheFile)
5111 {
5112 if (!pszCacheDir)
5113 return SyntaxError("No cache dir (-d / KOBJCACHE_DIR) and no cache filename!\n");
5114 if (!pszCacheName)
5115 {
5116 psz = (char *)FindFilenameInPath(pszEntryFile);
5117 if (!*psz)
5118 return SyntaxError("The cache file (-f) specifies a directory / nothing!\n");
5119 cch = psz - pszEntryFile;
5120 pszCacheName = memcpy(xmalloc(cch + 5), psz, cch + 1);
5121 psz = strrchr(pszCacheName, '.');
5122 if (!psz || psz <= pszCacheName)
5123 psz = (char *)pszCacheName + cch;
5124 memcpy(psz, ".koc", sizeof(".koc"));
5125 }
5126 pszCacheFile = MakePathFromDirAndFile(pszCacheName, pszCacheDir);
5127 }
5128
5129 /*
5130 * Create and initialize the two objects we'll be working on.
5131 *
5132 * We're supposed to be the only ones actually writing to the local file,
5133 * so it's perfectly fine to read it here before we lock it. This simplifies
5134 * the detection of object name and compiler argument changes.
5135 */
5136 SetErrorPrefix("kObjCache - %s", FindFilenameInPath(pszCacheFile));
5137 pCache = kObjCacheCreate(pszCacheFile);
5138
5139 pEntry = kOCEntryCreate(pszEntryFile);
5140 kOCEntryRead(pEntry);
5141 kOCEntrySetCppName(pEntry, pszPreCompName);
5142 kOCEntrySetCompileObjName(pEntry, pszObjName);
5143 kOCEntrySetCompileArgv(pEntry, papszArgvCompile, cArgvCompile);
5144 kOCEntrySetTarget(pEntry, pszTarget);
5145 kOCEntrySetPipedMode(pEntry, fRedirPreCompStdOut, fRedirCompileStdIn, pszNmPipeCompile);
5146 kOCEntrySetDepFilename(pEntry, pszMakeDepFilename, fMakeDepFixCase, fMakeDepQuiet, fMakeDepGenStubs);
5147 kOCEntrySetOptimizations(pEntry, fOptimizePreprocessorOutput);
5148
5149 /*
5150 * Open (& lock) the two files and do validity checks and such.
5151 */
5152 kObjCacheLock(pCache);
5153 if ( kObjCacheIsNew(pCache)
5154 && kOCEntryNeedsCompiling(pEntry))
5155 {
5156 /*
5157 * Both files are missing/invalid.
5158 * Optimize this path as it is frequently used when making a clean build.
5159 */
5160 kObjCacheUnlock(pCache);
5161 InfoMsg(1, "doing full compile\n");
5162 kOCEntryPreProcessAndCompile(pEntry, papszArgvPreComp, cArgvPreComp);
5163 kObjCacheLock(pCache);
5164 }
5165 else
5166 {
5167 /*
5168 * Do the preprocess (don't need to lock the cache file for this).
5169 */
5170 kObjCacheUnlock(pCache);
5171 kOCEntryPreProcess(pEntry, papszArgvPreComp, cArgvPreComp);
5172
5173 /*
5174 * Check if we need to recompile. If we do, try see if the is a cache entry first.
5175 */
5176 kOCEntryCalcRecompile(pEntry);
5177 if (kOCEntryNeedsCompiling(pEntry))
5178 {
5179 PKOCENTRY pUseEntry;
5180 kObjCacheLock(pCache);
5181 kObjCacheRemoveEntry(pCache, pEntry);
5182 pUseEntry = kObjCacheFindMatchingEntry(pCache, pEntry);
5183 if (pUseEntry)
5184 {
5185 InfoMsg(1, "using cache entry '%s'\n", kOCEntryAbsPath(pUseEntry));
5186 kOCEntryCopy(pEntry, pUseEntry);
5187 kOCEntryDestroy(pUseEntry);
5188 }
5189 else
5190 {
5191 kObjCacheUnlock(pCache);
5192 InfoMsg(1, "recompiling\n");
5193 kOCEntryCompileIt(pEntry);
5194 kObjCacheLock(pCache);
5195 }
5196 }
5197 else
5198 {
5199 InfoMsg(1, "no need to recompile\n");
5200 kObjCacheLock(pCache);
5201 }
5202 }
5203
5204 /*
5205 * Update the cache files.
5206 */
5207 kObjCacheRemoveEntry(pCache, pEntry);
5208 kObjCacheInsertEntry(pCache, pEntry);
5209 kOCEntryWrite(pEntry);
5210 kObjCacheUnlock(pCache);
5211 kObjCacheDestroy(pCache);
5212 if (fOptimizePreprocessorOutput)
5213 {
5214 InfoMsg(3, "g_cbMemMoved=%#x (%d)\n", g_cbMemMoved, g_cbMemMoved);
5215 InfoMsg(3, "g_cMemMoves=%#x (%d)\n", g_cMemMoves, g_cMemMoves);
5216 }
5217
5218 return 0;
5219}
5220
5221
5222/** @page kObjCache Benchmarks.
5223 *
5224 * (2007-06-10)
5225 *
5226 * Mac OS X debug -j 3 cached clobber build (rm -Rf out ; sync ; svn diff ; sync ; sleep 1 ; time kmk -j 3 USE_KOBJCACHE=1):
5227 * real 11m28.811s
5228 * user 13m59.291s
5229 * sys 3m24.590s
5230 *
5231 * Mac OS X debug -j 3 cached depend build [cdefs.h] (touch include/iprt/cdefs.h ; sync ; svn diff ; sync ; sleep 1 ; time kmk -j 3 USE_KOBJCACHE=1):
5232 * real 1m26.895s
5233 * user 1m26.971s
5234 * sys 0m32.532s
5235 *
5236 * Mac OS X debug -j 3 cached depend build [err.h] (touch include/iprt/err.h ; sync ; svn diff ; sync ; sleep 1 ; time kmk -j 3 USE_KOBJCACHE=1):
5237 * real 1m18.049s
5238 * user 1m20.462s
5239 * sys 0m27.887s
5240 *
5241 * Mac OS X release -j 3 cached clobber build (rm -Rf out/darwin.x86/release ; sync ; svn diff ; sync ; sleep 1 ; time kmk -j 3 USE_KOBJCACHE=1 BUILD_TYPE=release):
5242 * real 13m27.751s
5243 * user 18m12.654s
5244 * sys 3m25.170s
5245 *
5246 * Mac OS X profile -j 3 cached clobber build (rm -Rf out/darwin.x86/profile ; sync ; svn diff ; sync ; sleep 1 ; time kmk -j 3 USE_KOBJCACHE=1 BUILD_TYPE=profile):
5247 * real 9m9.720s
5248 * user 8m53.005s
5249 * sys 2m13.110s
5250 *
5251 * Mac OS X debug -j 3 clobber build (rm -Rf out/darwin.x86/debug ; sync ; svn diff ; sync ; sleep 1 ; time kmk -j 3 BUILD_TYPE=debug):
5252 * real 10m18.129s
5253 * user 12m52.687s
5254 * sys 2m51.277s
5255 *
5256 * Mac OS X debug -j 3 debug build [cdefs.h] (touch include/iprt/cdefs.h ; sync ; svn diff ; sync ; sleep 1 ; time kmk -j 3 BUILD_TYPE=debug):
5257 * real 4m46.147s
5258 * user 5m27.087s
5259 * sys 1m11.775s
5260 *
5261 * Mac OS X debug -j 3 debug build [err.h] (touch include/iprt/cdefs.h ; sync ; svn diff ; sync ; sleep 1 ; time kmk -j 3 BUILD_TYPE=debug):
5262 * real 4m17.572s
5263 * user 5m7.450s
5264 * sys 1m3.450s
5265 *
5266 * Mac OS X release -j 3 clobber build (rm -Rf out/darwin.x86/release ; sync ; svn diff ; sync ; sleep 1 ; time kmk -j 3 BUILD_TYPE=release):
5267 * real 12m14.742s
5268 * user 17m11.794s
5269 * sys 2m51.454s
5270 *
5271 * Mac OS X profile -j 3 clobber build (rm -Rf out/darwin.x86/profile ; sync ; svn diff ; sync ; sleep 1 ; time kmk -j 3 BUILD_TYPE=profile):
5272 * real 12m33.821s
5273 * user 17m35.086s
5274 * sys 2m53.312s
5275 *
5276 * Note. The profile build can pick object files from the release build.
5277 * (all with KOBJCACHE_OPTS=-v; which means a bit more output and perhaps a second or two slower.)
5278 */
5279
Note: See TracBrowser for help on using the repository browser.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette