¿Hay un equivalente portátil a DebugBreak () / __ debugbreak?

StackOverflow https://stackoverflow.com/questions/173618

  •  05-07-2019
  •  | 
  •  

Pregunta

En MSVC, DebugBreak () o __ debugbreak causa la ruptura de un depurador. En x86 es equivalente a escribir " _asm int 3 " ;, en x64 es algo diferente. Al compilar con gcc (o cualquier otro compilador estándar), también quiero hacer una interrupción en el depurador. ¿Existe una función independiente de la plataforma o intrínseca? Vi la pregunta de XCode sobre eso, pero no lo hace t parece lo suficientemente portátil.

Sidenote: principalmente quiero implementar ASSERT con eso, y entiendo que puedo usar assert () para eso, pero también quiero escribir DEBUG_BREAK o algo en el código.

¿Fue útil?

Solución

¿Qué pasa con la definición de una macro condicional basada en #ifdef que se expande a diferentes construcciones basadas en la arquitectura o plataforma actual?

Algo como: 

#ifdef _MSC_VER
#define DEBUG_BREAK __debugbreak()
#else
...
#endif

Esto se expandiría mediante el preprocesador de la correcta instrucción de interrupción del depurador basada en la plataforma donde se compila el código. De esta manera, siempre usas DEBUG_BREAK en tu código.

Otros consejos

Un método que es portátil para la mayoría de los sistemas POSIX es: 

raise(SIGTRAP);

GCC tiene una función incorporada llamada __builtin_trap que puede ver aquí , sin embargo, se supone que la ejecución del código se detiene una vez que se alcanza.

usted debería asegurarse de que la llamada __builtin_trap () sea condicional, de lo contrario no se emitirá ningún código después de ella.

esta publicación está alimentada por los 5 minutos de pruebas, YMMV.

Esto se parece a una biblioteca compatible adecuada https://github.com/scottt/debugbreak

Acabo de agregar un módulo a portable-snippets (una colección de fragmentos de dominio público de código portátil) para hacer esto. No es 100% portátil, pero debería ser bastante robusto:

  • __builtin_debugtrap para algunas versiones de clang (identificadas con __has_builtin (__ builtin_debugtrap) )
  • En MSVC y el compilador Intel C / C ++: __debugbreak
  • Para el Compilador ARM C / C ++: __breakpoint(42)
  • Para x86 / x86_64, ensamblado: int $ 03
  • Para ARM Thumb, ensamblado: .inst 0xde01
  • Para ARM AArch64, ensamblado: .inst 0xd4200000
  • Para otras ARM, ensamblado: .inst 0xe7f001f0
  • Para Alpha, ensamblado: bpt
  • Para C no alojada con GCC (o algo que se hace pasar por él), __builtin_trap
  • De lo contrario, incluya signal.h y
    • Si definido (SIGTRAP) (es decir, POSIX), raise(SIGTRAP)
    • De lo contrario, raise(SIGABRT)

En el futuro, el módulo en fragmentos portátiles se expandirá para incluir otra lógica y probablemente me olvide actualizar esta respuesta, por lo que debe buscar actualizaciones. Es de dominio público (CC0), así que siéntase libre de robar el código.

Si considera que aseverar (x) es lo suficientemente portátil, afirmar (falso) parece ser la solución portátil obvia para su problema.

Si está tratando de depurar una condición relacionada con un fallo, el abort () de buena calidad le dará una pila de llamadas en la mayoría de las plataformas. El inconveniente es que no puedes continuar desde la PC actual, lo que probablemente no quieras hacer de todos modos.

http://www.cplusplus.com/reference/cstdlib/abort/

En lugar de usar saltos de depuración 'normales', ¿por qué no usar uno de los siguientes, como una división por cero? 

int iCrash = 13 / 0;

o desreferencia un puntero NULO: 

BYTE bCrash = *(BYTE *)(NULL);

Al menos esto es portátil en muchas plataformas / arquitecturas.

En muchos depuradores, puede especificar qué acción desea realizar en qué excepciones para que pueda actuar en consecuencia cuando se golpee uno de los anteriores (como la ejecución de pausa, ala y " int 3 " instrucción) y se genera una excepción. 

#define __debugbreak() \
do \
{       static bool b; \
        while (!b) \
                sleep(1); \
        b = false; \
} while (false)

Cuando el proceso está inactivo, puede adjuntar un depurador al proceso, cambiar la variable b para romper el bucle y hacer lo suyo. ¡Este código podría no funcionar en una compilación optimizada!

Licenciado bajo: CC-BY-SA con atribución
No afiliado a StackOverflow
scroll top