~ubuntu-branches/ubuntu/saucy/clamav/saucy-backports

#ifndef _WIN32

#include <sys/time.h>

#endif

#include "ClamBCModule.h"

#include "ClamBCDiagnostics.h"

#include "llvm/ADT/DenseMap.h"

#include "llvm/ADT/BitVector.h"

#include "llvm/ADT/PostOrderIterator.h"

#include "llvm/Analysis/ScalarEvolution.h"

#include "llvm/Analysis/Verifier.h"

#include "llvm/AutoUpgrade.h"

#include "llvm/ExecutionEngine/ExecutionEngine.h"

#include "llvm/ExecutionEngine/JIT.h"

#include "llvm/ExecutionEngine/JITEventListener.h"

#include "llvm/PassManager.h"

#include "llvm/Support/Compiler.h"

#include "llvm/Support/Debug.h"

#include "llvm/Support/MemoryBuffer.h"

#include "llvm/Support/raw_ostream.h"

#include "llvm/Support/SourceMgr.h"

#include "llvm/Support/PrettyStackTrace.h"

 

#ifdef LLVM29

#include "llvm/Support/Signals.h"

#include "llvm/Support/Threading.h"

#include "llvm/Support/ThreadLocal.h"

#include "llvm/IntrinsicInst.h"

#else

#include "llvm/System/DataTypes.h"

#include "llvm/System/Host.h"

#else

#include "llvm/Target/TargetSelect.h"

#endif

#include "llvm/Target/TargetOptions.h"

#include "llvm/Support/TargetFolder.h"

#include "llvm/Transforms/Scalar.h"

#include <cerrno>

#include <string>

 

//#define TIMING

#undef TIMING

 

#include "llvm/Config/config.h"

#if !ENABLE_THREADS

#error "Thread support was explicitly disabled. Cannot continue"

#endif

 

#ifdef _GLIBCXX_PARALLEL

#error "libstdc++ parallel mode is not supported for ClamAV. Please remove -D_GLIBCXX_PARALLEL from CXXFLAGS!"

#undef PACKAGE_URL

#include "clamav-config.h"

#endif

#include "dconf.h"

#include "clamav.h"

#include "clambc.h"

#include "bytecode.h"

#include "bytecode_priv.h"

#include "type_desc.h"

 

#define MODULE "libclamav JIT: "

 

    jit_exception_handler();

}

 

void llvm_error_handler(void *user_data, const std::string &reason)

{

    // Output it to stderr, it might exceed the 1k/4k limit of cli_errmsg

    cli_errmsg("[Bytecode JIT]: [LLVM error] %s\n", reason.c_str());

        if (!cli_debug_flag)

            return;

        cli_dbgmsg_internal("[Bytecode JIT]: emitted function %s of %ld bytes at %p\n",

                            F.getNameStr().c_str(), (long)Size, Code);

    }

};

 

        CallInst* AbrtC = CallInst::Create(func_abort, "", AbrtBB);

        AbrtC->setCallingConv(CallingConv::C);

        AbrtC->setTailCall(true);

        AbrtC->setDoesNotReturn(true);

        AbrtC->setDoesNotThrow(true);

        new UnreachableInst(F.getContext(), AbrtBB);

        IRBuilder<false> Builder(F.getContext());

 

        : bc(bc), M(M), Context(M->getContext()), EE(EE),

        PM(PM),PMUnsigned(PMUnsigned), TypeMap(), apiFuncs(apiFuncs),apiMap(apiMap),

        compiledFunctions(cFuncs), BytecodeID("bc"+Twine(bc->id)),

        Folder(EE->getTargetData()), Builder(Context, Folder), Values(), CF(CF) {

 

        for (unsigned i=0;i<cli_apicall_maxglobal - _FIRST_GLOBAL;i++) {

            unsigned id = cli_globals[i].globalid;

            }

            V = SI->getOperand(0);

        }

        if (EE->getTargetData()->getPointerSize() == 8) {

            // eliminate useless trunc, GEP can take i64 too

            if (TruncInst *I = dyn_cast<TruncInst>(V)) {

                Value *Src = I->getOperand(0);

            Functions[j]->setLinkage(GlobalValue::InternalLinkage);

#ifdef C_LINUX

            /* bb #2270, this should really be fixed either by LLVM or GCC.*/

            Functions[j]->addFnAttr(Attribute::constructStackAlignmentFromInt(16));

#endif

        }

        constType *I32Ty = Type::getInt32Ty(Context);

                            }

                            CallInst *CI = Builder.CreateCall(DestF, ARRAYREF(Value*, args.begin(), args.end()));

                            CI->setCallingConv(CallingConv::Fast);

                            CI->setDoesNotThrow(true);

                            if (CI->getType()->getTypeID() != Type::VoidTyID)

                                Store(inst->dest, CI);

                            break;

                                args.push_back(convertOperand(func, DestF->getFunctionType()->getParamType(a+1), op));

                            }

                            CallInst *CI = Builder.CreateCall(DestF, ARRAYREFVECTOR(Value*, args));

                            CI->setDoesNotThrow(true);

                            Store(inst->dest, CI);

                            }

                            break;

                            Dst = Builder.CreatePointerCast(Dst, PointerType::getUnqual(Type::getInt8Ty(Context)));

                            Value *Src = convertOperand(func, inst, inst->u.three[1]);

                            Src = Builder.CreatePointerCast(Src, PointerType::getUnqual(Type::getInt8Ty(Context)));

                            Value *Len = convertOperand(func, EE->getTargetData()->getIntPtrType(Context), inst->u.three[2]);

                            CallInst *c = Builder.CreateCall3(CF->FRealmemcmp, Dst, Src, Len);

                            c->setTailCall(true);

                            c->setDoesNotThrow();

                            {

                                CallInst *C = Builder.CreateCall(CF->FBSwap16, convertOperand(func, inst, inst->u.unaryop));

                                C->setTailCall(true);

                                C->setDoesNotThrow(true);

                                Store(inst->dest, C);

                                break;

                            }

                            {

                                CallInst *C = Builder.CreateCall(CF->FBSwap32, convertOperand(func, inst, inst->u.unaryop));

                                C->setTailCall(true);

                                C->setDoesNotThrow(true);

                                Store(inst->dest, C);

                                break;

                            }

                            {

                                CallInst *C = Builder.CreateCall(CF->FBSwap64, convertOperand(func, inst, inst->u.unaryop));

                                C->setTailCall(true);

                                C->setDoesNotThrow(true);

                                Store(inst->dest, C);

                                break;

                            }

        // entrypoint can only be C, emit wrapper

        Function *F = Function::Create(Functions[0]->getFunctionType(),

                                       Function::ExternalLinkage,

                                       Functions[0]->getName()+"_wrap", M);

        F->setDoesNotThrow();

        BasicBlock *BB = BasicBlock::Create(Context, "", F);

        std::vector<Value*> Args;

                                          "clamjit.fail", M);

    CF->FHandler->setDoesNotReturn();

    CF->FHandler->setDoesNotThrow();

    CF->FHandler->addFnAttr(Attribute::NoInline);

    EE->addGlobalMapping(CF->FHandler, (void*)(intptr_t)jit_exception_handler);

    EE->InstallLazyFunctionCreator(noUnknownFunctions);

    EE->getPointerToFunction(CF->FHandler);

#endif

                                         M);

    CF->FMemset->setDoesNotThrow();

    CF->FMemset->setDoesNotCapture(1, true);

 

    args.clear();

    args.push_back(PointerType::getUnqual(Type::getInt8Ty(Context)));

#endif

                                          M);

    CF->FMemmove->setDoesNotThrow();

    CF->FMemmove->setDoesNotCapture(1, true);

 

    CF->FMemcpy = Function::Create(FuncTy_4, GlobalValue::ExternalLinkage,

#ifdef LLVM30

#endif

                                         M);

    CF->FMemcpy->setDoesNotThrow();

    CF->FMemcpy->setDoesNotCapture(1, true);

 

    args.clear();

    args.push_back(Type::getInt16Ty(Context));

    args.clear();

    args.push_back(PointerType::getUnqual(Type::getInt8Ty(Context)));

    args.push_back(PointerType::getUnqual(Type::getInt8Ty(Context)));

    args.push_back(EE->getTargetData()->getIntPtrType(Context));

    FuncTy_5 = FunctionType::get(Type::getInt32Ty(Context),

                                 args, false);

    CF->FRealmemcmp = Function::Create(FuncTy_5, GlobalValue::ExternalLinkage, "memcmp", M);

static unsigned char name_salt[16] = { 16, 38, 97, 12, 8, 4, 72, 196, 217, 144, 33, 124, 18, 11, 17, 253 };

static void setGuard(unsigned char* guardbuf)

{

    char salt[48];

    memcpy(salt, name_salt, 16);

    for(unsigned i = 16; i < 48; i++)

 

}

static void addFPasses(FunctionPassManager &FPM, bool trusted, const TargetData *TD)

{

    // Set up the optimizer pipeline.  Start with registering info about how

    // the target lays out data structures.

    FPM.add(new TargetData(*TD));

    // Promote allocas to registers.

    FPM.add(createPromoteMemoryToRegisterPass());

    FPM.add(new BrSimplifier());

        // Create the JIT.

        std::string ErrorMsg;

        EngineBuilder builder(M);

        builder.setErrorStr(&ErrorMsg);

        builder.setEngineKind(EngineKind::JIT);

        builder.setOptLevel(CodeGenOpt::Default);

        addFunctionProtos(&CF, EE, M);

 

        FunctionPassManager OurFPM(M), OurFPMUnsigned(M);

        M->setDataLayout(EE->getTargetData()->getStringRepresentation());

        M->setTargetTriple(sys::getHostTriple());

        addFPasses(OurFPM, true, EE->getTargetData());

        addFPasses(OurFPMUnsigned, false, EE->getTargetData());

 

        //TODO: create a wrapper that calls pthread_getspecific

        unsigned maxh = cli_globals[0].offset + sizeof(struct cli_bc_hooks);

            }

        }

        PassManager PM;

        PM.add(new TargetData(*EE->getTargetData()));

        // TODO: only run this on the untrusted bytecodes, not all of them...

        if (has_untrusted)

            PM.add(createClamBCRTChecks());

    llvm_install_error_handler(llvm_error_handler);

#ifdef CL_DEBUG

    sys::PrintStackTraceOnErrorSignal();

#else

    llvm::DisablePrettyStackTrace = true;

#endif

    atexit(do_shutdown);

 

#ifdef CL_DEBUG

    //disable this for now, it leaks

    llvm::JITEmitDebugInfo = false;

    llvm::JITEmitDebugInfo = false;

#endif

    llvm::DwarfExceptionHandling = false;

    llvm_start_multithreaded();

 

    // If we have a native target, initialize it to ensure it is linked in and

void stop(const char *msg, llvm::Function* F, llvm::Instruction* I)

{

    if (F && F->hasName()) {

        cli_warnmsg("[Bytecode JIT] in function %s: %s", F->getNameStr().c_str(), msg);

    } else {

        cli_warnmsg("[Bytecode JIT] %s", msg);

    }

static bool getLocationInfo(const Value *V, std::string &DisplayName,

                            std::string &Type, unsigned &LineNo,

                            std::string &File, std::string &Dir) {

  DICompileUnit Unit;

  DIType TypeD;

 

  if (GlobalVariable *GV = dyn_cast<GlobalVariable>(const_cast<Value*>(V))) {

    if (!D.empty())

      DisplayName = D;

    LineNo = Var.getLineNumber();

    Unit = Var.getCompileUnit();

    TypeD = Var.getType();

  } else if (Function *F = dyn_cast<Function>(const_cast<Value*>(V))){

    Value *DIF = findDbgSubprogramDeclare(F);

    if (!D.empty())

      DisplayName = D;

    LineNo = Var.getLineNumber();

    Unit = Var.getCompileUnit();

    TypeD = Var.getType();

  } else {

    const DbgDeclareInst *DDI = findDbgDeclare(V);

    if (!D.empty())

      DisplayName = D;

    LineNo = Var.getLineNumber();

    Unit = Var.getCompileUnit();

    TypeD = Var.getType();

  }

 

  StringRef T = TypeD.getName();

  if (!T.empty())

    Type = T;

  return true;

}

#endif