Merge branch 'maint'
[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 exit_if_skipped_commits () {
283         _tried=$1
284         _bad=$2
285         if test -n "$_tried" ; then
286                 echo "There are only 'skip'ped commit left to test."
287                 echo "The first bad commit could be any of:"
288                 echo "$_tried" | tr '[|]' '[\012]'
289                 test -n "$_bad" && echo "$_bad"
290                 echo "We cannot bisect more!"
291                 exit 2
292         fi
293 }
294
295 bisect_checkout() {
296         _rev="$1"
297         _msg="$2"
298         echo "Bisecting: $_msg"
299         mark_expected_rev "$_rev"
300         git checkout -q "$_rev" -- || exit
301         git show-branch "$_rev"
302 }
303
304 is_among() {
305         _rev="$1"
306         _list="$2"
307         case "$_list" in *$_rev*) return 0 ;; esac
308         return 1
309 }
310
311 handle_bad_merge_base() {
312         _badmb="$1"
313         _good="$2"
314         if is_expected_rev "$_badmb"; then
315                 cat >&2 <<EOF
316 The merge base $_badmb is bad.
317 This means the bug has been fixed between $_badmb and [$_good].
318 EOF
319                 exit 3
320         else
321                 cat >&2 <<EOF
322 Some good revs are not ancestor of the bad rev.
323 git bisect cannot work properly in this case.
324 Maybe you mistake good and bad revs?
325 EOF
326                 exit 1
327         fi
328 }
329
330 handle_skipped_merge_base() {
331         _mb="$1"
332         _bad="$2"
333         _good="$3"
334         cat >&2 <<EOF
335 Warning: the merge base between $_bad and [$_good] must be skipped.
336 So we cannot be sure the first bad commit is between $_mb and $_bad.
337 We continue anyway.
338 EOF
339 }
340
341 #
342 # "check_merge_bases" checks that merge bases are not "bad".
343 #
344 # - If one is "good", that's good, we have nothing to do.
345 # - If one is "bad", it means the user assumed something wrong
346 # and we must exit.
347 # - If one is "skipped", we can't know but we should warn.
348 # - If we don't know, we should check it out and ask the user to test.
349 #
350 # In the last case we will return 1, and otherwise 0.
351 #
352 check_merge_bases() {
353         _bad="$1"
354         _good="$2"
355         _skip="$3"
356         for _mb in $(git merge-base --all $_bad $_good)
357         do
358                 if is_among "$_mb" "$_good"; then
359                         continue
360                 elif test "$_mb" = "$_bad"; then
361                         handle_bad_merge_base "$_bad" "$_good"
362                 elif is_among "$_mb" "$_skip"; then
363                         handle_skipped_merge_base "$_mb" "$_bad" "$_good"
364                 else
365                         bisect_checkout "$_mb" "a merge base must be tested"
366                         return 1
367                 fi
368         done
369         return 0
370 }
371
372 #
373 # "check_good_are_ancestors_of_bad" checks that all "good" revs are
374 # ancestor of the "bad" rev.
375 #
376 # If that's not the case, we need to check the merge bases.
377 # If a merge base must be tested by the user we return 1 and
378 # otherwise 0.
379 #
380 check_good_are_ancestors_of_bad() {
381         test -f "$GIT_DIR/BISECT_ANCESTORS_OK" &&
382                 return
383
384         _bad="$1"
385         _good=$(echo $2 | sed -e 's/\^//g')
386         _skip="$3"
387
388         # Bisecting with no good rev is ok
389         test -z "$_good" && return
390
391         _side=$(git rev-list $_good ^$_bad)
392         if test -n "$_side"; then
393                 # Return if a checkout was done
394                 check_merge_bases "$_bad" "$_good" "$_skip" || return
395         fi
396
397         : > "$GIT_DIR/BISECT_ANCESTORS_OK"
398
399         return 0
400 }
401
402 bisect_next() {
403         case "$#" in 0) ;; *) usage ;; esac
404         bisect_autostart
405         bisect_next_check good
406
407         # Get bad, good and skipped revs
408         bad=$(git rev-parse --verify refs/bisect/bad) &&
409         good=$(git for-each-ref --format='^%(objectname)' \
410                 "refs/bisect/good-*" | tr '\012' ' ') &&
411         skip=$(git for-each-ref --format='%(objectname)' \
412                 "refs/bisect/skip-*" | tr '\012' ' ') || exit
413
414         # Maybe some merge bases must be tested first
415         check_good_are_ancestors_of_bad "$bad" "$good" "$skip"
416         # Return now if a checkout has already been done
417         test "$?" -eq "1" && return
418
419         # Get bisection information
420         eval=$(eval "git bisect--helper --next-vars") &&
421         eval "$eval" || exit
422
423         if [ -z "$bisect_rev" ]; then
424                 # We should exit here only if the "bad"
425                 # commit is also a "skip" commit (see above).
426                 exit_if_skipped_commits "$bisect_tried"
427                 echo "$bad was both good and bad"
428                 exit 1
429         fi
430         if [ "$bisect_rev" = "$bad" ]; then
431                 exit_if_skipped_commits "$bisect_tried" "$bad"
432                 echo "$bisect_rev is first bad commit"
433                 git diff-tree --pretty $bisect_rev
434                 exit 0
435         fi
436
437         bisect_checkout "$bisect_rev" "$bisect_nr revisions left to test after this (roughly $bisect_steps steps)"
438 }
439
440 bisect_visualize() {
441         bisect_next_check fail
442
443         if test $# = 0
444         then
445                 case "${DISPLAY+set}${SESSIONNAME+set}${MSYSTEM+set}${SECURITYSESSIONID+set}" in
446                 '')     set git log ;;
447                 set*)   set gitk ;;
448                 esac
449         else
450                 case "$1" in
451                 git*|tig) ;;
452                 -*)     set git log "$@" ;;
453                 *)      set git "$@" ;;
454                 esac
455         fi
456
457         not=$(git for-each-ref --format='%(refname)' "refs/bisect/good-*")
458         eval '"$@"' refs/bisect/bad --not $not -- $(cat "$GIT_DIR/BISECT_NAMES")
459 }
460
461 bisect_reset() {
462         test -s "$GIT_DIR/BISECT_START" || {
463                 echo "We are not bisecting."
464                 return
465         }
466         case "$#" in
467         0) branch=$(cat "$GIT_DIR/BISECT_START") ;;
468         1) git show-ref --verify --quiet -- "refs/heads/$1" ||
469                die "$1 does not seem to be a valid branch"
470            branch="$1" ;;
471         *)
472             usage ;;
473         esac
474         git checkout "$branch" -- && bisect_clean_state
475 }
476
477 bisect_clean_state() {
478         # There may be some refs packed during bisection.
479         git for-each-ref --format='%(refname) %(objectname)' refs/bisect/\* |
480         while read ref hash
481         do
482                 git update-ref -d $ref $hash || exit
483         done
484         rm -f "$GIT_DIR/BISECT_EXPECTED_REV" &&
485         rm -f "$GIT_DIR/BISECT_ANCESTORS_OK" &&
486         rm -f "$GIT_DIR/BISECT_LOG" &&
487         rm -f "$GIT_DIR/BISECT_NAMES" &&
488         rm -f "$GIT_DIR/BISECT_RUN" &&
489         # Cleanup head-name if it got left by an old version of git-bisect
490         rm -f "$GIT_DIR/head-name" &&
491
492         rm -f "$GIT_DIR/BISECT_START"
493 }
494
495 bisect_replay () {
496         test -r "$1" || die "cannot read $1 for replaying"
497         bisect_reset
498         while read git bisect command rev
499         do
500                 test "$git $bisect" = "git bisect" -o "$git" = "git-bisect" || continue
501                 if test "$git" = "git-bisect"; then
502                         rev="$command"
503                         command="$bisect"
504                 fi
505                 case "$command" in
506                 start)
507                         cmd="bisect_start $rev"
508                         eval "$cmd" ;;
509                 good|bad|skip)
510                         bisect_write "$command" "$rev" ;;
511                 *)
512                         die "?? what are you talking about?" ;;
513                 esac
514         done <"$1"
515         bisect_auto_next
516 }
517
518 bisect_run () {
519     bisect_next_check fail
520
521     while true
522     do
523       echo "running $@"
524       "$@"
525       res=$?
526
527       # Check for really bad run error.
528       if [ $res -lt 0 -o $res -ge 128 ]; then
529           echo >&2 "bisect run failed:"
530           echo >&2 "exit code $res from '$@' is < 0 or >= 128"
531           exit $res
532       fi
533
534       # Find current state depending on run success or failure.
535       # A special exit code of 125 means cannot test.
536       if [ $res -eq 125 ]; then
537           state='skip'
538       elif [ $res -gt 0 ]; then
539           state='bad'
540       else
541           state='good'
542       fi
543
544       # We have to use a subshell because "bisect_state" can exit.
545       ( bisect_state $state > "$GIT_DIR/BISECT_RUN" )
546       res=$?
547
548       cat "$GIT_DIR/BISECT_RUN"
549
550       if grep "first bad commit could be any of" "$GIT_DIR/BISECT_RUN" \
551                 > /dev/null; then
552           echo >&2 "bisect run cannot continue any more"
553           exit $res
554       fi
555
556       if [ $res -ne 0 ]; then
557           echo >&2 "bisect run failed:"
558           echo >&2 "'bisect_state $state' exited with error code $res"
559           exit $res
560       fi
561
562       if grep "is first bad commit" "$GIT_DIR/BISECT_RUN" > /dev/null; then
563           echo "bisect run success"
564           exit 0;
565       fi
566
567     done
568 }
569
570
571 case "$#" in
572 0)
573     usage ;;
574 *)
575     cmd="$1"
576     shift
577     case "$cmd" in
578     help)
579         git bisect -h ;;
580     start)
581         bisect_start "$@" ;;
582     bad|good)
583         bisect_state "$cmd" "$@" ;;
584     skip)
585         bisect_skip "$@" ;;
586     next)
587         # Not sure we want "next" at the UI level anymore.
588         bisect_next "$@" ;;
589     visualize|view)
590         bisect_visualize "$@" ;;
591     reset)
592         bisect_reset "$@" ;;
593     replay)
594         bisect_replay "$@" ;;
595     log)
596         cat "$GIT_DIR/BISECT_LOG" ;;
597     run)
598         bisect_run "$@" ;;
599     *)
600         usage ;;
601     esac
602 esac