Annotator.h

Go to the documentation of this file.

/*
 * Annotator.h
 *
 *  Created on: May 4, 2014
 *      Author: Yulei Sui
 */
 
#ifndef ANNOTATOR_H_
#define ANNOTATOR_H_
 
#include <SVF-LLVM/BasicTypes.h> // TODO: Remove LLVM Header
#include "SVFIR/SVFValue.h"
#include <vector>
 
namespace SVF
{
 
class Annotator
{
 
public:
    Annotator()
    {
        SB_SLICESOURCE = "SOURCE_";
        SB_SLICESINK = "SINK_";
        SB_FESIBLE = "FESIBLE_";
        SB_INFESIBLE = "INFESIBLE_";
 
        DR_NOT_CHECK = "DRNOTCHECK_";
        DR_CHECK = "DRCHECK_";
    }
 
    virtual ~Annotator()
    {
    }
 
 
    inline bool hasSBSourceFlag(Instruction* inst) const
    {
        std::vector<Value* > values;
        return evalMDTag(inst, inst, SB_SLICESOURCE, values);
    }
 
    inline bool hasSBSinkFlag(Instruction* inst) const
    {
        std::vector<Value* > values;
        return evalMDTag(inst, inst, SB_SLICESINK, values);
    }
 
 
    inline bool hasDRNotCheckFlag(Instruction* inst) const
    {
        //std::vector<Value* > values;
        //return evalMDTag(inst, inst, DR_NOT_CHECK, values);
        return inst->getMetadata(DR_NOT_CHECK);
    }
 
    inline bool hasDRNotCheckFlag(const Instruction* inst) const
    {
        //std::vector<Value* > values;
        //return evalMDTag(inst, inst, DR_NOT_CHECK, values);
        return inst->getMetadata(DR_NOT_CHECK);
    }
 
    inline bool hasDRCheckFlag(Instruction* inst) const
    {
        //std::vector<Value* > values;
        //return evalMDTag(inst, inst, DR_CHECK, values);
        return inst->getMetadata(DR_CHECK);
    }
 
    inline bool hasDRCheckFlag(const Instruction* inst) const
    {
        //std::vector<Value* > values;
        //return evalMDTag(inst, inst, DR_CHECK, values);
        return inst->getMetadata(DR_CHECK);
    }
 
 
    inline void addMDTag(Instruction* inst, std::string str)
    {
        addMDTag(inst, inst, str);
    }
    inline void removeMDTag(Instruction* inst, std::string str)
    {
        removeMDTag(inst, inst, str);
    }
 
 
    inline void addMDTag(Instruction* inst, Value* val, std::string str)
    {
        assert(!val->getType()->isVoidTy() && "expecting non-void value for MD!");
        std::vector<Value* > values;
        //std::vector<llvm::Metadata *> metavalues;
        // add the flag if we did not see it before
        if (evalMDTag(inst, val, str, values) == false)
        {
 
            values.push_back(val);
            //llvm::ArrayRef<llvm::Metadata*> ar(metavalues);
            // FIXME: delete the old MDNode
            inst->setMetadata(str, MDNode::get(inst->getContext(), nullptr));
            //inst->setMetadata(str, llvm::MDNode::get(inst->getContext(), ar));
        }
    }
 
    inline void removeMDTag(Instruction* inst, Value* val, std::string str)
    {
        assert(!val->getType()->isVoidTy() && "expecting non-void value for MD!");
        std::vector<Value* > values;
 
        // remove the flag if it is there
        if (evalMDTag(inst, val, str, values) == true)
        {
            llvm::ArrayRef<Value* > ar(values);
            // FIXME: delete the old MDNode
            //inst->setMetadata(str, llvm::MDNode::get(inst->getContext(), ar));
        }
    }
 
private:
 
    inline bool evalMDTag(const Instruction* inst, const Value* val, std::string str,
                          std::vector<Value* >&) const
    {
 
        assert(val && "value should not be null");
 
        bool hasFlag = false;
        if (MDNode *mdNode = inst->getMetadata(str))
        {
            for (unsigned k = 0; k < mdNode->getNumOperands(); ++k)
            {
                //Value* v = mdNode->getOperand(k);
                // if (v == val)
                //    hasFlag = true;
                //else
                //    values.push_back(v);
            }
        }
        return hasFlag;
    }
 
protected:
 
 
    const char* SB_SLICESOURCE;
    const char* SB_SLICESINK;
    const char* SB_FESIBLE;
    const char* SB_INFESIBLE;
 
 
    const char* DR_NOT_CHECK;
    const char* DR_CHECK;
};
 
} // End namespace SVF
 
#endif /* ANNOTATOR_H_ */