How does MAKE remember the file timestamps

Question

I've found this question which is basically asking the same, but got no real answer.

Where is the make's config file / database file where it remembers the file timestamps, so it can tell what changed? I checked and there's no .make or similar in my project, nor in the home directory.

Or does it somehow store the information inside the files themselves, perhaps by modifying the timestamps? (That sounds fishy though)

It did get a real answer. Perhaps it would have been better if you'd asked for clarification there. — reinierpost, Jun 11 '15 at 10:17

Some programmer dude · Accepted Answer · 2015-06-10T09:05:11.503

14

There is no such "database". The program simply compare the filesystems modification and creation timestamps of source and target files.

Lets say you have the following rule:

some_target: some_source_1 some_source_2

Then if the modified timestamp of either some_source_1 or some_source_2 is later than the modification/creation time of some_target then the rule will activate and the target will be rebuilt.

edited Jun 10 '15 at 09:05

answered Jun 10 '15 at 09:01

Some programmer dude

400,186
35
402
621

Yes, but how can it tell from that what files changed? It must store the information somewhere. – MightyPork Jun 10 '15 at 09:02
@MightyPork Yes, in the *filesystem*. Filesystems have timestamps for creation and modification built into them. – Some programmer dude Jun 10 '15 at 09:04
Yeah I'm just trying to understand. So make touches the target file when rebuilding it? – MightyPork Jun 10 '15 at 09:04
@JoachimPileborg what's with the `--print-data-base` option? any idea? – Arjun Sreedharan Jun 10 '15 at 09:05
@MightyPork No `make` doesn't have to do it, the timestamps are set automatically when a file is modified or created, for example by the compiler. – Some programmer dude Jun 10 '15 at 09:05
@ArjunSreedharan It's the internal *in memory* database that `make` builds to store the data it needs while running. There is no such database saved to disk between invocations. – Some programmer dude Jun 10 '15 at 09:06
No that can't possibly work, I have `noatime` mount option, nothing is changed when you *read* the file. – MightyPork Jun 10 '15 at 09:07
1

@MightyPork `noatime` is for the *access* time, not *modification* time. Those are two different fields in the filesystem. – Some programmer dude Jun 10 '15 at 09:07
But that implies that make must touch the file, no? – MightyPork Jun 10 '15 at 09:07
@MightyPork No, the *compiler* "touches" the target files, the `make` program doesn't need to. – Some programmer dude Jun 10 '15 at 09:08
Okay I can accept this, but I don't believe that's correct. I don't think make can blindly trust the compiler to change modification time of the files it *reads*... – MightyPork Jun 10 '15 at 09:14
4

The compiler doesn't have to change the modification times of the files it reads: the editor you use to edit the code does that. The compiler only changes the modification time of the files it generates or changes (object files, etc). This is pretty straight forward stuff... – Nik Bougalis Jun 10 '15 at 09:16

score 7 · Answer 2 · answered Jun 10 '15 at 09:18

Makefiles describe targets and dependencies. Make executes commands to create/recreate the target(s) if necessary.

If the target doesn't exist, then make will try to create it.

If the target does exist, make compares the modification times of the target and its dependencies. If any of the dependencies was modified after the target was modified, then make will execute the command(s) to regenerate the target.

For example, for C files the target is the corresponding .o file and the dependency is on the file containing the C source code (and possibly some include files). If the .c file is newer than the .o file, then make runs the C compiler. This will generate a .o file with a newer modification time than the .c file.

How does MAKE remember the file timestamps

2 Answers2