commit 7e8d2a45ef49e0f33e1e2f19372df87207dabdd0 Author: BigfootACA Date: Fri Dec 15 01:39:58 2023 +0800 Initial commit diff --git a/.SRCINFO b/.SRCINFO new file mode 100644 index 0000000..e39e02e --- /dev/null +++ b/.SRCINFO @@ -0,0 +1,29 @@ +pkgbase = glibc + pkgver = 2.38 + pkgrel = 7 + url = https://www.gnu.org/software/libc + arch = aarch64 + license = GPL + license = LGPL + makedepends = git + makedepends = gd + makedepends = armv7l-linux-gnueabihf-gcc + makedepends = armv7l-linux-gnueabihf-linux-api-headers + makedepends = python + options = staticlibs + options = !lto + source = git+https://gitmirrors.classfun.cn:4443/glibc.git#commit=750a45a783906a19591fb8ff6b7841470f1f5701 + source = lib32-glibc.conf + source = reenable_DT_HASH.patch + validpgpkeys = 7273542B39962DF7B299931416792B4EA25340F8 + validpgpkeys = BC7C7372637EC10C57D7AA6579C43DFBF1CF2187 + b2sums = SKIP + b2sums = 7c265e6d36a5c0dff127093580827d15519b6c7205c2e1300e82f0fb5b9dd00b6accb40c56581f18179c4fbbc95bd2bf1b900ace867a83accde0969f7b609f8a + b2sums = 35e03ed912e1b0cd23783ab83ce919412885c141344905b8b67bbad4a86c48cf3e893806060e48d5737514ff80cea0b58b0e1f15707c32224579c416dcd810c0 + +pkgname = lib32-glibc + pkgdesc = GNU C Library (32-bit) + depends = glibc=2.38 + options = staticlibs + options = !lto + options = !emptydirs diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..cb407e9 --- /dev/null +++ b/.gitignore @@ -0,0 +1,53 @@ +*.rej +*.orig +*.swp +*.save* +*.o +*.a +*.out +*.lib +*.obj +*.dll +*.so +*.exe +*.gch +*.plist +*.mo +*.gmo +*.fd +*.iso +*.img +*.img.* +*.qcow2 +*.vhd +*.vdi +*.vmdk +*.cpio +*.cpio.* +*.ttf +*.ttc +*.pcf +*.pcf.* +*.efi +*.pkg.tar.* +vgcore.* +/build* +initramfs*.* +initrd*.* +System.map* +/cmake-build-* +/.idea +/.vscode +/.cache +CMakeCache.txt +CMakeFiles +Makefile +cmake_install.cmake +node_modules +package.json +package-lock.json +fonts.scale +fonts.dir +/src +/pkg +/glibc diff --git a/Jenkinsfile b/Jenkinsfile new file mode 100644 index 0000000..1281526 --- /dev/null +++ b/Jenkinsfile @@ -0,0 +1,44 @@ +pipeline { + agent { + label 'aarch64 && archlinux' + } + stages { + stage('Download Config') { + steps { + dir('jenkins-utils') { + git 'https://gitlab.classfun.cn:4443/renegade-project/jenkins-utils' + } + } + } + stage('Cleanup packages') { + steps { + sh 'rm -f *.pkg.tar.*' + } + } + stage('Build') { + steps { + sh 'makepkg --config jenkins-utils/makepkg-aarch64.conf --syncdeps --force --noconfirm' + } + } + stage('Signature packages') { + steps { + withCredentials([ + file(credentialsId: 'gpg-file', variable: 'GPG_FILE'), + string(credentialsId: 'gpg-secret', variable: 'GPG_SECRET') + ]) { + sh 'python3 jenkins-utils/sign-pkg.py -d . -k "$GPG_FILE" -p "$GPG_SECRET"' + } + } + } + stage('Upload packages') { + steps { + sh 'python3 jenkins-utils/upload-pkg.py -d . -a aarch64' + } + } + stage('Archive') { + steps { + archiveArtifacts artifacts: '*.pkg.tar.*', fingerprint: true + } + } + } +} diff --git a/PKGBUILD b/PKGBUILD new file mode 100644 index 0000000..9d9298f --- /dev/null +++ b/PKGBUILD @@ -0,0 +1,100 @@ +# Maintainer: BigfootACA +# Maintainer: Giancarlo Razzolini +# Maintainer: Frederik Schwan +# Contributor: Bartłomiej Piotrowski +# Contributor: Allan McRae + +# toolchain build order: linux-api-headers->glibc->binutils->gcc->glibc->binutils->gcc +# NOTE: valgrind requires rebuilt with each major glibc version + +pkgbase=glibc +pkgname=(lib32-glibc) +pkgver=2.38 +_commit=750a45a783906a19591fb8ff6b7841470f1f5701 +pkgrel=7 +arch=(aarch64) +url='https://www.gnu.org/software/libc' +license=(GPL LGPL) +makedepends=(git gd armv7l-linux-gnueabihf-gcc armv7l-linux-gnueabihf-linux-api-headers python) +options=(staticlibs !lto) +source=(git+https://gitmirrors.classfun.cn:4443/glibc.git#commit=${_commit} + lib32-glibc.conf + reenable_DT_HASH.patch +) +validpgpkeys=(7273542B39962DF7B299931416792B4EA25340F8 # Carlos O'Donell + BC7C7372637EC10C57D7AA6579C43DFBF1CF2187) # Siddhesh Poyarekar +b2sums=('SKIP' + '7c265e6d36a5c0dff127093580827d15519b6c7205c2e1300e82f0fb5b9dd00b6accb40c56581f18179c4fbbc95bd2bf1b900ace867a83accde0969f7b609f8a' + '35e03ed912e1b0cd23783ab83ce919412885c141344905b8b67bbad4a86c48cf3e893806060e48d5737514ff80cea0b58b0e1f15707c32224579c416dcd810c0') + +prepare() { + mkdir -p lib32-glibc-build + + [[ -d glibc-$pkgver ]] && ln -s glibc-$pkgver glibc + cd glibc + + # Re-enable `--hash-style=both` for building shared objects due to issues with EPIC's EAC + # which relies on DT_HASH to be present in these libs. + # reconsider 2023-01 + patch -Np1 -i "${srcdir}"/reenable_DT_HASH.patch +} + +build() { + local _configure_flags=( + --prefix=/usr + --with-headers=/usr/armv7l-linux-gnueabihf/include + --with-bugurl=https://bugs.archlinux.org/ + --enable-bind-now + --enable-cet + --enable-fortify-source + --enable-kernel=4.4 + --enable-stack-protector=strong + --enable-systemtap + --disable-nscd + --disable-profile + --disable-werror + --disable-multi-arch + ) + ( + cd lib32-glibc-build + export CC="armv7l-linux-gnueabihf-gcc" + export CXX="armv7l-linux-gnueabihf-g++" + + echo "slibdir=/usr/lib32" >> configparms + echo "rtlddir=/usr/lib32" >> configparms + echo "sbindir=/usr/bin" >> configparms + echo "rootsbindir=/usr/bin" >> configparms + + "${srcdir}"/glibc/configure \ + --host=armv7l-linux-gnueabihf \ + --libdir=/usr/lib32 \ + --libexecdir=/usr/lib32 \ + "${_configure_flags[@]}" + + make -O + ) +} + +package_lib32-glibc() { + pkgdesc='GNU C Library (32-bit)' + depends=("glibc") + options+=('!emptydirs') + + cd lib32-glibc-build + + make DESTDIR="${pkgdir}" install + rm -rf "${pkgdir}"/{etc,sbin,usr/{bin,sbin,share},var} + + # We need to keep 32 bit specific header files + find "${pkgdir}"/usr/include -type f -not -name '*-32.h' -delete + + # Dynamic linker + install -d "${pkgdir}"/usr/lib + ln -s ../lib32/ld-linux-armhf.so.3 "${pkgdir}"/usr/lib/ + + # Add lib32 paths to the default library search path + install -Dm644 "${srcdir}"/lib32-glibc.conf "${pkgdir}"/etc/ld.so.conf.d/lib32-glibc.conf + + # Symlink /usr/lib32/locale to /usr/lib/locale + ln -s ../lib/locale "${pkgdir}"/usr/lib32/locale +} diff --git a/fix-malloc-p1.patch b/fix-malloc-p1.patch new file mode 100644 index 0000000..5309f9f --- /dev/null +++ b/fix-malloc-p1.patch @@ -0,0 +1,294 @@ +commit 542b1105852568c3ebc712225ae78b8c8ba31a78 +Author: Florian Weimer +Date: Fri Aug 11 11:18:17 2023 +0200 + + malloc: Enable merging of remainders in memalign (bug 30723) + + Previously, calling _int_free from _int_memalign could put remainders + into the tcache or into fastbins, where they are invisible to the + low-level allocator. This results in missed merge opportunities + because once these freed chunks become available to the low-level + allocator, further memalign allocations (even of the same size are) + likely obstructing merges. + + Furthermore, during forwards merging in _int_memalign, do not + completely give up when the remainder is too small to serve as a + chunk on its own. We can still give it back if it can be merged + with the following unused chunk. This makes it more likely that + memalign calls in a loop achieve a compact memory layout, + independently of initial heap layout. + + Drop some useless (unsigned long) casts along the way, and tweak + the style to more closely match GNU on changed lines. + + Reviewed-by: DJ Delorie + +diff --git a/malloc/malloc.c b/malloc/malloc.c +index e2f1a615a4..948f9759af 100644 +--- a/malloc/malloc.c ++++ b/malloc/malloc.c +@@ -1086,6 +1086,11 @@ typedef struct malloc_chunk* mchunkptr; + + static void* _int_malloc(mstate, size_t); + static void _int_free(mstate, mchunkptr, int); ++static void _int_free_merge_chunk (mstate, mchunkptr, INTERNAL_SIZE_T); ++static INTERNAL_SIZE_T _int_free_create_chunk (mstate, ++ mchunkptr, INTERNAL_SIZE_T, ++ mchunkptr, INTERNAL_SIZE_T); ++static void _int_free_maybe_consolidate (mstate, INTERNAL_SIZE_T); + static void* _int_realloc(mstate, mchunkptr, INTERNAL_SIZE_T, + INTERNAL_SIZE_T); + static void* _int_memalign(mstate, size_t, size_t); +@@ -4637,31 +4642,52 @@ _int_free (mstate av, mchunkptr p, int have_lock) + if (!have_lock) + __libc_lock_lock (av->mutex); + +- nextchunk = chunk_at_offset(p, size); +- +- /* Lightweight tests: check whether the block is already the +- top block. */ +- if (__glibc_unlikely (p == av->top)) +- malloc_printerr ("double free or corruption (top)"); +- /* Or whether the next chunk is beyond the boundaries of the arena. */ +- if (__builtin_expect (contiguous (av) +- && (char *) nextchunk +- >= ((char *) av->top + chunksize(av->top)), 0)) +- malloc_printerr ("double free or corruption (out)"); +- /* Or whether the block is actually not marked used. */ +- if (__glibc_unlikely (!prev_inuse(nextchunk))) +- malloc_printerr ("double free or corruption (!prev)"); +- +- nextsize = chunksize(nextchunk); +- if (__builtin_expect (chunksize_nomask (nextchunk) <= CHUNK_HDR_SZ, 0) +- || __builtin_expect (nextsize >= av->system_mem, 0)) +- malloc_printerr ("free(): invalid next size (normal)"); ++ _int_free_merge_chunk (av, p, size); + +- free_perturb (chunk2mem(p), size - CHUNK_HDR_SZ); ++ if (!have_lock) ++ __libc_lock_unlock (av->mutex); ++ } ++ /* ++ If the chunk was allocated via mmap, release via munmap(). ++ */ ++ ++ else { ++ munmap_chunk (p); ++ } ++} ++ ++/* Try to merge chunk P of SIZE bytes with its neighbors. Put the ++ resulting chunk on the appropriate bin list. P must not be on a ++ bin list yet, and it can be in use. */ ++static void ++_int_free_merge_chunk (mstate av, mchunkptr p, INTERNAL_SIZE_T size) ++{ ++ mchunkptr nextchunk = chunk_at_offset(p, size); ++ ++ /* Lightweight tests: check whether the block is already the ++ top block. */ ++ if (__glibc_unlikely (p == av->top)) ++ malloc_printerr ("double free or corruption (top)"); ++ /* Or whether the next chunk is beyond the boundaries of the arena. */ ++ if (__builtin_expect (contiguous (av) ++ && (char *) nextchunk ++ >= ((char *) av->top + chunksize(av->top)), 0)) ++ malloc_printerr ("double free or corruption (out)"); ++ /* Or whether the block is actually not marked used. */ ++ if (__glibc_unlikely (!prev_inuse(nextchunk))) ++ malloc_printerr ("double free or corruption (!prev)"); ++ ++ INTERNAL_SIZE_T nextsize = chunksize(nextchunk); ++ if (__builtin_expect (chunksize_nomask (nextchunk) <= CHUNK_HDR_SZ, 0) ++ || __builtin_expect (nextsize >= av->system_mem, 0)) ++ malloc_printerr ("free(): invalid next size (normal)"); ++ ++ free_perturb (chunk2mem(p), size - CHUNK_HDR_SZ); + +- /* consolidate backward */ +- if (!prev_inuse(p)) { +- prevsize = prev_size (p); ++ /* Consolidate backward. */ ++ if (!prev_inuse(p)) ++ { ++ INTERNAL_SIZE_T prevsize = prev_size (p); + size += prevsize; + p = chunk_at_offset(p, -((long) prevsize)); + if (__glibc_unlikely (chunksize(p) != prevsize)) +@@ -4669,9 +4695,25 @@ _int_free (mstate av, mchunkptr p, int have_lock) + unlink_chunk (av, p); + } + +- if (nextchunk != av->top) { ++ /* Write the chunk header, maybe after merging with the following chunk. */ ++ size = _int_free_create_chunk (av, p, size, nextchunk, nextsize); ++ _int_free_maybe_consolidate (av, size); ++} ++ ++/* Create a chunk at P of SIZE bytes, with SIZE potentially increased ++ to cover the immediately following chunk NEXTCHUNK of NEXTSIZE ++ bytes (if NEXTCHUNK is unused). The chunk at P is not actually ++ read and does not have to be initialized. After creation, it is ++ placed on the appropriate bin list. The function returns the size ++ of the new chunk. */ ++static INTERNAL_SIZE_T ++_int_free_create_chunk (mstate av, mchunkptr p, INTERNAL_SIZE_T size, ++ mchunkptr nextchunk, INTERNAL_SIZE_T nextsize) ++{ ++ if (nextchunk != av->top) ++ { + /* get and clear inuse bit */ +- nextinuse = inuse_bit_at_offset(nextchunk, nextsize); ++ bool nextinuse = inuse_bit_at_offset (nextchunk, nextsize); + + /* consolidate forward */ + if (!nextinuse) { +@@ -4686,8 +4728,8 @@ _int_free (mstate av, mchunkptr p, int have_lock) + been given one chance to be used in malloc. + */ + +- bck = unsorted_chunks(av); +- fwd = bck->fd; ++ mchunkptr bck = unsorted_chunks (av); ++ mchunkptr fwd = bck->fd; + if (__glibc_unlikely (fwd->bk != bck)) + malloc_printerr ("free(): corrupted unsorted chunks"); + p->fd = fwd; +@@ -4706,61 +4748,52 @@ _int_free (mstate av, mchunkptr p, int have_lock) + check_free_chunk(av, p); + } + +- /* +- If the chunk borders the current high end of memory, +- consolidate into top +- */ +- +- else { ++ else ++ { ++ /* If the chunk borders the current high end of memory, ++ consolidate into top. */ + size += nextsize; + set_head(p, size | PREV_INUSE); + av->top = p; + check_chunk(av, p); + } + +- /* +- If freeing a large space, consolidate possibly-surrounding +- chunks. Then, if the total unused topmost memory exceeds trim +- threshold, ask malloc_trim to reduce top. +- +- Unless max_fast is 0, we don't know if there are fastbins +- bordering top, so we cannot tell for sure whether threshold +- has been reached unless fastbins are consolidated. But we +- don't want to consolidate on each free. As a compromise, +- consolidation is performed if FASTBIN_CONSOLIDATION_THRESHOLD +- is reached. +- */ ++ return size; ++} + +- if ((unsigned long)(size) >= FASTBIN_CONSOLIDATION_THRESHOLD) { ++/* If freeing a large space, consolidate possibly-surrounding ++ chunks. Then, if the total unused topmost memory exceeds trim ++ threshold, ask malloc_trim to reduce top. */ ++static void ++_int_free_maybe_consolidate (mstate av, INTERNAL_SIZE_T size) ++{ ++ /* Unless max_fast is 0, we don't know if there are fastbins ++ bordering top, so we cannot tell for sure whether threshold has ++ been reached unless fastbins are consolidated. But we don't want ++ to consolidate on each free. As a compromise, consolidation is ++ performed if FASTBIN_CONSOLIDATION_THRESHOLD is reached. */ ++ if (size >= FASTBIN_CONSOLIDATION_THRESHOLD) ++ { + if (atomic_load_relaxed (&av->have_fastchunks)) + malloc_consolidate(av); + +- if (av == &main_arena) { ++ if (av == &main_arena) ++ { + #ifndef MORECORE_CANNOT_TRIM +- if ((unsigned long)(chunksize(av->top)) >= +- (unsigned long)(mp_.trim_threshold)) +- systrim(mp_.top_pad, av); ++ if (chunksize (av->top) >= mp_.trim_threshold) ++ systrim (mp_.top_pad, av); + #endif +- } else { +- /* Always try heap_trim(), even if the top chunk is not +- large, because the corresponding heap might go away. */ +- heap_info *heap = heap_for_ptr(top(av)); ++ } ++ else ++ { ++ /* Always try heap_trim, even if the top chunk is not large, ++ because the corresponding heap might go away. */ ++ heap_info *heap = heap_for_ptr (top (av)); + +- assert(heap->ar_ptr == av); +- heap_trim(heap, mp_.top_pad); +- } ++ assert (heap->ar_ptr == av); ++ heap_trim (heap, mp_.top_pad); ++ } + } +- +- if (!have_lock) +- __libc_lock_unlock (av->mutex); +- } +- /* +- If the chunk was allocated via mmap, release via munmap(). +- */ +- +- else { +- munmap_chunk (p); +- } + } + + /* +@@ -5221,7 +5254,7 @@ _int_memalign (mstate av, size_t alignment, size_t bytes) + (av != &main_arena ? NON_MAIN_ARENA : 0)); + set_inuse_bit_at_offset (newp, newsize); + set_head_size (p, leadsize | (av != &main_arena ? NON_MAIN_ARENA : 0)); +- _int_free (av, p, 1); ++ _int_free_merge_chunk (av, p, leadsize); + p = newp; + + assert (newsize >= nb && +@@ -5232,15 +5265,27 @@ _int_memalign (mstate av, size_t alignment, size_t bytes) + if (!chunk_is_mmapped (p)) + { + size = chunksize (p); +- if ((unsigned long) (size) > (unsigned long) (nb + MINSIZE)) ++ mchunkptr nextchunk = chunk_at_offset(p, size); ++ INTERNAL_SIZE_T nextsize = chunksize(nextchunk); ++ if (size > nb) + { + remainder_size = size - nb; +- remainder = chunk_at_offset (p, nb); +- set_head (remainder, remainder_size | PREV_INUSE | +- (av != &main_arena ? NON_MAIN_ARENA : 0)); +- set_head_size (p, nb); +- _int_free (av, remainder, 1); +- } ++ if (remainder_size >= MINSIZE ++ || nextchunk == av->top ++ || !inuse_bit_at_offset (nextchunk, nextsize)) ++ { ++ /* We can only give back the tail if it is larger than ++ MINSIZE, or if the following chunk is unused (top ++ chunk or unused in-heap chunk). Otherwise we would ++ create a chunk that is smaller than MINSIZE. */ ++ remainder = chunk_at_offset (p, nb); ++ set_head_size (p, nb); ++ remainder_size = _int_free_create_chunk (av, remainder, ++ remainder_size, ++ nextchunk, nextsize); ++ _int_free_maybe_consolidate (av, remainder_size); ++ } ++ } + } + + check_inuse_chunk (av, p); diff --git a/fix-malloc-p2.patch b/fix-malloc-p2.patch new file mode 100644 index 0000000..2b41921 --- /dev/null +++ b/fix-malloc-p2.patch @@ -0,0 +1,249 @@ +commit 0dc7fc1cf094406a138e4d1bcf9553e59edcf89d +Author: Florian Weimer +Date: Thu Aug 10 19:36:56 2023 +0200 + + malloc: Remove bin scanning from memalign (bug 30723) + + On the test workload (mpv --cache=yes with VP9 video decoding), the + bin scanning has a very poor success rate (less than 2%). The tcache + scanning has about 50% success rate, so keep that. + + Update comments in malloc/tst-memalign-2 to indicate the purpose + of the tests. Even with the scanning removed, the additional + merging opportunities since commit 542b1105852568c3ebc712225ae78b + ("malloc: Enable merging of remainders in memalign (bug 30723)") + are sufficient to pass the existing large bins test. + + Remove leftover variables from _int_free from refactoring in the + same commit. + + Reviewed-by: DJ Delorie + +diff --git a/malloc/malloc.c b/malloc/malloc.c +index 948f9759af..d0bbbf3710 100644 +--- a/malloc/malloc.c ++++ b/malloc/malloc.c +@@ -4488,12 +4488,6 @@ _int_free (mstate av, mchunkptr p, int have_lock) + { + INTERNAL_SIZE_T size; /* its size */ + mfastbinptr *fb; /* associated fastbin */ +- mchunkptr nextchunk; /* next contiguous chunk */ +- INTERNAL_SIZE_T nextsize; /* its size */ +- int nextinuse; /* true if nextchunk is used */ +- INTERNAL_SIZE_T prevsize; /* size of previous contiguous chunk */ +- mchunkptr bck; /* misc temp for linking */ +- mchunkptr fwd; /* misc temp for linking */ + + size = chunksize (p); + +@@ -5032,42 +5026,6 @@ _int_realloc (mstate av, mchunkptr oldp, INTERNAL_SIZE_T oldsize, + ------------------------------ memalign ------------------------------ + */ + +-/* Returns 0 if the chunk is not and does not contain the requested +- aligned sub-chunk, else returns the amount of "waste" from +- trimming. NB is the *chunk* byte size, not the user byte +- size. */ +-static size_t +-chunk_ok_for_memalign (mchunkptr p, size_t alignment, size_t nb) +-{ +- void *m = chunk2mem (p); +- INTERNAL_SIZE_T size = chunksize (p); +- void *aligned_m = m; +- +- if (__glibc_unlikely (misaligned_chunk (p))) +- malloc_printerr ("_int_memalign(): unaligned chunk detected"); +- +- aligned_m = PTR_ALIGN_UP (m, alignment); +- +- INTERNAL_SIZE_T front_extra = (intptr_t) aligned_m - (intptr_t) m; +- +- /* We can't trim off the front as it's too small. */ +- if (front_extra > 0 && front_extra < MINSIZE) +- return 0; +- +- /* If it's a perfect fit, it's an exception to the return value rule +- (we would return zero waste, which looks like "not usable"), so +- handle it here by returning a small non-zero value instead. */ +- if (size == nb && front_extra == 0) +- return 1; +- +- /* If the block we need fits in the chunk, calculate total waste. */ +- if (size > nb + front_extra) +- return size - nb; +- +- /* Can't use this chunk. */ +- return 0; +-} +- + /* BYTES is user requested bytes, not requested chunksize bytes. */ + static void * + _int_memalign (mstate av, size_t alignment, size_t bytes) +@@ -5082,7 +5040,6 @@ _int_memalign (mstate av, size_t alignment, size_t bytes) + mchunkptr remainder; /* spare room at end to split off */ + unsigned long remainder_size; /* its size */ + INTERNAL_SIZE_T size; +- mchunkptr victim; + + nb = checked_request2size (bytes); + if (nb == 0) +@@ -5101,129 +5058,13 @@ _int_memalign (mstate av, size_t alignment, size_t bytes) + we don't find anything in those bins, the common malloc code will + scan starting at 2x. */ + +- /* This will be set if we found a candidate chunk. */ +- victim = NULL; +- +- /* Fast bins are singly-linked, hard to remove a chunk from the middle +- and unlikely to meet our alignment requirements. We have not done +- any experimentation with searching for aligned fastbins. */ +- +- if (av != NULL) +- { +- int first_bin_index; +- int first_largebin_index; +- int last_bin_index; +- +- if (in_smallbin_range (nb)) +- first_bin_index = smallbin_index (nb); +- else +- first_bin_index = largebin_index (nb); +- +- if (in_smallbin_range (nb * 2)) +- last_bin_index = smallbin_index (nb * 2); +- else +- last_bin_index = largebin_index (nb * 2); +- +- first_largebin_index = largebin_index (MIN_LARGE_SIZE); +- +- int victim_index; /* its bin index */ +- +- for (victim_index = first_bin_index; +- victim_index < last_bin_index; +- victim_index ++) +- { +- victim = NULL; +- +- if (victim_index < first_largebin_index) +- { +- /* Check small bins. Small bin chunks are doubly-linked despite +- being the same size. */ +- +- mchunkptr fwd; /* misc temp for linking */ +- mchunkptr bck; /* misc temp for linking */ +- +- bck = bin_at (av, victim_index); +- fwd = bck->fd; +- while (fwd != bck) +- { +- if (chunk_ok_for_memalign (fwd, alignment, nb) > 0) +- { +- victim = fwd; +- +- /* Unlink it */ +- victim->fd->bk = victim->bk; +- victim->bk->fd = victim->fd; +- break; +- } +- +- fwd = fwd->fd; +- } +- } +- else +- { +- /* Check large bins. */ +- mchunkptr fwd; /* misc temp for linking */ +- mchunkptr bck; /* misc temp for linking */ +- mchunkptr best = NULL; +- size_t best_size = 0; +- +- bck = bin_at (av, victim_index); +- fwd = bck->fd; ++ /* Call malloc with worst case padding to hit alignment. */ ++ m = (char *) (_int_malloc (av, nb + alignment + MINSIZE)); + +- while (fwd != bck) +- { +- int extra; +- +- if (chunksize (fwd) < nb) +- break; +- extra = chunk_ok_for_memalign (fwd, alignment, nb); +- if (extra > 0 +- && (extra <= best_size || best == NULL)) +- { +- best = fwd; +- best_size = extra; +- } ++ if (m == 0) ++ return 0; /* propagate failure */ + +- fwd = fwd->fd; +- } +- victim = best; +- +- if (victim != NULL) +- { +- unlink_chunk (av, victim); +- break; +- } +- } +- +- if (victim != NULL) +- break; +- } +- } +- +- /* Strategy: find a spot within that chunk that meets the alignment +- request, and then possibly free the leading and trailing space. +- This strategy is incredibly costly and can lead to external +- fragmentation if header and footer chunks are unused. */ +- +- if (victim != NULL) +- { +- p = victim; +- m = chunk2mem (p); +- set_inuse (p); +- if (av != &main_arena) +- set_non_main_arena (p); +- } +- else +- { +- /* Call malloc with worst case padding to hit alignment. */ +- +- m = (char *) (_int_malloc (av, nb + alignment + MINSIZE)); +- +- if (m == 0) +- return 0; /* propagate failure */ +- +- p = mem2chunk (m); +- } ++ p = mem2chunk (m); + + if ((((unsigned long) (m)) % alignment) != 0) /* misaligned */ + { +diff --git a/malloc/tst-memalign-2.c b/malloc/tst-memalign-2.c +index f229283dbf..ecd6fa249e 100644 +--- a/malloc/tst-memalign-2.c ++++ b/malloc/tst-memalign-2.c +@@ -86,7 +86,8 @@ do_test (void) + TEST_VERIFY (tcache_allocs[i].ptr1 == tcache_allocs[i].ptr2); + } + +- /* Test for non-head tcache hits. */ ++ /* Test for non-head tcache hits. This exercises the memalign ++ scanning code to find matching allocations. */ + for (i = 0; i < array_length (ptr); ++ i) + { + if (i == 4) +@@ -113,7 +114,9 @@ do_test (void) + free (p); + TEST_VERIFY (count > 0); + +- /* Large bins test. */ ++ /* Large bins test. This verifies that the over-allocated parts ++ that memalign releases for future allocations can be reused by ++ memalign itself at least in some cases. */ + + for (i = 0; i < LN; ++ i) + { diff --git a/glibc.install b/glibc.install new file mode 100644 index 0000000..6d5bc35 --- /dev/null +++ b/glibc.install @@ -0,0 +1,3 @@ +post_upgrade() { + ldconfig -r . +} diff --git a/keys/pgp/7273542B39962DF7B299931416792B4EA25340F8.asc b/keys/pgp/7273542B39962DF7B299931416792B4EA25340F8.asc new file mode 100644 index 0000000..484dd1a --- /dev/null +++ b/keys/pgp/7273542B39962DF7B299931416792B4EA25340F8.asc @@ -0,0 +1,56 @@ +-----BEGIN PGP PUBLIC KEY BLOCK----- + +mQINBFef5BoBEACvJ15QMMZh4stKHbz0rs78XsOdxuug37dumTx6ngrDCwZ61k7n +HQ+uxLuoQvLSc6YJGBEfiNFbs1hvhRFNR7xJbzRYmin7kJZZ/06fH2cgTkQhN0mR +BP8KsKKT+7SvvBL785ZfAhArWf5m5Tl0CktZ8yoG8g9dM4SgdvdSdzZUaWBVHc6T +jdAb9YEQ1/jpyfHsQp+PWLuQZI8nZUm+I3IBDLkbbuJVQklKzpT1b8yxVSsHCyIP +FRqDDUjPL5G4WnUVy529OzfrciBvHdxGsYYDV8FX7fv6V/S3eL6qmZbObivIbLD2 +NbeDqw6vNpr+aehEwgwNbMVuVfH1PVHJV8Qkgxg4PqPgQC7GbIhxxYroGbLJCQ41 +j25M+oqCO/XW/FUu/9x0vY5w0RsZFhlmSP5lBDcaiy3SUgp3MSTePGuxpPlLVMeP +xKvabSS7EErLKlrAEmDgnUYYdPqGCefA+5N9Rn2JPfP7SoQEp2pHhEyM6Xg9x7TJ ++JNuDowQCgwussmeDt2ZUeMl3s1f6/XePfTd3l8c8Yn5Fc8reRa28dFANU6oXiZf +7/h3iQXPg81BsLMJK3aA/nyajRrNxL8dHIx7BjKX0/gxpOozlUHZHl73KhAvrBRa +qLrr2tIPLkKrf3d7wdz4llg4NAGIU4ERdTTne1QAwS6x2tNa9GO9tXGPawARAQAB +tClDYXJsb3MgTydEb25lbGwgPGNhcmxvc0BzeXN0ZW1oYWx0ZWQub3JnPokCWAQT +AQgAQgIbAwYLCQgHAwIGFQgCCQoLBBYCAwECHgECF4ACGQEWIQRyc1QrOZYt97KZ +kxQWeStOolNA+AUCXxkICAUJCzuK7gAKCRAWeStOolNA+LYKD/45UnrTH28tppSy +QVi2V0hDqghi4OEw0KxUfemz/rgNhmhafZx1574g5DBG6hiP6VLZ2GunO4r2+pRj +7sBs2IYCr8pf/sdWdJVArO13zMm+1qSSd8gG044IyXx5cjgxCKk7tkaJ5wg+7q2h +COGa+ie4fb4/XMl8SP2u3RioDA1yxnmxqEWvwqsqn+JLuxrzrA9KgwzreKj36RJb +KnhSc1nDxze0MLBmDEixtbgDvV4xaTMw9kw39LaIE4qZ4NF4tyEH/8X67ZnVtGfj +vusqiQa2Vk5Bz4gmbyZbTVtrKod2Y+u6ZebhSXoq/egjhcoDOgoKWq/hMrAitJEh +jLgiq+9zzlmpqq4qkXVlQ/s0eYTsZPH11fK5hO/6b2+rfruJaYmqKM/LzwqpeR8m +xEqvgBjgfn+SjG78Xod4qT1/kCOlpVO/9ZdI0j0v232BvOtNbP2nWyCjcy2mkppv +594ttPRmQ8C1yx7XlPmRojcOFpEfgdZ2kNA3sSgVibjjeVjPKC1UWwsua1lCMG2y +qkp33+fot8HWA13DfXBdjeaC7Q69XZlHLSBh0Qx8crRVhfNYMxmZpoTZfkW3Sy6U +qjSrvHU8ext1xCBdZhlM2m6SE5R6XKlY90U5as7lIoTdGd9pfUzazes1U6ChPIS2 +A8lbCo/chVog/fTrOvqmi4J79l0P1rQqQ2FybG9zIE8nRG9uZWxsIChXb3JrKSA8 +Y2FybG9zQHJlZGhhdC5jb20+iQJVBBMBCAA/AhsDBgsJCAcDAgYVCAIJCgsEFgID +AQIeAQIXgBYhBHJzVCs5li33spmTFBZ5K06iU0D4BQJfGQgOBQkLO4ruAAoJEBZ5 +K06iU0D4uewP/A+4gHGPoqiDddrmg/C41mHOB3bQJHQKmeyfKmsu1zZI/QQw2MHQ +OdjFeHgok22P/TI/O/Ocsxsq8q9MDfHKQdWpcPWeUnOGyldtmDjlcAgsI4wmNKiV +Z63uFs8VV9eBeofs/dNp7zVx+nwrkvsjuA77DH93aZqH9rVMSR5qXoMjlBaofOga +wAmFVX/9Uf+mEaY8VNYTMe3eOAZIGrB711OwUQxQDTcZLTu2//x62PF/1413ZtBL ++ApVCW2jk1A8RnmkDWv8li61z0TMzE3dyDK9L+7GhTvEy0DuW7Fsf4GEHGVo9Fbz +eQpOHgpIV27DV2JSvEl/TCVN8wb1Obpo7OmXPtPF7IJgcs/UOFqhL174D5Y36i/T +JPiBMWkzEMYhUE0f3ZqRksHeFEtRSmkfnJf25XV3Rgc17RAZmoK0MG9mO8ncKcGb +1utOGq396uI8X8pEZ0kqOAFxDQEcyoy9qNoBi41Dr/0WTRY0mtFdgtbfqMr0gDZ+ +FDXFBZ4roGJgryltjznLN2XMV2vQtpBqscUZl/bZP31YjJoSv9sVcTxkZLkxAr+2 +8X5miVjAw8ZN5AhzPnhuz6q/ZRL/MZum6JWx/nQH7bbdllMUJPT5fb1dptO7YCsW +wj39XAVxciakA/DocnW1CzN/gp/noRojL/dlcHn5kFsInfOFVeI1zH5ItCxDYXJs +b3MgTydEb25lbGwgKFdvcmspIDxjb2RvbmVsbEByZWRoYXQuY29tPokCVQQTAQgA +PwIbAwYLCQgHAwIGFQgCCQoLBBYCAwECHgECF4AWIQRyc1QrOZYt97KZkxQWeStO +olNA+AUCXxkIDgUJCzuK7gAKCRAWeStOolNA+OPkD/9GUwdXKLXNtZpLi5rZ2VZi +yUd6SIJ9CW7BScNtOc5QaNhawH4FBoVjz7jjomio0JihMAfdlibDJ2+Rn2UtmrJ6 +/9hAB8Hv9zSRKVKkVN74Xoy78yr3FXsR3jydvb3ZM2EsLr1leTf5v8TRArsVPhGH +K0X4RMhtkXJvI/fliZgnC7vqCLFk+nXznVFB/LCWOOehiU2/+wtaJZTTXI5/Ogn2 +LNLkvx7ZRD8xumcjMtZZONILOjjcPa+JZIGE1uJ6LUQs3Z8Dkh5BNgLLQSgPwVxK +qup7g6WUWGKEIp/tpRpVDZPuYvJLEJTCJUV1TWkFCXHDQDoRrYImn5y1fNcuMRJu +W8y7oepsI16CptAIoQKkhC8ojdy3GgKgMDzyjxtRA2PxlZ+78+80HBjCv7duEjx4 +yNpfoDF/60nZ/g2ZeeworoOK8bNbAWZ5EO10NbLjIMuvS5OnTE8GS0UZEu91wrBx +yyYHxaFWkIAZcF41dGj5FrsJNLdjoLGFqLjMFJw9mXm+eD36Cb76AfzGGeeMWuPZ +A8OM8tYftwT2velI2tVQUeWOH2KzS+noRDSkD4D84VWBROOFhp7ww7nPz2MTDpjG +OLWvTPdljob3Z7418Ih/6KuZSN0GDlScmZQIl52gri52hGdbIxLwTMGFqD072m5+ +hRUYRIMEBuHSKz3rNrJkKw== +=CWf2 +-----END PGP PUBLIC KEY BLOCK----- diff --git a/keys/pgp/BC7C7372637EC10C57D7AA6579C43DFBF1CF2187.asc b/keys/pgp/BC7C7372637EC10C57D7AA6579C43DFBF1CF2187.asc new file mode 100644 index 0000000..67d0c96 --- /dev/null +++ b/keys/pgp/BC7C7372637EC10C57D7AA6579C43DFBF1CF2187.asc @@ -0,0 +1,68 @@ +-----BEGIN PGP PUBLIC KEY BLOCK----- + +mQENBFMAZNMBCACeatEKl6YY9iEVxzS64bPbvJsA1mLE2XFWmKXyYzm58dFqPMa0 +OQQTKCxjFCOrc+LD2KtmypttcahKnk5Lk1lNU/lV2hCuR7jJ37sL+/TFQuMMgsLP +ED6XU4/AYK3VUJvgGYLBnMVfpAGYLB5rnPvhFNx0r2KItO/CfiSEyD4g1Wu26SUA +XGOp5hbSyBRGhju+8YJlhHBBjn3vZfw7IpwAWDVjK0crqMhGDXoZwK+ADUFY5NER +AkT3Lb7d11F6+W4558WQZCYIWa3rZ62d986OE7+7xKmJUcLLWvlv5spgUmvotZ4D +MzaKba+waY5ygXdGIpm5seVIEUCTaBIe6QVLABEBAAG0KFNpZGRoZXNoIFBveWFy +ZWthciA8c2lkZGhlc2hAZ290cGx0Lm9yZz6JATgEEwECACIFAle0y0wCGwMGCwkI +BwMCBhUIAgkKCwQWAgMBAh4BAheAAAoJEHnEPfvxzyGHUggIAJtLMvzHjRQi/Dg6 +oSMUMPtH7oEmgnk482dC4MGNl/bCtUV7VVIAtEN5TGvHxk1EKBNqj49Q+mZjef82 +iluW1RbXRY6+72yZ380yUC41SY+2hVOurJ//h3nvE+YHfO7QjV97yhIegc1kdwAr +VtgNNApLxj5Nc2epT824uaSznVhwyAS2OIHFLmiMYuIW338uXVEug1XKBHwJ9Mpp +Vblk4zapc9fRGvRG72ivbTGXNgcza+Kkx1IdA0XB2dEQaAE1XR0FOshKtpeSDRER +wZ17+rRT8EjmkRsR7qm1uvPSNW7wMTtlj8ox/XuSyG0Coy1NRgqe5bi53ha1kBoK +lLaxvyW0KFNpZGRoZXNoIFBveWFyZWthciA8c2lkZGhlc2hAcmVkaGF0LmNvbT6J +AT4EMAECACgFAljc8cohHSBObyBsb25nZXIgZW1wbG95ZWQgd2l0aCBSZWQgSGF0 +AAoJEHnEPfvxzyGHhvoH/3KWe6JIWptc283au0UROXog3VdBFM3pE6SgMhOlFTM2 +r9fU24rvsTZgAMC7N7TxDil0JajMR6CYXoapDncuRs4u27D4uK/oUqHxL6CHuDKw +GwURM9OjqV1kJY1gPYn9IZL3XHejg/YwxodGKK4jRJrL0prR5HSiR6QyQVgJ886D +pOyHGqUwi5GGLZVAgwo9NBsr2GEmXMBmwGU44g+UuCSBiySvXwsBDDx2j34Q166t +eoz+CHsIf4J3UPv2nIR6L0EvboTw39m55aTlyJ3dPHh8OeKwTAZCFzzOv0WxINcC +fVWnL138fOkILt4u12Tv7D2K99PI/bYv1Xeal+zRtBO0KFNpZGRoZXNoIFBveWFy +ZWthciA8c3BveWFyZWtAcmVkaGF0LmNvbT6JAT4EMAECACgFAljc8awhHSBObyBs +b25nZXIgZW1wbG95ZWQgd2l0aCBSZWQgSGF0AAoJEHnEPfvxzyGHT5UH/0eeAKeR +jobfz+8n98UgYzPZnihlS1yd8wznaVThm0cgqUp1hu3NIHuDiirr/VCRwxqP+hmJ +ulwnQsJZwMllf2riFxbnnun4VBeocENxqE/m5EHLHjKkZklhYJSxbxWysXt7BYZb +7+2S3zvlP7TCl2Hb7JhdJgUiOdondBBWAygA+uxolabetIv6X3v8evr+H87PMeOw +lcaTxO2DXPAAsGDqxPJNSzVtiB5WEz6/2fRhsSGkisDSZTs5d/SL+lLS/FfRR2NT +SN20+2/eepzMJM5fyoV9vVkytI3XxhQsepeMya34DEP92ltJnhnG/tToUvHVttOd +IIVwZtDWIYwSg6a0KVNpZGRoZXNoIFBveWFyZWthciA8c2lkQHJlc2VydmVkLWJp +dC5jb20+iQE3BBMBCAAhBQJVwGR2AhsDBQsJCAcCBhUICQoLAgQWAgMBAh4BAheA +AAoJEHnEPfvxzyGHPs8H/3BzCbDhXI1txfjYCCUDJwDMtY2iqcHINZb7LPGJGDbx +vuAwEgJcbrpK6QlbAqBXAg4hwBOzM+CLZRPRQ0g4hBsNQv1m+1WIJdbUfS9ZL4O9 +XPWSHYdKY0U+83XPyaValGOPMvSb2glOy2RRRC+CECN9CaQNbfJo91ZfmMk3waNb +EpZ6Te04vZ9zdoRHz3D7qhr2U2Hazlvv6P9TGqKFRbEbMgMxBJM7L6WiiBhFIIyB +D4N0NaB0xnc1JB1fwpfrRfRT9CPWeqmeXvnt0bGJAlzpG7tc3d0evva2mMVTooyq +C8vXiCRsszcrG5NYOPYkgnt0ahqivVGXd/5F57tMtGq0PFNpZGRoZXNoIFBveWFy +ZWthciAoUGVyc29uYWwpIDxzaWRkaGVzaC5wb3lhcmVrYXJAZ21haWwuY29tPokB +OAQTAQIAIgIbAwYLCQgHAwIGFQgCCQoLBBYCAwECHgECF4AFAlTqsncACgkQecQ9 ++/HPIYd28Qf9GfOK+VgDxaTzyixbGHWVWpk1nie67BdPvaorTb1jOUVsI582jKO+ +WDIKmI2PTFk9RwsN47q4s/QyN8oCjgYCYmuj+cse8Zh5acEJx2ENJRmP0QLJU3eK +IQMxKJ7SG4UHyVBlqdchWryZq5KDGbAKf3WtMhgBzr825UnybImpZ7qPfJM8u78y +jHPQvBKkKaAzhVwC65Lt+ESQA9+EZqvYeEwlYpAq5gmKKaD/QialyI/8FEsshBqw +DdLzFMMDSjFxVukjiC5t3WJvFz52v+tzEXE0HZsV26p/LrPSA+cei/s75FBmw9qz +4AM0YDOrEaeEG+CSSPLGgQYFYMp1EX+LvrRFU2lkZGhlc2ggUG95YXJla2FyICho +dHRwczovL3NvdXJjZXdhcmUub3JnKSA8c2lkZGhlc2hAc291cmNld2FyZS5vcmc+ +iQE4BBMBAgAiBQJXtMr3AhsDBgsJCAcDAgYVCAIJCgsEFgIDAQIeAQIXgAAKCRB5 +xD378c8hh6doB/49aFm02tJCigXO7NrWRg7esjdQT66g8/LYYa2O3oHef6yACSmt +bdJWpbZ5aReRledYcsI1WVtLgUHOchrspeKVO6KWAA5cFMDjRhMP0ArhxyL4KDqz +U9AHpo3t9bYBGKNfH9Df3a0rVknkIB9NyENPAJpbJOdrND0TDWXhyOHLGsFC6WuE +MtQudfSKMOhKFqySN0xZQUKlb11n2MT479gqlw7o/UPDy1gDtssG+zG9DD72Xkq3 +lbzzthM/e7ldcB8dMRoVLl9e1XZLoOfL/RAV/z9UxHezRjjYDV69EPxzKsgj+Id3 +AzmY9XeSqUeDWX17z6ARV0mh4uGePEriEmPCuQENBFMAZNMBCAChC0iEpSfa897U +gTzZKcqsCD5+P/2QbhDSUHyFiFmDPa+9rAUR2YIopbDeyu4OhGu7y1FYL+fliJxO +D1hUGqlEmzLm047IZ2iACHklNK7JcEUartgfR5kvJmqwflGHUPjLD1RCJ6wfLq6B +X/CYe4ftjqrNjClDLGsqBckJFbcIdxyPwDE5Jiuorp9wIpDivifVi0MdkKn/ny42 +Of2SI26MG3fBitweIeJFD23lCOUzYOsXClcsVTzMvB2s32g8JVB34dOytFBVrWhb +sPb97ZWonjkyx9A9HAV8mEwKoLOwuunMrccPkK+v/rh2vDDERA0MExBMMInJN4dI +fryIQrFdABEBAAGJAR8EGAECAAkCGwwFAlTqs98ACgkQecQ9+/HPIYf1Mwf9ENd6 +C/2kvJJvbFzmvDNa6EOvTVKaqTBDhgVjuZ2ivMGdkCoeA9OQ3zWu8k+RYDyyPmuJ +HToFm1tn4hP8DGDjIr46Bb3jnZcz6bHsOp9quf3L6KbKa4ghiVqM05ML9Xb/YH0y +ge3QybfiAnWm6e2qIbzYucXmYDOBsQojta369CZ+zQEdy+baULFQ+Hg02vY4NKqv +xIhfri0B/Ng+m7MbUv163u2/7Eyit4xOrLYbouuMOxd1+TNasJPFwrKgjQNWdnPs +1pCxh+GXgf0a8WqbtB9P0wIQQbWw6OuuRmkW9zUisxuKyUo10hEHOK52v2O/7N3P +bgdMo3cl19PJpx81Tg== +=RgMn +-----END PGP PUBLIC KEY BLOCK----- diff --git a/lib32-glibc.conf b/lib32-glibc.conf new file mode 100644 index 0000000..9b08c3f --- /dev/null +++ b/lib32-glibc.conf @@ -0,0 +1 @@ +/usr/lib32 diff --git a/reenable_DT_HASH.patch b/reenable_DT_HASH.patch new file mode 100644 index 0000000..87a2329 --- /dev/null +++ b/reenable_DT_HASH.patch @@ -0,0 +1,28 @@ +From 31915e55f9c34f6137ab1c5ac002375a2d5d4589 Mon Sep 17 00:00:00 2001 +From: Frederik Schwan +Date: Fri, 4 Aug 2023 15:19:57 +0200 +Subject: [PATCH] force --hash-style=both to keep compatibility with old niche + software + +--- + Makeconfig | 4 ++++ + 1 file changed, 4 insertions(+) + +diff --git a/Makeconfig b/Makeconfig +index 77d7fd14df..2ae67c4beb 100644 +--- a/Makeconfig ++++ b/Makeconfig +@@ -378,6 +378,10 @@ relro-LDFLAGS = -Wl,-z,relro + LDFLAGS.so += $(relro-LDFLAGS) + LDFLAGS-rtld += $(relro-LDFLAGS) + ++hashstyle-LDFLAGS = -Wl,--hash-style=both ++LDFLAGS.so += $(hashstyle-LDFLAGS) ++LDFLAGS-rtld += $(hashstyle-LDFLAGS) ++ + # Linker options to enable and disable DT_RELR. + ifeq ($(have-dt-relr),yes) + dt-relr-ldflag = -Wl,-z,pack-relative-relocs +-- +2.41.0 + diff --git a/sdt-config.h b/sdt-config.h new file mode 100644 index 0000000..733045a --- /dev/null +++ b/sdt-config.h @@ -0,0 +1,6 @@ +/* includes/sys/sdt-config.h. Generated from sdt-config.h.in by configure. + + This file just defines _SDT_ASM_SECTION_AUTOGROUP_SUPPORT to 0 or 1 to + indicate whether the assembler supports "?" in .pushsection directives. */ + +#define _SDT_ASM_SECTION_AUTOGROUP_SUPPORT 1 diff --git a/sdt.h b/sdt.h new file mode 100644 index 0000000..c0c5a49 --- /dev/null +++ b/sdt.h @@ -0,0 +1,430 @@ +/* - Systemtap static probe definition macros. + + This file is dedicated to the public domain, pursuant to CC0 + (https://creativecommons.org/publicdomain/zero/1.0/) +*/ + +#ifndef _SYS_SDT_H +#define _SYS_SDT_H 1 + +/* + This file defines a family of macros + + STAP_PROBEn(op1, ..., opn) + + that emit a nop into the instruction stream, and some data into an auxiliary + note section. The data in the note section describes the operands, in terms + of size and location. Each location is encoded as assembler operand string. + Consumer tools such as gdb or systemtap insert breakpoints on top of + the nop, and decode the location operand-strings, like an assembler, + to find the values being passed. + + The operand strings are selected by the compiler for each operand. + They are constrained by gcc inline-assembler codes. The default is: + + #define STAP_SDT_ARG_CONSTRAINT nor + + This is a good default if the operands tend to be integral and + moderate in number (smaller than number of registers). In other + cases, the compiler may report "'asm' requires impossible reload" or + similar. In this case, consider simplifying the macro call (fewer + and simpler operands), reduce optimization, or override the default + constraints string via: + + #define STAP_SDT_ARG_CONSTRAINT g + #include + + See also: + https://sourceware.org/systemtap/wiki/UserSpaceProbeImplementation + https://gcc.gnu.org/onlinedocs/gcc/Constraints.html + */ + + + +#ifdef __ASSEMBLER__ +# define _SDT_PROBE(provider, name, n, arglist) \ + _SDT_ASM_BODY(provider, name, _SDT_ASM_STRING_1, (_SDT_DEPAREN_##n arglist)) \ + _SDT_ASM_BASE +# define _SDT_ASM_1(x) x; +# define _SDT_ASM_2(a, b) a,b; +# define _SDT_ASM_3(a, b, c) a,b,c; +# define _SDT_ASM_5(a, b, c, d, e) a,b,c,d,e; +# define _SDT_ASM_STRING_1(x) .asciz #x; +# define _SDT_DEPAREN_0() /* empty */ +# define _SDT_DEPAREN_1(a) a +# define _SDT_DEPAREN_2(a,b) a b +# define _SDT_DEPAREN_3(a,b,c) a b c +# define _SDT_DEPAREN_4(a,b,c,d) a b c d +# define _SDT_DEPAREN_5(a,b,c,d,e) a b c d e +# define _SDT_DEPAREN_6(a,b,c,d,e,f) a b c d e f +# define _SDT_DEPAREN_7(a,b,c,d,e,f,g) a b c d e f g +# define _SDT_DEPAREN_8(a,b,c,d,e,f,g,h) a b c d e f g h +# define _SDT_DEPAREN_9(a,b,c,d,e,f,g,h,i) a b c d e f g h i +# define _SDT_DEPAREN_10(a,b,c,d,e,f,g,h,i,j) a b c d e f g h i j +# define _SDT_DEPAREN_11(a,b,c,d,e,f,g,h,i,j,k) a b c d e f g h i j k +# define _SDT_DEPAREN_12(a,b,c,d,e,f,g,h,i,j,k,l) a b c d e f g h i j k l +#else +# define _SDT_PROBE(provider, name, n, arglist) \ + do { \ + __asm__ __volatile__ (_SDT_ASM_BODY(provider, name, _SDT_ASM_ARGS, (n)) \ + :: _SDT_ASM_OPERANDS_##n arglist); \ + __asm__ __volatile__ (_SDT_ASM_BASE); \ + } while (0) +# define _SDT_S(x) #x +# define _SDT_ASM_1(x) _SDT_S(x) "\n" +# define _SDT_ASM_2(a, b) _SDT_S(a) "," _SDT_S(b) "\n" +# define _SDT_ASM_3(a, b, c) _SDT_S(a) "," _SDT_S(b) "," \ + _SDT_S(c) "\n" +# define _SDT_ASM_5(a, b, c, d, e) _SDT_S(a) "," _SDT_S(b) "," \ + _SDT_S(c) "," _SDT_S(d) "," \ + _SDT_S(e) "\n" +# define _SDT_ASM_ARGS(n) _SDT_ASM_STRING(_SDT_ASM_TEMPLATE_##n) +# define _SDT_ASM_STRING_1(x) _SDT_ASM_1(.asciz #x) + +# define _SDT_ARGFMT(no) %n[_SDT_S##no]@_SDT_ARGTMPL(_SDT_A##no) + +# ifndef STAP_SDT_ARG_CONSTRAINT +# if defined __powerpc__ +# define STAP_SDT_ARG_CONSTRAINT nZr +# else +# define STAP_SDT_ARG_CONSTRAINT nor +# endif +# endif + +# define _SDT_STRINGIFY(x) #x +# define _SDT_ARG_CONSTRAINT_STRING(x) _SDT_STRINGIFY(x) +# define _SDT_ARG(n, x) \ + [_SDT_S##n] "n" ((_SDT_ARGSIGNED (x) ? 1 : -1) * (int) _SDT_ARGSIZE (x)), \ + [_SDT_A##n] _SDT_ARG_CONSTRAINT_STRING (STAP_SDT_ARG_CONSTRAINT) (_SDT_ARGVAL (x)) +#endif +#define _SDT_ASM_STRING(x) _SDT_ASM_STRING_1(x) + +#define _SDT_ARGARRAY(x) (__builtin_classify_type (x) == 14 \ + || __builtin_classify_type (x) == 5) + +#ifdef __cplusplus +# define _SDT_ARGSIGNED(x) (!_SDT_ARGARRAY (x) \ + && __sdt_type<__typeof (x)>::__sdt_signed) +# define _SDT_ARGSIZE(x) (_SDT_ARGARRAY (x) \ + ? sizeof (void *) : sizeof (x)) +# define _SDT_ARGVAL(x) (x) + +# include + +template +struct __sdt_type +{ + static const bool __sdt_signed = false; +}; + +#define __SDT_ALWAYS_SIGNED(T) \ +template<> struct __sdt_type { static const bool __sdt_signed = true; }; +#define __SDT_COND_SIGNED(T,CT) \ +template<> struct __sdt_type { static const bool __sdt_signed = ((CT)(-1) < 1); }; +__SDT_ALWAYS_SIGNED(signed char) +__SDT_ALWAYS_SIGNED(short) +__SDT_ALWAYS_SIGNED(int) +__SDT_ALWAYS_SIGNED(long) +__SDT_ALWAYS_SIGNED(long long) +__SDT_ALWAYS_SIGNED(volatile signed char) +__SDT_ALWAYS_SIGNED(volatile short) +__SDT_ALWAYS_SIGNED(volatile int) +__SDT_ALWAYS_SIGNED(volatile long) +__SDT_ALWAYS_SIGNED(volatile long long) +__SDT_ALWAYS_SIGNED(const signed char) +__SDT_ALWAYS_SIGNED(const short) +__SDT_ALWAYS_SIGNED(const int) +__SDT_ALWAYS_SIGNED(const long) +__SDT_ALWAYS_SIGNED(const long long) +__SDT_ALWAYS_SIGNED(const volatile signed char) +__SDT_ALWAYS_SIGNED(const volatile short) +__SDT_ALWAYS_SIGNED(const volatile int) +__SDT_ALWAYS_SIGNED(const volatile long) +__SDT_ALWAYS_SIGNED(const volatile long long) +__SDT_COND_SIGNED(char, char) +__SDT_COND_SIGNED(wchar_t, wchar_t) +__SDT_COND_SIGNED(volatile char, char) +__SDT_COND_SIGNED(volatile wchar_t, wchar_t) +__SDT_COND_SIGNED(const char, char) +__SDT_COND_SIGNED(const wchar_t, wchar_t) +__SDT_COND_SIGNED(const volatile char, char) +__SDT_COND_SIGNED(const volatile wchar_t, wchar_t) +#if defined (__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 4)) +/* __SDT_COND_SIGNED(char16_t) */ +/* __SDT_COND_SIGNED(char32_t) */ +#endif + +template +struct __sdt_type<__sdt_E[]> : public __sdt_type<__sdt_E *> {}; + +template +struct __sdt_type<__sdt_E[__sdt_N]> : public __sdt_type<__sdt_E *> {}; + +#elif !defined(__ASSEMBLER__) +__extension__ extern unsigned long long __sdt_unsp; +# define _SDT_ARGINTTYPE(x) \ + __typeof (__builtin_choose_expr (((__builtin_classify_type (x) \ + + 3) & -4) == 4, (x), 0U)) +# define _SDT_ARGSIGNED(x) \ + (!__extension__ \ + (__builtin_constant_p ((((unsigned long long) \ + (_SDT_ARGINTTYPE (x)) __sdt_unsp) \ + & ((unsigned long long)1 << (sizeof (unsigned long long) \ + * __CHAR_BIT__ - 1))) == 0) \ + || (_SDT_ARGINTTYPE (x)) -1 > (_SDT_ARGINTTYPE (x)) 0)) +# define _SDT_ARGSIZE(x) \ + (_SDT_ARGARRAY (x) ? sizeof (void *) : sizeof (x)) +# define _SDT_ARGVAL(x) (x) +#endif + +#if defined __powerpc__ || defined __powerpc64__ +# define _SDT_ARGTMPL(id) %I[id]%[id] +#elif defined __i386__ +# define _SDT_ARGTMPL(id) %w[id] /* gcc.gnu.org/PR80115 */ +#else +# define _SDT_ARGTMPL(id) %[id] +#endif + +#ifdef __LP64__ +# define _SDT_ASM_ADDR .8byte +#else +# define _SDT_ASM_ADDR .4byte +#endif + +/* The ia64 and s390 nop instructions take an argument. */ +#if defined(__ia64__) || defined(__s390__) || defined(__s390x__) +#define _SDT_NOP nop 0 +#else +#define _SDT_NOP nop +#endif + +#define _SDT_NOTE_NAME "stapsdt" +#define _SDT_NOTE_TYPE 3 + +/* If the assembler supports the necessary feature, then we can play + nice with code in COMDAT sections, which comes up in C++ code. + Without that assembler support, some combinations of probe placements + in certain kinds of C++ code may produce link-time errors. */ +#include "sdt-config.h" +#if _SDT_ASM_SECTION_AUTOGROUP_SUPPORT +# define _SDT_ASM_AUTOGROUP "?" +#else +# define _SDT_ASM_AUTOGROUP "" +#endif + +#define _SDT_ASM_BODY(provider, name, pack_args, args) \ + _SDT_ASM_1(990: _SDT_NOP) \ + _SDT_ASM_3( .pushsection .note.stapsdt,_SDT_ASM_AUTOGROUP,"note") \ + _SDT_ASM_1( .balign 4) \ + _SDT_ASM_3( .4byte 992f-991f, 994f-993f, _SDT_NOTE_TYPE) \ + _SDT_ASM_1(991: .asciz _SDT_NOTE_NAME) \ + _SDT_ASM_1(992: .balign 4) \ + _SDT_ASM_1(993: _SDT_ASM_ADDR 990b) \ + _SDT_ASM_1( _SDT_ASM_ADDR _.stapsdt.base) \ + _SDT_SEMAPHORE(provider,name) \ + _SDT_ASM_STRING(provider) \ + _SDT_ASM_STRING(name) \ + pack_args args \ + _SDT_ASM_1(994: .balign 4) \ + _SDT_ASM_1( .popsection) + +#define _SDT_ASM_BASE \ + _SDT_ASM_1(.ifndef _.stapsdt.base) \ + _SDT_ASM_5( .pushsection .stapsdt.base,"aG","progbits", \ + .stapsdt.base,comdat) \ + _SDT_ASM_1( .weak _.stapsdt.base) \ + _SDT_ASM_1( .hidden _.stapsdt.base) \ + _SDT_ASM_1( _.stapsdt.base: .space 1) \ + _SDT_ASM_2( .size _.stapsdt.base, 1) \ + _SDT_ASM_1( .popsection) \ + _SDT_ASM_1(.endif) + +#if defined _SDT_HAS_SEMAPHORES +#define _SDT_SEMAPHORE(p,n) _SDT_ASM_1( _SDT_ASM_ADDR p##_##n##_semaphore) +#else +#define _SDT_SEMAPHORE(p,n) _SDT_ASM_1( _SDT_ASM_ADDR 0) +#endif + +#define _SDT_ASM_TEMPLATE_0 /* no arguments */ +#define _SDT_ASM_TEMPLATE_1 _SDT_ARGFMT(1) +#define _SDT_ASM_TEMPLATE_2 _SDT_ASM_TEMPLATE_1 _SDT_ARGFMT(2) +#define _SDT_ASM_TEMPLATE_3 _SDT_ASM_TEMPLATE_2 _SDT_ARGFMT(3) +#define _SDT_ASM_TEMPLATE_4 _SDT_ASM_TEMPLATE_3 _SDT_ARGFMT(4) +#define _SDT_ASM_TEMPLATE_5 _SDT_ASM_TEMPLATE_4 _SDT_ARGFMT(5) +#define _SDT_ASM_TEMPLATE_6 _SDT_ASM_TEMPLATE_5 _SDT_ARGFMT(6) +#define _SDT_ASM_TEMPLATE_7 _SDT_ASM_TEMPLATE_6 _SDT_ARGFMT(7) +#define _SDT_ASM_TEMPLATE_8 _SDT_ASM_TEMPLATE_7 _SDT_ARGFMT(8) +#define _SDT_ASM_TEMPLATE_9 _SDT_ASM_TEMPLATE_8 _SDT_ARGFMT(9) +#define _SDT_ASM_TEMPLATE_10 _SDT_ASM_TEMPLATE_9 _SDT_ARGFMT(10) +#define _SDT_ASM_TEMPLATE_11 _SDT_ASM_TEMPLATE_10 _SDT_ARGFMT(11) +#define _SDT_ASM_TEMPLATE_12 _SDT_ASM_TEMPLATE_11 _SDT_ARGFMT(12) +#define _SDT_ASM_OPERANDS_0() [__sdt_dummy] "g" (0) +#define _SDT_ASM_OPERANDS_1(arg1) _SDT_ARG(1, arg1) +#define _SDT_ASM_OPERANDS_2(arg1, arg2) \ + _SDT_ASM_OPERANDS_1(arg1), _SDT_ARG(2, arg2) +#define _SDT_ASM_OPERANDS_3(arg1, arg2, arg3) \ + _SDT_ASM_OPERANDS_2(arg1, arg2), _SDT_ARG(3, arg3) +#define _SDT_ASM_OPERANDS_4(arg1, arg2, arg3, arg4) \ + _SDT_ASM_OPERANDS_3(arg1, arg2, arg3), _SDT_ARG(4, arg4) +#define _SDT_ASM_OPERANDS_5(arg1, arg2, arg3, arg4, arg5) \ + _SDT_ASM_OPERANDS_4(arg1, arg2, arg3, arg4), _SDT_ARG(5, arg5) +#define _SDT_ASM_OPERANDS_6(arg1, arg2, arg3, arg4, arg5, arg6) \ + _SDT_ASM_OPERANDS_5(arg1, arg2, arg3, arg4, arg5), _SDT_ARG(6, arg6) +#define _SDT_ASM_OPERANDS_7(arg1, arg2, arg3, arg4, arg5, arg6, arg7) \ + _SDT_ASM_OPERANDS_6(arg1, arg2, arg3, arg4, arg5, arg6), _SDT_ARG(7, arg7) +#define _SDT_ASM_OPERANDS_8(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) \ + _SDT_ASM_OPERANDS_7(arg1, arg2, arg3, arg4, arg5, arg6, arg7), \ + _SDT_ARG(8, arg8) +#define _SDT_ASM_OPERANDS_9(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9) \ + _SDT_ASM_OPERANDS_8(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8), \ + _SDT_ARG(9, arg9) +#define _SDT_ASM_OPERANDS_10(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10) \ + _SDT_ASM_OPERANDS_9(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9), \ + _SDT_ARG(10, arg10) +#define _SDT_ASM_OPERANDS_11(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11) \ + _SDT_ASM_OPERANDS_10(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10), \ + _SDT_ARG(11, arg11) +#define _SDT_ASM_OPERANDS_12(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12) \ + _SDT_ASM_OPERANDS_11(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11), \ + _SDT_ARG(12, arg12) + +/* These macros can be used in C, C++, or assembly code. + In assembly code the arguments should use normal assembly operand syntax. */ + +#define STAP_PROBE(provider, name) \ + _SDT_PROBE(provider, name, 0, ()) +#define STAP_PROBE1(provider, name, arg1) \ + _SDT_PROBE(provider, name, 1, (arg1)) +#define STAP_PROBE2(provider, name, arg1, arg2) \ + _SDT_PROBE(provider, name, 2, (arg1, arg2)) +#define STAP_PROBE3(provider, name, arg1, arg2, arg3) \ + _SDT_PROBE(provider, name, 3, (arg1, arg2, arg3)) +#define STAP_PROBE4(provider, name, arg1, arg2, arg3, arg4) \ + _SDT_PROBE(provider, name, 4, (arg1, arg2, arg3, arg4)) +#define STAP_PROBE5(provider, name, arg1, arg2, arg3, arg4, arg5) \ + _SDT_PROBE(provider, name, 5, (arg1, arg2, arg3, arg4, arg5)) +#define STAP_PROBE6(provider, name, arg1, arg2, arg3, arg4, arg5, arg6) \ + _SDT_PROBE(provider, name, 6, (arg1, arg2, arg3, arg4, arg5, arg6)) +#define STAP_PROBE7(provider, name, arg1, arg2, arg3, arg4, arg5, arg6, arg7) \ + _SDT_PROBE(provider, name, 7, (arg1, arg2, arg3, arg4, arg5, arg6, arg7)) +#define STAP_PROBE8(provider,name,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8) \ + _SDT_PROBE(provider, name, 8, (arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8)) +#define STAP_PROBE9(provider,name,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9)\ + _SDT_PROBE(provider, name, 9, (arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9)) +#define STAP_PROBE10(provider,name,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10) \ + _SDT_PROBE(provider, name, 10, \ + (arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10)) +#define STAP_PROBE11(provider,name,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11) \ + _SDT_PROBE(provider, name, 11, \ + (arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11)) +#define STAP_PROBE12(provider,name,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12) \ + _SDT_PROBE(provider, name, 12, \ + (arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12)) + +/* This STAP_PROBEV macro can be used in variadic scenarios, where the + number of probe arguments is not known until compile time. Since + variadic macro support may vary with compiler options, you must + pre-#define SDT_USE_VARIADIC to enable this type of probe. + + The trick to count __VA_ARGS__ was inspired by this post by + Laurent Deniau : + http://groups.google.com/group/comp.std.c/msg/346fc464319b1ee5 + + Note that our _SDT_NARG is called with an extra 0 arg that's not + counted, so we don't have to worry about the behavior of macros + called without any arguments. */ + +#ifdef SDT_USE_VARIADIC +#define _SDT_NARG(...) __SDT_NARG(__VA_ARGS__, 12,11,10,9,8,7,6,5,4,3,2,1,0) +#define __SDT_NARG(_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12, N, ...) N +#define _SDT_PROBE_N(provider, name, N, ...) \ + _SDT_PROBE(provider, name, N, (__VA_ARGS__)) +#define STAP_PROBEV(provider, name, ...) \ + _SDT_PROBE_N(provider, name, _SDT_NARG(0, ##__VA_ARGS__), ##__VA_ARGS__) +#endif + +/* These macros are for use in asm statements. You must compile + with -std=gnu99 or -std=c99 to use the STAP_PROBE_ASM macro. + + The STAP_PROBE_ASM macro generates a quoted string to be used in the + template portion of the asm statement, concatenated with strings that + contain the actual assembly code around the probe site. + + For example: + + asm ("before\n" + STAP_PROBE_ASM(provider, fooprobe, %eax 4(%esi)) + "after"); + + emits the assembly code for "before\nafter", with a probe in between. + The probe arguments are the %eax register, and the value of the memory + word located 4 bytes past the address in the %esi register. Note that + because this is a simple asm, not a GNU C extended asm statement, these + % characters do not need to be doubled to generate literal %reg names. + + In a GNU C extended asm statement, the probe arguments can be specified + using the macro STAP_PROBE_ASM_TEMPLATE(n) for n arguments. The paired + macro STAP_PROBE_ASM_OPERANDS gives the C values of these probe arguments, + and appears in the input operand list of the asm statement. For example: + + asm ("someinsn %0,%1\n" // %0 is output operand, %1 is input operand + STAP_PROBE_ASM(provider, fooprobe, STAP_PROBE_ASM_TEMPLATE(3)) + "otherinsn %[namedarg]" + : "r" (outvar) + : "g" (some_value), [namedarg] "i" (1234), + STAP_PROBE_ASM_OPERANDS(3, some_value, some_ptr->field, 1234)); + + This is just like writing: + + STAP_PROBE3(provider, fooprobe, some_value, some_ptr->field, 1234)); + + but the probe site is right between "someinsn" and "otherinsn". + + The probe arguments in STAP_PROBE_ASM can be given as assembly + operands instead, even inside a GNU C extended asm statement. + Note that these can use operand templates like %0 or %[name], + and likewise they must write %%reg for a literal operand of %reg. */ + +#if __STDC_VERSION__ >= 199901L +# define STAP_PROBE_ASM(provider, name, ...) \ + _SDT_ASM_BODY(provider, name, _SDT_ASM_STRING, (__VA_ARGS__)) \ + _SDT_ASM_BASE +# define STAP_PROBE_ASM_OPERANDS(n, ...) _SDT_ASM_OPERANDS_##n(__VA_ARGS__) +#else +# define STAP_PROBE_ASM(provider, name, args) \ + _SDT_ASM_BODY(provider, name, _SDT_ASM_STRING, (args)) \ + _SDT_ASM_BASE +#endif +#define STAP_PROBE_ASM_TEMPLATE(n) _SDT_ASM_TEMPLATE_##n + + +/* DTrace compatible macro names. */ +#define DTRACE_PROBE(provider,probe) \ + STAP_PROBE(provider,probe) +#define DTRACE_PROBE1(provider,probe,parm1) \ + STAP_PROBE1(provider,probe,parm1) +#define DTRACE_PROBE2(provider,probe,parm1,parm2) \ + STAP_PROBE2(provider,probe,parm1,parm2) +#define DTRACE_PROBE3(provider,probe,parm1,parm2,parm3) \ + STAP_PROBE3(provider,probe,parm1,parm2,parm3) +#define DTRACE_PROBE4(provider,probe,parm1,parm2,parm3,parm4) \ + STAP_PROBE4(provider,probe,parm1,parm2,parm3,parm4) +#define DTRACE_PROBE5(provider,probe,parm1,parm2,parm3,parm4,parm5) \ + STAP_PROBE5(provider,probe,parm1,parm2,parm3,parm4,parm5) +#define DTRACE_PROBE6(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6) \ + STAP_PROBE6(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6) +#define DTRACE_PROBE7(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7) \ + STAP_PROBE7(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7) +#define DTRACE_PROBE8(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8) \ + STAP_PROBE8(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8) +#define DTRACE_PROBE9(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9) \ + STAP_PROBE9(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9) +#define DTRACE_PROBE10(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9,parm10) \ + STAP_PROBE10(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9,parm10) +#define DTRACE_PROBE11(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9,parm10,parm11) \ + STAP_PROBE11(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9,parm10,parm11) +#define DTRACE_PROBE12(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9,parm10,parm11,parm12) \ + STAP_PROBE12(provider,probe,parm1,parm2,parm3,parm4,parm5,parm6,parm7,parm8,parm9,parm10,parm11,parm12) + + +#endif /* sys/sdt.h */