•  20-09-2019
  •  | 
  •  

Pergunta

Existe uma maneira de linha de comando em make Para descobrir qual dos pré -requisitos de um alvo não é atualizado?

Foi útil?

Solução 

make -d

deve dar a você mais do que informações suficientes para depurar seu makefile.

Esteja avisado: levará algum tempo e esforço para analisar a saída, mas carregar a saída em seu editor favorito e fazer pesquisas ajudará muito.

Você pode reduzir bastante a quantidade de saída de depuração se especificar o alvo específico em que está interessado. Portanto, se você estiver interessado apenas no dodgy alvo, em vez de apenas make -d O que pode fazer cem coisas diferentes, tente:

make clean
make -d dodgy

(Supondo que você tenha um clean alvo, é claro).

o make --debug é idêntico a make -d Mas você também pode especificar:

make --debug=FLAGS

onde as bandeiras podem estar:

  • a Para todos os depuração (o mesmo que make -d e make --debug).
  • b para depuração básica.
  • v Para uma depuração básica um pouco mais detalhada.
  • i para regras implícitas.
  • j Para informações de invocação.
  • m Para obter informações durante os remakes makefile.

Parece make --debug=b é a melhor opção para o que você precisa, como mostrado na seguinte transcrição:

pax@paxbox> cat makefile
c:a b
    touch c

pax@paxbox> touch a b ; make
touch c

pax@paxbox> make
make: 'c' is up to date.

pax@paxbox> touch a ; make --debug=b
GNU Make 3.81
Copyright (C) 2006  Free Software Foundation, Inc. Blah, blah, blah.
Reading makefiles...
Updating goal targets....
 Prerequisite 'a' is newer than target 'c'.
Must remake target 'c'.
touch c
Successfully remade target file 'c'.

Outras dicas

Você está procurando "corrida a seco" da Make? Ele imprimirá o que faz, sem realmente fazer isso, permitindo que você veja o que acontece.

A bandeira é -n, use como make -n.

Também há GNU fazer com um depurador e melhor saída de rastreamento/erro: Refazer

Screencast: http://showmedo.com/videotutorials/video?name=linuxbernsteinmakedebug1&fromesseriesid=40

Sua pergunta é um pouco pouco clara. Se você quiser ver quais arquivos pré -requisitos não foram modificados recentemente, use LS -l para ver o tempo de modificação. Se você quiser ver o que fazer está fazendo, tente o seguinte:

# Make will announce when it is making this target, and why.
sometarget: preq1 preq2 preq3
    @echo making $@
    @echo The following preqs are newer than the target: $?
    do_things

O que eu costumo fazer é usar -d, como disseram os respondentes anteriores.

Eu também:

  1. Use -p para imprimir o banco de dados, para ver quais regras foram criadas. Isso é útil se você tiver segundas regras de expansão e estiver criando regras em tempo real, especialmente a marca recursiva.
  2. Função de uso pesado de $ (info).
  3. Use as dicas e truques descritos neste artigo Drdobbs Debugando makefiles

Abaixo está algum código que estou usando para imprimir valores:

define pv
$(info $(1) [$(origin $(1))] : >|$($(1))|<)
endef

define pva
$(foreach t,$(1),$(call pv,$(t)))
endef

define itemizer
$(foreach t,$($(1)),$(info $(t)))
endef

Poucas vezes eu também usei isto (antigo, mas ainda funcionando) Interactive Make Depurger, de John Graham-Cumming

Estou usando o Make GNU Make Modelos para definir as regras de criação por destino;

Os modelos são como macros que escrevem regras, são explicadas aqui https://www.gnu.org/software/make/manual/html_node/eval-function.html

Esse recurso é útil quando você possui um sistema de criação que inclui um Makefile central para gerar todas as regras por tipo de projeto; Se diz para fazer uma biblioteca compartilhada, ele escreve as regras para compilar uma biblioteca compartilhada; etc. para outros tipos de alvos.

Neste exemplo: se você adicionar show_rules = 1 à linha de comando Make, ele também mostrará o texto das regras geradas pelo programa_target_setup_template; junto com a geração das próprias regras (com avaliação).

 # this one defines the target for real
 $(foreach prog, $(TARGETS), $(eval $(call PROGRAM_target_setup_template,$(prog))))

 ifneq "$(SHOW_RULES)" ""
 $(foreach prog, $(TARGETS), $(info $(call PROGRAM_target_setup_template,$(prog))))
 endif
  • $ (ligue ...) chama o modelo
  • $ (info ...) imprime o resultado da substituição do modelo; (Eval teria invocado a análise da saída e adição ao arquivo atual de fabricação)

Mais sobre meus arquivos make aqui: http://mosermichael.github.io/cstuff/all/projects/2011/06/17/make-system.html

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top