diff --git a/module/language/cps/optimize.scm b/module/language/cps/optimize.scm
index a94a471c1..590d2a40d 100644
--- a/module/language/cps/optimize.scm
+++ b/module/language/cps/optimize.scm
@@ -42,6 +42,7 @@
   #:use-module (language cps split-rec)
   #:use-module (language cps type-fold)
   #:use-module (language cps verify)
+  #:use-module (system base optimize)
   #:export (optimize-higher-order-cps
             optimize-first-order-cps
             cps-optimizations
@@ -117,22 +118,7 @@
   (simplify #:simplify? #t))
 
 (define (cps-optimizations)
-  '( ;; (#:split-rec? #t)
-    (#:simplify? 2)
-    (#:eliminate-dead-code? 2)
-    (#:prune-top-level-scopes? 2)
-    (#:contify? 2)
-    (#:specialize-primcalls? 2)
-    (#:peel-loops? 2)
-    (#:cse? 2)
-    (#:type-fold? 2)
-    (#:resolve-self-references? 2)
-    (#:devirtualize-integers? 2)
-    (#:specialize-numbers? 2)
-    (#:licm? 2)
-    (#:rotate-loops? 2)
-    ;; This one is used by the slot allocator.
-    (#:precolor-calls? 2)))
+  (available-optimizations 'cps))
 
 (define (lower-cps exp opts)
   ;; FIXME: For now the closure conversion pass relies on $rec instances
diff --git a/module/language/tree-il/optimize.scm b/module/language/tree-il/optimize.scm
index f4a5b4db1..6c64e17c1 100644
--- a/module/language/tree-il/optimize.scm
+++ b/module/language/tree-il/optimize.scm
@@ -27,6 +27,7 @@
   #:use-module (language tree-il peval)
   #:use-module (language tree-il primitives)
   #:use-module (ice-9 match)
+  #:use-module (system base optimize)
   #:export (optimize
             make-lowerer
             tree-il-optimizations))
@@ -62,21 +63,7 @@
   x)
 
 (define (tree-il-optimizations)
-  ;; Avoid resolve-primitives until -O2, when CPS optimizations kick in.
-  ;; Otherwise, inlining the primcalls during Tree-IL->CPS compilation
-  ;; will result in a lot of code that will never get optimized nicely.
-  ;; Similarly letrectification is great for generated code quality, but
-  ;; as it gives the compiler more to work with, it increases compile
-  ;; time enough that we reserve it for -O2.  Also, this makes -O1 avoid
-  ;; assumptions about top-level values, in the same way that avoiding
-  ;; resolve-primitives does.
-  '((#:cps? 1)
-    (#:resolve-primitives? 2)
-    (#:expand-primitives? 1)
-    (#:letrectify? 2)
-    (#:seal-private-bindings? 3)
-    (#:partial-eval? 1)
-    (#:eta-expand? 2)))
+  (available-optimizations 'tree-il))
 
 (define (make-lowerer optimization-level opts)
   (define (enabled-for-level? level) (<= level optimization-level))
diff --git a/module/system/base/optimize.scm b/module/system/base/optimize.scm
index 562f94ae7..3b056a540 100644
--- a/module/system/base/optimize.scm
+++ b/module/system/base/optimize.scm
@@ -1,6 +1,6 @@
 ;;; Optimization flags
 
-;; Copyright (C) 2018 Free Software Foundation, Inc.
+;; Copyright (C) 2018, 2020 Free Software Foundation, Inc.
 
 ;;;; This library is free software; you can redistribute it and/or
 ;;;; modify it under the terms of the GNU Lesser General Public
@@ -19,15 +19,49 @@
 ;;; Code:
 
 (define-module (system base optimize)
-  #:use-module (language tree-il optimize)
-  #:use-module (language cps optimize)
   #:use-module (ice-9 match)
   #:export (available-optimizations
             pass-optimization-level
             optimizations-for-level))
 
-(define (available-optimizations)
-  (append (tree-il-optimizations) (cps-optimizations)))
+(define* (available-optimizations #:optional lang-name)
+  (match lang-name
+    ('tree-il
+     ;; Avoid resolve-primitives until -O2, when CPS optimizations kick in.
+     ;; Otherwise, inlining the primcalls during Tree-IL->CPS compilation
+     ;; will result in a lot of code that will never get optimized nicely.
+     ;; Similarly letrectification is great for generated code quality, but
+     ;; as it gives the compiler more to work with, it increases compile
+     ;; time enough that we reserve it for -O2.  Also, this makes -O1 avoid
+     ;; assumptions about top-level values, in the same way that avoiding
+     ;; resolve-primitives does.
+     '((#:cps? 1)
+       (#:resolve-primitives? 2)
+       (#:expand-primitives? 1)
+       (#:letrectify? 2)
+       (#:seal-private-bindings? 3)
+       (#:partial-eval? 1)
+       (#:eta-expand? 2)))
+    ('cps
+     '( ;; (#:split-rec? #t)
+       (#:simplify? 2)
+       (#:eliminate-dead-code? 2)
+       (#:prune-top-level-scopes? 2)
+       (#:contify? 2)
+       (#:specialize-primcalls? 2)
+       (#:peel-loops? 2)
+       (#:cse? 2)
+       (#:type-fold? 2)
+       (#:resolve-self-references? 2)
+       (#:devirtualize-integers? 2)
+       (#:specialize-numbers? 2)
+       (#:licm? 2)
+       (#:rotate-loops? 2)
+       ;; This one is used by the slot allocator.
+       (#:precolor-calls? 2)))
+    (#f
+     (append (available-optimizations 'tree-il)
+             (available-optimizations 'cps)))))
 
 (define (pass-optimization-level kw)
   (match (assq kw (available-optimizations))