contrib/compiler-rt/lib/ubsan/ubsan_value.h

   1 //===-- ubsan_value.h -------------------------------------------*- 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 // Representation of data which is passed from the compiler-generated calls into
  11 // the ubsan runtime.
  12 //
  13 //===----------------------------------------------------------------------===//
  14 #ifndef UBSAN_VALUE_H
  15 #define UBSAN_VALUE_H
  16
  17 #include "sanitizer_common/sanitizer_atomic.h"
  18 #include "sanitizer_common/sanitizer_common.h"
  19
  20 // FIXME: Move this out to a config header.
  21 #if __SIZEOF_INT128__
  22 __extension__ typedef __int128 s128;
  23 __extension__ typedef unsigned __int128 u128;
  24 #define HAVE_INT128_T 1
  25 #else
  26 #define HAVE_INT128_T 0
  27 #endif
  28
  29 namespace __ubsan {
  30
  31 /// \brief Largest integer types we support.
  32 #if HAVE_INT128_T
  33 typedef s128 SIntMax;
  34 typedef u128 UIntMax;
  35 #else
  36 typedef s64 SIntMax;
  37 typedef u64 UIntMax;
  38 #endif
  39
  40 /// \brief Largest floating-point type we support.
  41 typedef long double FloatMax;
  42
  43 /// \brief A description of a source location. This corresponds to Clang's
  44 /// \c PresumedLoc type.
  45 class SourceLocation {
  46   const char *Filename;
  47   u32 Line;
  48   u32 Column;
  49
  50 public:
  51   SourceLocation() : Filename(), Line(), Column() {}
  52   SourceLocation(const char *Filename, unsigned Line, unsigned Column)
  53     : Filename(Filename), Line(Line), Column(Column) {}
  54
  55   /// \brief Determine whether the source location is known.
  56   bool isInvalid() const { return !Filename; }
  57
  58   /// \brief Atomically acquire a copy, disabling original in-place.
  59   /// Exactly one call to acquire() returns a copy that isn't disabled.
  60   SourceLocation acquire() {
  61     u32 OldColumn = __sanitizer::atomic_exchange(
  62                         (__sanitizer::atomic_uint32_t *)&Column, ~u32(0),
  63                         __sanitizer::memory_order_relaxed);
  64     return SourceLocation(Filename, Line, OldColumn);
  65   }
  66
  67   /// \brief Determine if this Location has been disabled.
  68   /// Disabled SourceLocations are invalid to use.
  69   bool isDisabled() {
  70     return Column == ~u32(0);
  71   }
  72
  73   /// \brief Get the presumed filename for the source location.
  74   const char *getFilename() const { return Filename; }
  75   /// \brief Get the presumed line number.
  76   unsigned getLine() const { return Line; }
  77   /// \brief Get the column within the presumed line.
  78   unsigned getColumn() const { return Column; }
  79 };
  80
  81
  82 /// \brief A description of a type.
  83 class TypeDescriptor {
  84   /// A value from the \c Kind enumeration, specifying what flavor of type we
  85   /// have.
  86   u16 TypeKind;
  87
  88   /// A \c Type-specific value providing information which allows us to
  89   /// interpret the meaning of a ValueHandle of this type.
  90   u16 TypeInfo;
  91
  92   /// The name of the type follows, in a format suitable for including in
  93   /// diagnostics.
  94   char TypeName[1];
  95
  96 public:
  97   enum Kind {
  98     /// An integer type. Lowest bit is 1 for a signed value, 0 for an unsigned
  99     /// value. Remaining bits are log_2(bit width). The value representation is
 100     /// the integer itself if it fits into a ValueHandle, and a pointer to the
 101     /// integer otherwise.
 102     TK_Integer = 0x0000,
 103     /// A floating-point type. Low 16 bits are bit width. The value
 104     /// representation is that of bitcasting the floating-point value to an
 105     /// integer type.
 106     TK_Float = 0x0001,
 107     /// Any other type. The value representation is unspecified.
 108     TK_Unknown = 0xffff
 109   };
 110
 111   const char *getTypeName() const { return TypeName; }
 112
 113   Kind getKind() const {
 114     return static_cast<Kind>(TypeKind);
 115   }
 116
 117   bool isIntegerTy() const { return getKind() == TK_Integer; }
 118   bool isSignedIntegerTy() const {
 119     return isIntegerTy() && (TypeInfo & 1);
 120   }
 121   bool isUnsignedIntegerTy() const {
 122     return isIntegerTy() && !(TypeInfo & 1);
 123   }
 124   unsigned getIntegerBitWidth() const {
 125     CHECK(isIntegerTy());
 126     return 1 << (TypeInfo >> 1);
 127   }
 128
 129   bool isFloatTy() const { return getKind() == TK_Float; }
 130   unsigned getFloatBitWidth() const {
 131     CHECK(isFloatTy());
 132     return TypeInfo;
 133   }
 134 };
 135
 136 /// \brief An opaque handle to a value.
 137 typedef uptr ValueHandle;
 138
 139
 140 /// \brief Representation of an operand value provided by the instrumented code.
 141 ///
 142 /// This is a combination of a TypeDescriptor (which is emitted as constant data
 143 /// as an operand to a handler function) and a ValueHandle (which is passed at
 144 /// runtime when a check failure occurs).
 145 class Value {
 146   /// The type of the value.
 147   const TypeDescriptor &Type;
 148   /// The encoded value itself.
 149   ValueHandle Val;
 150
 151   /// Is \c Val a (zero-extended) integer?
 152   bool isInlineInt() const {
 153     CHECK(getType().isIntegerTy());
 154     const unsigned InlineBits = sizeof(ValueHandle) * 8;
 155     const unsigned Bits = getType().getIntegerBitWidth();
 156     return Bits <= InlineBits;
 157   }
 158
 159   /// Is \c Val a (zero-extended) integer representation of a float?
 160   bool isInlineFloat() const {
 161     CHECK(getType().isFloatTy());
 162     const unsigned InlineBits = sizeof(ValueHandle) * 8;
 163     const unsigned Bits = getType().getFloatBitWidth();
 164     return Bits <= InlineBits;
 165   }
 166
 167 public:
 168   Value(const TypeDescriptor &Type, ValueHandle Val) : Type(Type), Val(Val) {}
 169
 170   const TypeDescriptor &getType() const { return Type; }
 171
 172   /// \brief Get this value as a signed integer.
 173   SIntMax getSIntValue() const;
 174
 175   /// \brief Get this value as an unsigned integer.
 176   UIntMax getUIntValue() const;
 177
 178   /// \brief Decode this value, which must be a positive or unsigned integer.
 179   UIntMax getPositiveIntValue() const;
 180
 181   /// Is this an integer with value -1?
 182   bool isMinusOne() const {
 183     return getType().isSignedIntegerTy() && getSIntValue() == -1;
 184   }
 185
 186   /// Is this a negative integer?
 187   bool isNegative() const {
 188     return getType().isSignedIntegerTy() && getSIntValue() < 0;
 189   }
 190
 191   /// \brief Get this value as a floating-point quantity.
 192   FloatMax getFloatValue() const;
 193 };
 194
 195 } // namespace __ubsan
 196
 197 #endif // UBSAN_VALUE_H