#include <cstdint>
#include <deque>
#include <llvm/Config/llvm-config.h>
#include "llvm/Demangle/Demangle.h"
#include "llvm/Demangle/ItaniumDemangle.h"
#include "llvm/IR/Constants.h"
#include "llvm/IR/Function.h"
#include "llvm/IR/InstrTypes.h"
#include "llvm/IR/Instructions.h"
#include "llvm/IR/IntrinsicInst.h"
#include "llvm/IR/ModuleSlotTracker.h"
#include "llvm/IR/Type.h"
#include "llvm/IR/Value.h"
#include "llvm/ProfileData/InstrProf.h"
#include "llvm/IR/InstIterator.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/TimeProfiler.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/ADT/SmallSet.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/ADT/StringSet.h"
#include "llvm/IR/InlineAsm.h"
#include "../EnzymeLogic.h"
#include "../Utils.h"
#include "TypeAnalysis.h"
#include "../FunctionUtils.h"
#include "../LibraryFuncs.h"
#include "TBAA.h"
#include <math.h>
#include "BlasTA.inc"

Include dependency graph for TypeAnalysis.cpp:

Classes
struct	TypeHandler< T >
	This template class is defined to take the templated type T update the analysis of the first argument (val) to be type T As such, below we have several template specializations to convert various c/c++ to TypeAnalysis types. More...

struct	TypeHandler< double >

struct	TypeHandler< float >

struct	TypeHandler< long double >

struct	TypeHandler< double * >

struct	TypeHandler< float * >

struct	TypeHandler< long double * >

struct	TypeHandler< void >

struct	TypeHandler< void * >

struct	TypeHandler< int >

struct	TypeHandler< int * >

struct	TypeHandler< unsigned int >

struct	TypeHandler< unsigned int * >

struct	TypeHandler< long int >

struct	TypeHandler< long int * >

struct	TypeHandler< long unsigned int >

struct	TypeHandler< long unsigned int * >

struct	TypeHandler< long long int >

struct	TypeHandler< long long int * >

struct	TypeHandler< long long unsigned int >

struct	TypeHandler< long long unsigned int * >

struct	FunctionArgumentIterator< Arg0 >

struct	FunctionArgumentIterator< Arg0, Args... >

Macros
#define	CONSIDER(fn)

#define	CONSIDER2(fn, ...)

Functions
llvm::cl::opt< int >	MaxIntOffset ("enzyme-max-int-offset", cl::init(100), cl::Hidden, cl::desc("Maximum type tree offset"))
	Maximum offset for type trees to keep.

llvm::cl::opt< unsigned >	EnzymeMaxTypeDepth ("enzyme-max-type-depth", cl::init(6), cl::Hidden, cl::desc("Maximum type tree depth"))

llvm::cl::opt< bool >	EnzymePrintType ("enzyme-print-type", cl::init(false), cl::Hidden, cl::desc("Print type analysis algorithm"))

llvm::cl::opt< bool >	RustTypeRules ("enzyme-rust-type", cl::init(false), cl::Hidden, cl::desc("Enable rust-specific type rules"))

llvm::cl::opt< bool >	EnzymeStrictAliasing ("enzyme-strict-aliasing", cl::init(true), cl::Hidden, cl::desc("Assume strict aliasing of types / type stability"))

static bool	isItaniumEncoding (StringRef S)

bool	dontAnalyze (StringRef str)

static SmallPtrSet< BasicBlock *, 1 >	findLoopIndices (llvm::Value val, LoopInfo &LI, DominatorTree &DT, SmallPtrSet< PHINode , 1 > &seen)

void	getConstantAnalysis (Constant Val, TypeAnalyzer &TA, std::map< llvm::Value , TypeTree > &analysis)
	Given a constant value, deduce any type information applicable.

static bool	AllJuliaTypes (Type *T)

static TypeTree	fortranDescriptorTree (Value *desc, const DataLayout &DL)
	Type of a pointer to an LLVM flang descriptor (CFI_cdesc_t).

static bool	AnyJuliaTypes (Type *T)

static void	AugmentWithJuliaObjectType (TypeTree &TT, Type *T, const DataLayout &DL)

static void	checkEnzymeTypeExtent (TypeAnalyzer TA, const TypeTree &TT, size_t RegSize, Instruction &I, Value Val)

template<typename T >
std::set< SmallVector< T, 4 > >	getSet (ArrayRef< std::set< T > > todo, size_t idx)

template<typename RT , typename... Args>
void	analyzeFuncTypesNoFn (CallBase &call, TypeAnalyzer &TA)

template<typename RT , typename... Args>
void	analyzeFuncTypes (RT(*fn)(Args...), CallBase &call, TypeAnalyzer &TA)

void	analyzeIntelSubscriptIntrinsic (IntrinsicInst &II, TypeAnalyzer &TA)

size_t	skippedBytes (SmallSet< size_t, 8 > &offs, Type *T, const DataLayout &DL, size_t offset=0)

TypeTree	defaultTypeTreeForLLVM (llvm::Type ET, llvm::Instruction I, bool intIsPointer)

FnTypeInfo	preventTypeAnalysisLoops (const FnTypeInfo &oldTypeInfo_, llvm::Function *todiff)

Variables
const llvm::StringMap< llvm::Intrinsic::ID >	LIBM_FUNCTIONS

Macro Definition Documentation

◆ CONSIDER

#define CONSIDER ( fn )

Value:

  if (funcName == #fn) {                                                       \
    analyzeFuncTypes(::fn, call, *this);                                       \
    return;                                                                    \
  }

Referenced by TypeAnalyzer::visitCallBase().

◆ CONSIDER2

#define CONSIDER2	(		fn,
			... )

Value:

  if (funcName == #fn) {                                                       \
    analyzeFuncTypesNoFn<__VA_ARGS__>(call, *this);                            \
    return;                                                                    \
  }

Referenced by TypeAnalyzer::visitCallBase().

Function Documentation

◆ AllJuliaTypes()

static bool AllJuliaTypes ( Type * T )

static

Definition at line 952 of file TypeAnalysis.cpp.

References AllJuliaTypes().

Referenced by AllJuliaTypes(), and AugmentWithJuliaObjectType().

◆ analyzeFuncTypes()

template<typename RT , typename... Args>

void analyzeFuncTypes	(	RT(*	fn )(Args...),
		CallBase &	call,
		TypeAnalyzer &	TA )

Definition at line 4587 of file TypeAnalysis.cpp.

References analyzeFuncTypesNoFn(), and Args.

◆ analyzeFuncTypesNoFn()

template<typename RT , typename... Args>

void analyzeFuncTypesNoFn	(	CallBase &	call,
		TypeAnalyzer &	TA )

Definition at line 4581 of file TypeAnalysis.cpp.

References FunctionArgumentIterator< Arg0 >::analyzeFuncTypesHelper().

Referenced by analyzeFuncTypes().

◆ analyzeIntelSubscriptIntrinsic()

void analyzeIntelSubscriptIntrinsic	(	IntrinsicInst &	II,
		TypeAnalyzer &	TA )

◆ AnyJuliaTypes()

static bool AnyJuliaTypes ( Type * T )

static

Definition at line 1002 of file TypeAnalysis.cpp.

References AnyJuliaTypes().

Referenced by AnyJuliaTypes(), and AugmentWithJuliaObjectType().

◆ AugmentWithJuliaObjectType()

static void AugmentWithJuliaObjectType	(	TypeTree &	TT,
		Type *	T,
		const DataLayout &	DL )

static

Definition at line 1022 of file TypeAnalysis.cpp.

References AllJuliaTypes(), AnyJuliaTypes(), TypeTree::insert(), Pointer, TypeTree::remove(), and Unknown.

Referenced by TypeAnalyzer::getAnalysis().

◆ checkEnzymeTypeExtent()

static void checkEnzymeTypeExtent	(	TypeAnalyzer *	TA,
		const TypeTree &	TT,
		size_t	RegSize,
		Instruction &	I,
		Value *	Val )

static

Definition at line 1411 of file TypeAnalysis.cpp.

References CustomErrorHandler, EmitFailure(), TypeTree::getMapping(), IllegalTypeAnalysis, str(), and TypeTree::str().

Referenced by TypeAnalyzer::considerTBAA().

◆ defaultTypeTreeForLLVM()

TypeTree defaultTypeTreeForLLVM	(	llvm::Type *	ET,
		llvm::Instruction *	I,
		bool	intIsPointer )

Definition at line 6785 of file TypeAnalysis.cpp.

References defaultTypeTreeForLLVM(), getAggregateElementOffset(), Integer, TypeTree::Only(), Pointer, and TypeTree::ShiftIndices().

Referenced by defaultTypeTreeForLLVM(), AdjointGenerator::visitCommonStore(), and AdjointGenerator::visitLoadLike().

◆ dontAnalyze()

bool dontAnalyze ( StringRef str )

Definition at line 237 of file TypeAnalysis.cpp.

References isItaniumEncoding(), and str().

Referenced by TypeAnalyzer::visitCallBase().

◆ EnzymeMaxTypeDepth()

llvm::cl::opt< unsigned > EnzymeMaxTypeDepth	(	"enzyme-max-type-depth"	,
		cl::init(6)	,
		cl::Hidden	,
		cl::desc("Maximum type tree depth")	)

◆ EnzymePrintType()

llvm::cl::opt< bool > EnzymePrintType	(	"enzyme-print-type"	,
		cl::init(false)	,
		cl::Hidden	,
		cl::desc("Print type analysis algorithm")	)

◆ EnzymeStrictAliasing()

llvm::cl::opt< bool > EnzymeStrictAliasing	(	"enzyme-strict-aliasing"	,
		cl::init(true)	,
		cl::Hidden	,
		cl::desc("Assume strict aliasing of types / type stability")	)