After using ToDesk for a few days, since it was not shut down(I prefer to leaving the computer open), the free quota was used up in the middle of the month, and I could no longer continue using it for free. I uninstalled it and switched to RustDesk, it really astonished me, using Self-host, which is free and offers much higher frame rates and resolution than ToDesk’s free version. Below is the setup log.
Basic Environment Setup
I am using two Windows (win10) and one Ubuntu (with the configuration shown below). The Ubuntu server acts as the ID/relay server, allowing one Windows machine to connect to another. Ubuntu needs Docker installed, and both Windows machines need to install RustDesk and perform some configuration.
My three machines are all in the same local area network (LAN)
Once installation is complete, add the current user to the Docker group:
1 2 3 4 5 6 7
# Add docker user group, it should already exist sudo groupadd docker # Add the current user to the docker group sudo gpasswd -a $USER docker # Update the user group newgrp docker docker version
After installation, open the network settings and enter the IP address of the ID/relay server, which is the server running Docker. The controlled machine does not need to enter the relay server, but it’s recommended for the controlling machine to do so. Then, the controlling machine should enter the key (the contents of the .pub file in the data folder above).
Finally, enter the controlled machine’s ID and password to connect.
]]>Using RustDesk with a self-hosted serverCSAPP Data Labhttps://even629.com/en/posts/42856/2025-03-07T12:12:13.000Z2025-03-11T14:31:13.000Z
Timeline
2025-03-07
I got as far as the “howManyBits” problem.
2025-03-07
I finished it. Once again, I feel this experiment is quite good.
Recently, as a teaching assistant for the computer system course, I need to check students’ completion of this CSAPP experiment. I did this experiment during my undergraduate studies, but I’ve basically forgotten everything after so long. So, I’m doing it again and recording the process here.
Experiment Environment Setup
I completed this in the Windows 10 WSL2 environment:
For detailed instructions on setting up the environment, please refer to the following link. There is a script for one-click environment setup, which is very convenient:
Complete the function implementations in bits.c, but there are certain restrictions on the code.
1 2 3 4 5 6
# Check whether the code complies with the required specifications ./dlc bits.c # View score make clean make ./btest
Experiment Content
bitXor
Problem:
1 2 3 4 5 6 7 8 9 10
/* * bitXor - x^y using only ~ and & * Example: bitXor(4, 5) = 1 * Legal ops: ~ & * Max ops: 14 * Rating: 1 */ intbitXor(int x, int y) { return2; }
The requirement is to implement XOR using only ~(Bitwise NOT) and &(Bitwise AND). You may use equivalence calculus from discrete mathematics. XOR means ‘0 if the bits are the same, 1 if different’:
$$ x \oplus y = \lnot (\lnot x \land \lnot y) \land \lnot ( x \land y) $$
Returns the smallest two’s complement integer. The definitions of sign-magnitude, one’s complement, and two’s complement are as follows:
Representation
Definition
Sign-magnitude
The most significant bit is the sign bit (0 indicates positive, 1 indicates negative), and the remaining bits represent the absolute value.
One’s complement
For positive numbers, the one’s complement is the same as the sign-magnitude; for negative numbers, the sign bit remains unchanged, and the other bits are bitwise inverted.
Two’s complement
For positive numbers, the two’s complement is the same as the sign-magnitude; for negative numbers, the two’s complement is the one’s complement plus 1.
Two’s complement encoding is asymmetric. Except for the smallest negative number, every negative number corresponds to a positive number. On a 64-bit system, the range of integers represented in two’s complement is:
Maximum positive number: 0x7FFFFFFFFFFFFFFF (i.e., 2^63 - 1)
1 2 3
inttmin(void) { return1 << 31; }
isTmax
Problem:
1 2 3 4 5 6 7 8 9 10
/* * isTmax - returns 1 if x is the maximum, two's complement number, * and 0 otherwise * Legal ops: ! ~ & ^ | + * Max ops: 10 * Rating: 1 */ intisTmax(int x) { return2; }
Returns 1 if x is the maximum two’s complement value; otherwise, returns 0.
The maximum value is 0x7FFFFFFF, characterized by the most significant bit being 0 and all others being 1, so 0x7FFFFFFFbecomes 0x8 after adding +0x1. 00000000, with the most significant bit being 1 and all others 0, which is exactly the opposite.
Here, we need to use the property of XOR, such as x^target. After inverting x and XORing it with target, since XOR outputs 1 for differing bits and 0 for identical bits, only when x and target are exactly the same will x^target be 0x0. Then, by applying the ! operator, we get !(x^target), which is 1 when x equals target and 0 otherwise. For 0x7FFFFFFF, after adding 1, it becomes 0x80000000, due to the opposite characteristic, after bitwise NOT, it becomes 0x7FFFFFFF, so we can use XOR to check if they are the same, that is: !(~(x+1) ^ x).
Keep thinking: is it only 0x7FFFFFFFthat satisfies this property, where adding 1 is equivalent to bitwise NOT? Obviously, 0xFFFFFFFFalso satisfies this property, because when overflow occurs, the most significant bit is discarded, resulting in 0x0. Therefore, we need to construct an expression combined with !((x+1) ^ x), called expression1, i.e., !((x+1) ^ x) & expression1. When x is 0x7,FFFFFFFexpression1 equals 1, and when x is 0xFFFFFFFFit equals 0.
The exclusion method must use 0x7. FFFFFFFThere is 0xFFFFFFFFThe characteristic of lacking 0, that is, the difference between these two numbers, and the simplest difference is 0x7. FFFFFFFbecomes 0x8 after adding +0x1. FFFFFFFIt is a non-zero number, and 0xFFFFFFFFbecomes 0 after adding 0x1. Therefore, !(x+1) is 0 when x is 0x7. FFFFFFFand is 1 when x is 0xFFFFFFFF!(x+1) is exactly the opposite of what is needed, so adding a NOT operation suffices, that is:
/* * allOddBits - return 1 if all odd-numbered bits in word set to 1 * where bits are numbered from 0 (least significant) to 31 (most significant) * Examples allOddBits(0xFFFFFFFD) = 0, allOddBits(0xAAAAAAAA) = 1 * Legal ops: ! ~ & ^ | + << >> * Max ops: 12 * Rating: 2 */ intallOddBits(int x) { return2; }
Returns 1 if all odd-numbered bit positions are 1; otherwise, returns 0. That is, if the 1st, 3rd, 5th, 7th, and so on bits of a number are 1 (regardless of other bits), it returns 1; otherwise, it returns 0.
We can eliminate the influence of all even-numbered bits and focus on the odd bits, for example, by performing x & 0xAAAAAAAAUsing bitwise AND, all even bits become 0; then check whether it equals 0xAAAAAAAAthe same (as explained in isTmax, using bitwise AND to determine if two numbers are identical). Alternatively, you can let x and 0x55555555bitwise OR, so all even bits become 1; then check whether it equals 0xFFFFFFFFthe same. That is:
!((x|0x55555555)^0xFFFFFFFF)
!((x&0xAAAAAAAA)^(0xAAAAAAAA))
However, due to the experiment’s constraints, you cannot directly write 0xAAAAAAAAlike this; you can only write 0xAA and obtain 0x through bitwise operationsAAAAAAAA
Note: According to the C standard, shift operations have lower precedence than addition and subtraction.
1 2 3 4 5 6 7 8
intallOddBits(int x) { // return !((x|0x55555555)^0xFFFFFFFF); // return !((x&0xAAAAAAAA)^(0xAAAAAAAA)); int a = 0xAA<<8;//0x00AA int b = a | 0xAA;//0xAAAA int c = b<<16 | b;//0xAAAAAAAA return !((x&c)^c); }
To check whether x is an ASCII digit, simply determine if x is between 0x30 and 0x39.
In assembly, comparisons are performed by subtraction which sets the flags. Therefore, we can subtract x from 0x30 and 0x39 respectively and check the sign bit to verify: 0x30 - x should be less than or equal to 0 with the sign bit set to 1, and 0x39 - x should be greater than or equal to 0 with the sign bit 0. However, if x is at the boundary, for example x == 0x30, then 0x30 - x equals 0 with the sign bit 0, which also satisfies the condition. Hence, we can replace <= with <:
0x30 <= x <= 0x39
This is equivalent to:
0x2F < x <= 0x39
Now, does the right side x < 0x39 require an equivalent transformation? Since 0x39 - x should be greater than or equal to 0 with the sign bit 0, and if 0x39 - x < 0 the sign bit is 1, analyzing the boundary conditions shows it is inclusive, so no equivalent transformation is needed (transforming it would exclude the boundary condition). To ensure the sign bit of 0x2F - x is 1 and the sign bit of 0x39 - x is 0, both conditions must be met simultaneously. First, consider 0x2F < x. After subtraction, how can we extract the sign bit? We can perform an arithmetic right shift by 31 bits so that the sign bit fills all 32 bits. That is, if 0x2F - x < 0, then (0x2F + (x + 1)) >> 31 equals 0xFFFFFFFF, and if 0x2F - x >= 0, (0x2F + (x + 1)) >> 31 equals 0;
(0x2F + (~x + 1)) >> 31
Next, consider x <= 0x39. Using the same method, if 0x39 - x < 0, then (0x39 + (x + 1)) >> 31 equals 0xFFFFFFFF, and if 0x39 - x >= 0, (0x39 + (x + 1)) >> 31 equals 0. We take the negation to satisfy this condition:
~((0x39 + (~x + 1)) >> 31)
Both conditions must be satisfied simultaneously, so:
intisAsciiDigit(int x) { int low = (0x2F + (~x + 1)) >> 31; // 0x2F - x < 0 => x > 0x2F (即 x >= 0x30) int high = ~((0x39 + (~x + 1)) >> 31); // 0x39 - x >= 0 => x <= 0x39 return low & high & 0x1; }
conditional
Problem:
1 2 3 4 5 6 7 8 9 10
/* * conditional - same as x ? y : z * Example: conditional(2,4,5) = 4 * Legal ops: ! ~ & ^ | + << >> * Max ops: 16 * Rating: 3 */ intconditional(int x, int y, int z) { return2; }
The expression for conditional is the same as x ? y : z.
To implement returning y or z based on the value of x using only bit operations is very difficult. Although it is easy to determine whether x is zero, it is hard to simultaneously associate x with both y and z. Therefore, we rely on addition operations and assume the return expression is:
a + y + z
When x != 0, let a = -z = ~z + 1; When x == 0, let a = -y = ~y + 1 to satisfy the requirement. However, this is also difficult because a depends on both y and z, and a is determined by whether x is zero. Thus, we consider splitting a:
b + c + y + z
When x is non-zero, let b = 0 and c = -z = ~z + 1; when x is zero, let b = -y = ~y + 1 and c = 0. This way, b depends only on y, and c depends only on z. First, we need to determine whether x is zero. This is straightforward using the NOT operation: when x is non-zero, it yields 0; when x is zero, it yields 1. Let’s focus on b. When !x == 0, b should be 0; when !x != 0, b should be ~z + 1. Clearly, the AND operation can achieve this:
b = !x & (~y + 1)
However, when !x != 0, !x equals 1, and its bitwise AND with ~z + 1 only preserves the least significant bit, which is not necessarily ~z + 1. Therefore, we need to ensure that when x != 0, the result is 0x. FFFFFFFF, and 0 when x == 0. Thus, we define a as:
a = ~(!x) + 1
When x is zero, !x equals 1, and (!x) equals 0x. FFFFFFFE,a==0xFFFFFFFF；当x为非零时，!x==0，(!x)==0xFFFFFFFFSince a == 0, the expression for b should be
b = a & (~y + 1)
Next, consider c. The case for c is exactly the opposite of b, so simply add a ~ to a:
c = ~a & (~z + 1)
There is no need to worry about addition overflow here.
1 2 3 4 5 6
intconditional(int x, int y, int z) { int a = ~(!x)+1; int b = a&(~y+1); int c = ~a&(~z+1); return b+y+c+z; }
isLessOrEqual
Problem:
1 2 3 4 5 6 7 8 9 10
/* * isLessOrEqual - if x <= y then return 1, else return 0 * Example: isLessOrEqual(4,5) = 1. * Legal ops: ! ~ & ^ | + << >> * Max ops: 24 * Rating: 3 */ intisLessOrEqual(int x, int y) { return2; }
Return 1 if x <= y; otherwise, return 0.
To compare values using subtraction, compute y - x. If y - x >= 0 (sign bit is 0), return 1; if y - x < 0 (sign bit is 1), return 0. Since y - x = y + ~x + 1, right shift by 31 bits to extract the sign bit. We apply bitwise negation to ensure that when the sign bit is 0, the result is 1; when the sign bit is 1, the result is 0:
~((y + (~x + 1)) >> 31) & 0x1
1 2 3
intisLessOrEqual(int x, int y) { return ~((y+(~x+1))>>31) &0x1; }
logicalNeg
Problem:
1 2 3 4 5 6 7 8 9 10 11
/* * logicalNeg - implement the ! operator, using all of * the legal operators except ! * Examples: logicalNeg(3) = 0, logicalNeg(0) = 1 * Legal ops: ~ & ^ | + << >> * Max ops: 12 * Rating: 4 */ intlogicalNeg(int x) { return2; }
Implement the NOT operation: for !x, return 1 when x is 0, and return 0 when x is non-zero.
The most intuitive difference between 0 and non-zero values is that every bit of 0 is zero, while a non-zero value has at least one bit set to 1. However, since we cannot use looped shift operations to determine this, we must find an alternative approach.
Another distinguishing characteristic between 0 and non-zero values is that the negative of 0 is still 0, i.e., ~0 + 1 = 0, whereas the negative of a non-zero number is not 0. We can leverage this fact to check whether the negative of x equals x itself. Previously, we used a trick with XOR to check if two numbers are equal: this expression returns 0 when x is 0, and non-zero when x is non-zero, but this effectively does nothing.
(~x+1)^x
We can use another insight: the sign bit of a non-zero number and its negative must be opposite—one is 1, the other 0—while the sign bit of 0 and its negative are both 0. Therefore, by OR-ing the two, we get an expression whose sign bit is 1 when non-zero, and 0 when zero.
(~x+1)|x
Next, we extract the sign bit and invert it, because we want to return 1 when the input is 0, and 0 otherwise. We used this technique in the previous problem: perform an arithmetic right shift by 31 bits, invert the result, and then AND with 0x1 to isolate the least significant bit:
/* howManyBits - return the minimum number of bits required to represent x in * two's complement * Examples: howManyBits(12) = 5 * howManyBits(298) = 10 * howManyBits(-5) = 4 * howManyBits(0) = 1 * howManyBits(-1) = 1 * howManyBits(0x80000000) = 32 * Legal ops: ! ~ & ^ | + << >> * Max ops: 90 * Rating: 4 */ inthowManyBits(int x) { return0; }
Return the number of bits required to represent x in binary two’s complement form. Essentially, this involves finding the position of the most significant 1 bit and then adding 1 bit for the sign bit. This problem is somewhat challenging and not very intuitive. Below is an implementation method from someone else.
Here, we use a binary search approach: First, consider positive numbers and zero.
High 16 bits: Check if there is a 1 in the high 16 bits; if so, at least 16 bits are needed.
High 8 bits: Within the remaining 16 bits, check if there is a 1 in the high 8 bits.
High 4 bits: Within the remaining 8 bits, check if there is a 1 in the high 4 bits.
High 2 bits: Within the remaining 4 bits, check if there is a 1 in the high 2 bits.
High bit: Among the remaining 2 bits, check if the higher bit is 1.
Least significant bit: The last remaining bit. Finally, sum the bit counts of all parts and add 1 for the sign bit.
Handling negative numbers: The flag is x >> 31, which is the sign bit. If x is negative, flag is 1; otherwise, it is 0.
If x is negative (flag == 1), then x is bitwise inverted: x = ~x.
If x is non-negative (flag == 0), x remains unchanged. In two’s complement representation of negative numbers, the sign bit and the value bits are combined. If you directly calculate the number of significant bits for a negative number, the sign bit will cause incorrect results. For example: The two’s complement of -1 is 11111111 11111111 11111111 11111111, if we directly count the bits, we get 32 bits, but in reality, we only care about the number of effective bits. By applying bitwise negation, the two’s complement representation of a negative number is converted into a positive number, and the number of effective bits in its binary form remains the same as that of the original negative number. For example:
The two’s complement of -1 is 11111111 11111111 11111111 11111111, and after negation it becomes 00000000 00000000 00000000 00000000, with an effective bit count of 1.
The two’s complement of -2 is 11111111 11111111 11111111 11111110, and after negation it becomes 00000000 00000000 00000000 00000001, with an effective bit count of 2.
inthowManyBits(int x) { int b16, b8, b4, b2, b1, b0; int flag = x >> 31; x = (flag & ~x) | (~flag & x); // If the sign bit of x is 0, it remains unchanged; if the sign bit of x is 1, invert all bits b16 = !!(x >> 16) << 4; // Check if the number is greater than or equal to 2^16 x >>= b16; b8 = !!(x >> 8) << 3; // Check if the number is greater than or equal to 2^8 x >>= b8; b4 = !!(x >> 4) << 2; // Check if the number is greater than or equal to 2^4 x >>= b4; b2 = !!(x >> 2) << 1; // Check if the number is greater than or equal to 2^2 x >>= b2; b1 = !!(x >> 1); // Check if the number is greater than or equal to 2^1 x >>= b1; b0 = x; // Check if the number is greater than or equal to 2^0 return b0 + b1 + b2 + b4 + b8 + b16 + 1; // Return the total number of bits required }
floatScale2
Problem:
1 2 3 4 5 6 7 8 9 10 11 12 13 14
/* * floatScale2 - Return bit-level equivalent of expression 2*f for * floating point argument f. * Both the argument and result are passed as unsigned int's, but * they are to be interpreted as the bit-level representation of * single-precision floating point values. * When argument is NaN, return argument * Legal ops: Any integer/unsigned operations incl. ||, &&. also if, while * Max ops: 30 * Rating: 4 */ unsignedfloatScale2(unsigned uf) { return2; }
Multiply a single-precision floating-point number (float) by 2, and return the binary representation of the result. The function’s input and output are both of type unsigned int, but they actually represent the binary bit pattern of a single-precision floating-point number. When the input is NaN, return it unchanged. Also, finally I get to use if and while😭😭😭
Let’s first review the concepts of IEEE 754 floating-point numbers:
There are three categories of floating-point numbers defined by IEEE 754:
Denormalized numbers represent very small values close to zero, preventing floating-point underflow and ensuring the continuity of floating-point computations.
First, we extract the sign bit (sign), the fraction (frac), and the exponent (exp):
sign=uf>>31&0x1
frac=uf&0x7FFFFF
exp = (uf&0x7f800000)>>23
Based on the exponent, determine whether this floating-point number is normalized, denormalized, or one of the special cases.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
unsignedfloatScale2(unsigned uf) { unsignedexp = (uf & 0x7f800000) >> 23; unsigned sign = uf >> 31 & 0x1; unsigned frac = uf & 0x7FFFFF; if (exp == 0) { // Denormalized number, exponent is 0, just multiply frac by 2 frac <<= 1; return (sign << 31) | (exp << 23) | frac; } elseif (exp == 0xFF) { // Special case, NaN return uf; } else { exp++; // Multiply by 2, equivalent to E + 1 return (sign << 31) | (exp << 23) | frac; } }
floatFloat2Int
Problem:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
/* * floatFloat2Int - Return bit-level equivalent of expression (int) f * for floating point argument f. * Argument is passed as unsigned int, but * it is to be interpreted as the bit-level representation of a * single-precision floating point value. * Anything out of range (including NaN and infinity) should return * 0x80000000u. * Legal ops: Any integer/unsigned operations incl. ||, &&. also if, while * Max ops: 30 * Rating: 4 */ intfloatFloat2Int(unsigned uf) { return2; }
Represent the input IEEE 754 floating-point number as an int; if it exceeds the representable range, return 0x8. 0000000u。
If it is a denormalized number, return 0 immediately; if it is a special case, return 0x8 immediately. 0000000u
If it is a normalized number, we first need to check whether it exceeds the int representation range. An int consists of 32 bits in total, with one bit for the sign bit. The maximum value is 2^31, and the minimum value is -(2^31 + 1). Therefore, the exponent E cannot exceed 30 (when E is 31, left shifting by E bits will overwrite the sign bit). When the exponent E is less than 0, it means the number is less than 1, so we directly return 0. Also:
We can consider it as 1frac (the 24th bit is 1, and bits 1 to 23 form frac), which is equivalent to 1.frac (integer part 1, fractional part frac) left shifted by 23 bits. At this point, the exponent is E, meaning it should be multiplied by 2 to the power of E, i.e., left shifted by E bits. Therefore, when E is less than 23, we should right shift by (23 - E) bits to truncate the last (23 - E) bits of frac. When E is greater than 23, since this is equivalent to having already shifted left by 23 bits, you only need to shift left by (E - 23) additional bits.
intfloatFloat2Int(unsigned uf) { unsignedexp = (uf & 0x7f800000) >> 23; unsigned sign = uf >> 31 & 0x1; unsigned frac = uf & 0x7FFFFF; if (exp == 0xFF) { // Special case return0x80000000u; } elseif (exp == 0) { // Denormalized number return0x0; } else { // Normalized number int E = exp - 127; // Exponent, note not to set as unsigned if (E >= 31) { // Out of range return0x80000000u; } elseif (E < 0) { // If E < 0, it means the number is smaller than 1, return 0 return0; } frac = frac | (1 << 23); // Set the implicit 1 in the fraction if (E < 23) { frac = frac >> (23 - E); } else { frac = frac << (E - 23); } if (sign == 0) { // Return positive or negative based on the sign bit return frac; } else { return -frac; } } }
floatPower2
Problem:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
/* * floatPower2 - Return bit-level equivalent of the expression 2.0^x * (2.0 raised to the power x) for any 32-bit integer x. * * The unsigned value that is returned should have the identical bit * representation as the single-precision floating-point number 2.0^x. * If the result is too small to be represented as a denorm, return * 0. If too large, return +INF. * * Legal ops: Any integer/unsigned operations incl. ||, &&. Also if, while * Max ops: 30 * Rating: 4 */ unsignedfloatPower2(int x) { return2; }
Calculate 2.0^x and return its unsigned representation according to IEEE 754. If the result is too small—so small that even denormalized numbers cannot represent it—return 0. If the result is too large, return +INF. Clearly, this problem primarily tests the representable range of IEEE 754.
For float single precision
Sign bit sign: 1 bit
Exponent exp: 8 bits
Fraction frac: 23 bits
Representable range
Normalized numbers: The exponent exp is neither all zeros nor all ones, $ V = (-1)^S \times 2^E \times M = (-1)^{sign} \times 2^{exp - bias} \times (1 + frac) $ The exponent ranges from 1 to 254, with E = Exp - Bias = Exp - 127, so E ranges from -126 to 127. For frac, the minimum value is 0 and the maximum is 1 - 2^{-23}. Therefore, ignoring S, $ V_{max} = (-1)^S \times 2^{127} \times (2 - 2^{-23}) = (-1)^S \times 2^{127} \times (2 - 2^{-23}) $ $ V_{min} = (-1)^S \times 2^{-126} \times (1 + 0) = (-1)^S \times 2^{-126} $
Denormalized number: exponent all zeros $ V = (-1)^S \times 2^E \times M = (-1)^{sign} \times 2^{1 - Bias} \times (0 + frac) $ The exponent exp is all zeros, so E = 1 - Bias = 1 - 127 = -126. Therefore: $ V = (-1)^{sign} \times 2^{-126} \times (0 + frac) $ For frac, the minimum value is 0, but the smallest representable nonzero value is 2^{-23}. Values between 0 and 2^{-23} cannot be represented. The maximum value is 1 - 2^{-23}. Thus, when frac is 0, the value is 0. However, to calculate the smallest representable nonzero value, frac must be set to 2^{-23}, ignoring S: $ V_{max} = (-1)^S \times 2^{-126} \times (0 + 1 - 2^{-23}) = (-1)^S \times 2^{-126} \times (1 - 2^{-23}) $ $ V_{min} = (-1)^S \times 2^{-126} \times (0 + 2^{-23}) = (-1)^S \times 2^{-149} $
Special values
+infinity: all bits of exp are 1, frac is 0, and S is 0
-infinity: all bits of exp are 1, frac is 0, and S is 1
NaN: all bits of exp are 1, and frac is not 0
Therefore, based on the above analysis:
Return +NaN when x > 127
A normalized number when -126 ≤ x ≤ 127
Denormalized number when -149 ≤ x < -126
Return 0 when x < -149 because the value is too small to represent
1 2 3 4 5 6 7 8 9 10 11 12
unsignedfloatPower2(int x) { if (x > 127) { // Return +infinity, S=0, exp=0xFF, frac=0; return0xFF << 23; } elseif (-126 <= x && x <= 127) { // Normalized number, exp = E + Bias = E + 127 return (x + 127) << 23; } elseif (-149 <= x && x < -126) { // Denormalized number, exp=0, E = 1 - Bias = -126, 2^(-126) * frac return1 << (23 - (-x - 126)); // E already has 2^(-126), when frac is 0x1, it represents 2^(-23), assuming input x is -127, frac should be 2^(-1), i.e., 1 shifted left by 22 bits } else { // x < -149, too small, return 0 return0; } }
]]>Computer system - CSAPP Data LabSummary of EDK2 Protocol Retrievalhttps://even629.com/en/posts/42855/2025-02-25T06:45:13.000Z2025-02-25T06:45:13.000Z
// // Open and Close Protocol Services // EFI_OPEN_PROTOCOL OpenProtocol; EFI_CLOSE_PROTOCOL CloseProtocol; EFI_OPEN_PROTOCOL_INFORMATION OpenProtocolInformation;
#define EFI_OPEN_PROTOCOL_BY_HANDLE_PROTOCOL 0x00000001 #define EFI_OPEN_PROTOCOL_GET_PROTOCOL 0x00000002 #define EFI_OPEN_PROTOCOL_TEST_PROTOCOL 0x00000004 #define EFI_OPEN_PROTOCOL_BY_CHILD_CONTROLLER 0x00000008 #define EFI_OPEN_PROTOCOL_BY_DRIVER 0x00000010 #define EFI_OPEN_PROTOCOL_EXCLUSIVE 0x00000020 /* Queries a handle to determine if it supports a specified protocol. If the protocol is supported by the handle, it opens the protocol on behalf of the calling agent. @param[in] Handle The handle for the protocol interface that is being opened. @param[in] Protocol The published unique identifier of the protocol. @param[out] Interface Supplies the address where a pointer to the corresponding Protocol Interface is returned. @param[in] AgentHandle The handle of the agent that is opening the protocol interface specified by Protocol and Interface. @param[in] ControllerHandle If the agent that is opening a protocol is a driver that follows the UEFI Driver Model, then this parameter is the controller handle that requires the protocol interface. If the agent does not follow the UEFI Driver Model, then this parameter is optional and may be NULL. @param[in] Attributes The open mode of the protocol interface specified by Handle and Protocol. @retval EFI_SUCCESS An item was added to the open list for the protocol interface, and the protocol interface was returned in Interface. @retval EFI_UNSUPPORTED Handle does not support Protocol. @retval EFI_INVALID_PARAMETER One or more parameters are invalid. @retval EFI_ACCESS_DENIED Required attributes can't be supported in current environment. @retval EFI_ALREADY_STARTED Item on the open list already has requierd attributes whose agent handle is the same as AgentHandle. */ typedef EFI_STATUS (EFIAPI *EFI_OPEN_PROTOCOL)( IN EFI_HANDLE Handle, IN EFI_GUID *Protocol, OUT VOID **Interface OPTIONAL, IN EFI_HANDLE AgentHandle, IN EFI_HANDLE ControllerHandle, IN UINT32 Attributes );
/** Queries a handle to determine if it supports a specified protocol. @param[in] Handle The handle being queried. @param[in] Protocol The published unique identifier of the protocol. @param[out] Interface Supplies the address where a pointer to the corresponding Protocol Interface is returned. @retval EFI_SUCCESS The interface information for the specified protocol was returned. @retval EFI_UNSUPPORTED The device does not support the specified protocol. @retval EFI_INVALID_PARAMETER Handle is NULL. @retval EFI_INVALID_PARAMETER Protocol is NULL. @retval EFI_INVALID_PARAMETER Interface is NULL. **/ typedef EFI_STATUS (EFIAPI *EFI_HANDLE_PROTOCOL)( IN EFI_HANDLE Handle, IN EFI_GUID *Protocol, OUT VOID **Interface );
/** Retrieves the list of protocol interface GUIDs that are installed on a handle in a buffer allocated from pool. @param[in] Handle The handle from which to retrieve the list of protocol interface GUIDs. @param[out] ProtocolBuffer A pointer to the list of protocol interface GUID pointers that are installed on Handle. @param[out] ProtocolBufferCount A pointer to the number of GUID pointers present in ProtocolBuffer. @retval EFI_SUCCESS The list of protocol interface GUIDs installed on Handle was returned in ProtocolBuffer. The number of protocol interface GUIDs was returned in ProtocolBufferCount. @retval EFI_OUT_OF_RESOURCES There is not enough pool memory to store the results. @retval EFI_INVALID_PARAMETER Handle is NULL. @retval EFI_INVALID_PARAMETER Handle is not a valid EFI_HANDLE. @retval EFI_INVALID_PARAMETER ProtocolBuffer is NULL. @retval EFI_INVALID_PARAMETER ProtocolBufferCount is NULL. **/ typedef EFI_STATUS (EFIAPI *EFI_PROTOCOLS_PER_HANDLE)( IN EFI_HANDLE Handle, OUT EFI_GUID ***ProtocolBuffer, OUT UINTN *ProtocolBufferCount );
Unlike HandleProtocol and OpenProtocol, LocateProtocol does not care which device the protocol is on. It sequentially searches through the system’s handle list and returns the first instance of the protocol it finds.
/** Returns the first protocol instance that matches the given protocol. @param[in] Protocol Provides the protocol to search for. @param[in] Registration Optional registration key returned from RegisterProtocolNotify(). @param[out] Interface On return, a pointer to the first interface that matches Protocol and Registration. @retval EFI_SUCCESS A protocol instance matching Protocol was found and returned in Interface. @retval EFI_NOT_FOUND No protocol instances were found that match Protocol and Registration. @retval EFI_INVALID_PARAMETER Interface is NULL. Protocol is NULL. **/ typedef EFI_STATUS (EFIAPI *EFI_LOCATE_PROTOCOL)( IN EFI_GUID *Protocol, IN VOID *Registration OPTIONAL, OUT VOID **Interface );
EFI_STATUS LoadFileByName( IN CHAR16 *FileName, OUT UINT8 **FileData, OUT UINTN *FileSize) { EFI_STATUS Status; EFI_SIMPLE_FILE_SYSTEM_PROTOCOL *SimpleFileSystem; EFI_FILE_PROTOCOL *Root; EFI_FILE_PROTOCOL *FileHandle = NULL; EFI_FILE_INFO *FileInfo; UINTN FileInfoSize; UINTN TempBufferSize; VOID *TempBuffer;
Status = gBS->LocateProtocol(&gEfiSimpleFileSystemProtocolGuid, NULL, (VOID **)&SimpleFileSystem); if (EFI_ERROR(Status)) { return Status; }
// // Open the root directory // Status = SimpleFileSystem->OpenVolume(SimpleFileSystem, &Root); if (EFI_ERROR(Status)) { return Status; }
// // Open the file // Status = Root->Open(Root, &FileHandle, FileName, EFI_FILE_MODE_READ, 0); if ((FileHandle == NULL) || (EFI_ERROR(Status))) { Print(L"Open file %s failed !!\n", FileName); Root->Close(Root); return Status; }
// // Get the file information // FileInfoSize = sizeof(EFI_FILE_INFO) + 1024; FileInfo = AllocateZeroPool(FileInfoSize); if (FileInfo == NULL) { FileHandle->Close(FileHandle); return Status; }
Status = FileHandle->GetInfo(FileHandle, &gEfiFileInfoGuid, &FileInfoSize, FileInfo); if (EFI_ERROR(Status)) { FileHandle->Close(FileHandle); gBS->FreePool(FileInfo); return Status; }
// // Allocate buffer for the file data. The last CHAR16 is for L'\0' // TempBufferSize = (UINTN)FileInfo->FileSize + sizeof(CHAR16); TempBuffer = AllocateZeroPool(TempBufferSize); if (TempBuffer == NULL) { FileHandle->Close(FileHandle); gBS->FreePool(FileInfo); return Status; }
gBS->FreePool(FileInfo);
// // Read the file data to the buffer // Status = FileHandle->Read(FileHandle, &TempBufferSize, TempBuffer); if (EFI_ERROR(Status)) { FileHandle->Close(FileHandle); gBS->FreePool(TempBuffer); return Status; }
/** Retrieves the list of agents that currently have a protocol interface opened. @param[in] Handle The handle for the protocol interface that is being queried. @param[in] Protocol The published unique identifier of the protocol. @param[out] EntryBuffer A pointer to a buffer of open protocol information in the form of EFI_OPEN_PROTOCOL_INFORMATION_ENTRY structures. @param[out] EntryCount A pointer to the number of entries in EntryBuffer. @retval EFI_SUCCESS The open protocol information was returned in EntryBuffer, and the number of entries was returned EntryCount. @retval EFI_OUT_OF_RESOURCES There are not enough resources available to allocate EntryBuffer. @retval EFI_NOT_FOUND Handle does not support the protocol specified by Protocol. **/ typedef EFI_STATUS (EFIAPI *EFI_OPEN_PROTOCOL_INFORMATION)( IN EFI_HANDLE Handle, IN EFI_GUID *Protocol, OUT EFI_OPEN_PROTOCOL_INFORMATION_ENTRY **EntryBuffer, OUT UINTN *EntryCount );
/** Closes a protocol on a handle that was opened using OpenProtocol(). @param[in] Handle The handle for the protocol interface that was previously opened with OpenProtocol(), and is now being closed. @param[in] Protocol The published unique identifier of the protocol. @param[in] AgentHandle The handle of the agent that is closing the protocol interface. @param[in] ControllerHandle If the agent that opened a protocol is a driver that follows the UEFI Driver Model, then this parameter is the controller handle that required the protocol interface. @retval EFI_SUCCESS The protocol instance was closed. @retval EFI_INVALID_PARAMETER 1) Handle is NULL. 2) AgentHandle is NULL. 3) ControllerHandle is not NULL and ControllerHandle is not a valid EFI_HANDLE. 4) Protocol is NULL. @retval EFI_NOT_FOUND 1) Handle does not support the protocol specified by Protocol. 2) The protocol interface specified by Handle and Protocol is not currently open by AgentHandle and ControllerHandle. **/ typedef EFI_STATUS (EFIAPI *EFI_CLOSE_PROTOCOL)( IN EFI_HANDLE Handle, IN EFI_GUID *Protocol, IN EFI_HANDLE AgentHandle, IN EFI_HANDLE ControllerHandle );
Example:
1
]]>A summary of methods for retrieving Protocol in EDK2 during UEFI developmentKeil Installationhttps://even629.com/en/posts/28522/2025-01-31T11:36:13.000Z2025-01-31T11:36:13.000ZC51 Installation
First, visit the official website and click to download C51
You will be asked to fill out a form; just fill it out simply, then click the downloaded exe installation package to begin installation.
After entering the installer, click through and confirm. For the installation location, I chose to install it on the D drive instead of the default C drive.
Finally, click Finish to complete the installation.
MDK Installation
Keil’s MDK and C51 can coexist, and the installation steps are similar.
First, visit the official website to download the MDK installation package.
During installation, set the installation location according to the location where C51 was installed.
Finally, click Finish to complete the installation.
Note: Do not reverse the installation order of C51 and MDK
v5 Compiler
First, download the v5 compiler. Since the official site seems not to offer a direct download for this version anymore, you will need to extract the v5 compiler from an older version of Keil. Below are links to pre-extracted compilers that you can download directly:
]]>Keil installation, coexistence of C51 and MDK, and installation of the v5 compilerMy Emacs Configurationhttps://even629.com/en/posts/28521/2025-01-12T11:36:13.000Z2025-08-02T02:50:13.000ZEnvironment
Using Windows Terminal + WSL2
Configuration
Windows Terminal
Open Windows Terminal settings, select “Open JSON file”, and add the following color scheme under "schemes":
- In your Arch Linux profile under Appearance: - Set the color scheme to GitHub-Dark-Default - Use the FiraCode Nerd Font - Set background opacity to 86% and enable Acrylic effect - In the Advanced tab: - Disable sound notifications, enable window flash and taskbar flash instead
(custom-set-variables ;; custom-set-variables was added by Custom. ;; If you edit it by hand, you could mess it up, so be careful. ;; Your init file should contain only one such instance. ;; If there is more than one, they won't work right. '(package-selected-packages nil)) (custom-set-faces ;; custom-set-faces was added by Custom. ;; If you edit it by hand, you could mess it up, so be careful. ;; Your init file should contain only one such instance. ;; If there is more than one, they won't work right. )
Preview
Keybindings Overview
Shortcut
Description
Source
C-/
Undo (undo-only)
Custom
C-?
Redo (undo-redo)
Custom
M-↑
Increase window height
Custom
M-↓
Decrease window height
Custom
M-←
Decrease window width
Custom
M-→
Increase window width
Custom
C-←
Switch to previous tab (Centaur Tabs)
centaur-tabs
C-→
Switch to next tab
centaur-tabs
M-g g
Preview go-to-line
goto-line-preview
M-p
Move current line up
move-dup
M-n
Move current line down
move-dup
C-x t
Toggle file tree sidebar (neotree)
neotree
C-x g
Open Git status (magit-status)
magit
M-x magit-log-all
View all Git commits in the current repository
magit
C-x f
Format current buffer (clang-format / rustfmt)
format-all
M-,
Jump to definition (xref-find-definitions, LSP)
Custom
M-.
Jump back to previous location (xref-pop-marker)
Custom
M-?
Find references (xref-find-references, LSP)
Custom
M-o
Switch between windows
ace-window
C-c ↑
Move current buffer up to another window
buffer-move
C-c ↓
Move current buffer down to another window
buffer-move
C-c ←
Move current buffer left to another window
buffer-move
C-c →
Move current buffer right to another window
buffer-move
C-a
Smart move to beginning of line
crux
C-c k
Smart kill line
crux
C-c p
Projectile command prefix
projectile
]]>My personal Emacs configuration for C/C++, Rust, and Assembly development, including syntax highlighting for various common file types.Setting up a UEFI Development Environment based on edk2 in Linuxhttps://even629.com/en/posts/42853/2025-01-10T11:18:13.000Z2025-02-07T08:44:13.000ZBasic Environment Setup
This is my hardware environment and operating system.
Download edk2 Source Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
# Install required packages sudo apt update sudo apt install git mkdir -p ~/UEFI cd UEFI git clone"https://github.com/tianocore/edk2.git" cd edk2 # Switch to this branch git checkout origin/stable/202408 git submodule update --init --recursive git branch # Check if all submodules are initialized correctly. If not, compilation may have issues. git submodule status cd - # Download edk2-libc code, mainly for using the C standard library in UEFI development. git clone https://github.com/tianocore/edk2-libc.git # Create a code folder to store our own code mkdir -p code
Install Compilation Tools
1 2 3 4 5 6 7 8
# Install basic software packages sudo apt-get install python3 python3-distutils uuid-dev build-essential bison flex nasm acpica-tools gcc # Install ARM compiler, mainly for compiling aarch64 mkdir -p ~/UEFI/toolchain cd ~/UEFI/toolchain wget https://developer.arm.com/-/media/Files/downloads/gnu-a/8.2-2019.01/gcc-arm-8.2-2019.01-x86_64-aarch64-elf.tar.xz tar -xf gcc-arm-8.2-2019.01-x86_64-aarch64-elf.tar.xz cd -
HelloWorld Example
Let’s implement a UEFI code compilation for the target platform x64 or aarch64, which supports running on Emulator and qemu, and debugging with gdb.
Code
1 2 3 4 5
touch HelloWorld.dsc touch HelloWorld.inf touch HelloWorld.c # Use this command to generate UUID, used in dsc and inf files uuidgen
HelloWorld.dsc
The DSC file is the package description file, where all fields in Defines are mandatory. To find paths for LibraryClasses, use the following command:
1 2 3 4 5
cd edk2 # Take UefiApplicationEntryPoint as an example grep UefiApplicationEntryPoint -r ./ --include=*.inf | grep LIBRARY_CLASS # Find by GUID grep -i 752F3136 -r ./ --exclude-dir=Build
The format for LibraryClasses is:
1
LibraryClassName|Path/To/LibInstanceName.inf
For a full explanation of DSC files, refer to the following link:
# Variables defined to be used during the build process [Defines] INF_VERSION = 1.25 BASE_NAME = HelloWorld FILE_GUID = 5455334b-dbd9-4f95-b6ed-5ae261a6a0c1 MODULE_TYPE = UEFI_APPLICATION VERSION_STRING = 1.0 ENTRY_POINT = UefiMain
# Source code [Sources] HelloWorld.c
# Required packages [Packages] MdePkg/MdePkg.dec # Contains Uefi and UefiLib
#!/bin/bash # Project name, also the directory of the source files export PROJ_NAME="HelloWorld" # DSC file name export DSC_NAME="HelloWorld" # INF file name export INF_NAME="HelloWorld" # Also the name of the generated *.efi, defined in INF's BASE_NAME export INF_BASE_NAME="HelloWorld" # UEFI workspace directory export UEFI_WORKSPACE="$HOME/UEFI" # EDK II path export EDK_PATH="$UEFI_WORKSPACE/edk2" # EDK II libc path export EDK_LIBC_PATH="$UEFI_WORKSPACE/edk2-libc" # Application code path export APP_PATH="$UEFI_WORKSPACE/code/$PROJ_NAME" # Build output directory export PKG_OUTPUT_DIR="$APP_PATH/Build" # Emulator path export EMULATOR_PATH="$EDK_PATH/Build/EmulatorX64/DEBUG_GCC5/X64" # Package path settings, supports multiple paths separated by colon export PACKAGES_PATH="$EDK_PATH:$EDK_LIBC_PATH:$APP_PATH" # Specify Python interpreter export PYTHON_COMMAND="/usr/bin/python3" # Confirm that environment variables have been set echo"Environment variables for $PROJ_NAME project are configured."
Next, we will write a script to compile the code for the x64 target platform.
export GCC5=/usr/bin/gcc cd$EDK_PATH source edksetup.sh cd -
# Building BaseTools make -C $EDK_PATH/BaseTools # In this script, the -b flag is set to DEBUG. When deploying, you should use RELEASE instead. # -p --platform= # -m --module= # -a --arch= # -b --buildtarget= # -t --taggname= build -p $APP_PATH/$DSC_NAME.dsc -m $APP_PATH/$INF_NAME.inf -a X64 -t GCC5 -b DEBUG -D PKG_OUTPUT_DIR=$PKG_OUTPUT_DIR
The process for compiling to the AArch64 platform is similar.
Finally, we write a script to run on the emulator provided by edk2. Note that you need a GUI environment here. If you’re only using the command line, skip this step and refer to the next section to run with QEMU.
1 2
touch run.sh chmod a+x run.sh
run.sh
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
#!/bin/bash set -e trap"Exiting" INT
source env.sh
export GCC5=/usr/bin/gcc # Emulator compilation, once compiled, no need to compile again cd$EDK_PATH source edksetup.sh build -p $EDK_PATH/EmulatorPkg/EmulatorPkg.dsc -t GCC5 -a X64
First, compile and install QEMU. Here, I choose version 8.1.5. If your version is not working as expected, consider using QEMU version 8.1.5.
1 2 3 4 5 6 7 8 9 10 11 12
git clone https://gitlab.com/qemu-project/qemu.git cd qemu git checkout stable-8.1 sudo apt install python3-venv python3-pip python3-setuptools python3-sphinx ninja-build pkg-config libglib2.0-dev libpixman-1-dev # x86_64 ./configure --target-list=x86_64-softmmu make -j$(nproc) sudo make install # aarch64 ./configure --target-list=aarch64-softmmu make -j$(nproc) sudo make install
Next, write a script to run with QEMU. Some parameters here are for debugging the program with GDB in the next section, but if you just want to run with QEMU, it won’t affect the operation.
export GCC5=/usr/bin/gcc # Compiled once, no need to compile again cd$EDK_PATH source edksetup.sh build -a X64 -p OvmfPkg/OvmfPkgX64.dsc -t GCC5 -b DEBUG #-D SOURCE_DEBUG_ENABLE
cd$APP_PATH mkdir -p _ovmf_dbg cd _ovmf_dbg rm -f debug.log # The default QEMU from Ubuntu 22.04 repo is not compatible; we need to upgrade to QEMU v8.1.5 cp$EDK_PATH/Build/OvmfX64/DEBUG_GCC5/FV/OVMF.fd ./
This script first compiles the OVMF (Open Virtual Machine Firmware), which is a firmware based on EDKII that runs on QEMU x86-64 virtual machines. This makes debugging and experimenting with UEFI firmware easier, whether for testing OS booting or using the (built-in) EFI shell.
The OVMF firmware (for QEMU’s UEFI implementation) is divided into two files:
OVMF_CODE.fd: contains the actual UEFI firmware.
OVMF_VARS.fd: acts as a “template” for simulating persistent NVRAM storage. All virtual machine instances can share the read-only OVMF_CODE.fd file from the OVMF package, but each instance needs a private, writable copy of OVMF_VARS.fd. In QEMU, you can specify OVMF_CODE.fd and OVMF_VARS.fd separately, or use a simplified approach:
Run debug-x64.sh, and you should see the following interface, which is the UEFI Shell:
1 2 3 4 5 6 7 8 9 10 11 12
UEFI Interactive Shell v2.2 EDK II UEFI v2.70 (EDK II, 0x00010000) Mapping table FS0: Alias(s):HD0a1:;BLK1: PciRoot(0x0)/Pci(0x1,0x1)/Ata(0x0)/HD(1,MBR,0xBE1AFDFA,0x3F,0xFBFC1) BLK0: Alias(s): PciRoot(0x0)/Pci(0x1,0x1)/Ata(0x0) BLK2: Alias(s): PciRoot(0x0)/Pci(0x1,0x1)/Ata(0x0) Press ESC in 2 seconds to skip startup.nsh or any other key to continue. Shell>
In this shell, type fs0: (note the English colon), then type HelloWorld.efi to run your program, and the expected output should be “Hello World!!!”
If the Backspace key doesn’t respond in the shell, try using Ctrl+H instead
# No need to compile again after one successful compilation cd$EDK_PATH source edksetup.sh build -a AARCH64 -p ArmVirtPkg/ArmVirtQemu.dsc -t GCC5 -b RELEASE
cd$APP_PATH/$INF_NAME mkdir -p _armvirt_dbg cd _armvirt_dbg rm -f debug.log # Ubuntu 22.04 default QEMU is incompatible, need to upgrade QEMU to version 8.1.5
Debugging UEFI programs using gdb can be a bit tricky, but it can be automated with scripts. The general process is as follows:
Run debug.sh, then enter UEFI Shell and run the following code (same as using QEMU in the previous section; this is mainly to capture the driver startup address in _ovmf_dbg/debug.log).
Open another terminal and run the script addr.sh below.
Run gdb -x gdb_commands.txt in the _ovmf_dbg/UEFI_Disk directory.
Set a breakpoint in GDB, e.g., break UefiMain.
Add the GDB debug target target remote localhost:1234.
Run and type c to continue to the first breakpoint.
# Use regular expression to extract the two addresses if [[ $line =~ Loading\ driver\ at\ (0x[0-9a-fA-F]+)\ EntryPoint=(0x[0-9a-fA-F]+)\ $INF_BASE_NAME\.efi ]]; then address0="${BASH_REMATCH[1]}" address1="${BASH_REMATCH[2]}" echo"Loading driver at $address0" echo"EntryPoint=$address1" else echo"Error: No matching line found, maybe you need to run $INF_BASE_NAME in qemu first" exit 0 fi
cd UEFI_Disk
# Use objdump to get file header info and extract .text and .data File offsets text_offset=$(objdump -h "$INF_BASE_NAME.efi" | awk ' /\.text/ {print $6} # Extract .text File offset ')
# Output the file content for verification echo"gdb_commands.txt has been created with the following content:" printf"\n" cat gdb_commands.txt printf"\n" echo"Run the following command to debug:" echo"cd _ovmf_dbg/UEFI_Disk" echo"gdb -x gdb_commands.txt" echo"break UefiMain" echo"target remote localhost:1234" echo"c"
HelloStd
Another example, using edk-libc to implement a program that calls the standard C library in UEFI.
You can copy HelloWorld.dsc, modify the GUID, and make sure to change the [Components] section to HelloWorld.inf. Finally, add the following line to the [LibraryClasses] section at the end: HelloStd.dsc
1
!include StdLib/StdLib.inc
Next, for HelloStd.inf, modify the ENTRY_POINT in the [Defines] section to ShellCEntryLib, and in the [Packages] section, add the StdLib/StdLib.dec and ShellPkg/ShellPkg.dec packages. In the [LibraryClasses], remove UefiApplicationEntryPoint, and add the LibC and LibStdio libraries. Below is the declaration of HelloStd.inf:
# Variables defined to be used during the build process [Defines] INF_VERSION = 1.25 BASE_NAME = HelloStd FILE_GUID = d0956d2b-c033-45af-8ef2-76c9d30518ec MODULE_TYPE = UEFI_APPLICATION VERSION_STRING = 1.0 ENTRY_POINT = ShellCEntryLib
]]>Setting up a UEFI development environment in Linux with compilation and debugging scripts, supporting x64 and aarch64 architectures.Emacshttps://even629.com/en/posts/28520/2025-01-09T08:18:13.000Z2025-01-09T08:18:13.000ZCommonly used selection commands
Command
Name
Effect
M - h
mark-paragraph
Select a paragraph
C - x + C - p
mark-page
Select the entire page
C - x h
mark-whole-buffer
Select the entire content of the editing window
M - y
yank-pop
After C - y, paste previous items in the clipboard
Location of Emacs configuration files on Windows
On Windows, the .emacs file may be called _emacs for backward compatibility with DOS and FAT filesystems where filenames could not start with a dot. Some users prefer to continue using such a name because Explorer cannot create a file with a name starting with a dot, even though the filesystem and most other programs can handle it. In Emacs 22 and later, the init file may also be called .emacs.d/init.el. Many of the other files created by Lisp packages are now stored in the .emacs.d directory too, so this keeps all your Emacs-related files in one place.
All the files mentioned above should go in your HOME directory. The HOME directory is determined by following the steps below:
If the environment variable HOME is set, use the directory it indicates.
If the registry entry HKCU\SOFTWARE\GNU\Emacs\HOME is set, use the directory it indicates.
If the registry entry HKLM\SOFTWARE\GNU\Emacs\HOME is set, use the directory it indicates. Not recommended, as it results in users sharing the same HOME directory.
If C:.emacs exists, then use C:. This is for backward compatibility, as previous versions defaulted to C:\ if HOME was not set.
Use the user’s AppData directory, usually a directory called Application Data under the user’s profile directory, the location of which varies according to Windows version and whether the computer is part of a domain.
That is to say, there are three formats for Emacs configuration files: the .emacs file, the _emacs file, or the init.el file in the .emacs.d directory (for version 22 or higher). However, no matter which format is used, Emacs can only find the configuration file if it is placed in the correct directory, which is the HOME directory.
Friends familiar with Linux generally know the home directory, which is simply represented by ~ or the full path /home/, where xxx represents the user name. So, on Linux, just place .emacs and .emacs.d in this directory. However, Windows does not have the concept of a home directory, so Emacs searches for configuration files as follows:
If the HOME environment variable is set, use its value as the home directory ~.
If the registry key HKCU\SOFTWARE\GNU\Emacs\HOME exists, use its value as the home directory ~.
If the registry key HKLM\SOFTWARE\GNU\Emacs\HOME exists, use its value as the home directory ~ (the difference from 2 is that 2 is only for the current user’s registry path, while 3 is for all users).
If C:.emacs exists, use C:\ as the home directory ~.
If none of the above exist, use \Users\AppData\Roaming as the home directory ~ (for XP and earlier Windows users, you need to look in the Documents and Settings directory).
From the above strategies, method 1 is a better practice, so it has the highest priority and should be the recommended way. Therefore, create a new HOME environment variable and set its value to the place where you want to place the Emacs configuration files.
Previously, I set the HOME directory as described above, but now I regret it because I found that not only Emacs uses the HOME environment variable. At least the following programs or plugins also use this variable:
VIM, which places the _viminfo file in this directory.
The neocomplcache plugin for VIM, which places a .neocon directory in it.
The pentadactyl plugin for Firefox, which places a pentadactyl directory in it.
Therefore, personal suggestions are as follows:
If you want a common directory to store these configurations, just like the ~ directory on Linux, then setting the HOME environment variable is the most suitable option.
If you want this directory to store only Emacs configurations, then don’t use the HOME environment variable. Instead, add a HOME key value in the registry. (Personally, I prefer this method.)
That is:
Create a GNU item under HKEY_LOCAL_MACHINE\SOFTWARE, create an Emacs item under the GNU item, and then create a string value in Emacs with the key HOME and the value set to the path where you want to store the files.
Emacs tutorials
C: Ctrl M: Alt
Exit Emacs
C-x C-c
Exit a running command
C-g
Move to the next screen
C-v
Move to the previous screen
M-v
Redraw the screen and center the line where the cursor is located on the screen
C-l (here it is CTRL-L)
Basic cursor control
1 2 3 4 5 6 7
Previous line C-p : : Move left C-b .... Current cursor position .... Move right C-f : : Next line C-n
Each line of text ends with a “newline character”, which distinguishes one line from another. (Normally, the last line of a file has a newline character, but Emacs does not enforce this.)
Move to the previous line
Ctrl + p
Previous
Move to the next line
Ctrl + n
Next
Move one character to the left
Ctrl + b
Backward
Move one character to the right
Ctrl + f
Forward
Move the cursor forward one word
Here, a word refers to an English word in English text and means moving to the next punctuation mark in Chinese text.
Alt + f
Move the cursor backward one word
Alt + b
Move the cursor to the beginning of the line
Ctrl + a
Beginning of the line
Move the cursor to the end of the line
Ctrl + e
End of the line
Move the cursor to the beginning of a sentence
Alt + a
Move the cursor to the end of a sentence
Alt + e
Move the cursor to the very beginning of all the text
Most Emacs commands accept numerical parameters. For most commands, these numerical parameters are used to specify the number of times the command should be repeated.
First, enter C - u, then enter a number as a parameter, and finally enter the command.
For example: C - u 8 C - f will move the cursor forward by 8 characters.
Some Emacs commands use numerical parameters for other purposes.
For example: C - v and M - v. When given a parameter, they will scroll by the specified number of lines instead of screens. That is, C - u 8 C - v will move the cursor down by 8 lines.
Panes
Close redundant panes
C - x 1 Keep only one pane, which means closing all other panes, expanding the remaining pane to the entire screen, and closing all other panes at the same time.
There is a series of commands starting with CONTROL - x. Many of these commands are related to panes, files, buffers, etc.
Insertion
Insert multiple identical characters
C - u 8 ***** This will insert *********.
Deletion
Delete the character after the cursor
C - d delete Equivalent to the delete key on the keyboard.
Delete the word after the cursor
M - d
Delete the characters from the cursor to the end of the line
C - k kill
Delete the characters from the cursor to the end of the sentence
M - k
Note that the difference between “kill” and “delete” is that the killed text can be re - inserted (anywhere), while the deleted text cannot be re - inserted in the same way (although you can undo a delete command, which will be mentioned later). [In fact, although the killed text seems to “disappear”, it is actually recorded by Emacs and can be retrieved; while the deleted text may still be in memory, but it has been “discarded” by Emacs and cannot be retrieved.] Re - inserting the killed text is called “yanking”. Generally, commands that may delete a large amount of text will record the deleted text (they are set to be “yankable”), while commands that only delete one character or only delete whitespace will not record the deleted content (naturally, you cannot yank it).
Note that a single C - k will remove the content of a line, and the second C - k will remove the newline character and move all subsequent lines up. The way C - k handles numerical parameters is very special. It will remove the specified number of lines along with their newline characters, rather than simply repeating C - k. For example, C - u 2C - k will remove two lines and their newline characters; obviously, just entering C - k twice will not achieve this result.
Yank (Paste)
The action of re - inserting the removed text is called “yanking”. (It’s like pulling back something that was taken away from you forcefully.) You can yank at the place where you deleted the text, or at other places, and you can also yank the same text multiple times to get multiple copies. Many other editors call “kill” and “yank” “cut” and “paste”.
Yank the most recently removed content
C - y yanking
Yank the previously removed content
M - y You need to press C - y first and then M - y.
Undo
C - / Or C - _ or C - x u
Search
Emacs can search for strings (a “string” refers to a sequence of consecutive characters) forward or backward.
The search command is a command to move the cursor: after a successful search, the cursor will stay at the position where the search target appears.
Search forward
C - s During an incremental search, Emacs will try to jump to the position where the search target appears. To jump to the next match, press C - s again. If the target cannot be found, Emacs will beep to tell you that the search has failed. Throughout the process, you can use C - g to terminate the search. [You will find that C - g will move the cursor back to the starting position of the search, while will leave the cursor at the search result, which is a very useful feature.]
Search backward
C - r
Replace
M - % When replacing, press y to confirm the replacement, n to skip the current replacement, and! to replace all.
Files
Find a file
C - x C - f
Save a file
C - x C - s This command saves the text in Emacs to a file. When saving a file for the first time, Emacs will rename the original file for backup. The renaming rule is usually to add a “~” character after the original file name. You can turn off this feature.
Buffers
Emacs stores each file being edited in a place called a “buffer”. Every time you find a file, Emacs creates a buffer inside. You can list all the current buffers with the following command:
C - x C - b List buffers
Enter C - x 1 to leave the buffer list.
Regardless of how many buffers there are, there can only be one “current” buffer at any time, which is the one you are currently editing. If you want to edit another buffer, you must “switch” to it. As mentioned above, using C - x C - f is one way. However, there is a simpler way, which is to use C - x b. With this command, you must enter the name of the buffer.
In most cases, the buffer has the same name as its corresponding file (excluding the directory name), but this is not absolute. The buffer list obtained by C - x C - b always shows the buffer names.
A buffer does not necessarily have a corresponding file. The buffer that displays the buffer list (called “Buffer List“) is such an example. The TUTORIAL.cn buffer initially did not have a corresponding file, but now it does because in the previous section you entered C - x C - s to save it as a file.
The “Messages“ buffer also does not have a corresponding file. This buffer stores all the messages that appear at the bottom of Emacs.
If you make some changes to a file and then switch to another file, this action will not save the previous file for you. The changes to the first file still only exist in Emacs, that is, in its corresponding buffer. Moreover, the changes to the second file will not affect the first file. This is very useful, but it also means that you need a convenient way to save the buffer of the first file. Switching back to that buffer and then using C - x C - s to save it is too troublesome. You need a simpler method, and Emacs has already prepared one for you:
C - x s Save multiple buffers
C - x s will find all the buffers that have been modified but not saved, and then ask you one by one: Do you want to save them?
Command Set Extension
The number of Emacs commands is as countless as the stars in the sky. It is obviously impossible to map them all to the CONTROL and META key combinations. Emacs uses extension (eXtend) commands to solve this problem. There are two styles of extension commands:
1 2
C - x Character extension. Enter another character or key combination after C - x. M - x Command name extension. Enter a command name after M - x.
Line Sorting
M-x sort-lines
Word Counting
Count the entire buffer
M-x count-words-region
Count the selected region
M-x count-words
Automatic Saving
If you have modified a file but your computer crashes before you can save it, the changes you made are likely to be lost. To avoid such an unfortunate situation, Emacs periodically writes the file you are editing into an “automatic save” file. The file name of the automatic save file has a “#” character at both the beginning and the end. For example, if the file you are editing is called “hello.c”, then its automatic save file is called “#hello.c#”. This file will be deleted by Emacs after a regular save.
So, if such an unfortunate event does occur, you can calmly open the original file (note that it’s not the automatic save file) and then enter M-x recover-file <Return> to restore your automatic save file. When prompted for confirmation, enter yes <Return>.
Status Bar
The line directly above the echo area is called the “status bar”. The status bar displays some information, such as:
-:**- TUTORIAL.cn 63% L749 (Fundamental)
The status bar shows the status of Emacs and some information about the text you are editing.
You should know what the file name means, right? It’s the file you found.
-NN%– indicates the position of the cursor in the entire text. If it’s at the beginning of the file, it shows –Top– instead of –00%–; if it’s at the end of the file, it shows –Bot–. If the file is small enough to be displayed entirely on one screen, the status bar will show –All–.
The “L” followed by a number gives the line number where the cursor is located.
The asterisk (*) at the very beginning indicates that you have made changes to the text. A newly opened file definitely hasn’t been modified, so the status bar shows a dash (-) instead of an asterisk.
The content in the parentheses on the status bar tells you the current editing mode. The default mode is Fundamental, which is the one you are currently using. It is a “major mode”.
Modes
Major modes are all extended commands that can be launched with M-x. You can switch to the Fundamental mode by using M-x fundamental-mode.
M-x text-mode <Return>: Switch to text mode.
You can view the documentation of the current major mode by using C-h m. Enter C-x 1 to close the documentation pane.
Major modes are called “major” because there are also “minor modes” at the same time. Minor modes cannot replace major modes but provide some auxiliary functions. Each minor mode can be independently enabled and disabled, regardless of other minor modes and the major mode. So you can choose not to use minor modes, or use only one or multiple minor modes simultaneously.
A minor mode called “Auto Fill” is very useful, especially when editing natural language text. After enabling Auto Fill, Emacs will automatically insert a line break when you type beyond the line boundary.
Use M-x auto-fill-mode <Return> to start the Auto Fill mode. Using this command again will turn off the Auto Fill mode. That is to say, if the Auto Fill mode is not enabled, this command will enable it; if it is already enabled, this command will disable it. Therefore, we say that this command can be used to “toggle” the mode.
The line boundary is usually set to 70 characters (here referring to English characters). You can use the C-x f command with a numeric parameter to reset it.
If you make some changes in the middle of a paragraph, the Auto Fill mode will not re-wrap the entire paragraph for you. You need to manually re-wrap it using M-q. Note that the cursor must be within the paragraph you want to re-wrap.
Window Management
Switch buffers
C-x b
Kill the current buffer
C-x k
Manage buffers in bulk
C-x C-b ;; Enter the buffer list
d ;; Mark for deletion
u ;; Unmark the current line
U ;; Unmark all lines
x ;; Execute the operation
? ;; View key help
Multiple Panes (Split Screen)
Divide the screen into two panes
C-x 0
Close the current split screen
C-x 1
Keep only the current split screen
C-x 2
Split the screen vertically
C-x 3
Split the screen horizontally
Adjust the width of split screens
Increase the height: C-x ^
Increase/decrease the width: C-x {C-x }
Move the cursor to another pane
C-x o
Here, “o” means “other”.
When you are editing in one pane and using another pane as a reference, the C-M-v command is very useful. You can use the C-M-v command to scroll the text in another pane without leaving the selected pane. [For example, translation and proofreading are very suitable to be done in this way.]
(In the upper pane) Enter C-x 1 to close the lower pane.
When there are many split screens, the efficiency is very low. You can use the ace-window plugin to quickly jump between windows. There are many similar plugins, but this one is the best solution.
Emacs provides some commands to view the documentation of Emacs commands. These commands all start with CONTROL-h, and this character is therefore called the “Help character”.
The most basic help function is C-h c. After entering C-h c and then a key combination, Emacs will give a brief description of this command.
Enter C-h c C-p.
The displayed message should be like this:
C-p runs the command previous-line
This message shows the function name corresponding to the C-p command. The function of a command is implemented by a function, so the function name itself can also be regarded as the simplest documentation - at least for the commands you have learned, their function names are sufficient to explain their functions.
If you want more information, try replacing C-h c with C-h k.
Enter C-h k C-p.
The above command will open a new Emacs pane to display the function name and its documentation. After you finish reading, you can use C-x 1 to close this help pane. Of course, you don’t need to do this immediately. You can first do something else in the editing pane and then close the help pane.
C-h f explains a function. You need to enter the function name.
Enter C-h f previous-line . Emacs will give all the information it knows about “the function that implements the C-p command”.
C-h v is used to display the documentation of Emacs variables. Emacs variables can be used to “customize the behavior of Emacs”. Similarly, you need to enter the name of the variable.
C-h a is for Command Apropos. Enter a keyword and Emacs will list all commands whose names contain this keyword. All these commands can be launched with M-x. For some commands, the Command Apropos will also list one or two key combinations.
Enter C-h a file .
Emacs will display a list of M-x commands in another pane. This list contains all commands whose names contain “file”. You can see key combinations like “C-x C-f” displayed next to command names like “find-file”.
C-h i is for reading the manual (usually referred to as Info). This command will open a special buffer called “info“, where you can read the usage manuals of the software packages installed in the system. To read the Emacs usage manual, press m emacs . If you have never used the Info system before, press “?” and Emacs will guide you through the Info usage guide. After reading this quick guide, Emacs Info will become your main reference document.
