diff --git a/basis/cpu/x86/32/bootstrap.factor b/basis/cpu/x86/32/bootstrap.factor
index 81779ac9f4..37f9b3ada0 100644
--- a/basis/cpu/x86/32/bootstrap.factor
+++ b/basis/cpu/x86/32/bootstrap.factor
@@ -6,6 +6,9 @@ IN: bootstrap.x86
 
 4 \ cell set
 
+: shift-arg ( -- reg ) ECX ;
+: div-arg ( -- reg ) EAX ;
+: mod-arg ( -- reg ) EDX ;
 : arg0 ( -- reg ) EAX ;
 : arg1 ( -- reg ) EDX ;
 : temp-reg ( -- reg ) EBX ;
diff --git a/basis/cpu/x86/64/bootstrap.factor b/basis/cpu/x86/64/bootstrap.factor
index 0092843bca..c1f5156178 100644
--- a/basis/cpu/x86/64/bootstrap.factor
+++ b/basis/cpu/x86/64/bootstrap.factor
@@ -6,6 +6,9 @@ IN: bootstrap.x86
 
 8 \ cell set
 
+: shift-arg ( -- reg ) RCX ;
+: div-arg ( -- reg ) RAX ;
+: mod-arg ( -- reg ) RDX ;
 : arg0 ( -- reg ) RDI ;
 : arg1 ( -- reg ) RSI ;
 : temp-reg ( -- reg ) RBX ;
diff --git a/basis/cpu/x86/bootstrap.factor b/basis/cpu/x86/bootstrap.factor
index c1471da915..c7c4d0de52 100644
--- a/basis/cpu/x86/bootstrap.factor
+++ b/basis/cpu/x86/bootstrap.factor
@@ -303,20 +303,30 @@ big-endian off
 ] f f f \ fixnum-bitnot define-sub-primitive
 
 [
-    ECX ds-reg [] MOV                          ! load shift count
-    ECX tag-bits get SHR                       ! untag shift count
+    shift-arg ds-reg [] MOV                    ! load shift count
+    shift-arg tag-bits get SAR                 ! untag shift count
     ds-reg bootstrap-cell SUB                  ! adjust stack pointer
     arg0 ds-reg [] MOV                         ! load value
     arg1 arg0 MOV                              ! make a copy
     arg1 CL SHL                                ! compute positive shift value in arg1
-    ECX NEG                                    ! compute negative shift value in arg0
-    arg0 CL SHR
+    shift-arg NEG                              ! compute negative shift value in arg0
+    arg0 CL SAR
     arg0 tag-mask get bitnot AND
-    ECX 0 CMP                                  ! if shift count was negative, move arg0 to arg1
-    arg1 arg0 CMOVLE
+    shift-arg 0 CMP                            ! if shift count was negative, move arg0 to arg1
+    arg1 arg0 CMOVGE
     ds-reg [] arg1 MOV                         ! push to stack
 ] f f f \ fixnum-shift-fast define-sub-primitive
 
+[
+    temp-reg ds-reg [] MOV                     ! load second parameter
+    ds-reg bootstrap-cell SUB                  ! adjust stack pointer
+    div-arg ds-reg [] MOV                      ! load first parameter
+    mod-arg div-arg MOV                        ! make a copy
+    mod-arg bootstrap-cell-bits 1- SAR         ! sign-extend
+    temp-reg IDIV                              ! divide
+    ds-reg [] mod-arg MOV                      ! push to stack
+] f f f \ fixnum-mod define-sub-primitive
+
 [
     arg0 ds-reg [] MOV                         ! load local number
     fixnum>slot@                               ! turn local number into offset
diff --git a/core/bootstrap/primitives.factor b/core/bootstrap/primitives.factor
index f55942603d..c3b13318ee 100644
--- a/core/bootstrap/primitives.factor
+++ b/core/bootstrap/primitives.factor
@@ -346,6 +346,8 @@ tuple
     { "fixnum-bitor" "math.private" }
     { "fixnum-bitxor" "math.private" }
     { "fixnum-bitnot" "math.private" }
+    { "fixnum-mod" "math.private" }
+    { "fixnum-shift-fast" "math.private" }
     { "fixnum<" "math.private" }
     { "fixnum<=" "math.private" }
     { "fixnum>" "math.private" }
@@ -399,10 +401,8 @@ tuple
     { "fixnum-" "math.private" }
     { "fixnum*" "math.private" }
     { "fixnum/i" "math.private" }
-    { "fixnum-mod" "math.private" }
     { "fixnum/mod" "math.private" }
     { "fixnum-shift" "math.private" }
-    { "fixnum-shift-fast" "math.private" }
     { "bignum=" "math.private" }
     { "bignum+" "math.private" }
     { "bignum-" "math.private" }
diff --git a/vm/math.c b/vm/math.c
index c1e13951dc..c7c5dba5a4 100644
--- a/vm/math.c
+++ b/vm/math.c
@@ -85,12 +85,6 @@ DEFINE_PRIMITIVE(fixnum_divmod)
 	dpush(tag_fixnum(x % y));
 }
 
-DEFINE_PRIMITIVE(fixnum_mod)
-{
-	POP_FIXNUMS(x,y)
-	dpush(tag_fixnum(x % y));
-}
-
 /*
  * Note the hairy overflow check.
  * If we're shifting right by n bits, we won't overflow as long as none of the
@@ -127,12 +121,6 @@ DEFINE_PRIMITIVE(fixnum_shift)
 		fixnum_to_bignum(x),y)));
 }
 
-DEFINE_PRIMITIVE(fixnum_shift_fast)
-{
-	POP_FIXNUMS(x,y)
-	dpush(tag_fixnum(y < 0 ? (x >> -y) : (x << y)));
-}
-
 /* Bignums */
 DEFINE_PRIMITIVE(fixnum_to_bignum)
 {
diff --git a/vm/math.h b/vm/math.h
index 6f81ece8a8..07d7fa9199 100644
--- a/vm/math.h
+++ b/vm/math.h
@@ -14,9 +14,7 @@ DECLARE_PRIMITIVE(fixnum_subtract);
 DECLARE_PRIMITIVE(fixnum_multiply);
 DECLARE_PRIMITIVE(fixnum_divint);
 DECLARE_PRIMITIVE(fixnum_divmod);
-DECLARE_PRIMITIVE(fixnum_mod);
 DECLARE_PRIMITIVE(fixnum_shift);
-DECLARE_PRIMITIVE(fixnum_shift_fast);
 
 CELL bignum_zero;
 CELL bignum_pos_one;
diff --git a/vm/primitives.c b/vm/primitives.c
index 94151f6c40..84cad12326 100755
--- a/vm/primitives.c
+++ b/vm/primitives.c
@@ -19,10 +19,8 @@ void *primitives[] = {
 	primitive_fixnum_subtract,
 	primitive_fixnum_multiply,
 	primitive_fixnum_divint,
-	primitive_fixnum_mod,
 	primitive_fixnum_divmod,
 	primitive_fixnum_shift,
-	primitive_fixnum_shift_fast,
 	primitive_bignum_eq,
 	primitive_bignum_add,
 	primitive_bignum_subtract,