Современный эквивалент LLVM AnnotationManager?

Question

Теперь, когда AnnotationManager от LLVM исчез (я думаю, он исчез в версии 2.6), как я могу получить аннотации для определенных функций, глобальных переменных и инструкций?

(Например, у меня есть битовый кодскомпилировано из C void myFunction(__attribute__((annotate("foo"))) int var) --- с учетом Argument * ссылки на этот аргумент int var, как я могу определить, какие annotate атрибуты прикреплены к нему?)

Answer 1

Чтобы получить аннотации для определенной функции, просмотрите элемент BasicBlock функции, чтобы найти ее вызовы к свойству @llvm.var.annotation, как показано ниже:

Module *module;

[...]

std::string getGlobalVariableString(std::string name)
{
    // assumption: the zeroth operand of a Value::GlobalVariableVal is the actual Value
    Value *v = module->getNamedValue(name)->getOperand(0);
    if(v->getValueID() == Value::ConstantArrayVal)
    {
        ConstantArray *ca = (ConstantArray *)v;
        return ca->getAsString();
    }

    return "";
}

void dumpFunctionArgAnnotations(std::string funcName)
{
    std::map<Value *,Argument*> mapValueToArgument;

    Function *func = module->getFunction(funcName);
    if(!func)
    {
        std::cout << "no function by that name.\n";
        return;
    }

    std::cout << funcName << "() ====================\n";


    // assumption: @llvm.var.annotation calls are always in the function's entry block.
    BasicBlock *b = &func->getEntryBlock();


    // run through entry block first to build map of pointers to arguments
    for(BasicBlock::iterator it = b->begin();it!=b->end();++it)
    {
        Instruction *inst = it;
        if(inst->getOpcode()!=Instruction::Store)
            continue;

        // `store` operands: http://llvm.org/docs/LangRef.html#i_store
        mapValueToArgument[inst->getOperand(1)] = (Argument *)inst->getOperand(0);
    }


    // run through entry block a second time, to associate annotations with arguments
    for(BasicBlock::iterator it = b->begin();it!=b->end();++it)
    {
        Instruction *inst = it;
        if(inst->getOpcode()!=Instruction::Call)
            continue;

        // assumption: Instruction::Call's operands are the function arguments, followed by the function name
        Value *calledFunction = inst->getOperand(inst->getNumOperands()-1);
        if(calledFunction->getName().str() != "llvm.var.annotation")
            continue;

        // `llvm.var.annotation` operands: http://llvm.org/docs/LangRef.html#int_var_annotation

        Value *annotatedValue = inst->getOperand(0);
        if(annotatedValue->getValueID() != Value::InstructionVal + Instruction::BitCast)
            continue;
        Argument *a = mapValueToArgument[annotatedValue->getUnderlyingObject()];
        if(!a)
            continue;

        Value *annotation = inst->getOperand(1);
        if(annotation->getValueID() != Value::ConstantExprVal)
            continue;
        ConstantExpr *ce = (ConstantExpr *)annotation;
        if(ce->getOpcode() != Instruction::GetElementPtr)
            continue;

        // `ConstantExpr` operands: http://llvm.org/docs/LangRef.html#constantexprs
        Value *gv = ce->getOperand(0);

        if(gv->getValueID() != Value::GlobalVariableVal)
            continue;

        std::cout << "    argument " << a->getType()->getDescription() << " " << a->getName().str()
            << " has annotation \"" << getGlobalVariableString(gv->getName().str()) << "\"\n";
    }
}

Answer 2

AnnotationManager был удален, потому что он был бесполезен (и это не решит вашу проблему). Все аннотации обрабатываются с помощью глобального имени 'llvm.global.annotations' и встроенных аннотаций, которые вы, безусловно, можете анализировать и получать необходимую информацию.

Посмотрите на IR, чтобы понять, как ваш код C был преобразован в IR и в какой атрибут аннотации был превращен.