		Search-engine friendly clone of the ACL2 documentation.

States

Write-memory-unsigned32

Write an unsigned 32-bit integer to memory.

Signature
(write-memory-unsigned32 addr val stat feat) → new-stat
Arguments: addr — Guard (integerp addr).; val — Guard (ubyte32p val).; stat — Guard (statp stat).; feat — Guard (featp feat).
Returns: new-stat — Type (statp new-stat).

The memory address is the one of the first byte; we write that, and the subsequent bytes. We write the bytes according to endianness.

As in write-memory-unsigned8, we let the address be any integer. We use write-memory-unsigned8 twice. Note that if addr is close to 2^XLEN - 1, then the subsequent addresses may wrap around to address 0.

Definitions and Theorems

Function: write-memory-unsigned32

(defun write-memory-unsigned32 (addr val stat feat)
  (declare (xargs :guard (and (integerp addr)
                              (ubyte32p val)
                              (statp stat)
                              (featp feat))))
  (declare (xargs :guard (stat-validp stat feat)))
  (let ((__function__ 'write-memory-unsigned32))
    (declare (ignorable __function__))
    (b* ((val (ubyte32-fix val))
         (b0 (part-select val :low 0 :width 8))
         (b1 (part-select val :low 8 :width 8))
         (b2 (part-select val :low 16 :width 8))
         (b3 (part-select val :low 24 :width 8))
         ((mv 1st-byte 2nd-byte 3rd-byte 4th-byte)
          (if (feat-little-endianp feat)
              (mv b0 b1 b2 b3)
            (mv b3 b2 b1 b0)))
         (stat (write-memory-unsigned8 addr 1st-byte stat feat))
         (stat (write-memory-unsigned8 (+ (lifix addr) 1)
                                       2nd-byte stat feat))
         (stat (write-memory-unsigned8 (+ (lifix addr) 2)
                                       3rd-byte stat feat))
         (stat (write-memory-unsigned8 (+ (lifix addr) 3)
                                       4th-byte stat feat)))
      stat)))

Theorem: statp-of-write-memory-unsigned32

(defthm statp-of-write-memory-unsigned32
  (b* ((new-stat (write-memory-unsigned32 addr val stat feat)))
    (statp new-stat))
  :rule-classes :rewrite)

Theorem: stat-validp-of-write-memory-unsigned32

(defthm stat-validp-of-write-memory-unsigned32
 (implies
      (stat-validp stat feat)
      (b* ((?new-stat (write-memory-unsigned32 addr val stat feat)))
        (stat-validp new-stat feat))))

Theorem: write-memory-unsigned32-of-ifix-addr

(defthm write-memory-unsigned32-of-ifix-addr
  (equal (write-memory-unsigned32 (ifix addr)
                                  val stat feat)
         (write-memory-unsigned32 addr val stat feat)))

Theorem: write-memory-unsigned32-int-equiv-congruence-on-addr

(defthm write-memory-unsigned32-int-equiv-congruence-on-addr
  (implies
       (acl2::int-equiv addr addr-equiv)
       (equal (write-memory-unsigned32 addr val stat feat)
              (write-memory-unsigned32 addr-equiv val stat feat)))
  :rule-classes :congruence)

Theorem: write-memory-unsigned32-of-ubyte32-fix-val

(defthm write-memory-unsigned32-of-ubyte32-fix-val
  (equal (write-memory-unsigned32 addr (ubyte32-fix val)
                                  stat feat)
         (write-memory-unsigned32 addr val stat feat)))

Theorem: write-memory-unsigned32-ubyte32-equiv-congruence-on-val

(defthm write-memory-unsigned32-ubyte32-equiv-congruence-on-val
  (implies
       (acl2::ubyte32-equiv val val-equiv)
       (equal (write-memory-unsigned32 addr val stat feat)
              (write-memory-unsigned32 addr val-equiv stat feat)))
  :rule-classes :congruence)

Theorem: write-memory-unsigned32-of-stat-fix-stat

(defthm write-memory-unsigned32-of-stat-fix-stat
  (equal (write-memory-unsigned32 addr val (stat-fix stat)
                                  feat)
         (write-memory-unsigned32 addr val stat feat)))

Theorem: write-memory-unsigned32-stat-equiv-congruence-on-stat

(defthm write-memory-unsigned32-stat-equiv-congruence-on-stat
  (implies
       (stat-equiv stat stat-equiv)
       (equal (write-memory-unsigned32 addr val stat feat)
              (write-memory-unsigned32 addr val stat-equiv feat)))
  :rule-classes :congruence)

Theorem: write-memory-unsigned32-of-feat-fix-feat

(defthm write-memory-unsigned32-of-feat-fix-feat
  (equal (write-memory-unsigned32 addr val stat (feat-fix feat))
         (write-memory-unsigned32 addr val stat feat)))

Theorem: write-memory-unsigned32-feat-equiv-congruence-on-feat

(defthm write-memory-unsigned32-feat-equiv-congruence-on-feat
  (implies
       (feat-equiv feat feat-equiv)
       (equal (write-memory-unsigned32 addr val stat feat)
              (write-memory-unsigned32 addr val stat feat-equiv)))
  :rule-classes :congruence)