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 23 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 44 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 60 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). 71 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
