//===--- OpenCLOptions.h ----------------------------------------*- C++ -*-===//

//

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

// See https://llvm.org/LICENSE.txt for license information.

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

//

//===----------------------------------------------------------------------===//

///

/// \file

/// Defines the clang::OpenCLOptions class.

///

//===----------------------------------------------------------------------===//

#ifndef LLVM_CLANG_BASIC_OPENCLOPTIONS_H

#define LLVM_CLANG_BASIC_OPENCLOPTIONS_H

#include "clang/Basic/LangOptions.h"

#include "llvm/ADT/StringMap.h"

namespace clang {

/// OpenCL supported extensions and optional core features

class OpenCLOptions {

  struct Info {

    bool Supported; // Is this option supported

    bool Enabled;   // Is this option enabled

    unsigned Avail; // Option starts to be available in this OpenCL version

    unsigned Core;  // Option becomes (optional) core feature in this OpenCL

                    // version

    Info(bool S = false, bool E = false, unsigned A = 100, unsigned C = ~0U)

      :Supported(S), Enabled(E), Avail(A), Core(C){}

  };

  llvm::StringMap<Info> OptMap;

public:

  /// Check if \c Ext is a recognized OpenCL extension.

  ///

  /// \param Ext - Extension to look up.

  /// \returns \c true if \c Ext is known, \c false otherwise.

  bool isKnown(llvm::StringRef Ext) const {

    return OptMap.find(Ext) != OptMap.end();

  }

  /// Check if \c Ext is an enabled OpenCL extension.

  ///

  /// \param Ext - Extension to look up.

  /// \returns \c true if \c Ext is known and enabled, \c false otherwise.

  bool isEnabled(llvm::StringRef Ext) const {

    auto E = OptMap.find(Ext);

    return E != OptMap.end() && E->second.Enabled;

  }

  /// Check if \c Ext is supported as either an extension or an (optional) core

  /// feature for the given OpenCL version.

  ///

  /// \param Ext - Extension to look up.

  /// \param LO - \c LangOptions specifying the OpenCL version.

  /// \returns \c true if \c Ext is known and supported, \c false otherwise.

  bool isSupported(llvm::StringRef Ext, const LangOptions &LO) const {

    auto E = OptMap.find(Ext);

    if (E == OptMap.end()) {

      return false;

    }

    // In C++ mode all extensions should work at least as in v2.0.

    auto CLVer = LO.OpenCLCPlusPlus ? 
2002.24k
 : 
LO.OpenCLVersion17.8k
;

    auto I = E->getValue();

    return I.Supported && 
I.Avail <= CLVer16.0k
;

  }

  /// Check if \c Ext is supported as an (optional) OpenCL core features for

  /// the given OpenCL version.

  ///

  /// \param Ext - Extension to look up.

  /// \param LO - \c LangOptions specifying the OpenCL version.

  /// \returns \c true if \c Ext is known and supported, \c false otherwise.

  bool isSupportedCore(llvm::StringRef Ext, const LangOptions &LO) const {

    auto E = OptMap.find(Ext);

    if (E == OptMap.end()) {

      return false;

    }

    // In C++ mode all extensions should work at least as in v2.0.

    auto CLVer = LO.OpenCLCPlusPlus ? 
2002.37k
 : 
LO.OpenCLVersion17.1k
;

    auto I = E->getValue();

    return I.Supported && 
I.Avail <= CLVer16.1k
 && 
I.Core != ~0U13.1k
 && 
CLVer >= I.Core4.68k
;

  }

  /// Check if \c Ext is a supported OpenCL extension for the given OpenCL

  /// version.

  ///

  /// \param Ext - Extension to look up.

  /// \param LO - \c LangOptions specifying the OpenCL version.

  /// \returns \c true if \c Ext is known and supported, \c false otherwise.

  bool isSupportedExtension(llvm::StringRef Ext, const LangOptions &LO) const {

    auto E = OptMap.find(Ext);

    if (E == OptMap.end()) {

      return false;

    }

    // In C++ mode all extensions should work at least as in v2.0.

    auto CLVer = LO.OpenCLCPlusPlus ? 
20093
 : 
LO.OpenCLVersion1.37k
;

    auto I = E->getValue();

    return I.Supported && 
I.Avail <= CLVer1.13k
 && 
(1.07k
I.Core == ~0U1.07k
 || 
CLVer < I.Core448
);

  }

  void enable(llvm::StringRef Ext, bool V = true) {

    OptMap[Ext].Enabled = V;

  }

  /// Enable or disable support for OpenCL extensions

  /// \param Ext name of the extension optionally prefixed with

  ///        '+' or '-'

  /// \param V used when \p Ext is not prefixed by '+' or '-'

  void support(llvm::StringRef Ext, bool V = true) {

    assert(!Ext.empty() && "Extension is empty.");

    switch (Ext[0]) {

    case '+':

      V = true;

      Ext = Ext.drop_front();

      break;

    case '-':

      V = false;

      Ext = Ext.drop_front();

      break;

    }

    if (Ext.equals("all")) {

      supportAll(V);

      return;

    }

    OptMap[Ext].Supported = V;

  }

  OpenCLOptions(){

#define OPENCLEXT_INTERNAL(Ext, AvailVer, CoreVer) \

    OptMap[#Ext].Avail = AvailVer; \

    OptMap[#Ext].Core = CoreVer;

#include "clang/Basic/OpenCLExtensions.def"

  }

  void addSupport(const OpenCLOptions &Opts) {

    for (auto &I:Opts.OptMap)

      if (I.second.Supported)

        OptMap[I.getKey()].Supported = true;

  }

  void copy(const OpenCLOptions &Opts) {

    OptMap = Opts.OptMap;

  }

  // Turn on or off support of all options.

  void supportAll(bool On = true) {

    for (llvm::StringMap<Info>::iterator I = OptMap.begin(),

         E = OptMap.end(); I != E; 
++I2.31M
)

      I->second.Supported = On;

  }

  void disableAll() {

    for (llvm::StringMap<Info>::iterator I = OptMap.begin(),

         E = OptMap.end(); I != E; 
++I1.61k
)

      I->second.Enabled = false;

  }

  void enableSupportedCore(LangOptions LO) {

    for (llvm::StringMap<Info>::iterator I = OptMap.begin(), E = OptMap.end();

         I != E; 
++I18.8k
)

      if (isSupportedCore(I->getKey(), LO))

        I->second.Enabled = true;

  }

  friend class ASTWriter;

  friend class ASTReader;

};

} // end namespace clang

#endif