int b;

if (&b > a) {

// printf("Stack grows upward\n");

return 1;

}

// printf("Stack grows downward\n");

return 0;

int a;

int retval = ptr_f(&a);

if (retval == 0) {

stack_direction = -1;

} else {

stack_direction = 1;

}

return retval;

assert(thd == current_thd);

assert(stack_direction == -1 || stack_direction == 1);

#if defined(HAVE_ASAN)

// Stack grows upward, but our address computations do not work with

// the "fake stack" of ASAN. Just return OK.

// With ASAN_OPTIONS=detect_stack_use_after_return=true

// any test which deliberately runs out of stack

// (expects ER_STACK_OVERRUN_NEED_MORE) will most likely crash.

if (stack_direction == 1) {

return false;

}

#endif

long stack_used =

used_stack(thd->thread_stack, reinterpret_cast<char *>(&stack_used));

if (stack_used >= static_cast<long>(my_thread_stack_size - margin) ||

DBUG_EVALUATE_IF("simulate_stack_overrun", true, false)) {

// Touch the buffer, so that it is not optimized away by -flto.

if (buf != nullptr) buf[0] = '\0';

/*

char *ebuff = new (std::nothrow) char[MYSQL_ERRMSG_SIZE];

if (ebuff) {

snprintf(ebuff, MYSQL_ERRMSG_SIZE,

ER_THD(thd, ER_STACK_OVERRUN_NEED_MORE), stack_used,

my_thread_stack_size, margin);

my_message(ER_STACK_OVERRUN_NEED_MORE, ebuff, MYF(ME_FATALERROR));

delete[] ebuff;

}

return true;

}

#ifndef NDEBUG

max_stack_used = std::max(max_stack_used.load(), stack_used);

#endif

return false;

}