[Guile-commits] 02/06: Avoid having "guild compile" load optimizers

[Andy Wingo]

wingo pushed a commit to branch master
in repository guile.

commit b5108ccb2a1e02ba7182be81b746ad86d31cb419
Author: Andy Wingo <address@hidden>
AuthorDate: Mon May 11 15:38:36 2020 +0200

    Avoid having "guild compile" load optimizers
    
    * module/language/cps/optimize.scm (cps-optimizations):
    * module/language/tree-il/optimize.scm (tree-il-optimizations):
    * module/system/base/optimize.scm (available-optimizations): Invert the
      dependency tree to hold the names and default optimization levels in a
      central place instead of in the optimizers.  It moves definitions
      farther from uses, but it avoids us having to load the CPS optimizer
      if we don't need it, which improves bootstrap times.
---
 module/language/cps/optimize.scm     | 18 ++-------------
 module/language/tree-il/optimize.scm | 17 ++------------
 module/system/base/optimize.scm      | 44 ++++++++++++++++++++++++++++++++----
 3 files changed, 43 insertions(+), 36 deletions(-)

diff --git a/module/language/cps/optimize.scm b/module/language/cps/optimize.scm
index a94a471..590d2a4 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 f4a5b4d..6c64e17 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 562f94a..3b056a5 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))