¿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 variablei
en 0.El bucle principal está etiquetado como
L1
, donde carga dos elementos del arreglo en los registrosR3
yR2
utilizando la instrucciónLDR
. Luego los compara utilizando la instrucciónCMP
.Si
R3
es menor o igual queR2
, salta a la etiquetaL2
. De lo contrario, intercambia los dos elementos y decrementai
si es diferente de cero, o lo incrementa en caso contrario.El bucle continúa hasta que
i
sea 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_t
en lugar de palabras enteras signadas. Para lograr esto, el código realiza los siguientes cambios:R12
con la dirección más dos, ya que cada semipalabra ocupa dos bytes.n
por dos y lo suma a la dirección inicial para obtener la dirección final del arreglo.LDR
para cargar semipalabras utilizando la instrucciónLDRH
.!
después de la operación deincremento
en la instrucciónLDRH
para indicar que es una operación de carga deincremento después
.STMDA
a la instrucciónSTRH
ya que solo estamos intercambiando dos semipalabras.SUBHI R0,R0,#8
aSUBHI R0,R0,#4
ya que estamos ordenando semipalabras en lugar de palabras enteras.BLT
con la instrucciónBLO
para verificar siR0
es 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
LDRH
carga 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
R2
yR3
deben intercambiarse en lugar del código actual donde se comparaR3
conR2
.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
LDRH
necesita estar acoplada con otra instrucciónLDRH
para cargar la semipalabra completa, y los registros que contienen los valores deben intercambiarse para que el algoritmo de clasificación funcione correctamente.