Thread: Swap Byte

>>It has to work, because it's the same physical space in memory. <<

What he is saying is that technically this is not a legal assumption.

Technically he is right. However, you are unlikely to see a problem in this instance.

Here's some code to demonstrate:

Code:

#include <stdio.h>
#include <stddef.h>

int main(void) {

	union unTest {
		struct {
			char  a;
			long  b;
			short c;
			char  d;
		} stTest;

		long long llTest;
	} test;

	printf("%d, %d, %d, %d, %d", sizeof(test), sizeof(test.stTest), sizeof(test.llTest),
	                             offsetof(union unTest, stTest), offsetof(union unTest, llTest));

	getchar();
	return 0;
}

Code:

Results(MSVC): 16, 12, 8, 0, 0

Intel has already provided opcodes to do this. Unfortunately C has no equivalent function but Quzah's is the best solution. For an assembly language solution, which will do this in 4 clock cycles or less look into the RCL, RCR, ROL, and ROR instructions. They rotate bits - the high order bit can be rotated to the low order and vice versa. Using these opcodes with the correct number of rotations will effectively reverse the bits. This can also be used to swap bytes since it would be possible to rotate the value by half of the total bits thus resulting in bytes being reversed.


START:

0000 1111

Rotated left by 4 bits

1111 0000

The result is that the low order bits of this byte have been switched with the high order bits of this byte.

Here is the same operation on a word - shifted left by (numberofbitsindatatype/2)

0000 1111 1111 0000

Rotated left by 8 bits

1111 0000 0000 1111

If you notice the bytes of this word have been swapped. Now with a simple mov instruction you could save these values. This is the fastest way to swap bytes but you can also swap words, dwords, and even qwords. Just shift left or right by the data type size in bits divided by 2.

This just swaps bits, it does not reverse them. But reversing can also be done in assembly but prob just as fast in C.

1000 0111

0111 1000

Pretty much a NOT operation isn't it or am I missing something?

This is to Alex's responce..

This is program for swapping the byte. FOr example, 0th bit should be swapped with 7th bit. 1st bit should be swapped with 6th bit and so on. But this particular solution is bit hard for me to analyse. Can anybody analyse this for me????

Code:

unsigned char quux(unsigned char value)
{
   value = ((value&0xaa)>>1) | ((value&0x55)<<1);
   value = ((value&0xcc)>>2) | ((value&0x33)<<2);
   return (value>>4) | (value<<4);
}

Yep, you're missing something. They're talking about reversing the order of the bits, not just inverting the bits. Therefore, it should be:
1000 0111
1110 0001

This is how it should be but I am not able to analyse the algorithm in following case. Meaning why is he ANDING with AA and 55. AThen OR. Againg ANDING with CC and 33 resectively and the OR each other.

End result is correct but what is analysis?

Let e know..

Hi Happy Man!

The algorithm uses the fact that reversing the bits of a value is the same as splitting the value in two parts (say hi_lo -> hi, lo), reverse the bits of both parts (lets call those rhi, rlo), and concatenating the reversed parts in the reverse order (rhi, rlo -> rlo_rhi)...

The first line interchanges odd and even bits: "value&0xaa" and "value&0x55" select the even and odd bits of value; the shift operator is used to change the position of the bits, and the or operator (which could just as well have been a xor or a simple add) puts the bits together...

Code:

abcdefgh: AND 10101010 -> a0c0e0g0: shift right 1 -> 0a0c0e0g
abcdefgh: AND 01010101 -> 0b0d0f0h: shift left 1 --> b0d0f0h0
                                             (or)    --------
                                                     badcfehg

The second line does the same for pairs of two-bit parts of value.

The third line does the same for four-bit parts of value, and could be written as "return ((value&0xf0)>>4) | ((value&0x0f)<<4);", but the and-operations are superfluous.

Now extend this to 16, 32, and 64 bits... Try the same for the other solutions mentioned

greetings,
alex

Hello Alex,

Thanks a lot....