Mercurial > sdl-ios-xcode
view src/atomic/qnx/SDL_atomic.c @ 3487:24d13328c44a
Eric Wing to Sam, hfutrell
This one is quite puzzling. I found a partial workaround, but I don't fully understand the reasons yet.
First, the console is complaining about not finding a nib for MainWindow.
I tried removing the entry for this in the info.plist, and the message went away, but it didn't really change anything.
Second, I stepped through this with the debugger and broke up some lines. It seems that the basic act of calling
view = [SDL_uikitopenglview alloc];
or even
view = [SDL_uikitview alloc]
will crash the program. The debugger messages plus the stack trace make me think it's not finding the SDL_uikitview classes for some reason. But I don't understand why this would be.
view = [UIView alloc] will not crash the program.
For kicks, I added a new definition of a class called SDL_object which subclasses NSObject in the same files as SDL_uikitopenglview and then call
view = [SDL_object alloc];
This does not crash the program.
So, then I modified SDL_object to subclass UIView. No crash.
Next, I made SDL_object subclass UIView<UITextFieldDelegate> . This crashes.
So it is the act of conforming to the UITextFieldDelegate protocol that is crashing things.
I don't understand why it would crash on alloc though. I'm guessing either a delegate needs to be set somewhere or one of the required methods needs to be implemented. But in the former case, I would not expect a crash, but a silent message to nil and something else doesn't work. And in the latter case, I would expect a compiler warning and an exception thrown instead of a crash.
Anyway, my temporary workaround is to change the interface declaration for SDL_uikitview to look like:
#if SDL_IPHONE_KEYBOARD
@interface SDL_uikitview : UIView<UITextFieldDelegate> {
#else
@interface SDL_uikitview : UIView {
#endif
And then disable the keyboard support in the SDL_config_iphoneos.h file.
/* enable iPhone keyboard support */
#define SDL_IPHONE_KEYBOARD 0
-Eric
On Nov 23, 2009, at 1:43 AM, Sam Lantinga wrote:
> I ran into a blocking startup crash with the Happy demo on iPhone OS 3.1.2 on my new iPhone:
>
> #0 0x323fea14 in _class_isInitialized
> #1 0x323fea68 in _class_initialize
> #2 0x32403e92 in prepareForMethodLookup
> #3 0x32401244 in lookUpMethod
> #4 0x323fea10 in _class_lookupMethodAndLoadCache
> #5 0x323fe746 in objc_msgSend_uncached
> #6 0x323feb26 in _class_initialize
> #7 0x323fea58 in _class_initialize
> #8 0x32403e92 in prepareForMethodLookup
> #9 0x32401244 in lookUpMethod
> #10 0x323fea10 in _class_lookupMethodAndLoadCache
> #11 0x323fe746 in objc_msgSend_uncached
> #12 0x000554dc in UIKit_GL_CreateContext at SDL_uikitopengles.m:103
> #13 0x0004f89e in SDL_GL_CreateContext at SDL_video.c:3155
> #14 0x000579e8 in GLES_CreateRenderer at SDL_renderer_gles.c:282
> #15 0x0004d7b8 in SDL_CreateRenderer at SDL_video.c:1509
> #16 0x00002bc2 in SDL_main at happy.c:156
> #17 0x000571b2 in -[SDLUIKitDelegate postFinishLaunch] at
> SDL_uikitappdelegate.m:77
> #18 0x313f9ef2 in __NSFireDelayedPerform
> #19 0x32567bb2 in CFRunLoopRunSpecific
> #20 0x3256735c in CFRunLoopRunInMode
> #21 0x32912cbe in GSEventRunModal
> #22 0x32912d6a in GSEventRun
> #23 0x32b6276e in -[UIApplication _run]
> #24 0x32b61472 in UIApplicationMain
> #25 0x00057088 in main at SDL_uikitappdelegate.m:50
>
> Any ideas?
>
> See ya!
> --
> -Sam Lantinga, Founder and President, Galaxy Gameworks LLC
author | Sam Lantinga <slouken@libsdl.org> |
---|---|
date | Tue, 24 Nov 2009 08:12:32 +0000 |
parents | 70bfe3337f8a |
children | f7b03b6838cb |
line wrap: on
line source
/* SDL - Simple DirectMedia Layer Copyright (C) 1997-2009 Sam Lantinga This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with this library; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA Sam Lantinga slouken@libsdl.org QNX native atomic operations Copyright (C) 2009 Mike Gorchak (mike@malva.ua, lestat@i.com.ua) */ #include "SDL_stdinc.h" #include "SDL_atomic.h" #include "SDL_error.h" #include <atomic.h> /* SMP Exchange for PPC platform */ #ifdef __PPC__ #include <ppc/smpxchg.h> #endif /* __PPC__ */ /* SMP Exchange for ARM platform */ #ifdef __ARM__ #include <arm/smpxchg.h> #endif /* __ARM__ */ /* SMP Exchange for MIPS platform */ #if defined (__MIPSEB__) || defined(__MIPSEL__) #include <mips/smpxchg.h> #endif /* __MIPSEB__ || __MIPSEL__ */ /* SMP Exchange for SH platform */ #ifdef __SH__ #include <sh/smpxchg.h> #endif /* __SH__ */ /* SMP Exchange for x86 platform */ #ifdef __X86__ #include <x86/smpxchg.h> #endif /* __X86__ */ /* This file provides 32, and 64 bit atomic operations. If the operations are provided by the native hardware and operating system they are used. If they are not then the operations are emulated using the SDL spin lock operations. If spin lock can not be implemented then these functions must fail. */ void SDL_AtomicLock(SDL_SpinLock *lock) { unsigned volatile* l = (unsigned volatile*)lock; Uint32 oldval = 0; Uint32 newval = 1; oldval = _smp_xchg(l, newval); while(1 == oldval) { oldval = _smp_xchg(l, newval); } } void SDL_AtomicUnlock(SDL_SpinLock *lock) { unsigned volatile* l = (unsigned volatile*)lock; Uint32 newval = 0; _smp_xchg(l, newval); } /* QNX 6.4.1 supports only 32 bit atomic access */ #undef nativeTestThenSet32 #define nativeClear32 #define nativeFetchThenIncrement32 #define nativeFetchThenDecrement32 #define nativeFetchThenAdd32 #define nativeFetchThenSubtract32 #define nativeIncrementThenFetch32 #define nativeDecrementThenFetch32 #define nativeAddThenFetch32 #define nativeSubtractThenFetch32 #undef nativeTestThenSet64 #undef nativeClear64 #undef nativeFetchThenIncrement64 #undef nativeFetchThenDecrement64 #undef nativeFetchThenAdd64 #undef nativeFetchThenSubtract64 #undef nativeIncrementThenFetch64 #undef nativeDecrementThenFetch64 #undef nativeAddThenFetch64 #undef nativeSubtractThenFetch64 /* If any of the operations are not provided then we must emulate some of them. That means we need a nice implementation of spin locks that avoids the "one big lock" problem. We use a vector of spin locks and pick which one to use based on the address of the operand of the function. To generate the index of the lock we first shift by 3 bits to get rid on the zero bits that result from 32 and 64 bit allignment of data. We then mask off all but 5 bits and use those 5 bits as an index into the table. Picking the lock this way insures that accesses to the same data at the same time will go to the same lock. OTOH, accesses to different data have only a 1/32 chance of hitting the same lock. That should pretty much eliminate the chances of several atomic operations on different data from waiting on the same "big lock". If it isn't then the table of locks can be expanded to a new size so long as the new size is a power of two. */ static SDL_SpinLock locks[32] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, }; static __inline__ void privateWaitLock(volatile void *ptr) { #if SIZEOF_VOIDP == 4 Uint32 index = ((((Uint32)ptr) >> 3) & 0x1f); #elif SIZEOF_VOIDP == 8 Uint64 index = ((((Uint64)ptr) >> 3) & 0x1f); #endif /* SIZEOF_VOIDP */ SDL_AtomicLock(&locks[index]); } static __inline__ void privateUnlock(volatile void *ptr) { #if SIZEOF_VOIDP == 4 Uint32 index = ((((Uint32)ptr) >> 3) & 0x1f); #elif SIZEOF_VOIDP == 8 Uint64 index = ((((Uint64)ptr) >> 3) & 0x1f); #endif /* SIZEOF_VOIDP */ SDL_AtomicUnlock(&locks[index]); } /* 32 bit atomic operations */ SDL_bool SDL_AtomicTestThenSet32(volatile Uint32 * ptr) { #ifdef nativeTestThenSet32 #else SDL_bool result = SDL_FALSE; privateWaitLock(ptr); result = (*ptr == 0); if (result) { *ptr = 1; } privateUnlock(ptr); return result; #endif /* nativeTestThenSet32 */ } void SDL_AtomicClear32(volatile Uint32 * ptr) { #ifdef nativeClear32 atomic_clr(ptr, 0xFFFFFFFF); #else privateWaitLock(ptr); *ptr = 0; privateUnlock(ptr); return; #endif /* nativeClear32 */ } Uint32 SDL_AtomicFetchThenIncrement32(volatile Uint32 * ptr) { #ifdef nativeFetchThenIncrement32 return atomic_add_value(ptr, 0x00000001); #else Uint32 tmp = 0; privateWaitLock(ptr); tmp = *ptr; (*ptr)+= 1; privateUnlock(ptr); return tmp; #endif /* nativeFetchThenIncrement32 */ } Uint32 SDL_AtomicFetchThenDecrement32(volatile Uint32 * ptr) { #ifdef nativeFetchThenDecrement32 return atomic_sub_value(ptr, 0x00000001); #else Uint32 tmp = 0; privateWaitLock(ptr); tmp = *ptr; (*ptr) -= 1; privateUnlock(ptr); return tmp; #endif /* nativeFetchThenDecrement32 */ } Uint32 SDL_AtomicFetchThenAdd32(volatile Uint32 * ptr, Uint32 value) { #ifdef nativeFetchThenAdd32 return atomic_add_value(ptr, value); #else Uint32 tmp = 0; privateWaitLock(ptr); tmp = *ptr; (*ptr)+= value; privateUnlock(ptr); return tmp; #endif /* nativeFetchThenAdd32 */ } Uint32 SDL_AtomicFetchThenSubtract32(volatile Uint32 * ptr, Uint32 value) { #ifdef nativeFetchThenSubtract32 return atomic_sub_value(ptr, value); #else Uint32 tmp = 0; privateWaitLock(ptr); tmp = *ptr; (*ptr)-= value; privateUnlock(ptr); return tmp; #endif /* nativeFetchThenSubtract32 */ } Uint32 SDL_AtomicIncrementThenFetch32(volatile Uint32 * ptr) { #ifdef nativeIncrementThenFetch32 atomic_add(ptr, 0x00000001); return atomic_add_value(ptr, 0x00000000); #else Uint32 tmp = 0; privateWaitLock(ptr); (*ptr)+= 1; tmp = *ptr; privateUnlock(ptr); return tmp; #endif /* nativeIncrementThenFetch32 */ } Uint32 SDL_AtomicDecrementThenFetch32(volatile Uint32 * ptr) { #ifdef nativeDecrementThenFetch32 atomic_sub(ptr, 0x00000001); return atomic_sub_value(ptr, 0x00000000); #else Uint32 tmp = 0; privateWaitLock(ptr); (*ptr)-= 1; tmp = *ptr; privateUnlock(ptr); return tmp; #endif /* nativeDecrementThenFetch32 */ } Uint32 SDL_AtomicAddThenFetch32(volatile Uint32 * ptr, Uint32 value) { #ifdef nativeAddThenFetch32 atomic_add(ptr, value); return atomic_add_value(ptr, 0x00000000); #else Uint32 tmp = 0; privateWaitLock(ptr); (*ptr)+= value; tmp = *ptr; privateUnlock(ptr); return tmp; #endif /* nativeAddThenFetch32 */ } Uint32 SDL_AtomicSubtractThenFetch32(volatile Uint32 * ptr, Uint32 value) { #ifdef nativeSubtractThenFetch32 atomic_sub(ptr, value); return atomic_sub_value(ptr, 0x00000000); #else Uint32 tmp = 0; privateWaitLock(ptr); (*ptr)-= value; tmp = *ptr; privateUnlock(ptr); return tmp; #endif /* nativeSubtractThenFetch32 */ } /* 64 bit atomic operations */ #ifdef SDL_HAS_64BIT_TYPE SDL_bool SDL_AtomicTestThenSet64(volatile Uint64 * ptr) { #ifdef nativeTestThenSet64 #else SDL_bool result = SDL_FALSE; privateWaitLock(ptr); result = (*ptr == 0); if (result) { *ptr = 1; } privateUnlock(ptr); return result; #endif /* nativeTestThenSet64 */ } void SDL_AtomicClear64(volatile Uint64 * ptr) { #ifdef nativeClear64 #else privateWaitLock(ptr); *ptr = 0; privateUnlock(ptr); return; #endif /* nativeClear64 */ } Uint64 SDL_AtomicFetchThenIncrement64(volatile Uint64 * ptr) { #ifdef nativeFetchThenIncrement64 #else Uint64 tmp = 0; privateWaitLock(ptr); tmp = *ptr; (*ptr)+= 1; privateUnlock(ptr); return tmp; #endif /* nativeFetchThenIncrement64 */ } Uint64 SDL_AtomicFetchThenDecrement64(volatile Uint64 * ptr) { #ifdef nativeFetchThenDecrement64 #else Uint64 tmp = 0; privateWaitLock(ptr); tmp = *ptr; (*ptr) -= 1; privateUnlock(ptr); return tmp; #endif /* nativeFetchThenDecrement64 */ } Uint64 SDL_AtomicFetchThenAdd64(volatile Uint64 * ptr, Uint64 value) { #ifdef nativeFetchThenAdd64 #else Uint64 tmp = 0; privateWaitLock(ptr); tmp = *ptr; (*ptr)+= value; privateUnlock(ptr); return tmp; #endif /* nativeFetchThenAdd64 */ } Uint64 SDL_AtomicFetchThenSubtract64(volatile Uint64 * ptr, Uint64 value) { #ifdef nativeFetchThenSubtract64 #else Uint64 tmp = 0; privateWaitLock(ptr); tmp = *ptr; (*ptr)-= value; privateUnlock(ptr); return tmp; #endif /* nativeFetchThenSubtract64 */ } Uint64 SDL_AtomicIncrementThenFetch64(volatile Uint64 * ptr) { #ifdef nativeIncrementThenFetch64 #else Uint64 tmp = 0; privateWaitLock(ptr); (*ptr)+= 1; tmp = *ptr; privateUnlock(ptr); return tmp; #endif /* nativeIncrementThenFetch64 */ } Uint64 SDL_AtomicDecrementThenFetch64(volatile Uint64 * ptr) { #ifdef nativeDecrementThenFetch64 #else Uint64 tmp = 0; privateWaitLock(ptr); (*ptr)-= 1; tmp = *ptr; privateUnlock(ptr); return tmp; #endif /* nativeDecrementThenFetch64 */ } Uint64 SDL_AtomicAddThenFetch64(volatile Uint64 * ptr, Uint64 value) { #ifdef nativeAddThenFetch64 #else Uint64 tmp = 0; privateWaitLock(ptr); (*ptr)+= value; tmp = *ptr; privateUnlock(ptr); return tmp; #endif /* nativeAddThenFetch64 */ } Uint64 SDL_AtomicSubtractThenFetch64(volatile Uint64 * ptr, Uint64 value) { #ifdef nativeSubtractThenFetch64 #else Uint64 tmp = 0; privateWaitLock(ptr); (*ptr)-= value; tmp = *ptr; privateUnlock(ptr); return tmp; #endif /* nativeSubtractThenFetch64 */ } #endif /* SDL_HAS_64BIT_TYPE */