Brtdku

Is there a way, within C code, to go from a textual representation of an ASM instruction (like cmpwi r3, 0x20) to its binary representation (0x2c030020)?

I am writing code that will be embedded into another application at runtime. That code is supposed to alter the behaviour / the code of the running program. That means, there is a bunch of code lines like this:

*((volatile int *)(0x80001234)) = 0x2c030020;

That code writes the ASM instruction cmpwi r3, 0x20 to 0x80001234, overwriting the current instruction at that address. Now, having the constant "0x2c030020" in my C code without knowing what that does is bad for maintaining the code. Thus, I'd usually add comments to code like the one above, stating the ASM instruction: // 2c 03 00 20 = cmpwi r3, 0x20

However, from time to time these get out of sync. I might do a quick change to the integer value and forgot to update the comment, or I might just make a typo in the comment, causing confusion.

Is there some way I could do something like this instead? (pseudo-code) *((volatile int *)(0x80001234)) = asm("cmpwi r3, 0x20"); which would then result in 0x2c030020 being written to 80001234? Or would I need a hacky solution with a custom preprocessor running over my C source files, replacing ASM instructions with their byte code?

I know there is the C syntax for inline assembler code using the asm() function, but that would execute the given ASM instructions, not give me their binary representation.

This sounds like a mad thing to do, but I assume you have a good reason for it. Life's no fun without a little bit of madness.

One approach you could use is to use an assembler to during your build to generate compile-time constants.

The first step is to make a file that has every assembly instruction you will use, one per line.

For example:

cmpwi   3,0x20

addi    3,3,0

blr

Name that file input.def. Then, use this shell script:

#!/usr/bin/env bash



(cat << HEADER

    .global main

    .text

main:

HEADER

cat input.def) > asm.s



powerpc-linux-gnu-as asm.s -o asm.o



powerpc-linux-gnu-objdump -d asm.o | 

    sed '1,/<main>/ d' | 

    paste -d't' - input.def | 

    awk -F't' '{

        bytes=$2

        asm=$4

        disasm=$3

        gsub(/ /, "", bytes);

        gsub(/[, ]+/, "_", asm);

        printf("#define ASM_%-20s 0x%s    // disassembly: %sn", asm, bytes, disasm)

    }'



# Clean temporaries

rm asm.s asm.o

(I am using GNU assembler and objdump here. You might need to change this part if you don't use those tools. objdump is being used as a glorified hexdump utility here.)

This shell script:

1. Creates an assembly file


2. Assembles it


3. Puts it side by side with input.def. (This is so it can see what assembly you typed.)


4. Reformats the hex so it is a legal C constant. Reformats the asm so it is a legal C symbol. Then, writes a define to map the instruction name to the constant.


5. Put all of this in asm.h

This is a lot of work, but you can do all of it at compile time.

This produces a header file named asm.h:

#define ASM_cmpwi_3_0x20         0x2c030020    // disassembly: cmpwi   r3,32

#define ASM_addi_3_3_0           0x38630000    // disassembly: addi    r3,r3,0

#define ASM_blr                  0x4e800020    // disassembly: blr

You use the asm.h file like this:

#include "asm.h"

*((volatile int *)(0x80001234)) = ASM_cmpwi_3_0x20;

If you need a new asm constant, edit input.def and re-run the shell script.