You said that checking the conditions amounts to a big part of the cost of execution. The question is whether throwing the exceptions or the ifs themselves are the highest cost there. If the cost is associated with the situations where the exception is actually thrown, you might want to refactor the code to work without exceptions (return codes seem a good option here) as exceptions are expensive. Also, note that exceptions might have a small impact even when they are not thrown --i.e. the compiler must track the set of objects to destroy during stack unwinding in case an exception is thrown. Compilers are smart, so expect that cost to be small, but not zero.
If on the other hand, the exceptions are not thrown, but the cost is really associated with mispredictions then you might want to go back to your compiler vendor docs and look how to hint it. Many compilers allow for a two phase compilation, where after the first compilation you can run tests and profile, and you can hand that profiling information back to the compiler to optimize your code with knowledge of what the expected behavior of the application can be.
Manually you can also hint the compiler as to what the most expected result of a check might be. In particular, some compilers will assume that the most probable outcome of an if is a success (enter the if, skip the else) , and that the most probable code path will enter the if. There are also special keywords that you can use to hint the compiler, as an example, in gcc you can use if (__builtin_expect( (condition), 0 )) to tell the compiler that the most probable outcome is condition to be false.