llvm dev - Jun 2004 - [LLVMdev] Assignment instruction.

Hi.

A small thing I miss in the intermediate representation is a simple
assignment instruction, like:

  %x = uint 3
or:
  %x = uint %y

It would simplify the implementation of frontends, I think.
,	Tobias

On Thu, Jun 17, 2004 at 05:09:30PM +0200, Tobias Nurmiranta
wrote:
> A small thing I miss in the intermediate representation is a simple
> assignment instruction, like:
> 
>   %x = uint 3
> or:
>   %x = uint %y
> 
> It would simplify the implementation of frontends, I think.
Neither of these is necessary, and adding new instructions means every
transformation has to handle these (extra cases, extra complexity, etc.)

In the first case, "x = 3", you can simply constant-propagate the 3
and
use it everywhere you would use the x.  If you are programming an LLVM
pass, create a Value* that is the "uint 3" and use it.  If you are
writing LLVM assembly by hand, use "x = add uint 3, 0" and you have
the
same effect, without an extra special case for future transformations.

As for "x = y", same as above: since we are using SSA, y cannot be
assigned a new value, ever, so you can just use y anywhere below where
you would otherwise use x, and the assignment isn't even necessary.

Basically, the point is to have an orthogonal instruction set where
little (or no) functionality is duplicated across the instructions,
because that cuts down on the number of cases a transformation has to
deal with.

-- 
Misha Brukman :: http://misha.brukman.net :: http://llvm.cs.uiuc.edu

Thanks for the fast reply. I'll do as you suggested, and create my own
identity instructions with "add" for int's and
"getelementptr" for
pointers.
,	Tobias

On Thu, 17 Jun 2004, Misha Brukman wrote:
> On Thu, Jun 17, 2004 at 05:09:30PM +0200, Tobias Nurmiranta wrote:
> > A small thing I miss in the intermediate representation is a simple
> > assignment instruction, like:
> >
> >   %x = uint 3
> > or:
> >   %x = uint %y
> >
> > It would simplify the implementation of frontends, I think.
>
> Neither of these is necessary, and adding new instructions means every
> transformation has to handle these (extra cases, extra complexity, etc.)
>
> In the first case, "x = 3", you can simply constant-propagate the
3 and
> use it everywhere you would use the x.  If you are programming an LLVM
> pass, create a Value* that is the "uint 3" and use it.  If you
are
> writing LLVM assembly by hand, use "x = add uint 3, 0" and you
have the
> same effect, without an extra special case for future transformations.
>
> As for "x = y", same as above: since we are using SSA, y cannot
be
> assigned a new value, ever, so you can just use y anywhere below where
> you would otherwise use x, and the assignment isn't even necessary.
>
> Basically, the point is to have an orthogonal instruction set where
> little (or no) functionality is duplicated across the instructions,
> because that cuts down on the number of cases a transformation has to
> deal with.
>
> --
> Misha Brukman :: http://misha.brukman.net :: http://llvm.cs.uiuc.edu
>
> _______________________________________________
> LLVM Developers mailing list
> LLVMdev at cs.uiuc.edu         http://llvm.cs.uiuc.edu
> http://mail.cs.uiuc.edu/mailman/listinfo/llvmdev
>