SVFIRBuilder.cpp File Reference

#include "SVF-LLVM/SVFIRBuilder.h"
#include "SVF-LLVM/BasicTypes.h"
#include "SVF-LLVM/CHGBuilder.h"
#include "SVF-LLVM/CppUtil.h"
#include "SVF-LLVM/LLVMLoopAnalysis.h"
#include "SVF-LLVM/LLVMUtil.h"
#include "SVF-LLVM/ObjTypeInference.h"
#include "SVF-LLVM/SymbolTableBuilder.h"
#include "SVFIR/PAGBuilderFromFile.h"
#include "Util/CallGraphBuilder.h"
#include "Graphs/CallGraph.h"
#include "Util/Options.h"
#include "Util/SVFUtil.h"

Go to the source code of this file.

Functions
static const Type *	getAggregateFieldType (const Type *type, const std::vector< unsigned > &indices)
	Return the type at a constant aggregate path, including fixed vector lanes.
static std::optional< unsigned >	getFixedVectorLane (const Type *type, const Value *index)
static bool	canModelAggregateReturn (const Function *fun)

Function Documentation

canModelAggregateReturn()

static bool canModelAggregateReturn ( const Function *  fun )

static

Require a returning, nonvariadic definition whose uses are all ordinary direct calls with matching types, so each call can pass the output pointers.

Definition at line 1558 of file SVFIRBuilder.cpp.

{
    if (!fun || LLVMUtil::isExtCall(fun) || fun->isVarArg() ||
            fun->doesNotReturn() || !fun->getReturnType()->isAggregateType() ||
            fun->hasAddressTaken())
        return false;
    for (const User* user : fun->users())
    {
        const auto* call = SVFUtil::dyn_cast<CallInst>(user);
        if (!call || call->getCalledFunction() != fun ||
                call->getFunctionType() != fun->getFunctionType())
            return false;
    }
    return true;
}

getAggregateFieldType()

static const Type * getAggregateFieldType ( const Type *  type, const std::vector< unsigned > &  indices  )

static

Return the type at a constant aggregate path, including fixed vector lanes.

Definition at line 1335 of file SVFIRBuilder.cpp.

{
    for (unsigned index : indices)
    {
        if (const auto* structure = SVFUtil::dyn_cast<StructType>(type))
        {
            if (index >= structure->getNumElements())
                return nullptr;
            type = structure->getElementType(index);
        }
        else if (const auto* array = SVFUtil::dyn_cast<ArrayType>(type))
        {
            if (index >= array->getNumElements())
                return nullptr;
            type = array->getElementType();
        }
        else if (const auto* vector = SVFUtil::dyn_cast<llvm::FixedVectorType>(type))
        {
            if (index >= vector->getNumElements())
                return nullptr;
            type = vector->getElementType();
        }
        else
            return nullptr;
    }
    return type;
}

getFixedVectorLane()

static std::optional< unsigned > getFixedVectorLane ( const Type *  type, const Value *  index  )

static

Return the selected fixed-vector lane, or no lane for other vector types, variable indices and out-of-range indices.

Definition at line 1366 of file SVFIRBuilder.cpp.

{
    const auto* vector = SVFUtil::dyn_cast<llvm::FixedVectorType>(type);
    const auto* constant = SVFUtil::dyn_cast<ConstantInt>(index);
    if (!vector || !constant ||
            constant->getValue().uge(vector->getNumElements()))
        return std::nullopt;
    return static_cast<unsigned>(constant->getZExtValue());
}