¿Cómo se implementa LLVM isa <>?

Question

De http://llvm.org/docs/CodingStandards.html#ci_rtti_exceptions

LLVM sí hace uso extensivo de una forma enrollado a mano de RTTI que utilizan plantillas como ISA <>, echados <>, y dyn_cast <>. Esta forma de RTTI es opt-in y se puede agregar a cualquier clase. También es sustancialmente más eficiente que dynamic_cast <>.

¿Cómo se implementa isa y los demás?

Answer 1

Debo mencionar que http://llvm.org/docs/ProgrammersManual.html#isa - este documento tiene alguna descripción adicional.

El código fuente de isa, cast y dyn_cast se encuentra en un solo archivo, y se comenta mucho.

http://llvm.org/doxygen/Casting_8h_source.html

00047 // isa<X> - Return true if the parameter to the template is an instance of the 
00048 // template type argument. Used like this: 
00049 // 
00050 // if (isa<Type*>(myVal)) { ... } 
00051 // 
00052 template <typename To, typename From> 
00053 struct isa_impl { 
00054 static inline bool doit(const From &Val) { 
00055  return To::classof(&Val); 
00056 } 
00057 }; 

00193 // cast<X> - Return the argument parameter cast to the specified type. This 
00194 // casting operator asserts that the type is correct, so it does not return null 
00195 // on failure. It does not allow a null argument (use cast_or_null for that). 
00196 // It is typically used like this: 
00197 // 
00198 // cast<Instruction>(myVal)->getParent() 
00199 // 
00200 template <class X, class Y> 
00201 inline typename cast_retty<X, Y>::ret_type cast(const Y &Val) { 
00202 assert(isa<X>(Val) && "cast<Ty>() argument of incompatible type!"); 
00203 return cast_convert_val<X, Y, 
00204       typename simplify_type<Y>::SimpleType>::doit(Val); 
00205 } 

00218 // dyn_cast<X> - Return the argument parameter cast to the specified type. This 
00219 // casting operator returns null if the argument is of the wrong type, so it can 
00220 // be used to test for a type as well as cast if successful. This should be 
00221 // used in the context of an if statement like this: 
00222 // 
00223 // if (const Instruction *I = dyn_cast<Instruction>(myVal)) { ... } 
00224 // 
00225 
00226 template <class X, class Y> 
00227 inline typename cast_retty<X, Y>::ret_type dyn_cast(const Y &Val) { 
00228 return isa<X>(Val) ? cast<X, Y>(Val) : 0; 
00229 } 

Answer 2

Simplemente añadiendo cosas a la respuesta de osgx: básicamente, cada clase debe implementar el método classof() que hace todo el material necesario. Por ejemplo, classof del Valor() rutina se ve así:

// Methods for support type inquiry through isa, cast, and dyn_cast: 
    static inline bool classof(const Value *) { 
    return true; // Values are always values. 
    } 

Para comprobar si tenemos una clase del tipo apropiado, cada clase tiene su ValueID único. Puede consultar la lista completa de ValueID dentro del archivo include/llvm/Value.h. Este ValueID se utiliza de la siguiente manera (extracto de Function.h):

/// Methods for support type inquiry through isa, cast, and dyn_cast: 
    static inline bool classof(const Function *) { return true; } 
    static inline bool classof(const Value *V) { 
    return V->getValueID() == Value::FunctionVal; 
    } 

Así, en pocas palabras: cada clase debe implementar el método classof() que realiza la decisión necesaria. La implementación en cuestión consiste en el conjunto de ValueID únicos. Por lo tanto, para implementar classof() uno debería simplemente comparar el ValueID del argumento con el propio ValueID.

Si mal no recuerdo, la primera implementación de isa <> y amigos fueron adoptados de boost ~ 10 años atrás. En este momento, las implementaciones divergen significativamente :)

Answer 3

En primer lugar, el sistema LLVM es extremadamente específico y en absoluto un reemplazo directo para el sistema RTTI.

Local

• Para la mayoría de las clases, no es necesario para generar información de RTTI
• Cuando se requiera, la información sólo tiene sentido dentro de una jerarquía dada
• Nos impide múltiples herencia de este sistema

Identificación de una clase de objeto

Tome una jerarquía simple, por ejemplo:

struct Base {}; /* abstract */ 
struct DerivedLeft: Base {}; /* abstract */ 
struct DerivedRight:Base {}; 
struct MostDerivedL1: DerivedLeft {}; 
struct MostDerivedL2: DerivedLeft {}; 
struct MostDerivedR: DerivedRight {}; 

Vamos a crear una enumeración específica a esta jerarquía, con un miembro de la enumeración de cada uno de los miembro de la jerarquía que se pueden crear instancias (las otras tendrían inútil).

enum BaseId { 
    DerivedRightId, 
    MostDerivedL1Id, 
    MostDerivedL2Id, 
    MostDerivedRId 
}; 

Entonces, la clase Base será reforzado con un método que devuelva esta enumeración.

struct Base { 
    static inline bool classof(Base const*) { return true; } 

    Base(BaseId id): Id(id) {} 

    BaseId getValueID() const { return Id; } 

    BaseId Id; 
}; 

Y cada clase concreta es aumentado también, de esta manera:

struct DerivedRight: Base { 
    static inline bool classof(DerivedRight const*) { return true; } 

    static inline bool classof(Base const* B) { 
    switch(B->getValueID()) { 
    case DerivedRightId: case MostDerivedRId: return true; 
    default: return false; 
    } 
    } 

    DerivedRight(BaseId id = DerivedRightId): Base(id) {} 
}; 

Ahora, es posible, simplemente, para consultar el tipo exacto, para la fundición.

ocultación de detalles de implementación

Tener los usuarios murking con getValueID sería problemático, sin embargo, por lo que en este LLVM está escondida con el uso de métodos classof.

Una clase determinada debe implementar dos métodos classof: uno para su base más profunda (con una prueba de los valores adecuados de BaseId) y uno para sí mismo (optimización pura). Por ejemplo:

struct MostDerivedL1: DerivedLeft { 
    static inline bool classof(MostDerivedL1 const*) { return true; } 

    static inline bool classof(Base const* B) { 
    return B->getValueID() == MostDerivedL1Id; 
    } 

    MostDerivedL1(): DerivedLeft(MostDerivedL1Id) {} 
}; 

De esta manera, se puede comprobar si un yeso es posible o no a través de las plantillas:

template <typename To, typename From> 
bool isa(From const& f) { 
    return To::classof(&f); 
} 

Imagínese por un momento que To es MostDerivedL1:

• si From es MostDerivedL1, luego invocamos la primera sobrecarga de classof, y funciona
• si From es cualquier otra cosa, luego invocamos la segunda sobrecarga de classof, y la verificación usa la enumeración para determinar si el tipo concreto coincide.

Espero que sea más claro.