URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [config/] [arm/] [linux-atomic.c] - Blame information for rev 444

Go to most recent revision | Details | Compare with Previous | View Log


/* Linux-specific atomic operations for ARM EABI.
   Copyright (C) 2008, 2009 Free Software Foundation, Inc.
   Contributed by CodeSourcery.
 
This file is part of GCC.
 
GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.
 
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.
 
Under Section 7 of GPL version 3, you are granted additional
permissions described in the GCC Runtime Library Exception, version
3.1, as published by the Free Software Foundation.
 
You should have received a copy of the GNU General Public License and
a copy of the GCC Runtime Library Exception along with this program;
see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
<http://www.gnu.org/licenses/>.  */
 
/* Kernel helper for compare-and-exchange.  */
typedef int (__kernel_cmpxchg_t) (int oldval, int newval, int *ptr);
#define __kernel_cmpxchg (*(__kernel_cmpxchg_t *) 0xffff0fc0)
 
/* Kernel helper for memory barrier.  */
typedef void (__kernel_dmb_t) (void);
#define __kernel_dmb (*(__kernel_dmb_t *) 0xffff0fa0)
 
/* Note: we implement byte, short and int versions of atomic operations using
   the above kernel helpers, but there is no support for "long long" (64-bit)
   operations as yet.  */
 
#define HIDDEN __attribute__ ((visibility ("hidden")))
 
#ifdef __ARMEL__
#define INVERT_MASK_1 0
#define INVERT_MASK_2 0
#else
#define INVERT_MASK_1 24
#define INVERT_MASK_2 16
#endif
 
#define MASK_1 0xffu
#define MASK_2 0xffffu
 
#define FETCH_AND_OP_WORD(OP, PFX_OP, INF_OP)                           \
  int HIDDEN                                                            \
  __sync_fetch_and_##OP##_4 (int *ptr, int val)                         \
  {                                                                     \
    int failure, tmp;                                                   \
                                                                        \
    do {                                                                \
      tmp = *ptr;                                                       \
      failure = __kernel_cmpxchg (tmp, PFX_OP tmp INF_OP val, ptr);     \
    } while (failure != 0);                                              \
                                                                        \
    return tmp;                                                         \
  }
 
FETCH_AND_OP_WORD (add,   , +)
FETCH_AND_OP_WORD (sub,   , -)
FETCH_AND_OP_WORD (or,    , |)
FETCH_AND_OP_WORD (and,   , &)
FETCH_AND_OP_WORD (xor,   , ^)
FETCH_AND_OP_WORD (nand, ~, &)
 
#define NAME_oldval(OP, WIDTH) __sync_fetch_and_##OP##_##WIDTH
#define NAME_newval(OP, WIDTH) __sync_##OP##_and_fetch_##WIDTH
 
/* Implement both __sync_<op>_and_fetch and __sync_fetch_and_<op> for
   subword-sized quantities.  */
 
#define SUBWORD_SYNC_OP(OP, PFX_OP, INF_OP, TYPE, WIDTH, RETURN)        \
  TYPE HIDDEN                                                           \
  NAME##_##RETURN (OP, WIDTH) (TYPE *ptr, TYPE val)                     \
  {                                                                     \
    int *wordptr = (int *) ((unsigned int) ptr & ~3);                   \
    unsigned int mask, shift, oldval, newval;                           \
    int failure;                                                        \
                                                                        \
    shift = (((unsigned int) ptr & 3) << 3) ^ INVERT_MASK_##WIDTH;      \
    mask = MASK_##WIDTH << shift;                                       \
                                                                        \
    do {                                                                \
      oldval = *wordptr;                                                \
      newval = ((PFX_OP ((oldval & mask) >> shift)                      \
                 INF_OP (unsigned int) val) << shift) & mask;           \
      newval |= oldval & ~mask;                                         \
      failure = __kernel_cmpxchg (oldval, newval, wordptr);             \
    } while (failure != 0);                                              \
                                                                        \
    return (RETURN & mask) >> shift;                                    \
  }
 
SUBWORD_SYNC_OP (add,   , +, short, 2, oldval)
SUBWORD_SYNC_OP (sub,   , -, short, 2, oldval)
SUBWORD_SYNC_OP (or,    , |, short, 2, oldval)
SUBWORD_SYNC_OP (and,   , &, short, 2, oldval)
SUBWORD_SYNC_OP (xor,   , ^, short, 2, oldval)
SUBWORD_SYNC_OP (nand, ~, &, short, 2, oldval)
 
SUBWORD_SYNC_OP (add,   , +, char, 1, oldval)
SUBWORD_SYNC_OP (sub,   , -, char, 1, oldval)
SUBWORD_SYNC_OP (or,    , |, char, 1, oldval)
SUBWORD_SYNC_OP (and,   , &, char, 1, oldval)
SUBWORD_SYNC_OP (xor,   , ^, char, 1, oldval)
SUBWORD_SYNC_OP (nand, ~, &, char, 1, oldval)
 
#define OP_AND_FETCH_WORD(OP, PFX_OP, INF_OP)                           \
  int HIDDEN                                                            \
  __sync_##OP##_and_fetch_4 (int *ptr, int val)                         \
  {                                                                     \
    int tmp, failure;                                                   \
                                                                        \
    do {                                                                \
      tmp = *ptr;                                                       \
      failure = __kernel_cmpxchg (tmp, PFX_OP tmp INF_OP val, ptr);     \
    } while (failure != 0);                                              \
                                                                        \
    return PFX_OP tmp INF_OP val;                                       \
  }
 
OP_AND_FETCH_WORD (add,   , +)
OP_AND_FETCH_WORD (sub,   , -)
OP_AND_FETCH_WORD (or,    , |)
OP_AND_FETCH_WORD (and,   , &)
OP_AND_FETCH_WORD (xor,   , ^)
OP_AND_FETCH_WORD (nand, ~, &)
 
SUBWORD_SYNC_OP (add,   , +, short, 2, newval)
SUBWORD_SYNC_OP (sub,   , -, short, 2, newval)
SUBWORD_SYNC_OP (or,    , |, short, 2, newval)
SUBWORD_SYNC_OP (and,   , &, short, 2, newval)
SUBWORD_SYNC_OP (xor,   , ^, short, 2, newval)
SUBWORD_SYNC_OP (nand, ~, &, short, 2, newval)
 
SUBWORD_SYNC_OP (add,   , +, char, 1, newval)
SUBWORD_SYNC_OP (sub,   , -, char, 1, newval)
SUBWORD_SYNC_OP (or,    , |, char, 1, newval)
SUBWORD_SYNC_OP (and,   , &, char, 1, newval)
SUBWORD_SYNC_OP (xor,   , ^, char, 1, newval)
SUBWORD_SYNC_OP (nand, ~, &, char, 1, newval)
 
int HIDDEN
__sync_val_compare_and_swap_4 (int *ptr, int oldval, int newval)
{
  int actual_oldval, fail;
 
  while (1)
    {
      actual_oldval = *ptr;
 
      if (oldval != actual_oldval)
        return actual_oldval;
 
      fail = __kernel_cmpxchg (actual_oldval, newval, ptr);
 
      if (!fail)
        return oldval;
    }
}
 
#define SUBWORD_VAL_CAS(TYPE, WIDTH)                                    \
  TYPE HIDDEN                                                           \
  __sync_val_compare_and_swap_##WIDTH (TYPE *ptr, TYPE oldval,          \
                                       TYPE newval)                     \
  {                                                                     \
    int *wordptr = (int *)((unsigned int) ptr & ~3), fail;              \
    unsigned int mask, shift, actual_oldval, actual_newval;             \
                                                                        \
    shift = (((unsigned int) ptr & 3) << 3) ^ INVERT_MASK_##WIDTH;      \
    mask = MASK_##WIDTH << shift;                                       \
                                                                        \
    while (1)                                                           \
      {                                                                 \
        actual_oldval = *wordptr;                                       \
                                                                        \
        if (((actual_oldval & mask) >> shift) != (unsigned int) oldval) \
          return (actual_oldval & mask) >> shift;                       \
                                                                        \
        actual_newval = (actual_oldval & ~mask)                         \
                        | (((unsigned int) newval << shift) & mask);    \
                                                                        \
        fail = __kernel_cmpxchg (actual_oldval, actual_newval,          \
                                 wordptr);                              \
                                                                        \
        if (!fail)                                                      \
          return oldval;                                                \
      }                                                                 \
  }
 
SUBWORD_VAL_CAS (short, 2)
SUBWORD_VAL_CAS (char,  1)
 
typedef unsigned char bool;
 
bool HIDDEN
__sync_bool_compare_and_swap_4 (int *ptr, int oldval, int newval)
{
  int failure = __kernel_cmpxchg (oldval, newval, ptr);
  return (failure == 0);
}
 
#define SUBWORD_BOOL_CAS(TYPE, WIDTH)                                   \
  bool HIDDEN                                                           \
  __sync_bool_compare_and_swap_##WIDTH (TYPE *ptr, TYPE oldval,         \
                                        TYPE newval)                    \
  {                                                                     \
    TYPE actual_oldval                                                  \
      = __sync_val_compare_and_swap_##WIDTH (ptr, oldval, newval);      \
    return (oldval == actual_oldval);                                   \
  }
 
SUBWORD_BOOL_CAS (short, 2)
SUBWORD_BOOL_CAS (char,  1)
 
void HIDDEN
__sync_synchronize (void)
{
  __kernel_dmb ();
}
 
int HIDDEN
__sync_lock_test_and_set_4 (int *ptr, int val)
{
  int failure, oldval;
 
  do {
    oldval = *ptr;
    failure = __kernel_cmpxchg (oldval, val, ptr);
  } while (failure != 0);
 
  return oldval;
}
 
#define SUBWORD_TEST_AND_SET(TYPE, WIDTH)                               \
  TYPE HIDDEN                                                           \
  __sync_lock_test_and_set_##WIDTH (TYPE *ptr, TYPE val)                \
  {                                                                     \
    int failure;                                                        \
    unsigned int oldval, newval, shift, mask;                           \
    int *wordptr = (int *) ((unsigned int) ptr & ~3);                   \
                                                                        \
    shift = (((unsigned int) ptr & 3) << 3) ^ INVERT_MASK_##WIDTH;      \
    mask = MASK_##WIDTH << shift;                                       \
                                                                        \
    do {                                                                \
      oldval = *wordptr;                                                \
      newval = (oldval & ~mask)                                         \
               | (((unsigned int) val << shift) & mask);                \
      failure = __kernel_cmpxchg (oldval, newval, wordptr);             \
    } while (failure != 0);                                              \
                                                                        \
    return (oldval & mask) >> shift;                                    \
  }
 
SUBWORD_TEST_AND_SET (short, 2)
SUBWORD_TEST_AND_SET (char,  1)
 
#define SYNC_LOCK_RELEASE(TYPE, WIDTH)                                  \
  void HIDDEN                                                           \
  __sync_lock_release_##WIDTH (TYPE *ptr)                               \
  {                                                                     \
    /* All writes before this point must be seen before we release      \
       the lock itself.  */                                             \
    __kernel_dmb ();                                                    \
    *ptr = 0;                                                            \
  }
 
SYNC_LOCK_RELEASE (int,   4)
SYNC_LOCK_RELEASE (short, 2)
SYNC_LOCK_RELEASE (char,  1)

Browse

Tools

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [config/] [arm/] [linux-atomic.c] - Blame information for rev 444

Line No.	Rev	Author	Line
1	282	jeremybenn	`/* Linux-specific atomic operations for ARM EABI.`
2			`Copyright (C) 2008, 2009 Free Software Foundation, Inc.`
3			`Contributed by CodeSourcery.`
4
5			`This file is part of GCC.`
6
7			`GCC is free software; you can redistribute it and/or modify it under`
8			`the terms of the GNU General Public License as published by the Free`
9			`Software Foundation; either version 3, or (at your option) any later`
10			`version.`
11
12			`GCC is distributed in the hope that it will be useful, but WITHOUT ANY`
13			`WARRANTY; without even the implied warranty of MERCHANTABILITY or`
14			`FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License`
15			`for more details.`
16
17			`Under Section 7 of GPL version 3, you are granted additional`
18			`permissions described in the GCC Runtime Library Exception, version`
19			`3.1, as published by the Free Software Foundation.`
20
21			`You should have received a copy of the GNU General Public License and`
22			`a copy of the GCC Runtime Library Exception along with this program;`
23			`see the files COPYING3 and COPYING.RUNTIME respectively. If not, see`
24			`<http://www.gnu.org/licenses/>. */`
25
26			`/* Kernel helper for compare-and-exchange. */`
27			`typedef int (__kernel_cmpxchg_t) (int oldval, int newval, int *ptr);`
28			`#define __kernel_cmpxchg ((__kernel_cmpxchg_t ) 0xffff0fc0)`
29
30			`/* Kernel helper for memory barrier. */`
31			`typedef void (__kernel_dmb_t) (void);`
32			`#define __kernel_dmb ((__kernel_dmb_t ) 0xffff0fa0)`
33
34			`/* Note: we implement byte, short and int versions of atomic operations using`
35			`the above kernel helpers, but there is no support for "long long" (64-bit)`
36			`operations as yet. */`
37
38			`#define HIDDEN __attribute__ ((visibility ("hidden")))`
39
40			`#ifdef __ARMEL__`
41			`#define INVERT_MASK_1 0`
42			`#define INVERT_MASK_2 0`
43			`#else`
44			`#define INVERT_MASK_1 24`
45			`#define INVERT_MASK_2 16`
46			`#endif`
47
48			`#define MASK_1 0xffu`
49			`#define MASK_2 0xffffu`
50
51			`#define FETCH_AND_OP_WORD(OP, PFX_OP, INF_OP) \`
52			`int HIDDEN \`
53			`__sync_fetch_and_##OP##_4 (int *ptr, int val) \`
54			`{ \`
55			`int failure, tmp; \`
56			`\`
57			`do { \`
58			`tmp = *ptr; \`
59			`failure = __kernel_cmpxchg (tmp, PFX_OP tmp INF_OP val, ptr); \`
60			`} while (failure != 0); \`
61			`\`
62			`return tmp; \`
63			`}`
64
65			`FETCH_AND_OP_WORD (add, , +)`
66			`FETCH_AND_OP_WORD (sub, , -)`
67			`FETCH_AND_OP_WORD (or, , \|)`
68			`FETCH_AND_OP_WORD (and, , &)`
69			`FETCH_AND_OP_WORD (xor, , ^)`
70			`FETCH_AND_OP_WORD (nand, ~, &)`
71
72			`#define NAME_oldval(OP, WIDTH) __sync_fetch_and_##OP##_##WIDTH`
73			`#define NAME_newval(OP, WIDTH) __sync_##OP##_and_fetch_##WIDTH`
74
75			`/* Implement both __sync_<op>_and_fetch and __sync_fetch_and_<op> for`
76			`subword-sized quantities. */`
77
78			`#define SUBWORD_SYNC_OP(OP, PFX_OP, INF_OP, TYPE, WIDTH, RETURN) \`
79			`TYPE HIDDEN \`
80			`NAME##_##RETURN (OP, WIDTH) (TYPE *ptr, TYPE val) \`
81			`{ \`
82			`int wordptr = (int ) ((unsigned int) ptr & ~3); \`
83			`unsigned int mask, shift, oldval, newval; \`
84			`int failure; \`
85			`\`
86			`shift = (((unsigned int) ptr & 3) << 3) ^ INVERT_MASK_##WIDTH; \`
87			`mask = MASK_##WIDTH << shift; \`
88			`\`
89			`do { \`
90			`oldval = *wordptr; \`
91			`newval = ((PFX_OP ((oldval & mask) >> shift) \`
92			`INF_OP (unsigned int) val) << shift) & mask; \`
93			`newval \|= oldval & ~mask; \`
94			`failure = __kernel_cmpxchg (oldval, newval, wordptr); \`
95			`} while (failure != 0); \`
96			`\`
97			`return (RETURN & mask) >> shift; \`
98			`}`
99
100			`SUBWORD_SYNC_OP (add, , +, short, 2, oldval)`
101			`SUBWORD_SYNC_OP (sub, , -, short, 2, oldval)`
102			`SUBWORD_SYNC_OP (or, , \|, short, 2, oldval)`
103			`SUBWORD_SYNC_OP (and, , &, short, 2, oldval)`
104			`SUBWORD_SYNC_OP (xor, , ^, short, 2, oldval)`
105			`SUBWORD_SYNC_OP (nand, ~, &, short, 2, oldval)`
106
107			`SUBWORD_SYNC_OP (add, , +, char, 1, oldval)`
108			`SUBWORD_SYNC_OP (sub, , -, char, 1, oldval)`
109			`SUBWORD_SYNC_OP (or, , \|, char, 1, oldval)`
110			`SUBWORD_SYNC_OP (and, , &, char, 1, oldval)`
111			`SUBWORD_SYNC_OP (xor, , ^, char, 1, oldval)`
112			`SUBWORD_SYNC_OP (nand, ~, &, char, 1, oldval)`
113
114			`#define OP_AND_FETCH_WORD(OP, PFX_OP, INF_OP) \`
115			`int HIDDEN \`
116			`__sync_##OP##_and_fetch_4 (int *ptr, int val) \`
117			`{ \`
118			`int tmp, failure; \`
119			`\`
120			`do { \`
121			`tmp = *ptr; \`
122			`failure = __kernel_cmpxchg (tmp, PFX_OP tmp INF_OP val, ptr); \`
123			`} while (failure != 0); \`
124			`\`
125			`return PFX_OP tmp INF_OP val; \`
126			`}`
127
128			`OP_AND_FETCH_WORD (add, , +)`
129			`OP_AND_FETCH_WORD (sub, , -)`
130			`OP_AND_FETCH_WORD (or, , \|)`
131			`OP_AND_FETCH_WORD (and, , &)`
132			`OP_AND_FETCH_WORD (xor, , ^)`
133			`OP_AND_FETCH_WORD (nand, ~, &)`
134
135			`SUBWORD_SYNC_OP (add, , +, short, 2, newval)`
136			`SUBWORD_SYNC_OP (sub, , -, short, 2, newval)`
137			`SUBWORD_SYNC_OP (or, , \|, short, 2, newval)`
138			`SUBWORD_SYNC_OP (and, , &, short, 2, newval)`
139			`SUBWORD_SYNC_OP (xor, , ^, short, 2, newval)`
140			`SUBWORD_SYNC_OP (nand, ~, &, short, 2, newval)`
141
142			`SUBWORD_SYNC_OP (add, , +, char, 1, newval)`
143			`SUBWORD_SYNC_OP (sub, , -, char, 1, newval)`
144			`SUBWORD_SYNC_OP (or, , \|, char, 1, newval)`
145			`SUBWORD_SYNC_OP (and, , &, char, 1, newval)`
146			`SUBWORD_SYNC_OP (xor, , ^, char, 1, newval)`
147			`SUBWORD_SYNC_OP (nand, ~, &, char, 1, newval)`
148
149			`int HIDDEN`
150			`__sync_val_compare_and_swap_4 (int *ptr, int oldval, int newval)`
151			`{`
152			`int actual_oldval, fail;`
153
154			`while (1)`
155			`{`
156			`actual_oldval = *ptr;`
157
158			`if (oldval != actual_oldval)`
159			`return actual_oldval;`
160
161			`fail = __kernel_cmpxchg (actual_oldval, newval, ptr);`
162
163			`if (!fail)`
164			`return oldval;`
165			`}`
166			`}`
167
168			`#define SUBWORD_VAL_CAS(TYPE, WIDTH) \`
169			`TYPE HIDDEN \`
170			`__sync_val_compare_and_swap_##WIDTH (TYPE *ptr, TYPE oldval, \`
171			`TYPE newval) \`
172			`{ \`
173			`int wordptr = (int )((unsigned int) ptr & ~3), fail; \`
174			`unsigned int mask, shift, actual_oldval, actual_newval; \`
175			`\`
176			`shift = (((unsigned int) ptr & 3) << 3) ^ INVERT_MASK_##WIDTH; \`
177			`mask = MASK_##WIDTH << shift; \`
178			`\`
179			`while (1) \`
180			`{ \`
181			`actual_oldval = *wordptr; \`
182			`\`
183			`if (((actual_oldval & mask) >> shift) != (unsigned int) oldval) \`
184			`return (actual_oldval & mask) >> shift; \`
185			`\`
186			`actual_newval = (actual_oldval & ~mask) \`
187			`\| (((unsigned int) newval << shift) & mask); \`
188			`\`
189			`fail = __kernel_cmpxchg (actual_oldval, actual_newval, \`
190			`wordptr); \`
191			`\`
192			`if (!fail) \`
193			`return oldval; \`
194			`} \`
195			`}`
196
197			`SUBWORD_VAL_CAS (short, 2)`
198			`SUBWORD_VAL_CAS (char, 1)`
199
200			`typedef unsigned char bool;`
201
202			`bool HIDDEN`
203			`__sync_bool_compare_and_swap_4 (int *ptr, int oldval, int newval)`
204			`{`
205			`int failure = __kernel_cmpxchg (oldval, newval, ptr);`
206			`return (failure == 0);`
207			`}`
208
209			`#define SUBWORD_BOOL_CAS(TYPE, WIDTH) \`
210			`bool HIDDEN \`
211			`__sync_bool_compare_and_swap_##WIDTH (TYPE *ptr, TYPE oldval, \`
212			`TYPE newval) \`
213			`{ \`
214			`TYPE actual_oldval \`
215			`= __sync_val_compare_and_swap_##WIDTH (ptr, oldval, newval); \`
216			`return (oldval == actual_oldval); \`
217			`}`
218
219			`SUBWORD_BOOL_CAS (short, 2)`
220			`SUBWORD_BOOL_CAS (char, 1)`
221
222			`void HIDDEN`
223			`__sync_synchronize (void)`
224			`{`
225			`__kernel_dmb ();`
226			`}`
227
228			`int HIDDEN`
229			`__sync_lock_test_and_set_4 (int *ptr, int val)`
230			`{`
231			`int failure, oldval;`
232
233			`do {`
234			`oldval = *ptr;`
235			`failure = __kernel_cmpxchg (oldval, val, ptr);`
236			`} while (failure != 0);`
237
238			`return oldval;`
239			`}`
240
241			`#define SUBWORD_TEST_AND_SET(TYPE, WIDTH) \`
242			`TYPE HIDDEN \`
243			`__sync_lock_test_and_set_##WIDTH (TYPE *ptr, TYPE val) \`
244			`{ \`
245			`int failure; \`
246			`unsigned int oldval, newval, shift, mask; \`
247			`int wordptr = (int ) ((unsigned int) ptr & ~3); \`
248			`\`
249			`shift = (((unsigned int) ptr & 3) << 3) ^ INVERT_MASK_##WIDTH; \`
250			`mask = MASK_##WIDTH << shift; \`
251			`\`
252			`do { \`
253			`oldval = *wordptr; \`
254			`newval = (oldval & ~mask) \`
255			`\| (((unsigned int) val << shift) & mask); \`
256			`failure = __kernel_cmpxchg (oldval, newval, wordptr); \`
257			`} while (failure != 0); \`
258			`\`
259			`return (oldval & mask) >> shift; \`
260			`}`
261
262			`SUBWORD_TEST_AND_SET (short, 2)`
263			`SUBWORD_TEST_AND_SET (char, 1)`
264
265			`#define SYNC_LOCK_RELEASE(TYPE, WIDTH) \`
266			`void HIDDEN \`
267			`__sync_lock_release_##WIDTH (TYPE *ptr) \`
268			`{ \`
269			`/* All writes before this point must be seen before we release \`
270			`the lock itself. */ \`
271			`__kernel_dmb (); \`
272			`*ptr = 0; \`
273			`}`
274
275			`SYNC_LOCK_RELEASE (int, 4)`
276			`SYNC_LOCK_RELEASE (short, 2)`
277			`SYNC_LOCK_RELEASE (char, 1)`