/* sort.c -- Sort without allocating memory | |

Copyright (C) 2012-2022 Free Software Foundation, Inc. | |

Written by Ian Lance Taylor, Google. | |

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. | |

(3) The name of the author may not be used to | |

endorse or promote products derived from this software without | |

specific prior written permission. | |

THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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. */ | |

#include "config.h" | |

#include <stddef.h> | |

#include <sys/types.h> | |

#include "backtrace.h" | |

#include "internal.h" | |

/* The GNU glibc version of qsort allocates memory, which we must not | |

do if we are invoked by a signal handler. So provide our own | |

sort. */ | |

static void | |

swap (char *a, char *b, size_t size) | |

{ | |

size_t i; | |

for (i = 0; i < size; i++, a++, b++) | |

{ | |

char t; | |

t = *a; | |

*a = *b; | |

*b = t; | |

} | |

} | |

void | |

backtrace_qsort (void *basearg, size_t count, size_t size, | |

int (*compar) (const void *, const void *)) | |

{ | |

char *base = (char *) basearg; | |

size_t i; | |

size_t mid; | |

tail_recurse: | |

if (count < 2) | |

return; | |

/* The symbol table and DWARF tables, which is all we use this | |

routine for, tend to be roughly sorted. Pick the middle element | |

in the array as our pivot point, so that we are more likely to | |

cut the array in half for each recursion step. */ | |

swap (base, base + (count / 2) * size, size); | |

mid = 0; | |

for (i = 1; i < count; i++) | |

{ | |

if ((*compar) (base, base + i * size) > 0) | |

{ | |

++mid; | |

if (i != mid) | |

swap (base + mid * size, base + i * size, size); | |

} | |

} | |

if (mid > 0) | |

swap (base, base + mid * size, size); | |

/* Recurse with the smaller array, loop with the larger one. That | |

ensures that our maximum stack depth is log count. */ | |

if (2 * mid < count) | |

{ | |

backtrace_qsort (base, mid, size, compar); | |

base += (mid + 1) * size; | |

count -= mid + 1; | |

goto tail_recurse; | |

} | |

else | |

{ | |

backtrace_qsort (base + (mid + 1) * size, count - (mid + 1), | |

size, compar); | |

count = mid; | |

goto tail_recurse; | |

} | |

} |