contrib/llvm/tools/clang/include/clang/Basic/Sanitizers.def

   1 //===--- Sanitizers.def - Runtime sanitizer 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 // This file defines the options for specifying which runtime sanitizers to
  11 // enable. Users of this file must define the SANITIZER macro to make use of
  12 // this information. Users of this file can also define the SANITIZER_GROUP
  13 // macro to get information on options which refer to sets of sanitizers.
  14 //
  15 //===----------------------------------------------------------------------===//
  16
  17 #ifndef SANITIZER
  18 #error "Define SANITIZER prior to including this file!"
  19 #endif
  20
  21 // SANITIZER(NAME, ID)
  22
  23 // The first value is the name of the sanitizer as a string. The sanitizer can
  24 // be enabled by specifying -fsanitize=NAME.
  25
  26 // The second value is an identifier which can be used to refer to the
  27 // sanitizer.
  28
  29
  30 // SANITIZER_GROUP(NAME, ID, ALIAS)
  31
  32 // The first two values have the same semantics as the corresponding SANITIZER
  33 // values. The third value is an expression ORing together the IDs of individual
  34 // sanitizers in this group.
  35
  36 #ifndef SANITIZER_GROUP
  37 #define SANITIZER_GROUP(NAME, ID, ALIAS)
  38 #endif
  39
  40
  41 // AddressSanitizer
  42 SANITIZER("address", Address)
  43
  44 // Kernel AddressSanitizer (KASan)
  45 SANITIZER("kernel-address", KernelAddress)
  46
  47 // Hardware-assisted AddressSanitizer
  48 SANITIZER("hwaddress", HWAddress)
  49
  50 // Kernel Hardware-assisted AddressSanitizer (KHWASan)
  51 SANITIZER("kernel-hwaddress", KernelHWAddress)
  52
  53 // MemorySanitizer
  54 SANITIZER("memory", Memory)
  55
  56 // Kernel MemorySanitizer (KMSAN)
  57 SANITIZER("kernel-memory", KernelMemory)
  58
  59 // libFuzzer
  60 SANITIZER("fuzzer", Fuzzer)
  61
  62 // libFuzzer-required instrumentation, no linking.
  63 SANITIZER("fuzzer-no-link", FuzzerNoLink)
  64
  65 // ThreadSanitizer
  66 SANITIZER("thread", Thread)
  67
  68 // LeakSanitizer
  69 SANITIZER("leak", Leak)
  70
  71 // UndefinedBehaviorSanitizer
  72 SANITIZER("alignment", Alignment)
  73 SANITIZER("array-bounds", ArrayBounds)
  74 SANITIZER("bool", Bool)
  75 SANITIZER("builtin", Builtin)
  76 SANITIZER("enum", Enum)
  77 SANITIZER("float-cast-overflow", FloatCastOverflow)
  78 SANITIZER("float-divide-by-zero", FloatDivideByZero)
  79 SANITIZER("function", Function)
  80 SANITIZER("integer-divide-by-zero", IntegerDivideByZero)
  81 SANITIZER("nonnull-attribute", NonnullAttribute)
  82 SANITIZER("null", Null)
  83 SANITIZER("nullability-arg", NullabilityArg)
  84 SANITIZER("nullability-assign", NullabilityAssign)
  85 SANITIZER("nullability-return", NullabilityReturn)
  86 SANITIZER_GROUP("nullability", Nullability,
  87                 NullabilityArg | NullabilityAssign | NullabilityReturn)
  88 SANITIZER("object-size", ObjectSize)
  89 SANITIZER("pointer-overflow", PointerOverflow)
  90 SANITIZER("return", Return)
  91 SANITIZER("returns-nonnull-attribute", ReturnsNonnullAttribute)
  92 SANITIZER("shift-base", ShiftBase)
  93 SANITIZER("shift-exponent", ShiftExponent)
  94 SANITIZER_GROUP("shift", Shift, ShiftBase | ShiftExponent)
  95 SANITIZER("signed-integer-overflow", SignedIntegerOverflow)
  96 SANITIZER("unreachable", Unreachable)
  97 SANITIZER("vla-bound", VLABound)
  98 SANITIZER("vptr", Vptr)
  99
 100 // IntegerSanitizer
 101 SANITIZER("unsigned-integer-overflow", UnsignedIntegerOverflow)
 102
 103 // DataFlowSanitizer
 104 SANITIZER("dataflow", DataFlow)
 105
 106 // Control Flow Integrity
 107 SANITIZER("cfi-cast-strict", CFICastStrict)
 108 SANITIZER("cfi-derived-cast", CFIDerivedCast)
 109 SANITIZER("cfi-icall", CFIICall)
 110 SANITIZER("cfi-mfcall", CFIMFCall)
 111 SANITIZER("cfi-unrelated-cast", CFIUnrelatedCast)
 112 SANITIZER("cfi-nvcall", CFINVCall)
 113 SANITIZER("cfi-vcall", CFIVCall)
 114 SANITIZER_GROUP("cfi", CFI,
 115                 CFIDerivedCast | CFIICall | CFIMFCall | CFIUnrelatedCast |
 116                     CFINVCall | CFIVCall)
 117
 118 // Safe Stack
 119 SANITIZER("safe-stack", SafeStack)
 120
 121 // Shadow Call Stack
 122 SANITIZER("shadow-call-stack", ShadowCallStack)
 123
 124 // -fsanitize=undefined includes all the sanitizers which have low overhead, no
 125 // ABI or address space layout implications, and only catch undefined behavior.
 126 SANITIZER_GROUP("undefined", Undefined,
 127                 Alignment | Bool | Builtin | ArrayBounds | Enum |
 128                     FloatCastOverflow | FloatDivideByZero |
 129                     IntegerDivideByZero | NonnullAttribute | Null | ObjectSize |
 130                     PointerOverflow | Return | ReturnsNonnullAttribute | Shift |
 131                     SignedIntegerOverflow | Unreachable | VLABound | Function |
 132                     Vptr)
 133
 134 // -fsanitize=undefined-trap is an alias for -fsanitize=undefined.
 135 SANITIZER_GROUP("undefined-trap", UndefinedTrap, Undefined)
 136
 137 // ImplicitConversionSanitizer
 138 SANITIZER("implicit-unsigned-integer-truncation",
 139           ImplicitUnsignedIntegerTruncation)
 140 SANITIZER("implicit-signed-integer-truncation", ImplicitSignedIntegerTruncation)
 141 SANITIZER_GROUP("implicit-integer-truncation", ImplicitIntegerTruncation,
 142                 ImplicitUnsignedIntegerTruncation |
 143                     ImplicitSignedIntegerTruncation)
 144
 145 SANITIZER("implicit-integer-sign-change", ImplicitIntegerSignChange)
 146
 147 SANITIZER_GROUP("implicit-integer-arithmetic-value-change",
 148                 ImplicitIntegerArithmeticValueChange,
 149                 ImplicitIntegerSignChange | ImplicitSignedIntegerTruncation)
 150
 151 // FIXME:
 152 //SANITIZER_GROUP("implicit-integer-conversion", ImplicitIntegerConversion,
 153 //                ImplicitIntegerArithmeticValueChange |
 154 //                    ImplicitUnsignedIntegerTruncation)
 155 //SANITIZER_GROUP("implicit-conversion", ImplicitConversion,
 156 //                ImplicitIntegerConversion)
 157
 158 SANITIZER_GROUP("implicit-conversion", ImplicitConversion,
 159                 ImplicitIntegerArithmeticValueChange |
 160                     ImplicitUnsignedIntegerTruncation)
 161
 162 SANITIZER_GROUP("integer", Integer,
 163                 ImplicitConversion | IntegerDivideByZero | Shift |
 164                     SignedIntegerOverflow | UnsignedIntegerOverflow)
 165
 166 SANITIZER("local-bounds", LocalBounds)
 167 SANITIZER_GROUP("bounds", Bounds, ArrayBounds | LocalBounds)
 168
 169 // EfficiencySanitizer
 170 SANITIZER("efficiency-cache-frag", EfficiencyCacheFrag)
 171 SANITIZER("efficiency-working-set", EfficiencyWorkingSet)
 172 // Meta-group only used internally.
 173 SANITIZER_GROUP("efficiency-all", Efficiency,
 174                 EfficiencyCacheFrag | EfficiencyWorkingSet)
 175
 176 // Scudo hardened allocator
 177 SANITIZER("scudo", Scudo)
 178
 179 // Magic group, containing all sanitizers. For example, "-fno-sanitize=all"
 180 // can be used to disable all the sanitizers.
 181 SANITIZER_GROUP("all", All, ~0ULL)
 182
 183 #undef SANITIZER
 184 #undef SANITIZER_GROUP