kc3-lang/angle/src/libANGLE/validationEGL.h

• Show log

  Commit

• Hash : 8403e4c5
  Author :
  Date : 2022-10-10T20:59:29
  

  EGL: Resource IDs for Surface, Context and EGL Image.
  
  This will make these classes play nicely with resource maps. As these
  objects are used in a lot of places, and simplified C can't handle
  unordered_map, it's necessary to index the maps by simple packed IDs
  in capture/replay code. This indirection will also have increased
  safety as we validate EGL resource ID handle values before accessing
  the memory directly.
  
  Also hides some of the other EGL capture methods behind helper methods
  to simplify the C code and hide assignments and other complex maps.
  
  Bug: angleproject:7758
  Change-Id: Ibc7bb56430d3068bd38877c9dfb011979d4ea234
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3957164
  Reviewed-by: Cody Northrop <cnorthrop@google.com>
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Yuxin Hu <yuxinhu@google.com>
  

Download

• src/libANGLE/validationEGL.h

• //
  // Copyright 2015 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.
  //
  
  // validationEGL.h: Validation functions for generic EGL entry point parameters
  
  #ifndef LIBANGLE_VALIDATIONEGL_H_
  #define LIBANGLE_VALIDATIONEGL_H_
  
  #include "common/PackedEnums.h"
  #include "libANGLE/Error.h"
  #include "libANGLE/Thread.h"
  
  #include <EGL/egl.h>
  #include <EGL/eglext.h>
  
  namespace gl
  {
  class Context;
  }
  
  namespace egl
  {
  constexpr EGLint kEglMajorVersion = 1;
  constexpr EGLint kEglMinorVersion = 5;
  
  class AttributeMap;
  struct ClientExtensions;
  struct Config;
  class Device;
  class Display;
  class Image;
  class Stream;
  class Surface;
  class Sync;
  class Thread;
  class LabeledObject;
  
  struct ValidationContext
  {
      ValidationContext(Thread *threadIn, const char *entryPointIn, const LabeledObject *objectIn)
          : eglThread(threadIn), entryPoint(entryPointIn), labeledObject(objectIn)
      {}
  
      // We should remove the message-less overload once we have messages for all EGL errors.
      void setError(EGLint error) const;
      ANGLE_FORMAT_PRINTF(3, 4)
      void setError(EGLint error, const char *message...) const;
  
      Thread *eglThread;
      const char *entryPoint;
      const LabeledObject *labeledObject;
  };
  
  // Object validation
  bool ValidateDisplay(const ValidationContext *val, const Display *display);
  bool ValidateSurface(const ValidationContext *val, const Display *display, SurfaceID surfaceID);
  bool ValidateConfig(const ValidationContext *val, const Display *display, const Config *config);
  bool ValidateContext(const ValidationContext *val, const Display *display, gl::ContextID contextID);
  bool ValidateImage(const ValidationContext *val, const Display *display, ImageID imageID);
  bool ValidateDevice(const ValidationContext *val, const Device *device);
  bool ValidateSync(const ValidationContext *val, const Display *display, const Sync *sync);
  
  // Return the requested object only if it is valid (otherwise nullptr)
  const Thread *GetThreadIfValid(const Thread *thread);
  const Display *GetDisplayIfValid(const Display *display);
  const Surface *GetSurfaceIfValid(const Display *display, SurfaceID surfaceID);
  const Image *GetImageIfValid(const Display *display, ImageID imageID);
  const Stream *GetStreamIfValid(const Display *display, const Stream *stream);
  const gl::Context *GetContextIfValid(const Display *display, gl::ContextID contextID);
  const Device *GetDeviceIfValid(const Device *device);
  const Sync *GetSyncIfValid(const Display *display, const Sync *sync);
  const LabeledObject *GetLabeledObjectIfValid(Thread *thread,
                                               const Display *display,
                                               ObjectType objectType,
                                               EGLObjectKHR object);
  LabeledObject *GetLabeledObjectIfValid(Thread *thread,
                                         Display *display,
                                         ObjectType objectType,
                                         EGLObjectKHR object);
  
  // A template struct for determining the default value to return for each entry point.
  template <angle::EntryPoint EP, typename ReturnType>
  struct DefaultReturnValue
  {
      static constexpr ReturnType kValue = static_cast<ReturnType>(0);
  };
  
  template <angle::EntryPoint EP, typename ReturnType>
  ReturnType GetDefaultReturnValue(Thread *thread);
  
  template <>
  ANGLE_INLINE EGLint
  GetDefaultReturnValue<angle::EntryPoint::EGLLabelObjectKHR, EGLint>(Thread *thread)
  {
      return thread->getError();
  }
  
  template <angle::EntryPoint EP, typename ReturnType>
  ANGLE_INLINE ReturnType GetDefaultReturnValue(Thread *thread)
  {
      return DefaultReturnValue<EP, ReturnType>::kValue;
  }
  
  // First case: handling packed enums.
  template <typename PackedT, typename FromT>
  typename std::enable_if<std::is_enum<PackedT>::value, PackedT>::type PackParam(FromT from)
  {
      return FromEGLenum<PackedT>(from);
  }
  
  // Second case: handling resource ids.
  template <typename PackedT,
            typename FromT,
            typename std::enable_if<IsResourceIDType<PackedT>::value>::type * = nullptr>
  PackedT PackParam(FromT from)
  {
      return {static_cast<GLuint>(reinterpret_cast<uintptr_t>(from))};
  }
  
  // This and the next 2 template specializations handle distinguishing between EGLint, EGLAttrib
  // and other. This is needed because on some architectures EGLint and EGLAttrib are not the same
  // base type. Previously the code conditionally compiled 2 specializations on 64 bit but it turns
  // out on WatchOS the assumption about 32/64 bit and if EGLint and ELGAttrib are the same or
  // different did not hold.
  template <typename PackedT,
            typename FromT,
            typename std::enable_if<!std::is_enum<PackedT>::value>::type              * = nullptr,
            typename std::enable_if<std::is_same<FromT, const EGLint *>::value>::type * = nullptr>
  typename std::remove_reference<PackedT>::type PackParam(FromT attribs)
  {
      return AttributeMap::CreateFromIntArray(attribs);
  }
  
  template <typename PackedT,
            typename FromT,
            typename std::enable_if<!std::is_enum<PackedT>::value>::type                 * = nullptr,
            typename std::enable_if<!std::is_same<FromT, const EGLint *>::value>::type   * = nullptr,
            typename std::enable_if<std::is_same<FromT, const EGLAttrib *>::value>::type * = nullptr>
  typename std::remove_reference<PackedT>::type PackParam(FromT attribs)
  {
      return AttributeMap::CreateFromAttribArray(attribs);
  }
  
  template <typename PackedT,
            typename FromT,
            typename std::enable_if<!std::is_enum<PackedT>::value>::type                  * = nullptr,
            typename std::enable_if<!std::is_same<FromT, const EGLint *>::value>::type    * = nullptr,
            typename std::enable_if<!std::is_same<FromT, const EGLAttrib *>::value>::type * = nullptr,
            typename std::enable_if<!IsResourceIDType<PackedT>::value>::type              * = nullptr>
  typename std::remove_reference<PackedT>::type PackParam(FromT from)
  {
      return static_cast<PackedT>(from);
  }
  
  }  // namespace egl
  
  #define ANGLE_EGL_VALIDATE(THREAD, EP, OBJ, RETURN_TYPE, ...)                              \
      do                                                                                     \
      {                                                                                      \
          const char *epname = "egl" #EP;                                                    \
          ValidationContext vctx(THREAD, epname, OBJ);                                       \
          auto ANGLE_LOCAL_VAR = (Validate##EP(&vctx, ##__VA_ARGS__));                       \
          if (!ANGLE_LOCAL_VAR)                                                              \
          {                                                                                  \
              return GetDefaultReturnValue<angle::EntryPoint::EGL##EP, RETURN_TYPE>(THREAD); \
          }                                                                                  \
      } while (0)
  
  #define ANGLE_EGL_VALIDATE_VOID(THREAD, EP, OBJ, ...)                \
      do                                                               \
      {                                                                \
          const char *epname = "egl" #EP;                              \
          ValidationContext vctx(THREAD, epname, OBJ);                 \
          auto ANGLE_LOCAL_VAR = (Validate##EP(&vctx, ##__VA_ARGS__)); \
          if (!ANGLE_LOCAL_VAR)                                        \
          {                                                            \
              return;                                                  \
          }                                                            \
      } while (0)
  
  #define ANGLE_EGL_TRY(THREAD, EXPR, FUNCNAME, LABELOBJECT)                   \
      do                                                                       \
      {                                                                        \
          auto ANGLE_LOCAL_VAR = (EXPR);                                       \
          if (ANGLE_LOCAL_VAR.isError())                                       \
              return THREAD->setError(ANGLE_LOCAL_VAR, FUNCNAME, LABELOBJECT); \
      } while (0)
  
  #define ANGLE_EGL_TRY_RETURN(THREAD, EXPR, FUNCNAME, LABELOBJECT, RETVAL) \
      do                                                                    \
      {                                                                     \
          auto ANGLE_LOCAL_VAR = (EXPR);                                    \
          if (ANGLE_LOCAL_VAR.isError())                                    \
          {                                                                 \
              THREAD->setError(ANGLE_LOCAL_VAR, FUNCNAME, LABELOBJECT);     \
              return RETVAL;                                                \
          }                                                                 \
      } while (0)
  
  #define ANGLE_EGLBOOLEAN_TRY(EXPR)           \
      do                                       \
      {                                        \
          EGLBoolean ANGLE_LOCAL_VAR = (EXPR); \
          if (ANGLE_LOCAL_VAR != EGL_TRUE)     \
          {                                    \
              return ANGLE_LOCAL_VAR;          \
          }                                    \
      } while (0)
  
  #endif  // LIBANGLE_VALIDATIONEGL_H_
  

Download