 Static branch prediction is a method of picking the speculative instruction based on just looking at the branch itself. We're not going to worry about what this branch has been doing. We may look at some of the parameters of the branch, but we're always going to do the same thing, but we're always going to do the same thing whenever we see a branch. So some of the simplest methods are just to assume that, well, we never take branches, so we'll just speculatively load the next instruction in the list. That's really simple. The processor almost wants to do that anyway. Something slightly more complicated would be to always assume that our branches are taken. So we just grab the branch target address and immediately try to run that instruction. For something slightly more complicated, we might assume that maybe we never take forward branches, but we'll always take backwards branches. Forward branches are associated with ifs, and we usually want to go into our if block, so we don't want to jump over that block, so we'll assume that our forward branches are never taken, but our backwards branches are associated with loops, and we often want to run our loops multiple times, so we will assume that those are taken. If we're going to build a static branch predictor, then we're really going to be interested in the properties of code in general. When are we likely to take branches? When are we not likely to take branches? And how does that work across all sets of code? Looking at things like, is this branch implementing an if statement? Is it implementing a loop? Is it implementing a case statement? Or something else that we can readily grab at and get some idea about what this code is likely to want to do.