1//===--- LangOptions.h - C Language Family Language Options -----*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9///
10/// \file
11/// \brief Defines the clang::LangOptions interface.
12///
13//===----------------------------------------------------------------------===//
14
15#ifndef LLVM_CLANG_BASIC_LANGOPTIONS_H
16#define LLVM_CLANG_BASIC_LANGOPTIONS_H
17
18#include "clang/Basic/CommentOptions.h"
19#include "clang/Basic/LLVM.h"
20#include "clang/Basic/ObjCRuntime.h"
21#include "clang/Basic/Sanitizers.h"
22#include "clang/Basic/Visibility.h"
23#include <string>
24#include <vector>
25
26namespace clang {
27
28/// Bitfields of LangOptions, split out from LangOptions in order to ensure that
29/// this large collection of bitfields is a trivial class type.
30class LangOptionsBase {
31public:
32  // Define simple language options (with no accessors).
33#define LANGOPT(Name, Bits, Default, Description) unsigned Name : Bits;
34#define ENUM_LANGOPT(Name, Type, Bits, Default, Description)
35#include "clang/Basic/LangOptions.def"
36
37protected:
38  // Define language options of enumeration type. These are private, and will
39  // have accessors (below).
40#define LANGOPT(Name, Bits, Default, Description)
41#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
42  unsigned Name : Bits;
43#include "clang/Basic/LangOptions.def"
44};
45
46/// \brief Keeps track of the various options that can be
47/// enabled, which controls the dialect of C or C++ that is accepted.
48class LangOptions : public LangOptionsBase {
49public:
50  typedef clang::Visibility Visibility;
51
52  enum GCMode { NonGC, GCOnly, HybridGC };
53  enum StackProtectorMode { SSPOff, SSPOn, SSPStrong, SSPReq };
54
55  enum SignedOverflowBehaviorTy {
56    SOB_Undefined,  // Default C standard behavior.
57    SOB_Defined,    // -fwrapv
58    SOB_Trapping    // -ftrapv
59  };
60
61  enum PragmaMSPointersToMembersKind {
62    PPTMK_BestCase,
63    PPTMK_FullGeneralitySingleInheritance,
64    PPTMK_FullGeneralityMultipleInheritance,
65    PPTMK_FullGeneralityVirtualInheritance
66  };
67
68  enum AddrSpaceMapMangling { ASMM_Target, ASMM_On, ASMM_Off };
69
70  enum MSVCMajorVersion {
71    MSVC2010 = 16,
72    MSVC2012 = 17,
73    MSVC2013 = 18,
74    MSVC2015 = 19
75  };
76
77public:
78  /// \brief Set of enabled sanitizers.
79  SanitizerSet Sanitize;
80
81  /// \brief Paths to blacklist files specifying which objects
82  /// (files, functions, variables) should not be instrumented.
83  std::vector<std::string> SanitizerBlacklistFiles;
84
85  clang::ObjCRuntime ObjCRuntime;
86
87  std::string ObjCConstantStringClass;
88
89  /// \brief The name of the handler function to be called when -ftrapv is
90  /// specified.
91  ///
92  /// If none is specified, abort (GCC-compatible behaviour).
93  std::string OverflowHandler;
94
95  /// \brief The name of the current module.
96  std::string CurrentModule;
97
98  /// \brief The name of the module that the translation unit is an
99  /// implementation of. Prevents semantic imports, but does not otherwise
100  /// treat this as the CurrentModule.
101  std::string ImplementationOfModule;
102
103  /// \brief The names of any features to enable in module 'requires' decls
104  /// in addition to the hard-coded list in Module.cpp and the target features.
105  ///
106  /// This list is sorted.
107  std::vector<std::string> ModuleFeatures;
108
109  /// \brief Options for parsing comments.
110  CommentOptions CommentOpts;
111
112  LangOptions();
113
114  // Define accessors/mutators for language options of enumeration type.
115#define LANGOPT(Name, Bits, Default, Description)
116#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
117  Type get##Name() const { return static_cast<Type>(Name); } \
118  void set##Name(Type Value) { Name = static_cast<unsigned>(Value); }
119#include "clang/Basic/LangOptions.def"
120
121  bool isSignedOverflowDefined() const {
122    return getSignedOverflowBehavior() == SOB_Defined;
123  }
124
125  bool isSubscriptPointerArithmetic() const {
126    return ObjCRuntime.isSubscriptPointerArithmetic() &&
127           !ObjCSubscriptingLegacyRuntime;
128  }
129
130  bool isCompatibleWithMSVC(MSVCMajorVersion MajorVersion) const {
131    return MSCompatibilityVersion >= MajorVersion * 10000000U;
132  }
133
134  /// \brief Reset all of the options that are not considered when building a
135  /// module.
136  void resetNonModularOptions();
137};
138
139/// \brief Floating point control options
140class FPOptions {
141public:
142  unsigned fp_contract : 1;
143
144  FPOptions() : fp_contract(0) {}
145
146  FPOptions(const LangOptions &LangOpts) :
147    fp_contract(LangOpts.DefaultFPContract) {}
148};
149
150/// \brief OpenCL volatile options
151class OpenCLOptions {
152public:
153#define OPENCLEXT(nm)  unsigned nm : 1;
154#include "clang/Basic/OpenCLExtensions.def"
155
156  OpenCLOptions() {
157#define OPENCLEXT(nm)   nm = 0;
158#include "clang/Basic/OpenCLExtensions.def"
159  }
160};
161
162/// \brief Describes the kind of translation unit being processed.
163enum TranslationUnitKind {
164  /// \brief The translation unit is a complete translation unit.
165  TU_Complete,
166  /// \brief The translation unit is a prefix to a translation unit, and is
167  /// not complete.
168  TU_Prefix,
169  /// \brief The translation unit is a module.
170  TU_Module
171};
172
173}  // end namespace clang
174
175#endif
176