Question

Question 1: Pointers

1. You are given the following C code and memory diagram. The “contents” column of the memory diagram shows the value of the variable. Update the “contents” column of the memory diagram for each assignment in main().

long *pt;
long data;   
long buffer[4];
void main(void){
  pt = &buffer[1];
  *pt = 1234;
  data = *pt;
}

address      contents   variable
0x20000000 0x00000000    pt
0x20000004 0x00000000    data
0x20000008 0x00000000    buffer[0]
0x2000000C 0x00000000    buffer[1]
0x20000010 0x00000000    buffer[2]
0x20000014 0x00000000    buffer[3]

2. Consider the following code.

The function GetFifo returns two parameters. The return parameter is a boolean specifying whether or not the request was successful, and the actual data removed from the queue is returned via the call-by-reference parameter. The calling program InChar passes the address of its local variable data. Normally GetFifo does not have the scope to access local variables of InChar, but in this case InChar explicitly granted that right by passing a pointer to GetFifo.

#define FifoSize 10    /* Number of 8-bit data in FIFO */
unsigned char PutI;    /* Index of where to put next */
unsigned char GetI;    /* Index of where to get next */
unsigned char Size;    /* Number currently in the FIFO */
char Fifo[FifoSize];   /* FIFO data */

int GetFifo (char *datapt) {
  if(Size == 0 )
    return(0);     /* empty if Size=0 */
  else{
    *datapt=Fifo[GetI++];

    Size--;
    if (GetI == FifoSize) GetI = 0;
    return(-1);
}
}

char InChar(void){

char data=0;
  if(GetFifo(&data)){};
  return (data);

}

Questions:

1. Sketch a simple diagram that illustrates the different scope of variables in the code. Use any notation you want to show global versus local variables and pointer variables. You are not given information about actual memory addresses, so do not try to set up a memory diagram.

2. What would happen if GetFifo is called instead with the following parameter GetFifo(data)? Will rate thanks!!

Answer 1

Answer 1: The solution is given below in the form of a table

Line	Explanation	address	contents	variable
		0x20000000	0x00000000	pt
		0x20000004	0x00000000	data
		0x20000008	0x00000000	buffer[0]
		0x2000000C	0x00000000	buffer[1]
		0x20000010	0x00000000	buffer[2]
		0x20000014	0x00000000	buffer[3]
pt = &buffer[1];	The address of buffer[1] is stored as the content of pt	0x20000000	0x2000000C	pt
*pt = 1234;	1234 is stored at the address stored as the content of pt	0x2000000C	1234 (base 10) = 0x000004D2	buffer[1]
data = *pt;	Value at address stored as contents of pt is copied as content of data	0x20000004	0x000004D2	data

Answer 2 (i):

The scope of the different variables is given in the table given below alongwith explanatory comments where needed.

Variable name	Scope/Type	Comments
Putl	global
Getl	global
Size	global
Fifo	global
datapt	local (pointer variable)	The scope of datapt is local, i.e. limited to the GetFifo() function. But since it is a pointer variable, depending on the value passed as arguments, it may be used to modify the local variables of another function.
data	local	The scope is local, i.e. limited to InChar() function. But its address is passed as an argument to allow another function to modify its contents.

Answer 2(ii):

Calling GetFifo(data) implies passing a char as parameter while the prototype requires a pointer to char (char *). Many C-compilers will result in a compilation error as they do not support implicit cast from integral values to pointers.

For the compilers that allow this implicit type casting, the behaviour will be as follows. The value of data will be implicitly typecasted to char*. Therefore the GetFifo() function will start with dataptr=0. i.e. dataptr stores the address 0.

If Size is zero, it will return 0.

If Size != 0, the following line will result in a segmentation fault and cause the program to crash, since an unallocated memory address is accessed:

    *datapt=Fifo[GetI++];

This is because application of the dereferencing operator to datapt results in accessing the memory address 0x0 which was never allocated in the first place.