Is this makefile cache trick safe? - makefile

Question

In my build system, I would like to avoid rebuilding a subproject if none of its files changed. The basic idea is this:
After doing make all, I hash the contents of the directory and save it.
The next time I want to build the project, hash the contents of the directory again.
If the hashes are equal, we are done. Otherwise, go to 1.
I'm trying to implement this in GNU Make, using this helper script named update-hash:
#!/bin/bash
HASH_FILE=$1
SRC_DIR=$2
echo Hashing sources
UPDATED_HASH=$(tar c $SRC_DIR | sha256sum | cut -c-64)
SAVED_HASH=$(<$HASH_FILE)
if [[ $SAVED_HASH != $UPDATED_HASH ]]; then
echo "Updating hash"
echo $UPDATED_HASH > $HASH_FILE
else
echo "$HASH_FILE is up to date. Not touching it."
fi
Here's the tricky part: since Make relies on file modification times to decide what to build, I use two files, pre_hash and post_hash, and take advantage of the fact that my update-hash script does not update the file if the hashes match.
subproject: update_pre_hash post_hash
post_hash: pre_hash
make -C subproject clean all
update-hash pre_hash subproject
cp pre_hash post_hash
update_pre_hash:
update-hash pre_hash subproject
The way this works is like this:
On the first run of make subproject, the pre_hash file gets updated, and so the post_hash rule gets built, ending with a built subproject and with a post_hash file that is newer than pre_hash.
On subsequent runs, update_pre_hash always gets invoked, but doesn't update the pre_hash file, and so the post_hash rule does not get invoked.
If any file in the subproject changes, the pre_hash file gets updated, and so post_hash gets invoked, resulting in a full build and new hash files.
My question is: will this actually work? Some basic testing did not reveal any glaring problems, but it seems a little shaky. I'm particularly worried about relying on the dependencies of subproject getting evaluated in order, which I know is an invalid assumption with make -j, but maybe there's a way to fix that.
Do you see a problem with this implementation?
If you do, can you suggest any fixes?
Do you know of another (maybe better) way to achieve the same effect? (other than the obvious "fix the subproject to no-op if there are no changes" - I don't want to maintain the subproject's build process)
Update: #dash-o suggested a much simpler approach, with a Makefile like this:
last_update: $(shell find subproject -type f)
make -C subproject clean all
touch last_update
This way, last_update is always newer than all the files in subproject, but if any files change later, a rebulid will be triggered. Thanks!