test/lit/passes/reorder-globals.wast - external/github.com/WebAssembly/binaryen - Git at Google

 ;; NOTE: Assertions have been generated by update_lit_checks.py and should not be edited.
 ;; RUN: foreach %s %t wasm-opt -all --reorder-globals-always -S -o - | filecheck %s
 ;; RUN: foreach %s %t wasm-opt -all --reorder-globals-always --roundtrip -S -o - | filecheck %s

 ;; Also check roundtripping here, so verify we don't end up emitting invalid
 ;; binaries.

 ;; Global $b has more uses, so it should be sorted first.
 (module

   ;; CHECK:      (global $b i32 (i32.const 20))

   ;; CHECK:      (global $a i32 (i32.const 10))
   (global $a i32 (i32.const 10))
   (global $b i32 (i32.const 20))

   ;; CHECK:      (func $uses (type $0)
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $b)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
   (func $uses
     (drop
       (global.get $b)
     )
   )
 )

 ;; As above, but now with global.sets. Again $b should be sorted first.
 (module

   ;; CHECK:      (global $b (mut i32) (i32.const 20))

   ;; CHECK:      (global $a (mut i32) (i32.const 10))
   (global $a (mut i32) (i32.const 10))
   (global $b (mut i32) (i32.const 20))

   ;; CHECK:      (func $uses (type $0)
   ;; CHECK-NEXT:  (global.set $b
   ;; CHECK-NEXT:   (i32.const 30)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (global.set $b
   ;; CHECK-NEXT:   (i32.const 40)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $a)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
   (func $uses
     (global.set $b
       (i32.const 30)
     )
     (global.set $b
       (i32.const 40)
     )
     (drop
       (global.get $a)
     )
   )
 )

 ;; As above, but flipped so now $a has more, and should remain first.
 (module
   ;; CHECK:      (global $a (mut i32) (i32.const 10))
   (global $a (mut i32) (i32.const 10))
   ;; CHECK:      (global $b (mut i32) (i32.const 20))
   (global $b (mut i32) (i32.const 20))

   ;; CHECK:      (func $uses (type $0)
   ;; CHECK-NEXT:  (global.set $a
   ;; CHECK-NEXT:   (i32.const 30)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (global.set $a
   ;; CHECK-NEXT:   (i32.const 40)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $b)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
   (func $uses
     (global.set $a
       (i32.const 30)
     )
     (global.set $a
       (i32.const 40)
     )
     (drop
       (global.get $b)
     )
   )
 )

 ;; $b has more uses, but it depends on $a and cannot be sorted before it.
 (module
   ;; CHECK:      (global $a i32 (i32.const 10))
   (global $a i32 (i32.const 10))
   ;; CHECK:      (global $b i32 (global.get $a))
   (global $b i32 (global.get $a))

   ;; CHECK:      (func $uses (type $0)
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $b)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
   (func $uses
     (drop
       (global.get $b)
     )
   )
 )

 ;; $c has more uses, but it depends on $b and $a and cannot be sorted before
 ;; them. Likewise $b cannot be before $a.
 (module
   ;; CHECK:      (global $a i32 (i32.const 10))
   (global $a i32 (i32.const 10))
   ;; CHECK:      (global $b i32 (global.get $a))
   (global $b i32 (global.get $a))
   ;; CHECK:      (global $c i32 (global.get $b))
   (global $c i32 (global.get $b))

   ;; CHECK:      (func $uses (type $0)
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $b)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $c)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $c)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
   (func $uses
     (drop
       (global.get $b)
     )
     (drop
       (global.get $c)
     )
     (drop
       (global.get $c)
     )
   )
 )

 ;; As above, but without dependencies, so now $c is first and then $b.
 (module
   ;; CHECK:      (global $c i32 (i32.const 30))

   ;; CHECK:      (global $b i32 (i32.const 20))

   ;; CHECK:      (global $a i32 (i32.const 10))
   (global $a i32 (i32.const 10))
   (global $b i32 (i32.const 20))
   (global $c i32 (i32.const 30))

   ;; CHECK:      (func $uses (type $0)
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $b)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $c)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $c)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
   (func $uses
     (drop
       (global.get $b)
     )
     (drop
       (global.get $c)
     )
     (drop
       (global.get $c)
     )
   )
 )

 ;; As above, but a mixed case: $b depends on $a but $c has no dependencies, and
 ;; the counts are $c with the most, followed by $b, and then $a. $c can be
 ;; first here, but $b must follow $a.
 (module
   ;; CHECK:      (global $c i32 (i32.const 30))

   ;; CHECK:      (global $a i32 (i32.const 10))
   (global $a i32 (i32.const 10))
   ;; CHECK:      (global $b i32 (global.get $a))
   (global $b i32 (global.get $a))
   (global $c i32 (i32.const 30))

   ;; CHECK:      (func $uses (type $0)
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $b)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $b)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $c)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $c)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $c)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
   (func $uses
     ;; ($a already has one use in the global $b)
     (drop
       (global.get $b)
     )
     (drop
       (global.get $b)
     )
     (drop
       (global.get $c)
     )
     (drop
       (global.get $c)
     )
     (drop
       (global.get $c)
     )
   )
 )

 ;; As above, but with the counts adjusted: before we had $c, $b, $a from most to
 ;; least uses, and now $b, $c, $a.
 ;;
 ;; A greedy sort would do $c, $a, $b (as the first choice is between $c and $a,
 ;; and $c wins), but that leaves $b, the highest count, for the end. The
 ;; smoothed-out LEB costs (1 byte at the start, +1/128 each index later) are:
 ;;
 ;;  $c           $a               $b
 ;; 1 * 2  +  129/128 * 1  +  130/128 * 3  =  775/128
 ;;
 ;; The original sort is
 ;;
 ;;  $a           $b               $c
 ;; 1 * 1  +  129/128 * 3  +  130/128 * 2  =  775/128
 ;;
 ;; As they are equal we prefer the original order.
 (module
   ;; CHECK:      (global $a i32 (i32.const 10))
   (global $a i32 (i32.const 10))
   ;; CHECK:      (global $b i32 (global.get $a))
   (global $b i32 (global.get $a))
   ;; CHECK:      (global $c i32 (i32.const 30))
   (global $c i32 (i32.const 30))

   ;; CHECK:      (func $uses (type $0)
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $b)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $b)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $b)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $c)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $c)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
   (func $uses
     (drop
       (global.get $b)
     )
     (drop
       (global.get $b)
     )
     (drop
       (global.get $b)
     )
     (drop
       (global.get $c)
     )
     (drop
       (global.get $c)
     )
   )
 )

 ;; As above, but with the counts adjusted to $b, $a, $c.
 (module
   ;; CHECK:      (global $a i32 (i32.const 10))
   (global $a i32 (i32.const 10))
   ;; CHECK:      (global $b i32 (global.get $a))
   (global $b i32 (global.get $a))
   ;; CHECK:      (global $c i32 (i32.const 30))
   (global $c i32 (i32.const 30))

   ;; CHECK:      (func $uses (type $0)
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $b)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $b)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
   (func $uses
     (drop
       (global.get $b)
     )
     (drop
       (global.get $b)
     )
   )
 )

 ;; As above, but with the counts adjusted to $c, $a, $b.
 (module
   ;; CHECK:      (global $c i32 (i32.const 30))

   ;; CHECK:      (global $a i32 (i32.const 10))
   (global $a i32 (i32.const 10))
   ;; CHECK:      (global $b i32 (global.get $a))
   (global $b i32 (global.get $a))
   (global $c i32 (i32.const 30))

   ;; CHECK:      (func $uses (type $0)
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $c)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $c)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
   (func $uses
     (drop
       (global.get $c)
     )
     (drop
       (global.get $c)
     )
   )
 )

 ;; As above, but with the counts adjusted to $a, $b, $c.
 (module
   ;; CHECK:      (global $a i32 (i32.const 10))
   (global $a i32 (i32.const 10))
   ;; CHECK:      (global $b i32 (global.get $a))
   (global $b i32 (global.get $a))
   ;; CHECK:      (global $c i32 (i32.const 30))
   (global $c i32 (i32.const 30))

   ;; CHECK:      (func $uses (type $0)
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $a)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $b)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
   (func $uses
     (drop
       (global.get $a)
     )
     (drop
       (global.get $b)
     )
   )
 )

 ;; As above, but with the counts adjusted to $a, $c, $b.
 (module
   ;; CHECK:      (global $a i32 (i32.const 10))
   (global $a i32 (i32.const 10))
   ;; CHECK:      (global $c i32 (i32.const 30))

   ;; CHECK:      (global $b i32 (global.get $a))
   (global $b i32 (global.get $a))
   (global $c i32 (i32.const 30))

   ;; CHECK:      (func $uses (type $0)
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $a)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $c)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
   (func $uses
     (drop
       (global.get $a)
     )
     (drop
       (global.get $c)
     )
   )
 )

 ;; $b has more uses, but $a is an import and must remain first.
 (module
   ;; CHECK:      (import "a" "b" (global $a i32))
   (import "a" "b" (global $a i32))
   ;; CHECK:      (global $b i32 (i32.const 10))
   (global $b i32 (i32.const 10))

   ;; CHECK:      (func $uses (type $0)
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $b)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
   (func $uses
     (drop
       (global.get $b)
     )
   )
 )

 ;; As above, but with a and b's names flipped, to check that the names do not
 ;; matter, and we keep imports first.
 (module
   ;; CHECK:      (import "a" "b" (global $b i32))
   (import "a" "b" (global $b i32))

   ;; CHECK:      (global $a i32 (i32.const 10))
   (global $a i32 (i32.const 10))

   ;; CHECK:      (func $uses (type $0)
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $a)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
   (func $uses
     (drop
       (global.get $a)
     )
   )
 )

 ;; Lower letters have lower counts: $a has the least, and $e has the most.
 ;;
 ;; Dependency graph (left depends on right):
 ;;
 ;;    $c - $a
 ;;   /
 ;; $e
 ;;   \
 ;;    $d - $b
 ;;
 ;; $e has the most uses, followed by $c and $d. $a and $b have a reverse
 ;; ordering from their dependers, so a naive topological sort will fail to
 ;; be optimal. There are multiple optimal orders however, including:
 ;;
 ;;   $b, $a, $c, $d, $e
 ;;   $b, $d, $a, $c, $e
 ;;
 ;; $b and $e must be at the edges, but there is no single way to sort the
 ;; others: the first sorting here puts $a before both $d (though $a has
 ;; lower count) while the second puts $d before $c. Our greedy algorithm
 ;; picks the second order here.
 (module
   ;; CHECK:      (global $b i32 (i32.const 20))

   ;; CHECK:      (global $d i32 (global.get $b))

   ;; CHECK:      (global $a i32 (i32.const 10))
   (global $a i32 (i32.const 10))

   (global $b i32 (i32.const 20))

   ;; CHECK:      (global $c i32 (global.get $a))
   (global $c i32 (global.get $a))

   (global $d i32 (global.get $b))

   ;; CHECK:      (global $e i32 (i32.add
   ;; CHECK-NEXT:  (global.get $c)
   ;; CHECK-NEXT:  (global.get $d)
   ;; CHECK-NEXT: ))
   (global $e i32 (i32.add
     (global.get $c)
     (global.get $d)
   ))

   ;; CHECK:      (func $uses (type $0)
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $e)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $e)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $e)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $e)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $e)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $d)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $d)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $d)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $c)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $c)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $b)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
   (func $uses
     ;; $a, $b, $c, $d each have one already from the globals. Add more so that
     ;; $a has the least, and $e has the most
     (drop (global.get $e))
     (drop (global.get $e))
     (drop (global.get $e))
     (drop (global.get $e))
     (drop (global.get $e))

     (drop (global.get $d))
     (drop (global.get $d))
     (drop (global.get $d))

     (drop (global.get $c))
     (drop (global.get $c))

     (drop (global.get $b))
   )
 )

 ;; As above, but add a direct dep from $d to $a:
 ;;
 ;;    $c - $a
 ;;   /    /
 ;; $e    / <-- this was added
 ;;   \  /
 ;;    $d - $b
 ;;
 ;; This forces $a to appear before $d: the order goes from before, which was
 ;;   $b, $d, $a, $c, $e
 ;; to
 ;;   $b, $a, $d, $c, $e
 (module
   ;; CHECK:      (global $b i32 (i32.const 20))

   ;; CHECK:      (global $a i32 (i32.const 10))
   (global $a i32 (i32.const 10))

   (global $b i32 (i32.const 20))

   ;; CHECK:      (global $d i32 (i32.add
   ;; CHECK-NEXT:  (global.get $b)
   ;; CHECK-NEXT:  (global.get $a)
   ;; CHECK-NEXT: ))

   ;; CHECK:      (global $c i32 (global.get $a))
   (global $c i32 (global.get $a))

   (global $d i32 (i32.add
     (global.get $b)
     (global.get $a) ;; this was added
   ))

   ;; CHECK:      (global $e i32 (i32.add
   ;; CHECK-NEXT:  (global.get $c)
   ;; CHECK-NEXT:  (global.get $d)
   ;; CHECK-NEXT: ))
   (global $e i32 (i32.add
     (global.get $c)
     (global.get $d)
   ))

   ;; CHECK:      (func $uses (type $0)
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $e)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $e)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $e)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $e)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $e)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $e)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $d)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $d)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $d)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $d)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $c)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $c)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $c)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $b)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $b)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
   (func $uses
     ;; $b, $c, $d each have one already from the globals, and $a has two. Add
     ;; more so that $a has the least, and $e has the most.
     (drop (global.get $e))
     (drop (global.get $e))
     (drop (global.get $e))
     (drop (global.get $e))
     (drop (global.get $e))
     (drop (global.get $e))

     (drop (global.get $d))
     (drop (global.get $d))
     (drop (global.get $d))
     (drop (global.get $d))

     (drop (global.get $c))
     (drop (global.get $c))
     (drop (global.get $c))

     (drop (global.get $b))
     (drop (global.get $b))
   )
 )

 ;; A situation where the simple greedy sort fails to be optimal. We have a
 ;; chain and one more independent global
 ;;
 ;;  a <- b <- c
 ;;
 ;;  other
 ;;
 ;; The candidates for the first global emitted are a and other, as they have no
 ;; dependencies, and other has a higher count so greedy sorting would pick it.
 ;; however, c has the highest count by far, so it is worth being less greedy and
 ;; doing a just in order to be able to do b and then c, and to emit other last.
 ;; In other words, the original order is best.
 (module
   ;; CHECK:      (global $a i32 (i32.const 0))
   (global $a i32 (i32.const 0))
   ;; CHECK:      (global $b i32 (global.get $a))
   (global $b i32 (global.get $a))
   ;; CHECK:      (global $c i32 (global.get $b))
   (global $c i32 (global.get $b))

   ;; CHECK:      (global $other i32 (i32.const 1))
   (global $other i32 (i32.const 1))

   ;; CHECK:      (func $uses (type $0)
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $c)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $c)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $c)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $c)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $c)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $c)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $c)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $c)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $c)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $c)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $other)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $other)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
   (func $uses
     ;; Ten uses for $c, far more than all the rest combined.
     (drop (global.get $c))
     (drop (global.get $c))
     (drop (global.get $c))
     (drop (global.get $c))
     (drop (global.get $c))
     (drop (global.get $c))
     (drop (global.get $c))
     (drop (global.get $c))
     (drop (global.get $c))
     (drop (global.get $c))

     ;; Two uses for other, which is more than $a's single use.
     (drop (global.get $other))
     (drop (global.get $other))
   )
 )

 ;; As above, but with the original order a little different. This is again a
 ;; case where the greedy sort is unoptimal (see above), but now also the
 ;; original sort is unoptimal as well, and instead we use the "sum" sort, which
 ;; counts the sum of the uses of a global and all the things it depends on and
 ;; uses that as the count for that global (which in effect means that we take
 ;; into consideration not only its own size but the entire size that it may
 ;; unlock, which happens to work well here).
 ;;
 ;; The only change in the input compared to the previous test is that $other
 ;; was moved up to between $b and $c. Sum sort works well here because the
 ;; first comparison is $a and $other, and sum takes into account $b and $c in
 ;; $a's favor, so it wins. Likewise $b and $c win against $other as well, so
 ;; the order is $a, $b, $c, $other which is optimal here.
 (module
   ;; CHECK:      (global $a i32 (i32.const 0))
   (global $a i32 (i32.const 0))
   ;; CHECK:      (global $b i32 (global.get $a))
   (global $b i32 (global.get $a))

   ;; CHECK:      (global $c i32 (global.get $b))

   ;; CHECK:      (global $other i32 (i32.const 1))
   (global $other i32 (i32.const 1))

   (global $c i32 (global.get $b))

   ;; CHECK:      (func $uses (type $0)
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $c)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $c)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $c)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $c)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $c)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $c)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $c)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $c)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $c)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $c)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $other)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT:  (drop
   ;; CHECK-NEXT:   (global.get $other)
   ;; CHECK-NEXT:  )
   ;; CHECK-NEXT: )
   (func $uses
     ;; Ten uses for $c, far more than all the rest combined.
     (drop (global.get $c))
     (drop (global.get $c))
     (drop (global.get $c))
     (drop (global.get $c))
     (drop (global.get $c))
     (drop (global.get $c))
     (drop (global.get $c))
     (drop (global.get $c))
     (drop (global.get $c))
     (drop (global.get $c))

     ;; Two uses for other, which is more than $a's single use.
     (drop (global.get $other))
     (drop (global.get $other))
   )
 )
	;; NOTE: Assertions have been generated by update_lit_checks.py and should not be edited.
	;; RUN: foreach %s %t wasm-opt -all --reorder-globals-always -S -o - \| filecheck %s
	;; RUN: foreach %s %t wasm-opt -all --reorder-globals-always --roundtrip -S -o - \| filecheck %s

	;; Also check roundtripping here, so verify we don't end up emitting invalid
	;; binaries.

	;; Global $b has more uses, so it should be sorted first.
	(module

	;; CHECK: (global $b i32 (i32.const 20))

	;; CHECK: (global $a i32 (i32.const 10))
	(global $a i32 (i32.const 10))
	(global $b i32 (i32.const 20))

	;; CHECK: (func $uses (type $0)
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $b)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: )
	(func $uses
	(drop
	(global.get $b)
	)
	)
	)

	;; As above, but now with global.sets. Again $b should be sorted first.
	(module

	;; CHECK: (global $b (mut i32) (i32.const 20))

	;; CHECK: (global $a (mut i32) (i32.const 10))
	(global $a (mut i32) (i32.const 10))
	(global $b (mut i32) (i32.const 20))

	;; CHECK: (func $uses (type $0)
	;; CHECK-NEXT: (global.set $b
	;; CHECK-NEXT: (i32.const 30)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (global.set $b
	;; CHECK-NEXT: (i32.const 40)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $a)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: )
	(func $uses
	(global.set $b
	(i32.const 30)
	)
	(global.set $b
	(i32.const 40)
	)
	(drop
	(global.get $a)
	)
	)
	)

	;; As above, but flipped so now $a has more, and should remain first.
	(module
	;; CHECK: (global $a (mut i32) (i32.const 10))
	(global $a (mut i32) (i32.const 10))
	;; CHECK: (global $b (mut i32) (i32.const 20))
	(global $b (mut i32) (i32.const 20))

	;; CHECK: (func $uses (type $0)
	;; CHECK-NEXT: (global.set $a
	;; CHECK-NEXT: (i32.const 30)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (global.set $a
	;; CHECK-NEXT: (i32.const 40)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $b)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: )
	(func $uses
	(global.set $a
	(i32.const 30)
	)
	(global.set $a
	(i32.const 40)
	)
	(drop
	(global.get $b)
	)
	)
	)

	;; $b has more uses, but it depends on $a and cannot be sorted before it.
	(module
	;; CHECK: (global $a i32 (i32.const 10))
	(global $a i32 (i32.const 10))
	;; CHECK: (global $b i32 (global.get $a))
	(global $b i32 (global.get $a))

	;; CHECK: (func $uses (type $0)
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $b)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: )
	(func $uses
	(drop
	(global.get $b)
	)
	)
	)

	;; $c has more uses, but it depends on $b and $a and cannot be sorted before
	;; them. Likewise $b cannot be before $a.
	(module
	;; CHECK: (global $a i32 (i32.const 10))
	(global $a i32 (i32.const 10))
	;; CHECK: (global $b i32 (global.get $a))
	(global $b i32 (global.get $a))
	;; CHECK: (global $c i32 (global.get $b))
	(global $c i32 (global.get $b))

	;; CHECK: (func $uses (type $0)
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $b)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $c)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $c)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: )
	(func $uses
	(drop
	(global.get $b)
	)
	(drop
	(global.get $c)
	)
	(drop
	(global.get $c)
	)
	)
	)

	;; As above, but without dependencies, so now $c is first and then $b.
	(module
	;; CHECK: (global $c i32 (i32.const 30))

	;; CHECK: (global $b i32 (i32.const 20))

	;; CHECK: (global $a i32 (i32.const 10))
	(global $a i32 (i32.const 10))
	(global $b i32 (i32.const 20))
	(global $c i32 (i32.const 30))

	;; CHECK: (func $uses (type $0)
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $b)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $c)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $c)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: )
	(func $uses
	(drop
	(global.get $b)
	)
	(drop
	(global.get $c)
	)
	(drop
	(global.get $c)
	)
	)
	)

	;; As above, but a mixed case: $b depends on $a but $c has no dependencies, and
	;; the counts are $c with the most, followed by $b, and then $a. $c can be
	;; first here, but $b must follow $a.
	(module
	;; CHECK: (global $c i32 (i32.const 30))

	;; CHECK: (global $a i32 (i32.const 10))
	(global $a i32 (i32.const 10))
	;; CHECK: (global $b i32 (global.get $a))
	(global $b i32 (global.get $a))
	(global $c i32 (i32.const 30))

	;; CHECK: (func $uses (type $0)
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $b)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $b)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $c)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $c)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $c)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: )
	(func $uses
	;; ($a already has one use in the global $b)
	(drop
	(global.get $b)
	)
	(drop
	(global.get $b)
	)
	(drop
	(global.get $c)
	)
	(drop
	(global.get $c)
	)
	(drop
	(global.get $c)
	)
	)
	)

	;; As above, but with the counts adjusted: before we had $c, $b, $a from most to
	;; least uses, and now $b, $c, $a.
	;;
	;; A greedy sort would do $c, $a, $b (as the first choice is between $c and $a,
	;; and $c wins), but that leaves $b, the highest count, for the end. The
	;; smoothed-out LEB costs (1 byte at the start, +1/128 each index later) are:
	;;
	;; $c $a $b
	;; 1 * 2 + 129/128 * 1 + 130/128 * 3 = 775/128
	;;
	;; The original sort is
	;;
	;; $a $b $c
	;; 1 * 1 + 129/128 * 3 + 130/128 * 2 = 775/128
	;;
	;; As they are equal we prefer the original order.
	(module
	;; CHECK: (global $a i32 (i32.const 10))
	(global $a i32 (i32.const 10))
	;; CHECK: (global $b i32 (global.get $a))
	(global $b i32 (global.get $a))
	;; CHECK: (global $c i32 (i32.const 30))
	(global $c i32 (i32.const 30))

	;; CHECK: (func $uses (type $0)
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $b)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $b)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $b)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $c)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $c)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: )
	(func $uses
	(drop
	(global.get $b)
	)
	(drop
	(global.get $b)
	)
	(drop
	(global.get $b)
	)
	(drop
	(global.get $c)
	)
	(drop
	(global.get $c)
	)
	)
	)

	;; As above, but with the counts adjusted to $b, $a, $c.
	(module
	;; CHECK: (global $a i32 (i32.const 10))
	(global $a i32 (i32.const 10))
	;; CHECK: (global $b i32 (global.get $a))
	(global $b i32 (global.get $a))
	;; CHECK: (global $c i32 (i32.const 30))
	(global $c i32 (i32.const 30))

	;; CHECK: (func $uses (type $0)
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $b)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $b)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: )
	(func $uses
	(drop
	(global.get $b)
	)
	(drop
	(global.get $b)
	)
	)
	)

	;; As above, but with the counts adjusted to $c, $a, $b.
	(module
	;; CHECK: (global $c i32 (i32.const 30))

	;; CHECK: (global $a i32 (i32.const 10))
	(global $a i32 (i32.const 10))
	;; CHECK: (global $b i32 (global.get $a))
	(global $b i32 (global.get $a))
	(global $c i32 (i32.const 30))

	;; CHECK: (func $uses (type $0)
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $c)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $c)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: )
	(func $uses
	(drop
	(global.get $c)
	)
	(drop
	(global.get $c)
	)
	)
	)

	;; As above, but with the counts adjusted to $a, $b, $c.
	(module
	;; CHECK: (global $a i32 (i32.const 10))
	(global $a i32 (i32.const 10))
	;; CHECK: (global $b i32 (global.get $a))
	(global $b i32 (global.get $a))
	;; CHECK: (global $c i32 (i32.const 30))
	(global $c i32 (i32.const 30))

	;; CHECK: (func $uses (type $0)
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $a)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $b)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: )
	(func $uses
	(drop
	(global.get $a)
	)
	(drop
	(global.get $b)
	)
	)
	)

	;; As above, but with the counts adjusted to $a, $c, $b.
	(module
	;; CHECK: (global $a i32 (i32.const 10))
	(global $a i32 (i32.const 10))
	;; CHECK: (global $c i32 (i32.const 30))

	;; CHECK: (global $b i32 (global.get $a))
	(global $b i32 (global.get $a))
	(global $c i32 (i32.const 30))

	;; CHECK: (func $uses (type $0)
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $a)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $c)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: )
	(func $uses
	(drop
	(global.get $a)
	)
	(drop
	(global.get $c)
	)
	)
	)

	;; $b has more uses, but $a is an import and must remain first.
	(module
	;; CHECK: (import "a" "b" (global $a i32))
	(import "a" "b" (global $a i32))
	;; CHECK: (global $b i32 (i32.const 10))
	(global $b i32 (i32.const 10))

	;; CHECK: (func $uses (type $0)
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $b)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: )
	(func $uses
	(drop
	(global.get $b)
	)
	)
	)

	;; As above, but with a and b's names flipped, to check that the names do not
	;; matter, and we keep imports first.
	(module
	;; CHECK: (import "a" "b" (global $b i32))
	(import "a" "b" (global $b i32))

	;; CHECK: (global $a i32 (i32.const 10))
	(global $a i32 (i32.const 10))

	;; CHECK: (func $uses (type $0)
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $a)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: )
	(func $uses
	(drop
	(global.get $a)
	)
	)
	)

	;; Lower letters have lower counts: $a has the least, and $e has the most.
	;;
	;; Dependency graph (left depends on right):
	;;
	;; $c - $a
	;; /
	;; $e
	;; \
	;; $d - $b
	;;
	;; $e has the most uses, followed by $c and $d. $a and $b have a reverse
	;; ordering from their dependers, so a naive topological sort will fail to
	;; be optimal. There are multiple optimal orders however, including:
	;;
	;; $b, $a, $c, $d, $e
	;; $b, $d, $a, $c, $e
	;;
	;; $b and $e must be at the edges, but there is no single way to sort the
	;; others: the first sorting here puts $a before both $d (though $a has
	;; lower count) while the second puts $d before $c. Our greedy algorithm
	;; picks the second order here.
	(module
	;; CHECK: (global $b i32 (i32.const 20))

	;; CHECK: (global $d i32 (global.get $b))

	;; CHECK: (global $a i32 (i32.const 10))
	(global $a i32 (i32.const 10))

	(global $b i32 (i32.const 20))

	;; CHECK: (global $c i32 (global.get $a))
	(global $c i32 (global.get $a))

	(global $d i32 (global.get $b))

	;; CHECK: (global $e i32 (i32.add
	;; CHECK-NEXT: (global.get $c)
	;; CHECK-NEXT: (global.get $d)
	;; CHECK-NEXT: ))
	(global $e i32 (i32.add
	(global.get $c)
	(global.get $d)
	))

	;; CHECK: (func $uses (type $0)
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $e)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $e)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $e)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $e)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $e)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $d)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $d)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $d)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $c)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $c)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $b)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: )
	(func $uses
	;; $a, $b, $c, $d each have one already from the globals. Add more so that
	;; $a has the least, and $e has the most
	(drop (global.get $e))
	(drop (global.get $e))
	(drop (global.get $e))
	(drop (global.get $e))
	(drop (global.get $e))

	(drop (global.get $d))
	(drop (global.get $d))
	(drop (global.get $d))

	(drop (global.get $c))
	(drop (global.get $c))

	(drop (global.get $b))
	)
	)

	;; As above, but add a direct dep from $d to $a:
	;;
	;; $c - $a
	;; / /
	;; $e / <-- this was added
	;; \ /
	;; $d - $b
	;;
	;; This forces $a to appear before $d: the order goes from before, which was
	;; $b, $d, $a, $c, $e
	;; to
	;; $b, $a, $d, $c, $e
	(module
	;; CHECK: (global $b i32 (i32.const 20))

	;; CHECK: (global $a i32 (i32.const 10))
	(global $a i32 (i32.const 10))

	(global $b i32 (i32.const 20))

	;; CHECK: (global $d i32 (i32.add
	;; CHECK-NEXT: (global.get $b)
	;; CHECK-NEXT: (global.get $a)
	;; CHECK-NEXT: ))

	;; CHECK: (global $c i32 (global.get $a))
	(global $c i32 (global.get $a))

	(global $d i32 (i32.add
	(global.get $b)
	(global.get $a) ;; this was added
	))

	;; CHECK: (global $e i32 (i32.add
	;; CHECK-NEXT: (global.get $c)
	;; CHECK-NEXT: (global.get $d)
	;; CHECK-NEXT: ))
	(global $e i32 (i32.add
	(global.get $c)
	(global.get $d)
	))

	;; CHECK: (func $uses (type $0)
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $e)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $e)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $e)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $e)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $e)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $e)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $d)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $d)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $d)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $d)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $c)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $c)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $c)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $b)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $b)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: )
	(func $uses
	;; $b, $c, $d each have one already from the globals, and $a has two. Add
	;; more so that $a has the least, and $e has the most.
	(drop (global.get $e))
	(drop (global.get $e))
	(drop (global.get $e))
	(drop (global.get $e))
	(drop (global.get $e))
	(drop (global.get $e))

	(drop (global.get $d))
	(drop (global.get $d))
	(drop (global.get $d))
	(drop (global.get $d))

	(drop (global.get $c))
	(drop (global.get $c))
	(drop (global.get $c))

	(drop (global.get $b))
	(drop (global.get $b))
	)
	)

	;; A situation where the simple greedy sort fails to be optimal. We have a
	;; chain and one more independent global
	;;
	;; a <- b <- c
	;;
	;; other
	;;
	;; The candidates for the first global emitted are a and other, as they have no
	;; dependencies, and other has a higher count so greedy sorting would pick it.
	;; however, c has the highest count by far, so it is worth being less greedy and
	;; doing a just in order to be able to do b and then c, and to emit other last.
	;; In other words, the original order is best.
	(module
	;; CHECK: (global $a i32 (i32.const 0))
	(global $a i32 (i32.const 0))
	;; CHECK: (global $b i32 (global.get $a))
	(global $b i32 (global.get $a))
	;; CHECK: (global $c i32 (global.get $b))
	(global $c i32 (global.get $b))

	;; CHECK: (global $other i32 (i32.const 1))
	(global $other i32 (i32.const 1))

	;; CHECK: (func $uses (type $0)
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $c)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $c)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $c)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $c)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $c)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $c)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $c)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $c)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $c)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $c)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $other)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $other)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: )
	(func $uses
	;; Ten uses for $c, far more than all the rest combined.
	(drop (global.get $c))
	(drop (global.get $c))
	(drop (global.get $c))
	(drop (global.get $c))
	(drop (global.get $c))
	(drop (global.get $c))
	(drop (global.get $c))
	(drop (global.get $c))
	(drop (global.get $c))
	(drop (global.get $c))

	;; Two uses for other, which is more than $a's single use.
	(drop (global.get $other))
	(drop (global.get $other))
	)
	)

	;; As above, but with the original order a little different. This is again a
	;; case where the greedy sort is unoptimal (see above), but now also the
	;; original sort is unoptimal as well, and instead we use the "sum" sort, which
	;; counts the sum of the uses of a global and all the things it depends on and
	;; uses that as the count for that global (which in effect means that we take
	;; into consideration not only its own size but the entire size that it may
	;; unlock, which happens to work well here).
	;;
	;; The only change in the input compared to the previous test is that $other
	;; was moved up to between $b and $c. Sum sort works well here because the
	;; first comparison is $a and $other, and sum takes into account $b and $c in
	;; $a's favor, so it wins. Likewise $b and $c win against $other as well, so
	;; the order is $a, $b, $c, $other which is optimal here.
	(module
	;; CHECK: (global $a i32 (i32.const 0))
	(global $a i32 (i32.const 0))
	;; CHECK: (global $b i32 (global.get $a))
	(global $b i32 (global.get $a))

	;; CHECK: (global $c i32 (global.get $b))

	;; CHECK: (global $other i32 (i32.const 1))
	(global $other i32 (i32.const 1))

	(global $c i32 (global.get $b))

	;; CHECK: (func $uses (type $0)
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $c)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $c)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $c)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $c)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $c)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $c)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $c)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $c)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $c)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $c)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $other)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: (drop
	;; CHECK-NEXT: (global.get $other)
	;; CHECK-NEXT: )
	;; CHECK-NEXT: )
	(func $uses
	;; Ten uses for $c, far more than all the rest combined.
	(drop (global.get $c))
	(drop (global.get $c))
	(drop (global.get $c))
	(drop (global.get $c))
	(drop (global.get $c))
	(drop (global.get $c))
	(drop (global.get $c))
	(drop (global.get $c))
	(drop (global.get $c))
	(drop (global.get $c))

	;; Two uses for other, which is more than $a's single use.
	(drop (global.get $other))
	(drop (global.get $other))
	)
	)