How do I force make/GCC to show me the commands?

Question

I'm trying to debug a compilation problem, but I cannot seem to get GCC (or maybe it is make??) to show me the actual compiler and linker commands it is executing.

Here is the output I am seeing:

  CCLD   libvirt_parthelper
libvirt_parthelper-parthelper.o: In function `main':
/root/qemu-build/libvirt-0.9.0/src/storage/parthelper.c:102: undefined reference to `ped_device_get'
/root/qemu-build/libvirt-0.9.0/src/storage/parthelper.c:116: undefined reference to `ped_disk_new'
/root/qemu-build/libvirt-0.9.0/src/storage/parthelper.c:122: undefined reference to `ped_disk_next_partition'
/root/qemu-build/libvirt-0.9.0/src/storage/parthelper.c:172: undefined reference to `ped_disk_next_partition'
/root/qemu-build/libvirt-0.9.0/src/storage/parthelper.c:172: undefined reference to `ped_disk_next_partition'
collect2: ld returned 1 exit status
make[3]: *** [libvirt_parthelper] Error 1

What I want to see should be similar to this:

$ make
gcc -Wall   -c -o main.o main.c
gcc -Wall   -c -o hello_fn.o hello_fn.c
gcc   main.o hello_fn.o   -o main

Notice how this example has the complete gcc command displayed. The above example merely shows things like "CCLD libvirt_parthelper". I'm not sure how to control this behavior.

Untuck

Are you running a makefile, or just a gcc command? – Joleenjolene

This looks like Kbuild or Autotools output. Try make V=1. – Necrolatry

Related: the opposite question Control the output of a make command to be less verbose, don't echo each command – Hepzi

Answer 1

To invoke a dry run:

make -n

This will show what make is attempting to do.

Rimbaud

Found it :) make V=1 Although the above suggestion of "make -n" worked as well. :) Thank you all for your responses. – Untuck

Difference is that make -n does not execute the commands. Thus correct answer is make V=1 – Obstetrician

make V=1 is only working if the Makefile supports it. automake's makefiles do that, but many others don't. – Vouch

For CMake, use make VERBOSE=1; for GNU autotools make V=1. – Lithography

@Obstetrician if you want to run actually run the commands, consider make SHELL='sh -x': https://mcmap.net/q/15178/-how-do-i-force-make-gcc-to-show-me-the-commands – Keffiyeh

running with make -k helped me (-k = --keep running) – Writhen

This never works in a recursive environment (like ./configure or cmake generate). – Goshawk

Answer 2

Build system independent method

make SHELL='sh -x'

is another option. Sample Makefile:

a:
    @echo a

Output:

+ echo a
a

This sets the special SHELL variable for make, and -x tells sh to print the expanded line before executing it.

One advantage over -n is that is actually runs the commands. I have found that for some projects (e.g. Linux kernel) that -n may stop running much earlier than usual probably because of dependency problems.

One downside of this method is that you have to ensure that the shell that will be used is sh, which is the default one used by Make as they are POSIX, but could be changed with the SHELL make variable.

Doing sh -v would be cool as well, but Dash 0.5.7 (Ubuntu 14.04 sh) ignores for -c commands (which seems to be how make uses it) so it doesn't do anything.

make -p will also interest you, which prints the values of set variables.

CMake generated Makefiles always support VERBOSE=1

As in:

mkdir build
cd build
cmake ..
make VERBOSE=1

Dedicated question at: Using CMake with GNU Make: How can I see the exact commands?

Keffiyeh

Definitely the best answer which doesn't depend on how well the original Makefile was written/generated – Vociferance

If anyone can explain the downvote, let me know so I can learn and improve the information ;-) – Keffiyeh

make SHELL='$$SHELL -x' will make $SHELL literal which is not evaluated. Using make SHELL="$SHELL -x" will work. – Kook

this is the best generic answer, in contrast to some other answers this does not depend on using cmake – Mackay

make SHELL='sh -x' is super! – Accession

Good idea (SHELL='sh -x'), but if your makefiles were to pass SHELL around, they must do it like so: SHELL='$(SHELL)', not SHELL=$(SHELL). So you might need to do some replacements. – Protocol

I don't know why the downvote, but there should be a makefile interface that can circumvent this. There are many options as expressed in other posts. However, the makefile may contain make help, which would give instruction on how to get verbose output. Using the sh -x could break a makefile if it wanted bash for instance. There is no right answer. I always take a negative vote as a fact that I may have stretched someone's mind and they didn't like it. – Branum

SHELL += -x might be a better tack. – Branum

Answer 3

Library makefiles, which are generated by autotools (the ./configure you have to issue) often have a verbose option, so basically, using make VERBOSE=1 or make V=1 should give you the full commands.

But this depends on how the makefile was generated.

The -d option might help, but it will give you an extremely long output.

Dermatologist

Note: CMake-generated Makefiles only support VERBOSE=1, not V=1. – Hostility

V=1 worked for me, compiling nuttx with mips-linux-gnu-gcc, thank you. – Stanfill

Answer 4

Since GNU Make version 4.0, the --trace argument is a nice way to tell what and why a makefile do, outputing lines like:

makefile:8: target 'foo.o' does not exist

or

makefile:12: update target 'foo' due to: bar

Mapping

This argument prints more detailed information than dry run. It is very helpful to understand make systems which has complex build process like dpdk. – Incubus

@makerj: Perhaps, but it does actually execute the commands, unlike make -n. – Catamnesis

Answer 5

Use make V=1

Other suggestions here:

• make VERBOSE=1 - did not work at least from my trials.

• make -n - displays only logical operation, not command line being executed. E.g. CC source.cpp

• make --debug=j - works as well, but might also enable multi threaded building, causing extra output.

Yttriferous

make VERBOSE=1 is for CMake. Your trials were most likely with GNU autotools-based projects. – Lithography

Answer 6

I like to use:

make --debug=j

https://linux.die.net/man/1/make

--debug[=FLAGS]

Print debugging information in addition to normal processing. If the FLAGS are omitted, then the behavior is the same as if -d was specified. FLAGS may be a for all debugging output (same as using -d), b for basic debugging, v for more verbose basic debugging, i for showing implicit rules, j for details on invocation of commands, and m for debugging while remaking makefiles.

Gerrilee

It doesn't necessarily show the command it executes. You may just get Reaping winning child xyz and Jobserver client (fds 3,4) and Need a job token; we don't have children and so on. – Catamnesis

Agreed, @einpoklum. – Gerrilee

Answer 7

Depending on your automake version, you can also use this:

make AM_DEFAULT_VERBOSITY=1

Reference: AM_DEFAULT_VERBOSITY

Note: I added this answer since V=1 did not work for me.

Cosmopolite

Answer 8

• In case you want to see all commands (including the compiled ones) of the default target run:

make --always-make --dry-run
make -Bn

• show commands executed the next run of make:

make --dry-run
make -n

You are free to choose a target other than the default in this example.

Bray