MAKE(1)

✨ MAKE(1) ✨

📖 This page is filed under User Commands 🎀

🌸 NAME 🌸

make - GNU Make utility to maintain groups of programs 💖

🦋 SYNOPSIS 🦋

make [OPTION]... [TARGET]...

💅 DESCRIPTION 💅

okay so make is literally the utility that figures out which bits of a big program need recompiling and then goes and does it for you 😭✨ it's giving automation, bestie.

This manual describes the GNU version of make. It was written by Richard Stallman and Roland McGrath, and it's currently looked after by Paul Smith 🫶 The examples use C programs because C is everywhere, but make works with any language whose compiler can be run from a shell command. ngl make isn't even only for programs. You can use it for any task where some files need updating from other files whenever those others change 🧚

To get started, you write a file called the makefile. This file describes how the files in your program relate to each other, and it includes the commands for updating each one. In a typical program, the executable gets updated from object files, and those object files get made by compiling source files 🔥

Once you have a decent makefile, every time you change some source files you just type this simple shell command:

make

and boom, all the necessary recompilations happen 💖 make uses the makefile plus the last-modification times of the files to work out which ones need updating. For each of those, it runs the commands recorded in the makefile. iconic behaviour, honestly 👑

make runs the commands in the makefile to update one or more targets, and a target is usually a program. If there's no -f option, make goes looking for the makefiles GNUmakefile, makefile, and Makefile, in that order 🦋

Normally you should name your makefile either makefile or Makefile. I'm team Makefile because it shows up right near the top of a directory listing, next to other important stuff like README ✨ The first name checked, GNUmakefile, is not recommended for most makefiles. Only use that name if your makefile is specific to GNU Make and other versions of make wouldn't understand it 🙈 If the makefile is -, make reads from the standard input.

make updates a target when it depends on prerequisite files that have been modified since the target was last modified, or when the target doesn't exist at all 🍓

🎀 OPTIONS 🎀

• -b, -m — these are ignored, just there for compatibility with other versions of make 🫶
• -B, --always-make — makes every target, no questions asked 💅
• -C dir, --directory=dir — switches to the directory dir before reading the makefiles or doing anything else. If you pass several -C options, each one is read relative to the one before it, so -C / -C etc is the same as -C /etc 🗺️ This is usually used when make calls itself recursively 🔁
• -d — prints debugging info alongside the normal stuff. The debugging info tells you which files are being considered for remaking, which file-times are being compared and what those comparisons come out to, which files actually need remaking, and which implicit rules get considered and which ones get applied. literally everything interesting about how make decides what to do 🕵️‍♀️💜
• --debug[=FLAGS] — also prints debugging info alongside normal processing. If you leave out FLAGS, it behaves exactly like -d. FLAGS can be any mix of the following names, separated by commas or spaces. Only the first character matters, so the rest can be dropped:
  • all for all debugging output (same as -d) 🌈
  • basic for basic debugging 🍓
  • verbose for more verbose basic debugging 📣
  • implicit for showing implicit rule search operations 🔍
  • jobs for details on how commands are invoked 🧚
  • makefile for debugging while remaking makefiles 🛠️
  • print shows every recipe that runs, even the silent ones 🤫
  • why shows the reason make decided to rebuild each target 💭
  • none turns off all the debugging flags you set before it 🙅‍♀️
• -e, --environment-overrides — gives variables from the environment priority over variables set in makefiles 🌿
• -E string, --eval string — runs string through the eval function before any makefiles get parsed 🪄
• -f file, --file=file, --makefile=FILE — uses file as the makefile 📄
• -i, --ignore-errors — ignores all errors from the commands run while remaking files. chaotic, but sometimes that's the vibe 🙈
• -I dir, --include-dir=dir — names a directory dir to search for included makefiles. If you use several -I options, the directories get searched in the order you gave them. Unlike the arguments to other make flags, directories given with -I can come right after the flag, so -Idir works as well as -I dir. This is allowed so it matches the -I flag of the C preprocessor 💖
• -j [jobs], --jobs[=jobs] — sets how many jobs (commands) can run at the same time. If you give more than one -j, the last one is the one that counts. If you give -j with no number, make won't limit how many jobs run at once 🏎️✨
• --jobserver-style=style — picks the jobserver style to use. style can be fifo, pipe, or sem (Windows only) 🪟
• -k, --keep-going — keeps going as far as possible after an error. The target that failed, plus anything depending on it, can't be remade, but the other dependencies of those targets still get processed 🦋
• -l [load], --load-average[=load] — says no new jobs (commands) should start if other jobs are already running and the load average is at least load (a floating-point number). With no argument, it removes any load limit you set before 🌡️
• -L, --check-symlink-times — uses the latest mtime between the symlinks and the target 🔗
• -n, --just-print, --dry-run, --recon — prints the commands that would run, but doesn't actually run them (except in certain circumstances 👀) 🔮
• -o file, --old-file=file, --assume-old=file — doesn't remake file, even if it's older than its dependencies, and doesn't remake anything just because file changed. Basically file gets treated as super old and its rules get ignored 🧓
• -O[type], --output-sync[=type] — when you're running several jobs in parallel with -j, this keeps each job's output collected together instead of mixed in with everyone else's 🧃
  • no type, or type is target: the whole recipe for each target gets grouped together 🎀
  • type is line: the output from each command line in a recipe gets grouped together 📏
  • type is recurse: the output from an entire recursive make gets grouped together 🔁
  • type is none: output synchronization is turned off 🙅‍♀️
• -p, --print-data-base — prints the data base (the rules and variable values) you get from reading the makefiles, and then carries on executing as usual or however else you specified. This also prints the version information you'd get with the -v switch (see below). If you want to print the data base without remaking any files, use make -p -f/dev/null 🗃️💅

⚠️ the next batch of options (-q and friends) is coming up in part 2, bestie, so stay tuned 💜🧚

✨ COPYRIGHT ✨

okay so bestie, the legal stuff matters too 💅 Copyright © 1992-1993, 1996-2023 Free Software Foundation, Inc. This file is part of GNU Make. 🎀

GNU Make is free software, so you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation. Pick either version 3 of the License, or (at your option) any later version. It's giving freedom 🦋

GNU Make is distributed in the hope that it'll be useful, but WITHOUT ANY WARRANTY 😭 that means no guarantee at all, not even the implied kind of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. For the full tea, check out the GNU General Public License. 🫶

You should have received a copy of the GNU General Public License along with this program. If you didn't, go see https://www.gnu.org/licenses/ ✨

GNU 🌸 26 May 2023 🌸 MAKE(1)

Source: GNU Make, dated 26 May 2023. Bye bestie, go make some magic 🧚💜