#!/bin/bash
# Description: Check for architecture-specific implementations and potential performance impact
# Look for any remaining UNALIGNED_OK references or architecture-specific optimizations

# Search for any remaining UNALIGNED_OK checks
echo "Checking for remaining UNALIGNED_OK references:"
rg "UNALIGNED_OK"

# Look for architecture-specific implementations that might be affected
echo "Checking for architecture-specific implementations:"
fd -e h -e c | xargs rg -l "__(i386|x86_64|arm|aarch64|ppc|sparc)__"

#!/bin/bash
# Let's check the content of zbuild.h to understand the UNALIGNED_OK definitions
echo "=== Checking zbuild.h for UNALIGNED_OK context ==="
rg -A 5 -B 5 "UNALIGNED_OK" zbuild.h

# Let's also check if there are any other uses of memcpy for unaligned access
echo -e "\n=== Checking for similar memcpy patterns in architecture-specific files ==="
rg "memcpy.*sizeof" arch/

# Check the context of insert_string_tpl.h usage
echo -e "\n=== Checking where insert_string_tpl.h is included ==="
rg -l "insert_string_tpl\.h"

#!/bin/bash
# Search for any remaining WITH_UNALIGNED flags in the workflow
rg "WITH_UNALIGNED" .github/workflows/

#!/bin/bash
# Let's check the entire workflow file content to understand the context better
cat .github/workflows/cmake.yml

#!/bin/bash
# Description: Check if sanitizers are properly integrated in the build system
# and verify their usage across the codebase

# Check build system integration
echo "Checking build system integration..."
rg -l "ASAN|MSAN|sanitizer" CMakeLists.txt *.cmake

# Check usage of instrumentation macros
echo "Checking instrumentation macro usage..."
rg "instrument_(read|write)" --type c --type cpp --type h

# Look for existing sanitizer-related tests
echo "Checking for sanitizer tests..."
rg -l "ASAN|MSAN|sanitizer" test/

#!/bin/bash
# Check CMakeLists.txt content for sanitizer configuration
echo "Main CMakeLists.txt sanitizer configuration:"
rg "sanitizer|ASAN|MSAN" -A 3 -B 3 CMakeLists.txt

echo -e "\nTest CMakeLists.txt sanitizer configuration:"
rg "sanitizer|ASAN|MSAN" -A 3 -B 3 test/CMakeLists.txt

# Check if there are any other sanitizer-related compiler flags
echo -e "\nCompiler flags related to sanitizers:"
rg "CMAKE_C_FLAGS|CMAKE_CXX_FLAGS" -A 1 -B 1 CMakeLists.txt test/CMakeLists.txt

#!/bin/bash
# Check sanitizer detection and configuration
echo "Sanitizer detection configuration:"
cat cmake/detect-sanitizer.cmake

# Check if there are any other sanitizer-related files
echo -e "\nOther sanitizer-related files in cmake directory:"
fd sanitizer cmake/

#!/bin/bash
# Description: Check for any performance regression tests or benchmarks in the codebase
# that might validate the OPTIMAL_CMP size choices.

# Look for performance tests
echo "Searching for performance tests..."
rg -l "benchmark|perf_test|performance" --type c --type cpp --type h

# Look for related discussions or documentation
echo "Searching for related documentation..."
rg -l "OPTIMAL_CMP|comparison size|unaligned" README.md docs/

#!/bin/bash
# Let's examine the benchmark files and implementation details

# Check the benchmark implementation for compare256
echo "=== Checking compare256 benchmark implementation ==="
cat test/benchmarks/benchmark_compare256.cc

# Check if there are any comments or documentation about OPTIMAL_CMP in README
echo -e "\n=== Checking README for OPTIMAL_CMP documentation ==="
cat README.md | grep -A 5 -B 5 "OPTIMAL_CMP\|unaligned"

# Look for any configuration or build system tests related to OPTIMAL_CMP
echo -e "\n=== Checking for build system tests ==="
rg "OPTIMAL_CMP" configure

#!/bin/bash
# Let's examine the actual implementation and usage of compare256 functions

# Check the compare256 implementation file
echo "=== Checking compare256 implementations ==="
rg -p "compare256_unaligned|compare256_c" --type c --type h -A 10

# Check where OPTIMAL_CMP is actually used
echo -e "\n=== Checking OPTIMAL_CMP usage ==="
rg "OPTIMAL_CMP" --type c --type h -A 5

# Look for any performance-related comments near the implementations
echo -e "\n=== Checking for performance-related comments ==="
rg -p "Performance|performance|optimized for|OPTIMAL" --type c --type h -B 3 -A 3

#!/bin/bash
# Description: Verify that all possible combinations of conditions are handled

# Check for any potential gaps in implementation selection
rg -l "longest_match.*generic|compare256.*generic" | xargs rg "define.*longest_match.*generic|define.*compare256.*generic" -A 5 -B 5

#!/bin/bash
# Description: Check if any CI workflows explicitly disable alignment sanitizer checks
# or rely on the old WITH_UNALIGNED behavior

# Search for alignment sanitizer configurations in workflow files
fd -e yml -e yaml . .github/workflows/ --exec rg -l 'sanitizer|UBSAN|WITH_UNALIGNED'

# Search for any remaining WITH_UNALIGNED references that might need updating
rg 'WITH_UNALIGNED'

#!/bin/bash
# Let's check the content of cmake.yml to understand the sanitizer configuration
cat .github/workflows/cmake.yml

# Also check for any remaining references to alignment checks or sanitizers in CMake files
rg -g '*.cmake' 'alignment|sanitizer|UBSAN' -A 3 -B 3

#!/bin/bash
# Description: Verify that OPTIMAL_CMP is used consistently across the codebase
# and that there are no remaining UNALIGNED_OK checks

# Check for any remaining UNALIGNED_OK references
rg "UNALIGNED_OK" --type c --type h

# Verify OPTIMAL_CMP usage
rg "OPTIMAL_CMP" --type c --type h

#!/bin/bash
# Check the context of OPTIMAL_CMP usage in match_tpl.h and chunkset_tpl.h
# to verify proper handling of different sizes

# Check match_tpl.h implementation
rg "OPTIMAL_CMP" match_tpl.h -B 2 -A 2

# Check chunkset_tpl.h implementation
rg "OPTIMAL_CMP" chunkset_tpl.h -B 2 -A 2

# Check if there are any other architecture-specific defines that might conflict
rg "#if.*defined\(__" zbuild.h -A 2

#!/bin/bash
# Search for OPTIMAL_CMP definitions and usage
echo "Searching for OPTIMAL_CMP definitions:"
rg -A 2 "define.*OPTIMAL_CMP" 

echo -e "\nSearching for other 16-bit operations with similar conditions:"
rg "OPTIMAL_CMP.*>=.*32.*16"

#!/bin/bash
# Let's check the implementation context and other similar conditions
echo "Checking the implementation context:"
rg -B 5 -A 10 "BYTE_ORDER == LITTLE_ENDIAN && OPTIMAL_CMP >= 32" arch/generic/compare256_c.c

echo -e "\nChecking for other OPTIMAL_CMP >= 32 conditions:"
rg "OPTIMAL_CMP >= 32"

echo -e "\nChecking for other 16-bit related implementations:"
rg -A 3 "memcmp_2|16.*bit"

#!/bin/bash
# Let's check zbuild.h for OPTIMAL_CMP definitions and their context
echo "Checking OPTIMAL_CMP definitions in zbuild.h:"
rg -B 5 -A 5 "define.*OPTIMAL_CMP" zbuild.h

echo -e "\nChecking compare256 implementations:"
rg -B 2 -A 5 "compare256.*16" arch/generic/compare256_c.c