retdec
Namespaces | Macros | Functions
llvmir_emul.cpp File Reference

LLVM IR emulator library. More...

#include <llvm/IR/CallSite.h>
#include <llvm/IR/GetElementPtrTypeIterator.h>
#include <llvm/IR/IRBuilder.h>
#include <llvm/IR/InstVisitor.h>
#include <llvm/IR/LLVMContext.h>
#include <llvm/IR/Module.h>
#include <llvm/IR/Type.h>
#include <llvm/Support/CommandLine.h>
#include <llvm/Support/Debug.h>
#include <llvm/Support/DynamicLibrary.h>
#include <llvm/Support/Format.h>
#include <llvm/Support/ManagedStatic.h>
#include <llvm/Support/MathExtras.h>
#include <llvm/Support/Memory.h>
#include <llvm/Support/MemoryBuffer.h>
#include <llvm/Support/Path.h>
#include <llvm/Support/PrettyStackTrace.h>
#include <llvm/Support/Process.h>
#include <llvm/Support/Program.h>
#include <llvm/Support/Signals.h>
#include <llvm/Support/SourceMgr.h>
#include <llvm/Support/TargetSelect.h>
#include <llvm/Support/raw_ostream.h>
#include "retdec/llvmir-emul/llvmir_emul.h"

Namespaces

 retdec
 
 retdec::llvmir_emul
 

Macros

#define IMPLEMENT_BINARY_OPERATOR(OP, TY)
 
#define IMPLEMENT_INTEGER_ICMP(OP, TY)
 
#define IMPLEMENT_VECTOR_INTEGER_ICMP(OP, TY)
 
#define IMPLEMENT_POINTER_ICMP(OP)
 
#define IMPLEMENT_FCMP(OP, TY)
 
#define IMPLEMENT_VECTOR_FCMP_T(OP, TY)
 
#define IMPLEMENT_VECTOR_FCMP(OP)
 
#define IMPLEMENT_SCALAR_NANS(TY, X, Y)
 
#define MASK_VECTOR_NANS_T(X, Y, TZ, FLAG)
 
#define MASK_VECTOR_NANS(TY, X, Y, FLAG)
 
#define IMPLEMENT_UNORDERED(TY, X, Y)
 
#define IMPLEMENT_VECTOR_UNORDERED(TY, X, Y, FUNC)
 
#define INTEGER_VECTOR_OPERATION(OP)
 
#define INTEGER_VECTOR_FUNCTION(OP)
 
#define FLOAT_VECTOR_FUNCTION(OP, TY)
 
#define FLOAT_VECTOR_OP(OP)
 

Functions

unsigned retdec::llvmir_emul::getShiftAmount (uint64_t orgShiftAmount, llvm::APInt valueToShift)
 

Detailed Description

LLVM IR emulator library.

Macro Definition Documentation

◆ FLOAT_VECTOR_FUNCTION

#define FLOAT_VECTOR_FUNCTION (   OP,
  TY 
)
Value:
for (unsigned i = 0; i < res.AggregateVal.size(); ++i) \
res.AggregateVal[i].TY = \
op0.AggregateVal[i].TY OP op1.AggregateVal[i].TY;

◆ FLOAT_VECTOR_OP

#define FLOAT_VECTOR_OP (   OP)
Value:
{ \
if (cast<VectorType>(ty)->getElementType()->isFloatTy()) \
FLOAT_VECTOR_FUNCTION(OP, FloatVal) \
else \
{ \
if (cast<VectorType>(ty)->getElementType()->isDoubleTy()) \
FLOAT_VECTOR_FUNCTION(OP, DoubleVal) \
else \
{ \
dbgs() << "Unhandled type for OP instruction: " << *ty << "\n"; \
llvm_unreachable(0); \
} \
} \
}

◆ IMPLEMENT_BINARY_OPERATOR

#define IMPLEMENT_BINARY_OPERATOR (   OP,
  TY 
)
Value:
case Type::TY##TyID: \
Dest.TY##Val = Src1.TY##Val OP Src2.TY##Val; \
break

◆ IMPLEMENT_FCMP

#define IMPLEMENT_FCMP (   OP,
  TY 
)
Value:
case Type::TY##TyID: \
Dest.IntVal = APInt(1,Src1.TY##Val OP Src2.TY##Val); \
break

◆ IMPLEMENT_INTEGER_ICMP

#define IMPLEMENT_INTEGER_ICMP (   OP,
  TY 
)
Value:
case Type::IntegerTyID: \
Dest.IntVal = APInt(1,Src1.IntVal.OP(Src2.IntVal)); \
break;

◆ IMPLEMENT_POINTER_ICMP

#define IMPLEMENT_POINTER_ICMP (   OP)
Value:
case Type::PointerTyID: \
Dest.IntVal = APInt(1, reinterpret_cast<void*>(reinterpret_cast<intptr_t>(Src1.PointerVal)) OP \
reinterpret_cast<void*>(reinterpret_cast<intptr_t>(Src2.PointerVal))); \
break;

◆ IMPLEMENT_SCALAR_NANS

#define IMPLEMENT_SCALAR_NANS (   TY,
  X,
 
)
Value:
if (TY->isFloatTy()) \
{ \
if (X.FloatVal != X.FloatVal || Y.FloatVal != Y.FloatVal) \
{ \
Dest.IntVal = APInt(1,false); \
return Dest; \
} \
} \
else \
{ \
if (X.DoubleVal != X.DoubleVal || Y.DoubleVal != Y.DoubleVal) \
{ \
Dest.IntVal = APInt(1,false); \
return Dest; \
} \
}
static RegisterPass< AsmInstructionRemover > X("retdec-remove-asm-instrs", "Assembly mapping instruction removal", false, false)

◆ IMPLEMENT_UNORDERED

#define IMPLEMENT_UNORDERED (   TY,
  X,
 
)
Value:
if (TY->isFloatTy()) \
{ \
if (X.FloatVal != X.FloatVal || Y.FloatVal != Y.FloatVal) \
{ \
Dest.IntVal = APInt(1,true); \
return Dest; \
} \
} else if (X.DoubleVal != X.DoubleVal || Y.DoubleVal != Y.DoubleVal) \
{ \
Dest.IntVal = APInt(1,true); \
return Dest; \
}

◆ IMPLEMENT_VECTOR_FCMP

#define IMPLEMENT_VECTOR_FCMP (   OP)
Value:
case Type::VectorTyID: \
if (cast<VectorType>(Ty)->getElementType()->isFloatTy()) \
{ \
IMPLEMENT_VECTOR_FCMP_T(OP, Float); \
} \
else \
{ \
IMPLEMENT_VECTOR_FCMP_T(OP, Double); \
}

◆ IMPLEMENT_VECTOR_FCMP_T

#define IMPLEMENT_VECTOR_FCMP_T (   OP,
  TY 
)
Value:
assert(Src1.AggregateVal.size() == Src2.AggregateVal.size()); \
Dest.AggregateVal.resize( Src1.AggregateVal.size() ); \
for( uint32_t _i=0;_i<Src1.AggregateVal.size();_i++) \
Dest.AggregateVal[_i].IntVal = APInt(1, \
Src1.AggregateVal[_i].TY##Val OP Src2.AggregateVal[_i].TY##Val);\
break;

◆ IMPLEMENT_VECTOR_INTEGER_ICMP

#define IMPLEMENT_VECTOR_INTEGER_ICMP (   OP,
  TY 
)
Value:
case Type::VectorTyID: \
{ \
assert(Src1.AggregateVal.size() == Src2.AggregateVal.size()); \
Dest.AggregateVal.resize( Src1.AggregateVal.size() ); \
for(uint32_t _i=0;_i<Src1.AggregateVal.size();_i++) \
Dest.AggregateVal[_i].IntVal = APInt(1, \
Src1.AggregateVal[_i].IntVal.OP(Src2.AggregateVal[_i].IntVal));\
} break;

◆ IMPLEMENT_VECTOR_UNORDERED

#define IMPLEMENT_VECTOR_UNORDERED (   TY,
  X,
  Y,
  FUNC 
)
Value:
if (TY->isVectorTy()) \
{ \
GenericValue DestMask = Dest; \
Dest = FUNC(Src1, Src2, Ty); \
for (size_t _i = 0; _i < Src1.AggregateVal.size(); _i++) \
if (DestMask.AggregateVal[_i].IntVal == true) \
Dest.AggregateVal[_i].IntVal = APInt(1, true); \
return Dest; \
}

◆ INTEGER_VECTOR_FUNCTION

#define INTEGER_VECTOR_FUNCTION (   OP)
Value:
for (unsigned i = 0; i < res.AggregateVal.size(); ++i) \
res.AggregateVal[i].IntVal = \
op0.AggregateVal[i].IntVal.OP(op1.AggregateVal[i].IntVal);

◆ INTEGER_VECTOR_OPERATION

#define INTEGER_VECTOR_OPERATION (   OP)
Value:
for (unsigned i = 0; i < res.AggregateVal.size(); ++i) \
res.AggregateVal[i].IntVal = \
op0.AggregateVal[i].IntVal OP op1.AggregateVal[i].IntVal;

◆ MASK_VECTOR_NANS

#define MASK_VECTOR_NANS (   TY,
  X,
  Y,
  FLAG 
)
Value:
if (TY->isVectorTy()) \
{ \
if (cast<VectorType>(TY)->getElementType()->isFloatTy()) \
{ \
MASK_VECTOR_NANS_T(X, Y, Float, FLAG) \
} \
else \
{ \
MASK_VECTOR_NANS_T(X, Y, Double, FLAG) \
} \
}

◆ MASK_VECTOR_NANS_T

#define MASK_VECTOR_NANS_T (   X,
  Y,
  TZ,
  FLAG 
)
Value:
assert(X.AggregateVal.size() == Y.AggregateVal.size()); \
Dest.AggregateVal.resize( X.AggregateVal.size() ); \
for( uint32_t _i=0;_i<X.AggregateVal.size();_i++) \
{ \
if (X.AggregateVal[_i].TZ##Val != X.AggregateVal[_i].TZ##Val || \
Y.AggregateVal[_i].TZ##Val != Y.AggregateVal[_i].TZ##Val) \
Dest.AggregateVal[_i].IntVal = APInt(1,FLAG); \
else \
{ \
Dest.AggregateVal[_i].IntVal = APInt(1,!FLAG); \
} \
}