CppUtil.cpp File Reference

#include "SVF-LLVM/CppUtil.h"
#include "SVF-LLVM/BasicTypes.h"
#include "SVF-LLVM/LLVMUtil.h"
#include "Util/Casting.h"
#include "Util/SVFUtil.h"
#include "SVF-LLVM/LLVMModule.h"
#include "SVF-LLVM/ObjTypeInference.h"
#include <cxxabi.h>

Go to the source code of this file.

Functions
static bool	isOperOverload (const std::string &name)
static std::string	getBeforeParenthesis (const std::string &name)
static void	handleThunkFunction (cppUtil::DemangledName &dname)
static bool	isDerivedFromThisPtr (const Argument *thisPtr, const Value *V)
void	stripBracketsAndNamespace (cppUtil::DemangledName &dname)
std::vector< std::string >	findInnermostBrackets (const std::string &input)
std::string	stripWhitespaces (const std::string &str)
std::vector< std::string >	splitAndStrip (const std::string &input, char delimiter)

Variables
const std::string	vtblLabelAfterDemangle = "vtable for "
const std::string	NVThunkFunLabel = "non-virtual thunk to "
const std::string	VThunkFuncLabel = "virtual thunk to "
const std::string	vtblLabelBeforeDemangle = "_ZTV"
const std::string	vfunPreLabel = "_Z"
const std::string	clsName = "class."
const std::string	structName = "struct."
const std::string	vtableType = "(...)**"
const std::string	znwm = "_Znwm"
const std::string	zn1Label = "_ZN1"
const std::string	znstLabel = "_ZNSt"
const std::string	znst5Label = "_ZNSt5"
const std::string	znst12Label = "_ZNSt12"
const std::string	znst6Label = "_ZNSt6"
const std::string	znst7Label = "_ZNSt7"
const std::string	znst14Label = "_ZNSt14"
const std::string	znkstLabel = "_ZNKSt"
const std::string	znkst5Label = "_ZNKSt15_"
const std::string	znkst20Label = "_ZNKSt20_"
const std::string	znkst23Label = "_ZNKSt23_"
const std::string	znkLabel = "_ZNK"
const std::string	znk9Label = "_ZNK9"
const std::string	ztilabel = "_ZTI"
const std::string	ztiprefix = "typeinfo for "
const std::string	dyncast = "__dynamic_cast"

Function Documentation

findInnermostBrackets()

std::vector< std::string > findInnermostBrackets

(

const std::string &

input

)

find the innermost brackets, e.g., return "int const, A" for "__gnu_cxx::__aligned_membuf<std::pair<int const, A> >::_M_ptr() const"

Parameters

input

Returns

Definition at line 805 of file CppUtil.cpp.

{
    typedef std::pair<u32_t, u32_t> StEdIdxPair;
    std::stack<int> stack;
    std::vector<StEdIdxPair> innerMostPairs;
    std::vector<bool> used(input.length(), false);
 
    for (u32_t i = 0; i < input.length(); ++i)
    {
        if (input[i] == '<')
        {
            stack.push(i);
        }
        else if (input[i] == '>' && i > 0 && input[i - 1] != '-')
        {
            if (!stack.empty())
            {
                int openIndex = stack.top();
                stack.pop();
 
                // Check if this pair is innermost
                bool isInnermost = true;
                for (u32_t j = openIndex + 1; j < i && isInnermost; ++j)
                {
                    if (used[j])
                    {
                        isInnermost = false;
                    }
                }
 
                if (isInnermost)
                {
                    innerMostPairs.emplace_back(openIndex, i);
                    used[openIndex] = used[i] = true; // Mark these indices as used
                }
            }
        }
    }
    std::vector<std::string> ans(innerMostPairs.size());
    std::transform(innerMostPairs.begin(), innerMostPairs.end(), ans.begin(), [&input](StEdIdxPair &p) -> std::string
    {
        return input.substr(p.first + 1, p.second - p.first - 1);
    });
    return ans;
}

getBeforeParenthesis()

static std::string getBeforeParenthesis ( const std::string &  name )

static

Definition at line 107 of file CppUtil.cpp.

{
    size_t lastRightParen = name.rfind(')');
    assert(lastRightParen > 0);
 
    s32_t paren_num = 1, pos;
    for (pos = lastRightParen - 1; pos >= 0; pos--)
    {
        if (name[pos] == ')')
            paren_num++;
        if (name[pos] == '(')
            paren_num--;
        if (paren_num == 0)
            break;
    }
    return name.substr(0, pos);
}

handleThunkFunction()

static void handleThunkFunction ( cppUtil::DemangledName &  dname )

static

Definition at line 146 of file CppUtil.cpp.

{
    // when handling multi-inheritance,
    // the compiler may generate thunk functions
    // to perform `this` pointer adjustment
    // they are indicated with `virtual thunk to `
    // and `nun-virtual thunk to`.
    // if the classname starts with part of a
    // demangled name starts with
    // these prefixes, we need to remove the prefix
    // to get the real class name
 
    static std::vector<std::string> thunkPrefixes = {VThunkFuncLabel,
                                                     NVThunkFunLabel
                                                    };
    for (unsigned i = 0; i < thunkPrefixes.size(); i++)
    {
        auto prefix = thunkPrefixes[i];
        if (dname.className.size() > prefix.size() &&
                dname.className.compare(0, prefix.size(), prefix) == 0)
        {
            dname.className = dname.className.substr(prefix.size());
            dname.isThunkFunc = true;
            return;
        }
    }
}

isDerivedFromThisPtr()

static bool isDerivedFromThisPtr ( const Argument *  thisPtr, const Value *  V  )

static

Check if V is derived from thisPtr Handles O0 pattern: this1 = load ptr, ptr this.addr

Definition at line 425 of file CppUtil.cpp.

{
    V = V->stripPointerCasts();
    if (V == thisPtr)
        return true;
 
    if (const LoadInst* load = SVFUtil::dyn_cast<LoadInst>(V))
    {
        if (const AllocaInst* alloca =
                    SVFUtil::dyn_cast<AllocaInst>(load->getPointerOperand()))
        {
            for (const User* U : alloca->users())
            {
                if (const StoreInst* store = SVFUtil::dyn_cast<StoreInst>(U))
                {
                    if (store->getPointerOperand() == alloca &&
                            store->getValueOperand()->stripPointerCasts() == thisPtr)
                        return true;
                }
            }
        }
    }
    return false;
}

isOperOverload()

static bool isOperOverload ( const std::string &  name )

static

Definition at line 84 of file CppUtil.cpp.

{
    u32_t leftnum = 0, rightnum = 0;
    std::string subname = name;
    size_t leftpos, rightpos;
    leftpos = subname.find('<');
    while (leftpos != std::string::npos)
    {
        subname = subname.substr(leftpos + 1);
        leftpos = subname.find('<');
        leftnum++;
    }
    subname = name;
    rightpos = subname.find('>');
    while (rightpos != std::string::npos)
    {
        subname = subname.substr(rightpos + 1);
        rightpos = subname.find('>');
        rightnum++;
    }
    return leftnum != rightnum;
}

splitAndStrip()

std::vector< std::string > splitAndStrip	(	const std::string &	input,
		char	delimiter
	)

Definition at line 870 of file CppUtil.cpp.

{
    std::vector<std::string> tokens;
    size_t start = 0, end = 0;
 
    while ((end = input.find(delimiter, start)) != std::string::npos)
    {
        tokens.push_back(stripWhitespaces(input.substr(start, end - start)));
        start = end + 1;
    }
 
    tokens.push_back(stripWhitespaces(input.substr(start)));
 
    return tokens;
}

stripBracketsAndNamespace()

void stripBracketsAndNamespace

(

cppUtil::DemangledName &

dname

)

strip off brackets and namespace from classname e.g., for ‘namespace::A<...::...>::f’, we get ‘A’ by stripping off namespace and <>

Definition at line 543 of file CppUtil.cpp.

{
    dname.funcName = cppUtil::getBeforeBrackets(dname.funcName);
    dname.className = cppUtil::getBeforeBrackets(dname.className);
    size_t colon = dname.className.rfind("::");
    if (colon == std::string::npos)
    {
        dname.className = cppUtil::getBeforeBrackets(dname.className);
    }
    else
    {
        // strip off namespace
        dname.className =
            cppUtil::getBeforeBrackets(dname.className.substr(colon + 2));
    }
}

stripWhitespaces()

std::string stripWhitespaces

(

const std::string &

str

)

strip off the whitespaces from the beginning and ending of str

Parameters

str

Returns

Definition at line 856 of file CppUtil.cpp.

{
    auto start = std::find_if(str.begin(), str.end(), [](unsigned char ch)
    {
        return !std::isspace(ch);
    });
    auto end = std::find_if(str.rbegin(), str.rend(), [](unsigned char ch)
    {
        return !std::isspace(ch);
    }).base();
 
    return (start < end) ? std::string(start, end) : std::string();
}

Variable Documentation

clsName

const std::string clsName = "class."

Definition at line 55 of file CppUtil.cpp.

dyncast

const std::string dyncast = "__dynamic_cast"

Definition at line 81 of file CppUtil.cpp.

NVThunkFunLabel

const std::string NVThunkFunLabel = "non-virtual thunk to "

Definition at line 46 of file CppUtil.cpp.

structName

const std::string structName = "struct."

Definition at line 56 of file CppUtil.cpp.

vfunPreLabel

const std::string vfunPreLabel = "_Z"

Definition at line 53 of file CppUtil.cpp.

vtableType

const std::string vtableType = "(...)**"

Definition at line 57 of file CppUtil.cpp.

vtblLabelAfterDemangle

const std::string vtblLabelAfterDemangle = "vtable for "

Definition at line 43 of file CppUtil.cpp.

vtblLabelBeforeDemangle

const std::string vtblLabelBeforeDemangle = "_ZTV"

Definition at line 50 of file CppUtil.cpp.

VThunkFuncLabel

const std::string VThunkFuncLabel = "virtual thunk to "

Definition at line 47 of file CppUtil.cpp.

zn1Label

const std::string zn1Label = "_ZN1"

Definition at line 60 of file CppUtil.cpp.

znk9Label

const std::string znk9Label = "_ZNK9"

Definition at line 77 of file CppUtil.cpp.

znkLabel

const std::string znkLabel = "_ZNK"

Definition at line 76 of file CppUtil.cpp.

znkst20Label

const std::string znkst20Label = "_ZNKSt20_"

Definition at line 71 of file CppUtil.cpp.

znkst23Label

const std::string znkst23Label = "_ZNKSt23_"

Definition at line 73 of file CppUtil.cpp.

znkst5Label

const std::string znkst5Label = "_ZNKSt15_"

Definition at line 70 of file CppUtil.cpp.

znkstLabel

const std::string znkstLabel = "_ZNKSt"

Definition at line 69 of file CppUtil.cpp.

znst12Label

const std::string znst12Label = "_ZNSt12"

Definition at line 63 of file CppUtil.cpp.

znst14Label

const std::string znst14Label = "_ZNSt14"

Definition at line 66 of file CppUtil.cpp.

znst5Label

const std::string znst5Label = "_ZNSt5"

Definition at line 62 of file CppUtil.cpp.

znst6Label

const std::string znst6Label = "_ZNSt6"

Definition at line 64 of file CppUtil.cpp.

znst7Label

const std::string znst7Label = "_ZNSt7"

Definition at line 65 of file CppUtil.cpp.

znstLabel

const std::string znstLabel = "_ZNSt"

Definition at line 61 of file CppUtil.cpp.

znwm

const std::string znwm = "_Znwm"

Definition at line 59 of file CppUtil.cpp.

ztilabel

const std::string ztilabel = "_ZTI"

Definition at line 79 of file CppUtil.cpp.

ztiprefix

const std::string ztiprefix = "typeinfo for "

Definition at line 80 of file CppUtil.cpp.