OK, this is a little bit of an odd request, but it seemed like this may be one of the best places to ask.
For a small portion of a project/presentation that I'm working on, I'd like to show that knowledge of the how particular assembly code operates can be used to try to find glitches/bugs. I am specifically referring to integer under/overflows, stack smashing, and other forms of memory corruption. Now, I certainly know it's possible (no such thing as "perfect" code), and there are a variety of glitches documented for a lot of different games, but coming up with a simple correlation between code and an example is turning out to be difficult. Just knowing that a certain subroutine only checks against a ceiling doesn't constitute a bug until there's some in-game method of exploiting it, which is the interesting/creative part. So in the end, I'm looking for any such glitches that have an easily verifiable effect (eg, "negative" values where they shouldn't be, infinite/max <thing> bugs, corrupted graphics, etc) that can fairly simply be related back to how the assembly code operates. I figure that there are plenty of veterans out there that have come across these sorts of things by accident, so if there are any you can share, I'd really appreciate it. In particular I'm focusing on the SNES for this, but I'm interested in hearing anything else you've seen from other platforms. You also don't have to know exactly why the glitch occurs; if you can describe how to reproduce it well enough I can go through and try to figure things out from the machine code.