Generic Pointers

Generic pointers are declared like standard C pointers. For example:

char *s;       /* string ptr */
int *numptr;   /* int ptr */
long *state;   /* Texas */

Generic pointers are always stored using three bytes. The first byte is the memory type, the second is the high-order byte of the offset, and the third is the low-order byte of the offset. Generic pointers may be used to access any variable regardless of its location in 8051 memory space. Many of the Cx51 Compiler library routines use these pointer types for this reason. By using these generic pointers, a function can access data regardless of the memory in which it is stored.

The following code and assembly listing shows the values assigned to generic pointers for variables in different memory areas. Note that the first value is the memory space followed by the high-order byte and low-order byte of the address.

stmt level  source
   1        char *c_ptr;          /* char ptr */
   2        int  *i_ptr;          /* int ptr */
   3        long *l_ptr;          /* long ptr */
   4
   5        void main (void)
   6        {
   7   1    char data dj;         /* data vars */
   8   1    int  data dk;
   9   1    long data dl;
  10   1
  11   1    char xdata xj;        /* xdata vars */
  12   1    int  xdata xk;
  13   1    long xdata xl;
  14   1
  15   1    char code cj = 9;     /* code vars */
  16   1    int  code ck = 357;
  17   1    long code cl = 123456789;
  18   1
  19   1
  20   1    c_ptr = &dj;          /* data ptrs */
  21   1    i_ptr = &dk;
  22   1    l_ptr = &dl;
  23   1
  24   1    c_ptr = &xj;          /* xdata ptrs */
  25   1    i_ptr = &xk;
  26   1    l_ptr = &xl;
  27   1
  28   1    c_ptr = &cj;          /* code ptrs */
  29   1    i_ptr = &ck;
  30   1    l_ptr = &cl;
  31   1    }


ASSEMBLY LISTING OF GENERATED OBJECT CODE

      ; FUNCTION main (BEGIN)
                      ; SOURCE LINE # 5
                      ; SOURCE LINE # 6
                      ; SOURCE LINE # 20
0000 750000 R   MOV   c_ptr,#00H
0003 750000 R   MOV   c_ptr+01H,#HIGH dj
0006 750000 R   MOV   c_ptr+02H,#LOW dj
                      ; SOURCE LINE # 21
0009 750000 R   MOV   i_ptr,#00H
000C 750000 R   MOV   i_ptr+01H,#HIGH dk
000F 750000 R   MOV   i_ptr+02H,#LOW dk
                      ; SOURCE LINE # 22
0012 750000 R   MOV   l_ptr,#00H
0015 750000 R   MOV   l_ptr+01H,#HIGH dl
0018 750000 R   MOV   l_ptr+02H,#LOW dl
                      ; SOURCE LINE # 24
001B 750001 R   MOV   c_ptr,#01H
001E 750000 R   MOV   c_ptr+01H,#HIGH xj
0021 750000 R   MOV   c_ptr+02H,#LOW xj
                      ; SOURCE LINE # 25
0024 750001 R   MOV   i_ptr,#01H
0027 750000 R   MOV   i_ptr+01H,#HIGH xk
002A 750000 R   MOV   i_ptr+02H,#LOW xk
                      ; SOURCE LINE # 26
002D 750001 R   MOV   l_ptr,#01H
0030 750000 R   MOV   l_ptr+01H,#HIGH xl
0033 750000 R   MOV   l_ptr+02H,#LOW xl
                      ; SOURCE LINE # 28
0036 7500FF R   MOV   c_ptr,#0FFH
0039 750000 R   MOV   c_ptr+01H,#HIGH cj
003C 750000 R   MOV   c_ptr+02H,#LOW cj
                      ; SOURCE LINE # 29
003F 7500FF R   MOV   i_ptr,#0FFH
0042 750000 R   MOV   i_ptr+01H,#HIGH ck
0045 750000 R   MOV   i_ptr+02H,#LOW ck
                      ; SOURCE LINE # 30
0048 7500FF R   MOV   l_ptr,#0FFH
004B 750000 R   MOV   l_ptr+01H,#HIGH cl
004E 750000 R   MOV   l_ptr+02H,#LOW cl
                      ; SOURCE LINE # 31
0051 22               RET
      ; FUNCTION main (END)

In the above example listing, the generic pointers c_ptr, i_ptr, and l_ptr are all stored in the internal data memory of the 8051. However, you may specify the memory area in which a generic pointer is stored by using a memory type specifier. For example:

char * xdata strptr;     /* generic ptr stored in xdata */
int * data numptr;       /* generic ptr stored in data */
long * idata varptr;     /* generic ptr stored in idata */

These examples are pointers to variables that may be stored in any memory area. The pointers, however, are stored in xdata, data, and idata respectively.

Note

• The code generated for a generic pointer executes more slowly than the equivalent code generated for a memory-specific pointer because the memory area is not known until run-time. The compiler cannot optimize memory accesses and must generate generic code that can access any memory area. If execution speed is a priority, you should use memory-specific pointers instead of generic pointers wherever possible.