← Back to branch summary

~oif-team/ubuntu/natty/qt4-x11/xi2.1

« back to all changes in this revision

Viewing changes to src/corelib/arch/ia64/arch/qatomic.h

  • Committer: Bazaar Package Importer
  • Author(s): Adam Conrad
  • Date: 2005-08-24 04:09:09 UTC
  • Revision ID: james.westby@ubuntu.com-20050824040909-xmxe9jfr4a0w5671
Tags: upstream-4.0.0
Import upstream version 4.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/corelib/arch/ia64/arch/qatomic.h
 
1
/****************************************************************************
 
2
**
 
3
** Copyright (C) 1992-2005 Trolltech AS. All rights reserved.
 
4
**
 
5
** This file is part of the core module of the Qt Toolkit.
 
6
**
 
7
** This file may be distributed under the terms of the Q Public License
 
8
** as defined by Trolltech AS of Norway and appearing in the file
 
9
** LICENSE.QPL included in the packaging of this file.
 
10
**
 
11
** This file may be distributed and/or modified under the terms of the
 
12
** GNU General Public License version 2 as published by the Free Software
 
13
** Foundation and appearing in the file LICENSE.GPL included in the
 
14
** packaging of this file.
 
15
**
 
16
** See http://www.trolltech.com/pricing.html or email sales@trolltech.com for
 
17
**   information about Qt Commercial License Agreements.
 
18
** See http://www.trolltech.com/qpl/ for QPL licensing information.
 
19
** See http://www.trolltech.com/gpl/ for GPL licensing information.
 
20
**
 
21
** Contact info@trolltech.com if any conditions of this licensing are
 
22
** not clear to you.
 
23
**
 
24
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 
25
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 
26
**
 
27
****************************************************************************/
 
28
 
 
29
#ifndef IA64_QATOMIC_H
 
30
#define IA64_QATOMIC_H
 
31
 
 
32
#include <QtCore/qglobal.h>
 
33
 
 
34
#if defined(Q_CC_INTEL)
 
35
 
 
36
// intrinsics provided by the Intel C++ Compiler
 
37
extern "C" {
 
38
    int _InterlockedExchange(volatile int *, int);
 
39
    int _InterlockedCompareExchange(volatile int *, int, int);
 
40
    int _InterlockedIncrement(volatile int *addend);
 
41
    int _InterlockedDecrement(volatile int *addend);
 
42
    void * _InterlockedCompareExchangePointer(void * volatile *, void *, void *);
 
43
    void * _InterlockedExchangePointer(void * volatile *, void *);
 
44
}
 
45
 
 
46
inline int q_atomic_test_and_set_int(volatile int *ptr, int expected, int newval)
 
47
{ return static_cast<int>(_InterlockedCompareExchange(ptr, newval, expected)) == expected; }
 
48
 
 
49
inline int q_atomic_test_and_set_ptr(volatile void *ptr, void *expected, void *newval)
 
50
{
 
51
    return _InterlockedCompareExchangePointer(reinterpret_cast<void * volatile *>(ptr),
 
52
                                              newval, expected) == expected;
 
53
}
 
54
 
 
55
 
 
56
inline int q_atomic_increment(volatile int *ptr)
 
57
{ return _InterlockedIncrement(ptr); }
 
58
 
 
59
inline int q_atomic_decrement(volatile int *ptr)
 
60
{ return _InterlockedDecrement(ptr); }
 
61
 
 
62
inline int q_atomic_set_int(volatile int *ptr, int newval)
 
63
{ return _InterlockedExchange(ptr, newval); }
 
64
 
 
65
inline void *q_atomic_set_ptr(volatile void *ptr, void *newval)
 
66
{
 
67
    return _InterlockedExchangePointer(reinterpret_cast<void * volatile *>(ptr), newval);
 
68
}
 
69
 
 
70
#else // !Q_CC_INTEL
 
71
 
 
72
#  if defined(Q_CC_GNU)
 
73
 
 
74
inline int q_atomic_test_and_set_int(volatile int *ptr, int expected, int newval)
 
75
{
 
76
    int ret;
 
77
    asm volatile("mov ar.ccv=%2\n"
 
78
                 ";;\n"
 
79
                 "cmpxchg4.acq %0=%1,%3,ar.ccv\n"
 
80
                 : "=r" (ret), "+m" (*ptr)
 
81
                 : "r" (expected), "r" (newval)
 
82
                 : "memory");
 
83
    return ret == expected;
 
84
}
 
85
 
 
86
inline int q_atomic_test_and_set_ptr(volatile void *ptr, void *expected, void *newval) {
 
87
    void *ret;
 
88
    asm volatile("mov ar.ccv=%2\n"
 
89
                 ";;\n"
 
90
                 "cmpxchg8.acq %0=%1,%3,ar.ccv\n"
 
91
                 : "=r" (ret), "+m" (*ptr)
 
92
                 : "r" (expected), "r" (newval)
 
93
                 : "memory");
 
94
    return ret == expected;
 
95
}
 
96
 
 
97
#  else // !Q_CC_GNU
 
98
 
 
99
extern "C" {
 
100
    Q_CORE_EXPORT int q_atomic_test_and_set_int(volatile int *ptr, int expected, int newval);
 
101
    Q_CORE_EXPORT int q_atomic_test_and_set_ptr(volatile void *ptr, void *expected, void *newval);
 
102
} // extern "C"
 
103
 
 
104
#  endif // Q_CC_GNU
 
105
 
 
106
inline int q_atomic_increment(volatile int * const ptr)
 
107
{
 
108
    register int expected;
 
109
    for (;;) {
 
110
        expected = *ptr;
 
111
        if (q_atomic_test_and_set_int(ptr, expected, expected + 1)) break;
 
112
    }
 
113
    return expected != -1;
 
114
}
 
115
 
 
116
inline int q_atomic_decrement(volatile int * const ptr)
 
117
{
 
118
    register int expected;
 
119
    for (;;) {
 
120
        expected = *ptr;
 
121
        if (q_atomic_test_and_set_int(ptr, expected, expected - 1)) break;
 
122
    }
 
123
    return expected != 1;
 
124
}
 
125
 
 
126
inline int q_atomic_set_int(volatile int *ptr, int newval)
 
127
{
 
128
    register int expected;
 
129
    for (;;) {
 
130
        expected = *ptr;
 
131
        if (q_atomic_test_and_set_int(ptr, expected, newval)) break;
 
132
    }
 
133
    return expected;
 
134
}
 
135
 
 
136
inline void *q_atomic_set_ptr(volatile void *ptr, void *newval)
 
137
{
 
138
    register void *expected;
 
139
    for (;;) {
 
140
        expected = *reinterpret_cast<void * volatile *>(ptr);
 
141
        if (q_atomic_test_and_set_ptr(ptr, expected, newval)) break;
 
142
    }
 
143
    return expected;
 
144
}
 
145
 
 
146
#endif // Q_CC_INTEL
 
147
 
 
148
#endif // IA64_QATOMIC_H