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 ||
:
285 echo "Bisecting: $_msg"
286 mark_expected_rev
"$_rev"
287 git checkout
-q "$_rev" -- ||
exit
288 git show-branch
"$_rev"
294 case "$_list" in *$_rev*) return 0 ;; esac
298 handle_bad_merge_base
() {
301 if is_expected_rev
"$_badmb"; then
303 The merge base $_badmb is bad.
304 This means the bug has been fixed between $_badmb and [$_good].
309 Some good revs are not ancestor of the bad rev.
310 git bisect cannot work properly in this case.
311 Maybe you mistake good and bad revs?
317 handle_skipped_merge_base
() {
322 Warning: the merge base between $_bad and [$_good] must be skipped.
323 So we cannot be sure the first bad commit is between $_mb and $_bad.
329 # "check_merge_bases" checks that merge bases are not "bad".
331 # - If one is "good", that's good, we have nothing to do.
332 # - If one is "bad", it means the user assumed something wrong
334 # - If one is "skipped", we can't know but we should warn.
335 # - If we don't know, we should check it out and ask the user to test.
337 # In the last case we will return 1, and otherwise 0.
339 check_merge_bases
() {
343 for _mb
in $
(git merge-base
--all $_bad $_good)
345 if is_among
"$_mb" "$_good"; then
347 elif test "$_mb" = "$_bad"; then
348 handle_bad_merge_base
"$_bad" "$_good"
349 elif is_among
"$_mb" "$_skip"; then
350 handle_skipped_merge_base
"$_mb" "$_bad" "$_good"
352 bisect_checkout
"$_mb" "a merge base must be tested"
360 # "check_good_are_ancestors_of_bad" checks that all "good" revs are
361 # ancestor of the "bad" rev.
363 # If that's not the case, we need to check the merge bases.
364 # If a merge base must be tested by the user we return 1 and
367 check_good_are_ancestors_of_bad
() {
368 test -f "$GIT_DIR/BISECT_ANCESTORS_OK" &&
372 _good
=$
(echo $2 |
sed -e 's/\^//g')
375 # Bisecting with no good rev is ok
376 test -z "$_good" && return
378 _side
=$
(git rev-list
$_good ^
$_bad)
379 if test -n "$_side"; then
380 # Return if a checkout was done
381 check_merge_bases
"$_bad" "$_good" "$_skip" ||
return
384 : > "$GIT_DIR/BISECT_ANCESTORS_OK"
390 case "$#" in 0) ;; *) usage
;; esac
392 bisect_next_check good
394 # Get bad, good and skipped revs
395 bad
=$
(git rev-parse
--verify refs
/bisect
/bad
) &&
396 good
=$
(git for-each-ref
--format='^%(objectname)' \
397 "refs/bisect/good-*" |
tr '\012' ' ') &&
398 skip
=$
(git for-each-ref
--format='%(objectname)' \
399 "refs/bisect/skip-*" |
tr '\012' ' ') ||
exit
401 # Maybe some merge bases must be tested first
402 check_good_are_ancestors_of_bad
"$bad" "$good" "$skip"
403 # Return now if a checkout has already been done
404 test "$?" -eq "1" && return
406 # Perform bisection computation, display and checkout
407 git bisect--helper
--next-exit
410 # Check if we should exit because bisection is finished
411 test $res -eq 10 && exit 0
413 # Check for an error in the bisection process
414 test $res -ne 0 && exit $res
420 bisect_next_check fail
424 case "${DISPLAY+set}${SESSIONNAME+set}${MSYSTEM+set}${SECURITYSESSIONID+set}" in
431 -*) set git log
"$@" ;;
436 not
=$
(git for-each-ref
--format='%(refname)' "refs/bisect/good-*")
437 eval '"$@"' refs
/bisect
/bad
--not $not -- $
(cat "$GIT_DIR/BISECT_NAMES")
441 test -s "$GIT_DIR/BISECT_START" ||
{
442 echo "We are not bisecting."
446 0) branch
=$
(cat "$GIT_DIR/BISECT_START") ;;
447 1) git show-ref
--verify --quiet -- "refs/heads/$1" ||
448 die
"$1 does not seem to be a valid branch"
453 git checkout
"$branch" -- && bisect_clean_state
456 bisect_clean_state
() {
457 # There may be some refs packed during bisection.
458 git for-each-ref
--format='%(refname) %(objectname)' refs
/bisect
/\
* |
461 git update-ref
-d $ref $hash ||
exit
463 rm -f "$GIT_DIR/BISECT_EXPECTED_REV" &&
464 rm -f "$GIT_DIR/BISECT_ANCESTORS_OK" &&
465 rm -f "$GIT_DIR/BISECT_LOG" &&
466 rm -f "$GIT_DIR/BISECT_NAMES" &&
467 rm -f "$GIT_DIR/BISECT_RUN" &&
468 # Cleanup head-name if it got left by an old version of git-bisect
469 rm -f "$GIT_DIR/head-name" &&
471 rm -f "$GIT_DIR/BISECT_START"
475 test -r "$1" || die
"cannot read $1 for replaying"
477 while read git bisect
command rev
479 test "$git $bisect" = "git bisect" -o "$git" = "git-bisect" ||
continue
480 if test "$git" = "git-bisect"; then
486 cmd
="bisect_start $rev"
489 bisect_write
"$command" "$rev" ;;
491 die
"?? what are you talking about?" ;;
498 bisect_next_check fail
506 # Check for really bad run error.
507 if [ $res -lt 0 -o $res -ge 128 ]; then
508 echo >&2 "bisect run failed:"
509 echo >&2 "exit code $res from '$@' is < 0 or >= 128"
513 # Find current state depending on run success or failure.
514 # A special exit code of 125 means cannot test.
515 if [ $res -eq 125 ]; then
517 elif [ $res -gt 0 ]; then
523 # We have to use a subshell because "bisect_state" can exit.
524 ( bisect_state
$state > "$GIT_DIR/BISECT_RUN" )
527 cat "$GIT_DIR/BISECT_RUN"
529 if grep "first bad commit could be any of" "$GIT_DIR/BISECT_RUN" \
531 echo >&2 "bisect run cannot continue any more"
535 if [ $res -ne 0 ]; then
536 echo >&2 "bisect run failed:"
537 echo >&2 "'bisect_state $state' exited with error code $res"
541 if grep "is first bad commit" "$GIT_DIR/BISECT_RUN" > /dev
/null
; then
542 echo "bisect run success"
562 bisect_state
"$cmd" "$@" ;;
566 # Not sure we want "next" at the UI level anymore.
569 bisect_visualize
"$@" ;;
573 bisect_replay
"$@" ;;
575 cat "$GIT_DIR/BISECT_LOG" ;;