Subversion Repositories core_arm

; Konrad Eisele <eiselekd@web.de>
; cdef_lib_i1.el: Some insn functions
;-----------------------------------------------------------------------
 
(defun is-decoder (l)
  (and (listp l) (eq (length l) 5) (hash-table-p (nth 3 l))))
 
(defun space-string (n c)
  (let ((str "")
	(e 0))
    (dotimes (e n)
      (setq str (concat str c))
    )
    `,str
  )
)
 
(defun print-decode-hash (dec depth)
  (cond 
     ((hash-table-p dec)
     (let ((p ""))
       ( maphash (function (lambda (k v)
	 (let ((p2 ""))
	   (setq p2 (concat p2 (space-string (- depth 1) "|") "+" (mapconcat 'number-to-string k "" ) "=" ))
	   (if (is-decoder v)
	       (setq p2 (concat p2 "\n" (print-decoder v depth)))
	       (setq p2 (concat p2 (mapconcat 'symbol-name v "," ) "\n"))
	   )
	   (setq p (concat p p2))
	 ))) dec )
       `,p
     ))
     ((listp dec)
      (mapconcat 'print-list dec " ")
     )
     ((t) ('"?")))
)
 
(defun print-decoder (d depth)
  (let ((l (- 31 (nth 1 d)))
	(r (+ (- 31 (nth 2 d)) 1))
	(dec (nth 3 d))
	(def (nth 4 d))
        (p ""))
    (if (not (and (eq l 31) (eq r 32)))
        (progn
	  (setq p (concat p (space-string depth "|") "[" (number-to-string l) "-" (number-to-string r) "]\n"  ))
	  (setq p (concat p (print-decode-hash dec (+ 1 depth) )))
        )
    )
    (if (eq (length def) 5)
	(if (and (eq (nth 0 def) 0) (eq (nth 1 def) 0) (> (length (nth 4 def)) 0))
	    (setq p (concat p (space-string depth "|") "+" "def=" (mapconcat 'symbol-name (nth 4 def)  " ") "\n" ))
	    (setq p (concat p (space-string depth "|") "+" "def=\n" (print-decoder def depth)))
	)
    )
    `,p
  )
)
 
(defun or-insn-set (insn) 
  (let ((e '())
	(v '())
	(m '()))
    (dolist (e insn v)
      (if (eq v '())
	(setq v (make-setbit-groups (make-set-bitstring (symbol-value e))))
	(setq v (or-setbit-groups  v (make-setbit-groups (make-set-bitstring (symbol-value e))) ))
      )
    )
  )
)
 
(defun insn-max-setenc-set-acc (start end i)
  (let ((a '())
        (v '())
	(e '()))
    (mapcar (function (lambda (x)
       (if (cmp* (cut-copy-list (make-set-bitstring (symbol-value x)) start end) 1)
	   (setq a (cons x a)))
       )) i)
    `,a
    )
  )
 
 
;cc: (( 0 0 0) (1 1) (0 0))
;i: 1           x
;(clear-setenc-set '(( 0 0 0) (1 1) (1 1)) 1)
(defun clear-setenc-set (cc i)
  (let ((e '())
	(v '())
	(j 0))
    (dolist (e cc v)
      (if (eq i j)
	  (setq v (append `(,(make-list (length e) 0)) v))
	  (setq v (append `(,e) v))
      )
      (setq j (1+ j))
    )
    (reverse v)
  )
)
 
(defun setenc-set-p (cc)
  ; check weater a setbit set is remaining
  (let ((e '())
	(v '()))
    (dolist (e cc v)
      (if (eq (nth 0 e) 1)
	(setq v 't)
      )
    )
  )
)
 
 
; returns: (ccindex ((insn set)(insn set complement)))
(defun insn-max-setenc-set (cc insn)
  "Resturn row encode set that has the most members" 
  (let ((a (mapcar-setbit 'insn-max-setenc-set-acc cc insn))
	(v '())
	(e '())
	(i 0)
	(j -1)
	(off 0))
    (dolist (e a v)
      (if (not (memq 'nil e))
	  (if (> (length e)(length v)) 
	      (progn 
		(setq v e)
		(setq j i)
	      )
          )
      )
      (setq i (+ i 1))
    )
    `(,j ( ,v ,(remq* v insn) ) )
  )
)
 
;cc: ((0 0 0) (1 1) (1) (0 0 0))
;i: 1          x
;r: (3 5)
;(insn-get-encrange '((0 0 0) (1 1) (1) (0 0 0)) 1)
 
(defun insn-get-encrange (cc i)
  ;get range of index <i> if bitset cc 
  (let ((j 0)
	(off 0)
	(end 0))
    (dotimes (j i off) 
      (setq off (+ off (length (nth j cc)))) )
    (setq end (+ off (length (nth i cc))))
    `(,off ,end)
  )
)
 
(defun get-insn-enc (insn start end)
  ;get the encod value of insn
  (cut-copy-list (symbol-value insn) start end)
)
 
(defun create-decoder-setenc (cc insnset depth) 
  (let ((i 0)
	(start 0)
	(insn '())
	(insnc '())
	(end 0)
	(range '())
	(nset '())
	(nkey '())
	(nval '())
	(dec)
	(defdec insnset)
	)
    (if (setenc-set-p cc)
	(progn
	  (setq range (insn-max-setenc-set cc insnset))
	  (setq i (nth 0 range))
	  (setq insn (nth 0 (nth 1 range)))
	  (setq insnc (nth 1 (nth 1 range)))
	  (setq start (nth 0 (insn-get-encrange cc i)))
	  (setq end (nth 1 (insn-get-encrange cc i)))
 
	  (define-hash-table-test 'contents-hash 'equal 'sxhash)
	  (setq dec (make-hash-table :test 'contents-hash))
	  (let ((e '())
		(k '())
		(v '())
		)
	    (dolist (e insn)
	      (setq k (get-insn-enc e start end))
	      (puthash k (cons e (gethash k dec '())) dec )
	      )
	    )
	  (setq nset (clear-setenc-set cc i))
	  (maphash (function (lambda (k v)
	     (if (setenc-set-p (and-setbit-groups nset (or-insn-set v)))
		 (puthash k (create-decoder-setenc (and-setbit-groups nset (or-insn-set v) ) v (+ 1 depth)) dec)
	     )
	  )) dec)
	  (setq defdec '())
          (if (> (length insnc) 0)
	      (setq defdec (create-decoder-setenc (and-setbit-groups nset (or-insn-set insnc)  ) insnc (+ 1 depth)))
	  )
        )
    )
    `(,i ,start ,end ,dec ,defdec ) ;defdec
  )
)
 
 
;-----------------------------------------------------------------------