source: trunk/abcl/src/org/armedbear/lisp/jvm-instructions.lisp @ 13792

Last change on this file since 13792 was 13792, checked in by astalla, 10 years ago

A small reorganization of compiler/jvm code. Runtime-class wasn't autoloading properly in certain situations due to a wrong dependency graph among some system files.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 37.0 KB
Line 
1;;; jvm-instructions.lisp
2;;;
3;;; Copyright (C) 2003-2006 Peter Graves
4;;; Copyright (C) 2010 Erik Huelsmann
5;;; $Id: jvm-instructions.lisp 13792 2012-01-20 01:10:39Z astalla $
6;;;
7;;; This program is free software; you can redistribute it and/or
8;;; modify it under the terms of the GNU General Public License
9;;; as published by the Free Software Foundation; either version 2
10;;; of the License, or (at your option) any later version.
11;;;
12;;; This program is distributed in the hope that it will be useful,
13;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
14;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15;;; GNU General Public License for more details.
16;;;
17;;; You should have received a copy of the GNU General Public License
18;;; along with this program; if not, write to the Free Software
19;;; Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
20;;;
21;;; As a special exception, the copyright holders of this library give you
22;;; permission to link this library with independent modules to produce an
23;;; executable, regardless of the license terms of these independent
24;;; modules, and to copy and distribute the resulting executable under
25;;; terms of your choice, provided that you also meet, for each linked
26;;; independent module, the terms and conditions of the license of that
27;;; module.  An independent module is a module which is not derived from
28;;; or based on this library.  If you modify this library, you may extend
29;;; this exception to your version of the library, but you are not
30;;; obligated to do so.  If you do not wish to do so, delete this
31;;; exception statement from your version.
32
33(in-package #:jvm)
34
35(declaim (inline u2 s1 s2))
36
37(defknown u2 (fixnum) cons)
38(defun u2 (n)
39  (declare (optimize speed))
40  (declare (type (unsigned-byte 16) n))
41  (when (not (<= 0 n 65535))
42    (error "u2 argument ~A out of 65k range." n))
43  (list (logand (ash n -8) #xff)
44        (logand n #xff)))
45
46(defknown s1 (fixnum) fixnum)
47(defun s1 (n)
48  (declare (optimize speed))
49  (declare (type (signed-byte 8) n))
50  (when (not (<= -128 n 127))
51    (error "s1 argument ~A out of 8-bit signed range." n))
52  (if (< n 0)
53      (1+ (logxor (- n) #xFF))
54      n))
55
56
57(defknown s2 (fixnum) cons)
58(defun s2 (n)
59  (declare (optimize speed))
60  (declare (type (signed-byte 16) n))
61  (when (not (<= -32768 n 32767))
62    (error "s2 argument ~A out of 16-bit signed range." n))
63  (u2 (if (< n 0) (1+ (logxor (- n) #xFFFF))
64          n)))
65
66;;    OPCODES
67
68(defconst *opcode-table* (make-array 256))
69
70(defconst *opcodes* (make-hash-table :test 'equalp))
71
72(defstruct jvm-opcode name number size stack-effect register-used)
73
74(defun %define-opcode (name number size stack-effect register)
75  (declare (type fixnum number size))
76  (let* ((name (string name))
77         (opcode (make-jvm-opcode :name name
78                                  :number number
79                                  :size size
80                                  :stack-effect stack-effect
81                                  :register-used register)))
82     (setf (svref *opcode-table* number) opcode)
83     (setf (gethash name *opcodes*) opcode)
84     (setf (gethash number *opcodes*) opcode)))
85
86(defmacro define-opcode (name number size stack-effect register)
87  `(%define-opcode ',name ,number ,size ,stack-effect ,register))
88
89;; name number size stack-effect register-used
90(define-opcode nop 0 1 0 nil)
91(define-opcode aconst_null 1 1 1 nil)
92(define-opcode iconst_m1 2 1 1 nil)
93(define-opcode iconst_0 3 1 1 nil)
94(define-opcode iconst_1 4 1 1 nil)
95(define-opcode iconst_2 5 1 1 nil)
96(define-opcode iconst_3 6 1 1 nil)
97(define-opcode iconst_4 7 1 1 nil)
98(define-opcode iconst_5 8 1 1 nil)
99(define-opcode lconst_0 9 1 2 nil)
100(define-opcode lconst_1 10 1 2 nil)
101(define-opcode fconst_0 11 1 1 nil)
102(define-opcode fconst_1 12 1 1 nil)
103(define-opcode fconst_2 13 1 1 nil)
104(define-opcode dconst_0 14 1 2 nil)
105(define-opcode dconst_1 15 1 2 nil)
106(define-opcode bipush 16 2 1 nil)
107(define-opcode sipush 17 3 1 nil)
108(define-opcode ldc 18 2 1 nil)
109(define-opcode ldc_w 19 3 1 nil)
110(define-opcode ldc2_w 20 3 2 nil)
111(define-opcode iload 21 2 1 t)
112(define-opcode lload 22 2 2 t)
113(define-opcode fload 23 2 nil t)
114(define-opcode dload 24 2 nil t)
115(define-opcode aload 25 2 1 t)
116(define-opcode iload_0 26 1 1 0)
117(define-opcode iload_1 27 1 1 1)
118(define-opcode iload_2 28 1 1 2)
119(define-opcode iload_3 29 1 1 3)
120(define-opcode lload_0 30 1 2 0)
121(define-opcode lload_1 31 1 2 1)
122(define-opcode lload_2 32 1 2 2)
123(define-opcode lload_3 33 1 2 3)
124(define-opcode fload_0 34 1 nil 0)
125(define-opcode fload_1 35 1 nil 1)
126(define-opcode fload_2 36 1 nil 2)
127(define-opcode fload_3 37 1 nil 3)
128(define-opcode dload_0 38 1 nil 0)
129(define-opcode dload_1 39 1 nil 1)
130(define-opcode dload_2 40 1 nil 2)
131(define-opcode dload_3 41 1 nil 3)
132(define-opcode aload_0 42 1 1 0)
133(define-opcode aload_1 43 1 1 1)
134(define-opcode aload_2 44 1 1 2)
135(define-opcode aload_3 45 1 1 3)
136(define-opcode iaload 46 1 -1 nil)
137(define-opcode laload 47 1 0 nil)
138(define-opcode faload 48 1 -1 nil)
139(define-opcode daload 49 1 0 nil)
140(define-opcode aaload 50 1 -1 nil)
141(define-opcode baload 51 1 nil nil)
142(define-opcode caload 52 1 nil nil)
143(define-opcode saload 53 1 nil nil)
144(define-opcode istore 54 2 -1 t)
145(define-opcode lstore 55 2 -2 t)
146(define-opcode fstore 56 2 nil t)
147(define-opcode dstore 57 2 nil t)
148(define-opcode astore 58 2 -1 t)
149(define-opcode istore_0 59 1 -1 0)
150(define-opcode istore_1 60 1 -1 1)
151(define-opcode istore_2 61 1 -1 2)
152(define-opcode istore_3 62 1 -1 3)
153(define-opcode lstore_0 63 1 -2 0)
154(define-opcode lstore_1 64 1 -2 1)
155(define-opcode lstore_2 65 1 -2 2)
156(define-opcode lstore_3 66 1 -2 3)
157(define-opcode fstore_0 67 1 nil 0)
158(define-opcode fstore_1 68 1 nil 1)
159(define-opcode fstore_2 69 1 nil 2)
160(define-opcode fstore_3 70 1 nil 3)
161(define-opcode dstore_0 71 1 nil 0)
162(define-opcode dstore_1 72 1 nil 1)
163(define-opcode dstore_2 73 1 nil 2)
164(define-opcode dstore_3 74 1 nil 3)
165(define-opcode astore_0 75 1 -1 0)
166(define-opcode astore_1 76 1 -1 1)
167(define-opcode astore_2 77 1 -1 2)
168(define-opcode astore_3 78 1 -1 3)
169(define-opcode iastore 79 1 -3 nil)
170(define-opcode lastore 80 1 -4 nil)
171(define-opcode fastore 81 1 -3 nil)
172(define-opcode dastore 82 1 -4 nil)
173(define-opcode aastore 83 1 -3 nil)
174(define-opcode bastore 84 1 nil nil)
175(define-opcode castore 85 1 nil nil)
176(define-opcode sastore 86 1 nil nil)
177(define-opcode pop 87 1 -1 nil)
178(define-opcode pop2 88 1 -2 nil)
179(define-opcode dup 89 1 1 nil)
180(define-opcode dup_x1 90 1 1 nil)
181(define-opcode dup_x2 91 1 1 nil)
182(define-opcode dup2 92 1 2 nil)
183(define-opcode dup2_x1 93 1 2 nil)
184(define-opcode dup2_x2 94 1 2 nil)
185(define-opcode swap 95 1 0 nil)
186(define-opcode iadd 96 1 -1 nil)
187(define-opcode ladd 97 1 -2 nil)
188(define-opcode fadd 98 1 -1 nil)
189(define-opcode dadd 99 1 -2 nil)
190(define-opcode isub 100 1 -1 nil)
191(define-opcode lsub 101 1 -2 nil)
192(define-opcode fsub 102 1 -1 nil)
193(define-opcode dsub 103 1 -2 nil)
194(define-opcode imul 104 1 -1 nil)
195(define-opcode lmul 105 1 -2 nil)
196(define-opcode fmul 106 1 -1 nil)
197(define-opcode dmul 107 1 -2 nil)
198(define-opcode idiv 108 1 nil nil)
199(define-opcode ldiv 109 1 nil nil)
200(define-opcode fdiv 110 1 nil nil)
201(define-opcode ddiv 111 1 nil nil)
202(define-opcode irem 112 1 nil nil)
203(define-opcode lrem 113 1 nil nil)
204(define-opcode frem 114 1 nil nil)
205(define-opcode drem 115 1 nil nil)
206(define-opcode ineg 116 1 0 nil)
207(define-opcode lneg 117 1 0 nil)
208(define-opcode fneg 118 1 0 nil)
209(define-opcode dneg 119 1 0 nil)
210(define-opcode ishl 120 1 -1 nil)
211(define-opcode lshl 121 1 -1 nil)
212(define-opcode ishr 122 1 -1 nil)
213(define-opcode lshr 123 1 -1 nil)
214(define-opcode iushr 124 1 nil nil)
215(define-opcode lushr 125 1 nil nil)
216(define-opcode iand 126 1 -1 nil)
217(define-opcode land 127 1 -2 nil)
218(define-opcode ior 128 1 -1 nil)
219(define-opcode lor 129 1 -2 nil)
220(define-opcode ixor 130 1 -1 nil)
221(define-opcode lxor 131 1 -2 nil)
222(define-opcode iinc 132 3 0 t)
223(define-opcode i2l 133 1 1 nil)
224(define-opcode i2f 134 1 0 nil)
225(define-opcode i2d 135 1 1 nil)
226(define-opcode l2i 136 1 -1 nil)
227(define-opcode l2f 137 1 -1 nil)
228(define-opcode l2d 138 1 0 nil)
229(define-opcode f2i 139 1 nil nil)
230(define-opcode f2l 140 1 nil nil)
231(define-opcode f2d 141 1 1 nil)
232(define-opcode d2i 142 1 nil nil)
233(define-opcode d2l 143 1 nil nil)
234(define-opcode d2f 144 1 -1 nil)
235(define-opcode i2b 145 1 nil nil)
236(define-opcode i2c 146 1 nil nil)
237(define-opcode i2s 147 1 nil nil)
238(define-opcode lcmp 148 1 -3 nil)
239(define-opcode fcmpl 149 1 -1 nil)
240(define-opcode fcmpg 150 1 -1 nil)
241(define-opcode dcmpl 151 1 -3 nil)
242(define-opcode dcmpg 152 1 -3 nil)
243(define-opcode ifeq 153 3 -1 nil)
244(define-opcode ifne 154 3 -1 nil)
245(define-opcode iflt 155 3 -1 nil)
246(define-opcode ifge 156 3 -1 nil)
247(define-opcode ifgt 157 3 -1 nil)
248(define-opcode ifle 158 3 -1 nil)
249(define-opcode if_icmpeq 159 3 -2 nil)
250(define-opcode if_icmpne 160 3 -2 nil)
251(define-opcode if_icmplt 161 3 -2 nil)
252(define-opcode if_icmpge 162 3 -2 nil)
253(define-opcode if_icmpgt 163 3 -2 nil)
254(define-opcode if_icmple 164 3 -2 nil)
255(define-opcode if_acmpeq 165 3 -2 nil)
256(define-opcode if_acmpne 166 3 -2 nil)
257(define-opcode goto 167 3 0 nil)
258;;(define-opcode jsr 168 3 1) Don't use these 2 opcodes: deprecated
259;;(define-opcode ret 169 2 0) their use results in JVM verifier errors
260(define-opcode tableswitch 170 0 nil nil)
261(define-opcode lookupswitch 171 0 nil nil)
262(define-opcode ireturn 172 1 nil nil)
263(define-opcode lreturn 173 1 nil nil)
264(define-opcode freturn 174 1 nil nil)
265(define-opcode dreturn 175 1 nil nil)
266(define-opcode ireturn 172 1 -1 nil)
267(define-opcode areturn 176 1 -1 nil)
268(define-opcode return 177 1 0 nil)
269(define-opcode getstatic 178 3 1 nil)
270(define-opcode putstatic 179 3 -1 nil)
271(define-opcode getfield 180 3 0 nil)
272(define-opcode putfield 181 3 -2 nil)
273(define-opcode invokevirtual 182 3 nil nil)
274(define-opcode invokespecial 183 3 nil nil)
275(define-opcode invokestatic 184 3 nil nil)
276(define-opcode invokeinterface 185 5 nil nil)
277(define-opcode unused 186 0 nil nil)
278(define-opcode new 187 3 1 nil)
279(define-opcode newarray 188 2 nil nil)
280(define-opcode anewarray 189 3 0 nil)
281(define-opcode arraylength 190 1 0 nil)
282(define-opcode athrow 191 1 0 nil)
283(define-opcode checkcast 192 3 0 nil)
284(define-opcode instanceof 193 3 0 nil)
285(define-opcode monitorenter 194 1 -1 nil)
286(define-opcode monitorexit 195 1 -1 nil)
287(define-opcode wide 196 0 nil nil)
288(define-opcode multianewarray 197 4 nil nil)
289(define-opcode ifnull 198 3 -1 nil)
290(define-opcode ifnonnull 199 3 nil nil)
291(define-opcode goto_w 200 5 nil nil)
292;; (define-opcode jsr_w 201 5 nil) Don't use: deprecated
293(define-opcode label 202 0 0 nil)  ;; virtual: does not exist in the JVM
294;; (define-opcode push-value 203 nil 1)
295;; (define-opcode store-value 204 nil -1)
296(define-opcode clear-values 205 0 0 t)  ;; virtual: does not exist in the JVM
297;;(define-opcode var-ref 206 0 0)
298
299(defparameter *last-opcode* 206)
300
301(declaim (ftype (function (t) t) opcode-name))
302(defun opcode-name (opcode-number)
303  (let ((opcode (gethash opcode-number *opcodes*)))
304    (and opcode (jvm-opcode-name opcode))))
305
306(declaim (ftype (function (t) (integer 0 255)) opcode-number))
307(defun opcode-number (opcode-name)
308  (declare (optimize speed))
309  (let ((opcode (gethash (string opcode-name) *opcodes*)))
310    (if opcode
311        (jvm-opcode-number opcode)
312        (error "Unknown opcode ~S." opcode-name))))
313
314(declaim (ftype (function (t) fixnum) opcode-size))
315(defun opcode-size (opcode-number)
316  (declare (optimize speed (safety 0)))
317  (declare (type (integer 0 255) opcode-number))
318  (jvm-opcode-size (svref *opcode-table* opcode-number)))
319
320(declaim (ftype (function (t) t) opcode-stack-effect))
321(defun opcode-stack-effect (opcode-number)
322  (declare (optimize speed))
323  (jvm-opcode-stack-effect (svref *opcode-table* opcode-number)))
324
325
326
327
328;;   INSTRUCTION
329
330(defstruct (instruction (:constructor %make-instruction (opcode args)))
331  (opcode 0 :type (integer 0 255))
332  args
333  stack
334  depth
335  wide)
336
337(defun make-instruction (opcode args)
338  (let ((inst (apply #'%make-instruction
339                     (list opcode
340                           (remove :wide-prefix args)))))
341    (when (memq :wide-prefix args)
342      (setf (inst-wide inst) t))
343    inst))
344
345(defun print-instruction (instruction)
346  (sys::%format nil "~A ~A stack = ~S depth = ~S"
347          (opcode-name (instruction-opcode instruction))
348          (instruction-args instruction)
349          (instruction-stack instruction)
350          (instruction-depth instruction)))
351
352(declaim (ftype (function (t) t) instruction-label))
353(defun instruction-label (instruction)
354  (and instruction
355       (= (instruction-opcode (the instruction instruction)) 202)
356       (car (instruction-args instruction))))
357
358
359
360(defknown inst * t)
361(defun inst (instr &optional args)
362  (declare (optimize speed))
363  (let ((opcode (if (fixnump instr)
364                    instr
365                    (opcode-number instr))))
366    (unless (listp args)
367      (setf args (list args)))
368    (make-instruction opcode args)))
369
370
371;; Having %emit and %%emit output their code to *code*
372;; is currently an implementation detail exposed to all users.
373;; We need to have APIs to address this, but for now pass2 is
374;; our only user and we'll hard-code the use of *code*.
375(defvar *code* nil)
376
377(defknown %%emit * t)
378(defun %%emit (instr &rest args)
379  (declare (optimize speed))
380  (let ((instruction (make-instruction instr args)))
381    (push instruction *code*)
382    instruction))
383
384(defknown %emit * t)
385(defun %emit (instr &rest args)
386  (declare (optimize speed))
387  (let ((instruction (inst instr args)))
388    (push instruction *code*)
389    instruction))
390
391(defmacro emit (instr &rest args)
392  (when (and (consp instr)
393             (eq (car instr) 'QUOTE)
394             (symbolp (cadr instr)))
395    (setf instr (opcode-number (cadr instr))))
396  (if (fixnump instr)
397      `(%%emit ,instr ,@args)
398      `(%emit ,instr ,@args)))
399
400
401;;  Helper routines
402
403(defknown label (symbol) t)
404(defun label (symbol)
405  (declare (type symbol symbol))
406  (declare (optimize speed))
407  (emit 'label symbol)
408  (setf (symbol-value symbol) nil))
409
410(defknown aload (fixnum) t)
411(defun aload (index)
412  (case index
413    (0 (emit 'aload_0))
414    (1 (emit 'aload_1))
415    (2 (emit 'aload_2))
416    (3 (emit 'aload_3))
417    (t (emit 'aload index))))
418
419(defknown astore (fixnum) t)
420(defun astore (index)
421  (case index
422    (0 (emit 'astore_0))
423    (1 (emit 'astore_1))
424    (2 (emit 'astore_2))
425    (3 (emit 'astore_3))
426    (t (emit 'astore index))))
427
428(declaim (ftype (function (t) t) branch-p)
429         (inline branch-p))
430(defun branch-p (opcode)
431;;  (declare (optimize speed))
432;;  (declare (type '(integer 0 255) opcode))
433  (or (<= 153 opcode 167)
434      (<= 198 opcode 200))) ;; ifnull / ifnonnull / goto_w
435
436(declaim (ftype (function (t) t) unconditional-control-transfer-p)
437         (inline unconditional-control-transfer-p))
438(defun unconditional-control-transfer-p (opcode)
439  (or (= 167 opcode) ;; goto
440      (= 200 opcode) ;; goto_w
441      (<= 172 opcode 177) ;; ?return
442      (= 191 opcode) ;; athrow
443      ))
444
445(declaim (ftype (function (t) boolean) label-p)
446         (inline label-p))
447(defun label-p (instruction)
448  (and instruction
449       (= (the fixnum (instruction-opcode (the instruction instruction))) 202)))
450
451(defun print-code (code)
452  (dotimes (i (length code))
453    (let ((instruction (elt code i)))
454      (sys::%format t "~D ~A ~S ~S ~S~%"
455                    i
456                    (opcode-name (instruction-opcode instruction))
457                    (instruction-args instruction)
458                    (instruction-stack instruction)
459                    (instruction-depth instruction)))))
460
461(defun print-code2 (code)
462  (dotimes (i (length code))
463    (let ((instruction (elt code i)))
464      (case (instruction-opcode instruction)
465        (202 ; LABEL
466         (format t "~A:~%" (car (instruction-args instruction))))
467        (t
468         (format t "~8D:   ~A ~S~%"
469                 i
470                 (opcode-name (instruction-opcode instruction))
471                 (instruction-args instruction)))))))
472
473(defun expand-virtual-instructions (code)
474  (let* ((len (length code))
475         (vector (make-array (ash len 1) :fill-pointer 0 :adjustable t)))
476    (dotimes (index len vector)
477      (declare (type (unsigned-byte 16) index))
478      (let ((instruction (svref code index)))
479        (case (instruction-opcode instruction)
480          (205 ; CLEAR-VALUES
481           (dolist (instruction
482                     (list
483                      (inst 'aload (car (instruction-args instruction)))
484                      (inst 'aconst_null)
485                      (inst 'putfield (u2 (pool-field +lisp-thread+ "_values"
486                                                      +lisp-object-array+)))))
487             (vector-push-extend instruction vector)))
488          (t
489           (vector-push-extend instruction vector)))))))
490
491
492;;   RESOLVERS
493
494(defun unsupported-opcode (instruction)
495  (error "Unsupported opcode ~D." (instruction-opcode instruction)))
496
497(declaim (type hash-table +resolvers+))
498(defconst +resolvers+ (make-hash-table))
499
500(defun initialize-resolvers ()
501  (let ((ht +resolvers+))
502    (dotimes (n (1+ *last-opcode*))
503      (setf (gethash n ht) #'unsupported-opcode))
504    ;; The following opcodes resolve to themselves.
505    (dolist (n '(0 ; nop
506                 1 ; aconst_null
507                 2 ; iconst_m1
508                 3 ; iconst_0
509                 4 ; iconst_1
510                 5 ; iconst_2
511                 6 ; iconst_3
512                 7 ; iconst_4
513                 8 ; iconst_5
514                 9 ; lconst_0
515                 10 ; lconst_1
516                 11 ; fconst_0
517                 12 ; fconst_1
518                 13 ; fconst_2
519                 14 ; dconst_0
520                 15 ; dconst_1
521                 42 ; aload_0
522                 43 ; aload_1
523                 44 ; aload_2
524                 45 ; aload_3
525                 46 ; iaload
526                 47 ; laload
527                 48 ; faload
528                 49 ; daload
529                 50 ; aaload
530                 75 ; astore_0
531                 76 ; astore_1
532                 77 ; astore_2
533                 78 ; astore_3
534                 79 ; iastore
535                 80 ; lastore
536                 81 ; fastore
537                 82 ; dastore
538                 83 ; aastore
539                 87 ; pop
540                 88 ; pop2
541                 89 ; dup
542                 90 ; dup_x1
543                 91 ; dup_x2
544                 92 ; dup2
545                 93 ; dup2_x1
546                 94 ; dup2_x2
547                 95 ; swap
548                 96 ; iadd
549                 97 ; ladd
550                 98 ; fadd
551                 99 ; dadd
552                 100 ; isub
553                 101 ; lsub
554                 102 ; fsub
555                 103 ; dsub
556                 104 ; imul
557                 105 ; lmul
558                 106 ; fmul
559                 107 ; dmul
560                 116 ; ineg
561                 117 ; lneg
562                 118 ; fneg
563                 119 ; dneg
564                 120 ; ishl
565                 121 ; lshl
566                 122 ; ishr
567                 123 ; lshr
568                 126 ; iand
569                 127 ; land
570                 128 ; ior
571                 129 ; lor
572                 130 ; ixor
573                 131 ; lxor
574                 133 ; i2l
575                 134 ; i2f
576                 135 ; i2d
577                 136 ; l2i
578                 137 ; l2f
579                 138 ; l2d
580                 141 ; f2d
581                 144 ; d2f
582                 148 ; lcmp
583                 149 ; fcmpd
584                 150 ; fcmpg
585                 151 ; dcmpd
586                 152 ; dcmpg
587                 153 ; ifeq
588                 154 ; ifne
589                 155 ; ifge
590                 156 ; ifgt
591                 157 ; ifgt
592                 158 ; ifle
593                 159 ; if_icmpeq
594                 160 ; if_icmpne
595                 161 ; if_icmplt
596                 162 ; if_icmpge
597                 163 ; if_icmpgt
598                 164 ; if_icmple
599                 165 ; if_acmpeq
600                 166 ; if_acmpne
601                 167 ; goto
602                 172 ; ireturn
603                 176 ; areturn
604                 177 ; return
605                 178 ; getstatic
606                 179 ; putstatic
607                 180 ; getfield
608                 181 ; putfield
609                 182 ; invokevirtual
610                 183 ; invockespecial
611                 184 ; invokestatic
612                 187 ; new
613                 189 ; anewarray
614                 190 ; arraylength
615                 191 ; athrow
616                 192 ; checkcast
617                 193 ; instanceof
618                 194 ; monitorenter
619                 195 ; monitorexit
620                 198 ; ifnull
621                 202 ; label
622                 ))
623      (setf (gethash n ht) nil))))
624
625(initialize-resolvers)
626
627(defmacro define-resolver (opcodes args &body body)
628  (let ((name (gensym)))
629    `(progn
630       (defun ,name ,args ,@body)
631       (eval-when (:load-toplevel :execute)
632         ,(if (listp opcodes)
633              `(dolist (op ',opcodes)
634                 (setf (gethash op +resolvers+)
635                       (symbol-function ',name)))
636              `(setf (gethash ,opcodes +resolvers+)
637                     (symbol-function ',name)))))))
638
639(defun load/store-resolver (instruction inst-index inst-index2 error-text)
640 (let* ((args (instruction-args instruction))
641        (index (car args)))
642   (declare (type (unsigned-byte 16) index))
643   (cond ((<= 0 index 3)
644          (inst (+ index inst-index)))
645         ((<= 0 index 255)
646          (inst inst-index2 index))
647         (t
648          (error error-text)))))
649
650;; aload
651(define-resolver 25 (instruction)
652  (load/store-resolver instruction 42 25 "ALOAD unsupported case"))
653
654;; astore
655(define-resolver 58 (instruction)
656  (load/store-resolver instruction 75 58 "ASTORE unsupported case"))
657
658;; iload
659(define-resolver 21 (instruction)
660  (load/store-resolver instruction 26 21 "ILOAD unsupported case"))
661
662;; istore
663(define-resolver 54 (instruction)
664  (load/store-resolver instruction 59 54 "ISTORE unsupported case"))
665
666;; lload
667(define-resolver 22 (instruction)
668  (load/store-resolver instruction 30 22 "LLOAD unsupported case"))
669
670;; lstore
671(define-resolver 55 (instruction)
672  (load/store-resolver instruction 63 55 "LSTORE unsupported case"))
673
674;; bipush, sipush
675(define-resolver (16 17) (instruction)
676  (let* ((args (instruction-args instruction))
677         (n (first args)))
678    (declare (type fixnum n))
679    (cond ((<= 0 n 5)
680           (inst (+ n 3)))
681          ((<= -128 n 127)
682           (inst 16 (logand n #xff))) ; BIPUSH
683          (t ; SIPUSH
684           (inst 17 (s2 n))))))
685
686;; ldc
687(define-resolver 18 (instruction)
688  (let* ((args (instruction-args instruction)))
689    (unless (= (length args) 1)
690      (error "Wrong number of args for LDC."))
691    (if (> (car args) 255)
692        (inst 19 (u2 (car args))) ; LDC_W
693        (inst 18 args))))
694
695;; ldc_w
696(define-resolver 19 (instruction)
697  (let* ((args (instruction-args instruction)))
698    (unless (= (length args) 1)
699      (error "Wrong number of args for LDC_W."))
700    (inst 19 (u2 (car args)))))
701
702;; ldc2_w
703(define-resolver 20 (instruction)
704  (let* ((args (instruction-args instruction)))
705    (unless (= (length args) 1)
706      (error "Wrong number of args for LDC2_W."))
707    (inst 20 (u2 (car args)))))
708
709;; iinc
710(define-resolver 132 (instruction)
711  (let* ((args (instruction-args instruction))
712         (register (first args))
713         (n (second args)))
714    (when (not (<= -128 n 127))
715      (error "IINC argument ~A out of bounds." n))
716    (inst 132 (list register (s1 n)))))
717
718(defknown resolve-instruction (t) t)
719(defun resolve-instruction (instruction)
720  (declare (optimize speed))
721  (let ((resolver (gethash1 (instruction-opcode instruction) +resolvers+)))
722    (if resolver
723        (funcall resolver instruction)
724        instruction)))
725
726(defun resolve-instructions (code)
727  (let* ((len (length code))
728         (vector (make-array len :fill-pointer 0 :adjustable t)))
729    (dotimes (index len vector)
730      (declare (type (unsigned-byte 16) index))
731      (let ((instruction (aref code index)))
732        (vector-push-extend (resolve-instruction instruction) vector)))))
733
734
735
736;; BYTE CODE ANALYSIS AND OPTIMIZATION
737
738(declaim (ftype (function (t t t) t) analyze-stack-path))
739(defun analyze-stack-path (code start-index depth)
740  (declare (optimize speed))
741  (declare (type fixnum start-index depth))
742  (do* ((i start-index (1+ i))
743        (limit (length code)))
744       ((>= i limit))
745    (declare (type fixnum i limit))
746    (let* ((instruction (aref code i))
747           (instruction-depth (instruction-depth instruction))
748           (instruction-stack (instruction-stack instruction)))
749      (declare (type fixnum instruction-stack))
750      (when instruction-depth
751        (unless (= (the fixnum instruction-depth)
752                   (the fixnum (+ depth instruction-stack)))
753          (internal-compiler-error "Stack inconsistency detected ~
754                                    in ~A at index ~D: ~
755                                    found ~S, expected ~S."
756                                   (if *current-compiland*
757                                       (compiland-name *current-compiland*)
758                                       "<unknown>")
759                                   i instruction-depth
760                                   (+ depth instruction-stack)))
761        (return-from analyze-stack-path))
762      (let ((opcode (instruction-opcode instruction)))
763        (setf depth (+ depth instruction-stack))
764        (setf (instruction-depth instruction) depth)
765        (unless (<= 0 depth)
766          (internal-compiler-error "Stack inconsistency detected ~
767                                    in ~A at index ~D: ~
768                                    negative depth ~S."
769                                   (if *current-compiland*
770                                       (compiland-name *current-compiland*)
771                                       "<unknown>")
772                                   i depth))
773        (when (branch-p opcode)
774          (let ((label (car (instruction-args instruction))))
775            (declare (type symbol label))
776            (analyze-stack-path code (symbol-value label) depth)))
777        (when (unconditional-control-transfer-p opcode)
778          ;; Current path ends.
779          (return-from analyze-stack-path))))))
780
781(declaim (ftype (function (t) t) analyze-stack))
782(defun analyze-stack (code exception-entry-points)
783  (declare (optimize speed))
784  (let* ((code-length (length code)))
785    (declare (type vector code))
786    (dotimes (i code-length)
787      (let* ((instruction (aref code i))
788             (opcode (instruction-opcode instruction)))
789        (when (eql opcode 202) ; LABEL
790          (let ((label (car (instruction-args instruction))))
791            (set label i)))
792        (if (instruction-stack instruction)
793            (when (opcode-stack-effect opcode)
794              (unless (eql (instruction-stack instruction)
795                           (opcode-stack-effect opcode))
796                (sys::%format t "instruction-stack = ~S ~
797                                 opcode-stack-effect = ~S~%"
798                              (instruction-stack instruction)
799                              (opcode-stack-effect opcode))
800                (sys::%format t "index = ~D instruction = ~A~%" i
801                              (print-instruction instruction))))
802            (setf (instruction-stack instruction)
803                  (opcode-stack-effect opcode)))
804        (unless (instruction-stack instruction)
805          (sys::%format t "no stack information for instruction ~D~%"
806                        (instruction-opcode instruction))
807          (aver nil))))
808    (analyze-stack-path code 0 0)
809    (dolist (entry-point exception-entry-points)
810      ;; Stack depth is always 1 when handler is called.
811      (analyze-stack-path code (symbol-value entry-point) 1))
812    (let ((max-stack 0))
813      (declare (type fixnum max-stack))
814      (dotimes (i code-length)
815        (let* ((instruction (aref code i))
816               (instruction-depth (instruction-depth instruction)))
817          (when instruction-depth
818            (setf max-stack (max max-stack (the fixnum instruction-depth))))))
819      max-stack)))
820
821(defun analyze-locals (code)
822  (let ((code-length (length code))
823        (max-local 0))
824    (dotimes (i code-length max-local)
825      (let* ((instruction (aref code i))
826             (opcode (instruction-opcode instruction)))
827        (setf max-local
828              (max max-local
829                   (or (let ((opcode-register
830                                (jvm-opcode-register-used opcode)))
831                         (if (eq t opcode-register)
832                             (car (instruction-args instruction))
833                             opcode-register))
834                       0)))))))
835
836(defun delete-unused-labels (code handler-labels)
837  (declare (optimize speed))
838  (let ((code (coerce code 'vector))
839        (changed nil)
840        (marker (gensym)))
841    ;; Mark the labels that are actually branched to.
842    (dotimes (i (length code))
843      (let ((instruction (aref code i)))
844        (when (branch-p (instruction-opcode instruction))
845          (let ((label (car (instruction-args instruction))))
846            (set label marker)))))
847    ;; Add labels used for exception handlers.
848    (dolist (label handler-labels)
849      (set label marker))
850    ;; Remove labels that are not used as branch targets.
851    (dotimes (i (length code))
852      (let ((instruction (aref code i)))
853        (when (= (instruction-opcode instruction) 202) ; LABEL
854          (let ((label (car (instruction-args instruction))))
855            (declare (type symbol label))
856            (unless (eq (symbol-value label) marker)
857              (setf (aref code i) nil)
858              (setf changed t))))))
859    (values (if changed (delete nil code) code)
860            changed)))
861
862(defun delete-unreachable-code (code)
863  ;; Look for unreachable code after GOTO.
864  (declare (optimize speed))
865  (let* ((code (coerce code 'vector))
866         (changed nil)
867         (after-goto/areturn nil))
868    (dotimes (i (length code))
869      (declare (type (unsigned-byte 16) i))
870      (let* ((instruction (aref code i))
871             (opcode (instruction-opcode instruction)))
872        (cond (after-goto/areturn
873               (if (= opcode 202) ; LABEL
874                   (setf after-goto/areturn nil)
875                   ;; Unreachable.
876                   (progn
877                     (setf (aref code i) nil)
878                     (setf changed t))))
879              ((unconditional-control-transfer-p opcode)
880               (setf after-goto/areturn t)))))
881    (values (if changed (delete nil code) code)
882            changed)))
883
884
885(declaim (ftype (function (t) label-target-instructions) hash-labels))
886(defun label-target-instructions (code)
887  (let ((ht (make-hash-table :test 'eq))
888        (code (coerce code 'vector))
889        (pending-labels '()))
890    (dotimes (i (length code))
891      (let ((instruction (aref code i)))
892        (cond ((label-p instruction)
893               (push (instruction-label instruction) pending-labels))
894              (t
895               ;; Not a label.
896               (when pending-labels
897                 (dolist (label pending-labels)
898                   (setf (gethash label ht) instruction))
899                 (setf pending-labels nil))))))
900    ht))
901
902(defun optimize-jumps (code)
903  (declare (optimize speed))
904  (let* ((code (coerce code 'vector))
905         (ht (label-target-instructions code))
906         (changed nil))
907    (dotimes (i (length code))
908      (let* ((instruction (aref code i))
909             (opcode (and instruction (instruction-opcode instruction))))
910        (when (and opcode (branch-p opcode))
911          (let* ((target-label (car (instruction-args instruction)))
912                 (next-instruction (gethash1 target-label ht)))
913            (when next-instruction
914              (case (instruction-opcode next-instruction)
915                ((167 200)                  ;; GOTO
916                 (setf (instruction-args instruction)
917                       (instruction-args next-instruction)
918                       changed t))
919                (176 ; ARETURN
920                 (when (unconditional-control-transfer-p opcode)
921                   (setf (instruction-opcode instruction) 176
922                         (instruction-args instruction) nil
923                         changed t)))))))))
924    (values code changed)))
925
926
927(defun optimize-instruction-sequences (code)
928  (let* ((code (coerce code 'vector))
929         (changed nil))
930    (dotimes (i (1- (length code)))
931      (let* ((this-instruction (aref code i))
932             (this-opcode (and this-instruction
933                               (instruction-opcode this-instruction)))
934             (labels-skipped-p nil)
935             (next-instruction (do ((j (1+ i) (1+ j)))
936                                   ((or (>= j (length code))
937                                        (/= 202 ; LABEL
938                                            (instruction-opcode (aref code j))))
939                                    (when (< j (length code))
940                                      (aref code j)))
941                                 (setf labels-skipped-p t)))
942             (next-opcode (and next-instruction
943                               (instruction-opcode next-instruction))))
944        (case this-opcode
945          (205 ; CLEAR-VALUES
946           (when (eql next-opcode 205)       ; CLEAR-VALUES
947             (setf (aref code i) nil)
948             (setf changed t)))
949          (178 ; GETSTATIC
950           (when (and (eql next-opcode 87)   ; POP
951                      (not labels-skipped-p))
952             (setf (aref code i) nil)
953             (setf (aref code (1+ i)) nil)
954             (setf changed t)))
955          (176 ; ARETURN
956           (when (eql next-opcode 176)       ; ARETURN
957             (setf (aref code i) nil)
958             (setf changed t)))
959          ((200 167)                         ; GOTO GOTO_W
960           (when (and (or (eql next-opcode 202)  ; LABEL
961                          (eql next-opcode 200)  ; GOTO_W
962                          (eql next-opcode 167)) ; GOTO
963                      (eq (car (instruction-args this-instruction))
964                          (car (instruction-args next-instruction))))
965             (setf (aref code i) nil)
966             (setf changed t))))))
967    (values (if changed (delete nil code) code)
968            changed)))
969
970(defvar *enable-optimization* t)
971
972(defknown optimize-code (t t) t)
973(defun optimize-code (code handler-labels)
974  (unless *enable-optimization*
975    (format t "optimizations are disabled~%"))
976  (when *enable-optimization*
977    (when *compiler-debug*
978      (format t "----- before optimization -----~%")
979      (print-code code))
980    (loop
981       (let ((changed-p nil))
982         (multiple-value-setq
983             (code changed-p)
984           (delete-unused-labels code handler-labels))
985         (if changed-p
986             (setf code (optimize-instruction-sequences code))
987             (multiple-value-setq
988                 (code changed-p)
989               (optimize-instruction-sequences code)))
990         (if changed-p
991             (setf code (optimize-jumps code))
992             (multiple-value-setq
993                 (code changed-p)
994               (optimize-jumps code)))
995         (if changed-p
996             (setf code (delete-unreachable-code code))
997             (multiple-value-setq
998                 (code changed-p)
999               (delete-unreachable-code code)))
1000         (unless changed-p
1001           (return))))
1002    (unless (vectorp code)
1003      (setf code (coerce code 'vector)))
1004    (when *compiler-debug*
1005      (sys::%format t "----- after optimization -----~%")
1006      (print-code code)))
1007  code)
1008
1009
1010
1011
1012(defun code-bytes (code)
1013  (let ((length 0)
1014        labels ;; alist
1015        )
1016    (declare (type (unsigned-byte 16) length))
1017    ;; Pass 1: calculate label offsets and overall length.
1018    (dotimes (i (length code))
1019      (declare (type (unsigned-byte 16) i))
1020      (let* ((instruction (aref code i))
1021             (opcode (instruction-opcode instruction)))
1022        (if (= opcode 202) ; LABEL
1023            (let ((label (car (instruction-args instruction))))
1024              (set label length)
1025              (setf labels
1026                    (acons label length labels)))
1027            (incf length (opcode-size opcode)))))
1028    ;; Pass 2: replace labels with calculated offsets.
1029    (let ((index 0))
1030      (declare (type (unsigned-byte 16) index))
1031      (dotimes (i (length code))
1032        (declare (type (unsigned-byte 16) i))
1033        (let ((instruction (aref code i)))
1034          (when (branch-p (instruction-opcode instruction))
1035            (let* ((label (car (instruction-args instruction)))
1036                   (offset (- (the (unsigned-byte 16)
1037                                (symbol-value (the symbol label)))
1038                              index)))
1039              (setf (instruction-args instruction) (s2 offset))))
1040          (unless (= (instruction-opcode instruction) 202) ; LABEL
1041            (incf index (opcode-size (instruction-opcode instruction)))))))
1042    ;; Expand instructions into bytes, skipping LABEL pseudo-instructions.
1043    (let ((bytes (make-array length))
1044          (index 0))
1045      (declare (type (unsigned-byte 16) index))
1046      (dotimes (i (length code))
1047        (declare (type (unsigned-byte 16) i))
1048        (let ((instruction (aref code i)))
1049          (unless (= (instruction-opcode instruction) 202) ; LABEL
1050            (setf (svref bytes index) (instruction-opcode instruction))
1051            (incf index)
1052            (dolist (byte (instruction-args instruction))
1053              (setf (svref bytes index) byte)
1054              (incf index)))))
1055      (values bytes labels))))
1056
1057(defun finalize-code (code handler-labels optimize)
1058  (setf code (coerce (nreverse code) 'vector))
1059  (when optimize
1060    (setf code (optimize-code code handler-labels)))
1061  (resolve-instructions (expand-virtual-instructions code)))
1062
1063(provide '#:opcodes)
Note: See TracBrowser for help on using the repository browser.