From 48c39c8083770a21222dbd8b5286baffe35cc083 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Daniel=20Kochma=C5=84ski?= Date: Thu, 30 Nov 2023 18:39:52 +0100 Subject: [PATCH] cmp: inl: remove maybe-save-value and introduce inline-arg0 instead This function has very clear resemblence of inline-args so it is moved to cmpc-opt-inl. --- src/cmp/cmpbackend-cxx/cmpc-opt-inl.lsp | 25 ++++++++--- src/cmp/cmpbackend-cxx/cmppass2-call.lsp | 57 +++++++++++------------- 2 files changed, 43 insertions(+), 39 deletions(-) diff --git a/src/cmp/cmpbackend-cxx/cmpc-opt-inl.lsp b/src/cmp/cmpbackend-cxx/cmpc-opt-inl.lsp index e580013ef..279b2ee40 100644 --- a/src/cmp/cmpbackend-cxx/cmpc-opt-inl.lsp +++ b/src/cmp/cmpbackend-cxx/cmpc-opt-inl.lsp @@ -83,7 +83,7 @@ (c2expr* form) (list type temp)) (list type - (list 'si:STRUCTURE-REF + (list 'SI:STRUCTURE-REF (first (coerce-locs (inline-args (list (c1form-arg 0 form))))) (c1form-arg 1 form) @@ -113,20 +113,21 @@ (emit-inlined-variable form forms)) (CALL-GLOBAL (emit-inlined-call-global form (c1form-primary-type form))) - (si:STRUCTURE-REF + (SI:STRUCTURE-REF (emit-inlined-structure-ref form forms)) #+clos - (si:INSTANCE-REF + (SI:INSTANCE-REF (emit-inlined-instance-ref form forms)) (SETQ (emit-inlined-setq form forms)) (PROGN - (emit-inlined-progn form forms)) + (emit-inlined-progn form forms)) (VALUES (emit-inlined-values form forms)) (t (let* ((type (c1form-primary-type form)) - (temp (make-inline-temp-var type))) - (let ((*destination* temp)) (c2expr* form)) + (temp (make-inline-temp-var type)) + (*destination* temp)) + (c2expr* form) (list type temp)))))) ;;; @@ -135,13 +136,23 @@ ;;; side effects: emits code for temporary variables ;;; ;;; Whoever calls inline-args must bind *inline-blocks* to 0 and afterwards -;;; call close-inline-blocks +;;; call close-inline-blocks. ;;; (defun inline-args (forms) (loop for form-list on forms for form = (first form-list) collect (emit-inline-form form (rest form-list)))) +;;; +;;; inline-arg0: +;;; returns a location that contains the function +;;; side effects: emits code for a temporary variable +;;; +;;; Whoever calls inline-arg0 must rebind *TEMP*. +;;; +(defun inline-arg0 (value-form other-forms) + (emit-inline-form value-form other-forms)) + (defun maybe-open-inline-block () (unless (plusp *inline-blocks*) (open-inline-block))) diff --git a/src/cmp/cmpbackend-cxx/cmppass2-call.lsp b/src/cmp/cmpbackend-cxx/cmppass2-call.lsp index 6eb5919b2..41c8a1b29 100644 --- a/src/cmp/cmpbackend-cxx/cmppass2-call.lsp +++ b/src/cmp/cmpbackend-cxx/cmppass2-call.lsp @@ -9,22 +9,6 @@ (in-package #:compiler) -;;; Functions that use MAYBE-SAVE-VALUE should rebind *TEMP*. -(defun maybe-save-value (value &optional (other-forms nil other-forms-flag)) - (declare (si::c-local)) - (let ((name (c1form-name value))) - (cond ((eq name 'LOCATION) - (c1form-arg 0 value)) - ((and (eq name 'VARIABLE) - other-forms-flag - (not (var-changed-in-form-list (c1form-arg 0 value) other-forms))) - (c1form-arg 0 value)) - (t - (let* ((temp (make-temp-var)) - (*destination* temp)) - (c2expr* value) - temp))))) - ;;; FIXME functions declared as SI::C-LOCAL can't be called from the stack ;;; because they are not installed in the environment. That means that if we ;;; have such function and call it with too many arguments it will be @@ -52,6 +36,28 @@ (defun c2mcall (c1form form args fun-val call-type) (c2call-stack c1form form args t)) +;;; +;;; c2call-stack: +;;; +;;; This is the most generic way of calling functions. First we push them on +;;; the stack, and then we apply from the stack frame. Other variants call +;;; inline-args and put results directly in the function call. +;;; +(defun c2call-stack (c1form form args values-p) + (declare (ignore c1form)) + (let* ((*inline-blocks* 0) + (*temp* *temp*) + (loc (inlined-arg-loc (inline-arg0 form args)))) + (with-stack-frame (frame) + (let ((*destination* (if values-p 'VALUEZ 'LEAVE))) + (dolist (arg args) + (c2expr* arg) + (if values-p + (wt-nl "ecl_stack_frame_push_values(" frame ");") + (wt-nl "ecl_stack_frame_push(" frame ",value0);")))) + (unwind-exit (call-stack-loc nil loc))) + (close-inline-blocks))) + ;;; ;;; c2call-global: ;;; @@ -126,23 +132,10 @@ (form-type (c1form-primary-type form)) (function-p (and (subtypep form-type 'function) (policy-assume-right-type))) - (loc (maybe-save-value form args))) + (loc (inlined-arg-loc (inline-arg0 form args)))) (unwind-exit (call-unknown-global-loc loc (inline-args args) function-p)) (close-inline-blocks))) -(defun c2call-stack (c1form form args values-p) - (declare (ignore c1form)) - (let* ((*temp* *temp*) - (loc (maybe-save-value form args))) - (with-stack-frame (frame) - (let ((*destination* (if values-p 'VALUEZ 'LEAVE))) - (dolist (arg args) - (c2expr* arg) - (if values-p - (wt-nl "ecl_stack_frame_push_values(" frame ");") - (wt-nl "ecl_stack_frame_push(" frame ",value0);")))) - (unwind-exit (call-stack-loc nil loc))))) - ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;; ;;; CALL LOCATIONS @@ -266,8 +259,8 @@ ;;; ;;; call-stack-loc -;;; LOC is NIL or location containing function -;;; ARGS is the list of typed locations for arguments +;;; LOC is the location containing function +;;; FNAME is NIL or a name of the function ;;; (defun call-stack-loc (fname loc) `(CALL-STACK ,loc ,fname))