¿Ordenamiento estúpido de medias palabras uint16_t?
Este es el primer código para ordenar palabras firmadas enteras (int32_t):
sort: SUB R1,R1,#1 //–n void StupidSort(int a[], int n)
ADD R12,R0,#4 //нач.адрес+4 {
ADD R1,R0,R1,LSL#2 //краен адрес int tmp, i = 0;
L1: LDR R3,[R0] //a do {
LDR R2,[R0,#4]! //++a ___ if (a[i] > a[i+1]) {
CMP R3,R2 // \ tmp = a[i+1];
BLE L2 // \ a[i+1] = a[i];
STMDA R0,{R2,R3} // \ a[i] = tmp;
CMP R0,R12 // \ if (i) i–;
SUBHI R0,R0,#8 // ___ } else i++;
L2: CMP R0,R1 // } while (i < n – 1);
BLT L1 // }
BX LR
Esto es lo que he hecho hasta ahora:
sort: SUB R1,R1,#1 //–n void StupidSort(int a[], int n)
ADD R12,R0,#2 //нач.адрес+4 {
ADD R1,R0,R1,LSL#1 //краен адрес int tmp, i = 0;
L1: LDRH R3,[R0] //a do {
LDRH R2,[R0,#2]! //++a ___ if (a[i] > a[i+1]) {
CMP R3,R2 // \ tmp = a[i+1];
BLE L2 // \ a[i+1] = a[i];
STRH R2,[R0,#2]
STRH R3,[R0] // \ a[i] = tmp;
CMP R0,R12 // \ if (i) i–;
SUBHI R0,R0,#4 // ___ } else i++;
L2: CMP R0,R1 // } while (i < n – 1);
BLT L1 // }
BX LR
Intenté cambiarlo para ordenar semipalabras sin signo uint16_t. Estoy casi terminado pero falta algo en el código. El problema es la ordenación, la arquitectura es ARM (en modo ARM, no Thumb). Además, no sé qué hace el signo ! detrás de la función LDRH, también creo que en LDRD R3 y R2 deberían intercambiar sus lugares.
davy.ai
Explicación del código
El código proporcionado sirve para ordenar palabras signadas enteras
int32_t. Utiliza un algoritmo StupidSort, que compara elementos adyacentes y los intercambia si están desordenados.El código comienza restando 1 de
n, que es el tamaño del arreglo. Luego inicializa la variableien 0.El bucle principal está etiquetado como
L1, donde carga dos elementos del arreglo en los registrosR3yR2utilizando la instrucciónLDR. Luego los compara utilizando la instrucciónCMP.Si
R3es menor o igual queR2, salta a la etiquetaL2. De lo contrario, intercambia los dos elementos y decrementaisi es diferente de cero, o lo incrementa en caso contrario.El bucle continúa hasta que
isea menor quen-1. Finalmente, el código retorna utilizando la instrucciónBX LR.Modificaciones realizadas
Las modificaciones realizadas en el código son para ordenar semipalabras no signadas
uint16_ten lugar de palabras enteras signadas. Para lograr esto, el código realiza los siguientes cambios:R12con la dirección más dos, ya que cada semipalabra ocupa dos bytes.npor dos y lo suma a la dirección inicial para obtener la dirección final del arreglo.LDRpara cargar semipalabras utilizando la instrucciónLDRH.!después de la operación deincrementoen la instrucciónLDRHpara indicar que es una operación de carga deincremento después.STMDAa la instrucciónSTRHya que solo estamos intercambiando dos semipalabras.SUBHI R0,R0,#8aSUBHI R0,R0,#4ya que estamos ordenando semipalabras en lugar de palabras enteras.BLTcon la instrucciónBLOpara verificar siR0es menor o igual queR1, ya que estamos trabajando con valores no signados.Problema con el código modificado
Si bien las modificaciones parecen ser correctas, todavía hay un problema con el código. La instrucción
LDRHcarga solo la mitad de la semipalabra en el registro. Por lo tanto, necesitamos cargar e intercambiar la siguiente semipalabra para obtener el valor completo.Además, los dos registros
R2yR3deben intercambiarse en lugar del código actual donde se comparaR3conR2.Conclusión
En general, el código modificado parece ir por el buen camino, pero necesita más modificaciones para ordenar adecuadamente las semipalabras no signadas. La instrucción
LDRHnecesita estar acoplada con otra instrucciónLDRHpara cargar la semipalabra completa, y los registros que contienen los valores deben intercambiarse para que el algoritmo de clasificación funcione correctamente.