Designing a simple ALU
(Cheat)
The simplest yet most powerful solution is to use a Flash memory as a lookup table for the results. 8-bit A input + 8-bit B input + 3 bits operation code is 19 bits. Pick a 512 k \$\times\$ 16 bit Flash (about $2), use the 19 input lines as address, and program it with the results for each input combination. This way you can have any operation you like. You want sin(A)? Just add a 256-word sine lookup table, you can even have a 16-bit precise result. You're not limited to multiplying by 8; you can multiply A by B. Like wise, you can divide A by B, and get an 8-bit quotient and an 8-bit remainder. For the multiplication and division you'll use all bits in a 64 kword block, but for instance the bit reversal makes less efficient use of it: it doesn't depend on the value of B, so you'll have 256 identical values for each A input, and the high order byte wouldn't even be used. So whereas you only need 256 \$\times\$ 8 = 2048 bits for the bit reversal you would use 65536 \$\times\$ 16 = 1048576 bits; that's not very efficient. You could call this a serious drawback of the Flash solution, but I would like to see you implement an 8 \$\times\$ 8 multiplier using basic logic gates for $2.

OK, maybe you don't want that; logic gates are much more challenging. Like Kaz says start with a 3-to-8 decoder to have a unique signal for each opcode. You can make this with basic gates, but I would suggest to use a 74HC238 to start with. When the ALU works you can still replace the HC238 by a collection of gates.  

What you don't want for the multiplier is a shift register which shifts left 3 times. That's a registered function which needs a clock, instead of a combinatory function which produces the result immediately. (Note that the Flash also produces any result in nanoseconds, though slower than with combinatory logic.) Have a path from A0 to Y3, A1 to Y4, etc, which you enable with the "010" decoded opcode. Likewise, Y3 will be connected to A6 if the "011" signal is active (division), and to A4 when the opcoe is "110" (bit reversal). That means a lot of multiplexing.

To get back to the Flash, you can also make a combination of combinatory logic for simple operations, like NAND, NOR, shift left, shift right\$^{(*)}\$, and only use the Flash for the multiplication and division. You could use a smaller Flash (128 kword instead of 512 kword), or add more advanced functions, like the sine I gave as an example (maybe not the best, but I'm sure you can think of something).





\$^{(*)}\$ How come you have a multiply by 8, but not the more basic shift left? Shift left/right, rotate left/right (both through carry and not) are must haves for any ALU, and you can divide by 8 using 3 shift rights, while you can't divide by 2. The bit reversal is a typical DSP function, but you don't want to build a DSP to start with, do you? I would change the functions to

x  y  z  |  operation

0  0  0  |  S = A - B
0  0  1  |  S = A + B
0  1  0  |  S = shift left A by 1 bit
0  1  1  |  S = shift right A by 1 bit
1  0  0  |  S = A NAND B (bitwise)
1  0  1  |  S = A XOR B (bitwise)
1  1  0  |  S = rotate left A
1  1  1  |  S = NOT A (bitwise)