¿Puedo crear un punto de interrupción en el código en iOS, como `__asm ​​{int 3}` en VC ++, y continuar la ejecución después de haber sido alcanzado?

Estoy intentando poner el equivalente de asm{int 3} (o similar) en mi progtwig de iPhone. Mi objective es hacer que Xcode se detenga exactamente en la línea ofensiva, sin tener que juguetear con la stack de llamadas (por lo que _Debugger no parece que haría, no podría encontrar en qué marco está …), y dejar Puedo reanudar la ejecución (por eso no estoy contento con assert ).

(Estoy acostumbrado a estos dos comportamientos en otros sistemas, y me gustaría reproducirlos en iOS).

Mi mejor bash hasta ahora ha sido esto:

 asm volatile("bkpt 1"); 

Esto detiene a Xcode en la línea en cuestión, pero cuando trato de continuar con Cmd + Alt + P, Xcode parece ejecutar nuevamente el BKPT . Y si uso Shift + Cmd + O, solo obtengo esto:

 Watchdog has expinetworking. Remote device was disconnected? Debugging session terminated. 

(No hace falta decir que el dispositivo remoto todavía está conectado).

No tengo una gran experiencia con iOS, Mac, ARM, gdb o gcc's asm stuff. Así que ya estoy desconcertado. ¿Hay alguna manera de hacer que iOS y Xcode hagan lo que quiero?

(No sé si hace una diferencia, pero a juzgar por el tamaño de la instrucción, mi progtwig es el código ARM).

[Esta pregunta apareció originalmente bajo otro título. Lo he editado, con el fin de aclarar las cosas.]

raise(SIGTRAP) es una forma relativamente portátil de tener un punto de corte "en código".

Tratar:

 __builtin_trap(); 

funciona tanto en Mac como iOS, y puede arrastrar el pequeño cursor verde a la siguiente línea para continuar ejecutándose.

He probado todas estas soluciones y, aunque la respuesta de @RichardGroves conservó la stack, la mejor solución es:

  1. cree su propio método assert, como Debug::assert(...)
  2. Establezca un punto de interrupción dentro de XCode en esa implementación.
  3. use el command Paso de salida para volver a la persona que llama

Esto se debe a que es la única forma confiable para ambos

  • ver el rastro de la stack
  • paso / continuar

Yo también. He puesto un código que hace lo que queremos + una explicación de lo que queremos en http://iphone.m20.nl/wp/2010/10/xcode-iphone-debugger-halt-assertions/ – es la primera publicación así que no tendrás que mirar muy duro.

 int resume = false; for (int i = 0; i < 20 && !resume; ++i) sleep(1); 

Arriba está la trampa de un pobre hombre, ya que tiene que adjuntarse manualmente al progtwig en cuestión. Incremente la demora según corresponda. Coloca el código donde quieres romper e inserta un punto de interrupción en la statement de suspensión, crea y ejecuta tu progtwig y adjúntalo desde Xcode. Una vez que Xcode se rompe, puede hacer clic derecho en la variable de currículum y editarlo en 1 para reanudar la ejecución.

Captura de pantalla

int pthread_kill(pthread_t thread, int sig); permite la continuación y pausa en el hilo actual, a través de pthread_self() .

Similar a otras funciones de señal (por ejemplo, kill() , raise() , etc.), sin embargo, pthread_kill() se utiliza para solicitar que se envíe una señal a un hilo particular.

Pthread_kill Manual

 std::runtime_error::runtime_error("breakpoint") 

junto con un punto de interrupción de exception XCode de tipo

Excepción: C ++ "named: std :: runtime"

Trabajó para mí (usando XCode 8.0).
Produce el mismo resultado que si hubiera establecido un punto de interrupción manualmente en la línea donde el

 std::runtime_error::runtime_error 

se llama a la function, es decir, hilo correcto, stack de llamadas correcta, y la posibilidad de reanudar.

Intenté encontrar la implementación que se comporta igual que __debugbreak () que viene con el comstackdor de Microsoft y se rompe dentro de mi código y no en algún lugar dentro de las bibliotecas del sistema y me permite continuar la ejecución. Esta implementación de __debugbreak () funciona exactamente como quería:

 #if defined(__APPLE__) && defined(__aarch64__) #define __debugbreak() __asm__ __volatile__( \ " mov x0, %x0; \n" /* pid */ \ " mov x1, #0x11; \n" /* SIGSTOP */ \ " mov x16, #0x25; \n" /* syscall 37 = kill */ \ " svc #0x80 \n" /* software interrupt */ \ " mov x0, x0 \n" /* nop */ \ :: "r"(getpid()) \ : "x0", "x1", "x16", "memory") #elif defined(__APPLE__) && defined(__arm__) #define __debugbreak() __asm__ __volatile__( \ " mov r0, %0; \n" /* pid */ \ " mov r1, #0x11; \n" /* SIGSTOP */ \ " mov r12, #0x25; \n" /* syscall 37 = kill */ \ " svc #0x80 \n" /* software interrupt */ \ " mov r0, r0 \n" /* nop */ \ :: "r"(getpid()) \ : "r0", "r1", "r12", "memory") #elif defined(__APPLE__) && defined(__i386__) #define __debugbreak() __asm__ __volatile__("int $3; mov %eax, %eax") #endif #define ASSERT(expr) do { if (!(expr)){ __debugbreak(); } } while(0)