Preciso criar uma ALU com duas entradas de 8 bits A e B e controlar as entradas x, ye z que oferecem suporte às seguintes operações:
x y z | operation
0 0 0 | S = A-B
0 0 1 | S = A+B
0 1 0 | S = A*8
0 1 1 | S = A/8
1 0 0 | S = A NAND B (bitwise)
1 0 1 | S = A XOR B (bitwise)
1 1 0 | s = reverse the bits of A
1 1 1 | S = NOT A (bitwise)
Isso deve ser feito com um somador de 8 bits e um extensor lógico-aritmético. Ao ler meu livro, vejo que o objetivo de um extensor AL é alterar os bits de entrada para que um somador, em vez de muitos componentes extras, possa ser usado para fazer tudo (ou pelo menos é isso que eu entendo dele) ) Por exemplo, o AL-extensor pode colocar os bits no complemento de dois para que o somador faça uma subtração. Da mesma forma, para as operações lógicas bit a bit, os bits podem ser alterados adequadamente e uma das entradas do somador pode ser apenas zero, para que o resultado seja obtido corretamente.
Mas o que exatamente faço sobre multiplicação? Meu livro é muito vago, então não tenho certeza se um extensor de AL exigiria que eu fizesse algo inteligente para fazer o adicionador fazer o trabalho (basta adicionar 8 vezes no meu caso? ... ha ha), ou se eu pode simplesmente jogar um multiplicador lá. Vou ter que ler sobre divisão, mas aposto que é semelhante à multiplicação.
Bem, enfim, a linha de fundo ainda é, o que um AL-extensor "permitido" pode / pode ter nele? Seu único objetivo é alterar a entrada para que ela possa ser alimentada a um adicionador?
* EDIT: Bem, é multiplicação / divisão por 8, então isso pode ser facilmente realizado com a mudança de esquerda ou direita por 3. Eu ainda teria um extensor de AL real / adequado se adicionasse alguns shifters lá? (Talvez eu esteja pensando demais nisso como iniciante completo ...)