FreeBSD/Linux Kernel Cross Reference
sys/kern/kern_ubsan.c

     /*      $NetBSD: ubsan.c,v 1.3 2018/08/03 16:31:04 kamil Exp $  */
     
     /*-
      * Copyright (c) 2018 The NetBSD Foundation, Inc.
      * All rights reserved.
      *
      * Redistribution and use in source and binary forms, with or without
      * modification, are permitted provided that the following conditions
      * are met:
     * 1. Redistributions of source code must retain the above copyright
     *    notice, this list of conditions and the following disclaimer.
     * 2. Redistributions in binary form must reproduce the above copyright
     *    notice, this list of conditions and the following disclaimer in the
     *    documentation and/or other materials provided with the distribution.
     *
     * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
     * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
     * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
     * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
     * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
     * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
     * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
     * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     * POSSIBILITY OF SUCH DAMAGE.
     */
    
    /*
     * The micro UBSan implementation for the userland (uUBSan) and kernel (kUBSan).
     * The uBSSan versions is suitable for inclusion into libc or used standalone
     * with ATF tests.
     *
     * This file due to long symbol names generated by a compiler during the
     * instrumentation process does not follow the KNF style with 80-column limit.
     */
    
    #include <sys/cdefs.h>
    #ifdef __FreeBSD__
    __FBSDID("$FreeBSD$");
    #else
    #if defined(_KERNEL)
    __KERNEL_RCSID(0, "$NetBSD: ubsan.c,v 1.3 2018/08/03 16:31:04 kamil Exp $");
    #else
    __RCSID("$NetBSD: ubsan.c,v 1.3 2018/08/03 16:31:04 kamil Exp $");
    #endif
    #endif
    
    #if defined(_KERNEL)
    #include <sys/param.h>
    #include <sys/types.h>
    #include <sys/limits.h>
    #include <sys/systm.h>
    #include <machine/_inttypes.h>
    #include <machine/stdarg.h>
    #define ASSERT(x) KASSERT(x, ("%s: " __STRING(x) " failed", __func__))
    #define __arraycount(x) nitems(x)
    #define ISSET(x, y)     ((x) & (y))
    #define __BIT(x)        ((uintmax_t)1 << (uintmax_t)(x))
    #define __LOWEST_SET_BIT(__mask) ((((__mask) - 1) & (__mask)) ^ (__mask))
    #define __SHIFTOUT(__x, __mask) (((__x) & (__mask)) / __LOWEST_SET_BIT(__mask))
    #else
    #if defined(_LIBC)
    #include "namespace.h"
    #endif
    #include <sys/param.h>
    #include <assert.h>
    #include <inttypes.h>
    #include <math.h>
    #include <signal.h>
    #include <stdarg.h>
    #include <stdbool.h>
    #include <stdint.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <syslog.h>
    #include <unistd.h>
    #if defined(_LIBC)
    #include "extern.h"
    #define ubsan_vsyslog vsyslog_ss
    #define ASSERT(x) _DIAGASSERT(x)
    #else
    #define ubsan_vsyslog vsyslog_r
    #define ASSERT(x) assert(x)
    #endif
    /* These macros are available in _KERNEL only */
    #define SET(t, f)       ((t) |= (f))
    #define ISSET(t, f)     ((t) & (f))
    #define CLR(t, f)       ((t) &= ~(f))
    #endif
    
    #define REINTERPRET_CAST(__dt, __st)    ((__dt)(__st))
    #define STATIC_CAST(__dt, __st)         ((__dt)(__st))
    
    #define ACK_REPORTED    __BIT(31)
    
    #define MUL_STRING      "*"
    #define PLUS_STRING     "+"
   #define MINUS_STRING    "-"
   #define DIVREM_STRING   "divrem"
   
   #define CFI_VCALL               0
   #define CFI_NVCALL              1
   #define CFI_DERIVEDCAST         2
   #define CFI_UNRELATEDCAST       3
   #define CFI_ICALL               4
   #define CFI_NVMFCALL            5
   #define CFI_VMFCALL             6
   
   #define NUMBER_MAXLEN   128
   #define LOCATION_MAXLEN (PATH_MAX + 32 /* ':LINE:COLUMN' */)
   
   #define WIDTH_8         8
   #define WIDTH_16        16
   #define WIDTH_32        32
   #define WIDTH_64        64
   #define WIDTH_80        80
   #define WIDTH_96        96
   #define WIDTH_128       128
   
   #define NUMBER_SIGNED_BIT       1U
   
   #if __SIZEOF_INT128__
   typedef __int128 longest;
   typedef unsigned __int128 ulongest;
   #else
   typedef int64_t longest;
   typedef uint64_t ulongest;
   #endif
   
   #ifndef _KERNEL
   static int ubsan_flags = -1;
   #define UBSAN_ABORT     __BIT(0)
   #define UBSAN_STDOUT    __BIT(1)
   #define UBSAN_STDERR    __BIT(2)
   #define UBSAN_SYSLOG    __BIT(3)
   #endif
   
   /* Undefined Behavior specific defines and structures */
   
   #define KIND_INTEGER    0
   #define KIND_FLOAT      1
   #define KIND_UNKNOWN    UINT16_MAX
   
   struct CSourceLocation {
           char *mFilename;
           uint32_t mLine;
           uint32_t mColumn;
   };
   
   struct CTypeDescriptor {
           uint16_t mTypeKind;
           uint16_t mTypeInfo;
           uint8_t mTypeName[1];
   };
   
   struct COverflowData {
           struct CSourceLocation mLocation;
           struct CTypeDescriptor *mType;
   };
   
   struct CUnreachableData {
           struct CSourceLocation mLocation;
   };
   
   struct CCFICheckFailData {
           uint8_t mCheckKind;
           struct CSourceLocation mLocation;
           struct CTypeDescriptor *mType;
   };
   
   struct CDynamicTypeCacheMissData {
           struct CSourceLocation mLocation;
           struct CTypeDescriptor *mType;
           void *mTypeInfo;
           uint8_t mTypeCheckKind;
   };
   
   struct CFunctionTypeMismatchData {
           struct CSourceLocation mLocation;
           struct CTypeDescriptor *mType;
   };
   
   struct CInvalidBuiltinData {
           struct CSourceLocation mLocation;
           uint8_t mKind;
   };
   
   struct CInvalidValueData {
           struct CSourceLocation mLocation;
           struct CTypeDescriptor *mType;
   };
   
   struct CNonNullArgData {
           struct CSourceLocation mLocation;
           struct CSourceLocation mAttributeLocation;
           int mArgIndex;
   };
   
   struct CNonNullReturnData {
           struct CSourceLocation mAttributeLocation;
   };
   
   struct COutOfBoundsData {
           struct CSourceLocation mLocation;
           struct CTypeDescriptor *mArrayType;
           struct CTypeDescriptor *mIndexType;
   };
   
   struct CPointerOverflowData {
           struct CSourceLocation mLocation;
   };
   
   struct CShiftOutOfBoundsData {
           struct CSourceLocation mLocation;
           struct CTypeDescriptor *mLHSType;
           struct CTypeDescriptor *mRHSType;
   };
   
   struct CTypeMismatchData {
           struct CSourceLocation mLocation;
           struct CTypeDescriptor *mType;
           unsigned long mLogAlignment;
           uint8_t mTypeCheckKind;
   };
   
   struct CTypeMismatchData_v1 {
           struct CSourceLocation mLocation;
           struct CTypeDescriptor *mType;
           uint8_t mLogAlignment;
           uint8_t mTypeCheckKind;
   };
   
   struct CVLABoundData {
           struct CSourceLocation mLocation;
           struct CTypeDescriptor *mType;
   };
   
   struct CFloatCastOverflowData {
           struct CSourceLocation mLocation;       /* This field exists in this struct since 2015 August 11th */
           struct CTypeDescriptor *mFromType;
           struct CTypeDescriptor *mToType;
   };
   
   struct CAlignmentAssumptionData {
           struct CSourceLocation mLocation;
           struct CSourceLocation mAssumptionLocation;
           struct CTypeDescriptor *mType;
   };
   
   /* Local utility functions */
   static void Report(bool isFatal, const char *pFormat, ...) __printflike(2, 3);
   static bool isAlreadyReported(struct CSourceLocation *pLocation);
   static size_t zDeserializeTypeWidth(struct CTypeDescriptor *pType);
   static void DeserializeLocation(char *pBuffer, size_t zBUfferLength, struct CSourceLocation *pLocation);
   #ifdef __SIZEOF_INT128__
   static void DeserializeUINT128(char *pBuffer, size_t zBUfferLength, struct CTypeDescriptor *pType, __uint128_t U128);
   #endif
   static void DeserializeNumberSigned(char *pBuffer, size_t zBUfferLength, struct CTypeDescriptor *pType, longest L);
   static void DeserializeNumberUnsigned(char *pBuffer, size_t zBUfferLength, struct CTypeDescriptor *pType, ulongest L);
   #ifndef _KERNEL
   static void DeserializeFloatOverPointer(char *pBuffer, size_t zBUfferLength, struct CTypeDescriptor *pType, unsigned long *pNumber);
   static void DeserializeFloatInlined(char *pBuffer, size_t zBUfferLength, struct CTypeDescriptor *pType, unsigned long ulNumber);
   #endif
   static longest llliGetNumber(char *szLocation, struct CTypeDescriptor *pType, unsigned long ulNumber);
   static ulongest llluGetNumber(char *szLocation, struct CTypeDescriptor *pType, unsigned long ulNumber);
   #ifndef _KERNEL
   static void DeserializeNumberFloat(char *szLocation, char *pBuffer, size_t zBUfferLength, struct CTypeDescriptor *pType, unsigned long ulNumber);
   #endif
   static void DeserializeNumber(char *szLocation, char *pBuffer, size_t zBUfferLength, struct CTypeDescriptor *pType, unsigned long ulNumber);
   static const char *DeserializeTypeCheckKind(uint8_t hhuTypeCheckKind);
   static const char *DeserializeBuiltinCheckKind(uint8_t hhuBuiltinCheckKind);
   static const char *DeserializeCFICheckKind(uint8_t hhuCFICheckKind);
   static bool isNegativeNumber(char *szLocation, struct CTypeDescriptor *pType, unsigned long ulNumber);
   static bool isShiftExponentTooLarge(char *szLocation, struct CTypeDescriptor *pType, unsigned long ulNumber, size_t zWidth);
   
   /* Unused in this implementation, emitted by the C++ check dynamic type cast. */
   intptr_t __ubsan_vptr_type_cache[128];
   
   /* Public symbols used in the instrumentation of the code generation part */
   void __ubsan_handle_add_overflow(struct COverflowData *pData, unsigned long ulLHS, unsigned long ulRHS);
   void __ubsan_handle_add_overflow_abort(struct COverflowData *pData, unsigned long ulLHS, unsigned long ulRHS);
   void __ubsan_handle_alignment_assumption(struct CAlignmentAssumptionData *pData, unsigned long ulPointer, unsigned long ulAlignment, unsigned long ulOffset);
   void __ubsan_handle_alignment_assumption_abort(struct CAlignmentAssumptionData *pData, unsigned long ulPointer, unsigned long ulAlignment, unsigned long ulOffset);
   void __ubsan_handle_builtin_unreachable(struct CUnreachableData *pData);
   void __ubsan_handle_cfi_bad_type(struct CCFICheckFailData *pData, unsigned long ulVtable, bool bValidVtable, bool FromUnrecoverableHandler, unsigned long ProgramCounter, unsigned long FramePointer);
   void __ubsan_handle_cfi_check_fail(struct CCFICheckFailData *pData, unsigned long ulValue, unsigned long ulValidVtable);
   void __ubsan_handle_cfi_check_fail_abort(struct CCFICheckFailData *pData, unsigned long ulValue, unsigned long ulValidVtable);
   void __ubsan_handle_divrem_overflow(struct COverflowData *pData, unsigned long ulLHS, unsigned long ulRHS);
   void __ubsan_handle_divrem_overflow_abort(struct COverflowData *pData, unsigned long ulLHS, unsigned long ulRHS);
   void __ubsan_handle_dynamic_type_cache_miss(struct CDynamicTypeCacheMissData *pData, unsigned long ulPointer, unsigned long ulHash);
   void __ubsan_handle_dynamic_type_cache_miss_abort(struct CDynamicTypeCacheMissData *pData, unsigned long ulPointer, unsigned long ulHash);
   void __ubsan_handle_float_cast_overflow(struct CFloatCastOverflowData *pData, unsigned long ulFrom);
   void __ubsan_handle_float_cast_overflow_abort(struct CFloatCastOverflowData *pData, unsigned long ulFrom);
   void __ubsan_handle_function_type_mismatch(struct CFunctionTypeMismatchData *pData, unsigned long ulFunction);
   void __ubsan_handle_function_type_mismatch_abort(struct CFunctionTypeMismatchData *pData, unsigned long ulFunction);
   void __ubsan_handle_invalid_builtin(struct CInvalidBuiltinData *pData);
   void __ubsan_handle_invalid_builtin_abort(struct CInvalidBuiltinData *pData);
   void __ubsan_handle_load_invalid_value(struct CInvalidValueData *pData, unsigned long ulVal);
   void __ubsan_handle_load_invalid_value_abort(struct CInvalidValueData *pData, unsigned long ulVal);
   void __ubsan_handle_missing_return(struct CUnreachableData *pData);
   void __ubsan_handle_mul_overflow(struct COverflowData *pData, unsigned long ulLHS, unsigned long ulRHS);
   void __ubsan_handle_mul_overflow_abort(struct COverflowData *pData, unsigned long ulLHS, unsigned long ulRHS);
   void __ubsan_handle_negate_overflow(struct COverflowData *pData, unsigned long ulOldVal);
   void __ubsan_handle_negate_overflow_abort(struct COverflowData *pData, unsigned long ulOldVal);
   void __ubsan_handle_nonnull_arg(struct CNonNullArgData *pData);
   void __ubsan_handle_nonnull_arg_abort(struct CNonNullArgData *pData);
   void __ubsan_handle_nonnull_return_v1(struct CNonNullReturnData *pData, struct CSourceLocation *pLocationPointer);
   void __ubsan_handle_nonnull_return_v1_abort(struct CNonNullReturnData *pData, struct CSourceLocation *pLocationPointer);
   void __ubsan_handle_nullability_arg(struct CNonNullArgData *pData);
   void __ubsan_handle_nullability_arg_abort(struct CNonNullArgData *pData);
   void __ubsan_handle_nullability_return_v1(struct CNonNullReturnData *pData, struct CSourceLocation *pLocationPointer);
   void __ubsan_handle_nullability_return_v1_abort(struct CNonNullReturnData *pData, struct CSourceLocation *pLocationPointer);
   void __ubsan_handle_out_of_bounds(struct COutOfBoundsData *pData, unsigned long ulIndex);
   void __ubsan_handle_out_of_bounds_abort(struct COutOfBoundsData *pData, unsigned long ulIndex);
   void __ubsan_handle_pointer_overflow(struct CPointerOverflowData *pData, unsigned long ulBase, unsigned long ulResult);
   void __ubsan_handle_pointer_overflow_abort(struct CPointerOverflowData *pData, unsigned long ulBase, unsigned long ulResult);
   void __ubsan_handle_shift_out_of_bounds(struct CShiftOutOfBoundsData *pData, unsigned long ulLHS, unsigned long ulRHS);
   void __ubsan_handle_shift_out_of_bounds_abort(struct CShiftOutOfBoundsData *pData, unsigned long ulLHS, unsigned long ulRHS);
   void __ubsan_handle_sub_overflow(struct COverflowData *pData, unsigned long ulLHS, unsigned long ulRHS);
   void __ubsan_handle_sub_overflow_abort(struct COverflowData *pData, unsigned long ulLHS, unsigned long ulRHS);
   void __ubsan_handle_type_mismatch(struct CTypeMismatchData *pData, unsigned long ulPointer);
   void __ubsan_handle_type_mismatch_abort(struct CTypeMismatchData *pData, unsigned long ulPointer);
   void __ubsan_handle_type_mismatch_v1(struct CTypeMismatchData_v1 *pData, unsigned long ulPointer);
   void __ubsan_handle_type_mismatch_v1_abort(struct CTypeMismatchData_v1 *pData, unsigned long ulPointer);
   void __ubsan_handle_vla_bound_not_positive(struct CVLABoundData *pData, unsigned long ulBound);
   void __ubsan_handle_vla_bound_not_positive_abort(struct CVLABoundData *pData, unsigned long ulBound);
   void __ubsan_get_current_report_data(const char **ppOutIssueKind, const char **ppOutMessage, const char **ppOutFilename, uint32_t *pOutLine, uint32_t *pOutCol, char **ppOutMemoryAddr);
   
   static void HandleOverflow(bool isFatal, struct COverflowData *pData, unsigned long ulLHS, unsigned long ulRHS, const char *szOperation);
   static void HandleNegateOverflow(bool isFatal, struct COverflowData *pData, unsigned long ulOldValue);
   static void HandleBuiltinUnreachable(bool isFatal, struct CUnreachableData *pData);
   static void HandleTypeMismatch(bool isFatal, struct CSourceLocation *mLocation, struct CTypeDescriptor *mType, unsigned long mLogAlignment, uint8_t mTypeCheckKind, unsigned long ulPointer);
   static void HandleVlaBoundNotPositive(bool isFatal, struct CVLABoundData *pData, unsigned long ulBound);
   static void HandleOutOfBounds(bool isFatal, struct COutOfBoundsData *pData, unsigned long ulIndex);
   static void HandleShiftOutOfBounds(bool isFatal, struct CShiftOutOfBoundsData *pData, unsigned long ulLHS, unsigned long ulRHS);
   static void HandleLoadInvalidValue(bool isFatal, struct CInvalidValueData *pData, unsigned long ulValue);
   static void HandleInvalidBuiltin(bool isFatal, struct CInvalidBuiltinData *pData);
   static void HandleFunctionTypeMismatch(bool isFatal, struct CFunctionTypeMismatchData *pData, unsigned long ulFunction);
   static void HandleCFIBadType(bool isFatal, struct CCFICheckFailData *pData, unsigned long ulVtable, bool *bValidVtable, bool *FromUnrecoverableHandler, unsigned long *ProgramCounter, unsigned long *FramePointer);
   static void HandleDynamicTypeCacheMiss(bool isFatal, struct CDynamicTypeCacheMissData *pData, unsigned long ulPointer, unsigned long ulHash);
   static void HandleFloatCastOverflow(bool isFatal, struct CFloatCastOverflowData *pData, unsigned long ulFrom);
   static void HandleMissingReturn(bool isFatal, struct CUnreachableData *pData);
   static void HandleNonnullArg(bool isFatal, struct CNonNullArgData *pData);
   static void HandleNonnullReturn(bool isFatal, struct CNonNullReturnData *pData, struct CSourceLocation *pLocationPointer);
   static void HandlePointerOverflow(bool isFatal, struct CPointerOverflowData *pData, unsigned long ulBase, unsigned long ulResult);
   static void HandleAlignmentAssumption(bool isFatal, struct CAlignmentAssumptionData *pData, unsigned long ulPointer, unsigned long ulAlignment, unsigned long ulOffset);
   
   static void
   HandleOverflow(bool isFatal, struct COverflowData *pData, unsigned long ulLHS, unsigned long ulRHS, const char *szOperation)
   {
           char szLocation[LOCATION_MAXLEN];
           char szLHS[NUMBER_MAXLEN];
           char szRHS[NUMBER_MAXLEN];
   
           ASSERT(pData);
   
           if (isAlreadyReported(&pData->mLocation))
                   return;
   
           DeserializeLocation(szLocation, LOCATION_MAXLEN, &pData->mLocation);
           DeserializeNumber(szLocation, szLHS, NUMBER_MAXLEN, pData->mType, ulLHS);
           DeserializeNumber(szLocation, szRHS, NUMBER_MAXLEN, pData->mType, ulRHS);
   
           Report(isFatal, "UBSan: Undefined Behavior in %s, %s integer overflow: %s %s %s cannot be represented in type %s\n",
                  szLocation, ISSET(pData->mType->mTypeInfo, NUMBER_SIGNED_BIT) ? "signed" : "unsigned", szLHS, szOperation, szRHS, pData->mType->mTypeName);
   }
   
   static void
   HandleNegateOverflow(bool isFatal, struct COverflowData *pData, unsigned long ulOldValue)
   {
           char szLocation[LOCATION_MAXLEN];
           char szOldValue[NUMBER_MAXLEN];
   
           ASSERT(pData);
   
           if (isAlreadyReported(&pData->mLocation))
                   return;
   
           DeserializeLocation(szLocation, LOCATION_MAXLEN, &pData->mLocation);
           DeserializeNumber(szLocation, szOldValue, NUMBER_MAXLEN, pData->mType, ulOldValue);
   
           Report(isFatal, "UBSan: Undefined Behavior in %s, negation of %s cannot be represented in type %s\n",
                  szLocation, szOldValue, pData->mType->mTypeName);
   }
   
   static void
   HandleBuiltinUnreachable(bool isFatal, struct CUnreachableData *pData)
   {
           char szLocation[LOCATION_MAXLEN];
   
           ASSERT(pData);
   
           if (isAlreadyReported(&pData->mLocation))
                   return;
   
           DeserializeLocation(szLocation, LOCATION_MAXLEN, &pData->mLocation);
   
           Report(isFatal, "UBSan: Undefined Behavior in %s, calling __builtin_unreachable()\n",
                  szLocation);
   }
   
   static void
   HandleTypeMismatch(bool isFatal, struct CSourceLocation *mLocation, struct CTypeDescriptor *mType, unsigned long mLogAlignment, uint8_t mTypeCheckKind, unsigned long ulPointer)
   {
           char szLocation[LOCATION_MAXLEN];
   
           ASSERT(mLocation);
           ASSERT(mType);
   
           if (isAlreadyReported(mLocation))
                   return;
   
           DeserializeLocation(szLocation, LOCATION_MAXLEN, mLocation);
   
           if (ulPointer == 0) {
                   Report(isFatal, "UBSan: Undefined Behavior in %s, %s null pointer of type %s\n",
                          szLocation, DeserializeTypeCheckKind(mTypeCheckKind), mType->mTypeName);
           } else if ((mLogAlignment - 1) & ulPointer) {
                   Report(isFatal, "UBSan: Undefined Behavior in %s, %s misaligned address %p for type %s which requires %ld byte alignment\n",
                          szLocation, DeserializeTypeCheckKind(mTypeCheckKind), REINTERPRET_CAST(void *, ulPointer), mType->mTypeName, mLogAlignment);
           } else {
                   Report(isFatal, "UBSan: Undefined Behavior in %s, %s address %p with insufficient space for an object of type %s\n",
                          szLocation, DeserializeTypeCheckKind(mTypeCheckKind), REINTERPRET_CAST(void *, ulPointer), mType->mTypeName);
           }
   }
   
   static void
   HandleVlaBoundNotPositive(bool isFatal, struct CVLABoundData *pData, unsigned long ulBound)
   {
           char szLocation[LOCATION_MAXLEN];
           char szBound[NUMBER_MAXLEN];
   
           ASSERT(pData);
   
           if (isAlreadyReported(&pData->mLocation))
                   return;
   
           DeserializeLocation(szLocation, LOCATION_MAXLEN, &pData->mLocation);
           DeserializeNumber(szLocation, szBound, NUMBER_MAXLEN, pData->mType, ulBound);
   
           Report(isFatal, "UBSan: Undefined Behavior in %s, variable length array bound value %s <= 0\n",
                  szLocation, szBound);
   }
   
   static void
   HandleOutOfBounds(bool isFatal, struct COutOfBoundsData *pData, unsigned long ulIndex)
   {
           char szLocation[LOCATION_MAXLEN];
           char szIndex[NUMBER_MAXLEN];
   
           ASSERT(pData);
   
           if (isAlreadyReported(&pData->mLocation))
                   return;
   
           DeserializeLocation(szLocation, LOCATION_MAXLEN, &pData->mLocation);
           DeserializeNumber(szLocation, szIndex, NUMBER_MAXLEN, pData->mIndexType, ulIndex);
   
           Report(isFatal, "UBSan: Undefined Behavior in %s, index %s is out of range for type %s\n",
                  szLocation, szIndex, pData->mArrayType->mTypeName);
   }
   
   static void
   HandleShiftOutOfBounds(bool isFatal, struct CShiftOutOfBoundsData *pData, unsigned long ulLHS, unsigned long ulRHS)
   {
           char szLocation[LOCATION_MAXLEN];
           char szLHS[NUMBER_MAXLEN];
           char szRHS[NUMBER_MAXLEN];
   
           ASSERT(pData);
   
           if (isAlreadyReported(&pData->mLocation))
                   return;
   
           DeserializeLocation(szLocation, LOCATION_MAXLEN, &pData->mLocation);
           DeserializeNumber(szLocation, szLHS, NUMBER_MAXLEN, pData->mLHSType, ulLHS);
           DeserializeNumber(szLocation, szRHS, NUMBER_MAXLEN, pData->mRHSType, ulRHS);
   
           if (isNegativeNumber(szLocation, pData->mRHSType, ulRHS))
                   Report(isFatal, "UBSan: Undefined Behavior in %s, shift exponent %s is negative\n",
                          szLocation, szRHS);
           else if (isShiftExponentTooLarge(szLocation, pData->mRHSType, ulRHS, zDeserializeTypeWidth(pData->mLHSType)))
                   Report(isFatal, "UBSan: Undefined Behavior in %s, shift exponent %s is too large for %zu-bit type %s\n",
                          szLocation, szRHS, zDeserializeTypeWidth(pData->mLHSType), pData->mLHSType->mTypeName);
           else if (isNegativeNumber(szLocation, pData->mLHSType, ulLHS))
                   Report(isFatal, "UBSan: Undefined Behavior in %s, left shift of negative value %s\n",
                          szLocation, szLHS);
           else
                   Report(isFatal, "UBSan: Undefined Behavior in %s, left shift of %s by %s places cannot be represented in type %s\n",
                          szLocation, szLHS, szRHS, pData->mLHSType->mTypeName);
   }
   
   static void
   HandleLoadInvalidValue(bool isFatal, struct CInvalidValueData *pData, unsigned long ulValue)
   {
           char szLocation[LOCATION_MAXLEN];
           char szValue[NUMBER_MAXLEN];
   
           ASSERT(pData);
   
           if (isAlreadyReported(&pData->mLocation))
                   return;
   
           DeserializeLocation(szLocation, LOCATION_MAXLEN, &pData->mLocation);
           DeserializeNumber(szLocation, szValue, NUMBER_MAXLEN, pData->mType, ulValue);
   
           Report(isFatal, "UBSan: Undefined Behavior in %s, load of value %s is not a valid value for type %s\n",
                  szLocation, szValue, pData->mType->mTypeName);
   }
   
   static void
   HandleInvalidBuiltin(bool isFatal, struct CInvalidBuiltinData *pData)
   {
           char szLocation[LOCATION_MAXLEN];
   
           ASSERT(pData);
   
           if (isAlreadyReported(&pData->mLocation))
                   return;
   
           DeserializeLocation(szLocation, LOCATION_MAXLEN, &pData->mLocation);
   
           Report(isFatal, "UBSan: Undefined Behavior in %s, passing zero to %s, which is not a valid argument\n",
                  szLocation, DeserializeBuiltinCheckKind(pData->mKind));
   }
   
   static void
   HandleFunctionTypeMismatch(bool isFatal, struct CFunctionTypeMismatchData *pData, unsigned long ulFunction)
   {
           char szLocation[LOCATION_MAXLEN];
   
           /*
            * There is no a portable C solution to translate an address of a
            * function to its name. On the cost of getting this routine simple
            * and portable without ifdefs between the userland and the kernel
            * just print the address of the function as-is.
            *
            * For better diagnostic messages in the userland, users shall use
            * the full upstream version shipped along with the compiler toolchain.
            */
   
           ASSERT(pData);
   
           if (isAlreadyReported(&pData->mLocation))
                   return;
   
           DeserializeLocation(szLocation, LOCATION_MAXLEN, &pData->mLocation);
   
           Report(isFatal, "UBSan: Undefined Behavior in %s, call to function %#lx through pointer to incorrect function type %s\n",
                 szLocation, ulFunction, pData->mType->mTypeName);
   }
   
   static void
   HandleCFIBadType(bool isFatal, struct CCFICheckFailData *pData, unsigned long ulVtable, bool *bValidVtable, bool *FromUnrecoverableHandler, unsigned long *ProgramCounter, unsigned long *FramePointer)
   {
           char szLocation[LOCATION_MAXLEN];
   
           /*
            * This is a minimal implementation without diving into C++
            * specifics and (Itanium) ABI deserialization.
            */
   
           ASSERT(pData);
   
           if (isAlreadyReported(&pData->mLocation))
                   return;
   
           DeserializeLocation(szLocation, LOCATION_MAXLEN, &pData->mLocation);
   
           if (pData->mCheckKind == CFI_ICALL || pData->mCheckKind == CFI_VMFCALL) {
                   Report(isFatal, "UBSan: Undefined Behavior in %s, control flow integrity check for type %s failed during %s (vtable address %#lx)\n",
                         szLocation, pData->mType->mTypeName, DeserializeCFICheckKind(pData->mCheckKind), ulVtable);
           } else {
                   Report(isFatal || FromUnrecoverableHandler, "UBSan: Undefined Behavior in %s, control flow integrity check for type %s failed during %s (vtable address %#lx; %s vtable; from %s handler; Program Counter %#lx; Frame Pointer %#lx)\n",
                         szLocation, pData->mType->mTypeName, DeserializeCFICheckKind(pData->mCheckKind), ulVtable, *bValidVtable ? "valid" : "invalid", *FromUnrecoverableHandler ? "unrecoverable" : "recoverable", *ProgramCounter, *FramePointer);
           }
   }
   
   static void
   HandleDynamicTypeCacheMiss(bool isFatal, struct CDynamicTypeCacheMissData *pData, unsigned long ulPointer, unsigned long ulHash)
   {
   #if 0
           char szLocation[LOCATION_MAXLEN];
   
           /*
            * Unimplemented.
            *
            * This UBSan handler is special as the check has to be impelemented
            * in an implementation. In order to handle it there is need to
            * introspect into C++ ABI internals (RTTI) and use low-level
            * C++ runtime interfaces.
            */
   
           ASSERT(pData);
   
           if (isAlreadyReported(&pData->mLocation))
                   return;
   
           DeserializeLocation(szLocation, LOCATION_MAXLEN, &pData->mLocation);
   
           Report(isFatal, "UBSan: Undefined Behavior in %s, %s address %#lx which might not point to an object of type %s\n"
                 szLocation, DeserializeTypeCheckKind(pData->mTypeCheckKind), ulPointer, pData->mType);
   #endif
   }
   
   static void
   HandleFloatCastOverflow(bool isFatal, struct CFloatCastOverflowData *pData, unsigned long ulFrom)
   {
           char szLocation[LOCATION_MAXLEN];
           char szFrom[NUMBER_MAXLEN];
   
           ASSERT(pData);
   
           if (isAlreadyReported(&pData->mLocation))
                   return;
   
           DeserializeLocation(szLocation, LOCATION_MAXLEN, &pData->mLocation);
           DeserializeNumber(szLocation, szFrom, NUMBER_MAXLEN, pData->mFromType, ulFrom);
   
           Report(isFatal, "UBSan: Undefined Behavior in %s, %s (of type %s) is outside the range of representable values of type %s\n",
                  szLocation, szFrom, pData->mFromType->mTypeName, pData->mToType->mTypeName);
   }
   
   static void
   HandleMissingReturn(bool isFatal, struct CUnreachableData *pData)
   {
           char szLocation[LOCATION_MAXLEN];
   
           ASSERT(pData);
   
           if (isAlreadyReported(&pData->mLocation))
                   return;
   
           DeserializeLocation(szLocation, LOCATION_MAXLEN, &pData->mLocation);
   
           Report(isFatal, "UBSan: Undefined Behavior in %s, execution reached the end of a value-returning function without returning a value\n",
                  szLocation);
   }
   
   static void
   HandleNonnullArg(bool isFatal, struct CNonNullArgData *pData)
   {
           char szLocation[LOCATION_MAXLEN];
           char szAttributeLocation[LOCATION_MAXLEN];
   
           ASSERT(pData);
   
           if (isAlreadyReported(&pData->mLocation))
                   return;
   
           DeserializeLocation(szLocation, LOCATION_MAXLEN, &pData->mLocation);
           if (pData->mAttributeLocation.mFilename)
                   DeserializeLocation(szAttributeLocation, LOCATION_MAXLEN, &pData->mAttributeLocation);
           else
                   szAttributeLocation[0] = '\0';
   
           Report(isFatal, "UBSan: Undefined Behavior in %s, null pointer passed as argument %d, which is declared to never be null%s%s\n",
                  szLocation, pData->mArgIndex, pData->mAttributeLocation.mFilename ? ", nonnull/_Nonnull specified in " : "", szAttributeLocation);
   }
   
   static void
   HandleNonnullReturn(bool isFatal, struct CNonNullReturnData *pData, struct CSourceLocation *pLocationPointer)
   {
           char szLocation[LOCATION_MAXLEN];
           char szAttributeLocation[LOCATION_MAXLEN];
   
           ASSERT(pData);
           ASSERT(pLocationPointer);
   
           if (isAlreadyReported(pLocationPointer))
                   return;
   
           DeserializeLocation(szLocation, LOCATION_MAXLEN, pLocationPointer);
           if (pData->mAttributeLocation.mFilename)
                   DeserializeLocation(szAttributeLocation, LOCATION_MAXLEN, &pData->mAttributeLocation);
           else
                   szAttributeLocation[0] = '\0';
   
           Report(isFatal, "UBSan: Undefined Behavior in %s, null pointer returned from function declared to never return null%s%s\n",
                  szLocation, pData->mAttributeLocation.mFilename ? ", nonnull/_Nonnull specified in " : "", szAttributeLocation);
   }
   
   static void
   HandlePointerOverflow(bool isFatal, struct CPointerOverflowData *pData, unsigned long ulBase, unsigned long ulResult)
   {
           char szLocation[LOCATION_MAXLEN];
   
           ASSERT(pData);
   
           if (isAlreadyReported(&pData->mLocation))
                   return;
   
           DeserializeLocation(szLocation, LOCATION_MAXLEN, &pData->mLocation);
   
           Report(isFatal, "UBSan: Undefined Behavior in %s, pointer expression with base %#lx overflowed to %#lx\n",
                  szLocation, ulBase, ulResult);
   }
   
   static void
   HandleAlignmentAssumption(bool isFatal, struct CAlignmentAssumptionData *pData, unsigned long ulPointer, unsigned long ulAlignment, unsigned long ulOffset)
   {
           char szLocation[LOCATION_MAXLEN];
           char szAssumptionLocation[LOCATION_MAXLEN];
           unsigned long ulRealPointer;
   
           ASSERT(pData);
   
           if (isAlreadyReported(&pData->mLocation))
                   return;
   
           DeserializeLocation(szLocation, LOCATION_MAXLEN, &pData->mLocation);
   
           ulRealPointer = ulPointer - ulOffset;
   
           if (pData->mAssumptionLocation.mFilename != NULL) {
                   DeserializeLocation(szAssumptionLocation, LOCATION_MAXLEN,
                       &pData->mAssumptionLocation);
                   Report(isFatal, "UBSan: Undefined Behavior in %s, alignment assumption of %#lx for pointer %#lx (offset %#lx), assumption made in %s\n",
                       szLocation, ulAlignment, ulRealPointer, ulOffset,
                       szAssumptionLocation);
           } else {
                   Report(isFatal, "UBSan: Undefined Behavior in %s, alignment assumption of %#lx for pointer %#lx (offset %#lx)\n",
                       szLocation, ulAlignment, ulRealPointer, ulOffset);
           }
   }
   
   /* Definions of public symbols emitted by the instrumentation code */
   void
   __ubsan_handle_add_overflow(struct COverflowData *pData, unsigned long ulLHS, unsigned long ulRHS)
   {
   
           ASSERT(pData);
   
           HandleOverflow(false, pData, ulLHS, ulRHS, PLUS_STRING);
   }
   
   void
   __ubsan_handle_add_overflow_abort(struct COverflowData *pData, unsigned long ulLHS, unsigned long ulRHS)
   {
   
           ASSERT(pData);
   
           HandleOverflow(true, pData, ulLHS, ulRHS, PLUS_STRING);
   }
   
   void
   __ubsan_handle_alignment_assumption(struct CAlignmentAssumptionData *pData, unsigned long ulPointer, unsigned long ulAlignment, unsigned long ulOffset)
   {
   
           ASSERT(pData);
   
           HandleAlignmentAssumption(false, pData, ulPointer, ulAlignment, ulOffset);
   }
   
   void
   __ubsan_handle_alignment_assumption_abort(struct CAlignmentAssumptionData *pData, unsigned long ulPointer, unsigned long ulAlignment, unsigned long ulOffset)
   {
   
           ASSERT(pData);
   
           HandleAlignmentAssumption(true, pData, ulPointer, ulAlignment, ulOffset);
   }
   
   void
   __ubsan_handle_builtin_unreachable(struct CUnreachableData *pData)
   {
   
           ASSERT(pData);
   
           HandleBuiltinUnreachable(true, pData);
   }
   
   void
   __ubsan_handle_cfi_bad_type(struct CCFICheckFailData *pData, unsigned long ulVtable, bool bValidVtable, bool FromUnrecoverableHandler, unsigned long ProgramCounter, unsigned long FramePointer)
   {
   
           ASSERT(pData);
   
           HandleCFIBadType(false, pData, ulVtable, &bValidVtable, &FromUnrecoverableHandler, &ProgramCounter, &FramePointer);
   }
   
   void
   __ubsan_handle_cfi_check_fail(struct CCFICheckFailData *pData, unsigned long ulValue, unsigned long ulValidVtable)
   {
   
           ASSERT(pData);
   
           HandleCFIBadType(false, pData, ulValue, 0, 0, 0, 0);
   }
   
   void
   __ubsan_handle_cfi_check_fail_abort(struct CCFICheckFailData *pData, unsigned long ulValue, unsigned long ulValidVtable)
   {
   
           ASSERT(pData);
   
           HandleCFIBadType(true, pData, ulValue, 0, 0, 0, 0);
   }
   
   void
   __ubsan_handle_divrem_overflow(struct COverflowData *pData, unsigned long ulLHS, unsigned long ulRHS)
   {
   
           ASSERT(pData);
   
           HandleOverflow(false, pData, ulLHS, ulRHS, DIVREM_STRING);
   }
   
   void
   __ubsan_handle_divrem_overflow_abort(struct COverflowData *pData, unsigned long ulLHS, unsigned long ulRHS)
   {
   
           ASSERT(pData);
   
           HandleOverflow(true, pData, ulLHS, ulRHS, DIVREM_STRING);
   }
   
   void
   __ubsan_handle_dynamic_type_cache_miss(struct CDynamicTypeCacheMissData *pData, unsigned long ulPointer, unsigned long ulHash)
   {
   
           ASSERT(pData);
   
           HandleDynamicTypeCacheMiss(false, pData, ulPointer, ulHash);
   }
   
   void
   __ubsan_handle_dynamic_type_cache_miss_abort(struct CDynamicTypeCacheMissData *pData, unsigned long ulPointer, unsigned long ulHash)
   {
   
           ASSERT(pData);
   
           HandleDynamicTypeCacheMiss(false, pData, ulPointer, ulHash);
   }
   
   void
   __ubsan_handle_float_cast_overflow(struct CFloatCastOverflowData *pData, unsigned long ulFrom)
   {
   
           ASSERT(pData);
   
           HandleFloatCastOverflow(false, pData, ulFrom);
   }
   
   void
   __ubsan_handle_float_cast_overflow_abort(struct CFloatCastOverflowData *pData, unsigned long ulFrom)
   {
   
           ASSERT(pData);
   
           HandleFloatCastOverflow(true, pData, ulFrom);
   }
   
   void
   __ubsan_handle_function_type_mismatch(struct CFunctionTypeMismatchData *pData, unsigned long ulFunction)
   {
   
           ASSERT(pData);
   
           HandleFunctionTypeMismatch(false, pData, ulFunction);
   }
   
   void
   __ubsan_handle_function_type_mismatch_abort(struct CFunctionTypeMismatchData *pData, unsigned long ulFunction)
   {
   
           ASSERT(pData);
   
           HandleFunctionTypeMismatch(false, pData, ulFunction);
   }
   
   void
   __ubsan_handle_invalid_builtin(struct CInvalidBuiltinData *pData)
   {
   
           ASSERT(pData);
   
           HandleInvalidBuiltin(true, pData);
   }
   
   void
   __ubsan_handle_invalid_builtin_abort(struct CInvalidBuiltinData *pData)
   {
   
           ASSERT(pData);
   
           HandleInvalidBuiltin(true, pData);
   }
   
   void
   __ubsan_handle_load_invalid_value(struct CInvalidValueData *pData, unsigned long ulValue)
   {
   
           ASSERT(pData);
   
           HandleLoadInvalidValue(false, pData, ulValue);
   }
   
   void
   __ubsan_handle_load_invalid_value_abort(struct CInvalidValueData *pData, unsigned long ulValue)
   {
   
           ASSERT(pData);
   
           HandleLoadInvalidValue(true, pData, ulValue);
   }
   
   void
   __ubsan_handle_missing_return(struct CUnreachableData *pData)
   {
   
           ASSERT(pData);
   
           HandleMissingReturn(true, pData);
   }
   
   void
   __ubsan_handle_mul_overflow(struct COverflowData *pData, unsigned long ulLHS, unsigned long ulRHS)
   {
   
           ASSERT(pData);
   
           HandleOverflow(false, pData, ulLHS, ulRHS, MUL_STRING);
   }
   
   void
   __ubsan_handle_mul_overflow_abort(struct COverflowData *pData, unsigned long ulLHS, unsigned long ulRHS)
   {
   
           ASSERT(pData);
   
           HandleOverflow(true, pData, ulLHS, ulRHS, MUL_STRING);
   }
   
   void
   __ubsan_handle_negate_overflow(struct COverflowData *pData, unsigned long ulOldValue)
   {
   
           ASSERT(pData);
   
           HandleNegateOverflow(false, pData, ulOldValue);
   }
   
   void
   __ubsan_handle_negate_overflow_abort(struct COverflowData *pData, unsigned long ulOldValue)
   {
   
           ASSERT(pData);
   
           HandleNegateOverflow(true, pData, ulOldValue);
   }
   
   void
   __ubsan_handle_nonnull_arg(struct CNonNullArgData *pData)
   {
   
           ASSERT(pData);
   
           HandleNonnullArg(false, pData);
   }
   
   void
   __ubsan_handle_nonnull_arg_abort(struct CNonNullArgData *pData)
   {
   
           ASSERT(pData);
   
           HandleNonnullArg(true, pData);
   }
   
   void
   __ubsan_handle_nonnull_return_v1(struct CNonNullReturnData *pData, struct CSourceLocation *pLocationPointer)
   {
   
           ASSERT(pData);
           ASSERT(pLocationPointer);
   
           HandleNonnullReturn(false, pData, pLocationPointer);
   }
   
   void
   __ubsan_handle_nonnull_return_v1_abort(struct CNonNullReturnData *pData, struct CSourceLocation *pLocationPointer)
   {
   
           ASSERT(pData);
           ASSERT(pLocationPointer);
   
           HandleNonnullReturn(true, pData, pLocationPointer);
   }
   
   void
   __ubsan_handle_nullability_arg(struct CNonNullArgData *pData)
   {
   
           ASSERT(pData);
   
           HandleNonnullArg(false, pData);
  }
  
  void
  __ubsan_handle_nullability_arg_abort(struct CNonNullArgData *pData)
  {
  
          ASSERT(pData);
  
          HandleNonnullArg(true, pData);
  }
  
  void
  __ubsan_handle_nullability_return_v1(struct CNonNullReturnData *pData, struct CSourceLocation *pLocationPointer)
  {
  
          ASSERT(pData);
          ASSERT(pLocationPointer);
  
          HandleNonnullReturn(false, pData, pLocationPointer);
  }
  
  void
  __ubsan_handle_nullability_return_v1_abort(struct CNonNullReturnData *pData, struct CSourceLocation *pLocationPointer)
  {
  
          ASSERT(pData);
          ASSERT(pLocationPointer);
  
          HandleNonnullReturn(true, pData, pLocationPointer);
  }
  
  void
  __ubsan_handle_out_of_bounds(struct COutOfBoundsData *pData, unsigned long ulIndex)
  {
  
          ASSERT(pData);
  
          HandleOutOfBounds(false, pData, ulIndex);
  }
  
  void
  __ubsan_handle_out_of_bounds_abort(struct COutOfBoundsData *pData, unsigned long ulIndex)
  {
  
          ASSERT(pData);
  
          HandleOutOfBounds(true, pData, ulIndex);
  }
  
  void
  __ubsan_handle_pointer_overflow(struct CPointerOverflowData *pData, unsigned long ulBase, unsigned long ulResult)
  {
  
          ASSERT(pData);
  
          HandlePointerOverflow(false, pData, ulBase, ulResult);
  }
  
  void
  __ubsan_handle_pointer_overflow_abort(struct CPointerOverflowData *pData, unsigned long ulBase, unsigned long ulResult)
  {
  
          ASSERT(pData);
  
          HandlePointerOverflow(true, pData, ulBase, ulResult);
  }
  
  void
  __ubsan_handle_shift_out_of_bounds(struct CShiftOutOfBoundsData *pData, unsigned long ulLHS, unsigned long ulRHS)
  {
  
          ASSERT(pData);
  
          HandleShiftOutOfBounds(false, pData, ulLHS, ulRHS);
  }
  
  void
  __ubsan_handle_shift_out_of_bounds_abort(struct CShiftOutOfBoundsData *pData, unsigned long ulLHS, unsigned long ulRHS)
  {
  
          ASSERT(pData);
  
          HandleShiftOutOfBounds(true, pData, ulLHS, ulRHS);
  }
  
  void
  __ubsan_handle_sub_overflow(struct COverflowData *pData, unsigned long ulLHS, unsigned long ulRHS)
  {
  
          ASSERT(pData);
  
          HandleOverflow(false, pData, ulLHS, ulRHS, MINUS_STRING);
  }
  
  void
  __ubsan_handle_sub_overflow_abort(struct COverflowData *pData, unsigned long ulLHS, unsigned long ulRHS)
  {
  
          ASSERT(pData);
  
          HandleOverflow(true, pData, ulLHS, ulRHS, MINUS_STRING);
  }
  
  void
  __ubsan_handle_type_mismatch(struct CTypeMismatchData *pData, unsigned long ulPointer)
  {
  
          ASSERT(pData);
  
          HandleTypeMismatch(false, &pData->mLocation, pData->mType, pData->mLogAlignment, pData->mTypeCheckKind, ulPointer);
  }
  
  void
  __ubsan_handle_type_mismatch_abort(struct CTypeMismatchData *pData, unsigned long ulPointer)
  {
  
          ASSERT(pData);
  
          HandleTypeMismatch(true, &pData->mLocation, pData->mType, pData->mLogAlignment, pData->mTypeCheckKind, ulPointer);
  }
  
  void
  __ubsan_handle_type_mismatch_v1(struct CTypeMismatchData_v1 *pData, unsigned long ulPointer)
  {
  
          ASSERT(pData);
  
          HandleTypeMismatch(false, &pData->mLocation, pData->mType, __BIT(pData->mLogAlignment), pData->mTypeCheckKind, ulPointer);
  }
  
  void
  __ubsan_handle_type_mismatch_v1_abort(struct CTypeMismatchData_v1 *pData, unsigned long ulPointer)
  {
  
          ASSERT(pData);
  
          HandleTypeMismatch(true, &pData->mLocation, pData->mType, __BIT(pData->mLogAlignment), pData->mTypeCheckKind, ulPointer);
  }
  
  void
  __ubsan_handle_vla_bound_not_positive(struct CVLABoundData *pData, unsigned long ulBound)
  {
  
          ASSERT(pData);
  
          HandleVlaBoundNotPositive(false, pData, ulBound);
  }
  
  void
  __ubsan_handle_vla_bound_not_positive_abort(struct CVLABoundData *pData, unsigned long ulBound)
  {
  
          ASSERT(pData);
  
          HandleVlaBoundNotPositive(true, pData, ulBound);
  }
  
  void
  __ubsan_get_current_report_data(const char **ppOutIssueKind, const char **ppOutMessage, const char **ppOutFilename, uint32_t *pOutLine, uint32_t *pOutCol, char **ppOutMemoryAddr)
  {
          /*
           * Unimplemented.
           *
           * The __ubsan_on_report() feature is non trivial to implement in a
           * shared code between the kernel and userland. It's also opening
           * new sets of potential problems as we are not expected to slow down
           * execution of certain kernel subsystems (synchronization issues,
           * interrupt handling etc).
           *
           * A proper solution would need probably a lock-free bounded queue built
           * with atomic operations with the property of miltiple consumers and
           * multiple producers. Maintaining and validating such code is not
           * worth the effort.
           *
           * A legitimate user - besides testing framework - is a debugger plugin
           * intercepting reports from the UBSan instrumentation. For such
           * scenarios it is better to run the Clang/GCC version.
           */
  }
  
  /* Local utility functions */
  
  static void
  Report(bool isFatal, const char *pFormat, ...)
  {
          va_list ap;
  
          ASSERT(pFormat);
  
          va_start(ap, pFormat);
  #if defined(_KERNEL)
          if (isFatal)
                  vpanic(pFormat, ap);
          else
                  vprintf(pFormat, ap);
  #else
          if (ubsan_flags == -1) {
                  char buf[1024];
                  char *p;
  
                  ubsan_flags = UBSAN_STDERR;
  
                  if (getenv_r("LIBC_UBSAN", buf, sizeof(buf)) != -1) {
                          for (p = buf; *p; p++) {
                                  switch (*p) {
                                  case 'a':
                                          SET(ubsan_flags, UBSAN_ABORT);
                                          break;
                                  case 'A':
                                          CLR(ubsan_flags, UBSAN_ABORT);
                                          break;
                                  case 'e':
                                          SET(ubsan_flags, UBSAN_STDERR);
                                          break;
                                  case 'E':
                                          CLR(ubsan_flags, UBSAN_STDERR);
                                          break;
                                  case 'l':
                                          SET(ubsan_flags, UBSAN_SYSLOG);
                                          break;
                                  case 'L':
                                          CLR(ubsan_flags, UBSAN_SYSLOG);
                                          break;
                                  case 'o':
                                          SET(ubsan_flags, UBSAN_STDOUT);
                                          break;
                                  case 'O':
                                          CLR(ubsan_flags, UBSAN_STDOUT);
                                          break;
                                  default:
                                          break;
                                  }
                          }
                  }
          }
  
          // The *v*print* functions can flush the va_list argument.
          // Create a local copy for each call to prevent invalid read.
          if (ISSET(ubsan_flags, UBSAN_STDOUT)) {
                  va_list tmp;
                  va_copy(tmp, ap);
                  vprintf(pFormat, tmp);
                  va_end(tmp);
                  fflush(stdout);
          }
          if (ISSET(ubsan_flags, UBSAN_STDERR)) {
                  va_list tmp;
                  va_copy(tmp, ap);
                  vfprintf(stderr, pFormat, tmp);
                  va_end(tmp);
                  fflush(stderr);
          }
          if (ISSET(ubsan_flags, UBSAN_SYSLOG)) {
                  va_list tmp;
                  va_copy(tmp, ap);
                  struct syslog_data SyslogData = SYSLOG_DATA_INIT;
                  ubsan_vsyslog(LOG_DEBUG | LOG_USER, &SyslogData, pFormat, tmp);
                  va_end(tmp);
          }
          if (isFatal || ISSET(ubsan_flags, UBSAN_ABORT)) {
                  abort();
                  /* NOTREACHED */
          }
  #endif
          va_end(ap);
  }
  
  static bool
  isAlreadyReported(struct CSourceLocation *pLocation)
  {
          /*
           * This code is shared between libc, kernel and standalone usage.
           * It shall work in early bootstrap phase of both of them.
           */
  
          uint32_t siOldValue;
          volatile uint32_t *pLine;
  
          ASSERT(pLocation);
  
          pLine = &pLocation->mLine;
  
          do {
                  siOldValue = *pLine;
          } while (__sync_val_compare_and_swap(pLine, siOldValue, siOldValue | ACK_REPORTED) != siOldValue);
  
          return ISSET(siOldValue, ACK_REPORTED);
  }
  
  static size_t
  zDeserializeTypeWidth(struct CTypeDescriptor *pType)
  {
          size_t zWidth = 0;
  
          ASSERT(pType);
  
          switch (pType->mTypeKind) {
          case KIND_INTEGER:
                  zWidth = __BIT(__SHIFTOUT(pType->mTypeInfo, ~NUMBER_SIGNED_BIT));
                  break;
          case KIND_FLOAT:
                  zWidth = pType->mTypeInfo;
                  break;
          default:
                  Report(true, "UBSan: Unknown variable type %#04" PRIx16 "\n", pType->mTypeKind);
                  /* NOTREACHED */
          }
  
          /* Invalid width will be transformed to 0 */
          ASSERT(zWidth > 0);
  
          return zWidth;
  }
  
  static void
  DeserializeLocation(char *pBuffer, size_t zBUfferLength, struct CSourceLocation *pLocation)
  {
  
          ASSERT(pLocation);
          ASSERT(pLocation->mFilename);
  
          snprintf(pBuffer, zBUfferLength, "%s:%" PRIu32 ":%" PRIu32, pLocation->mFilename, pLocation->mLine & (uint32_t)~ACK_REPORTED, pLocation->mColumn);
  }
  
  #ifdef __SIZEOF_INT128__
  static void
  DeserializeUINT128(char *pBuffer, size_t zBUfferLength, struct CTypeDescriptor *pType, __uint128_t U128)
  {
          char szBuf[3]; /* 'XX\0' */
          char rgNumber[sizeof(ulongest)];
          ssize_t zI;
  
          memcpy(rgNumber, &U128, sizeof(U128));
  
          strlcpy(pBuffer, "Undecoded-128-bit-Integer-Type (0x", zBUfferLength);
  #if BYTE_ORDER == LITTLE_ENDIAN
          for (zI = sizeof(ulongest) - 1; zI >= 0; zI--) {
  #else
          for (zI = 0; zI < (ssize_t)sizeof(ulongest); zI++) {
  #endif
                  snprintf(szBuf, sizeof(szBuf), "%02" PRIx8, rgNumber[zI]);
                  strlcat(pBuffer, szBuf, zBUfferLength);
          }
          strlcat(pBuffer, ")", zBUfferLength);
  }
  #endif
  
  static void
  DeserializeNumberSigned(char *pBuffer, size_t zBUfferLength, struct CTypeDescriptor *pType, longest L)
  {
  
          ASSERT(pBuffer);
          ASSERT(zBUfferLength > 0);
          ASSERT(pType);
          ASSERT(ISSET(pType->mTypeInfo, NUMBER_SIGNED_BIT));
  
          switch (zDeserializeTypeWidth(pType)) {
          default:
                  ASSERT(0 && "Invalid codepath");
                  /* NOTREACHED */
  #ifdef __SIZEOF_INT128__
          case WIDTH_128:
                  DeserializeUINT128(pBuffer, zBUfferLength, pType, STATIC_CAST(__uint128_t, L));
                  break;
  #endif
          case WIDTH_64:
          case WIDTH_32:
          case WIDTH_16:
          case WIDTH_8:
                  snprintf(pBuffer, zBUfferLength, "%" PRId64, STATIC_CAST(int64_t, L));
                  break;
          }
  }
  
  static void
  DeserializeNumberUnsigned(char *pBuffer, size_t zBUfferLength, struct CTypeDescriptor *pType, ulongest L)
  {
  
          ASSERT(pBuffer);
          ASSERT(zBUfferLength > 0);
          ASSERT(pType);
          ASSERT(!ISSET(pType->mTypeInfo, NUMBER_SIGNED_BIT));
  
          switch (zDeserializeTypeWidth(pType)) {
          default:
                  ASSERT(0 && "Invalid codepath");
                  /* NOTREACHED */
  #ifdef __SIZEOF_INT128__
          case WIDTH_128:
                  DeserializeUINT128(pBuffer, zBUfferLength, pType, STATIC_CAST(__uint128_t, L));
                  break;
  #endif
          case WIDTH_64:
          case WIDTH_32:
          case WIDTH_16:
          case WIDTH_8:
                  snprintf(pBuffer, zBUfferLength, "%" PRIu64, STATIC_CAST(uint64_t, L));
                  break;
          }
  }
  
  #ifndef _KERNEL
  static void
  DeserializeFloatOverPointer(char *pBuffer, size_t zBUfferLength, struct CTypeDescriptor *pType, unsigned long *pNumber)
  {
          double D;
  #ifdef __HAVE_LONG_DOUBLE
          long double LD;
  #endif
  
          ASSERT(pBuffer);
          ASSERT(zBUfferLength > 0);
          ASSERT(pType);
          ASSERT(pNumber);
          /*
           * This function handles 64-bit number over a pointer on 32-bit CPUs.
           */
          ASSERT((sizeof(*pNumber) * CHAR_BIT < WIDTH_64) || (zDeserializeTypeWidth(pType) >= WIDTH_64));
          ASSERT(sizeof(D) == sizeof(uint64_t));
  #ifdef __HAVE_LONG_DOUBLE
          ASSERT(sizeof(LD) > sizeof(uint64_t));
  #endif
  
          switch (zDeserializeTypeWidth(pType)) {
  #ifdef __HAVE_LONG_DOUBLE
          case WIDTH_128:
          case WIDTH_96:
          case WIDTH_80:
                  memcpy(&LD, pNumber, sizeof(long double));
                  snprintf(pBuffer, zBUfferLength, "%Lg", LD);
                  break;
  #endif
          case WIDTH_64:
                  memcpy(&D, pNumber, sizeof(double));
                  snprintf(pBuffer, zBUfferLength, "%g", D);
                  break;
          }
  }
  
  static void
  DeserializeFloatInlined(char *pBuffer, size_t zBUfferLength, struct CTypeDescriptor *pType, unsigned long ulNumber)
  {
          float F;
          double D;
          uint32_t U32;
  
          ASSERT(pBuffer);
          ASSERT(zBUfferLength > 0);
          ASSERT(pType);
          ASSERT(sizeof(F) == sizeof(uint32_t));
          ASSERT(sizeof(D) == sizeof(uint64_t));
  
          switch (zDeserializeTypeWidth(pType)) {
          case WIDTH_64:
                  memcpy(&D, &ulNumber, sizeof(double));
                  snprintf(pBuffer, zBUfferLength, "%g", D);
                  break;
          case WIDTH_32:
                  /*
                   * On supported platforms sizeof(float)==sizeof(uint32_t)
                   * unsigned long is either 32 or 64-bit, cast it to 32-bit
                   * value in order to call memcpy(3) in an Endian-aware way.
                   */
                  U32 = STATIC_CAST(uint32_t, ulNumber);
                  memcpy(&F, &U32, sizeof(float));
                  snprintf(pBuffer, zBUfferLength, "%g", F);
                  break;
          case WIDTH_16:
                  snprintf(pBuffer, zBUfferLength, "Undecoded-16-bit-Floating-Type (%#04" PRIx16 ")", STATIC_CAST(uint16_t, ulNumber));
                  break;
          }
  }
  #endif
  
  static longest
  llliGetNumber(char *szLocation, struct CTypeDescriptor *pType, unsigned long ulNumber)
  {
          size_t zNumberWidth;
          longest L = 0;
  
          ASSERT(szLocation);
          ASSERT(pType);
  
          zNumberWidth = zDeserializeTypeWidth(pType);
          switch (zNumberWidth) {
          default:
                  Report(true, "UBSan: Unexpected %zu-Bit Type in %s\n", zNumberWidth, szLocation);
                  /* NOTREACHED */
          case WIDTH_128:
  #ifdef __SIZEOF_INT128__
                  memcpy(&L, REINTERPRET_CAST(longest *, ulNumber), sizeof(longest));
  #else
                  Report(true, "UBSan: Unexpected 128-Bit Type in %s\n", szLocation);
                  /* NOTREACHED */
  #endif
                  break;
          case WIDTH_64:
                  if (sizeof(ulNumber) * CHAR_BIT < WIDTH_64) {
                          L = *REINTERPRET_CAST(int64_t *, ulNumber);
                  } else {
                          L = STATIC_CAST(int64_t, STATIC_CAST(uint64_t, ulNumber));
                  }
                  break;
          case WIDTH_32:
                  L = STATIC_CAST(int32_t, STATIC_CAST(uint32_t, ulNumber));
                  break;
          case WIDTH_16:
                  L = STATIC_CAST(int16_t, STATIC_CAST(uint16_t, ulNumber));
                  break;
          case WIDTH_8:
                  L = STATIC_CAST(int8_t, STATIC_CAST(uint8_t, ulNumber));
                  break;
          }
  
          return L;
  }
  
  static ulongest
  llluGetNumber(char *szLocation, struct CTypeDescriptor *pType, unsigned long ulNumber)
  {
          size_t zNumberWidth;
          ulongest UL = 0;
  
          ASSERT(pType);
  
          zNumberWidth = zDeserializeTypeWidth(pType);
          switch (zNumberWidth) {
          default:
                  Report(true, "UBSan: Unexpected %zu-Bit Type in %s\n", zNumberWidth, szLocation);
                  /* NOTREACHED */
          case WIDTH_128:
  #ifdef __SIZEOF_INT128__
                  memcpy(&UL, REINTERPRET_CAST(ulongest *, ulNumber), sizeof(ulongest));
                  break;
  #else
                  Report(true, "UBSan: Unexpected 128-Bit Type in %s\n", szLocation);
                  /* NOTREACHED */
  #endif
          case WIDTH_64:
                  if (sizeof(ulNumber) * CHAR_BIT < WIDTH_64) {
                          UL = *REINTERPRET_CAST(uint64_t *, ulNumber);
                          break;
                  }
                  /* FALLTHROUGH */
          case WIDTH_32:
                  /* FALLTHROUGH */
          case WIDTH_16:
                  /* FALLTHROUGH */
          case WIDTH_8:
                  UL = ulNumber;
                  break;
          }
  
          return UL;
  }
  
  #ifndef _KERNEL
  static void
  DeserializeNumberFloat(char *szLocation, char *pBuffer, size_t zBUfferLength, struct CTypeDescriptor *pType, unsigned long ulNumber)
  {
          size_t zNumberWidth;
  
          ASSERT(szLocation);
          ASSERT(pBuffer);
          ASSERT(zBUfferLength > 0);
          ASSERT(pType);
          ASSERT(pType->mTypeKind == KIND_FLOAT);
  
          zNumberWidth = zDeserializeTypeWidth(pType);
          switch (zNumberWidth) {
          default:
                  Report(true, "UBSan: Unexpected %zu-Bit Type in %s\n", zNumberWidth, szLocation);
                  /* NOTREACHED */
  #ifdef __HAVE_LONG_DOUBLE
          case WIDTH_128:
          case WIDTH_96:
          case WIDTH_80:
                  DeserializeFloatOverPointer(pBuffer, zBUfferLength, pType, REINTERPRET_CAST(unsigned long *, ulNumber));
                  break;
  #endif
          case WIDTH_64:
                  if (sizeof(ulNumber) * CHAR_BIT < WIDTH_64) {
                          DeserializeFloatOverPointer(pBuffer, zBUfferLength, pType, REINTERPRET_CAST(unsigned long *, ulNumber));
                          break;
                  }
          case WIDTH_32:
          case WIDTH_16:
                  DeserializeFloatInlined(pBuffer, zBUfferLength, pType, ulNumber);
                  break;
          }
  }
  #endif
  
  static void
  DeserializeNumber(char *szLocation, char *pBuffer, size_t zBUfferLength, struct CTypeDescriptor *pType, unsigned long ulNumber)
  {
  
          ASSERT(szLocation);
          ASSERT(pBuffer);
          ASSERT(zBUfferLength > 0);
          ASSERT(pType);
  
          switch(pType->mTypeKind) {
          case KIND_INTEGER:
                  if (ISSET(pType->mTypeInfo, NUMBER_SIGNED_BIT)) {
                          longest L = llliGetNumber(szLocation, pType, ulNumber);
                          DeserializeNumberSigned(pBuffer, zBUfferLength, pType, L);
                  } else {
                          ulongest UL = llluGetNumber(szLocation, pType, ulNumber);
                          DeserializeNumberUnsigned(pBuffer, zBUfferLength, pType, UL);
                  }
                  break;
          case KIND_FLOAT:
  #ifdef _KERNEL
                  Report(true, "UBSan: Unexpected Float Type in %s\n", szLocation);
                  /* NOTREACHED */
  #else
                  DeserializeNumberFloat(szLocation, pBuffer, zBUfferLength, pType, ulNumber);
  #endif
                  break;
          case KIND_UNKNOWN:
                  Report(true, "UBSan: Unknown Type in %s\n", szLocation);
                  /* NOTREACHED */
                  break;
          }
  }
  
  static const char *
  DeserializeTypeCheckKind(uint8_t hhuTypeCheckKind)
  {
          const char *rgczTypeCheckKinds[] = {
                  "load of",
                  "store to",
                  "reference binding to",
                  "member access within",
                  "member call on",
                  "constructor call on",
                  "downcast of",
                  "downcast of",
                  "upcast of",
                  "cast to virtual base of",
                  "_Nonnull binding to",
                  "dynamic operation on"
          };
  
          ASSERT(__arraycount(rgczTypeCheckKinds) > hhuTypeCheckKind);
  
          return rgczTypeCheckKinds[hhuTypeCheckKind];
  }
  
  static const char *
  DeserializeBuiltinCheckKind(uint8_t hhuBuiltinCheckKind)
  {
          const char *rgczBuiltinCheckKinds[] = {
                  "ctz()",
                  "clz()"
          };
  
          ASSERT(__arraycount(rgczBuiltinCheckKinds) > hhuBuiltinCheckKind);
  
          return rgczBuiltinCheckKinds[hhuBuiltinCheckKind];
  }
  
  static const char *
  DeserializeCFICheckKind(uint8_t hhuCFICheckKind)
  {
          const char *rgczCFICheckKinds[] = {
                  "virtual call",                                 // CFI_VCALL
                  "non-virtual call",                             // CFI_NVCALL
                  "base-to-derived cast",                         // CFI_DERIVEDCAST
                  "cast to unrelated type",                       // CFI_UNRELATEDCAST
                  "indirect function call",                       // CFI_ICALL
                  "non-virtual pointer to member function call",  // CFI_NVMFCALL
                  "virtual pointer to member function call",      // CFI_VMFCALL
          };
  
          ASSERT(__arraycount(rgczCFICheckKinds) > hhuCFICheckKind);
  
          return rgczCFICheckKinds[hhuCFICheckKind];
  }
  
  static bool
  isNegativeNumber(char *szLocation, struct CTypeDescriptor *pType, unsigned long ulNumber)
  {
  
          ASSERT(szLocation);
          ASSERT(pType);
          ASSERT(pType->mTypeKind == KIND_INTEGER);
  
          if (!ISSET(pType->mTypeInfo, NUMBER_SIGNED_BIT))
                  return false;
  
          return llliGetNumber(szLocation, pType, ulNumber) < 0;
  }
  
  static bool
  isShiftExponentTooLarge(char *szLocation, struct CTypeDescriptor *pType, unsigned long ulNumber, size_t zWidth)
  {
  
          ASSERT(szLocation);
          ASSERT(pType);
          ASSERT(pType->mTypeKind == KIND_INTEGER);
  
          return llluGetNumber(szLocation, pType, ulNumber) >= zWidth;
  }

Cache object: f9e41492fe72962989ee92bf4a2d6c6a