More information it maybe help
To optimize the function and avoid unexpected crashes in Borland C 64-bit, you can take a methodical approach focusing on improving type safety, error handling, and ensuring compatibility with the 64-bit architecture. Here are specific optimizations you can apply:
### 1. **Improve Type Safety**
Make sure that all data types are correctly sized for a 64-bit environment. This is especially important for types like `USHORT`, `BOOL`, and pointers. Use fixed-size types from `<stdint.h>` to guarantee consistency across different platforms. For example:
- Replace `USHORT` with `uint16_t`.
- Ensure that pointer types (like `PHB_ITEM` and `PHB_SYMB`) are correctly defined for 64-bit.
Code: Select all | Expand
#include <stdint.h> // for uint16_t
void hb_clsFinalize( PHB_ITEM pObject )
{
HB_THREAD_STUB
uint16_t uiClass; // Changed from USHORT to uint16_t
if( HB_IS_OBJECT( pObject ) )
uiClass = pObject->item.asArray.value->uiClass;
else
return;
### 2. **Validate Pointers Before Access**
In 64-bit, pointer mismanagement is a common source of crashes. Before accessing or using any pointers, ensure they are valid by checking for `NULL` or other invalid states. For example:
Code: Select all | Expand
if (pObject == NULL || pObject->item.asArray.value == NULL)
{
// Log or handle the error
return;
}
This ensures you avoid dereferencing invalid pointers.
### 3. **Use Robust Error Handling**
Ensure robust error handling around critical operations, particularly where you're interacting with the Harbour VM and using stack-based operations (`hb_vmSend`). Add more comprehensive error checks before calling these functions:
Code: Select all | Expand
if (pClass->pDestructor && pObject)
{
hb_vmPushSymbol(pClass->pDestructor->pMessage->pSymbol);
hb_vmPush(pObject);
// Add error handling for hb_vmSend
if (!hb_vmSend(0)) // Handle the case where hb_vmSend fails
{
hb_errInternal(HB_EI_ERRUNRECOV, "hb_vmSend failed", NULL, NULL);
return;
}
}
else
{
hb_errInternal(HB_EI_ERRUNRECOV, "Invalid destructor or object", NULL, NULL);
}
This ensures that if something fails during `hb_vmSend(0)`, the failure is handled gracefully rather than causing a crash.
### 4. **Minimize Stack Usage**
The Harbour VM stack could be another point of failure, especially if it becomes corrupted or misaligned. Minimize direct stack manipulations unless necessary. Check the stack state before and after every operation involving the stack (`hb_stackPush()`, `hb_stackPopState()`).
Ensure the stack is not too deeply nested, as excessive nesting can cause a stack overflow in 64-bit:
[/code]
if (hb_stackBaseItem() == NULL || hb_stackSelfItem() == NULL)
{
// Handle stack corruption or invalid stack state
hb_errInternal(HB_EI_ERRUNRECOV, "Invalid stack state", NULL, NULL);
return;
}
[/code]
### 5. **Disable/Enable Garbage Collection Wisely**
The function disables garbage collection (`hb_gcSetCollecting(TRUE)`) during the destructor call. Be very cautious when disabling and re-enabling garbage collection, and ensure it is balanced and applied correctly. If the destructor fails unexpectedly, you want to make sure the garbage collection state is restored properly:
Code: Select all | Expand
BOOL bCollecting = hb_gcSetCollecting(TRUE);
PHB_SYMB pDestructor = pClass->pDestructor->pMessage->pSymbol;
// Handle errors during destructor execution
if (pDestructor)
{
hb_vmPushSymbol(pDestructor);
hb_vmPush(pObject);
hb_vmSend(0);
}
hb_gcSetCollecting(bCollecting); // Ensure GC is reset even after errors
### 6. **Isolate Problematic Sections**
If you know where the crash is likely happening (for example, around `hb_vmSend(0)`), isolate that code into a separate function and handle exceptions locally, so they don't propagate and crash the entire program. You can use structured exception handling (`try/catch`) or equivalent mechanisms in your environment to catch and handle failures gracefully.
### 7. **Check Compatibility with 64-bit Stack Size**
Borland C 64-bit environments handle the stack differently from 32-bit. Make sure you aren't inadvertently exceeding the stack size or encountering memory alignment issues. If necessary, allocate large objects on the heap instead of the stack.
Code: Select all | Expand
PHB_ITEM* pObjectCopy = (PHB_ITEM*)malloc(sizeof(PHB_ITEM));
if (pObjectCopy == NULL)
{
// Handle memory allocation failure
return;
}
memcpy(pObjectCopy, pObject, sizeof(PHB_ITEM));
This ensures that larger objects are safely allocated in heap memory, which can handle bigger allocations in 64-bit environments.
### 8. **Compile with Appropriate Flags**
Ensure that your project is being compiled with the correct flags for 64-bit support. These flags ensure correct memory alignment, stack size, and handling of pointers. In Borland C, use the following:
- `-m64`: For 64-bit compilation.
- Ensure optimization flags are enabled for error checking (e.g., `-O2` for optimization, `-g` for debugging).
- If available, enable additional warning levels to catch potential issues at compile time (`-Wall` or equivalent).
### 9. **Use 64-bit Debugging Tools**
Utilize 64-bit debugging tools to check memory, stack, and pointers during runtime. Tools such as Valgrind (for memory checks), gdb (for stack traces), or specialized 64-bit debuggers in Borland C++ can help identify the exact source of the crash.
### Final Optimized Example:
Code: Select all | Expand
void hb_clsFinalize( PHB_ITEM pObject )
{
HB_THREAD_STUB
uint16_t uiClass;
if (!pObject || !HB_IS_OBJECT(pObject) || !pObject->item.asArray.value) {
// Handle invalid object
return;
}
uiClass = pObject->item.asArray.value->uiClass;
if (uiClass && uiClass <= s_uiClasses)
{
PCLASS pClass = s_pClasses + (uiClass - 1);
if (pClass->pDestructor)
{
if (pClass->uiScope & HB_OO_CLS_DESTRUC_SYMB)
{
assert(hb_stack_ready);
if (s_AllowDestructors)
{
if (hb_stackBaseItem() && hb_stackSelfItem() && strcmp(hb_stackBaseItem()->item.asSymbol.value->szName, "__CLSINSTSUPER"))
{
BOOL bCollecting = hb_gcSetCollecting(TRUE);
PHB_SYMB pDestructor = pClass->pDestructor->pMessage->pSymbol;
if (pDestructor && pObject)
{
hb_vmPushSymbol(pDestructor);
hb_vmPush(pObject);
// Call destructor and handle errors
if (!hb_vmSend(0))
{
hb_errInternal(HB_EI_ERRUNRECOV, "Error in hb_vmSend", NULL, NULL);
}
}
hb_gcSetCollecting(bCollecting);
}
}
else
{
hb_errInternal(HB_EI_ERRUNRECOV, "Destructors disabled!", pClass->szName, NULL);
}
}
}
}
}
By following these steps, you can improve the robustness of your function and reduce the likelihood of unexpected crashes in Borland C 64-bit.
Alterantive function by claude maybe help:
Code: Select all | Expand
B_BOOL hb_vm_ready( void )
{
/* Verificar si la pila de la máquina virtual está inicializada */
if( !hb_stack_ready )
{
return HB_FALSE;
}
/* Verificar si el puntero de la máquina virtual es válido */
if( hb_vm_ptr() == NULL )
{
return HB_FALSE;
}
/* Verificar si el área de memoria de la máquina virtual está inicializada */
if( hb_vmMemoryPtr() == NULL )
{
return HB_FALSE;
}
/* Puedes agregar más verificaciones aquí si es necesario */
return HB_TRUE;
}
void hb_clsFinalize( PHB_ITEM pObject )
{
HB_THREAD_STUB
USHORT uiClass;
if( HB_IS_OBJECT( pObject ) )
uiClass = pObject->item.asArray.value->uiClass;
else
return;
if( uiClass && uiClass <= s_uiClasses )
{
PCLASS pClass = s_pClasses + ( uiClass - 1 );
if( pClass->pDestructor )
{
if( pClass->uiScope & HB_OO_CLS_DESTRUC_SYMB )
{
assert( hb_stack_ready );
if( s_AllowDestructors )
{
if( HB_IS_SYMBOL( hb_stackBaseItem() ) &&
( hb_stackBaseItem()->item.asSymbol.pCargo->uiSuperClass == 0 ||
( USHORT ) hb_stackBaseItem()->item.asSymbol.pCargo->uiSuperClass != uiClass ||
( HB_IS_ARRAY( hb_stackSelfItem() ) &&
hb_stackSelfItem()->item.asArray.value != pObject->item.asArray.value ) ) &&
strcmp( hb_stackBaseItem()->item.asSymbol.value->szName, "__CLSINSTSUPER" ) )
{
BOOL bCollecting = hb_gcSetCollecting( TRUE ), bPop = TRUE;
PHB_SYMB pDestructor = pClass->pDestructor->pMessage->pSymbol;
if( HB_IS_ARRAY( &HB_VM_STACK.Return ) &&
HB_VM_STACK.Return.item.asArray.value == pObject->item.asArray.value )
{
bPop = FALSE;
hb_stackPush();
}
else
hb_vmPushState();
hb_vmPushSymbol( pDestructor );
hb_vmPush( pObject );
#ifdef __BORLANDC__
#if __BORLANDC__ > 0x0580 // Ajusta este valor según la versión de Borland C 64-bit
// Alternativa para 64-bit
if (hb_vm_ready()) // Asume que existe una función como esta
{
// Llama directamente al destructor si es posible
if (pDestructor && pDestructor->value)
{
pDestructor->value(pObject);
}
else
{
// Registra un error o maneja la situación de otra manera
hb_errInternal(HB_EI_ERRUNRECOV, "Unable to call destructor", NULL, NULL);
}
}
else
{
hb_errInternal(HB_EI_ERRUNRECOV, "Harbour VM not ready", NULL, NULL);
}
#else
hb_vmSend( 0 );
#endif
#else
hb_vmSend( 0 );
#endif
if( bPop )
hb_vmPopState();
else
hb_stackDec();
hb_gcSetCollecting( bCollecting );
}
}
else
hb_errInternal( HB_EI_ERRUNRECOV, "Destructors disabled! Destructor of class: '%s' can't be executed.", pClass->szName, NULL );
}
}
}
}
