Merge branch 'jc/maint-1.6.0-split-diff-metainfo' into jc/maint-split-diff-metainfo
[git] / git-bisect.sh
1 #!/bin/sh
2
3 USAGE='[help|start|bad|good|skip|next|reset|visualize|replay|log|run]'
4 LONG_USAGE='git bisect help
5         print this long help message.
6 git bisect start [<bad> [<good>...]] [--] [<pathspec>...]
7         reset bisect state and start bisection.
8 git bisect bad [<rev>]
9         mark <rev> a known-bad revision.
10 git bisect good [<rev>...]
11         mark <rev>... known-good revisions.
12 git bisect skip [(<rev>|<range>)...]
13         mark <rev>... untestable revisions.
14 git bisect next
15         find next bisection to test and check it out.
16 git bisect reset [<branch>]
17         finish bisection search and go back to branch.
18 git bisect visualize
19         show bisect status in gitk.
20 git bisect replay <logfile>
21         replay bisection log.
22 git bisect log
23         show bisect log.
24 git bisect run <cmd>...
25         use <cmd>... to automatically bisect.
26
27 Please use "git help bisect" to get the full man page.'
28
29 OPTIONS_SPEC=
30 . git-sh-setup
31 require_work_tree
32
33 _x40='[0-9a-f][0-9a-f][0-9a-f][0-9a-f][0-9a-f]'
34 _x40="$_x40$_x40$_x40$_x40$_x40$_x40$_x40$_x40"
35
36 sq() {
37         @@PERL@@ -e '
38                 for (@ARGV) {
39                         s/'\''/'\'\\\\\'\''/g;
40                         print " '\''$_'\''";
41                 }
42                 print "\n";
43         ' "$@"
44 }
45
46 bisect_autostart() {
47         test -s "$GIT_DIR/BISECT_START" || {
48                 echo >&2 'You need to start by "git bisect start"'
49                 if test -t 0
50                 then
51                         echo >&2 -n 'Do you want me to do it for you [Y/n]? '
52                         read yesno
53                         case "$yesno" in
54                         [Nn]*)
55                                 exit ;;
56                         esac
57                         bisect_start
58                 else
59                         exit 1
60                 fi
61         }
62 }
63
64 bisect_start() {
65         #
66         # Verify HEAD.
67         #
68         head=$(GIT_DIR="$GIT_DIR" git symbolic-ref -q HEAD) ||
69         head=$(GIT_DIR="$GIT_DIR" git rev-parse --verify HEAD) ||
70         die "Bad HEAD - I need a HEAD"
71
72         #
73         # Check if we are bisecting.
74         #
75         start_head=''
76         if test -s "$GIT_DIR/BISECT_START"
77         then
78                 # Reset to the rev from where we started.
79                 start_head=$(cat "$GIT_DIR/BISECT_START")
80                 git checkout "$start_head" || exit
81         else
82                 # Get rev from where we start.
83                 case "$head" in
84                 refs/heads/*|$_x40)
85                         # This error message should only be triggered by
86                         # cogito usage, and cogito users should understand
87                         # it relates to cg-seek.
88                         [ -s "$GIT_DIR/head-name" ] &&
89                                 die "won't bisect on seeked tree"
90                         start_head="${head#refs/heads/}"
91                         ;;
92                 *)
93                         die "Bad HEAD - strange symbolic ref"
94                         ;;
95                 esac
96         fi
97
98         #
99         # Get rid of any old bisect state.
100         #
101         bisect_clean_state || exit
102
103         #
104         # Check for one bad and then some good revisions.
105         #
106         has_double_dash=0
107         for arg; do
108             case "$arg" in --) has_double_dash=1; break ;; esac
109         done
110         orig_args=$(sq "$@")
111         bad_seen=0
112         eval=''
113         while [ $# -gt 0 ]; do
114             arg="$1"
115             case "$arg" in
116             --)
117                 shift
118                 break
119                 ;;
120             *)
121                 rev=$(git rev-parse -q --verify "$arg^{commit}") || {
122                     test $has_double_dash -eq 1 &&
123                         die "'$arg' does not appear to be a valid revision"
124                     break
125                 }
126                 case $bad_seen in
127                 0) state='bad' ; bad_seen=1 ;;
128                 *) state='good' ;;
129                 esac
130                 eval="$eval bisect_write '$state' '$rev' 'nolog'; "
131                 shift
132                 ;;
133             esac
134         done
135
136         #
137         # Change state.
138         # In case of mistaken revs or checkout error, or signals received,
139         # "bisect_auto_next" below may exit or misbehave.
140         # We have to trap this to be able to clean up using
141         # "bisect_clean_state".
142         #
143         trap 'bisect_clean_state' 0
144         trap 'exit 255' 1 2 3 15
145
146         #
147         # Write new start state.
148         #
149         echo "$start_head" >"$GIT_DIR/BISECT_START" &&
150         sq "$@" >"$GIT_DIR/BISECT_NAMES" &&
151         eval "$eval" &&
152         echo "git bisect start$orig_args" >>"$GIT_DIR/BISECT_LOG" || exit
153         #
154         # Check if we can proceed to the next bisect state.
155         #
156         bisect_auto_next
157
158         trap '-' 0
159 }
160
161 bisect_write() {
162         state="$1"
163         rev="$2"
164         nolog="$3"
165         case "$state" in
166                 bad)            tag="$state" ;;
167                 good|skip)      tag="$state"-"$rev" ;;
168                 *)              die "Bad bisect_write argument: $state" ;;
169         esac
170         git update-ref "refs/bisect/$tag" "$rev" || exit
171         echo "# $state: $(git show-branch $rev)" >>"$GIT_DIR/BISECT_LOG"
172         test -n "$nolog" || echo "git bisect $state $rev" >>"$GIT_DIR/BISECT_LOG"
173 }
174
175 is_expected_rev() {
176         test -f "$GIT_DIR/BISECT_EXPECTED_REV" &&
177         test "$1" = $(cat "$GIT_DIR/BISECT_EXPECTED_REV")
178 }
179
180 mark_expected_rev() {
181         echo "$1" > "$GIT_DIR/BISECT_EXPECTED_REV"
182 }
183
184 check_expected_revs() {
185         for _rev in "$@"; do
186                 if ! is_expected_rev "$_rev"; then
187                         rm -f "$GIT_DIR/BISECT_ANCESTORS_OK"
188                         rm -f "$GIT_DIR/BISECT_EXPECTED_REV"
189                         return
190                 fi
191         done
192 }
193
194 bisect_skip() {
195         all=''
196         for arg in "$@"
197         do
198             case "$arg" in
199             *..*)
200                 revs=$(git rev-list "$arg") || die "Bad rev input: $arg" ;;
201             *)
202                 revs=$(sq "$arg") ;;
203             esac
204             all="$all $revs"
205         done
206         eval bisect_state 'skip' $all
207 }
208
209 bisect_state() {
210         bisect_autostart
211         state=$1
212         case "$#,$state" in
213         0,*)
214                 die "Please call 'bisect_state' with at least one argument." ;;
215         1,bad|1,good|1,skip)
216                 rev=$(git rev-parse --verify HEAD) ||
217                         die "Bad rev input: HEAD"
218                 bisect_write "$state" "$rev"
219                 check_expected_revs "$rev" ;;
220         2,bad|*,good|*,skip)
221                 shift
222                 eval=''
223                 for rev in "$@"
224                 do
225                         sha=$(git rev-parse --verify "$rev^{commit}") ||
226                                 die "Bad rev input: $rev"
227                         eval="$eval bisect_write '$state' '$sha'; "
228                 done
229                 eval "$eval"
230                 check_expected_revs "$@" ;;
231         *,bad)
232                 die "'git bisect bad' can take only one argument." ;;
233         *)
234                 usage ;;
235         esac
236         bisect_auto_next
237 }
238
239 bisect_next_check() {
240         missing_good= missing_bad=
241         git show-ref -q --verify refs/bisect/bad || missing_bad=t
242         test -n "$(git for-each-ref "refs/bisect/good-*")" || missing_good=t
243
244         case "$missing_good,$missing_bad,$1" in
245         ,,*)
246                 : have both good and bad - ok
247                 ;;
248         *,)
249                 # do not have both but not asked to fail - just report.
250                 false
251                 ;;
252         t,,good)
253                 # have bad but not good.  we could bisect although
254                 # this is less optimum.
255                 echo >&2 'Warning: bisecting only with a bad commit.'
256                 if test -t 0
257                 then
258                         printf >&2 'Are you sure [Y/n]? '
259                         read yesno
260                         case "$yesno" in [Nn]*) exit 1 ;; esac
261                 fi
262                 : bisect without good...
263                 ;;
264         *)
265                 THEN=''
266                 test -s "$GIT_DIR/BISECT_START" || {
267                         echo >&2 'You need to start by "git bisect start".'
268                         THEN='then '
269                 }
270                 echo >&2 'You '$THEN'need to give me at least one good' \
271                         'and one bad revisions.'
272                 echo >&2 '(You can use "git bisect bad" and' \
273                         '"git bisect good" for that.)'
274                 exit 1 ;;
275         esac
276 }
277
278 bisect_auto_next() {
279         bisect_next_check && bisect_next || :
280 }
281
282 filter_skipped() {
283         _eval="$1"
284         _skip="$2"
285
286         if [ -z "$_skip" ]; then
287                 eval "$_eval"
288                 return
289         fi
290
291         # Let's parse the output of:
292         # "git rev-list --bisect-vars --bisect-all ..."
293         eval "$_eval" | while read hash line
294         do
295                 case "$VARS,$FOUND,$TRIED,$hash" in
296                         # We display some vars.
297                         1,*,*,*) echo "$hash $line" ;;
298
299                         # Split line.
300                         ,*,*,---*) ;;
301
302                         # We had nothing to search.
303                         ,,,bisect_rev*)
304                                 echo "bisect_rev="
305                                 VARS=1
306                                 ;;
307
308                         # We did not find a good bisect rev.
309                         # This should happen only if the "bad"
310                         # commit is also a "skip" commit.
311                         ,,*,bisect_rev*)
312                                 echo "bisect_rev=$TRIED"
313                                 VARS=1
314                                 ;;
315
316                         # We are searching.
317                         ,,*,*)
318                                 TRIED="${TRIED:+$TRIED|}$hash"
319                                 case "$_skip" in
320                                 *$hash*) ;;
321                                 *)
322                                         echo "bisect_rev=$hash"
323                                         echo "bisect_tried=\"$TRIED\""
324                                         FOUND=1
325                                         ;;
326                                 esac
327                                 ;;
328
329                         # We have already found a rev to be tested.
330                         ,1,*,bisect_rev*) VARS=1 ;;
331                         ,1,*,*) ;;
332
333                         # ???
334                         *) die "filter_skipped error " \
335                             "VARS: '$VARS' " \
336                             "FOUND: '$FOUND' " \
337                             "TRIED: '$TRIED' " \
338                             "hash: '$hash' " \
339                             "line: '$line'"
340                         ;;
341                 esac
342         done
343 }
344
345 exit_if_skipped_commits () {
346         _tried=$1
347         if expr "$_tried" : ".*[|].*" > /dev/null ; then
348                 echo "There are only 'skip'ped commit left to test."
349                 echo "The first bad commit could be any of:"
350                 echo "$_tried" | tr '[|]' '[\012]'
351                 echo "We cannot bisect more!"
352                 exit 2
353         fi
354 }
355
356 bisect_checkout() {
357         _rev="$1"
358         _msg="$2"
359         echo "Bisecting: $_msg"
360         mark_expected_rev "$_rev"
361         git checkout -q "$_rev" || exit
362         git show-branch "$_rev"
363 }
364
365 is_among() {
366         _rev="$1"
367         _list="$2"
368         case "$_list" in *$_rev*) return 0 ;; esac
369         return 1
370 }
371
372 handle_bad_merge_base() {
373         _badmb="$1"
374         _good="$2"
375         if is_expected_rev "$_badmb"; then
376                 cat >&2 <<EOF
377 The merge base $_badmb is bad.
378 This means the bug has been fixed between $_badmb and [$_good].
379 EOF
380                 exit 3
381         else
382                 cat >&2 <<EOF
383 Some good revs are not ancestor of the bad rev.
384 git bisect cannot work properly in this case.
385 Maybe you mistake good and bad revs?
386 EOF
387                 exit 1
388         fi
389 }
390
391 handle_skipped_merge_base() {
392         _mb="$1"
393         _bad="$2"
394         _good="$3"
395         cat >&2 <<EOF
396 Warning: the merge base between $_bad and [$_good] must be skipped.
397 So we cannot be sure the first bad commit is between $_mb and $_bad.
398 We continue anyway.
399 EOF
400 }
401
402 #
403 # "check_merge_bases" checks that merge bases are not "bad".
404 #
405 # - If one is "good", that's good, we have nothing to do.
406 # - If one is "bad", it means the user assumed something wrong
407 # and we must exit.
408 # - If one is "skipped", we can't know but we should warn.
409 # - If we don't know, we should check it out and ask the user to test.
410 #
411 # In the last case we will return 1, and otherwise 0.
412 #
413 check_merge_bases() {
414         _bad="$1"
415         _good="$2"
416         _skip="$3"
417         for _mb in $(git merge-base --all $_bad $_good)
418         do
419                 if is_among "$_mb" "$_good"; then
420                         continue
421                 elif test "$_mb" = "$_bad"; then
422                         handle_bad_merge_base "$_bad" "$_good"
423                 elif is_among "$_mb" "$_skip"; then
424                         handle_skipped_merge_base "$_mb" "$_bad" "$_good"
425                 else
426                         bisect_checkout "$_mb" "a merge base must be tested"
427                         return 1
428                 fi
429         done
430         return 0
431 }
432
433 #
434 # "check_good_are_ancestors_of_bad" checks that all "good" revs are
435 # ancestor of the "bad" rev.
436 #
437 # If that's not the case, we need to check the merge bases.
438 # If a merge base must be tested by the user we return 1 and
439 # otherwise 0.
440 #
441 check_good_are_ancestors_of_bad() {
442         test -f "$GIT_DIR/BISECT_ANCESTORS_OK" &&
443                 return
444
445         _bad="$1"
446         _good=$(echo $2 | sed -e 's/\^//g')
447         _skip="$3"
448
449         # Bisecting with no good rev is ok
450         test -z "$_good" && return
451
452         _side=$(git rev-list $_good ^$_bad)
453         if test -n "$_side"; then
454                 # Return if a checkout was done
455                 check_merge_bases "$_bad" "$_good" "$_skip" || return
456         fi
457
458         : > "$GIT_DIR/BISECT_ANCESTORS_OK"
459
460         return 0
461 }
462
463 bisect_next() {
464         case "$#" in 0) ;; *) usage ;; esac
465         bisect_autostart
466         bisect_next_check good
467
468         # Get bad, good and skipped revs
469         bad=$(git rev-parse --verify refs/bisect/bad) &&
470         good=$(git for-each-ref --format='^%(objectname)' \
471                 "refs/bisect/good-*" | tr '\012' ' ') &&
472         skip=$(git for-each-ref --format='%(objectname)' \
473                 "refs/bisect/skip-*" | tr '\012' ' ') || exit
474
475         # Maybe some merge bases must be tested first
476         check_good_are_ancestors_of_bad "$bad" "$good" "$skip"
477         # Return now if a checkout has already been done
478         test "$?" -eq "1" && return
479
480         # Get bisection information
481         BISECT_OPT=''
482         test -n "$skip" && BISECT_OPT='--bisect-all'
483         eval="git rev-list --bisect-vars $BISECT_OPT $good $bad --" &&
484         eval="$eval $(cat "$GIT_DIR/BISECT_NAMES")" &&
485         eval=$(filter_skipped "$eval" "$skip") &&
486         eval "$eval" || exit
487
488         if [ -z "$bisect_rev" ]; then
489                 echo "$bad was both good and bad"
490                 exit 1
491         fi
492         if [ "$bisect_rev" = "$bad" ]; then
493                 exit_if_skipped_commits "$bisect_tried"
494                 echo "$bisect_rev is first bad commit"
495                 git diff-tree --pretty $bisect_rev
496                 exit 0
497         fi
498
499         # We should exit here only if the "bad"
500         # commit is also a "skip" commit (see above).
501         exit_if_skipped_commits "$bisect_rev"
502
503         bisect_checkout "$bisect_rev" "$bisect_nr revisions left to test after this"
504 }
505
506 bisect_visualize() {
507         bisect_next_check fail
508
509         if test $# = 0
510         then
511                 case "${DISPLAY+set}${SESSIONNAME+set}${MSYSTEM+set}${SECURITYSESSIONID+set}" in
512                 '')     set git log ;;
513                 set*)   set gitk ;;
514                 esac
515         else
516                 case "$1" in
517                 git*|tig) ;;
518                 -*)     set git log "$@" ;;
519                 *)      set git "$@" ;;
520                 esac
521         fi
522
523         not=$(git for-each-ref --format='%(refname)' "refs/bisect/good-*")
524         eval '"$@"' refs/bisect/bad --not $not -- $(cat "$GIT_DIR/BISECT_NAMES")
525 }
526
527 bisect_reset() {
528         test -s "$GIT_DIR/BISECT_START" || {
529                 echo "We are not bisecting."
530                 return
531         }
532         case "$#" in
533         0) branch=$(cat "$GIT_DIR/BISECT_START") ;;
534         1) git show-ref --verify --quiet -- "refs/heads/$1" ||
535                die "$1 does not seem to be a valid branch"
536            branch="$1" ;;
537         *)
538             usage ;;
539         esac
540         git checkout "$branch" && bisect_clean_state
541 }
542
543 bisect_clean_state() {
544         # There may be some refs packed during bisection.
545         git for-each-ref --format='%(refname) %(objectname)' refs/bisect/\* |
546         while read ref hash
547         do
548                 git update-ref -d $ref $hash || exit
549         done
550         rm -f "$GIT_DIR/BISECT_EXPECTED_REV" &&
551         rm -f "$GIT_DIR/BISECT_ANCESTORS_OK" &&
552         rm -f "$GIT_DIR/BISECT_LOG" &&
553         rm -f "$GIT_DIR/BISECT_NAMES" &&
554         rm -f "$GIT_DIR/BISECT_RUN" &&
555         # Cleanup head-name if it got left by an old version of git-bisect
556         rm -f "$GIT_DIR/head-name" &&
557
558         rm -f "$GIT_DIR/BISECT_START"
559 }
560
561 bisect_replay () {
562         test -r "$1" || die "cannot read $1 for replaying"
563         bisect_reset
564         while read git bisect command rev
565         do
566                 test "$git $bisect" = "git bisect" -o "$git" = "git-bisect" || continue
567                 if test "$git" = "git-bisect"; then
568                         rev="$command"
569                         command="$bisect"
570                 fi
571                 case "$command" in
572                 start)
573                         cmd="bisect_start $rev"
574                         eval "$cmd" ;;
575                 good|bad|skip)
576                         bisect_write "$command" "$rev" ;;
577                 *)
578                         die "?? what are you talking about?" ;;
579                 esac
580         done <"$1"
581         bisect_auto_next
582 }
583
584 bisect_run () {
585     bisect_next_check fail
586
587     while true
588     do
589       echo "running $@"
590       "$@"
591       res=$?
592
593       # Check for really bad run error.
594       if [ $res -lt 0 -o $res -ge 128 ]; then
595           echo >&2 "bisect run failed:"
596           echo >&2 "exit code $res from '$@' is < 0 or >= 128"
597           exit $res
598       fi
599
600       # Find current state depending on run success or failure.
601       # A special exit code of 125 means cannot test.
602       if [ $res -eq 125 ]; then
603           state='skip'
604       elif [ $res -gt 0 ]; then
605           state='bad'
606       else
607           state='good'
608       fi
609
610       # We have to use a subshell because "bisect_state" can exit.
611       ( bisect_state $state > "$GIT_DIR/BISECT_RUN" )
612       res=$?
613
614       cat "$GIT_DIR/BISECT_RUN"
615
616       if grep "first bad commit could be any of" "$GIT_DIR/BISECT_RUN" \
617                 > /dev/null; then
618           echo >&2 "bisect run cannot continue any more"
619           exit $res
620       fi
621
622       if [ $res -ne 0 ]; then
623           echo >&2 "bisect run failed:"
624           echo >&2 "'bisect_state $state' exited with error code $res"
625           exit $res
626       fi
627
628       if grep "is first bad commit" "$GIT_DIR/BISECT_RUN" > /dev/null; then
629           echo "bisect run success"
630           exit 0;
631       fi
632
633     done
634 }
635
636
637 case "$#" in
638 0)
639     usage ;;
640 *)
641     cmd="$1"
642     shift
643     case "$cmd" in
644     help)
645         git bisect -h ;;
646     start)
647         bisect_start "$@" ;;
648     bad|good)
649         bisect_state "$cmd" "$@" ;;
650     skip)
651         bisect_skip "$@" ;;
652     next)
653         # Not sure we want "next" at the UI level anymore.
654         bisect_next "$@" ;;
655     visualize|view)
656         bisect_visualize "$@" ;;
657     reset)
658         bisect_reset "$@" ;;
659     replay)
660         bisect_replay "$@" ;;
661     log)
662         cat "$GIT_DIR/BISECT_LOG" ;;
663     run)
664         bisect_run "$@" ;;
665     *)
666         usage ;;
667     esac
668 esac