diff --git a/compiler/locall.lisp b/compiler/locall.lisp index ed1fde683379411f32505223d2bba0e3109910f4..fcec75970af93b3a8068695ab6819a4095aae720 100644 --- a/compiler/locall.lisp +++ b/compiler/locall.lisp @@ -9,9 +9,10 @@ ;;; ;;; This file implements local call analysis. A local call is a function ;;; call between functions being compiled at the same time. If we can tell at -;;; compile time that such a call is legal, then we modify the flow graph to -;;; represent the control transfers previously implicit in the call. This -;;; change allows us to do inter-routine flow analysis. +;;; compile time that such a call is legal, then we change the combination +;;; to call the correct lambda, mark it as local, and add this link to our call +;;; graph. Once a call is local, it is then eligible for let conversion, which +;;; places the body of the function inline. ;;; ;;; We cannot always do a local call even when we do have the function being ;;; called. Local call can be explicitly disabled by a NOTINLINE declaration. @@ -342,8 +343,8 @@ ;;; we give a warning and mark the Ref as :Notinline to remove it from future ;;; consideration. If the argcount is O.K. then we just convert it. ;;; -(proclaim '(function convert-lambda-call (ref combination lambda) void)) (defun convert-lambda-call (ref call fun) + (declare (type ref ref) (type combination call) (type clambda fun)) (let ((nargs (length (lambda-vars fun))) (call-args (length (combination-args call)))) (cond ((= call-args nargs) @@ -407,9 +408,9 @@ ;;; new function and the entry point immediately so that everything gets ;;; converted during the single pass. ;;; -(proclaim '(function convert-hairy-fun-entry - (ref combination lambda list list list))) (defun convert-hairy-fun-entry (ref call entry vars ignores args) + (declare (list vars ignores args) (type ref ref) (type combination call) + (type clambda entry)) (let ((new-fun (with-ir1-environment call (ir1-convert-lambda