Bit Manipulation Operators
The bit manipulation operators in C language include bitwise AND (&), bitwise OR (|), bitwise XOR (^), bitwise NOT (~), left shift (<<), and right shift (>>).
Bitwise AND (&): The result bit is 1 only when both corresponding binary bits of the operands are 1; otherwise, it is 0. For example, 3 & 5, where the binary of 3 is 0b0011 and that of 5 is 0b0101, results in: 0b0011 & 0b0101 = 0b0001, which equals 1. Bitwise AND is commonly used to mask certain bits. For instance, if we want to keep the lower 4 bits of an integer, we can perform a bitwise AND operation with 0b00001111.
Bitwise OR (|): The result bit is 1 if at least one of the corresponding binary bits of the operands is 1; otherwise, it is 0. For example, 3 | 5 results in 0b0011 | 0b0101 = 0b0111, which equals 7. Bitwise OR is often used to set certain bits. If we want to set the lower 4 bits of an integer to 1, we can perform a bitwise OR with 0b00001111.
Bitwise XOR (^): The result bit is 1 if the corresponding binary bits of the operands are different (one is 1 and the other is 0); otherwise, it is 0. For example, 3 ^ 5 results in 0b0011 ^ 0b0101 = 0b0110, which equals 6. Bitwise XOR can be used to flip certain bits. For instance, to flip the lower 4 bits of an integer, we can perform a bitwise XOR with 0b00001111.
Bitwise NOT (~): This operator inverts each bit of the operand, changing 1 to 0 and 0 to 1. For example, ~3, where the binary of 3 is 0b0011, results in 0b1100, which equals -4 (in signed integers, the value after bitwise NOT needs to consider the sign bit, involving the concept of two’s complement).
Left Shift (<<): This operator shifts all binary bits of the operand to the left by a specified number of positions, filling the right with 0s. For example, 5 << 2, where the binary of 5 is 0b0101, results in 0b010100, which equals 20. Shifting left by one position is equivalent to multiplying by 2, and shifting left by n positions is equivalent to multiplying by 2 raised to the power of n.
Right Shift (>>): For unsigned numbers, the right is filled with 0s; for signed numbers, positive numbers are filled with 0s, and negative numbers are filled with 1s. For example, 5 >> 2 results in 0b0101 right-shifted by 2 positions to 0b0001, which equals 1; while -5 >> 1 (the two’s complement of -5 is 11111011) results in 11111101, which equals -3. Shifting right by one position is equivalent to dividing by 2 (rounding down), and shifting right by n positions is equivalent to dividing by 2 raised to the power of n.
Registers
A register is a storage unit within the CPU used for temporarily storing data, instructions, and addresses. Registers are directly integrated into the CPU and are closely connected to the CPU’s arithmetic and logic units, allowing for very fast access, making them the fastest storage devices in computers, significantly enhancing CPU processing efficiency.
Common types of registers include:
General-purpose registers: These can store data and intermediate results during operations, and programmers can use them freely. For example, in the x86 architecture, EAX, EBX, ECX, EDX, etc., are general-purpose registers. In a simple addition operation, if we want to calculate the sum of two numbers a and b, we can first store a and b in general-purpose registers, then perform the addition in the registers, and finally store the result back in the registers or memory.
Instruction register: This is specifically used to store the currently executing instruction, which the CPU’s arithmetic unit decodes and executes. For instance, when the CPU needs to execute an addition instruction, this instruction is stored in the instruction register, and the CPU performs the corresponding operation based on the instruction’s content.
Program counter: This stores the address of the next instruction to be executed. The CPU continuously changes the value of the program counter to achieve sequential execution and jumps in the program. When the program executes sequentially, the program counter automatically increments to point to the address of the next instruction; when a jump instruction is encountered, the program counter is modified to the address of the jump target.
Stack pointer register: This is used to store the address of the top of the stack, primarily supporting stack operations such as push and pop. During function calls, the stack is used to save function parameters, local variables, and return addresses, and the stack pointer register plays a crucial guiding role.
During program execution, the role of registers is very important. When a C program is loaded and executed, the program’s instructions and data are loaded into memory, but the CPU does not frequently access memory directly; instead, it first reads the necessary data and instructions into registers. For example, when performing a loop accumulation operation, the loop variable and accumulation result are stored in registers, and calculations are performed directly in the registers during each loop, with results written back to memory only when necessary. This reduces the number of times the CPU accesses memory, improving program execution speed. Additionally, registers play a key role in program control, such as the program counter controlling the execution flow, and the status register storing CPU status information for controlling program execution and exception handling.
Register Operation Methods
In embedded systems and low-level development, hardware control is performed through registers. The CPU’s read and write operations to registers are generally performed according to data width, with common data widths being 8 bits, 16 bits, 32 bits, etc. When modifying specific bits in a register, the typical approach is to follow the “read-modify-write” steps. First, the CPU reads the current value of the register, then modifies the target bits using bit manipulation based on the read value; finally, the modified value is written back to the register.
Examples of Specific Bit Operations on Registers
Below, we will understand how to use bit manipulation to clear, set, and invert specific bits of a register through concrete examples. Suppose we have a 32-bit register represented by an unsigned integer variable register_value, currently holding the value 0xFFFF0000.
Clearing Specific Bits: If we want to clear the 16th and 17th bits of the register, we can use the bitwise AND (&) operation and a bitmask. A bitmask is a binary number with the same number of bits as the register, where the target bits are 0 and the others are 1. To clear the 16th and 17th bits, the bitmask is 0xFFFCFFFF (binary: 1111 1111 1111 1100 1111 1111 1111 1111). The code implementation is as follows:
#include <stdio.h>
int main() { unsigned int register_value = 0xFFFF0000; // Define bitmask to clear the 16th and 17th bits unsigned int mask = 0xFFFCFFFF; // Perform specific bit clearing operation on the register register_value &= mask;
printf("Value of register after clearing specific bits: 0x%X\n", register_value); return 0;}In the above example, after executing register_value &= mask;, the value of register_value changes to 0xFFFC0000 (binary: 1111 1111 1111 1100 0000 0000 0000 0000), successfully clearing the 16th and 17th bits.
Setting Specific Bits to 1: If we want to set the 8th and 9th bits of the register to 1, we can use the bitwise OR (|) operation and the corresponding bitmask. The bitmask is 0x00030000 (binary: 0000 0000 0000 0011 0000 0000 0000 0000). The code is as follows:
#include <stdio.h>
int main() { unsigned int register_value = 0xFFFF0000; // Define bitmask to set the 8th and 9th bits to 1 unsigned int mask = 0x00030000; // Perform specific bit setting operation on the register register_value |= mask;
printf("Value of register after setting specific bits to 1: 0x%X\n", register_value); return 0;}After executing register_value |= mask;, the value of register_value changes to 0xFFFF3000 (binary: 1111 1111 1111 1111 0011 0000 0000 0000), successfully setting the 8th and 9th bits to 1.
Inverting Specific Bits: When we need to invert the 24th and 25th bits of the register, we use the bitwise XOR (^) operation and the bitmask. The bitmask is 0x03000000 (binary: 0000 0011 0000 0000 0000 0000 0000 0000). The code is as follows:
#include <stdio.h>
int main() { unsigned int register_value = 0xFFFF0000; // Define bitmask to invert the 24th and 25th bits unsigned int mask = 0x03000000; // Perform specific bit inversion operation on the register register_value ^= mask;
printf("Value of register after inverting specific bits: 0xFCFF0000\n", register_value); return 0;}After executing register_value ^= mask;, the value of register_value changes to 0xFCFF0000 (binary: 1111 1100 1111 1111 0000 0000 0000 0000), successfully inverting the 24th and 25th bits.
Application Scenarios of Bit Manipulation
In practical projects, especially in embedded system development, bit manipulation is widely used in register control.
In hardware control, for example, in GPIO (General Purpose Input/Output) control. Suppose the microcontroller we are using has a GPIO port register, and through bit manipulation of this register, we can control the input/output mode and output level of the GPIO pins. For instance, to configure a GPIO pin as output mode and output a high level, we can implement it as follows:
// Define GPIO direction register address and output register address#define GPIO_DIR_REG *((volatile unsigned int*)0x40020000)#define GPIO_OUT_REG *((volatile unsigned int*)0x40020004)
// Configure the 5th pin as output modeGPIO_DIR_REG |= (1 << 5);// Set the 5th pin to output high levelGPIO_OUT_REG |= (1 << 5);In this example, by performing a set operation on the 5th bit of the GPIO direction register, we configure that pin as output mode; then, by performing a set operation on the 5th bit of the GPIO output register, we make that pin output a high level, thus controlling the hardware device.
In data communication, for example, in the SPI (Serial Peripheral Interface) communication protocol. In SPI communication, data transmission and reception are achieved through shift registers, and bit manipulation is used to control the operation of the shift registers and data parsing. When sending data, the data needs to be shifted into the shift register bit by bit; when receiving data, it needs to be read from the shift register bit by bit. For example, the following code demonstrates how to implement simple SPI data transmission through bit manipulation:
// Assume SPI control register address and data register address#define SPI_CTRL_REG *((volatile unsigned int*)0x40030000)#define SPI_DATA_REG *((volatile unsigned int*)0x40030004)
// Send a byte of datavoid spi_send_byte(unsigned char data) { for (int i = 0; i < 8; i++) { // Write the i-th bit of data into the SPI data register if (data & (1 << i)) { SPI_DATA_REG |= (1 << 0); } else { SPI_DATA_REG &= ~(1 << 0); } // Start SPI transmission SPI_CTRL_REG |= (1 << 1); // Wait for transmission to complete while (SPI_CTRL_REG & (1 << 1)); }}In this function, through a loop and bit manipulation, a byte of data is sent bit by bit, achieving the data transmission function in SPI communication.
Bit manipulation can also be used for resource optimization. In embedded systems, resources are often very limited, and reasonable use of bit manipulation can save memory space and improve code execution efficiency. For example, we can use the bits of an integer variable to represent different status flags instead of defining a separate variable for each status flag. Suppose we have a device with multiple states, such as power status, operating mode status, error status, etc., we can use different bits of an unsigned integer variable to represent these states:
// Define status flags#define POWER_ON (1 << 0)#define WORK_MODE_1 (1 << 1)#define WORK_MODE_2 (1 << 2)#define ERROR_FLAG (1 << 3)
// Use one variable to represent device statusunsigned int device_status = 0;
// Set power on statusdevice_status |= POWER_ON;// Set working mode to WORK_MODE_1device_status |= WORK_MODE_1;// Check error statusif (device_status & ERROR_FLAG) { // Handle error}In this example, through bit manipulation, multiple status flags are represented by one variable, saving memory space.
Programming Techniques for Bit Manipulation and Registers
1. Use Macros to Simplify Operations
In C language programming, to simplify the code, macros can be used to encapsulate bit manipulation. Below is a specific example code demonstrating how to use macros to implement bit operations such as setting bits, clearing bits, and getting values.
// Macro definition: Set specific bit to 1#define SET_BIT(reg, bit) ((reg) |= (1 << (bit)))
// Macro definition: Clear specific bit#define CLEAR_BIT(reg, bit) ((reg) &= ~(1 << (bit)))
// Macro definition: Get specific bit value#define GET_BIT(reg, bit) (((reg) >> (bit)) & 1)In the above code:
SET_BIT(reg, bit) macro implements the operation of setting the bit bit of register reg to 1. (1 << (bit)) generates a mask where only the bit bit is 1, and the rest are 0. Then, through the bitwise OR (|) operation, this mask is ORed with the value of register reg, thus setting the bit bit to 1.
CLEAR_BIT(reg, bit) macro is used to clear the bit bit of register reg. ~(1 << (bit)) generates a mask where the bit bit is 0 and the rest are 1. Through the bitwise AND (&) operation, this mask is ANDed with the value of register reg, thus clearing the bit bit.
GET_BIT(reg, bit) macro is used to get the value of the bit bit of register reg. (reg) >> (bit) shifts the value of register reg to the right by bit positions, moving the bit bit to the least significant bit, and then through & 1 operation, it masks other bits, keeping only the value of the least significant bit, which is the value of the bit bit.
Examples of using these macros are as follows:
#include <stdio.h>
int main() { unsigned int register_value = 0x00;
// Set the 3rd bit to 1 SET_BIT(register_value, 3); printf("Value of register after setting the 3rd bit to 1: 0x%X\n", register_value);
// Clear the 5th bit CLEAR_BIT(register_value, 5); printf("Value of register after clearing the 5th bit: 0x%X\n", register_value);
// Get the value of the 4th bit int bit_value = GET_BIT(register_value, 4); printf("Value of the 4th bit: %d\n", bit_value);
return 0;}In the above example, an unsigned integer variable register_value is defined and initialized to 0x00. Then, the SET_BIT, CLEAR_BIT, and GET_BIT macros are used to perform set, clear, and get operations on the register value, and the results are printed.
2. Using Bit Fields
Bit fields are a special structure in C language that allows us to specify the number of binary bits occupied by members within a structure, which is particularly useful for efficiently managing memory or handling hardware registers. Through bit fields, developers can directly manipulate certain bits in memory without complex bit operations.
The layout and alignment of bit fields in memory may vary depending on the compiler and platform. Generally, the order of bit fields is arranged according to the order of declaration, but the actual storage may be affected by the machine’s byte order (big-endian or little-endian). Some compilers may enforce alignment to machine word boundaries, which may cause the memory occupied by bit fields to be more than expected.
Below is a specific example to understand the application of bit fields.
1. Hardware Register Mapping
In embedded systems, when operating hardware registers, bit fields can help us precisely control the bits within the register without using bit masks and shift operations. Suppose we want to access an 8-bit hardware register defined as follows:
Bit 7: Global Enable Bit (Enable)
Bits 6-4: Mode Selection (Mode)
Bits 3-0: Status Code (Status)
The code to map this register using bit fields is as follows:
#include <stdio.h>
// Define a structure containing bit fields to map the hardware registerstruct Register { unsigned int enable : 1; // Occupies 1 bit, global enable bit unsigned int mode : 3; // Occupies 3 bits, mode selection bits unsigned int status : 4; // Occupies 4 bits, status code bits} reg;
int main() { // Enable global enable reg.enable = 1; // Set mode to 5 reg.mode = 5; // Read status code unsigned int status = reg.status;
printf("Global enable bit: %d\n", reg.enable); printf("Mode selection bit: %d\n", reg.mode); printf("Status code bit: %d\n", status);
return 0;}In this example, through bit fields, we can directly and intuitively operate on the bits of the hardware register, making the code more concise and understandable, reducing the possibility of errors.
2. Communication Protocol Parsing
In the implementation of network or communication protocols, we often encounter fields defined by bits. Using bit fields can directly map these fields, simplifying the parsing and processing of protocol headers. For example, parsing a communication frame header that contains flag bits and data types, defined as follows:
Bits 7-6: Flag Bit 1 (Flag1)
Bits 5-4: Flag Bit 2 (Flag2)
Bits 3-0: Data Type (DataType)
The code to parse this communication frame header using bit fields is as follows:
#include <stdio.h>
// Define a structure containing bit fields to parse the communication frame headerstruct FrameHeader { unsigned int flag1 : 2; // Occupies 2 bits, flag bit 1 unsigned int flag2 : 2; // Occupies 2 bits, flag bit 2 unsigned int dataType : 4; // Occupies 4 bits, data type} frameHeader;
int main() { // Assume the received value of a communication frame header is 0x3A (binary: 00111010) unsigned char received_frame = 0x3A;
// Assign the received byte data to the bit field structure *(unsigned char*)&frameHeader = received_frame;
printf("Flag bit 1: %d\n", frameHeader.flag1); printf("Flag bit 2: %d\n", frameHeader.flag2); printf("Data type: %d\n", frameHeader.dataType);
return 0;}In the above example, through bit fields, we can conveniently parse the received communication frame header data into various fields.
3. Memory Optimization
In some cases where memory usage is strictly limited, bit fields can significantly reduce the memory usage of data structures. For example, if a data structure contains multiple boolean values, using bit fields can compress these boolean values into one byte or even less. Suppose we have a data structure containing 8 boolean flags, the code to define this data structure using bit fields is as follows:
#include <stdio.h>
// Define a structure containing bit fields to store boolean flagsstruct Flags { unsigned int flag1 : 1; // Occupies 1 bit, flag 1 unsigned int flag2 : 1; // Occupies 1 bit, flag 2 unsigned int flag3 : 1; // Occupies 1 bit, flag 3 unsigned int flag4 : 1; // Occupies 1 bit, flag 4 unsigned int flag5 : 1; // Occupies 1 bit, flag 5 unsigned int flag6 : 1; // Occupies 1 bit, flag 6 unsigned int flag7 : 1; // Occupies 1 bit, flag 7 unsigned int flag8 : 1; // Occupies 1 bit, flag 8} flags;
int main() { // Set flag 1 to true flags.flag1 = 1; // Set flag 3 to true flags.flag3 = 1;
// Check the value of flag 1 if (flags.flag1) { printf("Flag 1 is true\n"); }
// Check the value of flag 2 if (!flags.flag2) { printf("Flag 2 is false\n"); }
return 0;}In this example, through bit fields, 8 boolean flags are compressed into one byte, which is very practical in situations with limited memory resources.
Combining Unions with Bit Manipulation
A union is a special data structure in C language that allows storing different types of data in the same memory location. All members of a union share the same memory space, so its size depends on the size of the largest member, not the total size of all members. This feature makes unions very convenient when combined with bit manipulation, especially for operations on registers.
Suppose we have a 32-bit register that can be viewed as a whole 32-bit unsigned integer, as well as composed of 4 8-bit unsigned characters, or 2 16-bit unsigned short integers. We can define this register using a union, as follows:
#include <stdio.h>
// Define a union to represent the registerunion Register { unsigned int value; // 32-bit unsigned integer unsigned char bytes[4]; // 4 8-bit unsigned characters unsigned short half_words[2]; // 2 16-bit unsigned short integers};
int main() { union Register reg;
// Set the register value to 0x12345678 reg.value = 0x12345678;
// Access the register by bytes printf("Accessing register by bytes:"); for (int i = 0; i < 4; i++) { printf("0x%02X ", reg.bytes[i]); } printf("\n");
// Access the register by half-words printf("Accessing register by half-words:"); for (int i = 0; i < 2; i++) { printf("0x%04X ", reg.half_words[i]); } printf("\n");
// Use bit manipulation to modify specific bits of the register // Set the 8th and 9th bits to 1 reg.value |= (1 << 8) | (1 << 9); printf("Value of register after setting the 8th and 9th bits to 1: 0x%X\n", reg.value);
// Clear the 16th bit reg.value &= ~(1 << 16); printf("Value of register after clearing the 16th bit: 0x%X\n", reg.value);
return 0;}In the above example, a union Register is defined, containing three members: value (32-bit unsigned integer), bytes (array of 4 8-bit unsigned characters), and half_words (array of 2 16-bit unsigned short integers). These three members share the same memory space, allowing us to access and manipulate the same register through different members.
When accessing the register by bytes, we can obtain the value of each byte of the register; when accessing the register by half-words, we can obtain the value of each half-word of the register. When using bit manipulation to modify specific bits of the register, we first view the register as a whole 32-bit unsigned integer through the value member, and then use bit operators to modify it, with the modified value reflecting in other members as well.
