Как я могу отклонить вызов, если во время компиляции известно граничное условие?

Смысл __assume в том, чтобы указать компилятору пропускать части кода при оптимизации. В предоставленной вами ссылке пример дается с предложением default конструкции switch - там подсказка сообщает компилятору, что предложение никогда не будет достигнуто, даже если теоретически это возможно. Вы обычно говорите оптимизатору: «Эй, я знаю лучше, выбросьте этот код».

Для default вы не можете не записывать его (если вы не покрываете весь диапазон в cases, что иногда бывает проблематично), потому что это вызовет ошибку компиляции. Итак, вам нужна подсказка для оптимизации кода, вы знаете, что в нем нет необходимости.

В вашем случае - код доступен, но не всегда, поэтому подсказка __assume вам не сильно поможет. Вы должны проверить, действительно ли count равно 0. Если вы не уверены, что оно никогда не может быть чем-либо, кроме 0, просто не записывайте его.

В этом решении используется трюк, описанный в Обнаружении константы времени компиляции C ++ - трюк использует Фактическое целое число времени компиляции, равное нулю, можно преобразовать в указатель, и это можно использовать вместе с перегрузкой для проверки свойства «известное время компиляции».

struct chkconst {
  struct Small {char a;};
  struct Big: Small {char b;};
  struct Temp { Temp( int x ) {} };
  static Small chk2( void* ) { return Small(); }
  static Big chk2( Temp  ) { return Big(); }
};

#define is_const_0(X) (sizeof(chkconst::chk2(X))<sizeof(chkconst::Big))
#define is_const(X) is_const_0( int(X)-int(X) )

#define memmove_smart(dst,src,n) do { \
    if (is_const(n)) {if (n>0) memmove(dst,src,n);} \
    else memmove(dst,src,n); \
  } while (false)

Или, в вашем случае, поскольку вы все равно хотите проверять только ноль, можно использовать is_const_0 напрямую для максимальной простоты и переносимости:

#define memmove_smart(dst,src,n) if (is_const_0(n)) {} else memmove(dst,src,n)

Примечание: здесь используется версия is_const более простая, чем в связанном вопросе. Это связано с тем, что в этом случае Visual Studio более соответствует стандартам, чем GCC. Если нацелен на gcc, вы можете использовать следующий вариант is_const (адаптированный для обработки всех возможных целочисленных значений, включая отрицательные и INT_MAX):

#define is_const_0(X) (sizeof(chkconst::chk2(X))<sizeof(chkconst::Big))
#define is_const_pos(X) is_const_0( int(X)^(int(X)&INT_MAX) )
#define is_const(X) (is_const_pos(X)|is_const_pos(-int(X))|is_const_pos(-(int(X)+1)))

Я думаю, что вы неправильно поняли значение __assume. Он не сообщает компилятору об изменении своего поведения, когда он знает, каковы значения, а скорее сообщает ему, какими будут значения, когда он не может вывести его самостоятельно.

В вашем случае, если вы сказали __assume, что count > 0 он пропустит тест, поскольку вы уже сказали ему, что результат всегда будет true, он удалит условие и вызовет memmove always, который это именно то, чего вы хотите избежать.

Я не знаю особенностей VS, но в GCC есть вероятный / маловероятный внутренний (__builtin_expect((x),1)), который можно использовать для подсказки компилятору относительно того, какой наиболее вероятный исход теста. при этом тест не удаляется, но код компоновки будет таким, чтобы наиболее вероятная (как в по вашему определению) ветвь была более эффективной (не разветвлялась).

Если возможно переименовать memmove, я думаю, что подойдет что-то вроде этого - http://codepad.org/s974Fp9k

struct Temp {
  int x;
  Temp( int y ) { x=y; }
  operator int() { return x; };
};

void memmove1( void* dest, const void* source, void* count ) {
  printf( "void\n" );
}

void memmove1( void* dest, const void* source, Temp count ) {
  memmove( dest, source, count );
  printf( "temp\n" );
}

int main( void ) {
  int a,b;
  memmove1( &a,&b, sizeof(a) );
  memmove1( &a,&b, sizeof(a)-4 );
}

Я думаю, что то же самое, вероятно, возможно и без класса - нужно посмотреть правила преобразования, чтобы подтвердить это.

Также должна быть возможность перегрузить исходный memmove (), например. передавая объект (например, Temp (sizeof (a)) в качестве третьего аргумента.

Не уверен, какой способ удобнее.