explaination of some gcc functions

[Mike Stump]

On Jul 1, 2006, at 12:54 AM, kernel coder wrote:
> I'm having trouble in understanding the term sequnce in an insn
> chain.get_insns() actually returns the current instruction.

I'd recommend reading the code:

/* Emission of insns (adding them to the doubly-linked list).  */

/* Return the first insn of the current sequence or current  
function.  */

rtx
get_insns (void)
{
   return first_insn;
}

/* Specify a new insn as the first in the chain.  */

void
set_first_insn (rtx insn)
{
   gcc_assert (!PREV_INSN (insn));
   first_insn = insn;
}

/* Return the last insn emitted in current sequence or current  
function.  */

rtx
get_last_insn (void)
{
   return last_insn;
}

/* Specify a new insn as the last in the chain.  */

void
set_last_insn (rtx insn)
{
   gcc_assert (!NEXT_INSN (insn));
   last_insn = insn;
}

It can help form a basis from which you can  build your understanding  
of the code.

> What does the term "sequence" mean,as the name suggests it must be  
> a sequence of
> instructions

Ok, so you know what it means...

Another way would be to read the code.  If you read the code:

push_topmost_sequence (void)
{
   struct sequence_stack *stack, *top = NULL;

   start_sequence ();

   for (stack = seq_stack; stack; stack = stack->next)
     top = stack;

   first_insn = top->first;

and then first_insn:

#define first_insn (cfun->emit->x_first_insn)

and then if you find x_first_insn:

   /* The ends of the doubly-linked chain of rtl for the current  
function.
      Both are reset to null at the start of rtl generation for the  
function.

      start_sequence saves both of these on `sequence_stack' and then  
starts
      a new, nested sequence of insns.  */
   rtx x_first_insn;
   rtx x_last_insn;

and then you can read the comments.  The term doubly linked list  
should help understand the term sequence.  Also, if you read the  
code, the code can also help understand the term sequence, just M- 
grep sequence *.c and read it all.  And lastly, to understand the  
term sequence you can google("sequence") and read how it is used, as  
our use of the term is no different that every other use of the term.

> but in an instruction chain,a single element will be an instruction,

Unless you have a reference to a member of a container and you can  
find the container from the reference.  I'd recommend some books on  
data structures and programming if your unfamiliar with data structures.

> When push_topmost_sequence is called ,it should push a sequence of
> instructions ,but an element of insn chain is a single
> instruction,then which sequence will be pushed.

See above.  In addition, another way to understand the code would be  
to set a breakpoint on whatever you're interested in and single step  
it in your favorite debugger.  You can then see what it does, how it  
does it, what data structures are in play, the comments around that  
code and so on.

> Suppose following is a sequnce of instructions.
>
> 1)    entry_insns = get_insns ();
> 2)     push_topmost_sequence ();
> 3)      emit_insn_after (entry_insns, get_insns ());
> 4)      pop_topmost_sequence ();
>
> In 1) current insn is saved in entry_insns. what is happening in In
> 2).Is sequence differnet from insn in an insn chain ,any example will
> be helpful.

If you read the comments in the code:

     /* Put the insns after the NOTE that starts the function.
        If this is inside a start_sequence, make the outer-level insn
        chain current, so the code is placed at the start of the
        function.  */
     push_topmost_sequence ();
     emit_insn_before (seq, NEXT_INSN (entry_of_function ()));
     pop_topmost_sequence ();
     return temp;

and:

   /* Put the insns after the NOTE that starts the function.  If this
      is inside a start_sequence, make the outer-level insn chain  
current, so
      the code is placed at the start of the function.  */
   push_topmost_sequence ();
   emit_insn_after (seq, entry_of_function ());
   pop_topmost_sequence ();

do they help clarify things?

> But does get_insns() also increaments the current instruction pointer.

Is is documented to do that?  Is there code in the function to do  
that?  Hint, here is everything you need to answer those questions:

/* Return the first insn of the current sequence or current  
function.  */

rtx
get_insns (void)
{
   return first_insn;
}

If you don't use emacs, I'd recommend it.  If you don't know about  
M-., I'd recommend reading up on it, to use it, just go the the call  
of the function your interested in, such s get_insns and then hit  
M-., and then presto, you're there.  Just be sure to do a make TAGS  
once.  You can then read up on what it is and does.

> Now again which sequnce is being  poped out in 4).

In the idiom:

push
pop

the pop, pops the thing on top the stack, in the above case, it would  
be the thing just pushed.  If you don't understand that, I'd  
recommend an intro to CS type book, then a dara structures book, and  
algorithms book, then an advanced data structures book.  We can't  
help with this sort of background.

Asking on this list those questions that can be answered by google,  
CS books, the code, comments in the code and the documentation is  
generally off-topic.