ae.cpp File Reference

#include "SVF-LLVM/SVFIRBuilder.h"
#include "WPA/WPAPass.h"
#include "Util/CommandLine.h"
#include "Util/Options.h"
#include "WPA/Andersen.h"
#include "AE/Core/RelExeState.h"
#include "AE/Core/RelationSolver.h"
#include "AE/Svfexe/AbstractInterpretation.h"
#include <chrono>

Go to the source code of this file.

Classes
class	SymblicAbstractionTest
class	AETest

Functions
int	main (int argc, char **argv)

Variables
static Option< bool >	SYMABS ("symabs", "symbolic abstraction test", false)
static Option< bool >	AETEST ("aetest", "abstract execution basic function test", false)

Function Documentation

main()

int main	(	int	argc,
		char **	argv
	)

Definition at line 849 of file ae.cpp.

{
    int arg_num = 0;
    int extraArgc = 3;
    char **arg_value = new char *[argc + extraArgc];
    for (; arg_num < argc; ++arg_num)
    {
        arg_value[arg_num] = argv[arg_num];
    }
    // add extra options
    arg_value[arg_num++] = (char*) "-model-consts=true";
    arg_value[arg_num++] = (char*) "-model-arrays=true";
    arg_value[arg_num++] = (char*) "-pre-field-sensitive=false";
    assert(arg_num == (argc + extraArgc) && "more extra arguments? Change the value of extraArgc");
 
    std::vector<std::string> moduleNameVec;
    moduleNameVec = OptionBase::parseOptions(
                        arg_num, arg_value, "Static Symbolic Execution", "[options] <input-bitcode...>"
                    );
    delete[] arg_value;
    if (SYMABS())
    {
        SymblicAbstractionTest saTest;
        saTest.testsValidation();
        return 0;
    }
 
    if (AETEST())
    {
        AETest aeTest;
        aeTest.testBinaryOpStmt();
        aeTest.testAbsState();
        return 0;
    }
 
    LLVMModuleSet::getLLVMModuleSet()->buildSVFModule(moduleNameVec);
    SVFIRBuilder builder;
    SVFIR* pag = builder.build();
    // Run Andersen's to resolve indirect calls, then update SVFIR with resolved targets.
    // The Andersen singleton will be reused inside AbstractInterpretation::runOnModule().
    AndersenWaveDiff* ander = AndersenWaveDiff::createAndersenWaveDiff(pag);
    builder.updateCallGraph(ander->getCallGraph());
    AbstractInterpretation& ae = AbstractInterpretation::getAEInstance();
    if (Options::BufferOverflowCheck())
        ae.addDetector(std::make_unique<BufOverflowDetector>());
    if (Options::NullDerefCheck())
        ae.addDetector(std::make_unique<NullptrDerefDetector>());
    ae.runOnModule();
 
    AndersenWaveDiff::releaseAndersenWaveDiff();
    LLVMModuleSet::releaseLLVMModuleSet();
 
    return 0;
}

Variable Documentation

AETEST

Option< bool > AETEST("aetest", "abstract execution basic function test", false) ( "aetest"  , "abstract execution basic function test"  , false    )

static

SYMABS

Option< bool > SYMABS("symabs", "symbolic abstraction test", false) ( "symabs"  , "symbolic abstraction test"  , false    )

static