| ▼Ncmdline | |
| ►Ndetail | |
| Cis_same | |
| Cis_same< T, T > | |
| Clexical_cast_t | |
| Clexical_cast_t< std::string, Source, false > | |
| Clexical_cast_t< Target, Source, true > | |
| Clexical_cast_t< Target, std::string, false > | |
| Cdefault_reader | |
| Coneof_reader | |
| Cparser | |
| Crange_reader | |
| ▼NHalide | This file defines the class FunctionDAG, which is our representation of a Halide pipeline, and contains methods to using Halide's bounds tools to query properties of it |
| ►NBoundaryConditions | Namespace to hold functions for imposing boundary conditions on Halide Funcs |
| NInternal | |
| NConciseCasts | |
| ►NInternal | |
| ►NAutoscheduler | |
| CAdams2019Params | |
| CAnderson2021Params | |
| ►CBoundContents | |
| CLayout | |
| CCache | |
| CCachingOptions | |
| CExprBranching | |
| CFilter | |
| ►CFunctionDAG | |
| ►CEdge | |
| CBoundInfo | |
| ►CNode | |
| CLoop | |
| CRegionComputedInfo | |
| CStage | |
| CSymbolicInterval | |
| CGlobalAccessAccumulator | |
| CGPULoopInfo | |
| CLoadJacobian | |
| CLocalAccessAccumulator | |
| ►CLoopNest | |
| CFeatureIntermediates | |
| CSites | |
| ►CStageScheduleState | |
| CFuncVar | |
| CLoopNestParser | |
| CMemInfo | |
| CMemTraits | |
| CMemTraits< GlobalMem > | |
| CMemTraits< LocalMem > | |
| CMemTraits< SharedMem > | |
| CNoOpMutator | |
| COptionalRational | |
| CParamParser | |
| CScopedStatistic | |
| CScopedTimer | |
| ►CSearchSpace | |
| CParallelTileOption | |
| CSearchSpaceOptions | |
| CSharedAccessAccumulator | |
| CSpan | |
| ►CState | |
| CFeatureLoopNestMutator | |
| CStateQueue | |
| CStatistics | |
| CStrides | |
| CThreadInfo | |
| CThreadTileOption | |
| CTimer | |
| ►NElf | |
| Citerator_range | |
| CLinker | Base class for a target architecture to implement the target specific aspects of linking |
| CObject | Holds all of the relevant sections and symbols for an object |
| CRelocation | Describes a relocation to be applied to an offset of a section in an Object |
| CSection | Describes a section of an object file |
| CSymbol | Describes a symbol |
| NGeneratorMinMax | |
| NIntegerDivision | |
| ►NIRMatcher | An alternative template-metaprogramming approach to expression matching |
| Cbindings | |
| ►CBinOp | |
| Cpattern_tag | |
| ►CBroadcastOp | |
| Cpattern_tag | |
| ►CCanProve | |
| Cpattern_tag | |
| ►CCastOp | |
| Cpattern_tag | |
| ►CCmpOp | |
| Cpattern_tag | |
| ►Cenable_if_pattern | |
| Ctype | |
| ►CFold | |
| Cpattern_tag | |
| ►CIntLiteral | |
| Cpattern_tag | |
| ►CIntrin | |
| Cpattern_tag | |
| ►CIsConst | |
| Cpattern_tag | |
| ►CIsFloat | |
| Cpattern_tag | |
| ►CIsInt | |
| Cpattern_tag | |
| ►CIsMaxValue | |
| Cpattern_tag | |
| ►CIsMinValue | |
| Cpattern_tag | |
| ►CIsScalar | |
| Cpattern_tag | |
| ►CIsUInt | |
| Cpattern_tag | |
| ►CLanesOf | |
| Cpattern_tag | |
| CMatcherState | To save stack space, the matcher objects are largely stateless and immutable |
| ►CNegateOp | |
| Cpattern_tag | |
| ►CNotOp | |
| Cpattern_tag | |
| COptionalIntrinType | |
| COptionalIntrinType< Call::saturating_cast > | |
| ►COverflow | |
| Cpattern_tag | |
| ►COverflows | |
| Cpattern_tag | |
| ►CRampOp | |
| Cpattern_tag | |
| CRewriter | |
| ►CSelectOp | |
| Cpattern_tag | |
| ►CSliceOp | |
| Cpattern_tag | |
| ►CSpecificExpr | |
| Cpattern_tag | |
| ►CVectorReduceOp | |
| Cpattern_tag | |
| ►CWidenOp | |
| Cpattern_tag | |
| ►CWild | |
| Cpattern_tag | |
| ►CWildConst | |
| Cpattern_tag | |
| ►CWildConstFloat | |
| Cpattern_tag | |
| ►CWildConstInt | |
| Cpattern_tag | |
| ►CWildConstUInt | |
| Cpattern_tag | |
| ►NTest | |
| CSharder | |
| ►CAbstractGenerator | AbstractGenerator is an ABC that defines the API a Generator must provide to work with the existing Generator infrastructure (GenGen, RunGen, execute_generator(), Generator Stubs) |
| CArgInfo | ArgInfo is a struct to contain name-and-type information for the inputs and outputs to the Pipeline that build_pipeline() will return |
| CAcquire | |
| CAdd | The sum of two expressions |
| Call_are_convertible | |
| Call_are_printable_args | |
| Call_ints_and_optional_name | |
| Call_ints_and_optional_name< First, Rest... > | |
| Call_ints_and_optional_name< T > | |
| Call_ints_and_optional_name<> | |
| CAllocate | Allocate a scratch area called with the given name, type, and size |
| CAnd | Logical and - are both expressions true |
| CAnsi | |
| CApplySplitResult | |
| Caslog | |
| CAssertStmt | If the 'condition' is false, then evaluate and return the message, which should be a call to an error function |
| ►CAssociativeOp | Represent the equivalent associative op of an update definition |
| CReplacement | |
| CAssociativePattern | Represent an associative op with its identity |
| CAtomic | Lock all the Store nodes in the body statement |
| CBaseExprNode | A base class for expression nodes |
| CBaseStmtNode | IR nodes are split into expressions and statements |
| CBlock | A sequence of statements to be executed in-order |
| CBound | A bound on a loop, typically from Func::bound |
| CBox | Represents the bounds of a region of arbitrary dimension |
| CBroadcast | A vector with 'lanes' elements, in which every element is 'value' |
| CBufferBuilder | A builder to help create Exprs representing halide_buffer_t structs (e.g |
| CBufferContents | |
| CBufferInfo | Find all calls to image buffers and parameters in the function |
| CCall | A function call |
| CCast | The actual IR nodes begin here |
| ►CClosure | A helper class to manage closures |
| CBuffer | Information about a buffer reference from a closure |
| ►CCodeGen_C | This class emits C++ code equivalent to a halide Stmt |
| CAllocation | |
| CCodeGen_GPU_C | A base class for GPU backends that require C-like shader output |
| CCodeGen_GPU_Dev | A code generator that emits GPU code from a given Halide stmt |
| ►CCodeGen_LLVM | A code generator abstract base class |
| CAllEnabledMask | Type indicating mask to use is all true – all lanes enabled |
| CIntrinsic | Description of an intrinsic function overload |
| CNoMask | Type indicating an intrinsic does not take a mask |
| CScopedFastMath | If any_strict_float is true, sets fast math flags for the lifetime of this object, then sets them to strict on destruction |
| CVPArg | Support for generating LLVM vector predication intrinsics ("@llvm.vp.*" and "@llvm.experimental.vp.*") |
| CVPResultType | |
| ►CCodeGen_Posix | A code generator that emits posix code from a given Halide stmt |
| CAllocation | A struct describing heap or stack allocations |
| CCodeGen_PyTorch | This class emits C++ code to wrap a Halide pipeline so that it can be used as a C++ extension operator in PyTorch |
| CCompilerLogger | |
| Ccond | |
| CConstantInterval | A class to represent ranges of integers |
| CConvert | |
| CCost | |
| CDefinition | A Function definition which can either represent a init or an update definition |
| CDeviceArgument | A DeviceArgument looks similar to an Halide::Argument, but has behavioral differences that make it specific to the GPU pipeline; the fact that neither is-a nor has-a Halide::Argument is deliberate |
| CDim | The Dim struct represents one loop in the schedule's representation of a loop nest |
| CDimension | |
| CDiv | The ratio of two expressions |
| CEQ | Is the first expression equal to the second |
| CErrorReport | |
| CEvaluate | Evaluate and discard an expression, presumably because it has some side-effect |
| CExecuteGeneratorArgs | ExecuteGeneratorArgs is the set of arguments to execute_generator() |
| CExprNode | We use the "curiously recurring template pattern" to avoid duplicated code in the IR Nodes |
| CExprUsesVars | |
| CFeatureIntermediates | |
| CFileStat | |
| CFindAllCalls | Visitor for keeping track of functions that are directly called and the arguments with which they are called |
| CFloatImm | Floating point constants |
| CFor | A for loop |
| CFork | A pair of statements executed concurrently |
| CFree | Free the resources associated with the given buffer |
| CFuncSchedule | A schedule for a Function of a Halide pipeline |
| ►CFunction | A reference-counted handle to Halide's internal representation of a function |
| CCompare | This lets you use a Function as a key in a map of the form map<Function, Foo, Function::Compare> |
| CFunctionPtr | A possibly-weak pointer to a Halide function |
| CFusedPair | This represents two stages with fused loop nests from outermost to a specific loop level |
| CGE | Is the first expression greater than or equal to the second |
| CGeneratorBase | |
| CGeneratorFactoryProvider | GeneratorFactoryProvider provides a way to customize the Generators that are visible to generate_filter_main (which otherwise would just look at the global registry of C++ Generators) |
| CGeneratorInput_Arithmetic | |
| CGeneratorInput_Buffer | |
| CGeneratorInput_DynamicScalar | |
| CGeneratorInput_Func | |
| CGeneratorInput_Scalar | |
| CGeneratorInputBase | |
| CGeneratorInputImpl | |
| CGeneratorOutput_Arithmetic | |
| CGeneratorOutput_Buffer | |
| CGeneratorOutput_Func | |
| CGeneratorOutputBase | |
| CGeneratorOutputImpl | |
| CGeneratorParam_Arithmetic | |
| CGeneratorParam_AutoSchedulerParams | |
| CGeneratorParam_Bool | |
| CGeneratorParam_Enum | |
| CGeneratorParam_LoopLevel | |
| CGeneratorParam_String | |
| CGeneratorParam_Synthetic | |
| CGeneratorParam_Target | |
| CGeneratorParam_Type | |
| CGeneratorParamBase | |
| CGeneratorParamImpl | |
| CGeneratorParamInfo | |
| CGeneratorRegistry | |
| CGIOBase | GIOBase is the base class for all GeneratorInput<> and GeneratorOutput<> instantiations; it is not part of the public API and should never be used directly by user code |
| CGPUCompilationCache | |
| CGpuObjectLifetimeTracker | |
| CGT | Is the first expression greater than the second |
| CHalideBufferStaticTypeAndDims | |
| CHalideBufferStaticTypeAndDims<::Halide::Buffer< T, Dims > > | |
| CHalideBufferStaticTypeAndDims<::Halide::Runtime::Buffer< T, Dims > > | |
| Chas_static_halide_type_method | |
| Chas_static_halide_type_method< T2, typename type_sink< decltype(T2::static_halide_type())>::type > | |
| CHexagonAlignmentAnalyzer | |
| CHoistedStorage | Represents a location where storage will be hoisted to for a Func / Realize node with a given name |
| CHostClosure | A Closure modified to inspect GPU-specific memory accesses, and produce a vector of DeviceArgument objects |
| CIfThenElse | An if-then-else block |
| CIndentation | |
| CInferredArgument | An inferred argument |
| CInterval | A class to represent ranges of Exprs |
| CIntImm | Integer constants |
| CIntrusivePtr | Intrusive shared pointers have a reference count (a RefCount object) stored in the class itself |
| CIRDeepCompare | A compare struct built around less_than, for use as the comparison object in a std::map or std::set |
| CIRGraphDeepCompare | A compare struct built around graph_less_than, for use as the comparison object in a std::map or std::set |
| CIRGraphMutator | A mutator that caches and reapplies previously-done mutations, so that it can handle graphs of IR that have not had CSE done to them |
| CIRGraphVisitor | A base class for algorithms that walk recursively over the IR without visiting the same node twice |
| CIRHandle | IR nodes are passed around opaque handles to them |
| CIRMutator | A base class for passes over the IR which modify it (e.g |
| CIRNode | The abstract base classes for a node in the Halide IR |
| CIRPrinter | An IRVisitor that emits IR to the given output stream in a human readable form |
| CIRVisitor | A base class for algorithms that need to recursively walk over the IR |
| Cis_printable_arg | |
| CIsHalideBuffer | |
| CIsHalideBuffer< const halide_buffer_t * > | |
| CIsHalideBuffer< halide_buffer_t * > | |
| CIsHalideBuffer<::Halide::Buffer< T, Dims > > | |
| CIsHalideBuffer<::Halide::Runtime::Buffer< T, Dims > > | |
| CIsRoundtrippable | |
| CJITCache | |
| CJITErrorBuffer | |
| CJITFuncCallContext | |
| ►CJITModule | |
| CSymbol | |
| CJITSharedRuntime | |
| CJSONCompilerLogger | JSONCompilerLogger is a basic implementation of the CompilerLogger interface that saves logged data, then logs it all in JSON format in emit_to_stream() |
| CLE | Is the first expression less than or equal to the second |
| CLet | A let expression, like you might find in a functional language |
| CLetStmt | The statement form of a let node |
| CLoad | Load a value from a named symbol if predicate is true |
| CLoweredArgument | Definition of an argument to a LoweredFunc |
| CLoweredFunc | Definition of a lowered function |
| CLT | Is the first expression less than the second |
| CMax | The greater of two values |
| Cmeta_and | |
| Cmeta_and< T1, Args... > | |
| Cmeta_or | |
| Cmeta_or< T1, Args... > | |
| CMin | The lesser of two values |
| CMod | The remainder of a / b |
| CModulusRemainder | The result of modulus_remainder analysis |
| CMul | The product of two expressions |
| CNE | Is the first expression not equal to the second |
| CNoRealizations | |
| CNoRealizations< T, Args... > | |
| CNoRealizations<> | |
| CNot | Logical not - true if the expression false |
| CObjectInstanceRegistry | |
| COr | Logical or - is at least one of the expression true |
| COutputInfo | |
| CPipelineFeatures | |
| CPrefetch | Represent a multi-dimensional region of a Func or an ImageParam that needs to be prefetched |
| CPrefetchDirective | |
| CPrintSpan | Allow easily printing the contents of containers, or std::vector-like containers, in debug output |
| CPrintSpanLn | Allow easily printing the contents of spans, or std::vector-like spans, in debug output |
| CProducerConsumer | This node is a helpful annotation to do with permissions |
| CProvide | This defines the value of a function at a multi-dimensional location |
| CPythonExtensionGen | |
| CRamp | A linear ramp vector node |
| CRealize | Allocate a multi-dimensional buffer of the given type and size |
| ►CReductionDomain | A reference-counted handle on a reduction domain, which is just a vector of ReductionVariable |
| CCompare | This lets you use a ReductionDomain as a key in a map of the form map<ReductionDomain, Foo, ReductionDomain::Compare> |
| ►CReductionVariable | A single named dimension of a reduction domain |
| CCompare | This lets you use a ReductionVariable as a key in a map of the form map<ReductionVariable, Foo, ReductionVariable::Compare> |
| CReductionVariableInfo | Return a list of reduction variables the expression or tuple depends on |
| CRefCount | A class representing a reference count to be used with IntrusivePtr |
| CRegionCosts | Auto scheduling component which is used to assign costs for computing a region of a function or one of its stages |
| CRegisterGenerator | |
| CReinterpret | Reinterpret value as another type, without affecting any of the bits (on little-endian systems) |
| CReportBase | |
| Creverse_adaptor | |
| CScheduleFeatures | |
| ►CScope | A common pattern when traversing Halide IR is that you need to keep track of stuff when you find a Let or a LetStmt, and that it should hide previous values with the same name until you leave the Let or LetStmt nodes This class helps with that |
| Cconst_iterator | Iterate through the scope |
| CPushToken | |
| CScopedBinding | Helper class for pushing/popping Scope<> values, to allow for early-exit in Visitor/Mutators that preserves correctness |
| CScopedBinding< void > | |
| CScopedValue | Helper class for saving/restoring variable values on the stack, to allow for early-exit that preserves correctness |
| CSelect | A ternary operator |
| Cselect_type | |
| Cselect_type< First > | |
| CShuffle | Construct a new vector by taking elements from another sequence of vectors |
| ►CSimplify | |
| ►CExprInfo | |
| CBitsKnown | |
| CScopedFact | |
| CVarInfo | |
| CSmallStack | A stack which can store one item very efficiently |
| CSmallStack< void > | |
| CSolverResult | |
| CSpecialization | |
| CSplit | |
| CStageSchedule | A schedule for a single stage of a Halide pipeline |
| CStaticCast | |
| ►CStmt | A reference-counted handle to a statement node |
| CCompare | This lets you use a Stmt as a key in a map of the form map<Stmt, Foo, Stmt::Compare> |
| CStmtNode | |
| CStorageDim | Properties of one axis of the storage of a Func |
| CStore | Store a 'value' to the buffer called 'name' at a given 'index' if 'predicate' is true |
| CStringImm | String constants |
| CStubInput | |
| CStubInputBuffer | StubInputBuffer is the placeholder that a Stub uses when it requires a Buffer for an input (rather than merely a Func or Expr) |
| CStubOutputBuffer | StubOutputBuffer is the placeholder that a Stub uses when it requires a Buffer for an output (rather than merely a Func) |
| CStubOutputBufferBase | |
| CSub | The difference of two expressions |
| CTemporaryFile | A simple utility class that creates a temporary file in its ctor and deletes that file in its dtor; this is useful for temporary files that you want to ensure are deleted when exiting a certain scope |
| Ctype_sink | |
| CUIntImm | Unsigned integer constants |
| CVariable | A named variable |
| CVariadicVisitor | A visitor/mutator capable of passing arbitrary arguments to the visit methods using CRTP and returning any types from them |
| CVectorReduce | Horizontally reduce a vector to a scalar or narrower vector using the given commutative and associative binary operator |
| CVoidifier | |
| CWarningReport | |
| CWasmModule | Handle to compiled wasm code which can be called later |
| CWeights | |
| NPythonBindings | |
| ►NPyTorch | |
| CUserContext | |
| ►NRuntime | |
| ►NInternal | |
| NConstants | |
| ►NCuda | |
| CCUDA_MEMCPY3D_st | |
| NMetal | |
| NQurt | |
| ►NSynchronization | |
| Cbroadcast_parking_control | |
| Cbucket_pair | |
| Cfast_cond | |
| Cfast_mutex | |
| Chash_bucket | |
| Chash_table | |
| Cmutex_parking_control | |
| Cparking_control | |
| Cqueue_data | |
| Csignal_parking_control | |
| Cspin_control | |
| Cvalidate_action | |
| Cwait_parking_control | |
| Cword_lock | |
| Cword_lock_queue_data | |
| ►NVulkan | |
| CVulkanCompilationCacheEntry | |
| CVulkanCompiledShaderModule | |
| CVulkanContext | |
| CVulkanDispatchData | |
| CVulkanMemoryAllocator | Vulkan Memory Allocator class interface for managing large memory requests stored as contiguous blocks of memory, which are then sub-allocated into smaller regions of memory to avoid the excessive cost of vkAllocate and the limited number of available allocation calls through the API |
| CVulkanMemoryConfig | |
| CVulkanShaderBinding | |
| CVulkanSharedMemoryAllocation | |
| CVulkanSpecializationConstant | |
| CVulkanWorkgroupSizeBinding | |
| ►CBlockAllocator | Allocator class interface for managing large contiguous blocks of memory, which are then sub-allocated into smaller regions of memory |
| CConfig | |
| CMemoryAllocators | |
| CBlockRegion | |
| CBlockResource | |
| ►CBlockStorage | |
| CConfig | |
| CCacheEntry | |
| CCpuFeatures | |
| CDefaultAllocatorFns | |
| Cdevice_copy | |
| Chalide_cond_with_spinning | |
| CHalideSystemAllocatorFns | |
| CHashMap | |
| ►CLinkedList | |
| CEntryType | |
| ►CMemoryArena | |
| CConfig | |
| CMemoryBlock | |
| CMemoryBlockAllocatorFns | |
| CMemoryProperties | |
| CMemoryRange | |
| CMemoryRegion | |
| CMemoryRegionAllocatorFns | |
| CMemoryRequest | |
| CPointerTable | |
| ►CPrinterBase | |
| CFloat16Bits | |
| ►CRegionAllocator | Allocator class interface for sub-allocating a contiguous memory block into smaller regions of memory |
| CMemoryAllocators | |
| CScopedMutexLock | |
| CScopedSpinLock | |
| CStringStorage | |
| CStringTable | |
| CStringUtils | |
| CSystemMemoryAllocatorFns | |
| CTHashMap | |
| Cwork | |
| Cwork_queue_t | |
| CAllInts | |
| CAllInts< double, Args... > | |
| CAllInts< float, Args... > | |
| CAllInts< T, Args... > | |
| CAllInts<> | |
| CAllocationHeader | A struct acting as a header for allocations owned by the Buffer class itself |
| ►CBuffer | A templated Buffer class that wraps halide_buffer_t and adds functionality |
| ►CDimension | Read-only access to the shape |
| Citerator | An iterator class, so that you can iterate over coordinates in a dimensions using a range-based for loop |
| CDeviceRefCount | A similar struct for managing device allocations |
| CArgument | A struct representing an argument to a halide-generated function |
| CArgumentEstimates | |
| CAutoschedulerParams | Special the Autoscheduler to be used (if any), along with arbitrary additional arguments specific to the given Autoscheduler |
| CAutoSchedulerResults | |
| Cbfloat16_t | Class that provides a type that implements half precision floating point using the bfloat16 format |
| CBuffer | A Halide::Buffer is a named shared reference to a Halide::Runtime::Buffer |
| CBufferConstraint | |
| CCallable | |
| CCompileError | An error that occurs while compiling a Halide pipeline that Halide attributes to a user error |
| CCompileTimeErrorReporter | CompileTimeErrorReporter is used at compile time (not runtime) when an error or warning is generated by Halide |
| CCostModel | |
| CCustomLoweringPass | A custom lowering pass |
| CDefaultCostModel | |
| CDerivative | Helper structure storing the adjoints Func |
| CError | A base class for Halide errors |
| CEvictionKey | Helper class for identifying purpose of an Expr passed to memoize |
| CExpr | A fragment of Halide syntax |
| CExprCompare | This lets you use an Expr as a key in a map of the form map<Expr, Foo, ExprCompare> |
| CExternCFunction | |
| CExternFuncArgument | An argument to an extern-defined Func |
| CExternSignature | |
| Cfloat16_t | Class that provides a type that implements half precision floating point (IEEE754 2008 binary16) in software |
| CFunc | A halide function |
| CFuncRef | A fragment of front-end syntax of the form f(x, y, z), where x, y, z are Vars or Exprs |
| CFuncTupleElementRef | A fragment of front-end syntax of the form f(x, y, z)[index], where x, y, z are Vars or Exprs |
| CFuseLoopLevel | |
| CGenerator | |
| CGeneratorContext | GeneratorContext is a class that is used when using Generators (or Stubs) directly; it is used to allow the outer context (typically, either a Generator or "top-level" code) to specify certain information to the inner context to ensure that inner and outer Generators are compiled in a compatible way |
| CGeneratorInput | |
| CGeneratorOutput | |
| CGeneratorParam | GeneratorParam is a templated class that can be used to modify the behavior of the Generator at code-generation time |
| CImageParam | An Image parameter to a halide pipeline |
| CImplicitVar | |
| CInternalError | An error that occurs while compiling a Halide pipeline that Halide attributes to an internal compiler bug, or to an invalid use of Halide's internals |
| CJITExtern | |
| CJITHandlers | A set of custom overrides of runtime functions |
| CJITUserContext | A context to be passed to Pipeline::realize |
| CLoopLevel | A reference to a site in a Halide statement at the top of the body of a particular for loop |
| CModule | A halide module |
| CNamesInterface | |
| COutputImageParam | A handle on the output buffer of a pipeline |
| CParam | A scalar parameter to a halide pipeline |
| CParameter | A reference-counted handle to a parameter to a halide pipeline |
| ►CPipeline | A class representing a Halide pipeline |
| CRealizationArg | |
| CRange | A single-dimensional span |
| CRDom | A multi-dimensional domain over which to iterate |
| CRealization | A Realization is a vector of references to existing Buffer objects |
| CRuntimeError | An error that occurs while running a JIT-compiled Halide pipeline |
| CRVar | A reduction variable represents a single dimension of a reduction domain (RDom) |
| CSimdOpCheckTest | |
| CStage | A single definition of a Func |
| CTarget | A struct representing a target machine and os to generate code for |
| CTask | |
| CTestResult | |
| CTuple | Create a small array of Exprs for defining and calling functions with multiple outputs |
| CType | Types in the halide type system |
| CVar | A Halide variable, to be used when defining functions |
| CVarOrRVar | A class that can represent Vars or RVars |
| Nhalide_register_generator | |
| ▼Nllvm | |
| CIRBuilder | |
| NMessage | |