llvm dev - Apr 2005 - [LLVMdev] isa and friends as an alternative to dynamic cast?

I see a bunch of definitions scattered throughout LLVM, and I could not
find good documentation on them. I don't understand why they exist when
LLVM is being compiled with RTTI enabled. It seems to me that:

isa<T>(x) is a substitute for (dynamic_cast<T>(x) != NULL)

and there are some other similar casting tools defined in Casting.h. Why
should I use these instead of C++'s built-in features?

Evan Jones

On Thu, Apr 21, 2005 at 09:34:14PM -0400, Evan Jones
wrote:
> I see a bunch of definitions scattered throughout LLVM, and I could not
> find good documentation on them. I don't understand why they exist when
> LLVM is being compiled with RTTI enabled. It seems to me that:
> 
> isa<T>(x) is a substitute for (dynamic_cast<T>(x) != NULL)
Not really.  C++ dynamic_cast<T>(x), as I understand it, is a dynamic
type-checker that will walk the class hierarchy to determine if "x" is
a
subclass of "T", and hence, "is it a thing of type T".  This
means a
bunch of loads to traverse the tree.

LLVM does not have a complex hierarchy of Instructions and Values, so
this is just extra overhead.  If you look at
llvm/include/llvm/Instructions.h, for example, look at the classof()
implementations by each instruction.  isa<> is defined in terms of these
classof() member functions.  LLVM also provides a dyn_cast<T>(x) that is
"like" dynamic_cast<T>(x), but faster, because it benefits from
LLVM's
class hierarchy.

In Casting.h, you'll find:

// isa<X> - Return true if the parameter to the template is an instance
// of the template type argument.  Used like this:
//
//  if (isa<Type*>(myVal)) { ... }
//
template <typename To, typename From>
inline bool isa_impl(const From &Val) {
  return To::classof(&Val);
}

Also take a look at the definition of dyn_cast<X> in the same file.

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

> I see a bunch of definitions scattered throughout LLVM, and I could not
> find good documentation on them. I don't understand why they exist when
> LLVM is being compiled with RTTI enabled. It seems to me that:
>
> isa<T>(x) is a substitute for (dynamic_cast<T>(x) != NULL)
Misha seems to have answered your question, but documentation is found 
here:
http://llvm.cs.uiuc.edu/docs/ProgrammersManual.html#isa

-Tanya

On Thu, 2005-21-04 at 21:20 -0500, Tanya Lattner wrote:
> Misha seems to have answered your question, but documentation is found
> here:
> http://llvm.cs.uiuc.edu/docs/ProgrammersManual.html#isa
Ah, perfect! Thank you both.

Evan Jones

Evan,

In case it wasn't obvious from Misha's answer, the main reason for doing
this is speed. RTTI is not very quick. Since LLVM is well contained,
there are no IR classes that LLVM doesn't know about it. Using
dynamic_cast is really only warranted when blending libraries together
that have inheritance relationships between them that aren't known in
one or more of the libraries. Since we don't have that situation in
LLVM, using the various Casting.h facilities allows all that "dynamic"
casting to actually be done statically, hence no runtime performance
penalty.

If you wonder why LLVM is fast .. this is just one of the many reasons.

Reid.

On Thu, 2005-04-21 at 21:34 -0400, Evan Jones wrote:
> I see a bunch of definitions scattered throughout LLVM, and I could not
> find good documentation on them. I don't understand why they exist when
> LLVM is being compiled with RTTI enabled. It seems to me that:
> 
> isa<T>(x) is a substitute for (dynamic_cast<T>(x) != NULL)
> 
> and there are some other similar casting tools defined in Casting.h. Why
> should I use these instead of C++'s built-in features?
> 
> Evan Jones
> 
> 
> _______________________________________________
> LLVM Developers mailing list
> LLVMdev at cs.uiuc.edu         http://llvm.cs.uiuc.edu
> http://mail.cs.uiuc.edu/mailman/listinfo/llvmdev
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20050421/303632f8/attachment.html>
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 189 bytes
Desc: This is a digitally signed message part
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20050421/303632f8/attachment.sig>

On Thu, 2005-21-04 at 19:43 -0700, Reid Spencer wrote:
> In case it wasn't obvious from Misha's answer, the main reason for
> doing this is speed. RTTI is not very quick.
Right. This is why I was somewhat suprized to see the "isa" facilities
included in LLVM without also disabling rtti. It will reduce the memory
footprint a fair bit if you do disable it, at least based on my
experience with other C++ projects.

Evan Jones

On Thu, 21 Apr 2005, Reid Spencer wrote:
> one or more of the libraries. Since we don't have that situation in
> LLVM, using the various Casting.h facilities allows all that
"dynamic"
> casting to actually be done statically, hence no runtime performance
> penalty.
Reid is right.  isa on an instruction literally loads a field out of the 
instruction and compares it against a constant.  As another example, a 
good compiler (ahem, like LLVM :) ), turns this:

if (... = dyn_cast<LoadInst>(Y)) {
...
} else if (... = dyn_cast<StoreInst>(Y)) {
...
} else if (... = dyn_cast<AllocaInst>(Y)) {
...

Into:

switch (Y->getOpcode()) {
case Instruction::Load:
   ...
case Instruction::Store:
   ...
case Instruction::AllocaInst:
   ...

Which is something that is just not possible with RTTI.

-Chris

-- 
http://nondot.org/sabre/
http://llvm.cs.uiuc.edu/