 This time, we're going to be implementing a jump and link instruction. The jump and link instruction is similar to a jump instruction. The instruction format has two parts. It has the opcode as well as the 26-bit immediate. But unlike the jump instruction, we'll also need to set the return address. So for this instruction, we'll use all the same hardware we did for our jump instruction, program counter, instruction memory, all of this stuff to set the jump target address, and then send that back to the program counter. But we also need to update a register. In this case, we need to be able to update register 31. That's the return address register. And we want to be able to pass it the address from the program counter plus four. So it's simple enough to just pass the data from program counter plus four over to the right data field. This is where data will go when we want to write it to a register, so it's sensible to just send it right over there. But we also need to know that we're going to store something to register number 31. At the moment, we have a few different options for what we can put in our destination. Either we can use the RT field or the RD field. But neither of these really lend themselves to just having the number 31 in them. Both of those fields come straight out of the instruction memory, so they're not really going to be useful for our purposes. Instead, we need to find a different way to put 31 into this destination. And the easy way to do that is to just extend this multiplexer. Add a new option on here, say 2. That just allows us to pass in the value 31. In order to handle this instruction, we're going to need to add a couple of new control signals. This register destination line will need to be twice as big now because now our multiplexer has three options in it instead of just two. So we need at least two bits to choose between all three options. We're also going to need to have a way to choose between our new program counter plus four line and our original right back line. We can't just send both of those pieces of data straight to the registers. We need to pass them to a multiplexer so that we can choose between the two of them. For this multiplexer, we have a couple of options. It would be pretty obvious that I could just put in a new multiplexer right here. Then I could route my program counter plus four line into the multiplexer along with the original right back data. But I also have the option that I could just make the Memtorej multiplexer larger. It would mean that I would have to take the data from program counter plus four and pass it all the way over here to the Memtorej multiplexer. But that would be an option. I then again need a second line so that I could choose between all three options on my new Memtorej multiplexer. Alternatively, I could just have a control line going to the new jump and link multiplexer. One thing that would be nice about using the expanded Memtorej multiplexer is that I'd be able to send the same signal to both the register destination multiplexer as well as the Memtorej multiplexer. I wouldn't have to worry about coming up with a slightly different signal to send those two multiplexers. They'd actually get the same signal. I'd be selecting the two in both of those cases. So that would make my hardware a little simpler when it came to actually implementing this architecture. So again we have a couple different options for how we can implement our jump and link instruction. But we're using a lot of the core elements from things that we already saw. We still used all of the old jump hardware and then we just added in a little bit more about the registers. We had to extend a couple of multiplexers in order to implement the instruction completely and those involved having some extra control signals. But we didn't actually have to add a whole lot of hardware to implement this new instruction.