![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to wm_shrx.S CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / b / kernel / emulator|
Return to wm_shrx.S CVS log | Up to [MW Coherent from dump] / coherent / b / kernel / emulator |
1.1 ! root 1: .file "wm_shrx.S" ! 2: /*---------------------------------------------------------------------------+ ! 3: | wm_shrx.S | ! 4: | | ! 5: | 64 bit right shift functions | ! 6: | | ! 7: | Copyright (C) 1992 W. Metzenthen, 22 Parker St, Ormond, Vic 3163, | ! 8: | Australia. E-mail [email protected] | ! 9: | | ! 10: | Call from C as: | ! 11: | unsigned shrx(void *arg1, unsigned arg2) | ! 12: | and | ! 13: | unsigned shrxs(void *arg1, unsigned arg2) | ! 14: | | ! 15: +---------------------------------------------------------------------------*/ ! 16: ! 17: #include "fpu_asm.h" ! 18: ! 19: .text ! 20: .align 2,144 ! 21: ! 22: /*---------------------------------------------------------------------------+ ! 23: | unsigned shrx(void *arg1, unsigned arg2) | ! 24: | | ! 25: | Extended shift right function. | ! 26: | Fastest for small shifts. | ! 27: | Shifts the 64 bit quantity pointed to by the first arg (arg1) | ! 28: | right by the number of bits specified by the second arg (arg2). | ! 29: | Forms a 96 bit quantity from the 64 bit arg and eax: | ! 30: | [ 64 bit arg ][ eax ] | ! 31: | shift right ---------> | ! 32: | The eax register is initialized to 0 before the shifting. | ! 33: | Results returned in the 64 bit arg and eax. | ! 34: +---------------------------------------------------------------------------*/ ! 35: ! 36: .globl shrx ! 37: ! 38: shrx: ! 39: push %ebp ! 40: movl %esp,%ebp ! 41: pushl %esi ! 42: movl PARAM2,%ecx ! 43: movl PARAM1,%esi ! 44: cmpl $32,%ecx /* shrd only works for 0..31 bits */ ! 45: jnc L_more_than_31 ! 46: ! 47: /* less than 32 bits */ ! 48: pushl %ebx ! 49: movl (%esi),%ebx // lsl ! 50: movl 4(%esi),%edx // msl ! 51: xorl %eax,%eax // extension ! 52: shrd %cl,%ebx,%eax ! 53: shrd %cl,%edx,%ebx ! 54: shr %cl,%edx ! 55: movl %ebx,(%esi) ! 56: movl %edx,4(%esi) ! 57: popl %ebx ! 58: popl %esi ! 59: leave ! 60: ret ! 61: ! 62: L_more_than_31: ! 63: cmpl $64,%ecx ! 64: jnc L_more_than_63 ! 65: ! 66: subb $32,%cl ! 67: movl (%esi),%eax // lsl ! 68: movl 4(%esi),%edx // msl ! 69: shrd %cl,%edx,%eax ! 70: shr %cl,%edx ! 71: movl %edx,(%esi) ! 72: movl $0,4(%esi) ! 73: popl %esi ! 74: leave ! 75: ret ! 76: ! 77: L_more_than_63: ! 78: cmpl $96,%ecx ! 79: jnc L_more_than_95 ! 80: ! 81: subb $64,%cl ! 82: movl 4(%esi),%eax // msl ! 83: shr %cl,%eax ! 84: xorl %edx,%edx ! 85: movl %edx,(%esi) ! 86: movl %edx,4(%esi) ! 87: popl %esi ! 88: leave ! 89: ret ! 90: ! 91: L_more_than_95: ! 92: xorl %eax,%eax ! 93: movl %eax,(%esi) ! 94: movl %eax,4(%esi) ! 95: popl %esi ! 96: leave ! 97: ret ! 98: ! 99: ! 100: /*---------------------------------------------------------------------------+ ! 101: | unsigned shrxs(void *arg1, unsigned arg2) | ! 102: | | ! 103: | Extended shift right function (optimized for small floating point | ! 104: | integers). | ! 105: | Shifts the 64 bit quantity pointed to by the first arg (arg1) | ! 106: | right by the number of bits specified by the second arg (arg2). | ! 107: | Forms a 96 bit quantity from the 64 bit arg and eax: | ! 108: | [ 64 bit arg ][ eax ] | ! 109: | shift right ---------> | ! 110: | The eax register is initialized to 0 before the shifting. | ! 111: | The lower 8 bits of eax are lost and replaced by a flag which is | ! 112: | set (to 0x01) if any bit, apart from the first one, is set in the | ! 113: | part which has been shifted out of the arg. | ! 114: | Results returned in the 64 bit arg and eax. | ! 115: +---------------------------------------------------------------------------*/ ! 116: .globl shrxs ! 117: shrxs: ! 118: push %ebp ! 119: movl %esp,%ebp ! 120: pushl %esi ! 121: pushl %ebx ! 122: movl PARAM2,%ecx ! 123: movl PARAM1,%esi ! 124: cmpl $64,%ecx /* shrd only works for 0..31 bits */ ! 125: jnc Ls_more_than_63 ! 126: ! 127: cmpl $32,%ecx /* shrd only works for 0..31 bits */ ! 128: jc Ls_less_than_32 ! 129: ! 130: /* We got here without jumps by assuming that the most common requirement ! 131: is for small integers */ ! 132: /* Shift by [32..63] bits */ ! 133: subb $32,%cl ! 134: movl (%esi),%eax // lsl ! 135: movl 4(%esi),%edx // msl ! 136: xorl %ebx,%ebx ! 137: shrd %cl,%eax,%ebx ! 138: shrd %cl,%edx,%eax ! 139: shr %cl,%edx ! 140: orl %ebx,%ebx /* test these 32 bits */ ! 141: setne %bl ! 142: test $0x7fffffff,%eax /* and 31 bits here */ ! 143: setne %bh ! 144: orw %bx,%bx /* Any of the 63 bit set ? */ ! 145: setne %al ! 146: movl %edx,(%esi) ! 147: movl $0,4(%esi) ! 148: popl %ebx ! 149: popl %esi ! 150: leave ! 151: ret ! 152: ! 153: /* Shift by [0..31] bits */ ! 154: Ls_less_than_32: ! 155: movl (%esi),%ebx // lsl ! 156: movl 4(%esi),%edx // msl ! 157: xorl %eax,%eax // extension ! 158: shrd %cl,%ebx,%eax ! 159: shrd %cl,%edx,%ebx ! 160: shr %cl,%edx ! 161: test $0x7fffffff,%eax /* only need to look at eax here */ ! 162: setne %al ! 163: movl %ebx,(%esi) ! 164: movl %edx,4(%esi) ! 165: popl %ebx ! 166: popl %esi ! 167: leave ! 168: ret ! 169: ! 170: /* Shift by [64..95] bits */ ! 171: Ls_more_than_63: ! 172: cmpl $96,%ecx ! 173: jnc Ls_more_than_95 ! 174: ! 175: subb $64,%cl ! 176: movl (%esi),%ebx // lsl ! 177: movl 4(%esi),%eax // msl ! 178: xorl %edx,%edx // extension ! 179: shrd %cl,%ebx,%edx ! 180: shrd %cl,%eax,%ebx ! 181: shr %cl,%eax ! 182: orl %ebx,%edx ! 183: setne %bl ! 184: test $0x7fffffff,%eax /* only need to look at eax here */ ! 185: setne %bh ! 186: orw %bx,%bx ! 187: setne %al ! 188: xorl %edx,%edx ! 189: movl %edx,(%esi) // set to zero ! 190: movl %edx,4(%esi) // set to zero ! 191: popl %ebx ! 192: popl %esi ! 193: leave ! 194: ret ! 195: ! 196: Ls_more_than_95: ! 197: /* Shift by [96..inf) bits */ ! 198: xorl %eax,%eax ! 199: movl (%esi),%ebx ! 200: orl 4(%esi),%ebx ! 201: setne %al ! 202: xorl %ebx,%ebx ! 203: movl %ebx,(%esi) ! 204: movl %ebx,4(%esi) ! 205: popl %ebx ! 206: popl %esi ! 207: leave ! 208: ret
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.