Changeset 45f7449 in mainline


Ignore:
Timestamp:
2013-03-31T19:46:19Z (11 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
a5057cc
Parents:
582f4d28
Message:

Revert to the state of mainline,1783.

Files:
2 added
3 deleted
15 edited

Legend:

Unmodified
Added
Removed

  • boot/arch/mips32/Makefile.inc

    r582f4d28 r45f7449  
    5050endif
    5151
     52
    5253SOURCES = \
    5354        arch/$(BARCH)/src/asm.S \

  • boot/arch/mips32/src/asm.S

    r582f4d28 r45f7449  
    3737.global halt
    3838.global jump_to_kernel
    39 .global memset
    40 .global memcpy
    4139
    4240.section BOOTSTRAP
    … …  
    160158        j $a0
    161159        nop
    162 
    163 memset:
    164         move $v0, $a0
    165         beqz $a2, 0f
    166         addiu $t1, $a2, -1
    167        
    168         negu $t0, $a0
    169         andi $t0, $t0, 0x3
    170         sltu $v1, $a2, $t0
    171         bnez $v1, 1f
    172         andi $a1, $a1, 0xff
    173        
    174         7:
    175                 sltiu $v1, $a2, 4
    176                 beqz $v1, 2f
    177                 move $v1, $v0
    178                
    179                  move $t0, $a2
    180        
    181         3:
    182                 sb $a1, 0($v1)
    183                 addiu $v1, $v1, 1
    184                 subu $a3, $v1, $v0
    185                 sltu $a3, $a3, $t0
    186                 bnez $a3, 3b
    187                 addiu $t1, $t1, -1
    188                
    189                 beq $a2, $t0, 0f
    190                 subu $a2, $a2, $t0
    191        
    192         8:
    193                 srl $a0, $a2, 0x2
    194                 sll $t4, $a0, 0x2
    195                 beqz $t4, 4f
    196                 sll $t2, $a1, 0x10
    197                
    198                 sll $t3, $a1, 0x8
    199                 or $t3, $a1, $t3
    200                 sll $a3, $a1, 0x18
    201                 or $t3, $t3, $t2
    202                 or $t3, $t3, $a3
    203                 addu $t0, $v0, $t0
    204                 move $a3, $zero
    205        
    206         5:
    207                 addiu $a3, $a3, 1
    208                 sltu $t2, $a3, $a0
    209                 sw $t3, 0($t0)
    210                 bnez $t2, 5b
    211                 addiu $t0, $t0, 4
    212                
    213                 addu $v1, $v1, $t4
    214                 beq $a2, $t4, 0f
    215                 subu $t1, $t1, $t4
    216        
    217         4:
    218                 addiu $t1, $t1, 1
    219                 addu $t1, $v1, $t1
    220                 sb $a1, 0($v1)
    221        
    222         6:
    223                 addiu $v1, $v1, 1
    224                 bnel $v1, $t1, 6b
    225                 sb $a1, 0($v1)
    226        
    227         0:
    228                 jr $ra
    229                 nop
    230        
    231         1:
    232                 j 7b
    233                 move $t0, $a2
    234        
    235         2:
    236                 bnez $t0, 3b
    237                 nop
    238                
    239                 j 8b
    240                 subu $a2, $a2, $t0
    241 
    242 memcpy:
    243         move $t2, $a0  /* save dst */
    244        
    245         addiu $v0, $a1, 3
    246         li $v1, -4  /* 0xfffffffffffffffc */
    247         and $v0, $v0, $v1
    248         beq $a1, $v0, 3f
    249         move $t0, $a0
    250        
    251         0:
    252                 beq $a2, $zero, 2f
    253                 move $a3, $zero
    254        
    255         1:
    256                 addu $v0, $a1, $a3
    257                 lbu $a0, 0($v0)
    258                 addu $v1, $t0, $a3
    259                 addiu $a3, $a3, 1
    260                 bne $a3, $a2, 1b
    261                 sb $a0, 0($v1)
    262        
    263         2:
    264                 jr $ra
    265                 move $v0, $t2
    266        
    267         3:
    268                 addiu $v0, $a0, 3
    269                 and $v0, $v0, $v1
    270                 bne $a0, $v0, 0b
    271                 srl $t1, $a2, 2
    272                
    273                 beq $t1, $zero, 5f
    274                 move $a3, $zero
    275                
    276                 move $a3, $zero
    277                 move $a0, $zero
    278        
    279         4:
    280                 addu $v0, $a1, $a0
    281                 lw $v1, 0($v0)
    282                 addiu $a3, $a3, 1
    283                 addu $v0, $t0, $a0
    284                 sw $v1, 0($v0)
    285                 bne $a3, $t1, 4b
    286                 addiu $a0, $a0, 4
    287        
    288         5:
    289                 andi $a2, $a2, 0x3
    290                 beq $a2, $zero, 2b
    291                 nop
    292                
    293                 sll $v0, $a3, 2
    294                 addu $t1, $v0, $t0
    295                 move $a3, $zero
    296                 addu $t0, $v0, $a1
    297        
    298         6:
    299                 addu $v0, $t0, $a3
    300                 lbu $a0, 0($v0)
    301                 addu $v1, $t1, $a3
    302                 addiu $a3, $a3, 1
    303                 bne $a3, $a2, 6b
    304                 sb $a0, 0($v1)
    305                
    306                 jr $ra
    307                 move $v0, $t2

  • boot/generic/include/memstr.h

    r582f4d28 r45f7449  
    3535#include <typedefs.h>
    3636
    37 #define memset(dst, val, cnt)  __builtin_memset((dst), (val), (cnt))
    38 #define memcpy(dst, src, cnt)  __builtin_memcpy((dst), (src), (cnt))
    39 
     37extern void *memcpy(void *, const void *, size_t);
     38extern void *memset(void *, int, size_t);
    4039extern void *memmove(void *, const void *, size_t);
    4140

  • boot/generic/src/memstr.c

    r582f4d28 r45f7449  
    2929#include <memstr.h>
    3030#include <typedefs.h>
     31
     32/** Move memory block without overlapping.
     33 *
     34 * Copy cnt bytes from src address to dst address. The source
     35 * and destination memory areas cannot overlap.
     36 *
     37 * @param dst Destination address to copy to.
     38 * @param src Source address to copy from.
     39 * @param cnt Number of bytes to copy.
     40 *
     41 * @return Destination address.
     42 *
     43 */
     44void *memcpy(void *dst, const void *src, size_t cnt)
     45{
     46        uint8_t *dp = (uint8_t *) dst;
     47        const uint8_t *sp = (uint8_t *) src;
     48       
     49        while (cnt-- != 0)
     50                *dp++ = *sp++;
     51       
     52        return dst;
     53}
     54
     55/** Fill block of memory.
     56 *
     57 * Fill cnt bytes at dst address with the value val.
     58 *
     59 * @param dst Destination address to fill.
     60 * @param val Value to fill.
     61 * @param cnt Number of bytes to fill.
     62 *
     63 * @return Destination address.
     64 *
     65 */
     66void *memset(void *dst, int val, size_t cnt)
     67{
     68        uint8_t *dp = (uint8_t *) dst;
     69       
     70        while (cnt-- != 0)
     71                *dp++ = val;
     72       
     73        return dst;
     74}
    3175
    3276/** Move memory block with possible overlapping.

  • kernel/Makefile

    r582f4d28 r45f7449  
    228228        generic/src/lib/func.c \
    229229        generic/src/lib/memstr.c \
     230        generic/src/lib/memfnc.c \
    230231        generic/src/lib/sort.c \
    231232        generic/src/lib/str.c \

  • kernel/arch/amd64/src/asm.S

    r582f4d28 r45f7449  
    3737.global read_efer_flag
    3838.global set_efer_flag
    39 .global memset
    40 .global memcpy
    4139.global memcpy_from_uspace
    4240.global memcpy_to_uspace
    … …  
    4543.global early_putchar
    4644
    47 #define MEMSET_DST   %rdi
    48 #define MEMSET_VAL   %rsi
    49 #define MEMSET_SIZE  %rdx
    50 
    5145#define MEMCPY_DST   %rdi
    5246#define MEMCPY_SRC   %rsi
    5347#define MEMCPY_SIZE  %rdx
    5448
    55 /* Fill memory with byte pattern
    56  *
    57  * This is a conventional memset().
    58  *
    59  * @param MEMSET_DST  Destination address.
    60  * @param MEMSET_VAL  Value to fill.
    61  * @param MEMSET_SIZE Size.
    62  *
    63  * @return MEMSET_DST.
    64  *
    65  */
    66 memset:
    67         movq MEMSET_DST, %r8    /* save %rdi */
    68        
    69         /* Create byte pattern */
    70         movzbl %sil, %esi       /* MEMSET_VAL */
    71         movabs $0x0101010101010101, %rax
    72         imulq %rsi, %rax
    73        
    74         movq MEMSET_SIZE, %rcx
    75         shrq $3, %rcx           /* size / 8 */
    76        
    77         rep stosq               /* store as much as possible word by word */
    78        
    79         movq MEMSET_SIZE, %rcx
    80         andq $7, %rcx           /* size % 8 */
    81         jz 0f
    82        
    83         rep stosb               /* store the rest byte by byte */
    84        
    85         0:
    86                 movq %r8, %rax
    87                 ret                 /* return MEMCPY_SRC, success */
    88 
    89 /** Copy memory from/to userspace.
     49/**
     50 * Copy memory from/to userspace.
    9051 *
    9152 * This is almost conventional memcpy().
    … …  
    10263 *
    10364 */
    104 memcpy:
    10565memcpy_from_uspace:
    10666memcpy_to_uspace:

  • kernel/arch/ia32/src/asm.S

    r582f4d28 r45f7449  
    3838.global paging_on
    3939.global enable_l_apic_in_msr
    40 .global memset
    41 .global memcpy
    4240.global memcpy_from_uspace
    4341.global memcpy_from_uspace_failover_address
    … …  
    4644.global early_putchar
    4745
    48 #define MEMSET_DST   4
    49 #define MEMSET_VAL   8
    50 #define MEMSET_SIZE  12
    51 
    5246#define MEMCPY_DST   4
    5347#define MEMCPY_SRC   8
    5448#define MEMCPY_SIZE  12
    55 
    56 /* Fill memory with byte pattern
    57  *
    58  * This is a conventional memset().
    59  *
    60  * @param MEMSET_DST(%esp)  Destination address.
    61  * @param MEMSET_VAL(%esp)  Value to fill.
    62  * @param MEMSET_SIZE(%esp) Size.
    63  *
    64  * @return MEMSET_DST(%esp).
    65  *
    66  */
    67 memset:
    68         movl %edi, %edx  /* save %edi */
    69        
    70         movl MEMSET_DST(%esp), %edi
    71         movl MEMSET_VAL(%esp), %ecx
    72        
    73         /* Create byte pattern */
    74         movb %cl, %ch
    75         movw %cx, %ax
    76         shll $16, %eax
    77         orw %cx, %ax
    78        
    79         movl MEMSET_SIZE(%esp), %ecx
    80         shrl $2, %ecx  /* size / 4 */
    81        
    82         /* Write whole words */
    83         rep stosl
    84        
    85         movl MEMSET_SIZE(%esp), %ecx
    86         andl $3, %ecx  /* size % 4 */
    87         jz 0f
    88        
    89         /* Copy the rest byte by byte */
    90         rep stosb
    91        
    92         0:
    93        
    94                 movl %edx, %edi
    95                
    96                 /* MEMSET_DST(%esp), success */
    97                 movl MEMSET_DST(%esp), %eax
    98                 ret
    9949
    10050/** Copy memory to/from userspace.
    … …  
    11363 *
    11464 */
    115 memcpy:
    11665memcpy_from_uspace:
    11766memcpy_to_uspace:

  • kernel/arch/mips32/src/asm.S

    r582f4d28 r45f7449  
    5757        nop
    5858
    59 .global memset
    60 .global memcpy
    6159.global memcpy_from_uspace
    6260.global memcpy_to_uspace
    6361.global memcpy_from_uspace_failover_address
    6462.global memcpy_to_uspace_failover_address
    65 
    66 memset:
    67         move $v0, $a0
    68         beqz $a2, 0f
    69         addiu $t1, $a2, -1
    70        
    71         negu $t0, $a0
    72         andi $t0, $t0, 0x3
    73         sltu $v1, $a2, $t0
    74         bnez $v1, 1f
    75         andi $a1, $a1, 0xff
    76        
    77         7:
    78                 sltiu $v1, $a2, 4
    79                 beqz $v1, 2f
    80                 move $v1, $v0
    81                
    82                 move $t0, $a2
    83        
    84         3:
    85                 sb $a1, 0($v1)
    86                 addiu $v1, $v1, 1
    87                 subu $a3, $v1, $v0
    88                 sltu $a3, $a3, $t0
    89                 bnez $a3, 3b
    90                 addiu $t1, $t1, -1
    91                
    92                 beq $a2, $t0, 0f
    93                 subu $a2, $a2, $t0
    94        
    95         8:
    96                 srl $a0, $a2, 0x2
    97                 sll $t4, $a0, 0x2
    98                 beqz $t4, 4f
    99                 sll $t2, $a1, 0x10
    100                
    101                 sll $t3, $a1, 0x8
    102                 or $t3, $a1, $t3
    103                 sll $a3, $a1, 0x18
    104                 or $t3, $t3, $t2
    105                 or $t3, $t3, $a3
    106                 addu $t0, $v0, $t0
    107                 move $a3, $zero
    108        
    109         5:
    110                 addiu $a3, $a3, 1
    111                 sltu $t2, $a3, $a0
    112                 sw $t3, 0($t0)
    113                 bnez $t2, 5b
    114                 addiu $t0, $t0, 4
    115                
    116                 addu $v1, $v1, $t4
    117                 beq $a2, $t4, 0f
    118                 subu $t1, $t1, $t4
    119        
    120         4:
    121                 addiu $t1, $t1, 1
    122                 addu $t1, $v1, $t1
    123                 sb $a1, 0($v1)
    124        
    125         6:
    126                 addiu $v1, $v1, 1
    127                 bnel $v1, $t1, 6b
    128                 sb $a1, 0($v1)
    129        
    130         0:
    131                 jr $ra
    132                 nop
    133        
    134         1:
    135                 j 7b
    136                 move $t0, $a2
    137        
    138         2:
    139                 bnez $t0, 3b
    140                 nop
    141                
    142                 j 8b
    143                 subu $a2, $a2, $t0
    144 
    145 memcpy:
    14663memcpy_from_uspace:
    14764memcpy_to_uspace:

  • uspace/lib/c/arch/amd64/Makefile.inc

    r582f4d28 r45f7449  
    2828
    2929ARCH_SOURCES = \
    30         arch/$(UARCH)/src/asm.S \
    3130        arch/$(UARCH)/src/entry.s \
    3231        arch/$(UARCH)/src/entryjmp.s \

  • uspace/lib/c/arch/ia32/Makefile.inc

    r582f4d28 r45f7449  
    2828
    2929ARCH_SOURCES = \
    30         arch/$(UARCH)/src/asm.S \
    3130        arch/$(UARCH)/src/entry.S \
    3231        arch/$(UARCH)/src/entryjmp.s \

  • uspace/lib/c/arch/mips32/Makefile.inc

    r582f4d28 r45f7449  
    2828
    2929ARCH_SOURCES = \
    30         arch/$(UARCH)/src/asm.S \
    3130        arch/$(UARCH)/src/entry.S \
    3231        arch/$(UARCH)/src/entryjmp.S \

  • uspace/lib/c/arch/mips32eb/Makefile.inc

    r582f4d28 r45f7449  
    2828
    2929ARCH_SOURCES = \
    30         arch/$(UARCH)/src/asm.S \
    3130        arch/$(UARCH)/src/entry.S \
    3231        arch/$(UARCH)/src/entryjmp.S \

  • uspace/lib/c/generic/mem.c

    r582f4d28 r45f7449  
    3838#include <sys/types.h>
    3939
     40/** Fill memory block with a constant value. */
     41void *memset(void *dest, int b, size_t n)
     42{
     43        char *pb;
     44        unsigned long *pw;
     45        size_t word_size;
     46        size_t n_words;
     47
     48        unsigned long pattern;
     49        size_t i;
     50        size_t fill;
     51
     52        /* Fill initial segment. */
     53        word_size = sizeof(unsigned long);
     54        fill = word_size - ((uintptr_t) dest & (word_size - 1));
     55        if (fill > n) fill = n;
     56
     57        pb = dest;
     58
     59        i = fill;
     60        while (i-- != 0)
     61                *pb++ = b;
     62
     63        /* Compute remaining size. */
     64        n -= fill;
     65        if (n == 0) return dest;
     66
     67        n_words = n / word_size;
     68        n = n % word_size;
     69        pw = (unsigned long *) pb;
     70
     71        /* Create word-sized pattern for aligned segment. */
     72        pattern = 0;
     73        i = word_size;
     74        while (i-- != 0)
     75                pattern = (pattern << 8) | (uint8_t) b;
     76
     77        /* Fill aligned segment. */
     78        i = n_words;
     79        while (i-- != 0)
     80                *pw++ = pattern;
     81
     82        pb = (char *) pw;
     83
     84        /* Fill final segment. */
     85        i = n;
     86        while (i-- != 0)
     87                *pb++ = b;
     88
     89        return dest;
     90}
     91
     92struct along {
     93        unsigned long n;
     94} __attribute__ ((packed));
     95
     96static void *unaligned_memcpy(void *dst, const void *src, size_t n)
     97{
     98        size_t i, j;
     99        struct along *adst = dst;
     100        const struct along *asrc = src;
     101
     102        for (i = 0; i < n / sizeof(unsigned long); i++)
     103                adst[i].n = asrc[i].n;
     104               
     105        for (j = 0; j < n % sizeof(unsigned long); j++)
     106                ((unsigned char *) (((unsigned long *) dst) + i))[j] =
     107                    ((unsigned char *) (((unsigned long *) src) + i))[j];
     108               
     109        return (char *) dst;
     110}
     111
     112/** Copy memory block. */
     113void *memcpy(void *dst, const void *src, size_t n)
     114{
     115        size_t i;
     116        size_t mod, fill;
     117        size_t word_size;
     118        size_t n_words;
     119
     120        const unsigned long *srcw;
     121        unsigned long *dstw;
     122        const uint8_t *srcb;
     123        uint8_t *dstb;
     124
     125        word_size = sizeof(unsigned long);
     126
     127        /*
     128         * Are source and destination addresses congruent modulo word_size?
     129         * If not, use unaligned_memcpy().
     130         */
     131
     132        if (((uintptr_t) dst & (word_size - 1)) !=
     133            ((uintptr_t) src & (word_size - 1)))
     134                return unaligned_memcpy(dst, src, n);
     135
     136        /*
     137         * mod is the address modulo word size. fill is the length of the
     138         * initial buffer segment before the first word boundary.
     139         * If the buffer is very short, use unaligned_memcpy(), too.
     140         */
     141
     142        mod = (uintptr_t) dst & (word_size - 1);
     143        fill = word_size - mod;
     144        if (fill > n) fill = n;
     145
     146        /* Copy the initial segment. */
     147
     148        srcb = src;
     149        dstb = dst;
     150
     151        i = fill;
     152        while (i-- != 0)
     153                *dstb++ = *srcb++;
     154
     155        /* Compute remaining length. */
     156
     157        n -= fill;
     158        if (n == 0) return dst;
     159
     160        /* Pointers to aligned segment. */
     161
     162        dstw = (unsigned long *) dstb;
     163        srcw = (const unsigned long *) srcb;
     164
     165        n_words = n / word_size;        /* Number of whole words to copy. */
     166        n -= n_words * word_size;       /* Remaining bytes at the end. */
     167
     168        /* "Fast" copy. */
     169        i = n_words;
     170        while (i-- != 0)
     171                *dstw++ = *srcw++;
     172
     173        /*
     174         * Copy the rest.
     175         */
     176
     177        srcb = (const uint8_t *) srcw;
     178        dstb = (uint8_t *) dstw;
     179
     180        i = n;
     181        while (i-- != 0)
     182                *dstb++ = *srcb++;
     183
     184        return dst;
     185}
     186
    40187/** Move memory block with possible overlapping. */
    41188void *memmove(void *dst, const void *src, size_t n)

  • uspace/lib/c/include/mem.h

    r582f4d28 r45f7449  
    3838#include <sys/types.h>
    3939
    40 #define memset(dst, val, cnt)  __builtin_memset((dst), (val), (cnt))
    41 #define memcpy(dst, src, cnt)  __builtin_memcpy((dst), (src), (cnt))
    42 
    4340#define bzero(ptr, len)  memset((ptr), 0, (len))
    4441
     42extern void *memset(void *, int, size_t);
     43extern void *memcpy(void *, const void *, size_t);
    4544extern void *memmove(void *, const void *, size_t);
     45
    4646extern int bcmp(const void *, const void *, size_t);
    4747

  • uspace/lib/posix/include/posix/string.h

    r582f4d28 r45f7449  
    6060 * forward declarations ought to be enough.
    6161 */
    62 
    6362/* From str.h. */
    64 
    65 extern char *strtok_r(char *, const char *, char **);
    66 extern char *strtok(char *, const char *);
     63extern char * strtok_r(char *, const char *, char **);
     64extern char * strtok(char *, const char *);
    6765
    6866/* From mem.h */
     67#define bzero(ptr, len)  memset((ptr), 0, (len))
     68extern void *memset(void *, int, size_t);
     69extern void *memcpy(void *, const void *, size_t);
     70extern void *memmove(void *, const void *, size_t);
    6971
    70 #define memset(dst, val, cnt)  __builtin_memset((dst), (val), (cnt))
    71 #define memcpy(dst, src, cnt)  __builtin_memcpy((dst), (src), (cnt))
    72 
    73 #define bzero(ptr, len)  memset((ptr), 0, (len))
    74 
    75 extern void *memmove(void *, const void *, size_t);
    76 extern int bcmp(const void *, const void *, size_t);
    7772
    7873/* Copying and Concatenation */
Note: See TracChangeset for help on using the changeset viewer.