Activation Records

In this article, we are going to explain Access Links and Control Links. Well, both are in the field of Activation Records.

Activation Record : 
An activation record is a contiguous block of storage that manages information required by a single execution of a procedure. When you enter a procedure, you allocate an activation record, and when you exit that procedure, you de-allocate it. Basically, it stores the status of the current activation function. So, whenever a function call occurs, then a new activation record is created and it will be pushed onto the top of the stack. It will remain in stack till the execution of that function. So, once the procedure is completed and it is returned to the calling function, this activation function will be popped out of the stack.
If a procedure is called, an activation record is pushed into the stack, and it is popped when the control returns to the calling function.

Activation Record includes some fields which are - 
Return values, parameter list, control links, access links, saved machine status, local data, and temporaries.

Temporaries:

The temporary values, such as those arising in the evaluation of expressions, are stored in the field for temporaries.

Local data:

The field for local data holds data that is local to an execution of a procedure. 

Saved Machine States:

The field for Saved Machine Status holds information about the state of the machine just before the procedure is called. This information includes the value of the program counter and machine registers that have to be restored when control returns from the procedure.

Access Link : 
It refers to information stored in other activation records that is non-local. The access link is a static link and the main purpose of the access link is to access the data which is not present in the local scope of the activation record. It is a static link. 
Let's take an example to understand this -

#include <stdio.h>
int g=12;
void Geeks()
{
  printf("%d", g);
}
void main()
{
 Geeks();
}

Now, In this example, when Geeks() is called in a main(), the task of Geeks() in main() is to print(g), but g is not defined within its scope(local scope of Geeks()); in this case, Geeks() would use the access link to access 'g' from Global Scope and then print its value (g=12).

As a chain of access links (think of scopes), the program traces its static structure.
Now, let's take another example to understand the concept of access link in detail -

 #include <stdio.h>

  int main (int argc, char *argv[]) {
    int a = 100;

      int geeks(int b) {
      int c = a+b;
      return c;
      }

      int geek1(int b) {
      return geeks(2*b);
      }
   (void) printf("The answer is %d\n", geek1(a));
  return 0;
  }
 

There are no errors detected while compiling the program, and the correct answer is displayed, which is 300. Now, let's discuss the nesting paths. Nested procedures include an AR(Activation Record) access link that enables users to access the AR of the most recent action taken by their immediately outer procedure.  So, in this example, the access link for geeks and access link for geeks1 would each point to the AR of the activation of the main. 
Each activation record gets a pointer called the access link that facilitates the direct implementation of the normal static scope rule. 

Control Links :  
In this case, it refers to an activation record of the caller. They are generally used for links and saved status. It is a dynamic link in nature. When a function calls another function, then the control link points to the activation record of the caller.
Record A contains a control link pointing to the previous record on the stack. Dynamically executed programs are traced by the chain of control links.
Example -

#include<stdio.h>
int geeks(int x)
{
  printf("value of x is: %d", x);
}
int main()
{
  geeks(10);
}

Let's take another example -

#include <stdio.h>
int geeks();
int main() {
    int x, y;
    //Calling a function
    geeks();
  return 0;
}

int geeks() {

    //Function called from main()
  printf("Function called from main()");
    return 0;
}

When the function geeks() is called, it uses the access link method to access x and y (statically scoped) in its calling function main().

Parameter List:

The field for parameters list is used by the calling procedure to supply parameters to the called procedure. We show space for parameters in the activation record, but in practice, parameters are often passed in machine registers for greater efficiency.

Return value:

The field for the return value is used by the called procedure to return a value to the calling procedure. Again in practice, this value is often returned in a register for greater efficiency.