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.
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.
15 find next bisection to test and check it out.
16 git bisect reset [<branch>]
17 finish bisection search and go back to branch.
19 show bisect status in gitk.
20 git bisect replay <logfile>
24 git bisect run <cmd>...
25 use <cmd>... to automatically bisect.
27 Please use "git help bisect" to get the full man page.'
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"
39 s/'\''/'\'\\\\\'\''/g;
47 test -s "$GIT_DIR/BISECT_START" ||
{
48 echo >&2 'You need to start by "git bisect start"'
51 echo >&2 -n 'Do you want me to do it for you [Y/n]? '
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"
73 # Check if we are bisecting.
76 if test -s "$GIT_DIR/BISECT_START"
78 # Reset to the rev from where we started.
79 start_head
=$
(cat "$GIT_DIR/BISECT_START")
80 git checkout
"$start_head" ||
exit
82 # Get rev from where we start.
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/}"
93 die
"Bad HEAD - strange symbolic ref"
99 # Get rid of any old bisect state.
101 bisect_clean_state ||
exit
104 # Check for one bad and then some good revisions.
108 case "$arg" in --) has_double_dash
=1; break ;; esac
113 while [ $# -gt 0 ]; do
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"
127 0) state
='bad' ; bad_seen
=1 ;;
130 eval="$eval bisect_write '$state' '$rev' 'nolog'; "
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".
143 trap 'bisect_clean_state' 0
144 trap 'exit 255' 1 2 3 15
147 # Write new start state.
149 echo "$start_head" >"$GIT_DIR/BISECT_START" &&
150 sq "$@" >"$GIT_DIR/BISECT_NAMES" &&
152 echo "git bisect start$orig_args" >>"$GIT_DIR/BISECT_LOG" ||
exit
154 # Check if we can proceed to the next bisect state.
167 good|skip
) tag
="$state"-"$rev" ;;
168 *) die
"Bad bisect_write argument: $state" ;;
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"
176 test -f "$GIT_DIR/BISECT_EXPECTED_REV" &&
177 test "$1" = $
(cat "$GIT_DIR/BISECT_EXPECTED_REV")
180 mark_expected_rev
() {
181 echo "$1" > "$GIT_DIR/BISECT_EXPECTED_REV"
184 check_expected_revs
() {
186 if ! is_expected_rev
"$_rev"; then
187 rm -f "$GIT_DIR/BISECT_ANCESTORS_OK"
188 rm -f "$GIT_DIR/BISECT_EXPECTED_REV"
200 revs
=$
(git rev-list
"$arg") || die
"Bad rev input: $arg" ;;
206 eval bisect_state
'skip' $all
214 die
"Please call 'bisect_state' with at least one argument." ;;
216 rev=$
(git rev-parse
--verify HEAD
) ||
217 die
"Bad rev input: HEAD"
218 bisect_write
"$state" "$rev"
219 check_expected_revs
"$rev" ;;
225 sha
=$
(git rev-parse
--verify "$rev^{commit}") ||
226 die
"Bad rev input: $rev"
227 eval="$eval bisect_write '$state' '$sha'; "
230 check_expected_revs
"$@" ;;
232 die
"'git bisect bad' can take only one argument." ;;
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
244 case "$missing_good,$missing_bad,$1" in
246 : have both good and bad
- ok
249 # do not have both but not asked to fail - just report.
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.'
258 printf >&2 'Are you sure [Y/n]? '
260 case "$yesno" in [Nn
]*) exit 1 ;; esac
262 : bisect without good...
266 test -s "$GIT_DIR/BISECT_START" ||
{
267 echo >&2 'You need to start by "git bisect start".'
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.)'
279 bisect_next_check
&& bisect_next ||
:
286 if [ -z "$_skip" ]; then
297 # Let's parse the output of:
298 # "git rev-list --bisect-vars --bisect-all ..."
303 case "$VARS,$FOUND,$TRIED,$hash" in
305 # "bisect_foo=bar" read from rev-list output.
312 # We had nothing to search.
313 echo "bisect_rev= &&"
317 # We did not find a good bisect rev.
318 # This should happen only if the "bad"
319 # commit is also a "skip" commit.
320 echo "bisect_rev='$TRIED' &&"
325 TRIED
="${TRIED:+$TRIED|}$hash"
329 echo "bisect_rev=$hash &&"
330 echo "bisect_tried='$TRIED' &&"
336 # We have already found a rev to be tested.
343 echo "die 'filter_skipped error'"
344 die
"filter_skipped error " \
357 exit_if_skipped_commits
() {
359 if expr "$_tried" : ".*[|].*" > /dev
/null
; then
360 echo "There are only 'skip'ped commit left to test."
361 echo "The first bad commit could be any of:"
362 echo "$_tried" |
tr '[|]' '[\012]'
363 echo "We cannot bisect more!"
371 echo "Bisecting: $_msg"
372 mark_expected_rev
"$_rev"
373 git checkout
-q "$_rev" ||
exit
374 git show-branch
"$_rev"
380 case "$_list" in *$_rev*) return 0 ;; esac
384 handle_bad_merge_base
() {
387 if is_expected_rev
"$_badmb"; then
389 The merge base $_badmb is bad.
390 This means the bug has been fixed between $_badmb and [$_good].
395 Some good revs are not ancestor of the bad rev.
396 git bisect cannot work properly in this case.
397 Maybe you mistake good and bad revs?
403 handle_skipped_merge_base
() {
408 Warning: the merge base between $_bad and [$_good] must be skipped.
409 So we cannot be sure the first bad commit is between $_mb and $_bad.
415 # "check_merge_bases" checks that merge bases are not "bad".
417 # - If one is "good", that's good, we have nothing to do.
418 # - If one is "bad", it means the user assumed something wrong
420 # - If one is "skipped", we can't know but we should warn.
421 # - If we don't know, we should check it out and ask the user to test.
423 # In the last case we will return 1, and otherwise 0.
425 check_merge_bases
() {
429 for _mb
in $
(git merge-base
--all $_bad $_good)
431 if is_among
"$_mb" "$_good"; then
433 elif test "$_mb" = "$_bad"; then
434 handle_bad_merge_base
"$_bad" "$_good"
435 elif is_among
"$_mb" "$_skip"; then
436 handle_skipped_merge_base
"$_mb" "$_bad" "$_good"
438 bisect_checkout
"$_mb" "a merge base must be tested"
446 # "check_good_are_ancestors_of_bad" checks that all "good" revs are
447 # ancestor of the "bad" rev.
449 # If that's not the case, we need to check the merge bases.
450 # If a merge base must be tested by the user we return 1 and
453 check_good_are_ancestors_of_bad
() {
454 test -f "$GIT_DIR/BISECT_ANCESTORS_OK" &&
458 _good
=$
(echo $2 |
sed -e 's/\^//g')
461 # Bisecting with no good rev is ok
462 test -z "$_good" && return
464 _side
=$
(git rev-list
$_good ^
$_bad)
465 if test -n "$_side"; then
466 # Return if a checkout was done
467 check_merge_bases
"$_bad" "$_good" "$_skip" ||
return
470 : > "$GIT_DIR/BISECT_ANCESTORS_OK"
476 case "$#" in 0) ;; *) usage
;; esac
478 bisect_next_check good
480 # Get bad, good and skipped revs
481 bad
=$
(git rev-parse
--verify refs
/bisect
/bad
) &&
482 good
=$
(git for-each-ref
--format='^%(objectname)' \
483 "refs/bisect/good-*" |
tr '\012' ' ') &&
484 skip
=$
(git for-each-ref
--format='%(objectname)' \
485 "refs/bisect/skip-*" |
tr '\012' ' ') ||
exit
487 # Maybe some merge bases must be tested first
488 check_good_are_ancestors_of_bad
"$bad" "$good" "$skip"
489 # Return now if a checkout has already been done
490 test "$?" -eq "1" && return
492 # Get bisection information
494 test -n "$skip" && BISECT_OPT
='--bisect-all'
495 eval="git rev-list --bisect-vars $BISECT_OPT $good $bad --" &&
496 eval="$eval $(cat "$GIT_DIR/BISECT_NAMES
")" &&
497 eval=$
(filter_skipped
"$eval" "$skip") &&
500 if [ -z "$bisect_rev" ]; then
501 echo "$bad was both good and bad"
504 if [ "$bisect_rev" = "$bad" ]; then
505 exit_if_skipped_commits
"$bisect_tried"
506 echo "$bisect_rev is first bad commit"
507 git diff-tree
--pretty $bisect_rev
511 # We should exit here only if the "bad"
512 # commit is also a "skip" commit (see above).
513 exit_if_skipped_commits
"$bisect_rev"
515 bisect_checkout
"$bisect_rev" "$bisect_nr revisions left to test after this (roughly $bisect_steps steps)"
519 bisect_next_check fail
523 case "${DISPLAY+set}${SESSIONNAME+set}${MSYSTEM+set}${SECURITYSESSIONID+set}" in
530 -*) set git log
"$@" ;;
535 not
=$
(git for-each-ref
--format='%(refname)' "refs/bisect/good-*")
536 eval '"$@"' refs
/bisect
/bad
--not $not -- $
(cat "$GIT_DIR/BISECT_NAMES")
540 test -s "$GIT_DIR/BISECT_START" ||
{
541 echo "We are not bisecting."
545 0) branch
=$
(cat "$GIT_DIR/BISECT_START") ;;
546 1) git show-ref
--verify --quiet -- "refs/heads/$1" ||
547 die
"$1 does not seem to be a valid branch"
552 git checkout
"$branch" && bisect_clean_state
555 bisect_clean_state
() {
556 # There may be some refs packed during bisection.
557 git for-each-ref
--format='%(refname) %(objectname)' refs
/bisect
/\
* |
560 git update-ref
-d $ref $hash ||
exit
562 rm -f "$GIT_DIR/BISECT_EXPECTED_REV" &&
563 rm -f "$GIT_DIR/BISECT_ANCESTORS_OK" &&
564 rm -f "$GIT_DIR/BISECT_LOG" &&
565 rm -f "$GIT_DIR/BISECT_NAMES" &&
566 rm -f "$GIT_DIR/BISECT_RUN" &&
567 # Cleanup head-name if it got left by an old version of git-bisect
568 rm -f "$GIT_DIR/head-name" &&
570 rm -f "$GIT_DIR/BISECT_START"
574 test -r "$1" || die
"cannot read $1 for replaying"
576 while read git bisect
command rev
578 test "$git $bisect" = "git bisect" -o "$git" = "git-bisect" ||
continue
579 if test "$git" = "git-bisect"; then
585 cmd
="bisect_start $rev"
588 bisect_write
"$command" "$rev" ;;
590 die
"?? what are you talking about?" ;;
597 bisect_next_check fail
605 # Check for really bad run error.
606 if [ $res -lt 0 -o $res -ge 128 ]; then
607 echo >&2 "bisect run failed:"
608 echo >&2 "exit code $res from '$@' is < 0 or >= 128"
612 # Find current state depending on run success or failure.
613 # A special exit code of 125 means cannot test.
614 if [ $res -eq 125 ]; then
616 elif [ $res -gt 0 ]; then
622 # We have to use a subshell because "bisect_state" can exit.
623 ( bisect_state
$state > "$GIT_DIR/BISECT_RUN" )
626 cat "$GIT_DIR/BISECT_RUN"
628 if grep "first bad commit could be any of" "$GIT_DIR/BISECT_RUN" \
630 echo >&2 "bisect run cannot continue any more"
634 if [ $res -ne 0 ]; then
635 echo >&2 "bisect run failed:"
636 echo >&2 "'bisect_state $state' exited with error code $res"
640 if grep "is first bad commit" "$GIT_DIR/BISECT_RUN" > /dev
/null
; then
641 echo "bisect run success"
661 bisect_state
"$cmd" "$@" ;;
665 # Not sure we want "next" at the UI level anymore.
668 bisect_visualize
"$@" ;;
672 bisect_replay
"$@" ;;
674 cat "$GIT_DIR/BISECT_LOG" ;;