Download to read offline
![[YIDLUG] Programming Languages Differences, The Underlying Implementation 1 of 2](https://cdn.slidesharecdn.com/ss_thumbnails/presentationpart1-130721150408-phpapp02-thumbnail.jpg?width=640&height=640&fit=bounds)
Low Level Prog. (from 201-c).ppt
- 1. Signed and unsignedvariables The difference between signed and unsigned variables is that signed variables can be either negative or positive but unsigned variables can only be positive. By using an unsigned variable you can increase the maximum positive range. When you declare a variable in the normal way it is automatically a signed variable. To declare an unsigned variable you just put the word unsigned before your variable declaration or signed for a signed variable although there is no reason to declare a variable as signed since they already are. Signed Range Unsigned Range char -128 to 127 unsigned char 0 to 255 int -32768 to 32,767 unsigned int 0 to 65,535
- 2. Declaration of StorageClass Variables in C have not only the data type but also storage class that provides information about their location and visibility. The storage class divides the portion of the program within which the variables are recognized. auto : It is a local variable known only to the function in which it is declared. Auto is the default storage class. static : Local variable which exists and retains its value even after the control is transferred to the calling function. extern : Global variable known to all functions in the file register : Social variables which are stored in the register.
- 3. auto - storageclass auto is the default storage class for local variables. { int Count; auto int Month; } The example above defines two variables with the same storage class. auto can only be used within functions, i.e. local variables.
- 4. register - StorageClass register is used to define local variables that should be stored in a register instead of RAM. This means that the variable has a maximum size equal to the register size (usually one word) and can’t have the unary '&' operator applied to it (as it does not have a memory location). { register int Miles; } Register should only be used for variables that require quick access - such as counters. It should also be noted that defining 'register' goes not mean that the variable will be stored in a register. It means that it MIGHT be stored in a register - depending on hardware and implimentation restrictions.
- 5. static - StorageClass static is the default storage class for global variables. The two variables below (count and road) both have a static storage class. static int Count; int Road; main() { printf("%dn", Count); printf("%dn", Road); }
- 6. extern - storageClass extern defines a global variable that is visible to ALL object modules. Source 1 Source 2 ------------ ------------ extern int count; int count=5; write() main() { { printf("count is %dn", count); write(); } } Count in 'source 1' will have a value of 5. If source 1 changes the value of count - source 2 will see the new value.
- 7. Register Variables Register variablesare a special case of automatic variables. Automatic variables are allocated storage in the memory of the computer. These computers often have small amounts of storage within the CPU itself where data can be stored and accessed quickly. These storage cells are called registers. Normally, the compiler determines what data is to be stored in the registers of the CPU at what times. However, the C language provides the storage class register so that the programmer can ``suggest'' to the compiler that particular automatic variables should be allocated to CPU registers, if possible. Thus, register variables provide a certain control over efficiency of program execution. Variables which are used repeatedly or whose access times are critical, may be declared to be of storage class register.
- 8. Register variables behavein every other way just like automatic variables. They are allocated storage upon entry to a block; and the storage is freed when the block is exited. The scope of register variables is local to the block in which they are declared. Rules for initializations for register variables are the same as for automatic variables. As stated above, the register class designation is merely a suggestion to the compiler. Not all implementations will allocate storage in registers for these variables, depending on the number of registers available for the particular computer, or the use of these registers by the compiler. They may be treated just like automatic variables and provided storage in memory.
- 9. Finally, even theavailability of register storage does not guarantee faster execution of the program. For example, if too many register variables are declared, or there are not enough registers available to store all of them, values in some registers would have to be moved to temporary storage in memory in order to clear those registers for other variables. Thus, much time may be wasted in moving data back and forth between registers and memory locations.
- 10. When should youuse bitwise operators? Bitwise operators are good for saving space – In computer programming, a bitwise operation operates on one or two bit patterns or binary numerals at the level of their individual bits. On most microprocessors. bitwise operations are usually slightly faster than addition and subtraction operations and usually significantly faster than multiplication and division operations. There are also times when you need to use bitwise operators: if you're working with compression or some forms of encryption, or if you're working on a system that expects bit fields to be used to store boolean attributes.
- 11. Bitwise operations & AND |OR ^ XOR ~ one's compliment << Shift Left >> Shift Right DO NOT confuse & with &&: & is bitwise AND, && logical AND. Similarly for | and || . ~ is a unary operator -- it only operates on one argument to right of the operator. The shift operators perform appropriate shift by operator on the right to the operator on the left. The right operator must be positive. The vacated bits are filled with zero (i.e. There is NO wrap around).
- 12. 0000 0 10008 0001 1 1001 9 0010 2 1010 a 0011 3 1011 b 0100 4 1100 c 0101 5 1101 d 0110 6 1110 e 0111 7 1111 f
- 13. AND The bitwise operatorsoperate on numbers (always integers) as if they were sequences of binary bits (which, of course, internally to the computer they are). These operators will make the most sense, therefore, if we consider integers as represented in binary, octal, or hexadecimal (bases 2, 8, or 16), not decimal (base 10). Remember, you can use octal constants in C by prefixing them with an extra 0 (zero), and you can use hexadecimal constants by prefixing them with 0x (or 0X). The & operator performs a bitwise AND on two integers. Each bit in the result is 1 only if both corresponding bits in the two input operands are 1. For example, 0x56 & 0x32 is 18, because (in binary): 0 1 0 1 0 1 1 0 & 0 0 1 1 0 0 1 0 ------------------- 0 0 0 1 0 0 1 0
- 14. OR The | (verticalbar) operator performs a bitwise OR on two integers. Each bit in the result is 1 if either of the corresponding bits in the two input operands is 1. For example, 0x56 | 0x32 is 118, because: 0 1 0 1 0 1 1 0 | 0 0 1 1 0 0 1 0 ------------------- 0 1 1 1 0 1 1 0
- 15. XOR The ^ (caret)operator performs a bitwise exclusive-OR on two integers. Each bit in the result is 1 if one, but not both, of the corresponding bits in the two input operands is 1. For example, 0x56 ^ 0x32 is 100: 0 1 0 1 0 1 1 0 ^ 0 0 1 1 0 0 1 0 ------------------- 0 1 1 0 0 1 0 0
- 16. one's compliment The ~(tilde) operator performs a bitwise complement on its single integer operand. Complementing a number means to change all the 0 bits to 1 and all the 1s to 0s. For example, assuming 16-bit integers, ~0x56 is 0xffa9: ~ 0 0 0 0 0 0 0 0 0 1 0 1 0 1 1 0 ---------------------------------------- 1 1 1 1 1 1 1 1 1 0 1 0 1 0 0 1
- 17. Bit shifts The bitshifts are sometimes considered bitwise operations, since they operate on the binary representation of an integer instead of its numerical value; however, the bit shifts do not operate on pairs of corresponding bits, and therefore cannot properly be called bit-wise operations.
- 19. In an arithmeticshift, the bits that are shifted out of either end are discarded. In a left arithmetic shift, zeros are shifted in on the right; in a right arithmetic shift, the sign bit is shifted in on the left, 00010111 LEFT-SHIFT = 00101110 00010111 RIGHT-SHIFT = 00001011
- 20. In the firstcase, the leftmost digit was shifted past the end of the register, and a new 0 was shifted into the rightmost position. In the second case, the rightmost 1 was shifted out and a new 0 was copied into the leftmost position, preserving the sign of the number. Multiple shifts are sometimes shortened to a single shift by some number of digits. For example: 00010111 LEFT-SHIFT-BY-TWO = 01011100
- 21. The << operatorshifts its first operand left by a number of bits given by its second operand, filling in new 0 bits at the right. Similarly, the >> operator shifts its first operand right. If the first operand is unsigned, >> fills in 0 bits from the left. (it's usually a good idea to use all unsigned operands when working with the bitwise operators.) For example, 0x56 << 2 is 0x158: 0 1 0 1 0 1 1 0 << 2 ------------------------ 0 1 0 1 0 1 1 0 0 0 And 0x56 >> 1 is 0x2b: 0 1 0 1 0 1 1 0 >> 1 ------------------- 0 1 0 1 0 1 1
- 22. if x =00000010 (binary) or 2 (decimal) then: or 0 (decimal) Also: if x = 00000010 (binary) or 2 (decimal) or 8 (decimal) Therefore a shift left is equivalent to a multiplication by 2. Similarly a shift right is equal to division by 2 NOTE: Shifting is much faster than actual multiplication (*) or division (/) by 2. So if you want fast multiplications or division by 2 use shifts.
- 23. To illustrate manypoints of bitwise operators let us write a function, Bitcount, that counts bits set to 1 in an 8 bit number (unsigned char) passed as an argument to the function. int bitcount(unsigned char x) { int count; for (count=0; x != 0; x>>=1); if ( x & 01) count++; return count; } This function illustrates many C program points: •x x = x >> 1 •for loop will repeatedly shift right x until x becomes 0 •use expression evaluation of x & 01 to control if •x & 01 masks of 1st bit of x if this is 1 then count++
- 24. Bit Fields Bit Fieldsallow the packing of data in a structure. This is especially useful when memory or data storage is at a premium. Typical examples: •Packing several objects into a machine word. e.g. 1 bit flags can be compacted •Reading external file formats -- non-standard file formats could be read in. E.g. 9 bit integers. C lets us do this in a structure definition by putting :bit length after the variable. i.e. struct packed_struct { unsigned int f1:1; unsigned int f2:1; unsigned int f3:1; unsigned int f4:1; unsigned int type:4; unsigned int funny_int:9; } pack;
- 25. Here the packed_structcontains 6 members: Four 1 bit flags f1..f4, a 4 bit type and a 9 bit funny_int. C automatically packs the above bit fields as compactly as possible, provided that the maximum length of the field is less than or equal to the integer word length of the computer. If this is not the case then some compilers may allow memory overlap for the fields while other would store the next field in the next word (see comments on bit fiels portability below). Access members as usual via: pack.type = 7; NOTE: •Only n lower bits will be assigned to an n bit number. So type cannot take values larger than 15 (4 bits long). •Bit fields are always converted to integer type for computation. •You are allowed to mix ``normal'' types with bit fields. •The unsigned definition is important - ensures that no bits are used as a flag.
- 26. A note ofcaution: Portability Bit fields are a convenient way to express many difficult operations. However, bit fields do suffer from a lack of portability between platforms: integers may be signed or unsigned. Many compilers limit the maximum number of bits in the bit field to the size of an integer which may be either 16-bit or 32-bit varieties. Some bit field members are stored left to right others are stored right to left in memory. If bit fields too large, next bit field may be stored consecutively in memory (overlapping the boundary between memory locations) or in the next word of memory.
- 27. Bit Fields: PracticalExample Frequently device controllers (e.g. disk drives) and the operating system need to communicate at a low level. Device controllers contain several registers which may be packed together in one integer. struct DISK_REGISTER { unsigned ready:1; unsigned error_occured:1; unsigned disk_spinning:1; unsigned write_protect:1; unsigned head_loaded:1; unsigned error_code:8; unsigned track:9; unsigned sector:5; unsigned command:5; };