Changeset 04803bf in mainline for uspace/lib/c/arch/arm32


Ignore:
Timestamp:
2011-03-21T22:00:17Z (15 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
143932e3
Parents:
b50b5af2 (diff), 7308e84 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge mainline changes (needs fixes).

Location:
uspace/lib/c/arch/arm32
Files:
5 added
19 moved

Legend:

Unmodified
Added
Removed

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

    rb50b5af2 r04803bf  
    2828#
    2929
    30 ## Toolchain configuration
    31 #
    32 
    33 TARGET = arm-linux-gnu
    34 TOOLCHAIN_DIR = $(CROSS_PREFIX)/arm/bin
    35 
    36 ARCH_SOURCES += arch/$(UARCH)/src/syscall.c \
     30ARCH_SOURCES = \
     31        arch/$(UARCH)/src/entry.s \
     32        arch/$(UARCH)/src/thread_entry.s \
     33        arch/$(UARCH)/src/syscall.c \
    3734        arch/$(UARCH)/src/fibril.S \
    3835        arch/$(UARCH)/src/tls.c \
    39         arch/$(UARCH)/src/eabi.S
     36        arch/$(UARCH)/src/eabi.S \
     37        arch/$(UARCH)/src/stacktrace.c \
     38        arch/$(UARCH)/src/stacktrace_asm.S
    4039
    41 CFLAGS += -ffixed-r9 -mtp=soft
    42 LFLAGS += -N $(SOFTINT_PREFIX)/libsoftint.a
    43 
    44 ENDIANESS = LE
    45 
    46 BFD_NAME = elf32-littlearm
    47 BFD_ARCH = arm
     40.PRECIOUS: arch/$(UARCH)/src/entry.o

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

    rb50b5af2 r04803bf  
    1 STARTUP(LIBC_PREFIX/arch/UARCH/src/entry.o)
     1STARTUP(LIBC_PATH/arch/UARCH/src/entry.o)
    22ENTRY(__entry)
    33
    … …  
    1313                *(.init);
    1414        } :text
     15       
    1516        .text : {
    1617                *(.text);
    1718                *(.rodata*);
    1819        } :text
    19 
     20       
    2021        . = . + 0x1000;
    21 
     22       
    2223        .data : {
    23                 *(.data);
     24                *(.opd);
     25                *(.data .data.*);
     26                *(.sdata);
    2427        } :data
     28       
    2529        .tdata : {
    2630                _tdata_start = .;
    … …  
    3135                _tbss_end = .;
    3236        } :data
     37       
    3338        _tls_alignment = ALIGNOF(.tdata);
     39       
    3440        .bss : {
     41                *(.sbss);
     42                *(.scommon);
    3543                *(COMMON);
    3644                *(.bss);
    3745        } :data
    38 
    39         . = ALIGN(0x1000);
    40         _heap = .;
    4146       
    4247        /DISCARD/ : {
    4348                *(*);
    4449        }
    45 
    4650}

  • uspace/lib/c/arch/arm32/include/atomic.h

    rb50b5af2 r04803bf  
    2727 */
    2828
    29 /** @addtogroup libcarm32       
     29/** @addtogroup libcarm32
    3030 * @{
    3131 */
    … …  
    3737#define LIBC_arm32_ATOMIC_H_
    3838
     39#define LIBC_ARCH_ATOMIC_H_
     40#define CAS
     41
     42#include <atomicdflt.h>
     43#include <bool.h>
     44#include <sys/types.h>
     45
     46extern uintptr_t *ras_page;
     47
     48static inline bool cas(atomic_t *val, atomic_count_t ov, atomic_count_t nv)
     49{
     50        atomic_count_t ret = 0;
     51       
     52        /*
     53         * The following instructions between labels 1 and 2 constitute a
     54         * Restartable Atomic Seqeunce. Should the sequence be non-atomic,
     55         * the kernel will restart it.
     56         */
     57        asm volatile (
     58                "1:\n"
     59                "       adr %[ret], 1b\n"
     60                "       str %[ret], %[rp0]\n"
     61                "       adr %[ret], 2f\n"
     62                "       str %[ret], %[rp1]\n"
     63                "       ldr %[ret], %[addr]\n"
     64                "       cmp %[ret], %[ov]\n"
     65                "       streq %[nv], %[addr]\n"
     66                "2:\n"
     67                "       moveq %[ret], #1\n"
     68                "       movne %[ret], #0\n"
     69                : [ret] "+&r" (ret),
     70                  [rp0] "=m" (ras_page[0]),
     71                  [rp1] "=m" (ras_page[1]),
     72                  [addr] "+m" (val->count)
     73                : [ov] "r" (ov),
     74                  [nv] "r" (nv)
     75                : "memory"
     76        );
     77       
     78        ras_page[0] = 0;
     79        asm volatile (
     80                "" ::: "memory"
     81        );
     82        ras_page[1] = 0xffffffff;
     83       
     84        return (bool) ret;
     85}
     86
    3987/** Atomic addition.
    4088 *
    … …  
    4391 *
    4492 * @return Value after addition.
    45  */
    46 static inline long atomic_add(atomic_t *val, int i)
    47 {
    48         int ret;
    49         volatile long * mem = &(val->count);
    50 
    51         asm volatile (
    52         "1:\n"
    53                 "ldr r2, [%1]\n"
    54                 "add r3, r2, %2\n"
    55                 "str r3, %0\n"
    56                 "swp r3, r3, [%1]\n"
    57                 "cmp r3, r2\n"
    58                 "bne 1b\n"
    59 
    60                 : "=m" (ret)
    61                 : "r" (mem), "r" (i)
    62                 : "r3", "r2"
    63         );
    64 
     93 *
     94 */
     95static inline atomic_count_t atomic_add(atomic_t *val, atomic_count_t i)
     96{
     97        atomic_count_t ret = 0;
     98       
     99        /*
     100         * The following instructions between labels 1 and 2 constitute a
     101         * Restartable Atomic Seqeunce. Should the sequence be non-atomic,
     102         * the kernel will restart it.
     103         */
     104        asm volatile (
     105                "1:\n"
     106                "       adr %[ret], 1b\n"
     107                "       str %[ret], %[rp0]\n"
     108                "       adr %[ret], 2f\n"
     109                "       str %[ret], %[rp1]\n"
     110                "       ldr %[ret], %[addr]\n"
     111                "       add %[ret], %[ret], %[imm]\n"
     112                "       str %[ret], %[addr]\n"
     113                "2:\n"
     114                : [ret] "+&r" (ret),
     115                  [rp0] "=m" (ras_page[0]),
     116                  [rp1] "=m" (ras_page[1]),
     117                  [addr] "+m" (val->count)
     118                : [imm] "r" (i)
     119        );
     120       
     121        ras_page[0] = 0;
     122        asm volatile (
     123                "" ::: "memory"
     124        );
     125        ras_page[1] = 0xffffffff;
     126       
    65127        return ret;
    66128}
    … …  
    70132 *
    71133 * @param val Variable to be incremented.
     134 *
    72135 */
    73136static inline void atomic_inc(atomic_t *val)
    … …  
    80143 *
    81144 * @param val Variable to be decremented.
     145 *
    82146 */
    83147static inline void atomic_dec(atomic_t *val)
    … …  
    91155 * @param val Variable to be incremented.
    92156 * @return    Value after incrementation.
    93  */
    94 static inline long atomic_preinc(atomic_t *val)
     157 *
     158 */
     159static inline atomic_count_t atomic_preinc(atomic_t *val)
    95160{
    96161        return atomic_add(val, 1);
    … …  
    102167 * @param val Variable to be decremented.
    103168 * @return    Value after decrementation.
    104  */
    105 static inline long atomic_predec(atomic_t *val)
     169 *
     170 */
     171static inline atomic_count_t atomic_predec(atomic_t *val)
    106172{
    107173        return atomic_add(val, -1);
    … …  
    113179 * @param val Variable to be incremented.
    114180 * @return    Value before incrementation.
    115  */
    116 static inline long atomic_postinc(atomic_t *val)
     181 *
     182 */
     183static inline atomic_count_t atomic_postinc(atomic_t *val)
    117184{
    118185        return atomic_add(val, 1) - 1;
    … …  
    124191 * @param val Variable to be decremented.
    125192 * @return    Value before decrementation.
    126  */
    127 static inline long atomic_postdec(atomic_t *val)
     193 *
     194 */
     195static inline atomic_count_t atomic_postdec(atomic_t *val)
    128196{
    129197        return atomic_add(val, -1) + 1;

  • uspace/lib/c/arch/arm32/include/fibril.h

    rb50b5af2 r04803bf  
    5858 *  @param ptls  Pointer to the TCB.
    5959 */
    60 #define context_set(c, _pc, stack, size, ptls)                  \
    61         (c)->pc = (sysarg_t) (_pc);                             \
    62         (c)->sp = ((sysarg_t) (stack)) + (size) - SP_DELTA;     \
    63         (c)->tls = ((sysarg_t)(ptls)) + sizeof(tcb_t) + ARM_TP_OFFSET;
    64 
     60#define context_set(c, _pc, stack, size, ptls) \
     61        do { \
     62                (c)->pc = (sysarg_t) (_pc); \
     63                (c)->sp = ((sysarg_t) (stack)) + (size) - SP_DELTA; \
     64                (c)->tls = ((sysarg_t)(ptls)) + sizeof(tcb_t) + ARM_TP_OFFSET; \
     65                (c)->fp = 0; \
     66        } while (0)
    6567
    6668/** Fibril context.
    … …  
    7981        uint32_t r7;
    8082        uint32_t r8;
    81         uint32_t tls;
     83        uint32_t tls;   /* r9 */
    8284        uint32_t r10;
    83         uint32_t r11;
     85        uint32_t fp;    /* r11 */
    8486} context_t;
     87
     88static inline uintptr_t context_get_fp(context_t *ctx)
     89{
     90        return ctx->fp;
     91}
    8592
    8693

  • uspace/lib/c/arch/arm32/include/types.h

    rb50b5af2 r04803bf  
    2727 */
    2828
    29 /** @addtogroup libcarm32       
     29/** @addtogroup libcarm32
    3030 * @{
    3131 */
    32 /** @file 
     32/** @file
    3333 *  @brief Definitions of basic types like #uintptr_t.
    3434 */
    … …  
    3737#define LIBC_arm32_TYPES_H_
    3838
    39 typedef unsigned int sysarg_t;
     39#define __32_BITS__
    4040
    41 typedef char int8_t;
    42 typedef short int int16_t;
    43 typedef long int int32_t;
    44 typedef long long int int64_t;
     41#include <libarch/common.h>
    4542
    46 typedef unsigned char uint8_t;
    47 typedef unsigned short int uint16_t;
    48 typedef unsigned long int uint32_t;
    49 typedef unsigned long long int uint64_t;
     43#define SIZE_MIN  UINT32_MIN
     44#define SIZE_MAX  UINT32_MAX
     45
     46#define SSIZE_MIN  INT32_MIN
     47#define SSIZE_MAX  INT32_MAX
     48
     49typedef uint32_t sysarg_t;
    5050
    5151typedef int32_t ssize_t;
    … …  
    5353
    5454typedef uint32_t uintptr_t;
     55typedef uint32_t atomic_count_t;
     56typedef int32_t atomic_signed_t;
    5557
    5658#endif

  • uspace/lib/c/arch/arm32/src/entry.s

    rb50b5af2 r04803bf  
    3636#
    3737# r1 contains the PCB pointer
     38# r2 contains the RAS page address
    3839#
    3940__entry:
     41        # Store the RAS page address into the ras_page variable
     42        ldr r0, =ras_page
     43        str r2, [r0]
     44       
     45        #
     46        # Create the first stack frame.
     47        #
     48        mov fp, #0
     49        mov ip, sp
     50        push {fp, ip, lr, pc}
     51        sub fp, ip, #4
     52       
    4053        # Pass pcb_ptr to __main as the first argument (in r0)
    4154        mov r0, r1
    4255        bl __main
    4356
    44         bl __exit
     57.data
     58
     59.global ras_page
     60ras_page:
     61        .long 0

  • uspace/lib/c/arch/arm32/src/syscall.c

    rb50b5af2 r04803bf  
    6060        register sysarg_t __arm_reg_r5 asm("r5") = p6;
    6161        register sysarg_t __arm_reg_r6 asm("r6") = id;
    62 
    63         asm volatile ( "swi"
     62       
     63        asm volatile (
     64                "swi 0"
    6465                : "=r" (__arm_reg_r0)
    6566                : "r" (__arm_reg_r0),
    … …  
    7172                  "r" (__arm_reg_r6)
    7273        );
    73 
     74       
    7475        return __arm_reg_r0;
    7576}

  • uspace/lib/c/arch/arm32/src/thread_entry.s

    rb50b5af2 r04803bf  
    3535#
    3636__thread_entry:
     37        #
     38        # Create the first stack frame.
     39        #
     40        mov fp, #0
     41        mov ip, sp
     42        push {fp, ip, lr, pc}
     43        sub fp, ip, #4
     44
    3745        b __thread_main
Note: See TracChangeset for help on using the changeset viewer.