Add new pass to optimize branch chains to table dispatch

* module/language/cps/switch.scm: New pass.

* module/Makefile.am (SOURCES):
* am/bootstrap.am (SOURCES): Add switch.scm.

* module/system/base/optimize.scm (available-optimizations):
* module/language/cps/optimize.scm (optimize-first-order-cps): Run
  switch optimization at level 2.

* libguile/hash.c (JENKINS_LOOKUP3_HASHWORD2): Add note regarding
  cross-compilation.

* module/language/cps/graphs.scm (intmap-select): New definition.
* module/language/cps/utils.scm (compute-singly-referenced-labels): Move
  here, from various places.  Doesn't take a body intset argument.

* module/language/cps/contification.scm:
* module/language/cps/closure-conversion.scm:
* module/language/cps/simplify.scm: Use compute-singly-referenced-labels
  from utils.

* module/language/cps/effects-analysis.scm (annotation->memory-kind*):
  (annotation->memory-kind): Add symbol annotation cases.

module/language/cps/simplify.scm

@@ -180,40 +180,12 @@
               (_ ,cont))))
      conts)))
 
-(define (compute-singly-referenced-labels conts body)
-  (define (add-ref label single multiple)
-    (define (ref k single multiple)
-      (if (intset-ref single k)
-          (values single (intset-add! multiple k))
-          (values (intset-add! single k) multiple)))
-    (define (ref0) (values single multiple))
-    (define (ref1 k) (ref k single multiple))
-    (define (ref2 k k*)
-      (if k*
-          (let-values (((single multiple) (ref k single multiple)))
-            (ref k* single multiple))
-          (ref1 k)))
-    (match (intmap-ref conts label)
-      (($ $kreceive arity k) (ref1 k))
-      (($ $kfun src meta self ktail kclause) (ref2 ktail kclause))
-      (($ $ktail) (ref0))
-      (($ $kclause arity kbody kalt) (ref2 kbody kalt))
-      (($ $kargs names syms ($ $continue k)) (ref1 k))
-      (($ $kargs names syms ($ $branch kf kt)) (ref2 kf kt))
-      (($ $kargs names syms ($ $switch kf kt*))
-       (fold2 ref (cons kf kt*) single multiple))
-      (($ $kargs names syms ($ $prompt k kh)) (ref2 k kh))
-      (($ $kargs names syms ($ $throw)) (ref0))))
-  (let*-values (((single multiple) (values empty-intset empty-intset))
-                ((single multiple) (intset-fold add-ref body single multiple)))
-    (intset-subtract (persistent-intset single)
-                     (persistent-intset multiple))))
-
 (define (compute-beta-reductions conts kfun)
   (define (visit-fun kfun body beta)
-    (let ((single (compute-singly-referenced-labels conts body)))
-      (define (visit-cont label beta)
-        (match (intmap-ref conts label)
+    (let* ((conts (intmap-select conts body))
+           (single (compute-singly-referenced-labels conts)))
+      (define (visit-cont label cont beta)
+        (match cont
           ;; A continuation's body can be inlined in place of a $values
           ;; expression if the continuation is a $kargs.  It should only
           ;; be inlined if it is used only once, and not recursively.
@@ -225,7 +197,7 @@
                                      (_ #f)))))
           (_
            beta)))
-      (intset-fold visit-cont body beta)))
+      (intmap-fold visit-cont conts beta)))
   (persistent-intset
    (intmap-fold visit-fun
                 (compute-reachable-functions conts kfun)