From ed5640d8b587fbcfed7dd7967f3de04b37a76f26 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 11:06:44 +0200 Subject: Adding upstream version 4:7.4.7. Signed-off-by: Daniel Baumann --- external/firebird/ubsan.patch | 307 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 307 insertions(+) create mode 100644 external/firebird/ubsan.patch (limited to 'external/firebird/ubsan.patch') diff --git a/external/firebird/ubsan.patch b/external/firebird/ubsan.patch new file mode 100644 index 000000000..fa296108d --- /dev/null +++ b/external/firebird/ubsan.patch @@ -0,0 +1,307 @@ +--- configure ++++ configure +@@ -21506,7 +21468,7 @@ + char a; + union { long long x; sem_t y; } b; + }; +- exit((int)&((struct s*)0)->b); ++ exit((int)&((struct s*)1024)->b - 1024); + } + _ACEOF + if ac_fn_c_try_run "$LINENO"; then : +@@ -21541,7 +21503,7 @@ + char a; + double b; + }; +- exit((int)&((struct s*)0)->b); ++ exit((int)&((struct s*)1024)->b - 1024); + } + _ACEOF + if ac_fn_c_try_run "$LINENO"; then : +--- src/common/classes/array.h ++++ src/common/classes/array.h +@@ -149,7 +149,7 @@ + void copyFrom(const Array& source) + { + ensureCapacity(source.count, false); +- memcpy(data, source.data, sizeof(T) * source.count); ++ if (source.count != 0) memcpy(data, source.data, sizeof(T) * source.count); + count = source.count; + } + +@@ -227,7 +227,7 @@ + fb_assert(count <= FB_MAX_SIZEOF - itemsCount); + ensureCapacity(count + itemsCount); + memmove(data + index + itemsCount, data + index, sizeof(T) * (count - index)); +- memcpy(data + index, items, sizeof(T) * itemsCount); ++ if (itemsCount != 0) memcpy(data + index, items, sizeof(T) * itemsCount); + count += itemsCount; + } + +@@ -242,7 +242,7 @@ + { + fb_assert(count <= FB_MAX_SIZEOF - itemsCount); + ensureCapacity(count + itemsCount); +- memcpy(data + count, items, sizeof(T) * itemsCount); ++ if (itemsCount != 0) memcpy(data + count, items, sizeof(T) * itemsCount); + count += itemsCount; + } + +@@ -294,7 +294,7 @@ + { + fb_assert(newCount >= count); + ensureCapacity(newCount); +- memset(data + count, 0, sizeof(T) * (newCount - count)); ++ if (newCount != count) memset(data + count, 0, sizeof(T) * (newCount - count)); + count = newCount; + } + +@@ -328,7 +328,7 @@ + { + fb_assert(count <= FB_MAX_SIZEOF - L.count); + ensureCapacity(count + L.count); +- memcpy(data + count, L.data, sizeof(T) * L.count); ++ if (L.count != 0) memcpy(data + count, L.data, sizeof(T) * L.count); + count += L.count; + } + +@@ -462,7 +462,7 @@ + + T* newdata = static_cast + (this->getPool().allocate(sizeof(T) * newcapacity ALLOC_ARGS)); +- if (preserve) ++ if (preserve && count != 0) + memcpy(newdata, data, sizeof(T) * count); + freeData(); + data = newdata; +--- src/common/classes/fb_string.h ++++ src/common/classes/fb_string.h +@@ -674,7 +674,8 @@ + } + StringType& assign(const void* s, size_type n) + { +- memcpy(baseAssign(n), s, n); ++ auto const p = baseAssign(n); ++ if (n != 0) memcpy(p, s, n); + return *this; + } + StringType& assign(const_pointer s) +--- src/common/common.h ++++ src/common/common.h +@@ -1002,6 +1002,5 @@ + } + + #undef UCHAR_TYPE +-#define UCHAR_TYPE uint16_t + + #endif /* COMMON_COMMON_H */ +--- src/common/unicode_util.cpp ++++ src/common/unicode_util.cpp +@@ -187,7 +187,7 @@ + Mutex ciAiTransCacheMutex; + Array ciAiTransCache; + +- void (U_EXPORT2 *uVersionToString)(UVersionInfo versionArray, char* versionString); ++ void (U_EXPORT2 *uVersionToString)(UVersionInfo const versionArray, char* versionString); + + int32_t (U_EXPORT2 *ulocCountAvailable)(); + const char* (U_EXPORT2 *ulocGetAvailable)(int32_t n); +--- src/dsql/StmtNodes.cpp ++++ src/dsql/StmtNodes.cpp +@@ -6643,7 +6643,7 @@ + + void StoreNode::genBlr(DsqlCompilerScratch* dsqlScratch) + { +- const dsql_msg* message = dsqlGenDmlHeader(dsqlScratch, dsqlRse->as()); ++ const dsql_msg* message = dsqlGenDmlHeader(dsqlScratch, dsqlRse == nullptr ? nullptr : dsqlRse->as()); + + dsqlScratch->appendUChar(statement2 ? blr_store2 : blr_store); + GEN_expr(dsqlScratch, dsqlRelation); +--- src/gpre/hsh.cpp ++++ src/gpre/hsh.cpp +@@ -232,7 +232,7 @@ + { + SCHAR c; + +- SLONG value = 0; ++ ULONG value = 0; + + while (c = *string++) + value = (value << 1) + UPPER(c); +--- src/jrd/GlobalRWLock.cpp ++++ src/jrd/GlobalRWLock.cpp +@@ -78,7 +78,7 @@ + + cachedLock = FB_NEW_RPT(getPool(), lockLen) + Lock(tdbb, lockLen, lckType, this, lockCaching ? blocking_ast_cached_lock : NULL); +- memcpy(cachedLock->getKeyString(), lockStr, lockLen); ++ if (lockLen != 0) memcpy(cachedLock->getKeyString(), lockStr, lockLen); + } + + GlobalRWLock::~GlobalRWLock() +--- src/jrd/Optimizer.cpp ++++ src/jrd/Optimizer.cpp +@@ -368,7 +368,7 @@ + + // Allocate needed indexScratches + +- index_desc* idx = csb_tail->csb_idx->items; ++ index_desc* idx = csb_tail->csb_idx == nullptr ? nullptr : csb_tail->csb_idx->items; + for (int i = 0; i < csb_tail->csb_indices; ++i, ++idx) + indexScratches.add(IndexScratch(p, tdbb, idx, csb_tail)); + } +--- src/jrd/blb.cpp ++++ src/jrd/blb.cpp +@@ -1786,7 +1786,7 @@ + arg.slice_base = array->arr_data; + + SLONG variables[64]; +- memcpy(variables, param, MIN(sizeof(variables), param_length)); ++ if (param_length != 0) memcpy(variables, param, MIN(sizeof(variables), param_length)); + + if (SDL_walk(tdbb->tdbb_status_vector, sdl, array->arr_data, &array_desc->arr_desc, + variables, slice_callback, &arg)) +--- src/jrd/btn.cpp ++++ src/jrd/btn.cpp +@@ -387,7 +387,7 @@ + + put_short(pagePointer, offset); + pagePointer += sizeof(USHORT); +- memmove(pagePointer, data, length); ++ if (length != 0) memmove(pagePointer, data, length); + pagePointer += length; + return pagePointer; + } +@@ -622,7 +622,7 @@ + } + + // Store data +- if (withData) { ++ if (withData && length != 0) { + memcpy(pagePointer, data, length); + } + pagePointer += length; +--- src/jrd/btr.cpp ++++ src/jrd/btr.cpp +@@ -5206,7 +5206,7 @@ + // Push node on end in list + jumpNodes->add(jumpNode); + // Store new data in jumpKey, so a new jump node can calculate prefix +- memcpy(jumpData + jumpNode.prefix, jumpNode.data, jumpNode.length); ++ if (jumpNode.length != 0) memcpy(jumpData + jumpNode.prefix, jumpNode.data, jumpNode.length); + jumpLength = jumpNode.length + jumpNode.prefix; + + // Check if this could be our split point (if we need to split) +@@ -5391,7 +5391,7 @@ + // First, store needed data for beforeInsertNode into tempData. + HalfStaticArray tempBuf; + UCHAR* tempData = tempBuf.getBuffer(newLength); +- memcpy(tempData, beforeInsertNode.data + newPrefix - beforeInsertNode.prefix, newLength); ++ if (newLength != 0) memcpy(tempData, beforeInsertNode.data + newPrefix - beforeInsertNode.prefix, newLength); + + beforeInsertNode.prefix = newPrefix; + beforeInsertNode.length = newLength; +@@ -5611,7 +5611,7 @@ + for (size_t i = 0; i < jumpNodes->getCount(); i++, index++) + { + UCHAR* q = new_key->key_data + walkJumpNode[i].prefix; +- memcpy(q, walkJumpNode[i].data, walkJumpNode[i].length); ++ if (walkJumpNode[i].length != 0) memcpy(q, walkJumpNode[i].data, walkJumpNode[i].length); + if (index == splitJumpNodeIndex) + { + jn = &walkJumpNode[i]; +@@ -5636,7 +5636,7 @@ + const USHORT length = walkJumpNode[i].prefix + walkJumpNode[i].length; + UCHAR* newData = FB_NEW_POOL(*tdbb->getDefaultPool()) UCHAR[length]; + memcpy(newData, new_key->key_data, walkJumpNode[i].prefix); +- memcpy(newData + walkJumpNode[i].prefix, walkJumpNode[i].data, ++ if (walkJumpNode[i].length != 0) memcpy(newData + walkJumpNode[i].prefix, walkJumpNode[i].data, + walkJumpNode[i].length); + delete[] walkJumpNode[i].data; + walkJumpNode[i].prefix = 0; +--- src/jrd/evl.cpp ++++ src/jrd/evl.cpp +@@ -415,7 +415,7 @@ + case dtype_real: + case dtype_sql_time: + case dtype_sql_date: +- value->vlu_misc.vlu_long = *((SLONG*) from.dsc_address); ++ memcpy(&value->vlu_misc.vlu_long, from.dsc_address, sizeof (SLONG)); + return; + + case dtype_int64: +--- src/jrd/lck.cpp ++++ src/jrd/lck.cpp +@@ -488,7 +488,7 @@ + break; + } + +- dbb->dbb_lock_mgr->shutdownOwner(tdbb, owner_handle_ptr); ++ LockManager::shutdownOwner(dbb->dbb_lock_mgr, tdbb, owner_handle_ptr); + } + + +--- src/lock/lock.cpp ++++ src/lock/lock.cpp +@@ -441,7 +441,7 @@ + } + + +-void LockManager::shutdownOwner(thread_db* tdbb, SRQ_PTR* owner_handle) ++void LockManager::shutdownOwner(LockManager* This, thread_db* tdbb, SRQ_PTR* owner_handle) + { + /************************************** + * +@@ -460,8 +460,9 @@ + if (!owner_offset) + return; + +- LockTableGuard guard(this, FB_FUNCTION, owner_offset); ++ LockTableGuard guard(This, FB_FUNCTION, owner_offset); + ++#define SRQ_BASE ((UCHAR*) This->m_sharedMemory->getHeader()) + own* owner = (own*) SRQ_ABS_PTR(owner_offset); + if (!owner->own_count) + return; +@@ -472,7 +473,7 @@ + while (owner->own_ast_count) + { + { // checkout scope +- LockTableCheckout checkout(this, FB_FUNCTION); ++ LockTableCheckout checkout(This, FB_FUNCTION); + EngineCheckout cout(tdbb, FB_FUNCTION, true); + Thread::sleep(10); + } +@@ -484,8 +485,9 @@ + // released before destroying the lock owner. This is not strictly required, + // but it enforces the proper object lifetime discipline through the codebase. + fb_assert(SRQ_EMPTY(owner->own_requests)); ++#define SRQ_BASE ((UCHAR*) m_sharedMemory->getHeader()) + +- purge_owner(owner_offset, owner); ++ This->purge_owner(owner_offset, owner); + + *owner_handle = 0; + } +--- src/lock/lock_proto.h ++++ src/lock/lock_proto.h +@@ -402,7 +402,7 @@ + static void destroy(LockManager*); + + bool initializeOwner(Firebird::CheckStatusWrapper*, LOCK_OWNER_T, UCHAR, SRQ_PTR*); +- void shutdownOwner(thread_db*, SRQ_PTR*); ++ static void shutdownOwner(LockManager* This, thread_db*, SRQ_PTR*); + + SRQ_PTR enqueue(thread_db*, Firebird::CheckStatusWrapper*, SRQ_PTR, const USHORT, + const UCHAR*, const USHORT, UCHAR, lock_ast_t, void*, SINT64, SSHORT, SRQ_PTR); +--- src/yvalve/gds.cpp ++++ src/yvalve/gds.cpp +@@ -2561,7 +2561,7 @@ + value += ((SLONG) *ptr++) << shift; + shift += 8; + } +- value += ((SLONG)(SCHAR) *ptr) << shift; ++ value += ((ULONG)(SCHAR) *ptr) << shift; + + return value; + } -- cgit v1.2.3