sdl-ios-xcode: src/atomic/linux/SDL

annotate src/atomic/linux/SDL_atomic.c @ 4532:dc4a3de60d3a

Logitech G15 on Ubuntu 10.04: code = 1, sym = 0xFF1B (Escape) scancode = 41 (Escape) code = 2, sym = 0x31 (1) scancode = 30 (1) code = 3, sym = 0x32 (2) scancode = 31 (2) code = 4, sym = 0x33 (3) scancode = 32 (3) code = 5, sym = 0x34 (4) scancode = 33 (4) code = 6, sym = 0x35 (5) scancode = 34 (5) code = 7, sym = 0x36 (6) scancode = 35 (6) code = 8, sym = 0x37 (7) scancode = 36 (7) code = 9, sym = 0x38 (8) scancode = 37 (8) code = 10, sym = 0x39 (9) scancode = 38 (9) code = 11, sym = 0x30 (0) scancode = 39 (0) code = 12, sym = 0x2D (minus) scancode = 45 (-) code = 13, sym = 0x3D (equal) scancode = 46 (=) code = 14, sym = 0xFF08 (BackSpace) scancode = 42 (Backspace) code = 15, sym = 0xFF09 (Tab) scancode = 43 (Tab) code = 16, sym = 0x71 (q) scancode = 20 (Q) code = 17, sym = 0x77 (w) scancode = 26 (W) code = 18, sym = 0x65 (e) scancode = 8 (E) code = 19, sym = 0x72 (r) scancode = 21 (R) code = 20, sym = 0x74 (t) scancode = 23 (T) code = 21, sym = 0x79 (y) scancode = 28 (Y) code = 22, sym = 0x75 (u) scancode = 24 (U) code = 23, sym = 0x69 (i) scancode = 12 (I) code = 24, sym = 0x6F (o) scancode = 18 (O) code = 25, sym = 0x70 (p) scancode = 19 (P) code = 26, sym = 0x5B (bracketleft) scancode = 47 ([) code = 27, sym = 0x5D (bracketright) scancode = 48 (]) code = 28, sym = 0xFF0D (Return) scancode = 40 (Return) code = 29, sym = 0xFFE3 (Control_L) scancode = 224 (Left Ctrl) code = 30, sym = 0x61 (a) scancode = 4 (A) code = 31, sym = 0x73 (s) scancode = 22 (S) code = 32, sym = 0x64 (d) scancode = 7 (D) code = 33, sym = 0x66 (f) scancode = 9 (F) code = 34, sym = 0x67 (g) scancode = 10 (G) code = 35, sym = 0x68 (h) scancode = 11 (H) code = 36, sym = 0x6A (j) scancode = 13 (J) code = 37, sym = 0x6B (k) scancode = 14 (K) code = 38, sym = 0x6C (l) scancode = 15 (L) code = 39, sym = 0x3B (semicolon) scancode = 51 (;) code = 40, sym = 0x27 (apostrophe) scancode = 52 (') code = 41, sym = 0x60 (grave) scancode = 53 (`) code = 42, sym = 0xFFE1 (Shift_L) scancode = 225 (Left Shift) code = 43, sym = 0x5C (backslash) scancode = 49 (\) code = 44, sym = 0x7A (z) scancode = 29 (Z) code = 45, sym = 0x78 (x) scancode = 27 (X) code = 46, sym = 0x63 (c) scancode = 6 (C) code = 47, sym = 0x76 (v) scancode = 25 (V) code = 48, sym = 0x62 (b) scancode = 5 (B) code = 49, sym = 0x6E (n) scancode = 17 (N) code = 50, sym = 0x6D (m) scancode = 16 (M) code = 51, sym = 0x2C (comma) scancode = 54 (,) code = 52, sym = 0x2E (period) scancode = 55 (.) code = 53, sym = 0x2F (slash) scancode = 56 (/) code = 54, sym = 0xFFE2 (Shift_R) scancode = 229 (Right Shift) code = 55, sym = 0xFFAA (KP_Multiply) scancode = 85 (Keypad *) code = 56, sym = 0xFFE9 (Alt_L) scancode = 226 (Left Alt) code = 57, sym = 0x20 (space) scancode = 44 (Space) code = 58, sym = 0xFFE5 (Caps_Lock) scancode = 57 (CapsLock) code = 59, sym = 0xFFBE (F1) scancode = 58 (F1) code = 60, sym = 0xFFBF (F2) scancode = 59 (F2) code = 61, sym = 0xFFC0 (F3) scancode = 60 (F3) code = 62, sym = 0xFFC1 (F4) scancode = 61 (F4) code = 63, sym = 0xFFC2 (F5) scancode = 62 (F5) code = 64, sym = 0xFFC3 (F6) scancode = 63 (F6) code = 65, sym = 0xFFC4 (F7) scancode = 64 (F7) code = 66, sym = 0xFFC5 (F8) scancode = 65 (F8) code = 67, sym = 0xFFC6 (F9) scancode = 66 (F9) code = 68, sym = 0xFFC7 (F10) scancode = 67 (F10) code = 69, sym = 0xFF7F (Num_Lock) scancode = 83 (Numlock) code = 70, sym = 0xFF14 (Scroll_Lock) scancode = 71 (ScrollLock) code = 71, sym = 0xFF95 (KP_Home) scancode = 95 (Keypad 7) code = 72, sym = 0xFF97 (KP_Up) scancode = 96 (Keypad 8) code = 73, sym = 0xFF9A (KP_Prior) scancode = 97 (Keypad 9) code = 74, sym = 0xFFAD (KP_Subtract) scancode = 86 (Keypad -) code = 75, sym = 0xFF96 (KP_Left) scancode = 92 (Keypad 4) code = 76, sym = 0xFF9D (KP_Begin) scancode = 93 (Keypad 5) code = 77, sym = 0xFF98 (KP_Right) scancode = 94 (Keypad 6) code = 78, sym = 0xFFAB (KP_Add) scancode = 87 (Keypad +) code = 79, sym = 0xFF9C (KP_End) scancode = 89 (Keypad 1) code = 80, sym = 0xFF99 (KP_Down) scancode = 90 (Keypad 2) code = 81, sym = 0xFF9B (KP_Next) scancode = 91 (Keypad 3) code = 82, sym = 0xFF9E (KP_Insert) scancode = 98 (Keypad 0) code = 83, sym = 0xFF9F (KP_Delete) scancode = 99 (Keypad .) code = 84, sym = 0xFE03 (ISO_Level3_Shift) scancode = 0 () code = 86, sym = 0x3C (less) scancode not found code = 87, sym = 0xFFC8 (F11) scancode = 68 (F11) code = 88, sym = 0xFFC9 (F12) scancode = 69 (F12) code = 90, sym = 0xFF26 (Katakana) scancode = 0 () code = 91, sym = 0xFF25 (Hiragana) scancode = 0 () code = 92, sym = 0xFF23 (Henkan_Mode) scancode = 0 () code = 93, sym = 0xFF27 (Hiragana_Katakana) scancode = 0 () code = 94, sym = 0xFF22 (Muhenkan) scancode = 0 () code = 96, sym = 0xFF8D (KP_Enter) scancode = 88 (Keypad Enter) code = 97, sym = 0xFFE4 (Control_R) scancode = 228 (Right Ctrl) code = 98, sym = 0xFFAF (KP_Divide) scancode = 84 (Keypad /) code = 99, sym = 0xFF61 (Print) scancode = 70 (PrintScreen) code = 100, sym = 0xFFEA (Alt_R) scancode = 230 (Right Alt) code = 101, sym = 0xFF0A (Linefeed) scancode = 0 () code = 102, sym = 0xFF50 (Home) scancode = 74 (Home) code = 103, sym = 0xFF52 (Up) scancode = 82 (Up) code = 104, sym = 0xFF55 (Prior) scancode = 75 (PageUp) code = 105, sym = 0xFF51 (Left) scancode = 80 (Left) code = 106, sym = 0xFF53 (Right) scancode = 79 (Right) code = 107, sym = 0xFF57 (End) scancode = 77 (End) code = 108, sym = 0xFF54 (Down) scancode = 81 (Down) code = 109, sym = 0xFF56 (Next) scancode = 78 (PageDown) code = 110, sym = 0xFF63 (Insert) scancode = 73 (Insert) code = 111, sym = 0xFFFF (Delete) scancode = 76 (Delete) code = 113, sym = 0x1008FF12 (XF86AudioMute) scancode = 0 () code = 114, sym = 0x1008FF11 (XF86AudioLowerVolume) scancode = 0 () code = 115, sym = 0x1008FF13 (XF86AudioRaiseVolume) scancode = 0 () code = 116, sym = 0x1008FF2A (XF86PowerOff) scancode = 0 () code = 117, sym = 0xFFBD (KP_Equal) scancode = 103 (Keypad =) code = 118, sym = 0xB1 (plusminus) scancode not found code = 119, sym = 0xFF13 (Pause) scancode = 72 (Pause) code = 120, sym = 0x1008FF4A (XF86LaunchA) scancode = 0 () code = 121, sym = 0xFFAE (KP_Decimal) scancode = 99 (Keypad .) code = 122, sym = 0xFF31 (Hangul) scancode = 0 () code = 123, sym = 0xFF34 (Hangul_Hanja) scancode = 0 () code = 125, sym = 0xFFEB (Super_L) scancode = 227 (Left GUI) code = 126, sym = 0xFFEC (Super_R) scancode = 231 (Right GUI) code = 127, sym = 0xFF67 (Menu) scancode = 118 (Menu) code = 128, sym = 0xFF69 (Cancel) scancode = 120 (Stop) code = 129, sym = 0xFF66 (Redo) scancode = 121 (Again) code = 130, sym = 0x1005FF70 (SunProps) scancode = 0 () code = 131, sym = 0xFF65 (Undo) scancode = 122 (Undo) code = 132, sym = 0x1005FF71 (SunFront) scancode = 0 () code = 133, sym = 0x1008FF57 (XF86Copy) scancode = 0 () code = 134, sym = 0x1005FF73 (SunOpen) scancode = 0 () code = 135, sym = 0x1008FF6D (XF86Paste) scancode = 0 () code = 136, sym = 0xFF68 (Find) scancode = 126 (Find) code = 137, sym = 0x1008FF58 (XF86Cut) scancode = 0 () code = 138, sym = 0xFF6A (Help) scancode = 117 (Help) code = 139, sym = 0x1008FF65 (XF86MenuKB) scancode = 0 () code = 140, sym = 0x1008FF1D (XF86Calculator) scancode = 0 () code = 142, sym = 0x1008FF2F (XF86Sleep) scancode = 0 () code = 143, sym = 0x1008FF2B (XF86WakeUp) scancode = 0 () code = 144, sym = 0x1008FF5D (XF86Explorer) scancode = 0 () code = 145, sym = 0x1008FF7B (XF86Send) scancode = 0 () code = 147, sym = 0x1008FF8A (XF86Xfer) scancode = 0 () code = 148, sym = 0x1008FF41 (XF86Launch1) scancode = 0 () code = 149, sym = 0x1008FF42 (XF86Launch2) scancode = 0 () code = 150, sym = 0x1008FF2E (XF86WWW) scancode = 0 () code = 151, sym = 0x1008FF5A (XF86DOS) scancode = 0 () code = 152, sym = 0x1008FF2D (XF86ScreenSaver) scancode = 0 () code = 154, sym = 0x1008FF74 (XF86RotateWindows) scancode = 0 () code = 155, sym = 0x1008FF19 (XF86Mail) scancode = 0 () code = 156, sym = 0x1008FF30 (XF86Favorites) scancode = 0 () code = 157, sym = 0x1008FF33 (XF86MyComputer) scancode = 0 () code = 158, sym = 0x1008FF26 (XF86Back) scancode = 0 () code = 159, sym = 0x1008FF27 (XF86Forward) scancode = 0 () code = 161, sym = 0x1008FF2C (XF86Eject) scancode = 0 () code = 162, sym = 0x1008FF2C (XF86Eject) scancode = 0 () code = 163, sym = 0x1008FF17 (XF86AudioNext) scancode = 0 () code = 164, sym = 0x1008FF14 (XF86AudioPlay) scancode = 0 () code = 165, sym = 0x1008FF16 (XF86AudioPrev) scancode = 0 () code = 166, sym = 0x1008FF15 (XF86AudioStop) scancode = 0 () code = 167, sym = 0x1008FF1C (XF86AudioRecord) scancode = 0 () code = 168, sym = 0x1008FF3E (XF86AudioRewind) scancode = 0 () code = 169, sym = 0x1008FF6E (XF86Phone) scancode = 0 () code = 171, sym = 0x1008FF81 (XF86Tools) scancode = 0 () code = 172, sym = 0x1008FF18 (XF86HomePage) scancode = 0 () code = 173, sym = 0x1008FF73 (XF86Reload) scancode = 0 () code = 174, sym = 0x1008FF56 (XF86Close) scancode = 0 () code = 177, sym = 0x1008FF78 (XF86ScrollUp) scancode = 0 () code = 178, sym = 0x1008FF79 (XF86ScrollDown) scancode = 0 () code = 179, sym = 0x28 (parenleft) scancode not found code = 180, sym = 0x29 (parenright) scancode not found code = 181, sym = 0x1008FF68 (XF86New) scancode = 0 () code = 182, sym = 0xFF66 (Redo) scancode = 121 (Again) code = 183, sym = 0x1008FF81 (XF86Tools) scancode = 0 () code = 184, sym = 0x1008FF45 (XF86Launch5) scancode = 0 () code = 185, sym = 0x1008FF65 (XF86MenuKB) scancode = 0 () code = 192, sym = 0x1008FFA9 (XF86TouchpadToggle) scancode = 0 () code = 195, sym = 0xFF7E (Mode_switch) scancode = 257 (ModeSwitch) code = 200, sym = 0x1008FF14 (XF86AudioPlay) scancode = 0 () code = 201, sym = 0x1008FF31 (XF86AudioPause) scancode = 0 () code = 202, sym = 0x1008FF43 (XF86Launch3) scancode = 0 () code = 203, sym = 0x1008FF44 (XF86Launch4) scancode = 0 () code = 204, sym = 0x1008FF4B (XF86LaunchB) scancode = 0 () code = 205, sym = 0x1008FFA7 (XF86Suspend) scancode = 0 () code = 206, sym = 0x1008FF56 (XF86Close) scancode = 0 () code = 207, sym = 0x1008FF14 (XF86AudioPlay) scancode = 0 () code = 208, sym = 0x1008FF97 (XF86AudioForward) scancode = 0 () code = 210, sym = 0xFF61 (Print) scancode = 70 (PrintScreen) code = 212, sym = 0x1008FF8F (XF86WebCam) scancode = 0 () code = 215, sym = 0x1008FF19 (XF86Mail) scancode = 0 () code = 217, sym = 0x1008FF1B (XF86Search) scancode = 0 () code = 219, sym = 0x1008FF3C (XF86Finance) scancode = 0 () code = 221, sym = 0x1008FF36 (XF86Shop) scancode = 0 () code = 223, sym = 0xFF69 (Cancel) scancode = 120 (Stop) code = 224, sym = 0x1008FF03 (XF86MonBrightnessDown) scancode = 0 () code = 225, sym = 0x1008FF02 (XF86MonBrightnessUp) scancode = 0 () code = 226, sym = 0x1008FF32 (XF86AudioMedia) scancode = 0 () code = 227, sym = 0x1008FF59 (XF86Display) scancode = 0 () code = 228, sym = 0x1008FF04 (XF86KbdLightOnOff) scancode = 0 () code = 229, sym = 0x1008FF06 (XF86KbdBrightnessDown) scancode = 0 () code = 230, sym = 0x1008FF05 (XF86KbdBrightnessUp) scancode = 0 () code = 231, sym = 0x1008FF7B (XF86Send) scancode = 0 () code = 232, sym = 0x1008FF72 (XF86Reply) scancode = 0 () code = 233, sym = 0x1008FF90 (XF86MailForward) scancode = 0 () code = 234, sym = 0x1008FF77 (XF86Save) scancode = 0 () code = 235, sym = 0x1008FF5B (XF86Documents) scancode = 0 () code = 236, sym = 0x1008FF93 (XF86Battery) scancode = 0 () code = 237, sym = 0x1008FF94 (XF86Bluetooth) scancode = 0 () code = 238, sym = 0x1008FF95 (XF86WLAN) scancode = 0 ()

author	Sam Lantinga <slouken@libsdl.org>
date	Sun, 18 Jul 2010 00:40:17 -0700
parents	f7b03b6838cb
children

rev	line source
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	1 /*
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	2 SDL - Simple DirectMedia Layer
3697 f7b03b6838cb Fixed bug #926 Sam Lantinga <slouken@libsdl.org> parents: 3308 diff changeset	3 Copyright (C) 1997-2010 Sam Lantinga
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	4
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	5 This library is free software; you can redistribute it and/or
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	6 modify it under the terms of the GNU Lesser General Public
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	7 License as published by the Free Software Foundation; either
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	8 version 2.1 of the License, or (at your option) any later version.
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	9
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	10 This library is distributed in the hope that it will be useful,
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	11 but WITHOUT ANY WARRANTY; without even the implied warranty of
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	13 Lesser General Public License for more details.
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	14
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	15 You should have received a copy of the GNU Lesser General Public
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	16 License along with this library; if not, write to the Free Software
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	17 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	18
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	19 Sam Lantinga
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	20 slouken@libsdl.org
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	21
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	22 Contributed by Bob Pendleton, bob@pendleton.com
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	23 */
3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	24
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	25 #include "SDL_stdinc.h"
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	26 #include "SDL_atomic.h"
3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	27
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	28 #include "SDL_error.h"
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	29
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	30 /*
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	31 This file provides 32, and 64 bit atomic operations. If the
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	32 operations are provided by the native hardware and operating system
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	33 they are used. If they are not then the operations are emulated
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	34 using the SDL spin lock operations. If spin lock can not be
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	35 implemented then these functions must fail.
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	36 */
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	37
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	38 /*
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	39 LINUX/GCC VERSION.
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	40
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	41 This version of the code assumes support of the atomic builtins as
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	42 documented at gcc.gnu.org/onlinedocs/gcc/Atomic-Builtins.html This
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	43 code should work on any modern x86 or other processor supported by
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	44 GCC.
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	45
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	46 Some processors will only support some of these operations so
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	47 #ifdefs will have to be added as incompatibilities are discovered
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	48 */
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	49
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	50 /*
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	51 Native spinlock routines.
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	52 */
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	53
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	54 void
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	55 SDL_AtomicLock(SDL_SpinLock *lock)
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	56 {
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	57 while (0 != __sync_lock_test_and_set(lock, 1))
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	58 {
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	59 }
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	60 }
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	61
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	62 void
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	63 SDL_AtomicUnlock(SDL_SpinLock *lock)
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	64 {
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	65 __sync_lock_test_and_set(lock, 0);
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	66 }
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	67
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	68 /*
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	69 Note that platform specific versions can be built from this version
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	70 by changing the #undefs to #defines and adding platform specific
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	71 code.
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	72 */
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	73
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	74 #define nativeTestThenSet32
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	75 #define nativeClear32
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	76 #define nativeFetchThenIncrement32
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	77 #define nativeFetchThenDecrement32
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	78 #define nativeFetchThenAdd32
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	79 #define nativeFetchThenSubtract32
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	80 #define nativeIncrementThenFetch32
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	81 #define nativeDecrementThenFetch32
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	82 #define nativeAddThenFetch32
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	83 #define nativeSubtractThenFetch32
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	84
3296 6fe620d7ce92 Should now compile on 32 bit linux and 64 bit linux Bob Pendleton <bob@pendleton.com> parents: 3261 diff changeset	85 #ifdef SDL_HAS_64BIT_TYPE
6fe620d7ce92 Should now compile on 32 bit linux and 64 bit linux Bob Pendleton <bob@pendleton.com> parents: 3261 diff changeset	86 #ifdef __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8
6fe620d7ce92 Should now compile on 32 bit linux and 64 bit linux Bob Pendleton <bob@pendleton.com> parents: 3261 diff changeset	87 #define nativeTestThenSet64
6fe620d7ce92 Should now compile on 32 bit linux and 64 bit linux Bob Pendleton <bob@pendleton.com> parents: 3261 diff changeset	88 #define nativeClear64
6fe620d7ce92 Should now compile on 32 bit linux and 64 bit linux Bob Pendleton <bob@pendleton.com> parents: 3261 diff changeset	89 #define nativeFetchThenIncrement64
6fe620d7ce92 Should now compile on 32 bit linux and 64 bit linux Bob Pendleton <bob@pendleton.com> parents: 3261 diff changeset	90 #define nativeFetchThenDecrement64
6fe620d7ce92 Should now compile on 32 bit linux and 64 bit linux Bob Pendleton <bob@pendleton.com> parents: 3261 diff changeset	91 #define nativeFetchThenAdd64
6fe620d7ce92 Should now compile on 32 bit linux and 64 bit linux Bob Pendleton <bob@pendleton.com> parents: 3261 diff changeset	92 #define nativeFetchThenSubtract64
6fe620d7ce92 Should now compile on 32 bit linux and 64 bit linux Bob Pendleton <bob@pendleton.com> parents: 3261 diff changeset	93 #define nativeIncrementThenFetch64
6fe620d7ce92 Should now compile on 32 bit linux and 64 bit linux Bob Pendleton <bob@pendleton.com> parents: 3261 diff changeset	94 #define nativeDecrementThenFetch64
6fe620d7ce92 Should now compile on 32 bit linux and 64 bit linux Bob Pendleton <bob@pendleton.com> parents: 3261 diff changeset	95 #define nativeAddThenFetch64
6fe620d7ce92 Should now compile on 32 bit linux and 64 bit linux Bob Pendleton <bob@pendleton.com> parents: 3261 diff changeset	96 #define nativeSubtractThenFetch64
3297 d430982cd5cc oops Bob Pendleton <bob@pendleton.com> parents: 3296 diff changeset	97 #else
3296 6fe620d7ce92 Should now compile on 32 bit linux and 64 bit linux Bob Pendleton <bob@pendleton.com> parents: 3261 diff changeset	98 #undef nativeTestThenSet64
6fe620d7ce92 Should now compile on 32 bit linux and 64 bit linux Bob Pendleton <bob@pendleton.com> parents: 3261 diff changeset	99 #undef nativeClear64
6fe620d7ce92 Should now compile on 32 bit linux and 64 bit linux Bob Pendleton <bob@pendleton.com> parents: 3261 diff changeset	100 #undef nativeFetchThenIncrement64
6fe620d7ce92 Should now compile on 32 bit linux and 64 bit linux Bob Pendleton <bob@pendleton.com> parents: 3261 diff changeset	101 #undef nativeFetchThenDecrement64
6fe620d7ce92 Should now compile on 32 bit linux and 64 bit linux Bob Pendleton <bob@pendleton.com> parents: 3261 diff changeset	102 #undef nativeFetchThenAdd64
6fe620d7ce92 Should now compile on 32 bit linux and 64 bit linux Bob Pendleton <bob@pendleton.com> parents: 3261 diff changeset	103 #undef nativeFetchThenSubtract64
6fe620d7ce92 Should now compile on 32 bit linux and 64 bit linux Bob Pendleton <bob@pendleton.com> parents: 3261 diff changeset	104 #undef nativeIncrementThenFetch64
6fe620d7ce92 Should now compile on 32 bit linux and 64 bit linux Bob Pendleton <bob@pendleton.com> parents: 3261 diff changeset	105 #undef nativeDecrementThenFetch64
6fe620d7ce92 Should now compile on 32 bit linux and 64 bit linux Bob Pendleton <bob@pendleton.com> parents: 3261 diff changeset	106 #undef nativeAddThenFetch64
6fe620d7ce92 Should now compile on 32 bit linux and 64 bit linux Bob Pendleton <bob@pendleton.com> parents: 3261 diff changeset	107 #undef nativeSubtractThenFetch64
6fe620d7ce92 Should now compile on 32 bit linux and 64 bit linux Bob Pendleton <bob@pendleton.com> parents: 3261 diff changeset	108 #endif /* __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8 */
6fe620d7ce92 Should now compile on 32 bit linux and 64 bit linux Bob Pendleton <bob@pendleton.com> parents: 3261 diff changeset	109 #endif /* SDL_HAS_64BIT_TYPE */
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	110
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	111 /*
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	112 If any of the operations are not provided then we must emulate some
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	113 of them. That means we need a nice implementation of spin locks
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	114 that avoids the "one big lock" problem. We use a vector of spin
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	115 locks and pick which one to use based on the address of the operand
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	116 of the function.
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	117
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	118 To generate the index of the lock we first shift by 3 bits to get
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	119 rid on the zero bits that result from 32 and 64 bit allignment of
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	120 data. We then mask off all but 5 bits and use those 5 bits as an
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	121 index into the table.
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	122
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	123 Picking the lock this way insures that accesses to the same data at
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	124 the same time will go to the same lock. OTOH, accesses to different
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	125 data have only a 1/32 chance of hitting the same lock. That should
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	126 pretty much eliminate the chances of several atomic operations on
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	127 different data from waiting on the same "big lock". If it isn't
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	128 then the table of locks can be expanded to a new size so long as
3308 0e000afe3dc0 fixed a spelling error in the documentation. Bob Pendleton <bob@pendleton.com> parents: 3297 diff changeset	129 the new size is a power of two.
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	130 */
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	131
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	132 static SDL_SpinLock locks[32] = {
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	133 0, 0, 0, 0, 0, 0, 0, 0,
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	134 0, 0, 0, 0, 0, 0, 0, 0,
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	135 0, 0, 0, 0, 0, 0, 0, 0,
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	136 0, 0, 0, 0, 0, 0, 0, 0,
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	137 };
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	138
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	139 static __inline__ void
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	140 privateWaitLock(volatile void *ptr)
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	141 {
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	142 #if SIZEOF_VOIDP == 4
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	143 Uint32 index = ((((Uint32)ptr) >> 3) & 0x1f);
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	144 #elif SIZEOF_VOIDP == 8
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	145 Uint64 index = ((((Uint64)ptr) >> 3) & 0x1f);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	146 #endif
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	147
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	148 SDL_AtomicLock(&locks[index]);
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	149 }
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	150
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	151 static __inline__ void
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	152 privateUnlock(volatile void *ptr)
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	153 {
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	154 #if SIZEOF_VOIDP == 4
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	155 Uint32 index = ((((Uint32)ptr) >> 3) & 0x1f);
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	156 #elif SIZEOF_VOIDP == 8
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	157 Uint64 index = ((((Uint64)ptr) >> 3) & 0x1f);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	158 #endif
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	159
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	160 SDL_AtomicUnlock(&locks[index]);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	161 }
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	162
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	163 /* 32 bit atomic operations */
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	164
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	165 SDL_bool
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	166 SDL_AtomicTestThenSet32(volatile Uint32 * ptr)
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	167 {
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	168 #ifdef nativeTestThenSet32
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	169 return 0 == __sync_lock_test_and_set(ptr, 1);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	170 #else
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	171 SDL_bool result = SDL_FALSE;
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	172
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	173 privateWaitLock(ptr);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	174 result = (*ptr == 0);
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	175 if (result)
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	176 {
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	177 *ptr = 1;
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	178 }
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	179 privateUnlock(ptr);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	180
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	181 return result;
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	182 #endif
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	183 }
3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	184
3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	185 void
3216 48a80f2a7ff2 volitile... duh, yeah the variable need to be labeled volitile Bob Pendleton <bob@pendleton.com> parents: 3212 diff changeset	186 SDL_AtomicClear32(volatile Uint32 * ptr)
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	187 {
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	188 #ifdef nativeClear32
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	189 __sync_lock_test_and_set(ptr, 0);
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	190 return;
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	191 #else
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	192 privateWaitLock(ptr);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	193 *ptr = 0;
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	194 privateUnlock(ptr);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	195
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	196 return;
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	197 #endif
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	198 }
3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	199
3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	200 Uint32
3216 48a80f2a7ff2 volitile... duh, yeah the variable need to be labeled volitile Bob Pendleton <bob@pendleton.com> parents: 3212 diff changeset	201 SDL_AtomicFetchThenIncrement32(volatile Uint32 * ptr)
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	202 {
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	203 #ifdef nativeFetchThenIncrement32
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	204 return __sync_fetch_and_add(ptr, 1);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	205 #else
3212 759032c318d8 This is a cosmetic fix, I found a stupid typo Bob Pendleton <bob@pendleton.com> parents: 3202 diff changeset	206 Uint32 tmp = 0;
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	207
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	208 privateWaitLock(ptr);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	209 tmp = *ptr;
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	210 (*ptr)+= 1;
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	211 privateUnlock(ptr);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	212
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	213 return tmp;
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	214 #endif
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	215 }
3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	216
3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	217 Uint32
3216 48a80f2a7ff2 volitile... duh, yeah the variable need to be labeled volitile Bob Pendleton <bob@pendleton.com> parents: 3212 diff changeset	218 SDL_AtomicFetchThenDecrement32(volatile Uint32 * ptr)
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	219 {
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	220 #ifdef nativeFetchThenDecrement32
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	221 return __sync_fetch_and_sub(ptr, 1);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	222 #else
3212 759032c318d8 This is a cosmetic fix, I found a stupid typo Bob Pendleton <bob@pendleton.com> parents: 3202 diff changeset	223 Uint32 tmp = 0;
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	224
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	225 privateWaitLock(ptr);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	226 tmp = *ptr;
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	227 (*ptr) -= 1;
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	228 privateUnlock(ptr);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	229
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	230 return tmp;
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	231 #endif
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	232 }
3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	233
3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	234 Uint32
3216 48a80f2a7ff2 volitile... duh, yeah the variable need to be labeled volitile Bob Pendleton <bob@pendleton.com> parents: 3212 diff changeset	235 SDL_AtomicFetchThenAdd32(volatile Uint32 * ptr, Uint32 value)
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	236 {
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	237 #ifdef nativeFetchThenAdd32
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	238 return __sync_fetch_and_add(ptr, value);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	239 #else
3212 759032c318d8 This is a cosmetic fix, I found a stupid typo Bob Pendleton <bob@pendleton.com> parents: 3202 diff changeset	240 Uint32 tmp = 0;
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	241
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	242 privateWaitLock(ptr);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	243 tmp = *ptr;
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	244 (*ptr)+= value;
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	245 privateUnlock(ptr);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	246
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	247 return tmp;
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	248 #endif
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	249 }
3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	250
3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	251 Uint32
3216 48a80f2a7ff2 volitile... duh, yeah the variable need to be labeled volitile Bob Pendleton <bob@pendleton.com> parents: 3212 diff changeset	252 SDL_AtomicFetchThenSubtract32(volatile Uint32 * ptr, Uint32 value)
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	253 {
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	254 #ifdef nativeFetchThenSubtract32
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	255 return __sync_fetch_and_sub(ptr, value);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	256 #else
3212 759032c318d8 This is a cosmetic fix, I found a stupid typo Bob Pendleton <bob@pendleton.com> parents: 3202 diff changeset	257 Uint32 tmp = 0;
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	258
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	259 privateWaitLock(ptr);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	260 tmp = *ptr;
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	261 (*ptr)-= value;
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	262 privateUnlock(ptr);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	263
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	264 return tmp;
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	265 #endif
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	266 }
3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	267
3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	268 Uint32
3216 48a80f2a7ff2 volitile... duh, yeah the variable need to be labeled volitile Bob Pendleton <bob@pendleton.com> parents: 3212 diff changeset	269 SDL_AtomicIncrementThenFetch32(volatile Uint32 * ptr)
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	270 {
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	271 #ifdef nativeIncrementThenFetch32
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	272 return __sync_add_and_fetch(ptr, 1);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	273 #else
3212 759032c318d8 This is a cosmetic fix, I found a stupid typo Bob Pendleton <bob@pendleton.com> parents: 3202 diff changeset	274 Uint32 tmp = 0;
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	275
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	276 privateWaitLock(ptr);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	277 (*ptr)+= 1;
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	278 tmp = *ptr;
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	279 privateUnlock(ptr);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	280
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	281 return tmp;
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	282 #endif
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	283 }
3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	284
3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	285 Uint32
3216 48a80f2a7ff2 volitile... duh, yeah the variable need to be labeled volitile Bob Pendleton <bob@pendleton.com> parents: 3212 diff changeset	286 SDL_AtomicDecrementThenFetch32(volatile Uint32 * ptr)
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	287 {
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	288 #ifdef nativeDecrementThenFetch32
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	289 return __sync_sub_and_fetch(ptr, 1);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	290 #else
3212 759032c318d8 This is a cosmetic fix, I found a stupid typo Bob Pendleton <bob@pendleton.com> parents: 3202 diff changeset	291 Uint32 tmp = 0;
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	292
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	293 privateWaitLock(ptr);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	294 (*ptr)-= 1;
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	295 tmp = *ptr;
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	296 privateUnlock(ptr);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	297
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	298 return tmp;
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	299 #endif
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	300 }
3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	301
3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	302 Uint32
3216 48a80f2a7ff2 volitile... duh, yeah the variable need to be labeled volitile Bob Pendleton <bob@pendleton.com> parents: 3212 diff changeset	303 SDL_AtomicAddThenFetch32(volatile Uint32 * ptr, Uint32 value)
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	304 {
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	305 #ifdef nativeAddThenFetch32
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	306 return __sync_add_and_fetch(ptr, value);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	307 #else
3212 759032c318d8 This is a cosmetic fix, I found a stupid typo Bob Pendleton <bob@pendleton.com> parents: 3202 diff changeset	308 Uint32 tmp = 0;
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	309
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	310 privateWaitLock(ptr);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	311 (*ptr)+= value;
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	312 tmp = *ptr;
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	313 privateUnlock(ptr);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	314
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	315 return tmp;
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	316 #endif
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	317 }
3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	318
3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	319 Uint32
3216 48a80f2a7ff2 volitile... duh, yeah the variable need to be labeled volitile Bob Pendleton <bob@pendleton.com> parents: 3212 diff changeset	320 SDL_AtomicSubtractThenFetch32(volatile Uint32 * ptr, Uint32 value)
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	321 {
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	322 #ifdef nativeSubtractThenFetch32
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	323 return __sync_sub_and_fetch(ptr, value);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	324 #else
3212 759032c318d8 This is a cosmetic fix, I found a stupid typo Bob Pendleton <bob@pendleton.com> parents: 3202 diff changeset	325 Uint32 tmp = 0;
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	326
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	327 privateWaitLock(ptr);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	328 (*ptr)-= value;
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	329 tmp = *ptr;
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	330 privateUnlock(ptr);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	331
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	332 return tmp;
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	333 #endif
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	334 }
3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	335
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	336 /* 64 bit atomic operations */
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	337 #ifdef SDL_HAS_64BIT_TYPE
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	338
3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	339 SDL_bool
3216 48a80f2a7ff2 volitile... duh, yeah the variable need to be labeled volitile Bob Pendleton <bob@pendleton.com> parents: 3212 diff changeset	340 SDL_AtomicTestThenSet64(volatile Uint64 * ptr)
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	341 {
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	342 #ifdef nativeTestThenSet64
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	343 return 0 == __sync_lock_test_and_set(ptr, 1);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	344 #else
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	345 SDL_bool result = SDL_FALSE;
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	346
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	347 privateWaitLock(ptr);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	348 result = (*ptr == 0);
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	349 if (result)
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	350 {
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	351 *ptr = 1;
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	352 }
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	353 privateUnlock(ptr);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	354
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	355 return result;
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	356 #endif
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	357 }
3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	358
3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	359 void
3216 48a80f2a7ff2 volitile... duh, yeah the variable need to be labeled volitile Bob Pendleton <bob@pendleton.com> parents: 3212 diff changeset	360 SDL_AtomicClear64(volatile Uint64 * ptr)
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	361 {
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	362 #ifdef nativeClear64
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	363 __sync_lock_test_and_set(ptr, 0);
72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	364 return;
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	365 #else
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	366 privateWaitLock(ptr);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	367 *ptr = 0;
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	368 privateUnlock(ptr);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	369
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	370 return;
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	371 #endif
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	372 }
3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	373
3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	374 Uint64
3216 48a80f2a7ff2 volitile... duh, yeah the variable need to be labeled volitile Bob Pendleton <bob@pendleton.com> parents: 3212 diff changeset	375 SDL_AtomicFetchThenIncrement64(volatile Uint64 * ptr)
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	376 {
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	377 #ifdef nativeFetchThenIncrement64
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	378 return __sync_fetch_and_add(ptr, 1);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	379 #else
3212 759032c318d8 This is a cosmetic fix, I found a stupid typo Bob Pendleton <bob@pendleton.com> parents: 3202 diff changeset	380 Uint64 tmp = 0;
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	381
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	382 privateWaitLock(ptr);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	383 tmp = *ptr;
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	384 (*ptr)+= 1;
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	385 privateUnlock(ptr);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	386
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	387 return tmp;
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	388 #endif
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	389 }
3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	390
3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	391 Uint64
3216 48a80f2a7ff2 volitile... duh, yeah the variable need to be labeled volitile Bob Pendleton <bob@pendleton.com> parents: 3212 diff changeset	392 SDL_AtomicFetchThenDecrement64(volatile Uint64 * ptr)
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	393 {
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	394 #ifdef nativeFetchThenDecrement64
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	395 return __sync_fetch_and_sub(ptr, 1);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	396 #else
3212 759032c318d8 This is a cosmetic fix, I found a stupid typo Bob Pendleton <bob@pendleton.com> parents: 3202 diff changeset	397 Uint64 tmp = 0;
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	398
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	399 privateWaitLock(ptr);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	400 tmp = *ptr;
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	401 (*ptr) -= 1;
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	402 privateUnlock(ptr);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	403
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	404 return tmp;
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	405 #endif
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	406 }
3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	407
3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	408 Uint64
3216 48a80f2a7ff2 volitile... duh, yeah the variable need to be labeled volitile Bob Pendleton <bob@pendleton.com> parents: 3212 diff changeset	409 SDL_AtomicFetchThenAdd64(volatile Uint64 * ptr, Uint64 value)
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	410 {
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	411 #ifdef nativeFetchThenAdd64
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	412 return __sync_fetch_and_add(ptr, value);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	413 #else
3212 759032c318d8 This is a cosmetic fix, I found a stupid typo Bob Pendleton <bob@pendleton.com> parents: 3202 diff changeset	414 Uint64 tmp = 0;
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	415
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	416 privateWaitLock(ptr);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	417 tmp = *ptr;
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	418 (*ptr)+= value;
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	419 privateUnlock(ptr);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	420
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	421 return tmp;
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	422 #endif
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	423 }
3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	424
3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	425 Uint64
3216 48a80f2a7ff2 volitile... duh, yeah the variable need to be labeled volitile Bob Pendleton <bob@pendleton.com> parents: 3212 diff changeset	426 SDL_AtomicFetchThenSubtract64(volatile Uint64 * ptr, Uint64 value)
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	427 {
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	428 #ifdef nativeFetchThenSubtract64
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	429 return __sync_fetch_and_sub(ptr, value);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	430 #else
3212 759032c318d8 This is a cosmetic fix, I found a stupid typo Bob Pendleton <bob@pendleton.com> parents: 3202 diff changeset	431 Uint64 tmp = 0;
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	432
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	433 privateWaitLock(ptr);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	434 tmp = *ptr;
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	435 (*ptr)-= value;
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	436 privateUnlock(ptr);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	437
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	438 return tmp;
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	439 #endif
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	440 }
3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	441
3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	442 Uint64
3216 48a80f2a7ff2 volitile... duh, yeah the variable need to be labeled volitile Bob Pendleton <bob@pendleton.com> parents: 3212 diff changeset	443 SDL_AtomicIncrementThenFetch64(volatile Uint64 * ptr)
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	444 {
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	445 #ifdef nativeIncrementThenFetch64
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	446 return __sync_add_and_fetch(ptr, 1);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	447 #else
3212 759032c318d8 This is a cosmetic fix, I found a stupid typo Bob Pendleton <bob@pendleton.com> parents: 3202 diff changeset	448 Uint64 tmp = 0;
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	449
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	450 privateWaitLock(ptr);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	451 (*ptr)+= 1;
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	452 tmp = *ptr;
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	453 privateUnlock(ptr);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	454
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	455 return tmp;
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	456 #endif
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	457 }
3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	458
3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	459 Uint64
3216 48a80f2a7ff2 volitile... duh, yeah the variable need to be labeled volitile Bob Pendleton <bob@pendleton.com> parents: 3212 diff changeset	460 SDL_AtomicDecrementThenFetch64(volatile Uint64 * ptr)
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	461 {
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	462 #ifdef nativeDecrementThenFetch64
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	463 return __sync_sub_and_fetch(ptr, 1);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	464 #else
3212 759032c318d8 This is a cosmetic fix, I found a stupid typo Bob Pendleton <bob@pendleton.com> parents: 3202 diff changeset	465 Uint64 tmp = 0;
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	466
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	467 privateWaitLock(ptr);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	468 (*ptr)-= 1;
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	469 tmp = *ptr;
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	470 privateUnlock(ptr);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	471
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	472 return tmp;
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	473 #endif
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	474 }
3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	475
3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	476 Uint64
3216 48a80f2a7ff2 volitile... duh, yeah the variable need to be labeled volitile Bob Pendleton <bob@pendleton.com> parents: 3212 diff changeset	477 SDL_AtomicAddThenFetch64(volatile Uint64 * ptr, Uint64 value)
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	478 {
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	479 #ifdef nativeAddThenFetch64
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	480 return __sync_add_and_fetch(ptr, value);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	481 #else
3212 759032c318d8 This is a cosmetic fix, I found a stupid typo Bob Pendleton <bob@pendleton.com> parents: 3202 diff changeset	482 Uint64 tmp = 0;
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	483
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	484 privateWaitLock(ptr);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	485 (*ptr)+= value;
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	486 tmp = *ptr;
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	487 privateUnlock(ptr);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	488
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	489 return tmp;
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	490 #endif
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	491 }
3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	492
3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	493 Uint64
3216 48a80f2a7ff2 volitile... duh, yeah the variable need to be labeled volitile Bob Pendleton <bob@pendleton.com> parents: 3212 diff changeset	494 SDL_AtomicSubtractThenFetch64(volatile Uint64 * ptr, Uint64 value)
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	495 {
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	496 #ifdef nativeSubtractThenFetch64
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	497 return __sync_sub_and_fetch(ptr, value);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	498 #else
3212 759032c318d8 This is a cosmetic fix, I found a stupid typo Bob Pendleton <bob@pendleton.com> parents: 3202 diff changeset	499 Uint64 tmp = 0;
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	500
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	501 privateWaitLock(ptr);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	502 (*ptr)-= value;
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	503 tmp = *ptr;
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	504 privateUnlock(ptr);
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	505
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	506 return tmp;
3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	507 #endif
3199 3e1bf2b8bd81 This check in updates SDL_atomic.h to reflect the new set of atomic operations in 32 and 64 bit form. Bob Pendleton <bob@pendleton.com> parents: diff changeset	508 }
3202 3aa519a5c676 I've made so many changes I don't dare continue until I check the current stuff in. Bob Pendleton <bob@pendleton.com> parents: 3201 diff changeset	509
3261 72b542f34739 The new, cleaner, version of the atomic operations. The dummy code is what you should start working with to port atomic ops. Bob Pendleton <bob@pendleton.com> parents: 3216 diff changeset	510 #endif /* SDL_HAS_64BIT_TYPE */

Mercurial > sdl-ios-xcode

annotate src/atomic/linux/SDL_atomic.c @ 4532:dc4a3de60d3a