GitLab

at 2024-07-17T16:44:16+00:00

Address #336:  Fix compiler warnings in srctran.lisp

Merge branch 'issue-336-1-fix-compiler-notes' into 'master'

Address #336:  Fix compiler warnings in srctran.lisp

See merge request cmucl/cmucl!233
 			      (round-it pos)))))))

 (defun round-derive-type-quot (number-type divisor-type)

-  (let* ((rem-type (rem-result-type number-type divisor-type))

-	 (number-interval (numeric-type->interval number-type))

+  (let* ((number-interval (numeric-type->interval number-type))

 	 (divisor-interval (numeric-type->interval divisor-type)))

     (let ((quot (round-quotient-bound

 		 (interval-div number-interval

 				,(or (interval-high quot) '*))))))

 (defun round-derive-type-rem (number-type divisor-type)

-  (let* ((rem-type (rem-result-type number-type divisor-type))

-	 (number-interval (numeric-type->interval number-type))

-	 (divisor-interval (numeric-type->interval divisor-type)))

+  (let* ((rem-type (rem-result-type number-type divisor-type)))

     (multiple-value-bind (class format)

 	(ecase rem-type

 	  (integer

 	   (values 'float nil))

 	  (real

 	   (values nil nil)))

-      #+nil

-      (when (member rem-type '(float single-float double-float

-			       #+long-float long-float

-			       #+double-double double-double-float))

-	(setf rem (interval-func #'(lambda (x)

-				     (coerce x rem-type))

-				 rem)))

       (make-numeric-type :class class

 			 :format format

 			 :low nil

 			(inst ,opinst x (,ea y)))

 		       (,stack-sc

 			(inst ,opinst x (,ea-stack y)))))

-		    ((and ,commutative (location= y r))

-		     ;; y = r and the operation is commutative, so just

-		     ;; do the operation with r and x.

-		     (inst ,opinst y x))

+		    ,@(when commutative

+                        `(((location= y r)

+		           ;; y = r and the operation is commutative, so just

+		           ;; do the operation with r and x.

+		           (inst ,opinst y x))))

 		    ((not (location= r y))

 		     ;; x, y, and r are three different regs.  So just

 		     ;; move r to x and do the operation on r.

        `(cond

 	 ((location= x r)

 	  (inst ,opinst x y))

-	 ((and ,commutative (location= y r))

-	  (inst ,opinst y x))

+	 ,@(when commutative

+             `(((location= y r)

+	        (inst ,opinst y x))))

 	 ((not (location= r y))

 	  (inst ,movinst r x)

 	  (inst ,opinst r y))

Raymond Toy pushed to branch master at cmucl / cmucl

Commits:

2 changed files:

Changes: