		Search-engine friendly clone of the ACL2 documentation.

Structures

Ia32_eferbits

An 12-bit unsigned bitstruct type.

This is a bitstruct type introduced by defbitstruct, represented as a unsigned 12-bit integer.

Fields

sce — bit
res1 — 7bits
lme — bit
res2 — bit
lma — bit
nxe — bit

Source: Intel Manual, Dec-23, Vol. 3A, Section 2.2.1

Definitions and Theorems

Function: ia32_eferbits-p$inline

(defun ia32_eferbits-p$inline (x)
  (declare (xargs :guard t))
  (mbe :logic (unsigned-byte-p 12 x)
       :exec (and (natp x) (< x 4096))))

Theorem: ia32_eferbits-p-when-unsigned-byte-p

(defthm ia32_eferbits-p-when-unsigned-byte-p
  (implies (unsigned-byte-p 12 x)
           (ia32_eferbits-p x)))

Theorem: unsigned-byte-p-when-ia32_eferbits-p

(defthm unsigned-byte-p-when-ia32_eferbits-p
  (implies (ia32_eferbits-p x)
           (unsigned-byte-p 12 x)))

Theorem: ia32_eferbits-p-compound-recognizer

(defthm ia32_eferbits-p-compound-recognizer
  (implies (ia32_eferbits-p x) (natp x))
  :rule-classes :compound-recognizer)

Function: ia32_eferbits-fix$inline

(defun ia32_eferbits-fix$inline (x)
  (declare (xargs :guard (ia32_eferbits-p x)))
  (mbe :logic (loghead 12 x) :exec x))

Theorem: ia32_eferbits-p-of-ia32_eferbits-fix

(defthm ia32_eferbits-p-of-ia32_eferbits-fix
  (b* ((fty::fixed (ia32_eferbits-fix$inline x)))
    (ia32_eferbits-p fty::fixed))
  :rule-classes :rewrite)

Theorem: ia32_eferbits-fix-when-ia32_eferbits-p

(defthm ia32_eferbits-fix-when-ia32_eferbits-p
  (implies (ia32_eferbits-p x)
           (equal (ia32_eferbits-fix x) x)))

Function: ia32_eferbits-equiv$inline

(defun ia32_eferbits-equiv$inline (x y)
  (declare (xargs :guard (and (ia32_eferbits-p x)
                              (ia32_eferbits-p y))))
  (equal (ia32_eferbits-fix x)
         (ia32_eferbits-fix y)))

Theorem: ia32_eferbits-equiv-is-an-equivalence

(defthm ia32_eferbits-equiv-is-an-equivalence
  (and (booleanp (ia32_eferbits-equiv x y))
       (ia32_eferbits-equiv x x)
       (implies (ia32_eferbits-equiv x y)
                (ia32_eferbits-equiv y x))
       (implies (and (ia32_eferbits-equiv x y)
                     (ia32_eferbits-equiv y z))
                (ia32_eferbits-equiv x z)))
  :rule-classes (:equivalence))

Theorem: ia32_eferbits-equiv-implies-equal-ia32_eferbits-fix-1

(defthm ia32_eferbits-equiv-implies-equal-ia32_eferbits-fix-1
  (implies (ia32_eferbits-equiv x x-equiv)
           (equal (ia32_eferbits-fix x)
                  (ia32_eferbits-fix x-equiv)))
  :rule-classes (:congruence))

Theorem: ia32_eferbits-fix-under-ia32_eferbits-equiv

(defthm ia32_eferbits-fix-under-ia32_eferbits-equiv
  (ia32_eferbits-equiv (ia32_eferbits-fix x)
                       x)
  :rule-classes (:rewrite :rewrite-quoted-constant))

Function: ia32_eferbits$inline

(defun ia32_eferbits$inline (sce res1 lme res2 lma nxe)
  (declare (xargs :guard (and (bitp sce)
                              (7bits-p res1)
                              (bitp lme)
                              (bitp res2)
                              (bitp lma)
                              (bitp nxe))))
  (b* ((sce (mbe :logic (bfix sce) :exec sce))
       (res1 (mbe :logic (7bits-fix res1)
                  :exec res1))
       (lme (mbe :logic (bfix lme) :exec lme))
       (res2 (mbe :logic (bfix res2) :exec res2))
       (lma (mbe :logic (bfix lma) :exec lma))
       (nxe (mbe :logic (bfix nxe) :exec nxe)))
    (logapp 1 sce
            (logapp 7 res1
                    (logapp 1 lme
                            (logapp 1 res2 (logapp 1 lma nxe)))))))

Theorem: ia32_eferbits-p-of-ia32_eferbits

(defthm ia32_eferbits-p-of-ia32_eferbits
 (b*
  ((ia32_eferbits (ia32_eferbits$inline sce res1 lme res2 lma nxe)))
  (ia32_eferbits-p ia32_eferbits))
 :rule-classes :rewrite)

Theorem: ia32_eferbits$inline-of-bfix-sce

(defthm ia32_eferbits$inline-of-bfix-sce
  (equal (ia32_eferbits$inline (bfix sce)
                               res1 lme res2 lma nxe)
         (ia32_eferbits$inline sce res1 lme res2 lma nxe)))

Theorem: ia32_eferbits$inline-bit-equiv-congruence-on-sce

(defthm ia32_eferbits$inline-bit-equiv-congruence-on-sce
 (implies
     (bit-equiv sce sce-equiv)
     (equal (ia32_eferbits$inline sce res1 lme res2 lma nxe)
            (ia32_eferbits$inline sce-equiv res1 lme res2 lma nxe)))
 :rule-classes :congruence)

Theorem: ia32_eferbits$inline-of-7bits-fix-res1

(defthm ia32_eferbits$inline-of-7bits-fix-res1
  (equal (ia32_eferbits$inline sce (7bits-fix res1)
                               lme res2 lma nxe)
         (ia32_eferbits$inline sce res1 lme res2 lma nxe)))

Theorem: ia32_eferbits$inline-7bits-equiv-congruence-on-res1

(defthm ia32_eferbits$inline-7bits-equiv-congruence-on-res1
 (implies
     (7bits-equiv res1 res1-equiv)
     (equal (ia32_eferbits$inline sce res1 lme res2 lma nxe)
            (ia32_eferbits$inline sce res1-equiv lme res2 lma nxe)))
 :rule-classes :congruence)

Theorem: ia32_eferbits$inline-of-bfix-lme

(defthm ia32_eferbits$inline-of-bfix-lme
  (equal (ia32_eferbits$inline sce res1 (bfix lme)
                               res2 lma nxe)
         (ia32_eferbits$inline sce res1 lme res2 lma nxe)))

Theorem: ia32_eferbits$inline-bit-equiv-congruence-on-lme

(defthm ia32_eferbits$inline-bit-equiv-congruence-on-lme
 (implies
     (bit-equiv lme lme-equiv)
     (equal (ia32_eferbits$inline sce res1 lme res2 lma nxe)
            (ia32_eferbits$inline sce res1 lme-equiv res2 lma nxe)))
 :rule-classes :congruence)

Theorem: ia32_eferbits$inline-of-bfix-res2

(defthm ia32_eferbits$inline-of-bfix-res2
  (equal (ia32_eferbits$inline sce res1 lme (bfix res2)
                               lma nxe)
         (ia32_eferbits$inline sce res1 lme res2 lma nxe)))

Theorem: ia32_eferbits$inline-bit-equiv-congruence-on-res2

(defthm ia32_eferbits$inline-bit-equiv-congruence-on-res2
 (implies
     (bit-equiv res2 res2-equiv)
     (equal (ia32_eferbits$inline sce res1 lme res2 lma nxe)
            (ia32_eferbits$inline sce res1 lme res2-equiv lma nxe)))
 :rule-classes :congruence)

Theorem: ia32_eferbits$inline-of-bfix-lma

(defthm ia32_eferbits$inline-of-bfix-lma
  (equal (ia32_eferbits$inline sce res1 lme res2 (bfix lma)
                               nxe)
         (ia32_eferbits$inline sce res1 lme res2 lma nxe)))

Theorem: ia32_eferbits$inline-bit-equiv-congruence-on-lma

(defthm ia32_eferbits$inline-bit-equiv-congruence-on-lma
 (implies
     (bit-equiv lma lma-equiv)
     (equal (ia32_eferbits$inline sce res1 lme res2 lma nxe)
            (ia32_eferbits$inline sce res1 lme res2 lma-equiv nxe)))
 :rule-classes :congruence)

Theorem: ia32_eferbits$inline-of-bfix-nxe

(defthm ia32_eferbits$inline-of-bfix-nxe
  (equal (ia32_eferbits$inline sce res1 lme res2 lma (bfix nxe))
         (ia32_eferbits$inline sce res1 lme res2 lma nxe)))

Theorem: ia32_eferbits$inline-bit-equiv-congruence-on-nxe

(defthm ia32_eferbits$inline-bit-equiv-congruence-on-nxe
 (implies
     (bit-equiv nxe nxe-equiv)
     (equal (ia32_eferbits$inline sce res1 lme res2 lma nxe)
            (ia32_eferbits$inline sce res1 lme res2 lma nxe-equiv)))
 :rule-classes :congruence)

Function: ia32_eferbits-equiv-under-mask$inline

(defun ia32_eferbits-equiv-under-mask$inline (x x1 mask)
  (declare (xargs :guard (and (ia32_eferbits-p x)
                              (ia32_eferbits-p x1)
                              (integerp mask))))
  (fty::int-equiv-under-mask (ia32_eferbits-fix x)
                             (ia32_eferbits-fix x1)
                             mask))

Function: ia32_eferbits->sce$inline

(defun ia32_eferbits->sce$inline (x)
  (declare (xargs :guard (ia32_eferbits-p x)))
  (mbe :logic
       (let ((x (ia32_eferbits-fix x)))
         (part-select x :low 0 :width 1))
       :exec (the (unsigned-byte 1)
                  (logand (the (unsigned-byte 1) 1)
                          (the (unsigned-byte 12) x)))))

Theorem: bitp-of-ia32_eferbits->sce

(defthm bitp-of-ia32_eferbits->sce
  (b* ((sce (ia32_eferbits->sce$inline x)))
    (bitp sce))
  :rule-classes :rewrite)

Theorem: ia32_eferbits->sce$inline-of-ia32_eferbits-fix-x

(defthm ia32_eferbits->sce$inline-of-ia32_eferbits-fix-x
  (equal (ia32_eferbits->sce$inline (ia32_eferbits-fix x))
         (ia32_eferbits->sce$inline x)))

Theorem: ia32_eferbits->sce$inline-ia32_eferbits-equiv-congruence-on-x

(defthm
      ia32_eferbits->sce$inline-ia32_eferbits-equiv-congruence-on-x
  (implies (ia32_eferbits-equiv x x-equiv)
           (equal (ia32_eferbits->sce$inline x)
                  (ia32_eferbits->sce$inline x-equiv)))
  :rule-classes :congruence)

Theorem: ia32_eferbits->sce-of-ia32_eferbits

(defthm ia32_eferbits->sce-of-ia32_eferbits
 (equal
      (ia32_eferbits->sce (ia32_eferbits sce res1 lme res2 lma nxe))
      (bfix sce)))

Theorem: ia32_eferbits->sce-of-write-with-mask

(defthm ia32_eferbits->sce-of-write-with-mask
  (implies (and (fty::bitstruct-read-over-write-hyps
                     x ia32_eferbits-equiv-under-mask)
                (ia32_eferbits-equiv-under-mask x y fty::mask)
                (equal (logand (lognot fty::mask) 1) 0))
           (equal (ia32_eferbits->sce x)
                  (ia32_eferbits->sce y))))

Function: ia32_eferbits->res1$inline

(defun ia32_eferbits->res1$inline (x)
 (declare (xargs :guard (ia32_eferbits-p x)))
 (mbe
    :logic
    (let ((x (ia32_eferbits-fix x)))
      (part-select x :low 1 :width 7))
    :exec (the (unsigned-byte 7)
               (logand (the (unsigned-byte 7) 127)
                       (the (unsigned-byte 11)
                            (ash (the (unsigned-byte 12) x) -1))))))

Theorem: 7bits-p-of-ia32_eferbits->res1

(defthm 7bits-p-of-ia32_eferbits->res1
  (b* ((res1 (ia32_eferbits->res1$inline x)))
    (7bits-p res1))
  :rule-classes :rewrite)

Theorem: ia32_eferbits->res1$inline-of-ia32_eferbits-fix-x

(defthm ia32_eferbits->res1$inline-of-ia32_eferbits-fix-x
  (equal (ia32_eferbits->res1$inline (ia32_eferbits-fix x))
         (ia32_eferbits->res1$inline x)))

Theorem: ia32_eferbits->res1$inline-ia32_eferbits-equiv-congruence-on-x

(defthm
     ia32_eferbits->res1$inline-ia32_eferbits-equiv-congruence-on-x
  (implies (ia32_eferbits-equiv x x-equiv)
           (equal (ia32_eferbits->res1$inline x)
                  (ia32_eferbits->res1$inline x-equiv)))
  :rule-classes :congruence)

Theorem: ia32_eferbits->res1-of-ia32_eferbits

(defthm ia32_eferbits->res1-of-ia32_eferbits
 (equal
     (ia32_eferbits->res1 (ia32_eferbits sce res1 lme res2 lma nxe))
     (7bits-fix res1)))

Theorem: ia32_eferbits->res1-of-write-with-mask

(defthm ia32_eferbits->res1-of-write-with-mask
  (implies (and (fty::bitstruct-read-over-write-hyps
                     x ia32_eferbits-equiv-under-mask)
                (ia32_eferbits-equiv-under-mask x y fty::mask)
                (equal (logand (lognot fty::mask) 254)
                       0))
           (equal (ia32_eferbits->res1 x)
                  (ia32_eferbits->res1 y))))

Function: ia32_eferbits->lme$inline

(defun ia32_eferbits->lme$inline (x)
 (declare (xargs :guard (ia32_eferbits-p x)))
 (mbe
    :logic
    (let ((x (ia32_eferbits-fix x)))
      (part-select x :low 8 :width 1))
    :exec (the (unsigned-byte 1)
               (logand (the (unsigned-byte 1) 1)
                       (the (unsigned-byte 4)
                            (ash (the (unsigned-byte 12) x) -8))))))

Theorem: bitp-of-ia32_eferbits->lme

(defthm bitp-of-ia32_eferbits->lme
  (b* ((lme (ia32_eferbits->lme$inline x)))
    (bitp lme))
  :rule-classes :rewrite)

Theorem: ia32_eferbits->lme$inline-of-ia32_eferbits-fix-x

(defthm ia32_eferbits->lme$inline-of-ia32_eferbits-fix-x
  (equal (ia32_eferbits->lme$inline (ia32_eferbits-fix x))
         (ia32_eferbits->lme$inline x)))

Theorem: ia32_eferbits->lme$inline-ia32_eferbits-equiv-congruence-on-x

(defthm
      ia32_eferbits->lme$inline-ia32_eferbits-equiv-congruence-on-x
  (implies (ia32_eferbits-equiv x x-equiv)
           (equal (ia32_eferbits->lme$inline x)
                  (ia32_eferbits->lme$inline x-equiv)))
  :rule-classes :congruence)

Theorem: ia32_eferbits->lme-of-ia32_eferbits

(defthm ia32_eferbits->lme-of-ia32_eferbits
 (equal
      (ia32_eferbits->lme (ia32_eferbits sce res1 lme res2 lma nxe))
      (bfix lme)))

Theorem: ia32_eferbits->lme-of-write-with-mask

(defthm ia32_eferbits->lme-of-write-with-mask
  (implies (and (fty::bitstruct-read-over-write-hyps
                     x ia32_eferbits-equiv-under-mask)
                (ia32_eferbits-equiv-under-mask x y fty::mask)
                (equal (logand (lognot fty::mask) 256)
                       0))
           (equal (ia32_eferbits->lme x)
                  (ia32_eferbits->lme y))))

Function: ia32_eferbits->res2$inline

(defun ia32_eferbits->res2$inline (x)
 (declare (xargs :guard (ia32_eferbits-p x)))
 (mbe
    :logic
    (let ((x (ia32_eferbits-fix x)))
      (part-select x :low 9 :width 1))
    :exec (the (unsigned-byte 1)
               (logand (the (unsigned-byte 1) 1)
                       (the (unsigned-byte 3)
                            (ash (the (unsigned-byte 12) x) -9))))))

Theorem: bitp-of-ia32_eferbits->res2

(defthm bitp-of-ia32_eferbits->res2
  (b* ((res2 (ia32_eferbits->res2$inline x)))
    (bitp res2))
  :rule-classes :rewrite)

Theorem: ia32_eferbits->res2$inline-of-ia32_eferbits-fix-x

(defthm ia32_eferbits->res2$inline-of-ia32_eferbits-fix-x
  (equal (ia32_eferbits->res2$inline (ia32_eferbits-fix x))
         (ia32_eferbits->res2$inline x)))

Theorem: ia32_eferbits->res2$inline-ia32_eferbits-equiv-congruence-on-x

(defthm
     ia32_eferbits->res2$inline-ia32_eferbits-equiv-congruence-on-x
  (implies (ia32_eferbits-equiv x x-equiv)
           (equal (ia32_eferbits->res2$inline x)
                  (ia32_eferbits->res2$inline x-equiv)))
  :rule-classes :congruence)

Theorem: ia32_eferbits->res2-of-ia32_eferbits

(defthm ia32_eferbits->res2-of-ia32_eferbits
 (equal
     (ia32_eferbits->res2 (ia32_eferbits sce res1 lme res2 lma nxe))
     (bfix res2)))

Theorem: ia32_eferbits->res2-of-write-with-mask

(defthm ia32_eferbits->res2-of-write-with-mask
  (implies (and (fty::bitstruct-read-over-write-hyps
                     x ia32_eferbits-equiv-under-mask)
                (ia32_eferbits-equiv-under-mask x y fty::mask)
                (equal (logand (lognot fty::mask) 512)
                       0))
           (equal (ia32_eferbits->res2 x)
                  (ia32_eferbits->res2 y))))

Function: ia32_eferbits->lma$inline

(defun ia32_eferbits->lma$inline (x)
  (declare (xargs :guard (ia32_eferbits-p x)))
  (mbe :logic
       (let ((x (ia32_eferbits-fix x)))
         (part-select x :low 10 :width 1))
       :exec (the (unsigned-byte 1)
                  (logand (the (unsigned-byte 1) 1)
                          (the (unsigned-byte 2)
                               (ash (the (unsigned-byte 12) x)
                                    -10))))))

Theorem: bitp-of-ia32_eferbits->lma

(defthm bitp-of-ia32_eferbits->lma
  (b* ((lma (ia32_eferbits->lma$inline x)))
    (bitp lma))
  :rule-classes :rewrite)

Theorem: ia32_eferbits->lma$inline-of-ia32_eferbits-fix-x

(defthm ia32_eferbits->lma$inline-of-ia32_eferbits-fix-x
  (equal (ia32_eferbits->lma$inline (ia32_eferbits-fix x))
         (ia32_eferbits->lma$inline x)))

Theorem: ia32_eferbits->lma$inline-ia32_eferbits-equiv-congruence-on-x

(defthm
      ia32_eferbits->lma$inline-ia32_eferbits-equiv-congruence-on-x
  (implies (ia32_eferbits-equiv x x-equiv)
           (equal (ia32_eferbits->lma$inline x)
                  (ia32_eferbits->lma$inline x-equiv)))
  :rule-classes :congruence)

Theorem: ia32_eferbits->lma-of-ia32_eferbits

(defthm ia32_eferbits->lma-of-ia32_eferbits
 (equal
      (ia32_eferbits->lma (ia32_eferbits sce res1 lme res2 lma nxe))
      (bfix lma)))

Theorem: ia32_eferbits->lma-of-write-with-mask

(defthm ia32_eferbits->lma-of-write-with-mask
  (implies (and (fty::bitstruct-read-over-write-hyps
                     x ia32_eferbits-equiv-under-mask)
                (ia32_eferbits-equiv-under-mask x y fty::mask)
                (equal (logand (lognot fty::mask) 1024)
                       0))
           (equal (ia32_eferbits->lma x)
                  (ia32_eferbits->lma y))))

Function: ia32_eferbits->nxe$inline

(defun ia32_eferbits->nxe$inline (x)
  (declare (xargs :guard (ia32_eferbits-p x)))
  (mbe :logic
       (let ((x (ia32_eferbits-fix x)))
         (part-select x :low 11 :width 1))
       :exec (the (unsigned-byte 1)
                  (logand (the (unsigned-byte 1) 1)
                          (the (unsigned-byte 1)
                               (ash (the (unsigned-byte 12) x)
                                    -11))))))

Theorem: bitp-of-ia32_eferbits->nxe

(defthm bitp-of-ia32_eferbits->nxe
  (b* ((nxe (ia32_eferbits->nxe$inline x)))
    (bitp nxe))
  :rule-classes :rewrite)

Theorem: ia32_eferbits->nxe$inline-of-ia32_eferbits-fix-x

(defthm ia32_eferbits->nxe$inline-of-ia32_eferbits-fix-x
  (equal (ia32_eferbits->nxe$inline (ia32_eferbits-fix x))
         (ia32_eferbits->nxe$inline x)))

Theorem: ia32_eferbits->nxe$inline-ia32_eferbits-equiv-congruence-on-x

(defthm
      ia32_eferbits->nxe$inline-ia32_eferbits-equiv-congruence-on-x
  (implies (ia32_eferbits-equiv x x-equiv)
           (equal (ia32_eferbits->nxe$inline x)
                  (ia32_eferbits->nxe$inline x-equiv)))
  :rule-classes :congruence)

Theorem: ia32_eferbits->nxe-of-ia32_eferbits

(defthm ia32_eferbits->nxe-of-ia32_eferbits
 (equal
      (ia32_eferbits->nxe (ia32_eferbits sce res1 lme res2 lma nxe))
      (bfix nxe)))

Theorem: ia32_eferbits->nxe-of-write-with-mask

(defthm ia32_eferbits->nxe-of-write-with-mask
  (implies (and (fty::bitstruct-read-over-write-hyps
                     x ia32_eferbits-equiv-under-mask)
                (ia32_eferbits-equiv-under-mask x y fty::mask)
                (equal (logand (lognot fty::mask) 2048)
                       0))
           (equal (ia32_eferbits->nxe x)
                  (ia32_eferbits->nxe y))))

Theorem: ia32_eferbits-fix-in-terms-of-ia32_eferbits

(defthm ia32_eferbits-fix-in-terms-of-ia32_eferbits
  (equal (ia32_eferbits-fix x)
         (change-ia32_eferbits x)))

Function: !ia32_eferbits->sce$inline

(defun !ia32_eferbits->sce$inline (sce x)
  (declare (xargs :guard (and (bitp sce) (ia32_eferbits-p x))))
  (mbe :logic
       (b* ((sce (mbe :logic (bfix sce) :exec sce))
            (x (ia32_eferbits-fix x)))
         (part-install sce x :width 1 :low 0))
       :exec (the (unsigned-byte 12)
                  (logior (the (unsigned-byte 12)
                               (logand (the (unsigned-byte 12) x)
                                       (the (signed-byte 2) -2)))
                          (the (unsigned-byte 1) sce)))))

Theorem: ia32_eferbits-p-of-!ia32_eferbits->sce

(defthm ia32_eferbits-p-of-!ia32_eferbits->sce
  (b* ((new-x (!ia32_eferbits->sce$inline sce x)))
    (ia32_eferbits-p new-x))
  :rule-classes :rewrite)

Theorem: !ia32_eferbits->sce$inline-of-bfix-sce

(defthm !ia32_eferbits->sce$inline-of-bfix-sce
  (equal (!ia32_eferbits->sce$inline (bfix sce)
                                     x)
         (!ia32_eferbits->sce$inline sce x)))

Theorem: !ia32_eferbits->sce$inline-bit-equiv-congruence-on-sce

(defthm !ia32_eferbits->sce$inline-bit-equiv-congruence-on-sce
  (implies (bit-equiv sce sce-equiv)
           (equal (!ia32_eferbits->sce$inline sce x)
                  (!ia32_eferbits->sce$inline sce-equiv x)))
  :rule-classes :congruence)

Theorem: !ia32_eferbits->sce$inline-of-ia32_eferbits-fix-x

(defthm !ia32_eferbits->sce$inline-of-ia32_eferbits-fix-x
  (equal (!ia32_eferbits->sce$inline sce (ia32_eferbits-fix x))
         (!ia32_eferbits->sce$inline sce x)))

Theorem: !ia32_eferbits->sce$inline-ia32_eferbits-equiv-congruence-on-x

(defthm
     !ia32_eferbits->sce$inline-ia32_eferbits-equiv-congruence-on-x
  (implies (ia32_eferbits-equiv x x-equiv)
           (equal (!ia32_eferbits->sce$inline sce x)
                  (!ia32_eferbits->sce$inline sce x-equiv)))
  :rule-classes :congruence)

Theorem: !ia32_eferbits->sce-is-ia32_eferbits

(defthm !ia32_eferbits->sce-is-ia32_eferbits
  (equal (!ia32_eferbits->sce sce x)
         (change-ia32_eferbits x :sce sce)))

Theorem: ia32_eferbits->sce-of-!ia32_eferbits->sce

(defthm ia32_eferbits->sce-of-!ia32_eferbits->sce
  (b* ((?new-x (!ia32_eferbits->sce$inline sce x)))
    (equal (ia32_eferbits->sce new-x)
           (bfix sce))))

Theorem: !ia32_eferbits->sce-equiv-under-mask

(defthm !ia32_eferbits->sce-equiv-under-mask
  (b* ((?new-x (!ia32_eferbits->sce$inline sce x)))
    (ia32_eferbits-equiv-under-mask new-x x -2)))

Function: !ia32_eferbits->res1$inline

(defun !ia32_eferbits->res1$inline (res1 x)
  (declare (xargs :guard (and (7bits-p res1)
                              (ia32_eferbits-p x))))
  (mbe :logic
       (b* ((res1 (mbe :logic (7bits-fix res1)
                       :exec res1))
            (x (ia32_eferbits-fix x)))
         (part-install res1 x :width 7 :low 1))
       :exec (the (unsigned-byte 12)
                  (logior (the (unsigned-byte 12)
                               (logand (the (unsigned-byte 12) x)
                                       (the (signed-byte 9) -255)))
                          (the (unsigned-byte 8)
                               (ash (the (unsigned-byte 7) res1)
                                    1))))))

Theorem: ia32_eferbits-p-of-!ia32_eferbits->res1

(defthm ia32_eferbits-p-of-!ia32_eferbits->res1
  (b* ((new-x (!ia32_eferbits->res1$inline res1 x)))
    (ia32_eferbits-p new-x))
  :rule-classes :rewrite)

Theorem: !ia32_eferbits->res1$inline-of-7bits-fix-res1

(defthm !ia32_eferbits->res1$inline-of-7bits-fix-res1
  (equal (!ia32_eferbits->res1$inline (7bits-fix res1)
                                      x)
         (!ia32_eferbits->res1$inline res1 x)))

Theorem: !ia32_eferbits->res1$inline-7bits-equiv-congruence-on-res1

(defthm !ia32_eferbits->res1$inline-7bits-equiv-congruence-on-res1
  (implies (7bits-equiv res1 res1-equiv)
           (equal (!ia32_eferbits->res1$inline res1 x)
                  (!ia32_eferbits->res1$inline res1-equiv x)))
  :rule-classes :congruence)

Theorem: !ia32_eferbits->res1$inline-of-ia32_eferbits-fix-x

(defthm !ia32_eferbits->res1$inline-of-ia32_eferbits-fix-x
  (equal (!ia32_eferbits->res1$inline res1 (ia32_eferbits-fix x))
         (!ia32_eferbits->res1$inline res1 x)))

Theorem: !ia32_eferbits->res1$inline-ia32_eferbits-equiv-congruence-on-x

(defthm
    !ia32_eferbits->res1$inline-ia32_eferbits-equiv-congruence-on-x
  (implies (ia32_eferbits-equiv x x-equiv)
           (equal (!ia32_eferbits->res1$inline res1 x)
                  (!ia32_eferbits->res1$inline res1 x-equiv)))
  :rule-classes :congruence)

Theorem: !ia32_eferbits->res1-is-ia32_eferbits

(defthm !ia32_eferbits->res1-is-ia32_eferbits
  (equal (!ia32_eferbits->res1 res1 x)
         (change-ia32_eferbits x :res1 res1)))

Theorem: ia32_eferbits->res1-of-!ia32_eferbits->res1

(defthm ia32_eferbits->res1-of-!ia32_eferbits->res1
  (b* ((?new-x (!ia32_eferbits->res1$inline res1 x)))
    (equal (ia32_eferbits->res1 new-x)
           (7bits-fix res1))))

Theorem: !ia32_eferbits->res1-equiv-under-mask

(defthm !ia32_eferbits->res1-equiv-under-mask
  (b* ((?new-x (!ia32_eferbits->res1$inline res1 x)))
    (ia32_eferbits-equiv-under-mask new-x x -255)))

Function: !ia32_eferbits->lme$inline

(defun !ia32_eferbits->lme$inline (lme x)
 (declare (xargs :guard (and (bitp lme) (ia32_eferbits-p x))))
 (mbe
    :logic
    (b* ((lme (mbe :logic (bfix lme) :exec lme))
         (x (ia32_eferbits-fix x)))
      (part-install lme x :width 1 :low 8))
    :exec (the (unsigned-byte 12)
               (logior (the (unsigned-byte 12)
                            (logand (the (unsigned-byte 12) x)
                                    (the (signed-byte 10) -257)))
                       (the (unsigned-byte 9)
                            (ash (the (unsigned-byte 1) lme) 8))))))

Theorem: ia32_eferbits-p-of-!ia32_eferbits->lme

(defthm ia32_eferbits-p-of-!ia32_eferbits->lme
  (b* ((new-x (!ia32_eferbits->lme$inline lme x)))
    (ia32_eferbits-p new-x))
  :rule-classes :rewrite)

Theorem: !ia32_eferbits->lme$inline-of-bfix-lme

(defthm !ia32_eferbits->lme$inline-of-bfix-lme
  (equal (!ia32_eferbits->lme$inline (bfix lme)
                                     x)
         (!ia32_eferbits->lme$inline lme x)))

Theorem: !ia32_eferbits->lme$inline-bit-equiv-congruence-on-lme

(defthm !ia32_eferbits->lme$inline-bit-equiv-congruence-on-lme
  (implies (bit-equiv lme lme-equiv)
           (equal (!ia32_eferbits->lme$inline lme x)
                  (!ia32_eferbits->lme$inline lme-equiv x)))
  :rule-classes :congruence)

Theorem: !ia32_eferbits->lme$inline-of-ia32_eferbits-fix-x

(defthm !ia32_eferbits->lme$inline-of-ia32_eferbits-fix-x
  (equal (!ia32_eferbits->lme$inline lme (ia32_eferbits-fix x))
         (!ia32_eferbits->lme$inline lme x)))

Theorem: !ia32_eferbits->lme$inline-ia32_eferbits-equiv-congruence-on-x

(defthm
     !ia32_eferbits->lme$inline-ia32_eferbits-equiv-congruence-on-x
  (implies (ia32_eferbits-equiv x x-equiv)
           (equal (!ia32_eferbits->lme$inline lme x)
                  (!ia32_eferbits->lme$inline lme x-equiv)))
  :rule-classes :congruence)

Theorem: !ia32_eferbits->lme-is-ia32_eferbits

(defthm !ia32_eferbits->lme-is-ia32_eferbits
  (equal (!ia32_eferbits->lme lme x)
         (change-ia32_eferbits x :lme lme)))

Theorem: ia32_eferbits->lme-of-!ia32_eferbits->lme

(defthm ia32_eferbits->lme-of-!ia32_eferbits->lme
  (b* ((?new-x (!ia32_eferbits->lme$inline lme x)))
    (equal (ia32_eferbits->lme new-x)
           (bfix lme))))

Theorem: !ia32_eferbits->lme-equiv-under-mask

(defthm !ia32_eferbits->lme-equiv-under-mask
  (b* ((?new-x (!ia32_eferbits->lme$inline lme x)))
    (ia32_eferbits-equiv-under-mask new-x x -257)))

Function: !ia32_eferbits->res2$inline

(defun !ia32_eferbits->res2$inline (res2 x)
  (declare (xargs :guard (and (bitp res2) (ia32_eferbits-p x))))
  (mbe :logic
       (b* ((res2 (mbe :logic (bfix res2) :exec res2))
            (x (ia32_eferbits-fix x)))
         (part-install res2 x :width 1 :low 9))
       :exec (the (unsigned-byte 12)
                  (logior (the (unsigned-byte 12)
                               (logand (the (unsigned-byte 12) x)
                                       (the (signed-byte 11) -513)))
                          (the (unsigned-byte 10)
                               (ash (the (unsigned-byte 1) res2)
                                    9))))))

Theorem: ia32_eferbits-p-of-!ia32_eferbits->res2

(defthm ia32_eferbits-p-of-!ia32_eferbits->res2
  (b* ((new-x (!ia32_eferbits->res2$inline res2 x)))
    (ia32_eferbits-p new-x))
  :rule-classes :rewrite)

Theorem: !ia32_eferbits->res2$inline-of-bfix-res2

(defthm !ia32_eferbits->res2$inline-of-bfix-res2
  (equal (!ia32_eferbits->res2$inline (bfix res2)
                                      x)
         (!ia32_eferbits->res2$inline res2 x)))

Theorem: !ia32_eferbits->res2$inline-bit-equiv-congruence-on-res2

(defthm !ia32_eferbits->res2$inline-bit-equiv-congruence-on-res2
  (implies (bit-equiv res2 res2-equiv)
           (equal (!ia32_eferbits->res2$inline res2 x)
                  (!ia32_eferbits->res2$inline res2-equiv x)))
  :rule-classes :congruence)

Theorem: !ia32_eferbits->res2$inline-of-ia32_eferbits-fix-x

(defthm !ia32_eferbits->res2$inline-of-ia32_eferbits-fix-x
  (equal (!ia32_eferbits->res2$inline res2 (ia32_eferbits-fix x))
         (!ia32_eferbits->res2$inline res2 x)))

Theorem: !ia32_eferbits->res2$inline-ia32_eferbits-equiv-congruence-on-x

(defthm
    !ia32_eferbits->res2$inline-ia32_eferbits-equiv-congruence-on-x
  (implies (ia32_eferbits-equiv x x-equiv)
           (equal (!ia32_eferbits->res2$inline res2 x)
                  (!ia32_eferbits->res2$inline res2 x-equiv)))
  :rule-classes :congruence)

Theorem: !ia32_eferbits->res2-is-ia32_eferbits

(defthm !ia32_eferbits->res2-is-ia32_eferbits
  (equal (!ia32_eferbits->res2 res2 x)
         (change-ia32_eferbits x :res2 res2)))

Theorem: ia32_eferbits->res2-of-!ia32_eferbits->res2

(defthm ia32_eferbits->res2-of-!ia32_eferbits->res2
  (b* ((?new-x (!ia32_eferbits->res2$inline res2 x)))
    (equal (ia32_eferbits->res2 new-x)
           (bfix res2))))

Theorem: !ia32_eferbits->res2-equiv-under-mask

(defthm !ia32_eferbits->res2-equiv-under-mask
  (b* ((?new-x (!ia32_eferbits->res2$inline res2 x)))
    (ia32_eferbits-equiv-under-mask new-x x -513)))

Function: !ia32_eferbits->lma$inline

(defun !ia32_eferbits->lma$inline (lma x)
 (declare (xargs :guard (and (bitp lma) (ia32_eferbits-p x))))
 (mbe :logic
      (b* ((lma (mbe :logic (bfix lma) :exec lma))
           (x (ia32_eferbits-fix x)))
        (part-install lma x :width 1 :low 10))
      :exec (the (unsigned-byte 12)
                 (logior (the (unsigned-byte 12)
                              (logand (the (unsigned-byte 12) x)
                                      (the (signed-byte 12) -1025)))
                         (the (unsigned-byte 11)
                              (ash (the (unsigned-byte 1) lma)
                                   10))))))

Theorem: ia32_eferbits-p-of-!ia32_eferbits->lma

(defthm ia32_eferbits-p-of-!ia32_eferbits->lma
  (b* ((new-x (!ia32_eferbits->lma$inline lma x)))
    (ia32_eferbits-p new-x))
  :rule-classes :rewrite)

Theorem: !ia32_eferbits->lma$inline-of-bfix-lma

(defthm !ia32_eferbits->lma$inline-of-bfix-lma
  (equal (!ia32_eferbits->lma$inline (bfix lma)
                                     x)
         (!ia32_eferbits->lma$inline lma x)))

Theorem: !ia32_eferbits->lma$inline-bit-equiv-congruence-on-lma

(defthm !ia32_eferbits->lma$inline-bit-equiv-congruence-on-lma
  (implies (bit-equiv lma lma-equiv)
           (equal (!ia32_eferbits->lma$inline lma x)
                  (!ia32_eferbits->lma$inline lma-equiv x)))
  :rule-classes :congruence)

Theorem: !ia32_eferbits->lma$inline-of-ia32_eferbits-fix-x

(defthm !ia32_eferbits->lma$inline-of-ia32_eferbits-fix-x
  (equal (!ia32_eferbits->lma$inline lma (ia32_eferbits-fix x))
         (!ia32_eferbits->lma$inline lma x)))

Theorem: !ia32_eferbits->lma$inline-ia32_eferbits-equiv-congruence-on-x

(defthm
     !ia32_eferbits->lma$inline-ia32_eferbits-equiv-congruence-on-x
  (implies (ia32_eferbits-equiv x x-equiv)
           (equal (!ia32_eferbits->lma$inline lma x)
                  (!ia32_eferbits->lma$inline lma x-equiv)))
  :rule-classes :congruence)

Theorem: !ia32_eferbits->lma-is-ia32_eferbits

(defthm !ia32_eferbits->lma-is-ia32_eferbits
  (equal (!ia32_eferbits->lma lma x)
         (change-ia32_eferbits x :lma lma)))

Theorem: ia32_eferbits->lma-of-!ia32_eferbits->lma

(defthm ia32_eferbits->lma-of-!ia32_eferbits->lma
  (b* ((?new-x (!ia32_eferbits->lma$inline lma x)))
    (equal (ia32_eferbits->lma new-x)
           (bfix lma))))

Theorem: !ia32_eferbits->lma-equiv-under-mask

(defthm !ia32_eferbits->lma-equiv-under-mask
  (b* ((?new-x (!ia32_eferbits->lma$inline lma x)))
    (ia32_eferbits-equiv-under-mask new-x x -1025)))

Function: !ia32_eferbits->nxe$inline

(defun !ia32_eferbits->nxe$inline (nxe x)
 (declare (xargs :guard (and (bitp nxe) (ia32_eferbits-p x))))
 (mbe :logic
      (b* ((nxe (mbe :logic (bfix nxe) :exec nxe))
           (x (ia32_eferbits-fix x)))
        (part-install nxe x :width 1 :low 11))
      :exec (the (unsigned-byte 12)
                 (logior (the (unsigned-byte 12)
                              (logand (the (unsigned-byte 12) x)
                                      (the (signed-byte 13) -2049)))
                         (the (unsigned-byte 12)
                              (ash (the (unsigned-byte 1) nxe)
                                   11))))))

Theorem: ia32_eferbits-p-of-!ia32_eferbits->nxe

(defthm ia32_eferbits-p-of-!ia32_eferbits->nxe
  (b* ((new-x (!ia32_eferbits->nxe$inline nxe x)))
    (ia32_eferbits-p new-x))
  :rule-classes :rewrite)

Theorem: !ia32_eferbits->nxe$inline-of-bfix-nxe

(defthm !ia32_eferbits->nxe$inline-of-bfix-nxe
  (equal (!ia32_eferbits->nxe$inline (bfix nxe)
                                     x)
         (!ia32_eferbits->nxe$inline nxe x)))

Theorem: !ia32_eferbits->nxe$inline-bit-equiv-congruence-on-nxe

(defthm !ia32_eferbits->nxe$inline-bit-equiv-congruence-on-nxe
  (implies (bit-equiv nxe nxe-equiv)
           (equal (!ia32_eferbits->nxe$inline nxe x)
                  (!ia32_eferbits->nxe$inline nxe-equiv x)))
  :rule-classes :congruence)

Theorem: !ia32_eferbits->nxe$inline-of-ia32_eferbits-fix-x

(defthm !ia32_eferbits->nxe$inline-of-ia32_eferbits-fix-x
  (equal (!ia32_eferbits->nxe$inline nxe (ia32_eferbits-fix x))
         (!ia32_eferbits->nxe$inline nxe x)))

Theorem: !ia32_eferbits->nxe$inline-ia32_eferbits-equiv-congruence-on-x

(defthm
     !ia32_eferbits->nxe$inline-ia32_eferbits-equiv-congruence-on-x
  (implies (ia32_eferbits-equiv x x-equiv)
           (equal (!ia32_eferbits->nxe$inline nxe x)
                  (!ia32_eferbits->nxe$inline nxe x-equiv)))
  :rule-classes :congruence)

Theorem: !ia32_eferbits->nxe-is-ia32_eferbits

(defthm !ia32_eferbits->nxe-is-ia32_eferbits
  (equal (!ia32_eferbits->nxe nxe x)
         (change-ia32_eferbits x :nxe nxe)))

Theorem: ia32_eferbits->nxe-of-!ia32_eferbits->nxe

(defthm ia32_eferbits->nxe-of-!ia32_eferbits->nxe
  (b* ((?new-x (!ia32_eferbits->nxe$inline nxe x)))
    (equal (ia32_eferbits->nxe new-x)
           (bfix nxe))))

Theorem: !ia32_eferbits->nxe-equiv-under-mask

(defthm !ia32_eferbits->nxe-equiv-under-mask
  (b* ((?new-x (!ia32_eferbits->nxe$inline nxe x)))
    (ia32_eferbits-equiv-under-mask new-x x 2047)))

Function: ia32_eferbits-debug$inline

(defun ia32_eferbits-debug$inline (x)
 (declare (xargs :guard (ia32_eferbits-p x)))
 (b* (((ia32_eferbits x)))
   (cons (cons 'sce x.sce)
         (cons (cons 'res1 x.res1)
               (cons (cons 'lme x.lme)
                     (cons (cons 'res2 x.res2)
                           (cons (cons 'lma x.lma)
                                 (cons (cons 'nxe x.nxe) nil))))))))

Subtopics

!ia32_eferbits->res1: Update the |X86ISA|::|RES1| field of a ia32_eferbits bit structure.
!ia32_eferbits->res2: Update the |X86ISA|::|RES2| field of a ia32_eferbits bit structure.
!ia32_eferbits->sce: Update the |X86ISA|::|SCE| field of a ia32_eferbits bit structure.
!ia32_eferbits->nxe: Update the |X86ISA|::|NXE| field of a ia32_eferbits bit structure.
!ia32_eferbits->lme: Update the |X86ISA|::|LME| field of a ia32_eferbits bit structure.
!ia32_eferbits->lma: Update the |X86ISA|::|LMA| field of a ia32_eferbits bit structure.
Ia32_eferbits-p: Recognizer for ia32_eferbits bit structures.
Ia32_eferbits-fix: Fixing function for ia32_eferbits bit structures.
Ia32_eferbits->res2: Access the |X86ISA|::|RES2| field of a ia32_eferbits bit structure.
Ia32_eferbits->res1: Access the |X86ISA|::|RES1| field of a ia32_eferbits bit structure.
Ia32_eferbits->nxe: Access the |X86ISA|::|NXE| field of a ia32_eferbits bit structure.
Ia32_eferbits->lme: Access the |X86ISA|::|LME| field of a ia32_eferbits bit structure.
Ia32_eferbits->lma: Access the |X86ISA|::|LMA| field of a ia32_eferbits bit structure.
Ia32_eferbits->sce: Access the |X86ISA|::|SCE| field of a ia32_eferbits bit structure.