He usado objdump para desensamblar todas las funciones en un archivo de biblioteca compilado y escribí la salida en un archivo text. En el archivo text, la salida de la función llamada clear_bit es la siguiente.

Disassembly of section .text.stm32f30x::spi1::cr1::_CRCENW::clear_bit:

   0:   80 b5 84 b0     addlt   r11, r4, r0, lsl #11
   4:   01 46 03 90     andls   r4, r3, r1, lsl #12
   8:   03 98 00 22     andhs   r9, r0, #196608
   c:   02 91 11 46     ldrmi   r9, [r1], -r2, lsl #2
  10:   ff f7 fe ff  <unknown>
  14:   01 90 ff e7     ldrb    r9, [pc, r1]!
  18:   01 98 04 b0     andlt   r9, r4, r1, lsl #16
  1c:   80  <unknown>
  1d:   bd  <unknown>

La salida de otra función set_bit es la siguiente:

Disassembly of section .text.stm32f30x::spi1::cr1::_CRCNEXTW::set_bit:

   0:   80 b5 84 b0     addlt   r11, r4, r0, lsl #11
   4:   01 46 03 90     andls   r4, r3, r1, lsl #12
   8:   03 98 01 22     andhs   r9, r1, #196608
   c:   02 91 11 46     ldrmi   r9, [r1], -r2, lsl #2
  10:   ff f7 fe ff  <unknown>
  14:   01 90 ff e7     ldrb    r9, [pc, r1]!
  18:   01 98 04 b0     andlt   r9, r4, r1, lsl #16
  1c:   80  <unknown>
  1d:   bd  <unknown>

De manera similar a las dos funciones anteriores, este output.txt contiene el desmontaje de más de 100 de tales funciones. Sin embargo, lo que necesito lograr aquí es extraer solo los valores de bytes hexadecimales [80,b5,84,b0,01,..,b0,80,bd] que son respectivos a todas y cada una de las funciones sin instrucciones de ensamblaje, nombres de funciones, compensaciones, etc. Estoy tratando de extraer estas secuencias de bytes con las correspondientes a cada función sin como una única secuencia para desarrollar un modelo en aprendizaje automático. Lo siguiente es lo que espero para solo dos funciones. (Los comentarios son solo para comprender el propósito, no necesito ninguno de los que tengo en mi resultado esperado)

 // byte sequence related to first function
 80 b5 84 b0 01 46 03 90 03 98 00 22 02 91 11 46 ff f7 fe ff  01 90 ff 
 e7 01 98 04 b0 80 bd 

 // byte sequence related to second function separated by a line
 80 b5 84 b0 01 46 03 90 03 98 01 22 02 91 11 46 ff f7 fe ff 01 90 ff 
 e7 01 98 04 b0 80 bd

Usé el comando xxd -g 1 pero me da una secuencia de bytes de la siguiente manera con las compensaciones, algunos otros valores a la derecha de los valores de bytes y parece que contiene el desmontaje de todas las secciones (no solo el código en el sección de texto).

00000000: 21 3c 61 72 63 68 3e 0a 2f 20 20 20 20 20 20 20  !<arch>./       
00000010: 20 20 20 20 20 20 20 20 30 20 20 20 20 20 20 20          0       
00000020: 20 20 20 20 30 20 20 20 20 20 30 20 20 20 20 20      0     0     
00000030: 30 20 20 20 20 20 20 20 34 37 33 32 34 30 20 20  0       473240  
00000040: 20 20 60 0a 00 00 1c 8c 00 07 aa ea 00 07 aa ea    `.............
00000050: 00 07 aa ea 00 07 aa ea 00 07 aa ea 00 07 aa ea  ................
00000060: 00 07 aa ea 00 07 aa ea 00 07 aa ea 00 07 aa ea  ................
00000070: 00 07 aa ea 00 07 aa ea 00 07 aa ea 00 07 aa ea  ................
00000080: 00 07 aa ea 00 07 aa ea 00 07 aa ea 00 07 aa ea  ................
00000090: 00 07 aa ea 00 07 aa ea 00 07 aa ea 00 07 aa ea  ................
000000a0: 00 07 aa ea 00 07 aa ea 00 07 aa ea 00 07 aa ea  ................
000000b0: 00 08 1a 1a 00 08 1a 1a 00 08 1a 1a 00 08 1a 1a  ................
000000c0: 00 08 1a 1a 00 08 1a 1a 00 08 3a ee 00 08 3a ee  ..........:...:.

He estado probando diferentes herramientas y he pasado por otras preguntas de desbordamiento de pila similares, pero he fallado hasta ahora. No sé si estoy usando xxd de manera incorrecta o si hay otras herramientas para lograr mi objetivo. Cualquier ayuda sería muy apreciada. ¡Gracias!

0
hEShaN 21 oct. 2019 a las 04:21

1 respuesta

La mejor respuesta

¿Podría intentar lo siguiente?

# fold $str, print and clear
flush() {
    if [[ -n $str ]]; then
        fold -w 69 <<< "$str"
        echo
        str=""
    fi
}

header='^Disassembly of section'
body='^[[:blank:]]*[0-9a-fA-f]+:[[:blank:]]+(([0-9a-fA-f]{2} )+)'
while IFS= read -r line; do
    if [[ $line =~ $header ]]; then
        flush
        echo "// $line"
    elif [[ $line =~ $body ]]; then
        # concatenate the byte sequence on $str
        str+="${BASH_REMATCH[1]}"
    fi
done < output.txt
flush

Output.txt (como entrada al script anterior):

Disassembly of section .text.stm32f30x::spi1::cr1::_CRCENW::clear_bit:

   0:   80 b5 84 b0     addlt   r11, r4, r0, lsl #11
   4:   01 46 03 90     andls   r4, r3, r1, lsl #12
   8:   03 98 00 22     andhs   r9, r0, #196608
   c:   02 91 11 46     ldrmi   r9, [r1], -r2, lsl #2
  10:   ff f7 fe ff  <unknown>
  14:   01 90 ff e7     ldrb    r9, [pc, r1]!
  18:   01 98 04 b0     andlt   r9, r4, r1, lsl #16
  1c:   80  <unknown>
  1d:   bd  <unknown>

Disassembly of section .text.stm32f30x::spi1::cr1::_CRCNEXTW::set_bit:

   0:   80 b5 84 b0     addlt   r11, r4, r0, lsl #11
   4:   01 46 03 90     andls   r4, r3, r1, lsl #12
   8:   03 98 01 22     andhs   r9, r1, #196608
   c:   02 91 11 46     ldrmi   r9, [r1], -r2, lsl #2
  10:   ff f7 fe ff  <unknown>
  14:   01 90 ff e7     ldrb    r9, [pc, r1]!
  18:   01 98 04 b0     andlt   r9, r4, r1, lsl #16
  1c:   80  <unknown>
  1d:   bd  <unknown>

Resultado:

// Disassembly of section .text.stm32f30x::spi1::cr1::_CRCENW::clear_bit:
80 b5 84 b0 01 46 03 90 03 98 00 22 02 91 11 46 ff f7 fe ff 01 90 ff
e7 01 98 04 b0 80 bd

// Disassembly of section .text.stm32f30x::spi1::cr1::_CRCNEXTW::set_bit:
80 b5 84 b0 01 46 03 90 03 98 01 22 02 91 11 46 ff f7 fe ff 01 90 ff
e7 01 98 04 b0 80 bd
  • Detecta la línea del encabezado y las líneas del cuerpo (valores de bytes) mediante el uso de expresiones regulares.
  • Si se encuentra la línea del cuerpo, extrae la secuencia de bytes por la expresión regular y la almacena en la variable bash ${BASH_REMATCH[1]}.
  • Al final de cada sección, imprime la secuencia colocando nuevas líneas en el ancho designado.

Espero que esto sea lo que quieras.

1
tshiono 21 oct. 2019 a las 06:55