libsanitizer/ubsan/ubsan_value.h

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