You just started working for a company that is implementing a set of procedures to operate on a data structure where 4 signed bytes are packed into a 32-bit unsigned. Bytes within the word are numbered from 0 (least significant) to 3
(most significant). You have been assigned the task of implementing a function for a machine using two’s-complement arithmetic and arithmetic right shifts with the following prototype:
/* Declaration of data type where 4 bytes are packed
into an unsigned */
typedef unsigned packed_t;
/* Extract byte from word. Return as signed integer */
int xbyte (packed_t word, int bytenum);
That is, the function will extract the designated byte and sign extend it to be a 32-bit int.
Your predecessor (who was fired for incompetence) wrote the following code:
/* Failed attempt at xbyte */
int xbyte (packed_t word, int bytenum)
{
return (word >>(bytenum <<3)) & 0xFF;
}
- A. What is wrong with this code?
- B. Give a correct implementation of the function that uses only left and right shifts, along with one subtraction.
Want to see the full answer?
Check out a sample textbook solutionChapter 2 Solutions
Computer Systems: A Programmer's Perspective (3rd Edition)
Additional Engineering Textbook Solutions
Experiencing MIS
Java: An Introduction to Problem Solving and Programming (8th Edition)
Starting Out with Programming Logic and Design (4th Edition)
Concepts of Programming Languages (11th Edition)
Introduction to Programming Using Visual Basic (10th Edition)
Starting Out with Java: From Control Structures through Objects (6th Edition)
- // Task 3 // For this function, you must return the largest power of 2 that // is less than or equal to x (which will be positive). You may // not use multiplication or some sort of power function to do this, // and should instead rely on bitwise operations and the underlying // binary representation of x. If x is 0, then you should return 0. unsigned largest_po2_le(unsigned x) { return x; }arrow_forwardI could use some help converting this problem into code for IA32 x86 Assembly floatIsEqual - Compute f == g for floating point arguments f and g. Both the arguments are passed as unsigned int's, but they are to be interpreted as the bit-level representations of single-precision floating point values. If either argument is NaN, return 0 +0 and -0 are considered equal.arrow_forwardThis problem covers floating-point IEEE 754 format. 1)List four floating-point operations that cause NaN to be created? 2) In the 32-bit (single precision) IEEE 754 format, what is the encoding for negative zero? 3) In the 32-bit (single precision) IEEE 754 format, what is the encoding for positive infinity? 4) Assuming 32-bit (single precision) IEEE 754 format, what decimal number is represent by this word: 1 01111101 00100000000000000000000arrow_forward
- For each of the following C functions (given as function prototypes), which register is used to pass each of the parameters? Which register(s) is used to pass the return value? Note: uint64_t is unsigned 64-bit integer. a-short add2(short a, short b); b-uint16_t add3(uint8_t a, uint8_t b, uint8_t c); c-unsigned fibonacci(unsigned n); d-char* mystrcmp(char *dst, char *src) e-uint64_t sumOfArray(uint32_t X[], int N);arrow_forwardWrite a C-function with two arguments (n and r) that has prototype: char clearbit(char k, char bits) The function clears (sets to 0) the bit number k (in the range of 0 to 7) in bits and returns the resulting value. For example, if k is 0x02 and bits is 0x07, the function would return bits with its k’th bit cleared, resulting in 0x03. It must not change other bits in bits. Hint: You may use any number of C-statements, but this task can be accomplished in as few as one!arrow_forwardSuppose we number the bytes in a w-bit word from 0 (least significant)to w/8 −1 (most significant).Write code for the following C function, which will return an unsignedvalue in which byte i of argument x has been replaced by byte b:unsigned replace byte (unsigned x, int i, unsigned char b);Examples:replace byte(0x12345678, 2, 0xAB) → 0x12AB5678replace byte(0x12345678, 0, 0xAB) → 0x123456ABarrow_forward
- Write a MIPS program that will handle calculating minifloat addition for two numbers using the rules discussed in class and storing each of the parts as a binary integer. To do this, each ‘minifloat’ number will need to be represented (I suggest hard coded) as one register for the sign, one for the exponent part, one for the ‘significand’ (which you then convert to the fraction part). Hard coding means here that you don’t need to read in the 6 parts as user input, just have something like li $s0, 0 li $s1, 12 li $s2, 5 which is equivalent to a minifloat of 0 1101 101 = 1.101 * 2^(12-7) = 1.101*2^5 This means your program will be work with at least 6 registers as variables. For testing, show that your program can correctly calculate the Lab 5 X+Y and A+B and then one other example of your choosing. Don’t worry about special cases of 0 0000 000 or 1 1111 111 or similar, but your program should detect overflow. This will involve a lot of (in your head) jumping back and forth between…arrow_forwardConsider an 8-bit floating point format. In this representation 4 bits are reserved for the mantissa and 3 bits are reserved for the exponent and 1 bit is reserved for the sign of the number. The exponent of the number is stored with a bias = 3. Express the decimal number 4.75 in this 8 bit floating point format. Write down the next bigger representable number in decimal base. B If you would be conducting the following operation using this 8 bit floating point format what would the result of the following calculation be ? 4.75 + 0.05 - 4.75 Express the decimal number 4.75 in this 8 bit floating point format. [10] b) Write down the next bigger representable number in decimal base. [7.5] c) If you would be conducting the following operation using this 8 bit floating point format what would the result of the following calculation be ? 4.75 + 0.05 - 4.75arrow_forwardIn the Hamming coding system (7.3), its representation is expressed as 3 control (test) bits and 7 total bits (data+control bits).In the literature, control bits are represented as (cl, c2, c3, or (pl, p2, p3, .) The bit string sent by encoding with Hamming coding (15,4) is on the receiving side, It is retrieved as 001100101100 (pl.p2.dll). According to this bit sequence;Which option is given according to the control bits (p1.p2.p3.p4) sequence of the received bit sequence?A 0110B 1100C 1001D 0011E 0010arrow_forward
- Give small description or example and indicate the format of the following MIPS functions:(The first two of them are examples) FormatFormatDescription lw $1,100($2)Iload word from $2+100 and put it in $1 and $1,$2,$3Gadd $2 and $3 and put the result in $1 | $1= $2+$3 Sw $1,100($2) la $1,label andi $1,$2,100 or $1,$2,100 srl $1,$2,10 li $1,100 move $1,$2 Beq $1,$2,100 Bne $1,$2,100 div $2,$3 Bgt $1,$2,100 addi $1,$2,100 addu $1,$2,$3arrow_forwardIn c++ Now write a program for a double floating pointtype.•What are the number of significant bits that the double’s mantissa can hold, excluding the sign bit.•What is the largest number that a double’s mantissa can hold without roundoff error?•Repeat the program shown on the previous page but set to show where the double’s mantissa starts to exhibit roundoff errors.arrow_forwardWrite a function int bitset(int x, int n) to set nth bit of x to 1, if its (n-1)th bit is 1. if n <1 or n >15, the function will return -1 to thecalling functionarrow_forward
- C++ for Engineers and ScientistsComputer ScienceISBN:9781133187844Author:Bronson, Gary J.Publisher:Course Technology Ptr