Intel SPMD Program Compiler  1.9.2
Public Member Functions | Private Member Functions | Static Private Member Functions | Private Attributes | List of all members
FunctionEmitContext Class Reference

#include <ctx.h>

Collaboration diagram for FunctionEmitContext:
Collaboration graph
[legend]

Public Member Functions

 FunctionEmitContext (Function *function, Symbol *funSym, llvm::Function *llvmFunction, SourcePos firstStmtPos)
 
 ~FunctionEmitContext ()
 
const FunctionGetFunction () const
 
Current basic block management
llvm::BasicBlock * GetCurrentBasicBlock ()
 
void SetCurrentBasicBlock (llvm::BasicBlock *bblock)
 
Mask management
llvm::Value * GetFunctionMask ()
 
llvm::Value * GetInternalMask ()
 
llvm::Value * GetFullMask ()
 
llvm::Value * GetFullMaskPointer ()
 
void SetFunctionMask (llvm::Value *val)
 
void SetInternalMask (llvm::Value *val)
 
void SetInternalMaskAnd (llvm::Value *oldMask, llvm::Value *val)
 
void SetInternalMaskAndNot (llvm::Value *oldMask, llvm::Value *test)
 
void BranchIfMaskAny (llvm::BasicBlock *btrue, llvm::BasicBlock *bfalse)
 
void BranchIfMaskAll (llvm::BasicBlock *btrue, llvm::BasicBlock *bfalse)
 
void BranchIfMaskNone (llvm::BasicBlock *btrue, llvm::BasicBlock *bfalse)
 
Small helper/utility routines
llvm::Value * Any (llvm::Value *mask)
 
llvm::Value * All (llvm::Value *mask)
 
llvm::Value * None (llvm::Value *mask)
 
llvm::Value * LaneMask (llvm::Value *mask)
 
llvm::Value * MasksAllEqual (llvm::Value *mask1, llvm::Value *mask2)
 
llvm::Value * ProgramIndexVector (bool is32bits=true)
 
llvm::Value * GetStringPtr (const std::string &str)
 
llvm::BasicBlock * CreateBasicBlock (const char *name)
 
llvm::Value * I1VecToBoolVec (llvm::Value *b)
 
void AddInstrumentationPoint (const char *note)
 
Debugging support
void SetDebugPos (SourcePos pos)
 
SourcePos GetDebugPos () const
 
void AddDebugPos (llvm::Value *instruction, const SourcePos *pos=NULL, llvm::DIScope *scope=NULL)
 
void StartScope ()
 
void EndScope ()
 
llvm::DIScope GetDIScope () const
 
void EmitVariableDebugInfo (Symbol *sym)
 
void EmitFunctionParameterDebugInfo (Symbol *sym, int parameterNum)
 
IR instruction emission

These methods generally closely correspond to LLVM IR instructions. See the LLVM assembly language reference manual (http://llvm.org/docs/LangRef.html) and the LLVM doxygen documentaion (http://llvm.org/doxygen) for more information. Here we will only document significant generalizations to the functionality of the corresponding basic LLVM instructions.

Beyond actually emitting the instruction, the implementations of these methods in FunctionEmitContext also handle adding debugging metadata if debugging symbols are enabled, adding the instructions to the current basic block, and handling generalizations like 'varying' lvalues, arithmetic operations with VectorType operands, etc.

llvm::Value * BinaryOperator (llvm::Instruction::BinaryOps inst, llvm::Value *v0, llvm::Value *v1, const char *name=NULL)
 
llvm::Value * NotOperator (llvm::Value *v, const char *name=NULL)
 
llvm::Value * CmpInst (llvm::Instruction::OtherOps inst, llvm::CmpInst::Predicate pred, llvm::Value *v0, llvm::Value *v1, const char *name=NULL)
 
llvm::Value * SmearUniform (llvm::Value *value, const char *name=NULL)
 
llvm::Value * BitCastInst (llvm::Value *value, llvm::Type *type, const char *name=NULL)
 
llvm::Value * PtrToIntInst (llvm::Value *value, const char *name=NULL)
 
llvm::Value * PtrToIntInst (llvm::Value *value, llvm::Type *type, const char *name=NULL)
 
llvm::Value * IntToPtrInst (llvm::Value *value, llvm::Type *type, const char *name=NULL)
 
llvm::Instruction * TruncInst (llvm::Value *value, llvm::Type *type, const char *name=NULL)
 
llvm::Instruction * CastInst (llvm::Instruction::CastOps op, llvm::Value *value, llvm::Type *type, const char *name=NULL)
 
llvm::Instruction * FPCastInst (llvm::Value *value, llvm::Type *type, const char *name=NULL)
 
llvm::Instruction * SExtInst (llvm::Value *value, llvm::Type *type, const char *name=NULL)
 
llvm::Instruction * ZExtInst (llvm::Value *value, llvm::Type *type, const char *name=NULL)
 
void MatchIntegerTypes (llvm::Value **v0, llvm::Value **v1)
 
llvm::Value * MakeSlicePointer (llvm::Value *ptr, llvm::Value *offset)
 
llvm::Value * GetElementPtrInst (llvm::Value *basePtr, llvm::Value *index, const Type *ptrType, const char *name=NULL)
 
llvm::Value * GetElementPtrInst (llvm::Value *basePtr, llvm::Value *index0, llvm::Value *index1, const Type *ptrType, const char *name=NULL)
 
llvm::Value * AddElementOffset (llvm::Value *basePtr, int elementNum, const Type *ptrType, const char *name=NULL, const PointerType **resultPtrType=NULL)
 
llvm::Value * LoadInst (llvm::Value *ptr, llvm::Value *mask, const Type *ptrType, const char *name=NULL, bool one_elem=false)
 
llvm::Value * LoadInst (llvm::Value *ptr, const char *name=NULL)
 
llvm::Value * AllocaInst (llvm::Type *llvmType, const char *name=NULL, int align=0, bool atEntryBlock=true)
 
void StoreInst (llvm::Value *value, llvm::Value *ptr)
 
void StoreInst (llvm::Value *value, llvm::Value *ptr, llvm::Value *storeMask, const Type *valueType, const Type *ptrType)
 
void MemcpyInst (llvm::Value *dest, llvm::Value *src, llvm::Value *count, llvm::Value *align=NULL)
 
void BranchInst (llvm::BasicBlock *block)
 
void BranchInst (llvm::BasicBlock *trueBlock, llvm::BasicBlock *falseBlock, llvm::Value *test)
 
llvm::Value * ExtractInst (llvm::Value *v, int elt, const char *name=NULL)
 
llvm::Value * InsertInst (llvm::Value *v, llvm::Value *eltVal, int elt, const char *name=NULL)
 
llvm::Value * ShuffleInst (llvm::Value *v1, llvm::Value *v2, llvm::Value *mask, const char *name=NULL)
 
llvm::Value * BroadcastValue (llvm::Value *v, llvm::Type *vecType, const char *name=NULL)
 
llvm::PHINode * PhiNode (llvm::Type *type, int count, const char *name=NULL)
 
llvm::Instruction * SelectInst (llvm::Value *test, llvm::Value *val0, llvm::Value *val1, const char *name=NULL)
 
llvm::Value * CallInst (llvm::Value *func, const FunctionType *funcType, const std::vector< llvm::Value * > &args, const char *name=NULL)
 
llvm::Value * CallInst (llvm::Value *func, const FunctionType *funcType, llvm::Value *arg, const char *name=NULL)
 
llvm::Value * CallInst (llvm::Value *func, const FunctionType *funcType, llvm::Value *arg0, llvm::Value *arg1, const char *name=NULL)
 
llvm::Value * LaunchInst (llvm::Value *callee, std::vector< llvm::Value * > &argVals, llvm::Value *launchCount[3])
 
void SyncInst ()
 
llvm::Instruction * ReturnInst ()
 

Private Member Functions

llvm::Value * pointerVectorToVoidPointers (llvm::Value *value)
 
bool ifsInCFAllUniform (int cfType) const
 
void jumpIfAllLoopLanesAreDone (llvm::BasicBlock *target)
 
llvm::Value * emitGatherCallback (llvm::Value *lvalue, llvm::Value *retPtr)
 
llvm::Value * applyVaryingGEP (llvm::Value *basePtr, llvm::Value *index, const Type *ptrType)
 
void restoreMaskGivenReturns (llvm::Value *oldMask)
 
void addSwitchMaskCheck (llvm::Value *mask)
 
bool inSwitchStatement () const
 
llvm::Value * getMaskAtSwitchEntry ()
 
CFInfopopCFState ()
 
void scatter (llvm::Value *value, llvm::Value *ptr, const Type *valueType, const Type *ptrType, llvm::Value *mask)
 
void maskedStore (llvm::Value *value, llvm::Value *ptr, const Type *ptrType, llvm::Value *mask)
 
void storeUniformToSOA (llvm::Value *value, llvm::Value *ptr, llvm::Value *mask, const Type *valueType, const PointerType *ptrType)
 
llvm::Value * loadUniformFromSOA (llvm::Value *ptr, llvm::Value *mask, const PointerType *ptrType, const char *name)
 
llvm::Value * gather (llvm::Value *ptr, const PointerType *ptrType, llvm::Value *mask, const char *name)
 
llvm::Value * addVaryingOffsetsIfNeeded (llvm::Value *ptr, const Type *ptrType)
 

Static Private Member Functions

static bool initLabelBBlocks (ASTNode *node, void *data)
 
static void addGSMetadata (llvm::Value *inst, SourcePos pos)
 

Private Attributes

Functionfunction
 
llvm::Function * llvmFunction
 
llvm::BasicBlock * allocaBlock
 
llvm::BasicBlock * bblock
 
llvm::Value * fullMaskPointer
 
llvm::Value * internalMaskPointer
 
llvm::Value * functionMaskValue
 
SourcePos currentPos
 
SourcePos funcStartPos
 
llvm::Value * blockEntryMask
 
llvm::Value * breakLanesPtr
 
llvm::Value * continueLanesPtr
 
llvm::BasicBlock * breakTarget
 
llvm::BasicBlock * continueTarget
 
llvm::Value * returnedLanesPtr
 
llvm::Value * returnValuePtr
 
std::vector< CFInfo * > controlFlowInfo
 
llvm::DIFile diFile
 
llvm::DISubprogram diSubprogram
 
std::vector< llvm::DILexicalBlock > debugScopes
 
bool launchedTasks
 
llvm::Value * launchGroupHandlePtr
 
int disableGSWarningCount
 
std::map< std::string, llvm::BasicBlock * > labelMap
 
Switch statement state

These variables store various state that's active when we're generating code for a switch statement. They should all be NULL outside of a switch.

llvm::Value * switchExpr
 
const std::vector< std::pair< int, llvm::BasicBlock * > > * caseBlocks
 
llvm::BasicBlock * defaultBlock
 
const std::map< llvm::BasicBlock *, llvm::BasicBlock * > * nextBlocks
 
bool switchConditionWasUniform
 

Control flow management

enum  ForeachType { FOREACH_REGULAR, FOREACH_ACTIVE, FOREACH_UNIQUE }
 
void StartUniformIf ()
 
void StartVaryingIf (llvm::Value *oldMask)
 
void EndIf ()
 
void StartLoop (llvm::BasicBlock *breakTarget, llvm::BasicBlock *continueTarget, bool uniformControlFlow)
 
void SetBlockEntryMask (llvm::Value *mask)
 
void EndLoop ()
 
void StartForeach (ForeachType ft)
 
void EndForeach ()
 
void Break (bool doCoherenceCheck)
 
void Continue (bool doCoherenceCheck)
 
void RestoreContinuedLanes ()
 
void ClearBreakLanes ()
 
void StartSwitch (bool isUniform, llvm::BasicBlock *bbAfterSwitch)
 
void EndSwitch ()
 
void SwitchInst (llvm::Value *expr, llvm::BasicBlock *defaultBlock, const std::vector< std::pair< int, llvm::BasicBlock * > > &caseBlocks, const std::map< llvm::BasicBlock *, llvm::BasicBlock * > &nextBlocks)
 
void EmitDefaultLabel (bool checkMask, SourcePos pos)
 
void EmitCaseLabel (int value, bool checkMask, SourcePos pos)
 
int VaryingCFDepth () const
 
bool InForeachLoop () const
 
void DisableGatherScatterWarnings ()
 
void EnableGatherScatterWarnings ()
 
void SetContinueTarget (llvm::BasicBlock *bb)
 
void InitializeLabelMap (Stmt *code)
 
llvm::BasicBlock * GetLabeledBasicBlock (const std::string &label)
 
std::vector< std::string > GetLabels ()
 
void CurrentLanesReturned (Expr *value, bool doCoherenceCheck)
 

Detailed Description

FunctionEmitContext is one of the key classes in ispc; it is used to help with emitting the intermediate representation of a function during compilation. It carries information the current program context during IR emission (e.g. the basic block into which instructions should be added; or, the current source file and line number, so debugging symbols can be correctly generated). This class also provides a number of helper routines that are useful for code that emits IR.

Definition at line 68 of file ctx.h.

Member Enumeration Documentation

Indicates that code generation for a 'foreach', 'foreach_tiled', 'foreach_active', or 'foreach_unique' loop is about to start.

Enumerator
FOREACH_REGULAR 
FOREACH_ACTIVE 
FOREACH_UNIQUE 

Definition at line 175 of file ctx.h.

Constructor & Destructor Documentation

FunctionEmitContext::FunctionEmitContext ( Function function,
Symbol funSym,
llvm::Function *  llvmFunction,
SourcePos  firstStmtPos 
)

Create a new FunctionEmitContext.

Parameters
functionThe Function object representing the function
funSymSymbol that corresponds to the function
llvmFunctionLLVM function in the current module that corresponds to the function
firstStmtPosSource file position of the first statement in the function

Definition at line 245 of file ctx.cpp.

References Assert, AssertPos, Globals::ctx, Module::diBuilder, Opt::disableMaskAllOnOptimizations, Module::errorCount, Opt::forceAlignedMemory, g, SourcePos::GetDIFile(), FunctionType::GetDIType(), Target::GetISAString(), Target::getNativeVectorAlignment(), Type::IsVoidType(), Opt::level, LLVMMaskAllOff, LLVMMaskAllOn, Type::LLVMType(), m, LLVMTypes::MaskType, Module::module, Symbol::name, Globals::opt, Symbol::pos, SC_STATIC, Symbol::storageClass, Globals::target, LLVMTypes::VoidPointerType, and LLVMTypes::VoidType.

FunctionEmitContext::~FunctionEmitContext ( )

Definition at line 457 of file ctx.cpp.

References AssertPos, Module::diBuilder, and m.

Member Function Documentation

void FunctionEmitContext::AddDebugPos ( llvm::Value *  instruction,
const SourcePos pos = NULL,
llvm::DIScope *  scope = NULL 
)

Adds debugging metadata to the given instruction. If pos == NULL, use FunctionEmitContext::currentPos as the source file position for the instruction. Similarly, if a DIScope is provided, it's used and otherwise the scope is found from a GetDIScope() call. This takes a llvm::Value for the instruction rather than an llvm::Instruction for convenience; in calling code we often have Instructions stored using Value pointers; the code here returns silently if it's not actually given an instruction.

Definition at line 1693 of file ctx.cpp.

References Module::diBuilder, SourcePos::first_column, SourcePos::first_line, and m.

Referenced by SetContinueTarget().

llvm::Value * FunctionEmitContext::AddElementOffset ( llvm::Value *  basePtr,
int  elementNum,
const Type ptrType,
const char *  name = NULL,
const PointerType **  resultPtrType = NULL 
)

This method returns a new pointer that represents offsetting the given base pointer to point at the given element number of the structure type that the base pointer points to. (The provided pointer must be a pointer to a structure type. The ptrType gives the type of the pointer, though it may be NULL if the base pointer is uniform.

Definition at line 2598 of file ctx.cpp.

References AssertPos, Globals::ctx, Module::errorCount, Opt::force32BitAddressing, g, PointerType::GetBaseType(), CollectionType::GetElementType(), SequentialType::GetElementType(), Type::GetReferenceTarget(), PointerType::GetUniform(), PointerType::GetVariability(), LLVMTypes::Int64VectorType, Target::is32Bit(), PointerType::IsConstType(), PointerType::IsSlice(), Type::IsUniformType(), LLVMInt32(), LLVMInt64(), Type::LLVMType(), StructType::LLVMType(), m, Globals::opt, PTYPE, Target::SizeOf(), Target::StructOffset(), and Globals::target.

Referenced by Function::emitCode(), PrintStmt::EmitCode(), MemberExpr::GetLValue(), MemberExpr::GetValue(), VectorMemberExpr::GetValue(), InitSymbol(), lCopyInTaskParameter(), and SetContinueTarget().

void FunctionEmitContext::addGSMetadata ( llvm::Value *  v,
SourcePos  pos 
)
staticprivate

Add metadata to the given instruction to encode the current source file position. This data is used in the lGetSourcePosFromMetadata() function in opt.cpp.

Definition at line 3004 of file ctx.cpp.

References Globals::ctx, SourcePos::first_column, SourcePos::first_line, g, SourcePos::last_column, SourcePos::last_line, LLVMInt32(), and SourcePos::name.

void FunctionEmitContext::AddInstrumentationPoint ( const char *  note)

If the user has asked to compile the program with instrumentation, this inserts a callback to the user-supplied instrumentation function at the current point in the code.

Definition at line 1660 of file ctx.cpp.

References AssertPos, Globals::emitInstrumentation, g, lGetStringAsValue(), LLVMInt32(), m, and Module::module.

Referenced by Function::emitCode(), DoStmt::EmitCode(), ForStmt::EmitCode(), ForeachStmt::EmitCode(), lEmitIfStatements(), and SetContinueTarget().

void FunctionEmitContext::addSwitchMaskCheck ( llvm::Value *  mask)
private

Emit code to check for an "all off" mask before the code for a case or default label in a "switch" statement.

Definition at line 1046 of file ctx.cpp.

References AssertPos.

llvm::Value * FunctionEmitContext::addVaryingOffsetsIfNeeded ( llvm::Value *  ptr,
const Type ptrType 
)
private

When we gathering from or scattering to a varying atomic type, we need to add an appropriate offset to the final address for each lane right before we use it. Given a varying pointer we're about to use and its type, this function determines whether these offsets are needed and returns an updated pointer that incorporates these offsets if needed.

Definition at line 4096 of file ctx.cpp.

References AssertPos, Globals::ctx, Opt::force32BitAddressing, g, Type::GetAsUniformType(), Type::GetBaseType(), LLVMTypes::Int64VectorType, Target::is32Bit(), Type::IsBasicType(), Type::IsVaryingType(), Type::LLVMType(), Globals::opt, Target::SizeOf(), and Globals::target.

llvm::Value * FunctionEmitContext::All ( llvm::Value *  mask)

Given a boolean mask value of type LLVMTypes::MaskType, return an i1 value that indicates if all of the mask lanes are on.

Definition at line 1418 of file ctx.cpp.

References AssertPos, g, Target::getMaskBitCount(), LLVMGetName(), SymbolTable::LookupFunction(), m, Module::symbolTable, and Globals::target.

Referenced by Function::emitCode(), IfStmt::emitMaskAllOn(), IfStmt::emitVaryingIf(), lEmitLogicalOp(), and SetContinueTarget().

llvm::Value * FunctionEmitContext::AllocaInst ( llvm::Type *  llvmType,
const char *  name = NULL,
int  align = 0,
bool  atEntryBlock = true 
)

Emits an alloca instruction to allocate stack storage for the given type. If a non-zero alignment is specified, the object is also allocated at the given alignment. By default, the alloca instruction is added at the start of the function in the entry basic block; if it should be added to the current basic block, then the atEntryBlock parameter should be false.

Definition at line 3051 of file ctx.cpp.

References AssertPos, Module::errorCount, g, Target::getNativeVectorAlignment(), m, and Globals::target.

Referenced by Function::emitCode(), DeclStmt::EmitCode(), ForeachStmt::EmitCode(), ForeachActiveStmt::EmitCode(), ForeachUniqueStmt::EmitCode(), PrintStmt::EmitCode(), SelectExpr::GetValue(), IndexExpr::GetValue(), MemberExpr::GetValue(), ReferenceExpr::GetValue(), VectorMemberExpr::GetValue(), lCopyInTaskParameter(), lEmitLogicalOp(), lEmitVaryingSelect(), lProcessPrintArg(), and SetContinueTarget().

llvm::Value * FunctionEmitContext::Any ( llvm::Value *  mask)

Given a boolean mask value of type LLVMTypes::MaskType, return an i1 value that indicates if any of the mask lanes are on.

Definition at line 1401 of file ctx.cpp.

References AssertPos, g, Target::getMaskBitCount(), LLVMGetName(), SymbolTable::LookupFunction(), m, Module::symbolTable, and Globals::target.

Referenced by IfStmt::emitMaskAllOn(), IfStmt::emitMaskMixed(), lEmitSelectExprCode(), and SetContinueTarget().

llvm::Value * FunctionEmitContext::applyVaryingGEP ( llvm::Value *  basePtr,
llvm::Value *  index,
const Type ptrType 
)
private

Utility routine used by the GetElementPtrInst() methods; given a pointer to some type (either uniform or varying) and an index (also either uniform or varying), this returns the new pointer (varying if appropriate) given by offsetting the base pointer by the index times the size of the object that the pointer points to.

Definition at line 2276 of file ctx.cpp.

References AssertPos, Globals::ctx, Opt::force32BitAddressing, g, Type::GetBaseType(), LLVMTypes::Int32Type, LLVMTypes::Int32VectorType, LLVMTypes::Int64Type, LLVMTypes::Int64VectorType, Target::is32Bit(), LLVMGetName(), Type::LLVMType(), Globals::opt, Target::SizeOf(), and Globals::target.

llvm::Value * FunctionEmitContext::BinaryOperator ( llvm::Instruction::BinaryOps  inst,
llvm::Value *  v0,
llvm::Value *  v1,
const char *  name = NULL 
)

Emit the binary operator given by the inst parameter. If llvm::Values corresponding to VectorTypes are given as operands, this also handles applying the given operation to the vector elements.

Definition at line 1914 of file ctx.cpp.

References AssertPos, Module::errorCount, lArrayVectorWidth(), m, and CFInfo::type.

Referenced by ForeachStmt::EmitCode(), ForeachActiveStmt::EmitCode(), ForeachUniqueStmt::EmitCode(), NewExpr::GetValue(), lComputeSliceIndex(), lEmitBinaryArith(), lEmitBinaryBitOp(), lEmitBinaryPointerArith(), lEmitLogicalOp(), lEmitNegate(), lEmitPrePostIncDec(), lEmitSelectExprCode(), lHasUnsizedArrays(), lUpdateVaryingCounter(), and SetContinueTarget().

llvm::Value * FunctionEmitContext::BitCastInst ( llvm::Value *  value,
llvm::Type *  type,
const char *  name = NULL 
)
void FunctionEmitContext::BranchIfMaskAll ( llvm::BasicBlock *  btrue,
llvm::BasicBlock *  bfalse 
)

Emits a branch instruction to the basic block btrue if all of the lanes of current mask are on and bfalse if none are on.

Definition at line 558 of file ctx.cpp.

References AssertPos.

Referenced by DoStmt::EmitCode(), and ForStmt::EmitCode().

void FunctionEmitContext::BranchIfMaskAny ( llvm::BasicBlock *  btrue,
llvm::BasicBlock *  bfalse 
)

Emits a branch instruction to the basic block btrue if any of the lanes of current mask are on and bfalse if none are on.

Definition at line 547 of file ctx.cpp.

References AssertPos.

Referenced by DoStmt::EmitCode(), and ForStmt::EmitCode().

void FunctionEmitContext::BranchIfMaskNone ( llvm::BasicBlock *  btrue,
llvm::BasicBlock *  bfalse 
)

Emits a branch instruction to the basic block btrue if none of the lanes of current mask are on and bfalse if none are on.

Definition at line 569 of file ctx.cpp.

References AssertPos.

void FunctionEmitContext::BranchInst ( llvm::BasicBlock *  block)
void FunctionEmitContext::BranchInst ( llvm::BasicBlock *  trueBlock,
llvm::BasicBlock *  falseBlock,
llvm::Value *  test 
)

Definition at line 3492 of file ctx.cpp.

References AssertPos, Module::errorCount, and m.

void FunctionEmitContext::Break ( bool  doCoherenceCheck)

Emit code for a 'break' statement in a loop. If doCoherenceCheck is true, then if we're in a 'varying' loop, code will be emitted to see if all of the lanes want to break, in which case a jump to the break target will be taken. (For 'uniform' loops, the jump is always done).

Definition at line 776 of file ctx.cpp.

References AssertPos, Error(), LLVMMaskAllOff, CFInfo::Loop, and CFInfo::Switch.

Referenced by BreakStmt::EmitCode().

llvm::Value * FunctionEmitContext::BroadcastValue ( llvm::Value *  v,
llvm::Type *  vecType,
const char *  name = NULL 
)

This convenience method to generate broadcast pattern. It takes a value and a vector type. Type of the value must match element type of the vector.

Definition at line 3576 of file ctx.cpp.

References Assert, AssertPos, Globals::ctx, Module::errorCount, g, LLVMGetName(), and m.

Referenced by ForeachStmt::EmitCode(), TypeCastExpr::GetValue(), lUpdateVaryingCounter(), and SetContinueTarget().

llvm::Value * FunctionEmitContext::CallInst ( llvm::Value *  func,
const FunctionType funcType,
const std::vector< llvm::Value * > &  args,
const char *  name = NULL 
)

Emits IR to do a function call with the given arguments. If the function type is a varying function pointer type, its full type must be provided in funcType. funcType can be NULL if func is a uniform function pointer.

Definition at line 3667 of file ctx.cpp.

References AssertPos, Globals::ctx, Module::errorCount, g, FunctionType::GetReturnType(), PointerType::GetUniform(), LLVMTypes::Int32Type, lCalleeArgCount(), FunctionType::LLVMFunctionType(), LLVMMaskAllOn, Type::LLVMType(), m, LLVMTypes::MaskType, Module::module, and LLVMTypes::VoidType.

Referenced by ForeachActiveStmt::EmitCode(), ForeachUniqueStmt::EmitCode(), PrintStmt::EmitCode(), AssertStmt::EmitCode(), DeleteStmt::EmitCode(), FunctionCallExpr::GetValue(), NewExpr::GetValue(), lHasUnsizedArrays(), lUpdateVaryingCounter(), and SetContinueTarget().

llvm::Value * FunctionEmitContext::CallInst ( llvm::Value *  func,
const FunctionType funcType,
llvm::Value *  arg,
const char *  name = NULL 
)

This is a convenience method that issues a call instruction to a function that takes just a single argument.

Definition at line 3846 of file ctx.cpp.

llvm::Value * FunctionEmitContext::CallInst ( llvm::Value *  func,
const FunctionType funcType,
llvm::Value *  arg0,
llvm::Value *  arg1,
const char *  name = NULL 
)

This is a convenience method that issues a call instruction to a function that takes two arguments.

Definition at line 3855 of file ctx.cpp.

llvm::Instruction * FunctionEmitContext::CastInst ( llvm::Instruction::CastOps  op,
llvm::Value *  value,
llvm::Type *  type,
const char *  name = NULL 
)

Definition at line 2193 of file ctx.cpp.

References AssertPos, Module::errorCount, LLVMGetName(), and m.

Referenced by lTypeConvAtomic(), and SetContinueTarget().

void FunctionEmitContext::ClearBreakLanes ( )

This method is called by code emitting IR for a loop. It clears any lanes that contained a break since the mask has been updated to take them into account. This is necessary as all the bail out checks for breaks are meant to only deal with lanes breaking on the current iteration.

Definition at line 997 of file ctx.cpp.

References LLVMMaskAllOff.

Referenced by DoStmt::EmitCode(), and ForStmt::EmitCode().

llvm::Value * FunctionEmitContext::CmpInst ( llvm::Instruction::OtherOps  inst,
llvm::CmpInst::Predicate  pred,
llvm::Value *  v0,
llvm::Value *  v1,
const char *  name = NULL 
)

Emit a comparison instruction. If the operands are VectorTypes, then a value for the corresponding boolean VectorType is returned.

Definition at line 2000 of file ctx.cpp.

References AssertPos, Module::errorCount, lArrayVectorWidth(), lGetMatchingBoolVectorType(), m, and CFInfo::type.

Referenced by ForeachStmt::EmitCode(), ForeachActiveStmt::EmitCode(), ForeachUniqueStmt::EmitCode(), TypeCastExpr::GetValue(), NewExpr::GetValue(), lEmitBinaryCmp(), lEmitLogicalOp(), lTypeConvAtomic(), and SetContinueTarget().

void FunctionEmitContext::Continue ( bool  doCoherenceCheck)

Emit code for a 'continue' statement in a loop. If doCoherenceCheck is true, then if we're in a 'varying' loop, code will be emitted to see if all of the lanes want to continue, in which case a jump to the continue target will be taken. (For 'uniform' loops, the jump is always done).

Definition at line 856 of file ctx.cpp.

References AssertPos, Error(), lEnclosingLoopIsForeachActive(), LLVMMaskAllOff, and CFInfo::Loop.

Referenced by ContinueStmt::EmitCode().

llvm::BasicBlock * FunctionEmitContext::CreateBasicBlock ( const char *  name)
void FunctionEmitContext::CurrentLanesReturned ( Expr value,
bool  doCoherenceCheck 
)

Called to generate code for 'return' statement; value is the expression in the return statement (if non-NULL), and doCoherenceCheck indicates whether instructions should be generated to see if all of the currently-running lanes have returned (if we're under varying control flow).

Definition at line 1325 of file ctx.cpp.

References Error(), Type::GetString(), Expr::GetType(), PointerType::GetUniform(), Expr::GetValue(), Type::IsUniformType(), Type::IsVoidType(), LLVMMaskAllOff, ASTNode::pos, and TypeConvertExpr().

Referenced by ReturnStmt::EmitCode(), and SetContinueTarget().

void FunctionEmitContext::DisableGatherScatterWarnings ( )

Temporarily disables emission of performance warnings from gathers and scatters from subsequent code.

Definition at line 1264 of file ctx.cpp.

Referenced by ForeachStmt::EmitCode().

void FunctionEmitContext::EmitCaseLabel ( int  value,
bool  checkMask,
SourcePos  pos 
)

Generates code for a "case" label after a "switch" statement. See the documentation for EmitDefaultLabel() for discussion of the checkMask parameter.

Definition at line 1140 of file ctx.cpp.

References AssertPos, Error(), LLVMTypes::Int32VectorType, LLVMInt32Vector(), and LLVMInt64Vector().

Referenced by CaseStmt::EmitCode().

void FunctionEmitContext::EmitDefaultLabel ( bool  checkMask,
SourcePos  pos 
)

Generates code for a "default" label after a "switch" statement. The checkMask parameter indicates whether additional code should be generated to check to see if the execution mask is all off after the default label (in which case a jump to the following label will be issued.

Definition at line 1077 of file ctx.cpp.

References AssertPos, Error(), LLVMTypes::Int32VectorType, LLVMInt32Vector(), and LLVMInt64Vector().

Referenced by DefaultStmt::EmitCode().

void FunctionEmitContext::EmitFunctionParameterDebugInfo ( Symbol sym,
int  parameterNum 
)

Emits debugging information for the function parameter represented by sym.

Definition at line 1828 of file ctx.cpp.

References AssertPos, Module::diBuilder, SourcePos::first_column, SourcePos::first_line, SourcePos::GetDIFile(), Type::GetDIType(), m, Symbol::name, Symbol::pos, Symbol::storagePtr, and Symbol::type.

Referenced by Function::emitCode(), lCopyInTaskParameter(), and SetContinueTarget().

llvm::Value* FunctionEmitContext::emitGatherCallback ( llvm::Value *  lvalue,
llvm::Value *  retPtr 
)
private
void FunctionEmitContext::EmitVariableDebugInfo ( Symbol sym)
void FunctionEmitContext::EnableGatherScatterWarnings ( )

Reenables emission of gather/scatter performance warnings.

Definition at line 1270 of file ctx.cpp.

Referenced by ForeachStmt::EmitCode().

void FunctionEmitContext::EndForeach ( )
void FunctionEmitContext::EndIf ( )

Notifies the FunctionEmitConitext that we're done emitting the IR for an 'if' statement.

Definition at line 592 of file ctx.cpp.

References AssertPos, CFInfo::IsIf(), CFInfo::IsUniform(), LLVMMaskAllOff, LLVMMaskAllOn, and CFInfo::savedMask.

Referenced by IfStmt::EmitCode(), IfStmt::emitMaskAllOn(), IfStmt::emitMaskMixed(), and IfStmt::emitVaryingIf().

void FunctionEmitContext::EndLoop ( )

Informs FunctionEmitContext that code generation for a loop is finished.

Definition at line 684 of file ctx.cpp.

References AssertPos, CFInfo::IsLoop(), CFInfo::IsUniform(), and CFInfo::savedMask.

Referenced by DoStmt::EmitCode(), and ForStmt::EmitCode().

void FunctionEmitContext::EndScope ( )

Inform the debugging information generation code that the current scope is ending in the source program.

Definition at line 1753 of file ctx.cpp.

References AssertPos, Module::diBuilder, and m.

Referenced by DoStmt::EmitCode(), ForStmt::EmitCode(), ForeachStmt::EmitCode(), ForeachActiveStmt::EmitCode(), ForeachUniqueStmt::EmitCode(), StmtList::EmitCode(), lEmitIfStatements(), and SetContinueTarget().

void FunctionEmitContext::EndSwitch ( )

Indicates the end of code generation for a "switch" statement.

Definition at line 1033 of file ctx.cpp.

References AssertPos, CFInfo::IsVarying(), and CFInfo::savedMask.

Referenced by SwitchStmt::EmitCode().

llvm::Value * FunctionEmitContext::ExtractInst ( llvm::Value *  v,
int  elt,
const char *  name = NULL 
)

This convenience method maps to an llvm::ExtractElementInst if the given value is a llvm::VectorType, and to an llvm::ExtractValueInst otherwise.

Definition at line 3507 of file ctx.cpp.

References AssertPos, Module::errorCount, LLVMGetName(), LLVMInt32(), and m.

Referenced by IfStmt::EmitCode(), IfStmt::emitMaskMixed(), SelectExpr::GetValue(), TypeCastExpr::GetValue(), NewExpr::GetValue(), lEmitBinaryPointerArith(), lFinalSliceOffset(), lUniformValueToVarying(), and SetContinueTarget().

llvm::Instruction * FunctionEmitContext::FPCastInst ( llvm::Value *  value,
llvm::Type *  type,
const char *  name = NULL 
)

Definition at line 2213 of file ctx.cpp.

References AssertPos, Module::errorCount, LLVMGetName(), and m.

Referenced by lTypeConvAtomic(), and SetContinueTarget().

llvm::Value * FunctionEmitContext::gather ( llvm::Value *  ptr,
const PointerType ptrType,
llvm::Value *  mask,
const char *  name 
)
private
llvm::BasicBlock * FunctionEmitContext::GetCurrentBasicBlock ( )
SourcePos FunctionEmitContext::GetDebugPos ( ) const

Definition at line 1687 of file ctx.cpp.

Referenced by IfStmt::emitMaskedTrueAndFalse(), and SetContinueTarget().

llvm::DIScope FunctionEmitContext::GetDIScope ( ) const

Returns the llvm::DIScope corresponding to the current program scope.

Definition at line 1766 of file ctx.cpp.

References AssertPos.

Referenced by SetContinueTarget().

llvm::Value * FunctionEmitContext::GetElementPtrInst ( llvm::Value *  basePtr,
llvm::Value *  index,
const Type ptrType,
const char *  name = NULL 
)

These GEP methods are generalizations of the standard ones in LLVM; they support both uniform and varying basePtr values as well as uniform and varying index values (arrays of indices). Varying base pointers are expected to come in as vectors of i32/i64 (depending on the target), since LLVM doesn't currently support vectors of pointers. The underlying type of the base pointer must be provided via the ptrType parameter

Definition at line 2438 of file ctx.cpp.

References AssertPos, Module::errorCount, PointerType::GetAsNonSlice(), PointerType::GetBaseType(), Type::GetReferenceTarget(), Type::GetSOAWidth(), PointerType::GetUniform(), PointerType::IsFrozenSlice(), PointerType::IsSlice(), Type::IsUniformType(), Type::IsVaryingType(), lComputeSliceIndex(), m, and PTYPE.

Referenced by ForeachUniqueStmt::EmitCode(), IndexExpr::GetLValue(), IndexExpr::GetValue(), InitSymbol(), lAddVaryingOffsetsIfNeeded(), lEmitBinaryPointerArith(), lEmitPrePostIncDec(), lFinalSliceOffset(), and SetContinueTarget().

llvm::Value * FunctionEmitContext::GetElementPtrInst ( llvm::Value *  basePtr,
llvm::Value *  index0,
llvm::Value *  index1,
const Type ptrType,
const char *  name = NULL 
)
llvm::Value * FunctionEmitContext::GetFullMask ( )
llvm::Value * FunctionEmitContext::GetFullMaskPointer ( )

Returns a pointer to storage in memory that stores the current full mask.

Definition at line 501 of file ctx.cpp.

Referenced by Function::emitCode().

const Function * FunctionEmitContext::GetFunction ( ) const

Returns the Function * corresponding to the function that we're currently generating code for.

Definition at line 464 of file ctx.cpp.

Referenced by DeclStmt::EmitCode(), ForeachStmt::EmitCode(), ReturnStmt::EmitCode(), and lMaskForSymbol().

llvm::Value * FunctionEmitContext::GetFunctionMask ( )

Returns the mask value at entry to the current function.

Definition at line 482 of file ctx.cpp.

Referenced by Function::emitCode(), DoStmt::EmitCode(), ForStmt::EmitCode(), ForeachStmt::EmitCode(), UnmaskedStmt::EmitCode(), and IfStmt::emitMaskAllOn().

llvm::Value * FunctionEmitContext::GetInternalMask ( )

Returns the mask value corresponding to "varying" control flow within the current function. (i.e. this doesn't include the effect of the mask at function entry.

Definition at line 488 of file ctx.cpp.

Referenced by DoStmt::EmitCode(), ForStmt::EmitCode(), ForeachStmt::EmitCode(), ForeachActiveStmt::EmitCode(), ForeachUniqueStmt::EmitCode(), UnmaskedStmt::EmitCode(), IfStmt::emitVaryingIf(), SelectExpr::GetValue(), lEmitLogicalOp(), and lMaskForSymbol().

llvm::BasicBlock * FunctionEmitContext::GetLabeledBasicBlock ( const std::string &  label)

If there is a label in the function with the given name, return the new basic block that it starts.

Definition at line 1303 of file ctx.cpp.

Referenced by GotoStmt::EmitCode(), LabeledStmt::EmitCode(), and SetContinueTarget().

std::vector< std::string > FunctionEmitContext::GetLabels ( )

Returns a vector of all labels in the context. This is simply the key set of the labelMap

Definition at line 1311 of file ctx.cpp.

Referenced by GotoStmt::EmitCode(), and SetContinueTarget().

llvm::Value * FunctionEmitContext::getMaskAtSwitchEntry ( )
private

Returns the execution mask at entry to the first enclosing "switch" statement.

Definition at line 1066 of file ctx.cpp.

References AssertPos, CFInfo::Switch, and CFInfo::type.

llvm::Value * FunctionEmitContext::GetStringPtr ( const std::string &  str)

Given a string, create an anonymous global variable to hold its value and return the pointer to the string.

Definition at line 1590 of file ctx.cpp.

References Globals::ctx, g, m, Module::module, and LLVMTypes::VoidPointerType.

Referenced by PrintStmt::EmitCode(), AssertStmt::EmitCode(), and SetContinueTarget().

llvm::Value * FunctionEmitContext::I1VecToBoolVec ( llvm::Value *  b)

Given a vector with element type i1, return a vector of type LLVMTypes::BoolVectorType. This method handles the conversion for the targets where the bool vector element type is, for example, i32.

Definition at line 1608 of file ctx.cpp.

References AssertPos, LLVMTypes::BoolVectorType, Module::errorCount, g, Target::getMaskBitCount(), LLVMGetName(), m, and Globals::target.

Referenced by ForeachStmt::EmitCode(), ForeachActiveStmt::EmitCode(), ForeachUniqueStmt::EmitCode(), TypeCastExpr::GetValue(), lEmitBinaryCmp(), lEmitLogicalOp(), lTypeConvAtomic(), and SetContinueTarget().

bool FunctionEmitContext::ifsInCFAllUniform ( int  type) const
private

This function checks to see if all of the 'if' statements (if any) between the current scope and the first enclosing loop/switch of given control flow type have 'uniform' tests.

Definition at line 906 of file ctx.cpp.

References AssertPos, and CFInfo::isUniform.

bool FunctionEmitContext::InForeachLoop ( ) const

Definition at line 1255 of file ctx.cpp.

References CFInfo::IsForeach().

Referenced by ReturnStmt::EmitCode(), and GotoStmt::EmitCode().

void FunctionEmitContext::InitializeLabelMap ( Stmt code)

Step through the code and find label statements; create a basic block for each one, so that subsequent calls to GetLabeledBasicBlock() return the corresponding basic block.

Definition at line 1296 of file ctx.cpp.

References WalkAST().

Referenced by Function::emitCode(), and SetContinueTarget().

bool FunctionEmitContext::initLabelBBlocks ( ASTNode node,
void *  data 
)
staticprivate

Definition at line 1277 of file ctx.cpp.

References CreateBasicBlock(), Error(), labelMap, LabeledStmt::name, and ASTNode::pos.

llvm::Value * FunctionEmitContext::InsertInst ( llvm::Value *  v,
llvm::Value *  eltVal,
int  elt,
const char *  name = NULL 
)

This convenience method maps to an llvm::InsertElementInst if the given value is a llvm::VectorType, and to an llvm::InsertValueInst otherwise.

Definition at line 3530 of file ctx.cpp.

References AssertPos, Module::errorCount, LLVMGetName(), LLVMInt32(), and m.

Referenced by SelectExpr::GetValue(), TypeCastExpr::GetValue(), lConvertToSlicePointer(), lUniformValueToVarying(), and SetContinueTarget().

bool FunctionEmitContext::inSwitchStatement ( ) const
private

Returns "true" if the first enclosing non-if control flow expression is a "switch" statement.

Definition at line 762 of file ctx.cpp.

References CFInfo::IsIf().

llvm::Value * FunctionEmitContext::IntToPtrInst ( llvm::Value *  value,
llvm::Type *  type,
const char *  name = NULL 
)
void FunctionEmitContext::jumpIfAllLoopLanesAreDone ( llvm::BasicBlock *  target)
private

Definition at line 924 of file ctx.cpp.

llvm::Value * FunctionEmitContext::LaneMask ( llvm::Value *  mask)
llvm::Value * FunctionEmitContext::LaunchInst ( llvm::Value *  callee,
std::vector< llvm::Value * > &  argVals,
llvm::Value *  launchCount[3] 
)

Launch an asynchronous task to run the given function, passing it he given argument values.

Definition at line 3890 of file ctx.cpp.

References AssertPos, Globals::ctx, Module::errorCount, g, Target::getISA(), Target::getNativeVectorWidth(), LLVMTypes::Int64Type, LLVMInt32(), LLVMInt64(), m, Module::module, RoundUpPow2(), Target::SizeOf(), Globals::target, and LLVMTypes::VoidPointerType.

Referenced by FunctionCallExpr::GetValue(), and SetContinueTarget().

llvm::Value * FunctionEmitContext::LoadInst ( llvm::Value *  ptr,
llvm::Value *  mask,
const Type ptrType,
const char *  name = NULL,
bool  one_elem = false 
)

Load from the memory location(s) given by lvalue, using the given mask. The lvalue may be varying, in which case this corresponds to a gather from the multiple memory locations given by the array of pointer values given by the lvalue. If the lvalue is not varying, then both the mask pointer and the type pointer may be NULL.

Definition at line 2817 of file ctx.cpp.

References AssertPos, Error(), Module::errorCount, g, PointerType::GetBaseType(), Target::getMaskBitCount(), Type::GetReferenceTarget(), Type::GetString(), PointerType::GetUniform(), PointerType::IsSlice(), Type::IsUniformType(), Type::IsVaryingType(), LLVMGetName(), SymbolTable::LookupFunction(), m, Module::symbolTable, Globals::target, and Warning().

Referenced by Function::emitCode(), ForeachStmt::EmitCode(), ForeachActiveStmt::EmitCode(), ForeachUniqueStmt::EmitCode(), SelectExpr::GetValue(), IndexExpr::GetValue(), MemberExpr::GetValue(), DerefExpr::GetValue(), SymbolExpr::GetValue(), VectorMemberExpr::GetValue(), lCopyInTaskParameter(), lEmitLogicalOp(), lEmitOpAssign(), lEmitVaryingSelect(), lUpdateVaryingCounter(), and SetContinueTarget().

llvm::Value * FunctionEmitContext::LoadInst ( llvm::Value *  ptr,
const char *  name = NULL 
)
llvm::Value * FunctionEmitContext::loadUniformFromSOA ( llvm::Value *  ptr,
llvm::Value *  mask,
const PointerType ptrType,
const char *  name 
)
private

Utility routine that loads from a uniform pointer to soa<> data, returning a regular uniform (non-SOA result).

Definition at line 2783 of file ctx.cpp.

References Globals::ctx, g, Type::GetAsUniformType(), PointerType::GetBaseType(), CollectionType::GetElementCount(), lFinalSliceOffset(), and Type::LLVMType().

llvm::Value * FunctionEmitContext::MakeSlicePointer ( llvm::Value *  ptr,
llvm::Value *  offset 
)

Create a new slice pointer out of the given pointer to an soa type and an integer offset to a slice within that type.

Definition at line 2420 of file ctx.cpp.

References Globals::ctx, g, and LLVMGetName().

Referenced by TypeCastExpr::GetValue(), and SetContinueTarget().

void FunctionEmitContext::maskedStore ( llvm::Value *  value,
llvm::Value *  ptr,
const Type ptrType,
llvm::Value *  mask 
)
private

Code to store the given varying value to the given location, only storing the elements that correspond to active program instances as given by the provided storeMask value. Note that the lvalue is only a single pointer, not a varying lvalue of one pointer per program instance (that case is handled by scatters).

Definition at line 3108 of file ctx.cpp.

References Assert, AssertPos, LLVMTypes::DoubleVectorType, Module::errorCount, LLVMTypes::FloatVectorType, g, PointerType::GetAsNonSlice(), Type::GetBaseType(), CollectionType::GetElementCount(), CollectionType::GetElementType(), PointerType::GetUniform(), LLVMTypes::Int16VectorType, LLVMTypes::Int1VectorType, LLVMTypes::Int32VectorType, LLVMTypes::Int64VectorType, LLVMTypes::Int8VectorType, Target::is32Bit(), Type::IsBasicType(), PointerType::IsSlice(), Type::IsUniformType(), Type::IsVaryingType(), LLVMMaskAllOn, m, Module::module, Globals::target, and AtomicType::VaryingInt32.

llvm::Value * FunctionEmitContext::MasksAllEqual ( llvm::Value *  mask1,
llvm::Value *  mask2 
)

Given two masks of type LLVMTypes::MaskType, return an i1 value that indicates whether the two masks are equal.

Definition at line 1534 of file ctx.cpp.

References g, Target::getISA(), LLVMGetName(), and Globals::target.

Referenced by SetContinueTarget().

void FunctionEmitContext::MatchIntegerTypes ( llvm::Value **  v0,
llvm::Value **  v1 
)

Given two integer-typed values (but possibly one vector and the other not, and or of possibly-different bit-widths), update their values as needed so that the two have the same (more general) type.

Definition at line 2341 of file ctx.cpp.

References LLVMTypes::Int32Type, LLVMTypes::Int32VectorType, LLVMTypes::Int64Type, and LLVMTypes::Int64VectorType.

Referenced by lComputeSliceIndex(), lEmitBinaryPointerArith(), and SetContinueTarget().

void FunctionEmitContext::MemcpyInst ( llvm::Value *  dest,
llvm::Value *  src,
llvm::Value *  count,
llvm::Value *  align = NULL 
)

Copy count bytes of memory from the location pointed to by src to the location pointed to by dest. (src and dest must not be overlapping.)

Definition at line 3447 of file ctx.cpp.

References AssertPos, LLVMTypes::BoolType, LLVMTypes::Int32Type, LLVMTypes::Int64Type, LLVMFalse, LLVMInt32(), m, Module::module, LLVMTypes::VoidPointerType, and LLVMTypes::VoidType.

Referenced by InitSymbol(), and SetContinueTarget().

llvm::Value * FunctionEmitContext::None ( llvm::Value *  mask)

Given a boolean mask value of type LLVMTypes::MaskType, return an i1 value that indicates if all of the mask lanes are off.

Definition at line 1436 of file ctx.cpp.

References AssertPos, g, Target::getMaskBitCount(), LLVMGetName(), SymbolTable::LookupFunction(), m, Module::symbolTable, and Globals::target.

Referenced by SetContinueTarget().

llvm::Value * FunctionEmitContext::NotOperator ( llvm::Value *  v,
const char *  name = NULL 
)

Emit the "not" operator. Like BinaryOperator(), this also handles a VectorType-based operand.

Definition at line 1948 of file ctx.cpp.

References AssertPos, Module::errorCount, lArrayVectorWidth(), m, and CFInfo::type.

Referenced by ForeachActiveStmt::EmitCode(), ForeachUniqueStmt::EmitCode(), UnaryExpr::GetValue(), SelectExpr::GetValue(), lEmitLogicalOp(), and SetContinueTarget().

llvm::PHINode * FunctionEmitContext::PhiNode ( llvm::Type *  type,
int  count,
const char *  name = NULL 
)

Definition at line 3615 of file ctx.cpp.

Referenced by SelectExpr::GetValue(), and SetContinueTarget().

llvm::Value* FunctionEmitContext::pointerVectorToVoidPointers ( llvm::Value *  value)
private
CFInfo * FunctionEmitContext::popCFState ( )
private

Definition at line 4133 of file ctx.cpp.

References AssertPos, and CFInfo::savedBreakTarget.

llvm::Value * FunctionEmitContext::ProgramIndexVector ( bool  is32bits = true)

generate constantvector, which contains programindex, i.e. < i32 0, i32 1, i32 2, i32 3>

Definition at line 1562 of file ctx.cpp.

References g, Target::getVectorWidth(), LLVMTypes::Int32VectorType, LLVMInt32(), LLVMInt64(), m, Module::module, and Globals::target.

Referenced by ForeachActiveStmt::EmitCode(), lAddVaryingOffsetsIfNeeded(), and SetContinueTarget().

llvm::Value * FunctionEmitContext::PtrToIntInst ( llvm::Value *  value,
const char *  name = NULL 
)
llvm::Value * FunctionEmitContext::PtrToIntInst ( llvm::Value *  value,
llvm::Type *  type,
const char *  name = NULL 
)

Definition at line 2109 of file ctx.cpp.

References AssertPos, Module::errorCount, LLVMGetName(), and m.

void FunctionEmitContext::RestoreContinuedLanes ( )

This method is called by code emitting IR for a loop at the end of the loop body; it restores the lanes of the mask that executed a 'continue' statement when going through the loop body in the previous iteration.

Definition at line 979 of file ctx.cpp.

References LLVMMaskAllOff.

Referenced by DoStmt::EmitCode(), ForStmt::EmitCode(), ForeachStmt::EmitCode(), ForeachActiveStmt::EmitCode(), and ForeachUniqueStmt::EmitCode().

void FunctionEmitContext::restoreMaskGivenReturns ( llvm::Value *  oldMask)
private

Definition at line 740 of file ctx.cpp.

References LLVMMaskAllOn.

llvm::Instruction * FunctionEmitContext::ReturnInst ( )

Definition at line 3866 of file ctx.cpp.

References AssertPos, Globals::ctx, and g.

Referenced by Function::emitCode(), and SetContinueTarget().

void FunctionEmitContext::scatter ( llvm::Value *  value,
llvm::Value *  ptr,
const Type valueType,
const Type origPt,
llvm::Value *  mask 
)
private

Scatter the given varying value to the locations given by the varying lvalue (which should be an array of pointers with size equal to the target's vector width. We want to store each rvalue element at the corresponding pointer's location, if the mask for the corresponding program instance are on. If they're off, don't do anything.

Definition at line 3224 of file ctx.cpp.

References AssertPos, LLVMTypes::DoubleVectorType, LLVMTypes::FloatVectorType, g, PointerType::GetAsSlice(), Type::GetAsVaryingType(), PointerType::GetBaseType(), CollectionType::GetElementType(), PointerType::GetVarying(), LLVMTypes::Int16VectorType, LLVMTypes::Int32VectorType, LLVMTypes::Int64VectorType, LLVMTypes::Int8VectorType, Target::is32Bit(), Type::IsBasicType(), PointerType::IsSlice(), Type::IsUniformType(), Type::IsVaryingType(), lFinalSliceOffset(), m, Module::module, Globals::target, and CFInfo::type.

llvm::Instruction * FunctionEmitContext::SelectInst ( llvm::Value *  test,
llvm::Value *  val0,
llvm::Value *  val1,
const char *  name = NULL 
)

Definition at line 3625 of file ctx.cpp.

References AssertPos, Module::errorCount, LLVMGetName(), and m.

Referenced by SelectExpr::GetValue(), and SetContinueTarget().

void FunctionEmitContext::SetBlockEntryMask ( llvm::Value *  mask)

Informs FunctionEmitContext of the value of the mask at the start of a loop body or switch statement.

Definition at line 515 of file ctx.cpp.

Referenced by DoStmt::EmitCode(), ForStmt::EmitCode(), ForeachStmt::EmitCode(), ForeachActiveStmt::EmitCode(), ForeachUniqueStmt::EmitCode(), and SwitchStmt::EmitCode().

void FunctionEmitContext::SetContinueTarget ( llvm::BasicBlock *  bb)
inline
void FunctionEmitContext::SetCurrentBasicBlock ( llvm::BasicBlock *  bblock)
void FunctionEmitContext::SetDebugPos ( SourcePos  pos)
void FunctionEmitContext::SetFunctionMask ( llvm::Value *  val)

Provides the value of the mask at function entry

Definition at line 507 of file ctx.cpp.

Referenced by Function::emitCode(), DoStmt::EmitCode(), ForStmt::EmitCode(), ForeachStmt::EmitCode(), UnmaskedStmt::EmitCode(), and IfStmt::emitMaskAllOn().

void FunctionEmitContext::SetInternalMask ( llvm::Value *  val)
void FunctionEmitContext::SetInternalMaskAnd ( llvm::Value *  oldMask,
llvm::Value *  val 
)

Sets the internal mask to (oldMask & val)

Definition at line 529 of file ctx.cpp.

Referenced by DoStmt::EmitCode(), ForStmt::EmitCode(), IfStmt::emitMaskedTrueAndFalse(), IfStmt::emitMaskMixed(), SelectExpr::GetValue(), and lEmitLogicalOp().

void FunctionEmitContext::SetInternalMaskAndNot ( llvm::Value *  oldMask,
llvm::Value *  test 
)

Sets the internal mask to (oldMask & ~val)

Definition at line 537 of file ctx.cpp.

References LLVMMaskAllOn.

Referenced by IfStmt::emitMaskedTrueAndFalse(), IfStmt::emitMaskMixed(), SelectExpr::GetValue(), and lEmitLogicalOp().

llvm::Instruction * FunctionEmitContext::SExtInst ( llvm::Value *  value,
llvm::Type *  type,
const char *  name = NULL 
)

Definition at line 2232 of file ctx.cpp.

References AssertPos, Module::errorCount, LLVMGetName(), and m.

Referenced by NewExpr::GetValue(), lTypeConvAtomic(), and SetContinueTarget().

llvm::Value * FunctionEmitContext::ShuffleInst ( llvm::Value *  v1,
llvm::Value *  v2,
llvm::Value *  mask,
const char *  name = NULL 
)

This convenience method maps to an llvm::ShuffleVectorInst.

Definition at line 3555 of file ctx.cpp.

References AssertPos, Module::errorCount, LLVMGetName(), and m.

Referenced by SetContinueTarget().

llvm::Value * FunctionEmitContext::SmearUniform ( llvm::Value *  value,
const char *  name = NULL 
)
void FunctionEmitContext::StartForeach ( ForeachType  ft)
void FunctionEmitContext::StartLoop ( llvm::BasicBlock *  breakTarget,
llvm::BasicBlock *  continueTarget,
bool  uniformControlFlow 
)

Notifies the FunctionEmitContext that we're starting to emit IR for a loop. Basic blocks are provides for where 'break' and 'continue' statements should jump to (if all running lanes want to break or continue), uniformControlFlow indicates whether the loop condition is 'uniform'.

Definition at line 655 of file ctx.cpp.

References CFInfo::GetLoop(), LLVMMaskAllOff, and LLVMTypes::MaskType.

Referenced by DoStmt::EmitCode(), and ForStmt::EmitCode().

void FunctionEmitContext::StartScope ( )

Inform the debugging information generation code that a new scope is starting in the source program.

Definition at line 1715 of file ctx.cpp.

References AssertPos, Module::diBuilder, and m.

Referenced by DoStmt::EmitCode(), ForStmt::EmitCode(), ForeachStmt::EmitCode(), ForeachActiveStmt::EmitCode(), ForeachUniqueStmt::EmitCode(), StmtList::EmitCode(), lEmitIfStatements(), and SetContinueTarget().

void FunctionEmitContext::StartSwitch ( bool  isUniform,
llvm::BasicBlock *  bbAfterSwitch 
)

Indicates that code generation for a "switch" statement is about to start. isUniform indicates whether the "switch" value is uniform, and bbAfterSwitch gives the basic block immediately following the "switch" statement. (For example, if the switch condition is uniform, we jump here upon executing a "break" statement.)

Definition at line 1007 of file ctx.cpp.

References CFInfo::GetSwitch(), LLVMMaskAllOff, and LLVMTypes::MaskType.

Referenced by SwitchStmt::EmitCode().

void FunctionEmitContext::StartUniformIf ( )

Notifies the FunctionEmitContext that we're starting emission of an 'if' statement with a uniform test.

Definition at line 580 of file ctx.cpp.

References CFInfo::GetIf().

Referenced by IfStmt::EmitCode().

void FunctionEmitContext::StartVaryingIf ( llvm::Value *  oldMask)

Notifies the FunctionEmitContext that we're starting emission of an 'if' statement with a varying test. The value of the mask going into the 'if' statement is provided in the oldMask parameter.

Definition at line 586 of file ctx.cpp.

References CFInfo::GetIf().

Referenced by IfStmt::emitMaskAllOn(), IfStmt::emitMaskMixed(), and IfStmt::emitVaryingIf().

void FunctionEmitContext::StoreInst ( llvm::Value *  value,
llvm::Value *  ptr 
)
void FunctionEmitContext::StoreInst ( llvm::Value *  value,
llvm::Value *  ptr,
llvm::Value *  storeMask,
const Type valueType,
const Type ptrType 
)

In this variant of StoreInst(), the lvalue may be varying. If so, this corresponds to a scatter. Whether the lvalue is uniform of varying, the given storeMask is used to mask the stores so that they only execute for the active program instances.

Definition at line 3367 of file ctx.cpp.

References AssertPos, Opt::disableMaskAllOnOptimizations, Error(), Module::errorCount, g, PointerType::GetBaseType(), Type::GetReferenceTarget(), Type::GetString(), PointerType::GetUniform(), PointerType::IsSlice(), Type::IsUniformType(), Type::IsVaryingType(), LLVMMaskAllOn, m, and Globals::opt.

void FunctionEmitContext::storeUniformToSOA ( llvm::Value *  value,
llvm::Value *  ptr,
llvm::Value *  mask,
const Type valueType,
const PointerType ptrType 
)
private
void FunctionEmitContext::SwitchInst ( llvm::Value *  expr,
llvm::BasicBlock *  defaultBlock,
const std::vector< std::pair< int, llvm::BasicBlock * > > &  caseBlocks,
const std::map< llvm::BasicBlock *, llvm::BasicBlock * > &  nextBlocks 
)

Emits code for a "switch" statement in the program.

Parameters
exprGives the value of the expression after the "switch"
defaultBlockBasic block to execute for the "default" case. This should be NULL if there is no "default" label inside the switch.
caseBlocksvector that stores the mapping from label values after "case" statements to basic blocks corresponding to the "case" labels.
nextBlocksFor each basic block for a "case" or "default" label, this gives the basic block for the immediately-following "case" or "default" label (or the basic block after the "switch" statement for the last label.)

Definition at line 1192 of file ctx.cpp.

References AssertPos, LLVMTypes::Int32Type, LLVMTypes::Int64Type, LLVMInt32(), LLVMInt64(), and LLVMMaskAllOff.

Referenced by SwitchStmt::EmitCode().

void FunctionEmitContext::SyncInst ( )
llvm::Instruction * FunctionEmitContext::TruncInst ( llvm::Value *  value,
llvm::Type *  type,
const char *  name = NULL 
)
int FunctionEmitContext::VaryingCFDepth ( ) const

Returns the current number of nested levels of 'varying' control flow

Definition at line 1245 of file ctx.cpp.

References CFInfo::IsVarying().

Referenced by DeclStmt::EmitCode(), GotoStmt::EmitCode(), and lStoreAssignResult().

llvm::Instruction * FunctionEmitContext::ZExtInst ( llvm::Value *  value,
llvm::Type *  type,
const char *  name = NULL 
)

Member Data Documentation

llvm::BasicBlock* FunctionEmitContext::allocaBlock
private

The basic block into which we add any alloca instructions that need to go at the very start of the function.

Definition at line 586 of file ctx.h.

llvm::BasicBlock* FunctionEmitContext::bblock
private

The current basic block into which we're emitting new instructions

Definition at line 590 of file ctx.h.

llvm::Value* FunctionEmitContext::blockEntryMask
private

If currently in a loop body or switch statement, the value of the mask at the start of it.

Definition at line 615 of file ctx.h.

llvm::Value* FunctionEmitContext::breakLanesPtr
private

If currently in a loop body or switch statement, this is a pointer to memory to store a mask value that represents which of the lanes have executed a 'break' statement. If we're not in a loop body or switch, this should be NULL.

Definition at line 621 of file ctx.h.

llvm::BasicBlock* FunctionEmitContext::breakTarget
private

If we're inside a loop or switch statement, this gives the basic block immediately after the current loop or switch, which we will jump to if all of the lanes have executed a break statement or are otherwise done with it.

Definition at line 632 of file ctx.h.

const std::vector<std::pair<int, llvm::BasicBlock *> >* FunctionEmitContext::caseBlocks
private

Map from case label numbers to the basic block that will hold code for that case.

Definition at line 652 of file ctx.h.

llvm::Value* FunctionEmitContext::continueLanesPtr
private

Similar to breakLanesPtr, if we're inside a loop, this is a pointer to memory to record which of the program instances have executed a 'continue' statement.

Definition at line 626 of file ctx.h.

llvm::BasicBlock* FunctionEmitContext::continueTarget
private

If we're inside a loop, this gives the block to jump to if all of the running lanes have executed a 'continue' statement.

Definition at line 636 of file ctx.h.

std::vector<CFInfo *> FunctionEmitContext::controlFlowInfo
private

The CFInfo structure records information about a nesting level of control flow. This vector lets us see what control flow is going around outside the current position in the function being emitted.

Definition at line 686 of file ctx.h.

SourcePos FunctionEmitContext::currentPos
private

Current source file position; if debugging information is being generated, this position is used to set file/line information for instructions.

Definition at line 607 of file ctx.h.

std::vector<llvm::DILexicalBlock> FunctionEmitContext::debugScopes
private

These correspond to the current set of nested scopes in the function.

Definition at line 699 of file ctx.h.

llvm::BasicBlock* FunctionEmitContext::defaultBlock
private

The basic block of code to run for the "default" label in the switch statement.

Definition at line 656 of file ctx.h.

llvm::DIFile FunctionEmitContext::diFile
private

DIFile object corresponding to the source file where the current function was defined (used for debugging info).

Definition at line 691 of file ctx.h.

int FunctionEmitContext::disableGSWarningCount
private

Nesting count of the number of times calling code has disabled (and not yet reenabled) gather/scatter performance warnings.

Definition at line 724 of file ctx.h.

llvm::DISubprogram FunctionEmitContext::diSubprogram
private

DISubprogram corresponding to this function (used for debugging info).

Definition at line 695 of file ctx.h.

llvm::Value* FunctionEmitContext::fullMaskPointer
private

Pointer to stack-allocated memory that stores the current value of the full program mask.

Definition at line 594 of file ctx.h.

SourcePos FunctionEmitContext::funcStartPos
private

Source file position where the function definition started. Used for error messages and debugging symbols.

Definition at line 611 of file ctx.h.

Function* FunctionEmitContext::function
private

Pointer to the Function for which we're currently generating code.

Definition at line 579 of file ctx.h.

llvm::Value* FunctionEmitContext::functionMaskValue
private

Value of the program mask when the function starts execution.

Definition at line 602 of file ctx.h.

llvm::Value* FunctionEmitContext::internalMaskPointer
private

Pointer to stack-allocated memory that stores the current value of the program mask representing varying control flow within the function.

Definition at line 599 of file ctx.h.

std::map<std::string, llvm::BasicBlock *> FunctionEmitContext::labelMap
private

Definition at line 726 of file ctx.h.

Referenced by initLabelBBlocks().

bool FunctionEmitContext::launchedTasks
private

True if a 'launch' statement has been encountered in the function.

Definition at line 715 of file ctx.h.

llvm::Value* FunctionEmitContext::launchGroupHandlePtr
private

This is a pointer to a void * that is passed to the ISPCLaunch(), ISPCAlloc(), and ISPCSync() routines as a handle to the group ot tasks launched from the current function.

Definition at line 720 of file ctx.h.

llvm::Function* FunctionEmitContext::llvmFunction
private

LLVM function representation for the current function.

Definition at line 582 of file ctx.h.

const std::map<llvm::BasicBlock *, llvm::BasicBlock *>* FunctionEmitContext::nextBlocks
private

For each basic block for the code for cases (and the default label, if present), this map gives the basic block for the immediately following case/default label.

Definition at line 661 of file ctx.h.

llvm::Value* FunctionEmitContext::returnedLanesPtr
private

A pointer to memory that records which of the program instances have executed a 'return' statement (and are thus really truly done running any more instructions in this functions.

Definition at line 674 of file ctx.h.

llvm::Value* FunctionEmitContext::returnValuePtr
private

A pointer to memory to store the return value for the function. Since difference program instances may execute 'return' statements at different times, we need to accumulate the return values as they come in until we return for real.

Definition at line 680 of file ctx.h.

bool FunctionEmitContext::switchConditionWasUniform
private

Records whether the switch condition was uniform; this is a distinct notion from whether the switch represents uniform or varying control flow; we may have varying control flow from a uniform switch condition if there is a 'break' inside the switch that's under varying control flow.

Definition at line 668 of file ctx.h.

llvm::Value* FunctionEmitContext::switchExpr
private

The value of the expression used to determine which case in the statements after the switch to execute.

Definition at line 648 of file ctx.h.


The documentation for this class was generated from the following files: