Pourquoi cet alias de type provoque-t-il une erreur de compilation (C++)?

Question

J'écris un passage LLVM qui renomme des fonctions parmi d'autres choses. J'ai ce petit morceau de code

// Get function arguments 
std::vector<Argument*> Arguments; 
for (auto Arg = F.arg_begin(); Arg != F.arg_end(); ++Arg) 
{ 
    Type *ArgTy = Arg->getType(); 

    if (ArgTy->isFloatingPointTy()) 
    { 
    errs() << "Cannot test function: " << F.getName() << " (floating point arguments)\n"; 
    return false; 
    } 
    Arguments.push_back(Arg); 
} 

La ligne Arguments.push_back(Arg) provoque une erreur de compilation:

no known conversion for argument 1 from ‘llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::Argument, false, false, void>, false, false>’ to ‘llvm::Argument* const&’.

Cependant, dans le fichier d'en-tête llvm/IR/Function.h (source), arg_iterator est déclarée comme un alias pour le type Argument * et les fonctions arg_begin() et arg_end() appelées par une instance Function, retourner un type arg_iterator(). Alors, pourquoi ai-je l'erreur de type? Cela a-t-il quelque chose à voir avec l'utilisation du mot-clé auto?

Answer 1

Essayez de déréférencer votre iterator:

std::vector<Argument*> Arguments; 
for (auto Arg = F.arg_begin(); Arg != F.arg_end(); ++Arg) 
{ 
    auto *ArgTy = Arg->getType(); 

    if (ArgTy->isFloatingPointTy()) 
    { 
    errs() << "Cannot test function: " << F.getName() << " (floating point arguments)\n"; 
    return false; 
    } 
    Arguments.push_back(*Arg); 
} 

Cela ne fonctionnera que si les magasins F objets tels que Argument*

Answer 2

Vérifiez la version des fichiers que vous utilisez sur votre lecteur. Si vous ne l'utilisez pas directement depuis le GitHub, mais que vos fichiers arrivent avec l'installation de LLVM, vérifiez les fichiers que vous construisez.

Le « blâme » sur les spectacles GitHub, qu'il y avait un changement dans les arg_begin/arg_end types de retour de ArgumentListType::iterator à Argument * il y a environ 4 mois (commit), de sorte que vous pourriez construire contre l'ancienne version, qui a encore le type d'itérateur complexe d'origine.

Answer 3

Pour éviter l'erreur de compilation, comme solution possible est la suivante

// Get function arguments 
std::vector<Argument*> Arguments; 
for (auto Arg = F.arg_begin(); Arg != F.arg_end(); ++Arg) 
{ 
    Type *ArgTy = Arg->getType(); 

    if (ArgTy->isFloatingPointTy()) 
    { 
    errs() << "Cannot test function: " << F.getName() << " (floating point arguments)\n"; 
    return false; 
    } 
    // Grab a pointer to the argument reference 
    Argument *ArgPtr = &*Arg; 
    Arguments.push_back(ArgPtr); 
} 

Mon problème a surgi de mon incompréhension de pointeurs vs références en C++ (voir here pour plus de détails).

Je ne sais pas pourquoi arg_iterator != Argument * au moment de la compilation - c'est peut-être à cause de certaines fonctionnalités spécifiques au LLVM. Dans tous les cas, nous devons déréférencer Arg afin d'obtenir un type Argument, puis prendre l'adresse du type Argument (avec l'opérateur &) afin d'obtenir un pointeur vers ce type Argument.