Far and huge pointers


Far pointer:
Size of the far pointer is 4 bytes and it can point to 1MB of memory.
4 bytes = 32 bits

Far pointer has a 16 bit segment address and a 16 bit offset value.  Below is the declaration for far pointer
char far *ptr;

Consider, a 32 bit address is stored in far pointer.
char far *ptr = 0x82340005

Here, the 16 bit segment address is 0x8234 and offset value is 0x0005.  So, below is the segment offset pair for 0x82340005
segment:offset = 0x8234:0x0005

Let us see how to convert segment offset pair to 20-bit physical address.
Left shift the segment address by 4 bit = 0x8234 << 0x4 = 0x82340

Now, add the left shifted segment address and offset value to get 20 bit physical address.
20 bit physical address = (left shifted segment address)0x82340 + (offset)0x0005
                                  = 0x82345

The above expression can also be written as follows:
20 bit physical address = (segment address) * (0x10) + offset value
                                    = 0x8234 * 0x10 + 0x0005
                             = 0x82340 + 0x0005 = 0x82345

Consider the following,
char far *ptr1 = 0x82300045;
char far *ptr2 = 0x82200145;

If we convert the above 32 bit addresses to 20 bit physical addressing, both of them points to same location.

But, if you check whether ptr1 equals to ptr2, the condition would fail.  Because, the whole 32 bit address would be used for comparing far pointers using == or !=.

Only offset value will be used for far pointer comparison if the conditional operator is other than ==(equal to) or !=(not equal to). (ie) >, <, >=, <=.  Huge pointer is used in order to overcome the above limitation.

  #include <stdio.h>
  int main() {
       char far *ptr1 = (char far *)0x82340015;
       char far *ptr2 = (char far *)0x82350005;
       printf("Size of far pointer is %d\n", sizeof(ptr1));
       if (ptr1 == ptr2)
              printf("ptr1 and ptr2 are same!!\n");
       else
              printf("ptr1 and ptr2 are not same!!\n");
       if (ptr1 < ptr2)
              printf("ptr1 is less than ptr2!!\n");
       else
              printf("ptr2 is less than ptr1!!\n");
       return 0;
  }

  Output:
  Size of far pointer is 4
  ptr1 and ptr2 are not same!!
  ptr2 is less than ptr1!!

Huge pointer:
Size of huge pointer is 4 bytes and it can also point to 1 MB of data.
4 bytes = 32 bits

Below is the declaration for huge pointer.
char huge *ptr;

Huge pointer has 16 bit segment address and 16 bit offset value similar to far pointers.

But, huge pointers are normalized pointers.  Let us see how the normalization takes place from the below example.
char huge *ptr1 = 0x82300045;
char huge *ptr2 = 0x82200145;

Convert the above addresses to 20 bit addressing format.
20 bit address of 0x82300045  = 0x8230 * 0x10 + 0x0045 = 0x82345
20 bit address of 0x82200145  = 0x8220 * 0x10 + 0x0145 = 0x82345

Now, split 20 bit address into two parts.  16 bits for segment address and remaining 4 bits for offset.

20 bit address of 0x82300045 is 0x82345
Splitting 20 bit address into two parts - 0x8234(segment address):0x0005(offset value)
Then, the segment offset value pair for 0x82300045 is 0x8234:0x0005

Similarly, 20 bit address of 0x82300145 is 0x82345
Splitting 20 bit address into two parts - 0x8234(segment address):0x0005(offset value)
Then, the segment offset value for 0x82200145 is 0x8234:0x0005

So, the normalized value for 0x82300045 and 0x82200145 is 0x82340005

Now, if you check whether ptr1 is equal to ptr2, the result would be positive.  Because, the normalized value for both 0x82300045 and 0x82200145 is 0x82340005(32 bit address). The same is applicable(32 bit comparison) for other conditional operators too.

In huge pointer, most of the address part is available in segment address.  Whereas, offset has only 4 bit information(ie) offset will have any value from 0 to 0xF.  In our case, offset is 0x0005.  This resolves the limitation of far pointer.

  #include <stdio.h>
  int main() {
   

Comments

Post a Comment

Popular posts from this blog

Difference between asterisk and ampersand operators in c

Address Operator (& - Ampersand): Returns address of the given variable.  Consider the following example, int *ptr, var = 10; ptr = &var; ptr = &var sets the address of the variable var to pointer ptr.  & is also called as reference operator. Let us try to understand the purpose of reference operator using the following example program.   #include <stdio.h>   int main() {         int var = 10, *ptr;         /* assigning address of variable var to pointer ptr */         ptr = &var;         /* printing the address of the variable var */         printf("Address of var is 0x%x\n", &var);         /* printing the value of pointer ptr */         printf("Value of ptr is 0x%x\n", ptr);         return 0;   }   Output:   jp@jp-VirtualBox:~/$ ./a.out   Address of var is 0xbfdf202c   Value of ptr is 0xbfdf202c Indirection Operator('*' - asterisk): The dereference operator is an unary operator which returns the value of
Read more

kbhit in c

kbhit in c: kbhit function is used to determine if a key has been pressed or not. To use kbhit function in your program you should include the header file "conio.h". If a key has been pressed then it returns a non zero value otherwise returns zero. Declaration : int kbhit(); C programming code for kbhit #include <stdio.h> #include <conio.h> main() {    while (!kbhit())       printf("You haven't pressed a key.\n");    return 0; } As long as in the above program user doesn't presses a key kbhit() return zero and (!0) i.e. 1 the condition in while loop is true and "You haven't pressed a key." will be printed again and again. As a key is pressed from the keyboard the condition in while loop become false as now kbhit() will return a non-zero value and ( !(non-zero) = 0), so the control will come out of the while loop.
Read more