Changes in / [3abfe9a8:ebebd38] in mainline


Ignore:
Files:
8 added
2 deleted
52 edited

Legend:

Unmodified
Added
Removed

  • kernel/Makefile

    r3abfe9a8 rebebd38  
    240240        generic/src/lib/func.c \
    241241        generic/src/lib/memstr.c \
    242         generic/src/lib/memfnc.c \
    243242        generic/src/lib/sort.c \
    244243        generic/src/lib/str.c \

  • kernel/arch/amd64/Makefile.inc

    r3abfe9a8 rebebd38  
    3333
    3434FPU_NO_CFLAGS = -mno-sse -mno-sse2
    35 
    36 #
    37 # FIXME:
    38 #
    39 # The -fno-optimize-sibling-calls should be removed as soon as a bug
    40 # in GCC concerning the "large" memory model and tail call optimization
    41 # is fixed.
    42 #
    43 # If GCC generates a code for tail call, instead of generating ..
    44 #
    45 #   jmp *fnc
    46 #
    47 # it generates an assembly code with an illegal immediate prefix:
    48 #
    49 #   jmp *$fnc
    50 #
    51 
    52 CMN1 = -m64 -mcmodel=large -mno-red-zone -fno-unwind-tables -fno-omit-frame-pointer -fno-optimize-sibling-calls
     35CMN1 = -m64 -mcmodel=large -mno-red-zone -fno-unwind-tables -fno-omit-frame-pointer
    5336GCC_CFLAGS += $(CMN1)
    5437ICC_CFLAGS += $(CMN1)

  • kernel/arch/amd64/_link.ld.in

    r3abfe9a8 rebebd38  
    2626        .mapped (PA2KA(BOOT_OFFSET)+SIZEOF(.unmapped)) : AT (SIZEOF(.unmapped)) {
    2727                ktext_start = .;
    28                 *(.text .text.*);
     28                *(.text);
    2929                ktext_end = .;
    3030               
    3131                kdata_start = .;
    32                 *(.data);              /* initialized data */
    33                 *(.rodata .rodata.*);  /* string literals */
     32                *(.data);       /* initialized data */
     33                *(.rodata*);    /* string literals */
    3434                hardcoded_load_address = .;
    3535                QUAD(PA2KA(BOOT_OFFSET));

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

    r3abfe9a8 rebebd38  
    3737.global read_efer_flag
    3838.global set_efer_flag
     39.global memsetb
     40.global memsetw
     41.global memcpy
    3942.global memcpy_from_uspace
    4043.global memcpy_to_uspace
    … …  
    4346.global early_putchar
    4447
     48/* Wrapper for generic memsetb */
     49memsetb:
     50        jmp _memsetb
     51
     52/* Wrapper for generic memsetw */
     53memsetw:
     54        jmp _memsetw
     55
    4556#define MEMCPY_DST   %rdi
    4657#define MEMCPY_SRC   %rsi
    … …  
    6374 *
    6475 */
     76memcpy:
    6577memcpy_from_uspace:
    6678memcpy_to_uspace:

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

    r3abfe9a8 rebebd38  
    2929.text
    3030
     31.global memsetb
     32.global memsetw
     33.global memcpy
    3134.global memcpy_from_uspace
    3235.global memcpy_to_uspace
    … …  
    3538.global early_putchar
    3639
     40memsetb:
     41        b _memsetb
     42
     43memsetw:
     44        b _memsetw
     45
     46memcpy:
    3747memcpy_from_uspace:
    3848memcpy_to_uspace:

  • kernel/arch/arm32/src/exception.c

    r3abfe9a8 rebebd38  
    3535
    3636#include <arch/exception.h>
     37#include <arch/memstr.h>
    3738#include <arch/regutils.h>
    3839#include <arch/machine_func.h>

  • kernel/arch/ia32/_link.ld.in

    r3abfe9a8 rebebd38  
    2525        .mapped (PA2KA(BOOT_OFFSET)+SIZEOF(.unmapped)): AT (SIZEOF(.unmapped)) {
    2626                ktext_start = .;
    27                 *(.text .text.*);
     27                *(.text);
    2828                ktext_end = .;
    2929               
    3030                kdata_start = .;
    3131                *(.data);               /* initialized data */
    32                 *(.rodata .rodata.*);   /* string literals */
     32                *(.rodata*);            /* string literals */
    3333                *(COMMON);              /* global variables */
    3434                hardcoded_load_address = .;

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

    r3abfe9a8 rebebd38  
    3838.global paging_on
    3939.global enable_l_apic_in_msr
     40.global memsetb
     41.global memsetw
     42.global memcpy
    4043.global memcpy_from_uspace
    4144.global memcpy_from_uspace_failover_address
    … …  
    4447.global early_putchar
    4548
     49/* Wrapper for generic memsetb */
     50memsetb:
     51        jmp _memsetb
     52
     53/* Wrapper for generic memsetw */
     54memsetw:
     55        jmp _memsetw
     56
    4657#define MEMCPY_DST   4
    4758#define MEMCPY_SRC   8
    … …  
    6374 *
    6475 */
     76memcpy:
    6577memcpy_from_uspace:
    6678memcpy_to_uspace:

  • kernel/arch/ia32/src/cpu/cpu.c

    r3abfe9a8 rebebd38  
    9292void cpu_arch_init(void)
    9393{
     94        cpuid_extended_feature_info efi;
    9495        cpu_info_t info;
    9596        uint32_t help = 0;
    … …  
    103104       
    104105        CPU->arch.fi.word = info.cpuid_edx;
     106        efi.word = info.cpuid_ecx;
    105107       
    106108        if (CPU->arch.fi.bits.fxsr)

  • kernel/arch/ia64/_link.ld.in

    r3abfe9a8 rebebd38  
    1616                ktext_start = .;
    1717                *(K_TEXT_START);
    18                 *(.text .text.*)
     18                *(.text)
    1919                ktext_end = .;
    2020               
    … …  
    3636                *(.bss)
    3737                *(COMMON);
    38                
     38
    3939                . = ALIGN(8);
    40                 symbol_table = .;
    41                 *(symtab.*);            /* Symbol table, must be LAST symbol!*/
    42                
     40                symbol_table = .;
     41                *(symtab.*);            /* Symbol table, must be LAST symbol!*/
     42
    4343                kdata_end = .;
    4444        }
    45        
     45
    4646        /DISCARD/ : {
    4747                *(*);
    4848        }
     49
    4950}

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

    r3abfe9a8 rebebd38  
    3030
    3131.text
     32.global memcpy
    3233.global memcpy_from_uspace
    3334.global memcpy_to_uspace
    … …  
    3839 *
    3940 * This memcpy() has been taken from the assembler output of
    40  * a plain C implementation of memcpy() modified to have the
    41  * failover part.
     41 * the generic _memcpy() and modified to have the failover part.
    4242 *
    4343 * @param in0 Destination address.
    … …  
    4646 *
    4747 */
     48memcpy:
    4849memcpy_from_uspace:
    4950memcpy_to_uspace:
    … …  
    140141        br.ret.sptk.many rp
    141142
     143.global memsetb
     144memsetb:
     145        br _memsetb
     146
     147.global memsetw
     148memsetw:
     149        br _memsetw
     150
    142151.global cpu_halt
    143152cpu_halt:

  • kernel/arch/ia64/src/mm/tlb.c

    r3abfe9a8 rebebd38  
    475475void alternate_instruction_tlb_fault(uint64_t vector, istate_t *istate)
    476476{
     477        region_register_t rr;
     478        rid_t rid;
    477479        uintptr_t va;
    478480        pte_t *t;
    479481       
    480482        va = istate->cr_ifa; /* faulting address */
     483        rr.word = rr_read(VA2VRN(va));
     484        rid = rr.map.rid;
    481485       
    482486        page_table_lock(AS, true);
    … …  
    645649void data_dirty_bit_fault(uint64_t vector, istate_t *istate)
    646650{
     651        region_register_t rr;
     652        rid_t rid;
    647653        uintptr_t va;
    648654        pte_t *t;
    649655       
    650656        va = istate->cr_ifa;  /* faulting address */
     657        rr.word = rr_read(VA2VRN(va));
     658        rid = rr.map.rid;
    651659       
    652660        page_table_lock(AS, true);
    … …  
    678686void instruction_access_bit_fault(uint64_t vector, istate_t *istate)
    679687{
     688        region_register_t rr;
     689        rid_t rid;
    680690        uintptr_t va;
    681691        pte_t *t;
    682692       
    683693        va = istate->cr_ifa;  /* faulting address */
     694        rr.word = rr_read(VA2VRN(va));
     695        rid = rr.map.rid;
    684696       
    685697        page_table_lock(AS, true);
    … …  
    711723void data_access_bit_fault(uint64_t vector, istate_t *istate)
    712724{
     725        region_register_t rr;
     726        rid_t rid;
    713727        uintptr_t va;
    714728        pte_t *t;
    715729       
    716730        va = istate->cr_ifa;  /* faulting address */
     731        rr.word = rr_read(VA2VRN(va));
     732        rid = rr.map.rid;
    717733       
    718734        page_table_lock(AS, true);
    … …  
    744760void data_access_rights_fault(uint64_t vector, istate_t *istate)
    745761{
     762        region_register_t rr;
     763        rid_t rid;
    746764        uintptr_t va;
    747765        pte_t *t;
    748766       
    749767        va = istate->cr_ifa;  /* faulting address */
     768        rr.word = rr_read(VA2VRN(va));
     769        rid = rr.map.rid;
    750770       
    751771        /*
    … …  
    772792void page_not_present(uint64_t vector, istate_t *istate)
    773793{
     794        region_register_t rr;
     795        rid_t rid;
    774796        uintptr_t va;
    775797        pte_t *t;
    776798       
    777799        va = istate->cr_ifa;  /* faulting address */
     800        rr.word = rr_read(VA2VRN(va));
     801        rid = rr.map.rid;
    778802       
    779803        page_table_lock(AS, true);

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

    r3abfe9a8 rebebd38  
    5757        nop
    5858
     59.global memsetb
     60memsetb:
     61        j _memsetb
     62        nop
     63
     64.global memsetw
     65memsetw:
     66        j _memsetw
     67        nop
     68
     69.global memcpy
    5970.global memcpy_from_uspace
    6071.global memcpy_to_uspace
    6172.global memcpy_from_uspace_failover_address
    6273.global memcpy_to_uspace_failover_address
     74memcpy:
    6375memcpy_from_uspace:
    6476memcpy_to_uspace:

  • kernel/arch/ppc32/_link.ld.in

    r3abfe9a8 rebebd38  
    3636                kdata_start = .;
    3737                *(K_DATA_START);
    38                 *(.rodata .rodata.*);
     38                *(.rodata);
     39                *(.rodata.*);
    3940                *(.data);       /* initialized data */
    4041                *(.sdata);

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

    r3abfe9a8 rebebd38  
    3535.global iret
    3636.global iret_syscall
     37.global memsetb
     38.global memsetw
     39.global memcpy
    3740.global memcpy_from_uspace
    3841.global memcpy_to_uspace
    … …  
    205208        rfi
    206209
     210memsetb:
     211        b _memsetb
     212
     213memsetw:
     214        b _memsetw
     215
     216memcpy:
    207217memcpy_from_uspace:
    208218memcpy_to_uspace:

  • kernel/arch/sparc64/_link.ld.in

    r3abfe9a8 rebebd38  
    1515                ktext_start = .;
    1616                *(K_TEXT_START)
    17                 *(.text .text.*);
     17                *(.text);
    1818                ktext_end = .;
    1919               
    2020                kdata_start = .;
    2121                *(K_DATA_START)
    22                 *(.rodata .rodata.*);
     22                *(.rodata);
     23                *(.rodata.*);
    2324                *(.data);                   /* initialized data */
    2425                *(.sdata);

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

    r3abfe9a8 rebebd38  
    3636
    3737/*
     38 * This is the assembly language version of our _memcpy() generated by gcc.
     39 */
     40.global memcpy
     41memcpy:
     42        mov %o0, %o3  /* save dst */
     43        add %o1, 7, %g1
     44        and %g1, -8, %g1
     45        cmp %o1, %g1
     46        be,pn %xcc, 3f
     47        add %o0, 7, %g1
     48        mov 0, %g3
     49       
     50        0:
     51       
     52                brz,pn %o2, 2f
     53                mov 0, %g2
     54       
     55        1:
     56       
     57                ldub [%g3 + %o1], %g1
     58                add %g2, 1, %g2
     59                cmp %o2, %g2
     60                stb %g1, [%g3 + %o0]
     61                bne,pt %xcc, 1b
     62                mov %g2, %g3
     63       
     64        2:
     65       
     66                jmp %o7 + 8  /* exit point */
     67                mov %o3, %o0
     68       
     69        3:
     70       
     71                and %g1, -8, %g1
     72                cmp %o0, %g1
     73                bne,pt %xcc, 0b
     74                mov 0, %g3
     75                srlx %o2, 3, %g4
     76                brz,pn %g4, 5f
     77                mov 0, %g5
     78       
     79        4:
     80       
     81                sllx %g3, 3, %g2
     82                add %g5, 1, %g3
     83                ldx [%o1 + %g2], %g1
     84                mov %g3, %g5
     85                cmp %g4, %g3
     86                bne,pt %xcc, 4b
     87                stx %g1, [%o0 + %g2]
     88       
     89        5:
     90       
     91                and %o2, 7, %o2
     92                brz,pn %o2, 2b
     93                sllx %g4, 3, %g1
     94                mov 0, %g2
     95                add %g1, %o0, %o0
     96                add %g1, %o1, %g4
     97                mov 0, %g3
     98       
     99        6:
     100       
     101                ldub [%g2 + %g4], %g1
     102                stb %g1, [%g2 + %o0]
     103                add %g3, 1, %g2
     104                cmp %o2, %g2
     105                bne,pt %xcc, 6b
     106                mov %g2, %g3
     107               
     108                jmp %o7 + 8  /* exit point */
     109                mov %o3, %o0
     110
     111/*
    38112 * Almost the same as memcpy() except the loads are from userspace.
    39113 */
    … …  
    190264        mov %g0, %o0  /* return 0 on failure */
    191265
     266.global memsetb
     267memsetb:
     268        ba %xcc, _memsetb
     269        nop
     270
     271.global memsetw
     272memsetw:
     273        ba %xcc, _memsetw
     274        nop
     275
    192276.global early_putchar
    193277early_putchar:

  • kernel/arch/sparc64/src/mm/sun4u/as.c

    r3abfe9a8 rebebd38  
    4343
    4444#include <arch/mm/tsb.h>
     45#include <arch/memstr.h>
    4546#include <arch/asm.h>
    4647#include <mm/frame.h>

  • kernel/arch/sparc64/src/mm/sun4v/as.c

    r3abfe9a8 rebebd38  
    4646
    4747#include <arch/mm/tsb.h>
     48#include <arch/memstr.h>
    4849#include <arch/asm.h>
    4950#include <mm/frame.h>

  • kernel/genarch/src/drivers/via-cuda/cuda.c

    r3abfe9a8 rebebd38  
    239239        cuda_instance_t *instance = irq->instance;
    240240        cuda_t *dev = instance->cuda;
    241         uint8_t b;
    242        
     241        uint8_t data, b;
     242
    243243        b = pio_read_8(&dev->b);
    244         pio_read_8(&dev->sr);
    245        
     244        data = pio_read_8(&dev->sr);
     245
    246246        if ((b & TREQ) == 0) {
    247247                instance->xstate = cx_receive;
    … …  
    251251                cuda_send_start(instance);
    252252        }
    253        
    254         memcpy(buf, instance->rcv_buf, instance->bidx);
    255         *len = instance->bidx;
     253
     254        memcpy(buf, instance->rcv_buf, instance->bidx);
     255        *len = instance->bidx;
    256256        instance->bidx = 0;
    257257}

  • kernel/genarch/src/ofw/ebus.c

    r3abfe9a8 rebebd38  
    3939#include <genarch/ofw/ebus.h>
    4040#include <genarch/ofw/pci.h>
     41#include <arch/memstr.h>
    4142#include <str.h>
    4243#include <panic.h>

  • kernel/genarch/src/ofw/fhc.c

    r3abfe9a8 rebebd38  
    3939#include <genarch/ofw/fhc.h>
    4040#include <arch/drivers/fhc.h>
     41#include <arch/memstr.h>
    4142#include <str.h>
    4243#include <panic.h>

  • kernel/genarch/src/ofw/ofw_tree.c

    r3abfe9a8 rebebd38  
    3737
    3838#include <genarch/ofw/ofw_tree.h>
     39#include <arch/memstr.h>
    3940#include <mm/slab.h>
    40 #include <memstr.h>
    4141#include <str.h>
    4242#include <panic.h>

  • kernel/genarch/src/ofw/pci.c

    r3abfe9a8 rebebd38  
    4040#include <arch/drivers/pci.h>
    4141#include <arch/trap/interrupt.h>
     42#include <arch/memstr.h>
    4243#include <str.h>
    4344#include <panic.h>

  • kernel/genarch/src/ofw/upa.c

    r3abfe9a8 rebebd38  
    3838#include <genarch/ofw/ofw_tree.h>
    3939#include <genarch/ofw/upa.h>
     40#include <arch/memstr.h>
    4041#include <func.h>
    4142#include <panic.h>

  • kernel/generic/include/memstr.h

    r3abfe9a8 rebebd38  
    3737
    3838#include <typedefs.h>
     39#include <arch/memstr.h>
    3940
    40 #define memset(dst, val, cnt)  __builtin_memset((dst), (val), (cnt))
    41 #define memcpy(dst, src, cnt)  __builtin_memcpy((dst), (src), (cnt))
    42 
    43 extern void memsetb(void *, size_t, uint8_t);
    44 extern void memsetw(void *, size_t, uint16_t);
    45 extern void *memmove(void *, const void *, size_t);
     41/*
     42 * Architecture independent variants.
     43 */
     44extern void *_memcpy(void *dst, const void *src, size_t cnt);
     45extern void _memsetb(void *dst, size_t cnt, uint8_t x);
     46extern void _memsetw(void *dst, size_t cnt, uint16_t x);
     47extern void *memmove(void *dst, const void *src, size_t cnt);
    4648
    4749#endif

  • kernel/generic/src/lib/memstr.c

    r3abfe9a8 rebebd38  
    2828 */
    2929
    30 /** @addtogroup generic
     30/** @addtogroup generic 
    3131 * @{
    3232 */
    … …  
    3434/**
    3535 * @file
    36  * @brief Memory string operations.
     36 * @brief       Memory string operations.
    3737 *
    38  * This file provides architecture independent functions to manipulate blocks
    39  * of memory. These functions are optimized as much as generic functions of
    40  * this type can be.
     38 * This file provides architecture independent functions to manipulate blocks of
     39 * memory. These functions are optimized as much as generic functions of this
     40 * type can be. However, architectures are free to provide even more optimized
     41 * versions of these functions.
    4142 */
    4243
    4344#include <memstr.h>
    4445#include <typedefs.h>
     46#include <align.h>
    4547
    46 /** Fill block of memory.
     48/** Copy block of memory.
    4749 *
    48  * Fill cnt bytes at dst address with the value val.
     50 * Copy cnt bytes from src address to dst address.  The copying is done
     51 * word-by-word and then byte-by-byte.  The source and destination memory areas
     52 * cannot overlap.
    4953 *
    50  * @param dst Destination address to fill.
    51  * @param cnt Number of bytes to fill.
    52  * @param val Value to fill.
     54 * @param src           Source address to copy from.
     55 * @param dst           Destination address to copy to.
     56 * @param cnt           Number of bytes to copy.
     57 *
     58 * @return              Destination address.
     59 */
     60void *_memcpy(void *dst, const void *src, size_t cnt)
     61{
     62        unsigned int i, j;
     63       
     64        if (ALIGN_UP((uintptr_t) src, sizeof(sysarg_t)) != (uintptr_t) src ||
     65            ALIGN_UP((uintptr_t) dst, sizeof(sysarg_t)) != (uintptr_t) dst) {
     66                for (i = 0; i < cnt; i++)
     67                        ((uint8_t *) dst)[i] = ((uint8_t *) src)[i];
     68        } else {
     69                for (i = 0; i < cnt / sizeof(sysarg_t); i++)
     70                        ((sysarg_t *) dst)[i] = ((sysarg_t *) src)[i];
     71               
     72                for (j = 0; j < cnt % sizeof(sysarg_t); j++)
     73                        ((uint8_t *)(((sysarg_t *) dst) + i))[j] =
     74                            ((uint8_t *)(((sysarg_t *) src) + i))[j];
     75        }
     76               
     77        return (char *) dst;
     78}
     79
     80/** Move memory block with possible overlapping.
     81 *
     82 * Copy cnt bytes from src address to dst address. The source and destination
     83 * memory areas may overlap.
     84 *
     85 * @param src           Source address to copy from.
     86 * @param dst           Destination address to copy to.
     87 * @param cnt           Number of bytes to copy.
     88 *
     89 * @return              Destination address.
     90 */
     91void *memmove(void *dst, const void *src, size_t n)
     92{
     93        const uint8_t *sp;
     94        uint8_t *dp;
     95
     96        /* Nothing to do? */
     97        if (src == dst)
     98                return dst;
     99
     100        /* Non-overlapping? */
     101        if (dst >= src + n || src >= dst + n) {
     102                return memcpy(dst, src, n);
     103        }
     104
     105        /* Which direction? */
     106        if (src > dst) {
     107                /* Forwards. */
     108                sp = src;
     109                dp = dst;
     110
     111                while (n-- != 0)
     112                        *dp++ = *sp++;
     113        } else {
     114                /* Backwards. */
     115                sp = src + (n - 1);
     116                dp = dst + (n - 1);
     117
     118                while (n-- != 0)
     119                        *dp-- = *sp--;
     120        }
     121
     122        return dst;
     123}
     124
     125/** Fill block of memory
     126 *
     127 * Fill cnt bytes at dst address with the value x.  The filling is done
     128 * byte-by-byte.
     129 *
     130 * @param dst           Destination address to fill.
     131 * @param cnt           Number of bytes to fill.
     132 * @param x             Value to fill.
    53133 *
    54134 */
    55 void memsetb(void *dst, size_t cnt, uint8_t val)
     135void _memsetb(void *dst, size_t cnt, uint8_t x)
    56136{
    57         memset(dst, val, cnt);
     137        unsigned int i;
     138        uint8_t *p = (uint8_t *) dst;
     139       
     140        for (i = 0; i < cnt; i++)
     141                p[i] = x;
    58142}
    59143
    60144/** Fill block of memory.
    61145 *
    62  * Fill cnt words at dst address with the value val. The filling
    63  * is done word-by-word.
     146 * Fill cnt words at dst address with the value x.  The filling is done
     147 * word-by-word.
    64148 *
    65  * @param dst Destination address to fill.
    66  * @param cnt Number of words to fill.
    67  * @param val Value to fill.
     149 * @param dst           Destination address to fill.
     150 * @param cnt           Number of words to fill.
     151 * @param x             Value to fill.
    68152 *
    69153 */
    70 void memsetw(void *dst, size_t cnt, uint16_t val)
     154void _memsetw(void *dst, size_t cnt, uint16_t x)
    71155{
    72         size_t i;
    73         uint16_t *ptr = (uint16_t *) dst;
     156        unsigned int i;
     157        uint16_t *p = (uint16_t *) dst;
    74158       
    75159        for (i = 0; i < cnt; i++)
    76                 ptr[i] = val;
    77 }
    78 
    79 /** Move memory block with possible overlapping.
    80  *
    81  * Copy cnt bytes from src address to dst address. The source
    82  * and destination memory areas may overlap.
    83  *
    84  * @param dst Destination address to copy to.
    85  * @param src Source address to copy from.
    86  * @param cnt Number of bytes to copy.
    87  *
    88  * @return Destination address.
    89  *
    90  */
    91 void *memmove(void *dst, const void *src, size_t cnt)
    92 {
    93         /* Nothing to do? */
    94         if (src == dst)
    95                 return dst;
    96        
    97         /* Non-overlapping? */
    98         if ((dst >= src + cnt) || (src >= dst + cnt))
    99                 return memcpy(dst, src, cnt);
    100        
    101         uint8_t *dp;
    102         const uint8_t *sp;
    103        
    104         /* Which direction? */
    105         if (src > dst) {
    106                 /* Forwards. */
    107                 dp = dst;
    108                 sp = src;
    109                
    110                 while (cnt-- != 0)
    111                         *dp++ = *sp++;
    112         } else {
    113                 /* Backwards. */
    114                 dp = dst + (cnt - 1);
    115                 sp = src + (cnt - 1);
    116                
    117                 while (cnt-- != 0)
    118                         *dp-- = *sp--;
    119         }
    120        
    121         return dst;
     160                p[i] = x;       
    122161}
    123162

  • tools/autotool.py

    r3abfe9a8 rebebd38  
    501501                cross_prefix = os.environ['CROSS_PREFIX']
    502502        else:
    503                 cross_prefix = "/usr/local/cross"
     503                cross_prefix = "/usr/local"
    504504       
    505505        # Prefix binutils tools on Solaris

  • tools/toolchain.sh

    r3abfe9a8 rebebd38  
    5252#endif
    5353EOF
    54 
    55 BINUTILS_VERSION="2.21"
    56 GCC_VERSION="4.6.0"
    57 
    58 BASEDIR="`pwd`"
    59 BINUTILS="binutils-${BINUTILS_VERSION}.tar.bz2"
    60 GCC_CORE="gcc-core-${GCC_VERSION}.tar.bz2"
    61 GCC_OBJC="gcc-objc-${GCC_VERSION}.tar.bz2"
    62 GCC_CPP="gcc-g++-${GCC_VERSION}.tar.bz2"
    6354
    6455#
    … …  
    148139        echo " sparc64    SPARC V9"
    149140        echo " all        build all targets"
    150         echo " parallel   same as 'all', but in parallel"
    151141        echo
    152142        echo "The toolchain will be installed to the directory specified by"
    153143        echo "the CROSS_PREFIX environment variable. If the variable is not"
    154         echo "defined, /usr/local/cross will be used by default."
     144        echo "defined, /usr/local will be used by default."
    155145        echo
    156146       
    … …  
    204194}
    205195
    206 download_fetch() {
     196download_check() {
    207197        SOURCE="$1"
    208198        FILE="$2"
    … …  
    218208}
    219209
    220 source_check() {
    221         FILE="$1"
    222        
    223         if [ ! -f "${FILE}" ]; then
    224                 echo
    225                 echo "File ${FILE} not found."
    226                
    227                 exit 4
    228         fi
    229 }
    230 
    231210cleanup_dir() {
    232211        DIR="$1"
    … …  
    262241}
    263242
    264 prepare() {
    265         show_dependencies
    266         check_dependecies
    267         show_countdown 10
    268        
    269         BINUTILS_SOURCE="ftp://ftp.gnu.org/gnu/binutils/"
    270         GCC_SOURCE="ftp://ftp.gnu.org/gnu/gcc/gcc-${GCC_VERSION}/"
    271        
    272         download_fetch "${BINUTILS_SOURCE}" "${BINUTILS}" "c84c5acc9d266f1a7044b51c85a823f5"
    273         download_fetch "${GCC_SOURCE}" "${GCC_CORE}" "b1957f3209080b2f55bc3756d3a62b7c"
    274         download_fetch "${GCC_SOURCE}" "${GCC_OBJC}" "120d4675366ee82ea52f9ed65b57da04"
    275         download_fetch "${GCC_SOURCE}" "${GCC_CPP}" "a30090fa655d0db4c970740d353c81f1"
     243patch_binutils() {
     244        PLATFORM="$1"
     245       
     246        if [ "${PLATFORM}" == "arm32" ] ; then
     247                patch -p1 <<EOF
     248diff -Naur binutils-2.20.orig/gas/config/tc-arm.c binutils-2.20/gas/config/tc-arm.c
     249--- binutils-2.20.orig/gas/config/tc-arm.c      2009-08-30 00:10:59.000000000 +0200
     250+++ binutils-2.20/gas/config/tc-arm.c   2009-11-02 14:25:11.000000000 +0100
     251@@ -2485,8 +2485,9 @@
     252       know (frag->tc_frag_data.first_map == NULL);
     253       frag->tc_frag_data.first_map = symbolP;
     254     }
     255-  if (frag->tc_frag_data.last_map != NULL)
     256+  if (frag->tc_frag_data.last_map != NULL) {
     257     know (S_GET_VALUE (frag->tc_frag_data.last_map) < S_GET_VALUE (symbolP));
     258+  }
     259   frag->tc_frag_data.last_map = symbolP;
     260 }
     261EOF
     262                check_error $? "Error patching binutils"
     263        fi
    276264}
    277265
    … …  
    280268        TARGET="$2"
    281269       
    282         WORKDIR="${BASEDIR}/${PLATFORM}"
     270        BINUTILS_VERSION="2.20"
     271        GCC_VERSION="4.5.1"
     272       
     273        BINUTILS="binutils-${BINUTILS_VERSION}.tar.bz2"
     274        GCC_CORE="gcc-core-${GCC_VERSION}.tar.bz2"
     275        GCC_OBJC="gcc-objc-${GCC_VERSION}.tar.bz2"
     276        GCC_CPP="gcc-g++-${GCC_VERSION}.tar.bz2"
     277       
     278        BINUTILS_SOURCE="ftp://ftp.gnu.org/gnu/binutils/"
     279        GCC_SOURCE="ftp://ftp.gnu.org/gnu/gcc/gcc-${GCC_VERSION}/"
     280       
     281        WORKDIR="`pwd`"
    283282        BINUTILSDIR="${WORKDIR}/binutils-${BINUTILS_VERSION}"
    284283        GCCDIR="${WORKDIR}/gcc-${GCC_VERSION}"
    … …  
    286285       
    287286        if [ -z "${CROSS_PREFIX}" ] ; then
    288                 CROSS_PREFIX="/usr/local/cross"
     287                CROSS_PREFIX="/usr/local"
    289288        fi
    290289       
    … …  
    292291       
    293292        echo ">>> Downloading tarballs"
    294         source_check "${BASEDIR}/${BINUTILS}"
    295         source_check "${BASEDIR}/${GCC_CORE}"
    296         source_check "${BASEDIR}/${GCC_OBJC}"
    297         source_check "${BASEDIR}/${GCC_CPP}"
     293        download_check "${BINUTILS_SOURCE}" "${BINUTILS}" "ee2d3e996e9a2d669808713360fa96f8"
     294        download_check "${GCC_SOURCE}" "${GCC_CORE}" "dc8959e31b01a65ce10d269614815054"
     295        download_check "${GCC_SOURCE}" "${GCC_OBJC}" "3c11b7037896e967eddf8178af2ddd98"
     296        download_check "${GCC_SOURCE}" "${GCC_CPP}" "b294953ff0bb2f20c7acb2bf005d832a"
    298297       
    299298        echo ">>> Removing previous content"
    300299        cleanup_dir "${PREFIX}"
    301         cleanup_dir "${WORKDIR}"
     300        cleanup_dir "${OBJDIR}"
     301        cleanup_dir "${BINUTILSDIR}"
     302        cleanup_dir "${GCCDIR}"
    302303       
    303304        create_dir "${PREFIX}" "destination directory"
    … …  
    305306       
    306307        echo ">>> Unpacking tarballs"
    307         cd "${WORKDIR}"
    308         check_error $? "Change directory failed."
    309        
    310         unpack_tarball "${BASEDIR}/${BINUTILS}" "binutils"
    311         unpack_tarball "${BASEDIR}/${GCC_CORE}" "GCC Core"
    312         unpack_tarball "${BASEDIR}/${GCC_OBJC}" "Objective C"
    313         unpack_tarball "${BASEDIR}/${GCC_CPP}" "C++"
     308        unpack_tarball "${BINUTILS}" "binutils"
     309        unpack_tarball "${GCC_CORE}" "GCC Core"
     310        unpack_tarball "${GCC_OBJC}" "Objective C"
     311        unpack_tarball "${GCC_CPP}" "C++"
    314312       
    315313        echo ">>> Processing binutils (${PLATFORM})"
    316314        cd "${BINUTILSDIR}"
    317315        check_error $? "Change directory failed."
     316        patch_binutils "${PLATFORM}"
    318317       
    319318        change_title "binutils: configure (${PLATFORM})"
    … …  
    337336        check_error $? "Error compiling/installing GCC."
    338337       
    339         cd "${BASEDIR}"
     338        cd "${WORKDIR}"
    340339        check_error $? "Change directory failed."
    341340       
    342341        echo ">>> Cleaning up"
    343         cleanup_dir "${WORKDIR}"
     342        cleanup_dir "${OBJDIR}"
     343        cleanup_dir "${BINUTILSDIR}"
     344        cleanup_dir "${GCCDIR}"
    344345       
    345346        echo
    … …  
    351352fi
    352353
     354show_dependencies
     355check_dependecies
     356show_countdown 10
     357
    353358case "$1" in
    354359        "amd64")
    355                 prepare
    356360                build_target "amd64" "amd64-linux-gnu"
    357361                ;;
    358362        "arm32")
    359                 prepare
    360363                build_target "arm32" "arm-linux-gnu"
    361364                ;;
    362365        "ia32")
    363                 prepare
    364366                build_target "ia32" "i686-pc-linux-gnu"
    365367                ;;
    366368        "ia64")
    367                 prepare
    368369                build_target "ia64" "ia64-pc-linux-gnu"
    369370                ;;
     371        "ia64")
     372                build_target "ia64" "ia64-pc-linux-gnu"
     373                ;;
    370374        "mips32")
    371                 prepare
    372375                build_target "mips32" "mipsel-linux-gnu"
    373376                ;;
    374377        "mips32eb")
    375                 prepare
    376378                build_target "mips32eb" "mips-linux-gnu"
    377379                ;;
    378380        "mips64")
    379                 prepare
    380381                build_target "mips64" "mips64el-linux-gnu"
    381382                ;;
    382383        "ppc32")
    383                 prepare
    384384                build_target "ppc32" "ppc-linux-gnu"
    385385                ;;
    386386        "ppc64")
    387                 prepare
    388387                build_target "ppc64" "ppc64-linux-gnu"
    389388                ;;
    390389        "sparc64")
    391                 prepare
    392390                build_target "sparc64" "sparc64-linux-gnu"
    393391                ;;
    394392        "all")
    395                 prepare
    396393                build_target "amd64" "amd64-linux-gnu"
    397394                build_target "arm32" "arm-linux-gnu"
    398395                build_target "ia32" "i686-pc-linux-gnu"
     396                build_target "ia64" "ia64-pc-linux-gnu"
    399397                build_target "ia64" "ia64-pc-linux-gnu"
    400398                build_target "mips32" "mipsel-linux-gnu"
    … …  
    405403                build_target "sparc64" "sparc64-linux-gnu"
    406404                ;;
    407         "parallel")
    408                 prepare
    409                 build_target "amd64" "amd64-linux-gnu" &
    410                 build_target "arm32" "arm-linux-gnu" &
    411                 build_target "ia32" "i686-pc-linux-gnu" &
    412                 build_target "ia64" "ia64-pc-linux-gnu" &
    413                 build_target "mips32" "mipsel-linux-gnu" &
    414                 build_target "mips32eb" "mips-linux-gnu" &
    415                 build_target "mips64" "mips64el-linux-gnu" &
    416                 build_target "ppc32" "ppc-linux-gnu" &
    417                 build_target "ppc64" "ppc64-linux-gnu" &
    418                 build_target "sparc64" "sparc64-linux-gnu" &
    419                 wait
    420                 ;;
    421405        *)
    422406                show_usage

  • uspace/app/bdsh/cmds/modules/cat/cat.c

    r3abfe9a8 rebebd38  
    164164{
    165165        int fd, bytes = 0, count = 0, reads = 0;
     166        off64_t total = 0;
    166167        char *buff = NULL;
    167168        int i;
    … …  
    173174                return 1;
    174175        }
     176
     177        total = lseek(fd, 0, SEEK_END);
     178        lseek(fd, 0, SEEK_SET);
    175179
    176180        if (NULL == (buff = (char *) malloc(blen + 1))) {

  • uspace/app/sbi/src/run_expr.c

    r3abfe9a8 rebebd38  
    25292529        if (rc1 == EOK)
    25302530                rc2 = os_str_get_char(string->value, elem_index, &cval);
    2531         else
    2532                 rc2 = EOK;
    25332531
    25342532        if (rc1 != EOK || rc2 != EOK) {

  • uspace/app/tester/fault/fault2.c

    r3abfe9a8 rebebd38  
    2929
    3030#include "../tester.h"
    31 #include <stdio.h>
    3231
    3332typedef int __attribute__((may_alias)) aliasing_int;
    … …  
    3938       
    4039        var1 = *((aliasing_int *) (((char *) (&var)) + 1));
    41         printf("Read %d\n", var1);
    4240       
    4341        return "Survived unaligned read";

  • uspace/app/trace/trace.c

    r3abfe9a8 rebebd38  
    872872static display_mask_t parse_display_mask(const char *text)
    873873{
    874         display_mask_t dm = 0;
     874        display_mask_t dm;
    875875        const char *c = text;
    876876       

  • uspace/lib/c/arch/abs32le/_link.ld.in

    r3abfe9a8 rebebd38  
    1111       
    1212        .text : {
    13                 *(.text .text.*);
    14                 *(.rodata .rodata.*);
     13                *(.text);
     14                *(.rodata*);
    1515        } :text
    1616       

  • uspace/lib/c/arch/amd64/_link.ld.in

    r3abfe9a8 rebebd38  
    1616       
    1717        .text : {
    18                 *(.text .text.*);
    19                 *(.rodata .rodata.*);
     18                *(.text);
     19                *(.rodata*);
    2020        } :text
    2121       

  • uspace/lib/c/arch/arm32/_link.ld.in

    r3abfe9a8 rebebd38  
    1515       
    1616        .text : {
    17                 *(.text .text.*);
    18                 *(.rodata .rodata.*);
     17                *(.text);
     18                *(.rodata*);
    1919        } :text
    2020       

  • uspace/lib/c/arch/ia32/_link.ld.in

    r3abfe9a8 rebebd38  
    1616       
    1717        .text : {
    18                 *(.text .text.*);
    19                 *(.rodata .rodata.*);
     18                *(.text);
     19                *(.rodata*);
    2020        } :text
    2121       

  • uspace/lib/c/arch/ia64/_link.ld.in

    r3abfe9a8 rebebd38  
    1515       
    1616        .text : {
    17                 *(.text .text.*);
    18                 *(.rodata .rodata.*);
     17                *(.text);
     18                *(.rodata*);
    1919        } :text
    2020       
    … …  
    2323        .got : {
    2424                _gp = .;
    25                 *(.got .got.*);
     25                *(.got*);
    2626        } :data
    2727       

  • uspace/lib/c/arch/mips32/_link.ld.in

    r3abfe9a8 rebebd38  
    1515       
    1616        .text : {
    17                 *(.text .text.*);
    18                 *(.rodata .rodata.*);
     17                *(.text);
     18                *(.rodata*);
    1919        } :text
    2020       

  • uspace/lib/c/arch/ppc32/_link.ld.in

    r3abfe9a8 rebebd38  
    1515       
    1616        .text : {
    17                 *(.text .text.*);
    18                 *(.rodata .rodata.*);
     17                *(.text);
     18                *(.rodata*);
    1919        } :text
    2020       

  • uspace/lib/c/arch/sparc64/_link.ld.in

    r3abfe9a8 rebebd38  
    1515       
    1616        .text : {
    17                 *(.text .text.*);
    18                 *(.rodata .rodata.*);
     17                *(.text);
     18                *(.rodata*);
    1919        } :text
    2020       

  • uspace/lib/c/generic/vfs/vfs.c

    r3abfe9a8 rebebd38  
    756756{
    757757        struct stat stat;
    758        
    759         int rc = fstat(fildes, &stat);
    760         if (rc != 0)
    761                 return rc;
    762        
     758        int rc;
     759
     760        rc = fstat(fildes, &stat);
     761
    763762        if (!stat.device)
    764763                return -1;

  • uspace/srv/hw/bus/cuda_adb/cuda_adb.c

    r3abfe9a8 rebebd38  
    367367static void cuda_irq_rcv_end(void *buf, size_t *len)
    368368{
    369         uint8_t b;
    370        
     369        uint8_t data, b;
     370
    371371        b = pio_read_8(&dev->b);
    372         pio_read_8(&dev->sr);
    373        
     372        data = pio_read_8(&dev->sr);
     373
    374374        if ((b & TREQ) == 0) {
    375375                instance->xstate = cx_receive;
    … …  
    379379                cuda_send_start();
    380380        }
    381        
    382         memcpy(buf, instance->rcv_buf, instance->bidx);
    383         *len = instance->bidx;
     381
     382        memcpy(buf, instance->rcv_buf, instance->bidx);
     383        *len = instance->bidx;
    384384        instance->bidx = 0;
    385385}

  • uspace/srv/loader/arch/abs32le/_link.ld.in

    r3abfe9a8 rebebd38  
    2121       
    2222        .text : {
    23                 *(.text .text.*);
    24                 *(.rodata .rodata.*);
     23                *(.text);
     24                *(.rodata*);
    2525        } :text
    2626       

  • uspace/srv/loader/arch/amd64/_link.ld.in

    r3abfe9a8 rebebd38  
    2727       
    2828        .text : {
    29                 *(.text .text.*);
    30                 *(.rodata .rodata.*);
     29                *(.text);
     30                *(.rodata*);
    3131        } :text
    3232       

  • uspace/srv/loader/arch/arm32/_link.ld.in

    r3abfe9a8 rebebd38  
    2525       
    2626        .text : {
    27                 *(.text .text.*);
    28                 *(.rodata .rodata.*);
     27                *(.text);
     28                *(.rodata*);
    2929        } :text
    3030       

  • uspace/srv/loader/arch/ia32/_link.ld.in

    r3abfe9a8 rebebd38  
    2626       
    2727        .text : {
    28                 *(.text .text.*);
    29                 *(.rodata .rodata.*);
     28                *(.text);
     29                *(.rodata*);
    3030        } :text
    3131       

  • uspace/srv/loader/arch/ia64/_link.ld.in

    r3abfe9a8 rebebd38  
    2121       
    2222        .text : {
    23                 *(.text .text.*);
    24                 *(.rodata .rodata.*);
     23                *(.text);
     24                *(.rodata*);
    2525        } :text
    2626       
    … …  
    2929        .got : {
    3030                _gp = .;
    31                 *(.got .got.*);
     31                *(.got*);
    3232        } :data
    3333       

  • uspace/srv/loader/arch/mips32/_link.ld.in

    r3abfe9a8 rebebd38  
    2525       
    2626        .text : {
    27                 *(.text .text.*);
    28                 *(.rodata .rodata.*);
     27                *(.text);
     28                *(.rodata*);
    2929        } :text
    3030       

  • uspace/srv/loader/arch/ppc32/_link.ld.in

    r3abfe9a8 rebebd38  
    2525       
    2626        .text : {
    27                 *(.text .text.*);
    28                 *(.rodata .rodata.*);
     27                *(.text);
     28                *(.rodata*);
    2929        } :text
    3030       

  • uspace/srv/loader/arch/sparc64/_link.ld.in

    r3abfe9a8 rebebd38  
    2020       
    2121        .text : {
    22                 *(.text .text.*);
    23                 *(.rodata .rodata.*);
     22                *(.text);
     23                *(.rodata*);
    2424        } :text
    2525       

  • uspace/srv/loader/main.c

    r3abfe9a8 rebebd38  
    407407                        /* Not reached */
    408408                default:
    409                         retval = EINVAL;
     409                        retval = ENOENT;
    410410                        break;
    411411                }
    412                
    413                 if (IPC_GET_IMETHOD(call) != IPC_M_PHONE_HUNGUP)
    414                         async_answer_0(callid, retval);
     412                if (IPC_GET_IMETHOD(call) != IPC_M_PHONE_HUNGUP) {
     413                        DPRINTF("Responding EINVAL to method %d.\n",
     414                            IPC_GET_IMETHOD(call));
     415                        async_answer_0(callid, EINVAL);
     416                }
    415417        }
    416418}
Note: See TracChangeset for help on using the changeset viewer.