• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //===-- ubsan_value.cc ----------------------------------------------------===//
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 a runtime value, as marshaled from the generated code to
11 // the ubsan runtime.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #include "ubsan_platform.h"
16 #if CAN_SANITIZE_UB
17 #include "ubsan_value.h"
18 #include "sanitizer_common/sanitizer_common.h"
19 #include "sanitizer_common/sanitizer_libc.h"
20 
21 using namespace __ubsan;
22 
getSIntValue() const23 SIntMax Value::getSIntValue() const {
24   CHECK(getType().isSignedIntegerTy());
25   if (isInlineInt()) {
26     // Val was zero-extended to ValueHandle. Sign-extend from original width
27     // to SIntMax.
28     const unsigned ExtraBits =
29       sizeof(SIntMax) * 8 - getType().getIntegerBitWidth();
30     return SIntMax(Val) << ExtraBits >> ExtraBits;
31   }
32   if (getType().getIntegerBitWidth() == 64)
33     return *reinterpret_cast<s64*>(Val);
34 #if HAVE_INT128_T
35   if (getType().getIntegerBitWidth() == 128)
36     return *reinterpret_cast<s128*>(Val);
37 #else
38   if (getType().getIntegerBitWidth() == 128)
39     UNREACHABLE("libclang_rt.ubsan was built without __int128 support");
40 #endif
41   UNREACHABLE("unexpected bit width");
42 }
43 
getUIntValue() const44 UIntMax Value::getUIntValue() const {
45   CHECK(getType().isUnsignedIntegerTy());
46   if (isInlineInt())
47     return Val;
48   if (getType().getIntegerBitWidth() == 64)
49     return *reinterpret_cast<u64*>(Val);
50 #if HAVE_INT128_T
51   if (getType().getIntegerBitWidth() == 128)
52     return *reinterpret_cast<u128*>(Val);
53 #else
54   if (getType().getIntegerBitWidth() == 128)
55     UNREACHABLE("libclang_rt.ubsan was built without __int128 support");
56 #endif
57   UNREACHABLE("unexpected bit width");
58 }
59 
getPositiveIntValue() const60 UIntMax Value::getPositiveIntValue() const {
61   if (getType().isUnsignedIntegerTy())
62     return getUIntValue();
63   SIntMax Val = getSIntValue();
64   CHECK(Val >= 0);
65   return Val;
66 }
67 
68 /// Get the floating-point value of this object, extended to a long double.
69 /// These are always passed by address (our calling convention doesn't allow
70 /// them to be passed in floating-point registers, so this has little cost).
getFloatValue() const71 FloatMax Value::getFloatValue() const {
72   CHECK(getType().isFloatTy());
73   if (isInlineFloat()) {
74     switch (getType().getFloatBitWidth()) {
75 #if 0
76       // FIXME: OpenCL / NEON 'half' type. LLVM can't lower the conversion
77       //        from '__fp16' to 'long double'.
78       case 16: {
79         __fp16 Value;
80         internal_memcpy(&Value, &Val, 4);
81         return Value;
82       }
83 #endif
84       case 32: {
85         float Value;
86 #if defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
87        // For big endian the float value is in the last 4 bytes.
88        // On some targets we may only have 4 bytes so we count backwards from
89        // the end of Val to account for both the 32-bit and 64-bit cases.
90        internal_memcpy(&Value, ((const char*)(&Val + 1)) - 4, 4);
91 #else
92        internal_memcpy(&Value, &Val, 4);
93 #endif
94         return Value;
95       }
96       case 64: {
97         double Value;
98         internal_memcpy(&Value, &Val, 8);
99         return Value;
100       }
101     }
102   } else {
103     switch (getType().getFloatBitWidth()) {
104     case 64: return *reinterpret_cast<double*>(Val);
105     case 80: return *reinterpret_cast<long double*>(Val);
106     case 96: return *reinterpret_cast<long double*>(Val);
107     case 128: return *reinterpret_cast<long double*>(Val);
108     }
109   }
110   UNREACHABLE("unexpected floating point bit width");
111 }
112 
113 #endif  // CAN_SANITIZE_UB
114