kc3-lang/angle/src/common/PackedCLEnums_autogen.h

Branch : - branch - main - tag -

• Show log

  Commit

• Author : John Plate
  Date : 2021-04-28 18:26:00
  Hash : dfe208f1
  Message : Add loader for CL pass-through back end Bug: angleproject:5904 Change-Id: If4960f3150f6bbc85a30f0f6ac5c9e668e6ff756 Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/2864022 Commit-Queue: John Plate <jplate@google.com> Reviewed-by: Jamie Madill <jmadill@chromium.org> Reviewed-by: Cody Northrop <cnorthrop@google.com>

• src/common/PackedCLEnums_autogen.h

• // GENERATED FILE - DO NOT EDIT.
  // Generated by gen_packed_gl_enums.py using data from packed_cl_enums.json.
  //
  // Copyright 2017 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  // PackedCLEnums_autogen.h:
  //   Declares ANGLE-specific enums classes for CLenums and functions operating
  //   on them.
  
  #ifndef COMMON_PACKEDCLENUMS_AUTOGEN_H_
  #define COMMON_PACKEDCLENUMS_AUTOGEN_H_
  
  #include <angle_cl.h>
  typedef cl_uint CLenum;
  
  #include <cstdint>
  #include <ostream>
  
  namespace cl
  {
  
  template <typename Enum>
  Enum FromCLenum(CLenum from);
  
  enum class AddressingMode : uint8_t
  {
      None           = 0,
      ClampToEdge    = 1,
      Clamp          = 2,
      Repeat         = 3,
      MirroredRepeat = 4,
  
      InvalidEnum = 5,
      EnumCount   = 5,
  };
  
  template <>
  AddressingMode FromCLenum<AddressingMode>(CLenum from);
  CLenum ToCLenum(AddressingMode from);
  std::ostream &operator<<(std::ostream &os, AddressingMode value);
  
  enum class CommandQueueInfo : uint8_t
  {
      Context         = 0,
      Device          = 1,
      ReferenceCount  = 2,
      Properties      = 3,
      Size            = 4,
      DeviceDefault   = 5,
      PropertiesArray = 6,
  
      InvalidEnum = 7,
      EnumCount   = 7,
  };
  
  template <>
  CommandQueueInfo FromCLenum<CommandQueueInfo>(CLenum from);
  CLenum ToCLenum(CommandQueueInfo from);
  std::ostream &operator<<(std::ostream &os, CommandQueueInfo value);
  
  enum class ContextInfo : uint8_t
  {
      ReferenceCount = 0,
      Devices        = 1,
      Properties     = 2,
      NumDevices     = 3,
  
      InvalidEnum = 4,
      EnumCount   = 4,
  };
  
  template <>
  ContextInfo FromCLenum<ContextInfo>(CLenum from);
  CLenum ToCLenum(ContextInfo from);
  std::ostream &operator<<(std::ostream &os, ContextInfo value);
  
  enum class DeviceInfo : uint8_t
  {
      Type                                = 0,
      VendorID                            = 1,
      MaxComputeUnits                     = 2,
      MaxWorkItemDimensions               = 3,
      MaxWorkGroupSize                    = 4,
      MaxWorkItemSizes                    = 5,
      PreferredVectorWidthChar            = 6,
      PreferredVectorWidthShort           = 7,
      PreferredVectorWidthInt             = 8,
      PreferredVectorWidthLong            = 9,
      PreferredVectorWidthFloat           = 10,
      PreferredVectorWidthDouble          = 11,
      MaxClockFrequency                   = 12,
      AddressBits                         = 13,
      MaxReadImageArgs                    = 14,
      MaxWriteImageArgs                   = 15,
      MaxMemAllocSize                     = 16,
      Image2D_MaxWidth                    = 17,
      Image2D_MaxHeight                   = 18,
      Image3D_MaxWidth                    = 19,
      Image3D_MaxHeight                   = 20,
      Image3D_MaxDepth                    = 21,
      ImageSupport                        = 22,
      MaxParameterSize                    = 23,
      MaxSamplers                         = 24,
      MemBaseAddrAlign                    = 25,
      MinDataTypeAlignSize                = 26,
      SingleFpConfig                      = 27,
      GlobalMemCacheType                  = 28,
      GlobalMemCachelineSize              = 29,
      GlobalMemCacheSize                  = 30,
      GlobalMemSize                       = 31,
      MaxConstantBufferSize               = 32,
      MaxConstantArgs                     = 33,
      LocalMemType                        = 34,
      LocalMemSize                        = 35,
      ErrorCorrectionSupport              = 36,
      ProfilingTimerResolution            = 37,
      EndianLittle                        = 38,
      Available                           = 39,
      CompilerAvailable                   = 40,
      ExecutionCapabilities               = 41,
      QueueOnHostProperties               = 42,
      Name                                = 43,
      Vendor                              = 44,
      DriverVersion                       = 45,
      Profile                             = 46,
      Version                             = 47,
      Extensions                          = 48,
      Platform                            = 49,
      DoubleFpConfig                      = 50,
      HalfFpConfig                        = 51,
      PreferredVectorWidthHalf            = 52,
      HostUnifiedMemory                   = 53,
      NativeVectorWidthChar               = 54,
      NativeVectorWidthShort              = 55,
      NativeVectorWidthInt                = 56,
      NativeVectorWidthLong               = 57,
      NativeVectorWidthFloat              = 58,
      NativeVectorWidthDouble             = 59,
      NativeVectorWidthHalf               = 60,
      OpenCL_C_Version                    = 61,
      LinkerAvailable                     = 62,
      BuiltInKernels                      = 63,
      ImageMaxBufferSize                  = 64,
      ImageMaxArraySize                   = 65,
      ParentDevice                        = 66,
      PartitionMaxSubDevices              = 67,
      PartitionProperties                 = 68,
      PartitionAffinityDomain             = 69,
      PartitionType                       = 70,
      ReferenceCount                      = 71,
      PreferredInteropUserSync            = 72,
      PrintfBufferSize                    = 73,
      ImagePitchAlignment                 = 74,
      ImageBaseAddressAlignment           = 75,
      MaxReadWriteImageArgs               = 76,
      MaxGlobalVariableSize               = 77,
      QueueOnDeviceProperties             = 78,
      QueueOnDevicePreferredSize          = 79,
      QueueOnDeviceMaxSize                = 80,
      MaxOnDeviceQueues                   = 81,
      MaxOnDeviceEvents                   = 82,
      SVM_Capabilities                    = 83,
      GlobalVariablePreferredTotalSize    = 84,
      MaxPipeArgs                         = 85,
      PipeMaxActiveReservations           = 86,
      PipeMaxPacketSize                   = 87,
      PreferredPlatformAtomicAlignment    = 88,
      PreferredGlobalAtomicAlignment      = 89,
      PreferredLocalAtomicAlignment       = 90,
      IL_Version                          = 91,
      MaxNumSubGroups                     = 92,
      SubGroupIndependentForwardProgress  = 93,
      NumericVersion                      = 94,
      ExtensionsWithVersion               = 95,
      ILsWithVersion                      = 96,
      BuiltInKernelsWithVersion           = 97,
      AtomicMemoryCapabilities            = 98,
      AtomicFenceCapabilities             = 99,
      NonUniformWorkGroupSupport          = 100,
      OpenCL_C_AllVersions                = 101,
      PreferredWorkGroupSizeMultiple      = 102,
      WorkGroupCollectiveFunctionsSupport = 103,
      GenericAddressSpaceSupport          = 104,
      OpenCL_C_Features                   = 105,
      DeviceEnqueueCapabilities           = 106,
      PipeSupport                         = 107,
      LatestConformanceVersionPassed      = 108,
  
      InvalidEnum = 109,
      EnumCount   = 109,
  };
  
  template <>
  DeviceInfo FromCLenum<DeviceInfo>(CLenum from);
  CLenum ToCLenum(DeviceInfo from);
  std::ostream &operator<<(std::ostream &os, DeviceInfo value);
  
  enum class EventInfo : uint8_t
  {
      CommandQueue           = 0,
      CommandType            = 1,
      ReferenceCount         = 2,
      CommandExecutionStatus = 3,
      Context                = 4,
  
      InvalidEnum = 5,
      EnumCount   = 5,
  };
  
  template <>
  EventInfo FromCLenum<EventInfo>(CLenum from);
  CLenum ToCLenum(EventInfo from);
  std::ostream &operator<<(std::ostream &os, EventInfo value);
  
  enum class FilterMode : uint8_t
  {
      Nearest = 0,
      Linear  = 1,
  
      InvalidEnum = 2,
      EnumCount   = 2,
  };
  
  template <>
  FilterMode FromCLenum<FilterMode>(CLenum from);
  CLenum ToCLenum(FilterMode from);
  std::ostream &operator<<(std::ostream &os, FilterMode value);
  
  enum class ImageInfo : uint8_t
  {
      Format       = 0,
      ElementSize  = 1,
      RowPitch     = 2,
      SlicePitch   = 3,
      Width        = 4,
      Height       = 5,
      Depth        = 6,
      ArraySize    = 7,
      Buffer       = 8,
      NumMipLevels = 9,
      NumSamples   = 10,
  
      InvalidEnum = 11,
      EnumCount   = 11,
  };
  
  template <>
  ImageInfo FromCLenum<ImageInfo>(CLenum from);
  CLenum ToCLenum(ImageInfo from);
  std::ostream &operator<<(std::ostream &os, ImageInfo value);
  
  enum class KernelArgInfo : uint8_t
  {
      AddressQualifier = 0,
      AccessQualifier  = 1,
      TypeName         = 2,
      TypeQualifier    = 3,
      Name             = 4,
  
      InvalidEnum = 5,
      EnumCount   = 5,
  };
  
  template <>
  KernelArgInfo FromCLenum<KernelArgInfo>(CLenum from);
  CLenum ToCLenum(KernelArgInfo from);
  std::ostream &operator<<(std::ostream &os, KernelArgInfo value);
  
  enum class KernelExecInfo : uint8_t
  {
      SVM_Ptrs            = 0,
      SVM_FineGrainSystem = 1,
  
      InvalidEnum = 2,
      EnumCount   = 2,
  };
  
  template <>
  KernelExecInfo FromCLenum<KernelExecInfo>(CLenum from);
  CLenum ToCLenum(KernelExecInfo from);
  std::ostream &operator<<(std::ostream &os, KernelExecInfo value);
  
  enum class KernelInfo : uint8_t
  {
      FunctionName   = 0,
      NumArgs        = 1,
      ReferenceCount = 2,
      Context        = 3,
      Program        = 4,
      Attributes     = 5,
  
      InvalidEnum = 6,
      EnumCount   = 6,
  };
  
  template <>
  KernelInfo FromCLenum<KernelInfo>(CLenum from);
  CLenum ToCLenum(KernelInfo from);
  std::ostream &operator<<(std::ostream &os, KernelInfo value);
  
  enum class KernelSubGroupInfo : uint8_t
  {
      MaxSubGroupSizeForNdrange = 0,
      SubGroupCountForNdrange   = 1,
      LocalSizeForSubGroupCount = 2,
      MaxNumSubGroups           = 3,
      CompileNumSubGroups       = 4,
  
      InvalidEnum = 5,
      EnumCount   = 5,
  };
  
  template <>
  KernelSubGroupInfo FromCLenum<KernelSubGroupInfo>(CLenum from);
  CLenum ToCLenum(KernelSubGroupInfo from);
  std::ostream &operator<<(std::ostream &os, KernelSubGroupInfo value);
  
  enum class KernelWorkGroupInfo : uint8_t
  {
      WorkGroupSize                  = 0,
      CompileWorkGroupSize           = 1,
      LocalMemSize                   = 2,
      PreferredWorkGroupSizeMultiple = 3,
      PrivateMemSize                 = 4,
      GlobalWorkSize                 = 5,
  
      InvalidEnum = 6,
      EnumCount   = 6,
  };
  
  template <>
  KernelWorkGroupInfo FromCLenum<KernelWorkGroupInfo>(CLenum from);
  CLenum ToCLenum(KernelWorkGroupInfo from);
  std::ostream &operator<<(std::ostream &os, KernelWorkGroupInfo value);
  
  enum class MemInfo : uint8_t
  {
      Type                = 0,
      Flags               = 1,
      Size                = 2,
      HostPtr             = 3,
      MapCount            = 4,
      ReferenceCount      = 5,
      Context             = 6,
      AssociatedMemObject = 7,
      Offset              = 8,
      UsesSVM_Pointer     = 9,
      Properties          = 10,
  
      InvalidEnum = 11,
      EnumCount   = 11,
  };
  
  template <>
  MemInfo FromCLenum<MemInfo>(CLenum from);
  CLenum ToCLenum(MemInfo from);
  std::ostream &operator<<(std::ostream &os, MemInfo value);
  
  enum class MemObjectType : uint8_t
  {
      Buffer         = 0,
      Image2D        = 1,
      Image3D        = 2,
      Image2D_Array  = 3,
      Image1D        = 4,
      Image1D_Array  = 5,
      Image1D_Buffer = 6,
      Pipe           = 7,
  
      InvalidEnum = 8,
      EnumCount   = 8,
  };
  
  template <>
  MemObjectType FromCLenum<MemObjectType>(CLenum from);
  CLenum ToCLenum(MemObjectType from);
  std::ostream &operator<<(std::ostream &os, MemObjectType value);
  
  enum class PipeInfo : uint8_t
  {
      PacketSize = 0,
      MaxPackets = 1,
      Properties = 2,
  
      InvalidEnum = 3,
      EnumCount   = 3,
  };
  
  template <>
  PipeInfo FromCLenum<PipeInfo>(CLenum from);
  CLenum ToCLenum(PipeInfo from);
  std::ostream &operator<<(std::ostream &os, PipeInfo value);
  
  enum class PlatformInfo : uint8_t
  {
      Profile               = 0,
      Version               = 1,
      Name                  = 2,
      Vendor                = 3,
      Extensions            = 4,
      HostTimerResolution   = 5,
      NumericVersion        = 6,
      ExtensionsWithVersion = 7,
      IcdSuffix             = 8,
  
      InvalidEnum = 9,
      EnumCount   = 9,
  };
  
  template <>
  PlatformInfo FromCLenum<PlatformInfo>(CLenum from);
  CLenum ToCLenum(PlatformInfo from);
  std::ostream &operator<<(std::ostream &os, PlatformInfo value);
  
  enum class ProfilingInfo : uint8_t
  {
      CommandQueued   = 0,
      CommandSubmit   = 1,
      CommandStart    = 2,
      CommandEnd      = 3,
      CommandComplete = 4,
  
      InvalidEnum = 5,
      EnumCount   = 5,
  };
  
  template <>
  ProfilingInfo FromCLenum<ProfilingInfo>(CLenum from);
  CLenum ToCLenum(ProfilingInfo from);
  std::ostream &operator<<(std::ostream &os, ProfilingInfo value);
  
  enum class ProgramBuildInfo : uint8_t
  {
      Status                  = 0,
      Options                 = 1,
      Log                     = 2,
      BinaryType              = 3,
      GlobalVariableTotalSize = 4,
  
      InvalidEnum = 5,
      EnumCount   = 5,
  };
  
  template <>
  ProgramBuildInfo FromCLenum<ProgramBuildInfo>(CLenum from);
  CLenum ToCLenum(ProgramBuildInfo from);
  std::ostream &operator<<(std::ostream &os, ProgramBuildInfo value);
  
  enum class ProgramInfo : uint8_t
  {
      ReferenceCount          = 0,
      Context                 = 1,
      NumDevices              = 2,
      Devices                 = 3,
      Source                  = 4,
      BinarySizes             = 5,
      Binaries                = 6,
      NumKernels              = 7,
      KernelNames             = 8,
      IL                      = 9,
      ScopeGlobalCtorsPresent = 10,
      ScopeGlobalDtorsPresent = 11,
  
      InvalidEnum = 12,
      EnumCount   = 12,
  };
  
  template <>
  ProgramInfo FromCLenum<ProgramInfo>(CLenum from);
  CLenum ToCLenum(ProgramInfo from);
  std::ostream &operator<<(std::ostream &os, ProgramInfo value);
  
  enum class SamplerInfo : uint8_t
  {
      ReferenceCount   = 0,
      Context          = 1,
      NormalizedCoords = 2,
      AddressingMode   = 3,
      FilterMode       = 4,
      MipFilterMode    = 5,
      LOD_Min          = 6,
      LOD_Max          = 7,
      Properties       = 8,
  
      InvalidEnum = 9,
      EnumCount   = 9,
  };
  
  template <>
  SamplerInfo FromCLenum<SamplerInfo>(CLenum from);
  CLenum ToCLenum(SamplerInfo from);
  std::ostream &operator<<(std::ostream &os, SamplerInfo value);
  
  }  // namespace cl
  
  #endif  // COMMON_PACKEDCLENUMS_AUTOGEN_H_