Skip to content
Snippets Groups Projects
  1. Oct 05, 2003
    • gerd's avatar
      (compile nil · 56fd6636
      gerd authored
      	 '(lambda (a b c)
      		  (declare (notinline logandc2 not))
      		  (declare (optimize (safety 3)))
      		  (declare (optimize (speed 0)))
      		  (declare (optimize (debug 0)))
      		  (let ((v10
      			 (let ((v5 (if (not nil) -4 (logandc2 68392 c))))
      			      c)))
      		       a)))
      	 => assertion failure, (not (block-delete-p block))
      
      	* src/compiler/ir1opt.lisp (recognize-known-call): Treat
      	:inline and :maybe-inline like :notinline if byte-compiling
      	or converting for interpreter.  Reported by Paul Dietz.
      56fd6636
  2. Apr 29, 2003
    • gerd's avatar
      Fix for various ANSI test cases that fail when compiled because · bc84c059
      gerd authored
      	argument type checks are constant-folded away.
      
      	* src/compiler/ir1opt.lisp (constant-fold-call): In safe code,
      	don't constant-fold a call if one of its arguments requires
      	a type check.
      
      	* src/compiler/checkgen.lisp (probable-type-check-p): Return
      	true for :error type-checks if safety = 3.
      
      	Fix ENDP.* test failures when running tests compiled.  From SBCL,
      	basically.
      
      	* src/compiler/ir1opt.lisp (ir1-optimize, ir1-optimize-if):
      	Don't eliminate if-tests requiring type checks.
      
      	* src/compiler/checkgen.lisp (continuation-check-types):
      	Add parameter force-hairy.
      	(generate-type-checks): Call continuation-check-types with
      	force-hairy true for :error continuations in safe code.
      bc84c059
  3. Apr 26, 2003
    • gerd's avatar
      Fix for compiled test cases of the form (PROGN (FBOUNDP 42) T), · bdf98d92
      gerd authored
      	which don't signal an error in safe code because such calls are
      	flushed when the called function is FLUSHABLE and the value of the
      	call is not used.
      
      	* src/compiler/ir1opt.lisp (flush-dead-code):
      	Suppress flushing of flushable known functions if safety = 3.
      bdf98d92
  4. Apr 24, 2003
    • gerd's avatar
      ANSI test fixes, interpreted code. · cac10792
      gerd authored
      	* src/compiler/ir1opt.lisp (recognize-known-call): Don't inline if
      	*converting-for-interpreter*.  This suppresses inlining when
      	generating IR1 for interpretation because no type-checking IR1 is
      	generated in this case, and the interpreter, internal-apply-loop
      	for instance, doesn't do type checks is some other way either.
      cac10792
  5. Mar 04, 2001
  6. Sep 26, 2000
  7. Aug 09, 2000
    • dtc's avatar
      Add the ability to delay IR1 transforms, giving type and constraint · 0495a6a2
      dtc authored
      propagation a chance before transforming to less amiable forms.
      A transform may now choose to be delayed by calling delay-transform
      giving a reason. The two supported reasons are :optimize to delay
      until IR1 optimization has completed, and :constraint to delay until
      after constraint propagation.
      0495a6a2
  8. Jul 07, 2000
  9. Jul 06, 2000
    • dtc's avatar
      Reworking of the values-type system to overcome a number of inconsistencies · daf333f4
      dtc authored
      causing problems:
      
      o Redefine coerce-to-values to convert a single value type into (values type),
        rather than the former definition (values type &rest t). A single value
        type such as fixnum is now equivalent to (values fixnum). Values-type-union
        and values-type-intersection will canonicalise values types with a
        single value such as (values fixnum) back to a single value type
        such as fixnum.
      
      o Now when the compiler makes assertions for the first value of
        continuations that may be generating multiple values it asserts the
        type as (values type &rest t), or as (value &optional type &rest t) if
        it is not sure that the continuation does generate a value.
      
      o Enhance the type check generation to better handle the now common
        values types with optional and rest arguments. Add the new function
        Values-types-asserted which converts asserted optional and rest
        arguments to required arguments that have been proven to be delivered,
        Thus an assertion such as (values &optional fixnum &rest t) will
        generate a fixnum type check if the proven type if (values t).
      
      o The compiler is now far more likely to pickup attempts to use an
        assertion to select a subset of values. For example
        (the (values fixnum) (values x y)) will generated a compiler warning.
      
      o Update single values type assertions where appropriate to clarify that
        the received values may be optional or that multiple values may be
        received. For example, a macro argument which had been asserted to be
        a list via (the list ,...) would now be asserted to be
        (the (values &optional list &rest t)) etc.
      
      o Have the IR1 translator for THE convert single value types into
        (values &optional type &rest t) so that code such as
        (the fixnum (values x y)) will still work acceptably. This does not
        restrict the possible type assertions as the values types may be used
        and are not modified.
      daf333f4
    • dtc's avatar
      Enhance ir1-optimize-mv-bind to propagate the type of optional or rest · 6998c508
      dtc authored
      value types, using the new support function values-types-defaulted.
      6998c508
    • dtc's avatar
      o Skip substitute-single-use-continuation if CONT's assertion is · 38ca88d0
      dtc authored
        incompatbile with the proven type of ARG, such as when ARG
        returns multiple values and CONT has a single value assertion.
      
      o After propagate-let-args, only delete the let when none of
        the variables are set, otherwise an unreferenced variable that is set
        can end up without a home which would be unexpected by later stages
        of the compiler.
      
      o Correct and enhance the values deftransform to adjust the node continuation
        asserted type which may otherwise be inconsistent with the new single value
        type, and set the node derived type to the received single-value-type.
      38ca88d0
  10. Feb 25, 1999
  11. Feb 24, 1998
    • dtc's avatar
      When constant-folding succeeds alway transform the call so that even · ca288539
      dtc authored
      non-flushable functions are flushed.  For single value calls it had
      been just unlinking the result and inserting the constant but this
      failed to flush the call if it didn't have a flushable attribute, for
      example numeric constant coercions were not being flush when
      successful leading to rather inefficient code.
      ca288539
  12. Oct 31, 1994
  13. Feb 11, 1994
  14. Jan 06, 1994
  15. Aug 31, 1993
  16. Aug 19, 1993
  17. May 12, 1993
  18. May 11, 1993
  19. Mar 19, 1993
  20. Mar 14, 1993
  21. Feb 03, 1993
    • ram's avatar
      Fixed VALIDATE-CALL-TYPE to correctly handle calls where there is no · 7305cf47
      ram authored
      function type guarding the call (for example, calls to lambdas).  In this
      case, we still want to call RECOGNIZE-KNOWN-CALL, since it will figure
      out what leaf we are referencing, and might also do something else
      interesting: inline expansion, etc.
      7305cf47
  22. Jan 13, 1993
  23. Nov 03, 1992
  24. Sep 24, 1992
  25. Sep 23, 1992
  26. Sep 21, 1992
  27. Sep 16, 1992
  28. Sep 15, 1992
  29. Sep 07, 1992
  30. Aug 04, 1992
  31. Jul 31, 1992
  32. Jul 22, 1992
  33. Jun 04, 1992
  34. Jun 03, 1992
  35. Apr 14, 1992
  36. Apr 02, 1992
  37. Apr 01, 1992
  38. Feb 19, 1992
Loading