Changeset 1564ca8 in rtems


Ignore:
Timestamp:
Feb 4, 1999, 2:56:09 PM (20 years ago)
Author:
Joel Sherrill <joel.sherrill@…>
Branches:
4.10, 4.11, 4.8, 4.9, master
Children:
d3c1060
Parents:
8cce445
Message:

Added PowerPC specific header checksum code.

Files:
5 edited

Legend:

Unmodified
Added
Removed
  • c/src/exec/libnetworking/netinet/in_cksum_powerpc.c

    r8cce445 r1564ca8  
    4343        register int len;
    4444{
     45        u_char junk;
    4546        register u_short *w;
    4647        register unsigned sum = 0;
     
    9293                        }
    9394                }
    94                 /*
    95                  * Advance to a cache line boundary.
    96                  */
    97                 if (4 & (int) w && mlen >= 4) {
    98                         ADD(0);
    99                         MOP;
    100                         w += 2;
    101                         mlen -= 4;
    102                 }
    103                 if (8 & (int) w && mlen >= 8) {
    104                         ADD(0);
    105                         ADDC(4);
    106                         MOP;
    107                         w += 4;
    108                         mlen -= 8;
    109                 }
     95
    11096                /*
    11197                 * Do as much of the checksum as possible 32 bits at at time.
    112                  * In fact, this loop is unrolled to make overhead from
    113                  * branches &c small.
     98                 * In fact, this loop is unrolled to keep overhead from
     99                 * branches small.
    114100                 */
    115                 mlen -= 1;
    116                 while ((mlen -= 32) >= 0) {
    117                         u_char junk;
     101                while (mlen >= 32) {
    118102                        /*
    119103                         * Add with carry 16 words and fold in the last
     
    129113                        ADDC(12);
    130114                        LOAD(32);
    131                         ADDC(20);
    132                         ADDC(24);
    133                         ADDC(28);
    134                         MOP;
    135                         w += 16;
    136                 }
    137                 mlen += 32 + 1;
    138                 if (mlen >= 32) {
    139                         ADD(16);
    140                         ADDC(0);
    141                         ADDC(4);
    142                         ADDC(8);
    143                         ADDC(12);
    144115                        ADDC(20);
    145116                        ADDC(24);
  • c/src/lib/libnetworking/netinet/in_cksum_powerpc.c

    r8cce445 r1564ca8  
    4343        register int len;
    4444{
     45        u_char junk;
    4546        register u_short *w;
    4647        register unsigned sum = 0;
     
    9293                        }
    9394                }
    94                 /*
    95                  * Advance to a cache line boundary.
    96                  */
    97                 if (4 & (int) w && mlen >= 4) {
    98                         ADD(0);
    99                         MOP;
    100                         w += 2;
    101                         mlen -= 4;
    102                 }
    103                 if (8 & (int) w && mlen >= 8) {
    104                         ADD(0);
    105                         ADDC(4);
    106                         MOP;
    107                         w += 4;
    108                         mlen -= 8;
    109                 }
     95
    11096                /*
    11197                 * Do as much of the checksum as possible 32 bits at at time.
    112                  * In fact, this loop is unrolled to make overhead from
    113                  * branches &c small.
     98                 * In fact, this loop is unrolled to keep overhead from
     99                 * branches small.
    114100                 */
    115                 mlen -= 1;
    116                 while ((mlen -= 32) >= 0) {
    117                         u_char junk;
     101                while (mlen >= 32) {
    118102                        /*
    119103                         * Add with carry 16 words and fold in the last
     
    129113                        ADDC(12);
    130114                        LOAD(32);
    131                         ADDC(20);
    132                         ADDC(24);
    133                         ADDC(28);
    134                         MOP;
    135                         w += 16;
    136                 }
    137                 mlen += 32 + 1;
    138                 if (mlen >= 32) {
    139                         ADD(16);
    140                         ADDC(0);
    141                         ADDC(4);
    142                         ADDC(8);
    143                         ADDC(12);
    144115                        ADDC(20);
    145116                        ADDC(24);
  • c/src/libnetworking/netinet/in_cksum_powerpc.c

    r8cce445 r1564ca8  
    4343        register int len;
    4444{
     45        u_char junk;
    4546        register u_short *w;
    4647        register unsigned sum = 0;
     
    9293                        }
    9394                }
    94                 /*
    95                  * Advance to a cache line boundary.
    96                  */
    97                 if (4 & (int) w && mlen >= 4) {
    98                         ADD(0);
    99                         MOP;
    100                         w += 2;
    101                         mlen -= 4;
    102                 }
    103                 if (8 & (int) w && mlen >= 8) {
    104                         ADD(0);
    105                         ADDC(4);
    106                         MOP;
    107                         w += 4;
    108                         mlen -= 8;
    109                 }
     95
    11096                /*
    11197                 * Do as much of the checksum as possible 32 bits at at time.
    112                  * In fact, this loop is unrolled to make overhead from
    113                  * branches &c small.
     98                 * In fact, this loop is unrolled to keep overhead from
     99                 * branches small.
    114100                 */
    115                 mlen -= 1;
    116                 while ((mlen -= 32) >= 0) {
    117                         u_char junk;
     101                while (mlen >= 32) {
    118102                        /*
    119103                         * Add with carry 16 words and fold in the last
     
    129113                        ADDC(12);
    130114                        LOAD(32);
    131                         ADDC(20);
    132                         ADDC(24);
    133                         ADDC(28);
    134                         MOP;
    135                         w += 16;
    136                 }
    137                 mlen += 32 + 1;
    138                 if (mlen >= 32) {
    139                         ADD(16);
    140                         ADDC(0);
    141                         ADDC(4);
    142                         ADDC(8);
    143                         ADDC(12);
    144115                        ADDC(20);
    145116                        ADDC(24);
  • cpukit/libnetworking/netinet/in_cksum_powerpc.c

    r8cce445 r1564ca8  
    4343        register int len;
    4444{
     45        u_char junk;
    4546        register u_short *w;
    4647        register unsigned sum = 0;
     
    9293                        }
    9394                }
    94                 /*
    95                  * Advance to a cache line boundary.
    96                  */
    97                 if (4 & (int) w && mlen >= 4) {
    98                         ADD(0);
    99                         MOP;
    100                         w += 2;
    101                         mlen -= 4;
    102                 }
    103                 if (8 & (int) w && mlen >= 8) {
    104                         ADD(0);
    105                         ADDC(4);
    106                         MOP;
    107                         w += 4;
    108                         mlen -= 8;
    109                 }
     95
    11096                /*
    11197                 * Do as much of the checksum as possible 32 bits at at time.
    112                  * In fact, this loop is unrolled to make overhead from
    113                  * branches &c small.
     98                 * In fact, this loop is unrolled to keep overhead from
     99                 * branches small.
    114100                 */
    115                 mlen -= 1;
    116                 while ((mlen -= 32) >= 0) {
    117                         u_char junk;
     101                while (mlen >= 32) {
    118102                        /*
    119103                         * Add with carry 16 words and fold in the last
     
    129113                        ADDC(12);
    130114                        LOAD(32);
    131                         ADDC(20);
    132                         ADDC(24);
    133                         ADDC(28);
    134                         MOP;
    135                         w += 16;
    136                 }
    137                 mlen += 32 + 1;
    138                 if (mlen >= 32) {
    139                         ADD(16);
    140                         ADDC(0);
    141                         ADDC(4);
    142                         ADDC(8);
    143                         ADDC(12);
    144115                        ADDC(20);
    145116                        ADDC(24);
  • cpukit/libnetworking/netinet/in_cksum_powerpc.h

    r8cce445 r1564ca8  
    4343        register int len;
    4444{
     45        u_char junk;
    4546        register u_short *w;
    4647        register unsigned sum = 0;
     
    9293                        }
    9394                }
    94                 /*
    95                  * Advance to a cache line boundary.
    96                  */
    97                 if (4 & (int) w && mlen >= 4) {
    98                         ADD(0);
    99                         MOP;
    100                         w += 2;
    101                         mlen -= 4;
    102                 }
    103                 if (8 & (int) w && mlen >= 8) {
    104                         ADD(0);
    105                         ADDC(4);
    106                         MOP;
    107                         w += 4;
    108                         mlen -= 8;
    109                 }
     95
    11096                /*
    11197                 * Do as much of the checksum as possible 32 bits at at time.
    112                  * In fact, this loop is unrolled to make overhead from
    113                  * branches &c small.
     98                 * In fact, this loop is unrolled to keep overhead from
     99                 * branches small.
    114100                 */
    115                 mlen -= 1;
    116                 while ((mlen -= 32) >= 0) {
    117                         u_char junk;
     101                while (mlen >= 32) {
    118102                        /*
    119103                         * Add with carry 16 words and fold in the last
     
    129113                        ADDC(12);
    130114                        LOAD(32);
    131                         ADDC(20);
    132                         ADDC(24);
    133                         ADDC(28);
    134                         MOP;
    135                         w += 16;
    136                 }
    137                 mlen += 32 + 1;
    138                 if (mlen >= 32) {
    139                         ADD(16);
    140                         ADDC(0);
    141                         ADDC(4);
    142                         ADDC(8);
    143                         ADDC(12);
    144115                        ADDC(20);
    145116                        ADDC(24);
Note: See TracChangeset for help on using the changeset viewer.