1 //===-- ubsan_value.cpp ---------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // Representation of a runtime value, as marshaled from the generated code to
10 // the ubsan runtime.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "ubsan_platform.h"
15 #if CAN_SANITIZE_UB
16 #include "ubsan_value.h"
17 #include "sanitizer_common/sanitizer_common.h"
18 #include "sanitizer_common/sanitizer_libc.h"
19 #include "sanitizer_common/sanitizer_mutex.h"
20 
21 #if SANITIZER_APPLE
22 #include <dlfcn.h>
23 #endif
24 
25 using namespace __ubsan;
26 
27 typedef const char *(*ObjCGetClassNameTy)(void *);
28 
29 const char *__ubsan::getObjCClassName(ValueHandle Pointer) {
30 #if SANITIZER_APPLE
31   // We need to query the ObjC runtime for some information, but do not want
32   // to introduce a static dependency from the ubsan runtime onto ObjC. Try to
33   // grab a handle to the ObjC runtime used by the process.
34   static bool AttemptedDlopen = false;
35   static void *ObjCHandle = nullptr;
36   static void *ObjCObjectGetClassName = nullptr;
37 
38   // Prevent threads from racing to dlopen().
39   static __sanitizer::StaticSpinMutex Lock;
40   {
41     __sanitizer::SpinMutexLock Guard(&Lock);
42 
43     if (!AttemptedDlopen) {
44       ObjCHandle = dlopen(
45           "/usr/lib/libobjc.A.dylib",
46           RTLD_LAZY         // Only bind symbols when used.
47               | RTLD_LOCAL  // Only make symbols available via the handle.
48               | RTLD_NOLOAD // Do not load the dylib, just grab a handle if the
49                             // image is already loaded.
50               | RTLD_FIRST  // Only search the image pointed-to by the handle.
51       );
52       AttemptedDlopen = true;
53       if (!ObjCHandle)
54         return nullptr;
55       ObjCObjectGetClassName = dlsym(ObjCHandle, "object_getClassName");
56     }
57   }
58 
59   if (!ObjCObjectGetClassName)
60     return nullptr;
61 
62   return ObjCGetClassNameTy(ObjCObjectGetClassName)((void *)Pointer);
63 #else
64   return nullptr;
65 #endif
66 }
67 
68 SIntMax Value::getSIntValue() const {
69   CHECK(getType().isSignedIntegerTy());
70   if (isInlineInt()) {
71     // Val was zero-extended to ValueHandle. Sign-extend from original width
72     // to SIntMax.
73     const unsigned ExtraBits =
74       sizeof(SIntMax) * 8 - getType().getIntegerBitWidth();
75     return SIntMax(UIntMax(Val) << ExtraBits) >> ExtraBits;
76   }
77   if (getType().getIntegerBitWidth() == 64)
78     return *reinterpret_cast<s64*>(Val);
79 #if HAVE_INT128_T
80   if (getType().getIntegerBitWidth() == 128)
81     return *reinterpret_cast<s128*>(Val);
82 #else
83   if (getType().getIntegerBitWidth() == 128)
84     UNREACHABLE("libclang_rt.ubsan was built without __int128 support");
85 #endif
86   UNREACHABLE("unexpected bit width");
87 }
88 
89 UIntMax Value::getUIntValue() const {
90   CHECK(getType().isUnsignedIntegerTy());
91   if (isInlineInt())
92     return Val;
93   if (getType().getIntegerBitWidth() == 64)
94     return *reinterpret_cast<u64*>(Val);
95 #if HAVE_INT128_T
96   if (getType().getIntegerBitWidth() == 128)
97     return *reinterpret_cast<u128*>(Val);
98 #else
99   if (getType().getIntegerBitWidth() == 128)
100     UNREACHABLE("libclang_rt.ubsan was built without __int128 support");
101 #endif
102   UNREACHABLE("unexpected bit width");
103 }
104 
105 UIntMax Value::getPositiveIntValue() const {
106   if (getType().isUnsignedIntegerTy())
107     return getUIntValue();
108   SIntMax Val = getSIntValue();
109   CHECK(Val >= 0);
110   return Val;
111 }
112 
113 /// Get the floating-point value of this object, extended to a long double.
114 /// These are always passed by address (our calling convention doesn't allow
115 /// them to be passed in floating-point registers, so this has little cost).
116 FloatMax Value::getFloatValue() const {
117   CHECK(getType().isFloatTy());
118   if (isInlineFloat()) {
119     switch (getType().getFloatBitWidth()) {
120 #if 0
121       // FIXME: OpenCL / NEON 'half' type. LLVM can't lower the conversion
122       //        from '__fp16' to 'long double'.
123       case 16: {
124         __fp16 Value;
125         internal_memcpy(&Value, &Val, 4);
126         return Value;
127       }
128 #endif
129       case 32: {
130         float Value;
131 #if defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
132        // For big endian the float value is in the last 4 bytes.
133        // On some targets we may only have 4 bytes so we count backwards from
134        // the end of Val to account for both the 32-bit and 64-bit cases.
135        internal_memcpy(&Value, ((const char*)(&Val + 1)) - 4, 4);
136 #else
137        internal_memcpy(&Value, &Val, 4);
138 #endif
139         return Value;
140       }
141       case 64: {
142         double Value;
143         internal_memcpy(&Value, &Val, 8);
144         return Value;
145       }
146     }
147   } else {
148     switch (getType().getFloatBitWidth()) {
149     case 64: return *reinterpret_cast<double*>(Val);
150     case 80: return *reinterpret_cast<long double*>(Val);
151     case 96: return *reinterpret_cast<long double*>(Val);
152     case 128: return *reinterpret_cast<long double*>(Val);
153     }
154   }
155   UNREACHABLE("unexpected floating point bit width");
156 }
157 
158 #endif  // CAN_SANITIZE_UB
159