• Top
    • Documentation
    • Books
    • Boolean-reasoning
    • Projects
    • Debugging
    • Std
    • Proof-automation
    • Macro-libraries
    • ACL2
    • Interfacing-tools
    • Hardware-verification
      • Gl
      • Esim
      • Vl2014
      • Sv
        • Svex-stvs
        • Svex-decomposition-methodology
        • Sv-versus-esim
        • Svex-decomp
        • Svex-compose-dfs
        • Svex-compilation
        • Moddb
        • Svmods
        • Svstmt
        • Sv-tutorial
        • Expressions
          • Rewriting
          • Svex
          • Bit-blasting
          • Functions
            • 4vec-operations
              • 4vec-bit?
              • 4vec-part-install
              • 4vec-concat
              • 4vec-?
              • 4vec-rsh
                • 4vec-bit?!
                • 4vec-===*
                • 4vec-reduction-and
                • 4vec-bit-extract
                • 4vec-rev-blocks
                • 4vec-lsh
                • 4vec-resor
                • 4vec-resand
                • 4vec-parity
                • 4vec-plus
                • 4vec-<
                • 4vec-minus
                • 4vec-res
                • 4vec-override
                • 4vec-bit-index
                • 4vec-?!
                • 4vec-zero-ext
                • 4vec-part-select
                • 4vec-===
                • 4vec-remainder
                • 4vec-reduction-or
                • 4vec-idx->4v
                • 4vec-==
                • 4vec-sign-ext
                • 4vec-quotient
                • 4vec-?*
                • 4vec-bitxor
                • 4vec-wildeq
                • 4vec-times
                • 4vec-bitmux
                • 4vec-symwildeq
                • 4vec-bitand
                • 4vec-wildeq-safe
                • 4vec-bitor
                • 4vec-shift-core
                • 4vec-pow
                • 4vec-onset
                • 4vec-offset
                • 4vec-xdet
                • 4vec-uminus
                • 4vec-clog2
                • 4vec-bitnot
                • 4vec-onehot
                • 4vec-countones
                • 4veclist-p-to-stringp
                • 4vec-p-to-stringp
                • 4vec-onehot0
                • 4vec-1mask
                • 4vec-p-to-stringp-aux
                • 4v->4vec-bit
                • 4v-to-characterp
                • Bool->vec
                • Unsigned-4vec-p
              • 3vec-operations
              • *svex-op-table*
            • 4vmask
            • Why-infinite-width
            • Svex-vars
            • Evaluation
            • Values
          • Symbolic-test-vector
          • Vl-to-svex
        • Fgl
        • Vwsim
        • Vl
        • X86isa
        • Svl
        • Rtl
      • Software-verification
      • Math
      • Testing-utilities
    • 4vec-operations

    4vec-rsh

    Right ``arithmetic'' shift of 4vecs.

    Signature
    (4vec-rsh amt src) → shifted
    Arguments
    amt — Shift amount.
        Guard (4vec-p amt).
    src — Source operand.
        Guard (4vec-p src).
    Returns
    shifted — Type (4vec-p shifted).

    In the usual case, amt is a 2vec, i.e., its bits are all good Boolean values. In this case:

    • If amt is non-negative then we ``arithmetically'' shift src to the right by amt-many places. This doesn't affect the infinitely-repeated most significant bit of src. That is, if src is negative to begin with, i.e., its upper bits are all 1s, then the resulting, shifted value will also be a negative number whose upper bits are all 1s. If src has upper bits Z, then the shifted result will also have upper bits that are all Zs, etc.
    • If amt is negative, then we shift src to the left instead of to the right, shifting in 0s from below. Note that this behavior differs from the (very strange) semantics of Verilog/SystemVerilog, where shift amounts are always treated as unsigned.

    In cases where amt has any X or Z bits, the result is just all Xes.

    Definitions and Theorems

    Function: 4vec-rsh

    (defun 4vec-rsh (amt src)
      (declare (xargs :guard (and (4vec-p amt) (4vec-p src))))
      (let ((__function__ '4vec-rsh))
        (declare (ignorable __function__))
        (if (2vec-p amt)
            (4vec-shift-core (- (2vec->val amt))
                             src)
          (4vec-x))))

    Theorem: 4vec-p-of-4vec-rsh

    (defthm 4vec-p-of-4vec-rsh
      (b* ((shifted (4vec-rsh amt src)))
        (4vec-p shifted))
      :rule-classes :rewrite)

    Theorem: 4vec-rsh-of-2vecx-fix-amt

    (defthm 4vec-rsh-of-2vecx-fix-amt
      (equal (4vec-rsh (2vecx-fix amt) src)
             (4vec-rsh amt src)))

    Theorem: 4vec-rsh-2vecx-equiv-congruence-on-amt

    (defthm 4vec-rsh-2vecx-equiv-congruence-on-amt
      (implies (2vecx-equiv amt amt-equiv)
               (equal (4vec-rsh amt src)
                      (4vec-rsh amt-equiv src)))
      :rule-classes :congruence)

    Theorem: 4vec-rsh-of-4vec-fix-src

    (defthm 4vec-rsh-of-4vec-fix-src
      (equal (4vec-rsh amt (4vec-fix src))
             (4vec-rsh amt src)))

    Theorem: 4vec-rsh-4vec-equiv-congruence-on-src

    (defthm 4vec-rsh-4vec-equiv-congruence-on-src
      (implies (4vec-equiv src src-equiv)
               (equal (4vec-rsh amt src)
                      (4vec-rsh amt src-equiv)))
      :rule-classes :congruence)