1 Sumário Pag.Ant. Alberto Romano Schiesari – Assembler para Mainframes IBM

1Sumário Pag.Ant. Alberto Romano Schiesari – www.profars.com

Assembler para Mainframes IBM


Apresentação

Obrigado por usar esta apresentação. Você está livre para fazer isso.

Eu agradeço se fizer referência ao autor ao utilizá-la.

Agradeço se você me enviar qualquer correção que ache necessária para otimizar a compreensão do leitor.

O mesmo se aplica a erros técnicos que você encontrar; por favor me ajude a deixar este material sem erros.

Alberto Romano Schiesari – São Paulo - Brasil

www.profars.com

[email protected]


SumárioArquitetura / alguns componentesArquitetura mainframes IBMRepresentação de dadosRepresentação de instruçõesLinguagem AssemblerFluxoJeitão de um programa AssemblerStatementElementos do montador assemblerTipos de statementsComandos ao Montador Assembler Instruções de máquina Dicas Instruções por grupo InstruçõesMacro-InstruçõesApêndice - LinksApêndice – Sumário de instruções (por cod op) (por mnemônico) Apêndice - Alguns caracteres EBCDIC Alguns caracteres ASCIIApêndice - Questões RespostasApêndice – Dicas de programação


Sumário

Não estão no escopo deste curso: AREAD, MACRO, MEXIT, MENDACTR, AGO, AIF, ANOP, GBLA, GBLB, GBLC, LCLA, LCLB, LCLC, MHELP, MNOTE, SETA, SETB, SETC

Comandos Assembler (ordem alfabética)

AMODE

CCW

CCW0

CCW1

CNOP

COM

COPY

CSECT

CXD

DC

DROP

DS

DSECT

DXD

EJECT

END

ENTRY

EQU

EXTRN

ICTL

ISEQ

LOCTR

LTORG

OPSYN

ORG

POP

PRINT

PUNCH

PUSH

REPRO

RMODE

SPACE

START

TITLE

USING

WXTRN


SumárioInstruções de máquina (ordem alfabética)

A

AH

AL

ALR

AP

AR

BAL

BALR

BAS

BASR

BASSM

BC

BCR

BCT

BCTR

BSM

BXH

BXLE

C

CDS

CH

CL

CLC

CLCL

CLI

CLM

CLR

CP

CR

CS

CVB

CVD

D

DP

DR

ED

EDMK

EX

IC

ICM

IPM

L

LA

LCR

LH

LM

LNR

LPR

LR

LTR

M

MC

MH

MP

MR

MVC

MVCIN

MVCL

MVI

MVN

MVO

MVZ

N

NC

NI

NR

O

OC

OI

OR

PACK

S

SH

SL

SLA

SLDA

SLDL

SLL

SLR

SP

SPM

SR

SRA

SRDA

SRDL

SRL

SRP

ST

STC

STCK

STCM

STH

STM

SVC

TM

TR

TRT

TS

UNPK

X

XC

XI

XR

ZAP


Arquitetura

ARQUITETURA DE SISTEMAS


Arquitetura – Alguns componentes

CPU do sistema (CISC, RISC, híbrido)

CISC = Complex Instruction Set Computer

Instruções com tamanho variável.

Nelas, explicita ou implicitamente, deve estar especificado:

- Qual operação a ser feita

- Quais operandos serão usados (locais com dados a processar e

locais com dados resultantes): o endereço deles!

- Tamanho dos operandos

- Formato dos dados nos operandos

RISC = Reduced Instruction Set Computer

Instruções com tamanho fixo: por ex. 4 bytes; execução, na média,

mais rápida



Observar que...

Mainframes e PC’s = CISC



Endereçamento (acesso) dos bytes de memória Memória real? Memória virtual?

Se tiver memória virtual, o HW precisa conversar com o SW



Em linguagem simbólica a referência a um campo é feita:

Usando seu nome (variáveis ou constantes) ou

Usando seu conteúdo (literais)

MOVE 1 TO NPAGIN.

NPAGIN = 1



Em linguagem de máquina, a referência a um campo é feita indicando

seu endereço, ou seja, a localização de um campo deve ser

especificada por meio de um número (hexadecimal / binário) que seja

o seu endereço.

Não há referência aos nomes.

A referência ao endereço é denominada ENDEREÇAMENTO.

O número hexadecimal que expressa o endereço pode ter 6

algarismos ou 8 algarismos.

Se for com 6 algarismos são necessários 3 bytes para especificá-lo.

Se for com 8 algarismos são necessários 4 bytes para especificá-lo.

(em muitos de nossos exemplos usamos números menores, com 2 ou 3 algarismos, apenas para

simplificação visual e de cálculos).



Endereçamento (acesso) dos bytes de memória

Instrução MOVE em linguagem de máquina, que indica : (a) é MOVE (F8);

(b) Tamanho campo emissor [literal 1] = 0 (significa 1 byte)

(c) Tamanho campo receptor [variável NPAGIN] = 3 (significa 4 bytes)

(c) Endereço do campo emissor

(d) Endereço do campo receptor

Acredite em mim: x’B004’ é o endereço de NPAGIN e x’C82F’ é o endereço da literal com 1

Campo emissor [literal com conteúdo 1]

E que tem endereço !

Campo receptor[variável NPAGIN]

E que tem endereço !

Programa

Instruções ÁreasF830B004C82F 1C 00 00 00 1C



Memória real X Memória virtual

Somar 1 no campo de endereço x’2B40’

Se o conteúdo do campo de endereço x’2B40’ não estiver na

memória real:

De-Para para achar onde está na memória virtual

Trazer da memória virtual para a memória real

Executar a instrução

(Lembrar que isso pode acontecer também com a instrução, e com

qualquer operando...)




Endereçamento Direto? Indireto?

Ex. endereçamento Direto Somar 1 no campo de endereço x’00002B40’

Ex. endereçamento Indireto Somar 1 no campo de endereço x’2000’ + x’0B40’

Obs.:

(a) o campo a cujo conteúdo será somado 1 é, na verdade, o de endereço x’2B40’; o

endereço foi dito de forma indireta: X’2000’ + x’0B40’

(b) observar que x’2000’ pode estar num lugar (num registrador, por exemplo), e o x’0B40’

em outro (outro registrador ou na memória)...

Ex. endereçamento Indireto Somar 1 no campo de endereço x’2000’ + x’0B00’ +

x’0040’

Obs.: (a) o campo a cujo conteúdo será somado 1 é, na verdade, o de endereço x’2B40’; o

endereço foi dito de forma indireta: X’2000’ + x’0B00’ + x’0040’

(b) observar que x’2000’ pode estar num lugar (num registrador, por exemplo), e o x’0B00’

em outro (outro registrador, por exemplo) e x’0040’ em outro (na memória por exemplo)...




Capacidade de endereçamento dos bytes de memória Tamanho de memória; quantos “bits” tem a CPU do Mainframe?



Bus de Endereços = fazer referência aos endereços

Para endereçar memória de até 64K, precisa de um bus de endereços de 16

bits. Para endereçar 16MB precisa de 24 bits, etc...

Bus de dados = fazer transferência de dados entre componentes

Para transferir de modo paralelo uma halfword, precisa de um bus de dados

de 16 bits, para transferir uma fullword precisa 32 bits, etc...

CPU Memória

Bus de dados

Bus de endereços

Referência a endereços de memória

Transferência de dados

Capacidade de endereçamento dos bytes de memória



“Set” de instruções da CPU – tipos e características Quantas e quais instruções a CPU tem em seu Instruction Set?



Execução de instruções pela CPU

Qual o processo de execução das instruções?



Execução de instruções pela CPU – Processo genérico

FETCH (CPU carrega a instrução da memória RAM para área interna da

CPU; “problema”: instruções com tamanho variável)

Decode = Análise (decodificação): qual o tamanho da instrução (se

RISC não precisa), operação (errada? 0c1!), operandos, etc

Erro? Passar o controle para o sistema operacional resolver

Se OK, FETCH dos dados dos operandos

Se estiverem na memória real, “tá” ótimo.; Senão...

Validação do conteúdo dos operandos.

Erro? Pode ser um 0C7, por exemplo

Execução : em alguns casos (operações matemáticas,

principalmente), colocar resultados em áreas temporárias da CPU

OK? Se preciso, STORE do resultado na memória RAM



OUTROS componentes de arquitetura



OUTROS componentes de arquitetura

Sistema de interrupções

Quais podem ocorrer? Ex. Por tempo, por erro de programa (0Cx)

Sub-sistemas de entrada e saída

Como é a comunicação entre controladoras, devices, memória,

CPU e tudo isso e o software?

Sistema de proteção de memória

Como um programa está protegido da invasão de outro?

Sistema de memória virtual

Qual o processo? Quais algoritmos de page-in e page-out?

Interface/acesso com outros componentes do sistema

Quais são os outros componentes? Controladoras, Clocks, etc

Como eles se comunicam com a CPU? (por exemplo, CCW)

Quais informações após um I/O o software recebe?


Arquitetura Mainframes IBM




Tributo

A quem os mainframeiros devem os empregos ! Gene Myron Amdahl (1922-)



Mainframes IBM : principais componentes da arquitetura

CPU

Memória (RAM)

etc... (cache...)

UAL

GR0 GR1 GR2 GR3

GR4 GR5 GR6 GR7

GR8 GR9 GR10 GR11

GR12 GR13 GR14 GR15

16 Registradores Gerais (de ponto fixo)

4 bytes cada

1 Registrador especial de 8 bytes denominado PSW atual (Program Status Word)

PSW

FPR0 FPR2 FPR4 FPR6

4 Registradores de ponto flutuante – 8 bytes cada



Mainframes IBM : principais componentes da arquitetura

CPU

UAL

PSW PSW atual

cc epi etc

PSW atual : registrador especial com 8 bytes. 2 "campos" importantes: CONDITION CODE (*) : com 2 BITS, que indicam, após a execução de algumas instruções, alguma condição referente à execução da instrução, como por exemplo, o resultado de comparações(*) Lembrar que isto NÃO É o RETURN CODE do sistema operacional / JCL, e nem o erroneamente chamado COND CODE do JCL (que é o teste do RETURN CODE) endereço da próxima instrução a ser executada (com 3 ou 4 bytes)



Lay-out da PSW atual BC mode

BYTE 0 BITS 0-5 = máscaras de canal BIT 6 = máscara para canais 6 e acima BIT 7 = máscara externaBYTE 1 BITS 8-11 = chave de proteção BIT 12 = 0 = Basic Control Mode BIT 13 = máscara de machine-check BIT 14 = 1 = estado de wait BIT 15 = 1 = estado de programa problemaBYTES 2-3 (BITS 16-31) = Interruption codeBYTE 4 BITS 32-33 = ILC = Instruction length code BITS 34-35 = CC = Condition code BITS 36-39 = máscara de programaBYTES 5-7 (BITS 40-63) = Instruction address



Lay-out da PSW atual EC mode

BYTE 0 BIT 0 = 0 BIT 1 = máscara de program-event recording BIT 2 = 0 BIT 3 = 0 BIT 4 = 0 BIT 5 = translation mode BIT 6 = máscara de I/O BIT 7 = máscara externaBYTE 1 BITS 8-11 = chave de proteção BIT 12 = 1 = Extended Control Mode BIT 13 = máscara de machine-check BIT 14 = 1 = estado de wait BIT 15 = 1 = estado de programa problemaBYTE 2 BIT 16 = 0 BIT 17 = 0 BITS 18-19 = CC = condition code BITS 20-23 = máscara de programa BIT 20 = máscara de fixed-point overflow BIT 21 = máscara de decimal-overflow BIT 22 = máscara de exponent underflow BIT 23 = máscara de significânciaBYTE 3 (BITS 24-31) = 00000000BYTE 4 (BITS 32-39) = 00000000BYTES 5-7 (BITS 40-63) = Instruction address



Lay-out da PSW atual XA mode

BYTE 0 BIT 0 = 0 BIT 1 = máscara de program-event recording BIT 2-4 = 000 BIT 5 = translation mode BIT 6 = máscara de I/O BIT 7 = máscara externaBYTE 1 BITS 8-11 = chave de proteção BIT 12 = 1 BIT 13 = máscara de machine-check BIT 14 = 1 = estado de wait BIT 15 = 1 = estado de programa problemaBYTE 2 BIT 16 = address space mode (junto c/ bit 5) BIT 17 = 0 BITS 18-19 = CC = condition code BITS 20-23 = máscara de programa BIT 20 = máscara de fixed-point overflow BIT 21 = máscara de decimal-overflow BIT 22 = máscara de exponent underflow BIT 23 = máscara de significânciaBYTE 3 (BITS 24-31) = 00000000BYTE 4 BIT 32 = 0 = 24 bit addressing = 1 = 31 bit addressingBYTE 4/5/6/7 (BITS 33-63) = Instruction address



Lay-out da PSW atual ESA modeBYTE 0 BIT 0 = 0 BIT 1 = máscara de program-event recording BIT 2-4 = 000 BIT 5 = translation mode BIT 6 = máscara de I/O BIT 7 = máscara externaBYTE 1 BITS 8-11 = chave de proteção BIT 12 = 1 BIT 13 = máscara de machine-check BIT 14 = 1 = estado de wait BIT 15 = 1 = estado de programa problemaBYTE 2 BIT 16-17 = address space control = 00 = Primary space mode (bit 5 = 1) = 01 = Access-register mode (bit 5 = 1) = 10 = Secondary space mode (bit 5 = 1) = 11 = Home space mode (bit 5 = 1) BITS 18-19 = CC = condition code BITS 20-23 = máscara de programa BIT 20 = máscara de fixed-point overflow BIT 21 = máscara de decimal-overflow BIT 22 = máscara de exponent underflow BIT 23 = máscara de significânciaBYTE 3 (BITS 24-31) = 00000000BYTE 4 BIT 32 = 0 = 24 bit addressing = 1 = 31 bit addressingBYTE 4/5/6/7 (BITS 33-63) = Instruction address



Mainframes IBM : áreas “especiais”

HALFWORD = área com 2 bytes e endereço múltiplo de 2

WORD ou FULLWORD = área com 4 bytes e endereço múltiplo de 4

DOUBLEWORD = área com 8 bytes e endereço múltiplo de 8

QUADWORD = área com 16 bytes e endereço múltiplo de 16

•QW

•DW

•FW

•HW

•HW

•FW

•HW

•HW

•DW

•FW

•HW

•HW

•FW

•HW

•HW

•QW

•DW

•FW

•HW

etc.



Mainframes IBM : interrupções por erro de programa (0Cx)

Cod Razão

0001OPERAÇÃO = O código de operação da instrução é inválido, isto é, não corresponde a nenhuma instrução executável.

0002OPERAÇÃO PRIVILEGIADA = O programa tentou executar uma instrução privilegiada, isto é, que só pode ser executada em estado de supervisor.

0003EXECUTE = Foi dada uma instrução Execute para outra instrução Execute.

0004PROTEÇÃO = Uma instrução do programa tentou estragar uma área fora da sua partição.

0005ENDEREÇAMENTO = Uma instrução do programa fez referência a endereço não existente.

0006ESPECIFICAÇÃO = A instrução especificou algo errado, como, por exemplo, uma instrução que trabalhe com registradores de ponto flutuante, e especifique registrador 3, que não existe.

0007DADOS = Os campos que uma instrução utiliza não estão no formato que deveriam estar.

Cod Razão

0008OVERFLOW DE PONTO FIXO = A instrução faz alguma operação com um registrador geral e nele não cabe o resultado.

0009DIVISÃO DE PONTO FIXO = Divisão em binário, divisor 0.

000AOVERFLOW DECIMAL = Numa operação entre campos em compactado, o campo de resultado não é suficientemente grande para conter o resultado.

000BDIVISÃO DECIMAL = Divisão em compactado com divisor 0.

000COVERFLOW DE EXPOENTE = Para operações com números em ponto flutuante.

000DUNDERFLOW DE EXPOENTE = Para operações com números em ponto flutuante.

000ESIGNIFICÂNCIA = Para operações com números em ponto flutuante.

000FDIVISÃO EM PONTO FLUTUANTE = Para operações em ponto flutuante.



Mainframes IBM : endereçamento

São endereçados : registradores e bytes de memória (Lembrar que o endereço de um campo de memória é o endereço de seu byte mais à esquerda)

Só existe endereçamento DIRETO para registradores: Registradores Gerais = 0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F Registradores de Ponto Flutuante = 0,2,4,6

Não existe endereçamento DIRETO para memória. O endereçamento INDIRETO de memória pode ser: Base + Deslocamento Indexador + Base + Deslocamento




Observar que, na realidade, TODOS os endereços aqui especificados são em “memória real”, como se estivessem num espelho refletindo o address space. Mas lembre-se que na vida real as coisas não são tão belas... Tente imaginar: era uma vez um reino onde para cada address space havia uma memória real exatamente igual...



Base + Deslocamento

Esta é a BASE, uma referência a partir da qual fica possível identificar o

destino

Andar mais = Deslocamento

Instruções para o Sr. Carteiro da Av. Marginal:

Ir até o Restaurante Água Na BocaAndar mais 850 metros; então você chegou na casa onde o envelope deve ser entregue!



Base + Deslocamento

Número binário contido num Registrador Geral

(nesta hora “apelidado” de registrador base)

Número hexa de x’000’ até x’FFF’ (na

instrução) “apelidado” de deslocamento

Número hexadecimal que é o Endereço

(na memória Real)

+

=

Obs.: a caixinha tracejada indica que o número (endereço) NÃO ESTÁ num registrador geral e sim numa área interna da

CPU !!!


Registrador Base = 3Deslocamento = 5ACEndereço = conteúdo do reg 3 + x’5AC’

Registrador Base = 13 (D)Deslocamento = 08DEndereço = conteúdo do reg D + x’08D’

3 5 A Cxx

D 0 8 Dx x


Base + Deslocamento : especificação (usa-se 2 bytes)

x y y yx

Registrador base

Deslocamento

x



Base + Deslocamento

Portanto:

Deslocamento máximo = x’FFF’ = 4095

x y y y

Registrador base

Deslocamento

xx



Base + Deslocamento – Exemplos

Registrador Base :

QUAL é

Registrador Base : Conteúdo

Deslocamento Endereço “direto”

(seriam necessários 4

bytes para representar)

Endereço indireto

(Base e deslocamento :

com 2 bytes pode ser representado)

4 00002000 B40 00002B40 4B40

4 00B2F02C 1A2 00B2F1CE 41A2

15 00000000 DB4 00000DB4 FDB4

0 0046B28C 114 00000114 0114

O conteúdo do registrador zero NÃO É levado em consideração para cálculo de endereço !!!



Base + Deslocamento : Dicas de utilização

Usa-se para endereçar “endereços normais”O que são endereços “normais”?

Cada pergunta! (aqueles que podem ser expressos por meio de uma expressão)



Base + Deslocamento – Dicas de utilização

O que é expressão?

De novo! Cada pergunta! (veja mais adiante nas “cositas” do montador Assembler)



Indexador + Base + Deslocamento

Instruções para o Sr. Carteiro da Av. Marginal:

Ir até o Restaurante Água Na BocaAndar mais 850 metros; então você chegou na vilaDentro da vila, andar mais 50 metros então você terá chegado à casa onde o envelope deve ser entregue!

Esta é a BASE, uma referência a partir da qual fica possível identificar o

destino

Andar mais 850 = Deslocamento

Andar mais 50 = Indexador



Indexador + Base + Deslocamento

Obs.: a caixinha tracejada indica que o número (endereço) NÃO ESTÁ num registrador geral e sim numa área interna da

CPU !!!


(nesta hora “apelidado” de registrador base)

Número hexadecimal que é o Endereço

(na memória Real)

+

=

Número hexadecimalde x’000’ até x’FFF’ (na instrução) “apelidado”

de deslocamento


(nesta hora “apelidado” de registrador indexador)

+


Registrador base

DeslocamentoRegistrador

Indexador

x y y yzx xx


Indexador + Base + Deslocamento : especificação (usa-se 21/2 bytes)

Registrador Indexador = 7Registrador Base = 3Deslocamento = 5ACEndereço = conteúdo do reg 7 + conteúdo do reg 3 + x’5AC’

Registrador Indexador = 11 (B)Registrador Base = 5Deslocamento = FACEndereço = conteúdo do reg B + conteúdo do reg 5 + x’FAC’

3 5 A C7

5 F A CB

xxx

xxx



Portanto:

Deslocamento máximo = x’FFF’ = 4095

x y y y

Registrador base

Deslocamento

z

Registrador Indexador

xxx

Indexador + Base + Deslocamento : especificação (usa-se 21/2 bytes)



Indexador + Base + Deslocamento – ExemplosReg

Index :

QUAL é

Reg Index : Conteúdo

Reg Base :

QUAL é

Reg Base : Conteúdo

Desloc Endereço

“direto”

(seriam necessários

4 bytes para representar)

Endereço indireto

(com 2 bytes e meio pode

ser representado)

12 00100000 4 00002000 B40 00102B40 C4B40

0 00F4CAFE 10 000C8B00 1F0 000C8CF0 0A1F0

4 00007000 4 00007000 1A2 0000E1A2 441A2

15 00000000 12 00C42B06 002 00C42B08 FC002

O conteúdo do registrador zero NÃO É levado em consideração para cálculo de endereço !!!



Indexador + Base + Deslocamento – Dicas de utilização

Usa-se em geral para endereçar “endereços Anormais” O que são endereços “Anormais”?

Segundo Gabriel o Pensador: por exemplo, Itens de tabela



Indexador + Base + Deslocamento – Dicas de utilização

Um exemplo de endereçamento de itens de tabela

AC AM BA SC SP TO MT MS PB RS CE RN PA DF GO

Endereço inicial da tabela :Símbolo = TABUFS (transformado pelo montador em base + deslocamento)

Endereço do item desejado (8o) = Endereço inicial da tabela + [ tamanho de 1 item * ( qtdd itens –1) ] =TABUFS + [ 2 * (8 – 1) ] = TABUFS + 2 * 7 = TABUFS + 14

Endereço do item desejado (8o) = Base+deslocamento de TBUFS + Registrador Indexador (ex.: 17C0A = Indexador=1, Base = 7, deslocamento = C0A)

Endereço de TABUFS = na instrução, na forma Base + deslocamento (montador coloca); supor Base=7 e deslocamento = X’C0A’Conteúdo reg. Indexador = registrador 1 (responsabilidade de nosso programa colocar) com conteúdo X’0000000E’Endereço de TABUFS Indexador+base+deslocamento = X’17C0A’




X’00000000’

X’00000010’

X’00000020’

X’00000030’

X’00000040’

X’00000050’

X’00000060’

X’00000070’

X’00000080’

X’00000090’

X’000000A0’

X’000000B0’

X’000000C0’

X’000000D0’

X’000000E0’

X’000000F0’

Memória de 256 bytes



Mainframes IBM : endereçamentoX’00000000’

X’00000010’

X’00000020’

X’00000030’

X’00000040’

X’00000050’

X’00000060’

X’00000070’

X’00000080’

X’00000090’

X’000000A0’

X’000000B0’

X’000000C0’

X’000000D0’

X’000000E0’

X’000000F0’

Número contido no registrador base indica o byte *.

Se o endereço que se deseja referenciar é x’00000048’:

Se o registrador 12 for usado como base e tiver, por exemplo x’00000000’, quanto deve-se “andar” (deslocar) para, a partir do byte indicado no registrador base, chegar ao byte desejado?

R: x’048’ = deslocamento (linha azul tracejada)

*



Mainframes IBM : endereçamentoX’00000000’

X’00000010’

X’00000020’

X’00000030’

X’00000040’

X’00000050’

X’00000060’

X’00000070’

X’00000080’

X’00000090’

X’000000A0’

X’000000B0’

X’000000C0’

X’000000D0’

X’000000E0’

X’000000F0’

Número contido no registrador base indica o byte *.

Se o endereço que se deseja referenciar é x’000000E8’:

Se o registrador 12 for usado como base e tiver, por exemplo x’000000A0’, quanto deve-se “andar” (deslocar) para, a partir do byte indicado no registrador base, chegar ao byte desejado?

R: x’048’ = deslocamento (linha azul tracejada)

*




Byte de endereço x’00000048’ :

Base C (conteúdo x’00000000’) + Deslocamento x’048’

Lembrar que

DESLOCAMENTO MÁXIMO = x’FFF’

Ou seja

O registrador C, enquanto tiver x’00000000’ como conteúdo, só consegue ser usado como base para fazer referência aos endereços desde x’00000000’ até x’00000FFF’.




DESLOCAMENTO MÁXIMO = x’FFF’

Se uma instrução precisar endereçar 2 campos:

O de endereço x’00000048’ e o de endereço x’00001CB0’, na hora em que ela for executada, precisa de MAIS DO QUE UM REGISTRADOR BASE preparado convenientemente.

Pode-se, por exemplo,

Ter o registrador C com o conteúdo x’00000000’, e

Ter outro registrador (o D, por exemplo) com o conteúdo x’00001000’




DESLOCAMENTO MÁXIMO = x’FFF’O registrador base C (12) endereça o primeiro campoC048 Base C (com conteúdo x’00000000’ +

Deslocamento x’048’O registrador base D (13) endereça o segundo campoDCB0 Base D (com conteúdo x’00001000’ +

Deslocamento x’CB0’

NÃO TEM JEITO DE numa única instrução, neste caso, usar só um registrador base.




Então, “ao mesmo tempo”, dá para usar no máximo 15 registradores base (lembrar que o zero, mesmo se especificado, tem o conteúdo desprezado para o cálculo de endereços).

Isso significa no máximo (4K * 15) =

60K endereçáveis




Usando (quase) todos os registradores como registradores base, NÃO SOBRA NENHUM (além do zero) !

Cuidado !




Só isso?

E se o programa for maior?




Uma alternativa:

Pensar em quais serão os bases do programa inteiro.

Por exemplo: R3, R4, R5, R6 e R7

São 5 registradores, o que permite endereçar (5 x 4K) = 20K no máximo

Num trecho de 20K, carregar os bases com um conteúdo e usar coisas só desse trecho.

Em outro trecho de 20K, carregar os bases com outro conteúdo e usar coisas só desse novo trecho e assim por diante.




Memória de 60K bytes 56K52K48K44K40K36K32K28K24K20K16K12K8K4K0K

Programa

R3 com x’00000000’

R4 com x’00001000’

R5 com x’00002000’

R6 com x’00003000’

R7 com x’00004000’

R3 com x’00005000’

R4 com x’00006000’

R5 com x’00007000’

R6 com x’00008000’

R7 com x’00009000’

R3 com x’0000A000’

R4 com x’0000B000’

R5 com x’0000C000’

R6 com x’0000D000’

R7 com x’0000E000’



Uso de registradores : idéia / sugestão / dica



Uso de registradores : idéia / sugestão / dica

Reg Uso

0 Evitar; usado pelas rotinas dos métodos de acesso e Sist. Op.

1 Evitar; usado pelas rotinas dos métodos de acesso e Sist. Op. Usado pelas instruções TRT e EDMK

2 Evitar se necessário ou usar para work; usado pela instrução TRT de edição

3 Usar como base

4 Usar como base

5 Usar como base

6 Usar como base

7 Usar como base



Registradores : idéia / sugestão / dica

Reg Uso

8 Usar como work

9 Usar como work

10 Usar como work

11 Usar como work

12 Usar como work

13 Evitar; usado como base de área de salvação de saveareas nos processos de interface entre softwares

14 Evitar; usado em geral como “guardador” do endereço de volta do programa chamador

15 Evitar; usado em geral como pointer para efetuar algum desvio para programa chamado


Representação de dados





Dados alfanuméricosRepresentação em formato caracter, padrão EBCDIC

Dados numéricosRepresentação em formato binário ponto fixo

(operações aritméticas em registradores ou memória)

Representação em formato binário ponto flutuante(operações aritméticas em registradores ou memória)

Representação em formato decimal compactado(operações aritméticas em memória)

Representação em formato decimal zonado(não permite operações aritméticas)


Representação de dados alfanuméricos

Dados alfanuméricos

Representação em formato caracter, padrão EBCDIC



Representação em formato caracter, padrão EBCDIC1 byte por caracter

Ex.: representar palavra “ALBERTO”

Para efeito de comparação, em ASCII é

C1 D3 C2 C5 D9 E4 D6

1100 0001

1101 0011

1100 0010

1100 0101

1101 1001

1110 0100

1101 0110

41 4C 42 45 52 54 4F

0100 0001

0100 1100

0100 0010

0100 0101

0101 0010

0101 0100

0100 1111

A L B E R T O

A L B E R T O



Representação em formato caracter, padrão EBCDIC1 byte por caracter

Ex.: representar palavra “Alberto”

Para efeito de comparação, em ASCII é

C1 93 82 85 99 A4 96

1100 0001

1001 0011

1000 0010

1000 0101

1001 1001

1010 0100

1001 0110

41 6C 62 65 72 74 6F

0100 0001

0110 1100

0110 0010

0110 0101

0111 0010

0111 0100

0110 1111

A 1 b e r t o

A l b e r t o


Representação de dados numéricos

Dados numéricos

Formatos:

- Decimal zonado ou - Decimal compactado ou- Binário de ponto fixo ou- Binário de ponto flutuante



Representação em formato DECIMAL ZONADO

1 byte por algarismo, máximo 16 bytes = máximo 16 algarismosCada byte : à esquerda (parte de zona) = x’F’ à direita (parte numérica) = algarismoÚltimo byte à direita : à esquerda (parte de zona) = sinal

número positivo ou zero : x’F’ ou x’C’ número negativo : x’D’

IMPORTANTE !!!1 Este formato não permite efetuar operações aritméticas,é somente para receber dados (entrada de terminal ou outros meios)ou para formatar saída (terminal, impressão ou outros meios).2 A máquina só trabalha esses números como números INTEIROS.




F1 F2 F3

1111 0001 1111 0010 1111 0011

Representação do número

123

F1 F2 D3

1111 0001 1111 0010 1101 0011


-123

Atenção !!! : se for impresso (ou visualizado em caracter) esta configuração aparece como a letra “L”




F0 F0 F1 F2 F3

1111 0000 1111 0000 1111 0001 1111 0010 1111 0011

Representação do número 123 em um campo de 5 bytes

F0 F0 F1 F2 D3

1111 0000 1111 0000 1111 0001 1111 0010 1101 0011

Representação do número -123 em um campo de 5 bytes

Atenção !!! : se for impresso (ou visualizado em caracter) esta configuração aparece como a letra “L”



Representação em formato DECIMAL COMPACTADO

½ byte por algarismo, ½ byte para o sinal (ver adiante)Máximo 8 bytes = máximo 15 algarismosÚltimo byte à direita : à direita (parte numérica) = sinal

número positivo ou zero : x’F’ ou x’C’ número negativo : x’D’

IMPORTANTE !!!1 Este formato faz operações aritméticas somente em campos de memória (não faz em registradores, nos quais operaçõesaritméticas somente são feitas em binário)2 A máquina só trabalha esses números como números INTEIROS.




02 3F

0000 0010 0011 1111Número 23 : precisa 2 bytes

02 3D

0000 0010 0011 1101

Número - 23 : precisa 2 bytes

02 3C

0000 0010 0011 1100

Atenção !!! : se for impresso (ou visualizado em caracter) estas configurações poder aparecer como “outros” caracteres




12 3F

0001 0010 0011 1111Representação do número

123

12 3D

0001 0010 0011 1101


-123


12 3C

0001 0010 0011 1100





00 00 00 12 3C

0000 0000 0000 0000 0000 0000 0001 0010 0011 1100

Número 123 num campo de 5 bytes

00 00 00 12 3D

0000 0000 0000 0000 0000 0000 0001 0010 0011 1101

Número - 123 num campo de 5 bytes



Representação em formato BINÁRIO PONTO FIXO

Só usa campos com tamanho fixo : ou 2 bytes (1 bit para sinal + 15 bits para número)ou 4 bytes (1 bit para sinal + 31 bits para número)ou 8 bytes (1 bit para sinal + 63 bits para número)

A quantidade de algarismos (nos números decimais equivalentes)depende do número representado (VER TABELA NO PRÓXIMO SLIDE)Primeiro BIT à esquerda = sinal

número positivo ou zero : 0 ; número negativo : 1MAS...

Se positivo, é o próprio número binário representado Se negativo, o número binário representado é o complemento

dele para a próxima potência de 2 (ver adiante)

IMPORTANTE !!!1 Este formato faz operações aritméticas entre registradores ou entre registrador e campo de memória (NÃO FAZ SÓ EM CAMPOS DE MEMÓRIA, precisa ter registrador envolvido) 2 A máquina só trabalha esses números como números INTEIROS.




Qtdd de

bytes

Ordem de grandeza

Exemplo de uso Faixa de números inteiros decimais que podem ser representados, se for

“quantidade”

2

Milhares (32K)

Idade pessoa, contador de linhas

-32.768

a 32.767

4

Bilhões (2G)

Salário, Código de peça, Código de

cliente-2.147.483.648

a 2.147.483.647

8

Quintilhões (9Exa)

Receitas de empresas, População mundial,

distâncias astronômicas

-9.223.372.036.854.775.808

a 9.223.372.036.854.775.807




Exemplo de números e complementos:

Número +123 em binário = 1111011

Número –123 em binário = ...1111111111111111111111110000101

Por quê? 000000100- 000000001 ----------- 000000011

4 - 1----- 3

000000011

- 000000001

----------- 000000010

3 -1----- 2

000000010

- 000000001

--------- 000000001

2- 1----- 1

000000001 - 000000001 ----------- 000000000

1 - 1----- 0

000000000

- 000000001

----------- 111111111

0 - 1----- -1

111111111

- 000000001

----------- 111111110

-1 - 1----- -2

111111110 - 000000001 ----------- 111111101

-2 - 1----- -3

Etc... Etc... 110000110

- 000000001

----------- 110000101

-122 - 1----- -123



Binário Ponto Fixo

Como converter um número decimal negativo para binário?

Converter o número positivo correspondente para binário (considerar somente os dígitos significativos) Inverter os dígitos: 1 torna-se 0 e 0 torna-se 1 Somar 1 Preencher à esquerda com 1’s até completar uma halfword, fullword ou doubleword Exemplo: supor o número decimal –123; +123 é 1111011 Converter o número positivo correspondente para binário 1111011 Inverter: 1 torna-se 0 e 0 torna-se 1 0000100 Somar 1 0000100

+ 1-------0000101

preencher à esquerda com 1’s para completar uma halfword, fullword ou doubleword 1111111110000101 F F 8 1111.1111.1111.1111 1111.1111.1000.0101 F F 8 5 1111.1111.1111.1111.1111.1111.1111.1111.1111.1111 1111.1111.1000.0101 F F F F F F F F F F F F 8 5



Binário Ponto Fixo

Como converter um número binário negativo para decimal?

Subtrair de X’....FFFFFF’ (o número X’...F’ maior que o número a converter)

Somar 1; o resultado é o número desejado , mas POSITIVO. Converta-o para negativo.

Exemplo: supor X’FFE8’

Subtrair FFFF - FF85

----007A

Somar 1 007A - 1

----007B

X’7B’ é o hexadecimal equivalente ao decimal 123.

Portanto, o número desejado é o decimal -123




00000000 01111011Representação

do número 123

Atenção !!! : as configurações dos bytes, se visualizado em caracter, podem aparecer como “outros” caracteres

Em (halfword)

00000000 00000000 00000000 01111011Em (fullword)

Em (doubleword)00000000 00000000 00000000 00000000 00000000 00000000 00000000 01111011

X’007B’

X’0000007B’

X’000000000000007B’




Atenção !!! : as configurações dos bytes, se visualizado em caracter, podem aparecer como “outros” caracteres

11111111 10000101Representação

do número -123

Em (halfword)

11111111 11111111 11111111 10000101Em (fullword)

Em (doubleword)11111111 11111111 11111111 11111111 11111111 11111111 11111111 10000101

X’FF85’

X’FFFFFF85’

X’FFFFFFFFFFFFFF85’



Representação em formato BINÁRIO PONTO FLUTUANTE

Sorry... Não é escopo deste curso...


Representação de instruções

Representação de INSTRUÇÕES



Principais formatos de instruções

RR = 2 bytes

RX = 4 bytes RS = 4 bytes SI = 4 bytes

SS = 6 bytes

2 bytes : códigos de operação entre x’00’ e x’3F’ (b’0000 0000’ a b‘0011 1111’)4 bytes : códigos de operação entre x’40’ e x’BF’ (b’0100 0000’ a b‘1011 1111’’)6 bytes : códigos de operação entre x’C0’ e x’FF’ (b’1100 0000’ a b‘1111 1111’)




RR – (em princípio) 2 operandos, ambos em registradores

RX – 2 operandos: 1 em registrador 1 em memória : especificação de endereço indicando Indexador + [ Base + Deslocamento ]

RS – 3 operandos, 2 em registradores e 1 em memória 2 registradores (pode ser um “range”/faixa) 1 em memória : especificação de endereço indicando [ Base + Deslocamento ]

SI – 2 operandos, ambos em memória 1 em memória imediata = 1 único byte que é parte da própria instrução (ou seja, não precisa especificar endereço) 1 em memória : especificação de endereço indicando [ Base + Deslocamento ]

SS – 2 operandos, ambos em memória Ambos com especificação de endereço indicando [ Base + Deslocamento ]




RR – (em princípio) 2 operandos, ambos em registradores

x

CO

Registrador 1o.

operandox

Registrador 2o.

operandoxcódigo operação

R1 R2

0 5 E Fx

Código de operação = X’05’

Registrador 1o operando = X’E’ (registrador 14)

Registrador 2o operando = X’F’ (registrador 15)



Principais formatos de instruções RX – 2 operandos: 1 em registrador e 1 em memória : especificação de endereço indicando Indexador + [ Base + Deslocamento ]

x

CO

Registrador 1o.

operandox

Registrador Indexador

do 2o. operandox

código operação

R1 X2x

B2 D2

Base + Deslocamento do 2o. operando

D2 D2

4 5 E 0x

3 C 2 8x

Código de operação = X’45’ ; Registrador 1o operando = X’E’ (registrador 14) ; Registrador Indexador do 2o operando = registrador X’0’ (registrador 0); Registrador base do 2o operando = registrador X’3’ (registrador 3); Deslocamento do 2o operando = X’C28’



Principais formatos de instruções RS – 3 operandos, 2 em registradores e 1 em memória 2 registradores (pode ser um “range”/faixa) 1 em memória : especificação de endereço indicando [ Base + Deslocamento ]

xCO

Registrador 1o.

operandox

Registrador 3o.

operandoxcódigo operação

R1 R3x

B2 D2


D2 D2

9 8 E Cx

D 0 0 0x

Código de operaçao = X’98’ ; Registrador 1o operando = registrador X’E’ (registrador 14) ; Registrador 3o operando = registrador X’C’ (registrador 12); Registrador base do 2o operando = registrador X’D’ (registrador 13); Deslocamento do 2o operando = X’000’



Principais formatos de instruções SI – 2 operandos, ambos em memória 1 em memória imediata = 1 único byte que é parte da própria instrução 1 em memória : especificação de endereço indicando [ Base + Deslocamento ]

x

CO

Operando Imediato

(2o. Operando)código operação

I2x

B1 D1


D1 D1

9 2 5 Cx

5 6 D 2x

Código de operação = X’92’ ; 2o operando (operando imediato) = X’5C’ ; Registrador base do 1o operando = registrador X’5’ (registrador 5); Deslocamento do 1o operando = X’6D2’




SS – 2 operandos, ambos em memória; 1 único tamanho especificado (vale para os 2 operandos). Endereços especificados na forma [ Base + Deslocamento ]

x

CO

código operação

Lx

B1 D1

Base + Deslocamento

do 1o. operando

D1 D1 B2 D2 D2 D2

Base + Deslocamento

do 2o. operandoTamanho dos 2

operandos

- 1

4 Fx

3 B 9 4x

6 F 2 AD 2

Código de operação = X’D2’ ; Tamanho para os 2 operandos = X’4F’ (80 bytes);Registrador base do 1o operando = X’3’ (registrador 3); Deslocamento do 1o operando = X’B94’; Registrador base do 2o operando = X’6’ (registrador 6); Deslocamento do 2o operando = X’F2A’




SS – 2 operandos, ambos em memória; 2 tamanhos especificados, 1 para cada operando. Endereços especificados na forma [ Base + Deslocamento ]

x

CO

código operação

L1 L2x

B1 D1

Base + Deslocamento

do 1o. operando

D1 D1 B2 D2 D2 D2

Base + Deslocamento

do 2o. operando

Tamanho 1o. Operando - 1

Tamanho 2o. Operando - 1

F 8 4 0x

3 7 7 Ex

4 D 6 2

Código de operação = X’F8’ ; Tamanho do 1o operando = X’4’ (5 bytes) ; Tamanho do 2o operando = X’0’ (1 byte);Registrador base do 1o operando = X’3’ (registrador 3); Deslocamento do 1o operando = X’77E’; Registrador base do 2o operando = X’4’ (registrador 4); Deslocamento do 2o operando = X’D62’



Exercício

EP301

Somente veja o resultado aqui depois de tentar resolver


Linguagem Assembler

LINGUAGEM ASSEMBLER


Fluxo do montador

LOADER

Storage

SYSLIBMacros/Copys

SYSINFonte

SYSUT1Work

IEV90

SYSPUNCHObjeto

SYSGOObjeto

SYSPRINTList

SYSLINObjeto

SYSINControl stmts

SYSLIBOutras entradas

SYSUT1Work

IEWL

SYSPRINTList

SYSLMODExecutável

LINKLIB


Jeitão de um programa Assembler




Pode ser assim...

Programa

Instruções Áreas

LOAD POINT = ENTRY POINT



Ou assim...

Programa

Áreas Instruções

LOAD POINT ENTRY POINT



Assim também...

Programa

I

LOAD POINT =

ENTRY POINT

A I A I A I



Até com o estilo da casa da sogra...

Programa

LOAD POINT =

ENTRY POINT

IAIAIAIAIAIAIAI



Ou da sogra da casa...

Programa

LOAD POINT

AIAIAIAIAIAIAIA

ENTRY POINT



Lembrar que um programa reentrante pode ser assim...

Programa P1

An....A3A2A1

Instruções de P1( manipulando A1, e, concorrentemente ou paralelamente,

manipulando A2, manipulando A3, etc... manipulando An)

O programa P1 na verdade é :

Instruções de P1 Áreas de P1 (ou A1 ou A2 ou etc)

+



O que deu para perceber a respeito da estrutura de um programa em Assembler?

Pode ser de qualquer jeito !Se não mandar desviar, ele vai tentar executar uma área como se fosse instrução...É a arquitetura de von Newman...

Veja...


Statement

STATEMENT Assembler


Statement

Posição 1 : Se tiver *, statement inteiro é comentário Posições 1 a 8: SímboloPosições 10 a 14: Código da InstruçãoPosições 16 a 71: Operandos e ComentáriosPosição 72: Indicador de ContinuaçãoPosições 73 a 80: Identificação e Sequência

123456789012345678901234567890123456789012345678901234567890123456789012

* ESTE STATEMENT TODINHO EH UM COMENTARIO COMPLETA MVC ARIMP,=CL133'b' COMENTARIO = LIMPAR ARIMP OI *+5,X’F0’ COMENTARIO = FORCE BRANCHAQUI EQU *WMENSAGE DC C’AJK001A – OPEN PARA ARQUIVO SEM O DEVIDO STATEMENT DD – NO JCL. ACORDE E PROVIDENCIE!.’ ISTO TAMBEM EH COMENTARI

Símbolo Instrução Operandos e Comentários

Continuação


Statement

INIT TITLE 'ROTINA DE INICIALIZACAO'

SEGINIT DFHEIENT CODEREG=7,DATAREG=(10,11),EIBREG=9

B BEGIN SALTA CONSTANTES

DC C'5785-XAW COPYRIGHT IBM BRASIL 1985'

DC CL17'***SEGINIT,1.0***'

DC CL24'***ULT.MANUT.23/10/90***'

BEGIN EXEC CICS ADDRESS CWA(R13)

L R12,DFHEICAP ENDERECA INICIO DA COMMAREA

ST R13,TWSVCWA SALVA ENDERECO DA CWA

LA R2,TWAREA ENDERECO DO INICIO DA COMMAREA

LA R3,JREND ENDERECO DO FIM DA COMMAREA

SR R3,R2 TAMANHO DA COMMAREA

STH R3,TWLENGTH EM TWLENGTH

SPACE 2

Começando a sentir o cheirinho do jeitão do Assembler...


Statement

COPY COVER 00000130CWA DSECT 00000140 USING *,R13 00000150 COPY CWAREA 00000160 COPY TADSECT 00000170COMMAREA DSECT 00000180 USING *,R12 00000190 COPY TWAREA 00000200DFHEISTG DSECT 00000210 DFHEISTG 00000220 DFHEIEND 00000230 EJECT 00000240T131 TITLE 'TABELA DE TRANSACOES DE SERAG - NUMERO 131' 00000250 SPACE 2 00000260SEG131 DFHEIENT CODEREG=(7,9),DATAREG=(10,11),EIBREG=5 00000270 B BEGIN SALTA CONSTANTES 00000280 DC C'5785-XAW COPYRIGHT IBM BRASIL 1985' 00000290 DC CL16'***SEG131,3.2***' 00000300 DC CL24'***ULT.MANUT.19/07/2001*' BEGIN L R12,DFHEICAP ENDERECO DA COMMAREA 00000320 L R8,TWSVTERM ENDERECO DA AREA DE TERMINAIS 00000330 L R13,TWSVCWA ENDERECO DA CWA 00000340

+ Cheirinho (amarelo = Instr, azul = áreas, branco = comandos ao montador) ...

volta pro jeitão ...


Statement

* ================================================================== * 00000360* LOGICA COMUM PARA LOCALIZAR UMA ENTRADA NA TABELA DE TRANSACOES * 00000370* ================================================================== * 00000410 LA R2,TRLT 00000420TRLTLOOK CLI 0(R2),X'FF' FIM DA TABELA ? 00000430 BE ERRO TRLT NAO ESTA NA TABELA 00000440 CLC TWDBL(6),0(R2) CODIGO TRANSACAO ESTA NA TABELA ? 00000450 BE TRL0100 SIM 00000460 SR R15,R15 LIMPA REGISTRADOR 15 00000470 IC R15,40(R2) BYTE DE COMPRIMENTO DA ENTRADA 00000480 N R15,=F'127' ELIMINA BIT DE MAIS ALTA ORDEM-X'7F' 00000490 AR R2,R15 INCREMENTA POINTER DA TABELA 00000500 B TRLTLOOK E PESQUISA NOVAMENTE 00000510TRL0100 MVC TWTRLT,0(R2) MOVE TRLT PARA TWA 00000520EXIT EXEC CICS RETURN 00000530ERRO LA R2,25 -CODIGO ERRADO- 00000540 OI TWSW,X'01' LIGA SWITCH DE CANCELAMENTO 00000550 LA R3,7 TAMANHO DA WORKAREA DE MENSAGENS 00000560 LA R1,TWMSG ENDERECO WORKAREA DE MENSAGENS 00000570 STC R2,0(R1) MOVE NUM.MENSAGEM PARA WORKAREA 00000580 B EXIT RETORNA 00000590 LTORG 00000600



Statement

* ================================================================== * 00000620* TRANSACOES VALIDAS * 00000630* ================================================================== * 00000640TRLT TRLT CODE=000301, X00001540 TIT='CHEQUE SACADO ', X00001550 MAPN='NAO', X00001560 PTCM=01, X00001570 SPEC=14, X00001580 MNEM='CHS' 00001590 TRLT CODE=000302, X00001600 TIT='SAQUE AVULSO ', X00001610 MAPN='NAO', X00001620 PTCM=02, X00001630 SPEC=14, X00001640 MNEM='SAV' 00001650 END SEG131 00009330



Montador Assembler

Umas “cositas” do montador Assembler


Montador Assembler

“Cosita” 1 = Location Counter


00000 34 BLOCO1 EQU * 000000 35 DS CL4096 001000 00000 36 ORG BLOCO1 000000 37 DS CL1024 000400 38 A DS CL16 000410 39 B DS CL16 40 * . . 000420 3400 41 DC S(A) 000422 3410 42 DC S(B) 000424 400040165000502C 43 DC S(C,D,E,F) 00042C 6000604270007058 44 DC S(G,H,I,J) 45 * . . 000434 D20F 3400 3410 00400 00410 46 MVC A,B 00043A D215 4000 4016 01000 01016 47 MVC C,D 000440 D22B 5000 502C 02000 0202C 48 MVC E,F 000446 D241 6000 6042 03000 03042 49 MVC G,H 00044C D257 7000 7058 04000 04058 50 MVC I,J

Montador Assembler

Location Counter : há 1 para cada Section (Control e Dummy)

É um contador que começa com x’00000000’ e vai sendo - Incrementado cada vez que se aloca memória (por declaração de variável ou de instrução, por exemplo)- Alterado quando é pedido explicitamente por meio de um comando ao montador Assembler que o afete (ex.: ORG)


Montador Assembler

“Cosita” 2 = “Listagem gerada (algumas das coisas listadas também

fazem parte do programa-objeto)


Montador Assembler

EXTERNAL SYMBOL DICTIONARY SYMBOL TYPE ID ADDR LENGTH LD ID FLAGS PROGDEMO SD 0001 000000 000AF3 00 FORA ER 0002 Z LD 000844 0001 SUBROT ER 0003

External Symbol Dictionary : Lista de elementos que devem ser tratados pelo Linkage Editor e Loader


Montador Assembler

LOC OBJECT CODE ADDR1 ADDR2 STMT SOURCE STATEMENT 49 * VOU MUDAR PARA PRINT DATA 50 PRINT DATA 00003B C1D3C2C5D9E3D6 51 DC CL7'ALBERTO' 000042 C1D3C2C5D9E3D65C 52 DC CL8'ALBERTO*' 00004A C1D3C2C5D9E3C9D5 53 DC CL10'ALBERTINHO' 000052 C8D6 54 * VOU RESTAURAR O DEFAULT 55 PRINT NODATA 000054 C1D3C2C5D9E3D6 56 DC CL7'ALBERTO' 00005B C1D3C2C5D9E3D65C 57 DC CL8'ALBERTO*' 000063 C1D3C2C5D9E3C9D5 58 DC CL10'ALBERTINHO' 59 *----------------------------------- 60 * PRINT ON/OFF

Listagem do programa


Montador Assembler

RELOCATION DICTIONARY POS.ID REL.ID FLAGS ADDRESS 0001 0001 0C 000070 0001 0001 08 0001B9 0001 0001 0C 000860 0001 0001 0C 000864 0001 0001 0C 000868 0001 0001 0C 00086C 0001 0001 0C 000874 0001 0001 0C 0008A4 0001 0001 0C 0008A8 0001 0001 04 000A46

Relocation Dictionary : mais trabalho para o Linkage Editor e o Loader


Montador Assembler

Cross Reference / Symbol Table : vai sendo montada a cada passo de montagem, a cada vez que surge um statement com um label (símbolo).

CROSS REFERENCE SYMBOL LEN VALUE DEFN REFERENCES AAALIN 00001 000A68 0272 0297 ANO 00002 000AE6 0319 ARIMP 00133 0001C0 0130 0129 A1 00004 000848 0220 0229 A11 00001 000878 0231 0231 A12 00001 000879 0232 0232 A13 00001 000881 0233 0233 A2 00004 00084C 0221 0230 A3 00004 000854 0222 A4 00004 000858 0223 A5 00004 00085C 0224 0225 0226 0227 0261 0262 0263 BYTE ****UNDEFINED**** 0285 BYTEON 00001 000000FF 0085 CAMPO 00001 00008A 0091 0092 CAMPO 00001 00000000 0321 ****DUPLICATE**** COCIENTE 00012 00000074 0082 0256 DATA 00006 000AE2 0316

.

.

Atributo de tamanho

Símbolos (labels) Endereços


Montador Assembler

Se você usa um símbolo que vai ser convertido para endereço BASE + DESLOCAMENTO

e a conversão não for possível(o montador não conseguir fazer):

ADDRESSABILITY ERROR = Falta de registrador Base para esse endereço.


Montador Assembler

DIAGNOSTIC CROSS REFERENCE AND ASSEMBLER S THE FOLLOWING STATEMENTS WERE FLAGGED 000028 000119 000120 000122 000123 000125 000134 000142 000149 000156 000 000205 000212 000256 000261 000262 000263 000264 000265 000266 000267 000 30 STATEMENTS FLAGGED IN THIS ASSEMBLY 12 WAS HIGHEST SEVERITY CO OVERRIDING PARAMETERS- LINECOUNT(50),XREF(FULL) OPTIONS FOR THIS ASSEMBLY DECK, NOOBJECT, LIST, XREF(FULL), NORENT, NOTEST, NOBATCH, ALIGN, ESD, R FLAG(0), SYSPARM() NO OVERRIDING DD NAMES 312 CARDS FROM SYSIN 216 CARDS FROM SYSLIB 572 LINES OUTPUT 73 CARDS OUTPUT

Diagnósticos


Montador Assembler

“Cosita” 3 = Expressões


Montador Assembler

EXPRESSÕES

Conjunto de termos que tem um valor e que eventualmente pode ser convertido em um endereço.Se for convertido o formato será base + deslocamento.


Montador Assembler

EXPRESSÕES

Podem ser compostas por:

- Símbolos- Termos auto-definidos

(decimal, binário, caracter ou hexadecimal)

- Atributos de tamanho- Referência ao Location Counter- Operadores aritméticos ( + - * / )- Parênteses pareados


Montador Assembler

EXPRESSÕES

Exemplos

Expressão O valor resultante corresponde a

LPOUP primeiro byte à esquerda de LPOUP(Supor endereço de LPOUP = x’000A000C’; o valor da expressão LPOUP é x’000A000C’)

Esta expressão : somente 1 termo: 1 símbolo [LPOUP]

LPOUP+0 primeiro byte à esquerda de LPOUP(Supor endereço de LPOUP = x’000A000C’; o valor da expressão LPOUP+0 é x’000A000C’)

Esta expressão : 2 termos: 1 símbolo [LPOUP] e 1 termo auto-definido (decimal) [0]


Montador Assembler

EXPRESSÕES


LPOUP+3 quarto byte de LPOUP(Supor endereço de LPOUP = x’000A000C’; o valor da expressão LPOUP+3 é x’000A000F’)


LPOUP+15 16o. byte de LPOUP(Supor endereço de LPOUP = x’000A000C’; o valor da expressão LPOUP+15’ é x’000A001B’)



Montador Assembler

EXPRESSÕES


LPOUP+B’1111’ 16o. byte de LPOUP(Supor endereço de LPOUP = x’000A000C’; o valor da expressão LPOUP+B’1111’’ é x’000A001B’)

Esta expressão : 2 termos: 1 símbolo [LPOUP] e 1 termo auto-definido (binário) [B’1111’]

LPOUP+C’F’ 199o. byte de LPOUP(Supor endereço de LPOUP = x’000A000C’; o valor da expressão LPOUP+C’F’’ é x’000A00D2’)

Esta expressão : 2 termos: 1 símbolo [LPOUP] e 1 termo auto-definido (caracter) [C’F’]

Lembre que C’F’ = X’C6’X’000A000C’ + X’C6’ = X’000A00D2’


Montador Assembler

EXPRESSÕES


WAREA+50+X’100’+B’1100’+C’ ’ 383o. byte de WAREA(Supor endereço de WAREA = x’000A000C’; o valor da expressão WAREA+50+X’100’+B’1100’+C’ ‘ é x’000A018A’)

Esta expressão : 5 termos: 1 símbolo [WAREA] 1 termo auto-definido (decimal) [50] 1 termo auto-definido (hexadecimal) [X’100’] 1 termo auto-definido (binário) [B’1100’] 1 termo auto-definido (caracter) [C’ ‘]

Obs.: Decimal 50 = X’32’; B’1100’ = X’C’ ; C’ ‘ (espaço) = X’40’X’32’ + X’100’ + X’C’ + X’40‘ = X’17E’ = decimal 382X’000A000C’ X’32’ + X’100’ + X’C’ + X’40’ = X’000A018A’


Montador Assembler

EXPRESSÕES


WAREA+L’WAREA 1o. byte depois de (toda) WAREAEsta expressão : 2 termos: 1 símbolo (WAREA) e

1 atributo de tamanho [L’WAREA]

WAREA+1 1o. byte depois do inicio de WAREA (2o. byte de WAREA)Esta expressão : 2 termos: 1 símbolo (WAREA) e

1 termo decimal auto-definido [1]

WAREA+L’WAREA-1 último byte de WAREAEsta expressão : 3 termos: 1 símbolo (WAREA) e

1 atributo de tamanho [L’WAREA] 1 termo decimal auto-definido [1]


Montador Assembler

EXPRESSÕES


WAREA+L’FIXDLEN+1000Esta expressão : 3 termos: 1 símbolo (WAREA) +

1 atributo de tamanho [L’FIXDLEN] + 1 termo auto-definido (decimal) [1000] Supor que WAREA é composta por uma área denominada FIXDLEN + uma área de tamanho 1000 bytes.O valor da expressão WAREA+L’FIXDLEN +1000 corresponde aoprimeiro byte após toda a área WAREA ( WAREA + tamanho de FIXDLEN + 1000)


Montador Assembler

EXPRESSÕES


L’WATERM1+L’WATERM2+L’WATERM3 Esta expressão : 3 termos: 3 atributos de tamanho

[L’WATERM1, L’WATERM2, L’WATERM3] tamanho da area WATERM1 +tamanho da area WATERM2 +tamanho da area WATERM3 Supondo que o tamanho de WATERM1 seja de 1000 bytes, o tamanho de WATERM2 seja de 2000 bytes, e o tamanho de WATERM3 seja 3000 bytes(tamanho total = 6000 bytes [decimal] ou X’1770’ em hexadecimal)O valor da expressão L’WATERM1+ L’WATERM2+ L’WATERM3 éX’1770’


Montador Assembler

EXPRESSÕES


*+1 byte seguinte onde está o loc. CounterEsta expressão : 2 termos: 1 referência ao Location Counter (*) +

1 termo auto-definido (decimal) [1]

*+L’WAREA endereço que está no location counter +x bytes (x = tamanho WAREA)

Esta expressão : 2 termos: 1 referência ao Location Counter (*) + 1 atributo de tamanho [L’WAREA]

L’COMUM+L’REGTIP1 Tamanho de comum + tamanho de REGTIP1 Esta expressão : 2 termos: 2 atributos de tamanho [L’COMUM, L’REGTIP1]


Montador Assembler

“Cosita” 4 = Referências explícitas e implícitasNos operandos


Montador Assembler

Referências explícitas e implícitas

Registradores: sempre referenciados explicitamente

AR 1,6LR R5,R14

LR 5,14 LR R5,14 Sacanagem... LR 5,R14 Sacanagem...


Montador Assembler


Memória: referenciada explicitamente ou implicitamente

Instruções RX :

Referência explícita: op reg1,d2(x2,b2)L 14,12(13)L R14,12(R13) SE TIVER EQUATESST 7,96(8)ST 7,96(R8) SE TIVER O EQU DO R8

Referência implícita: op reg1,expressão2 (assume indexador = 0) or op reg1,expressão2(index2)

L 14,SAVE14L 14,SAVEAREA+12ST 7,WSALVA(7)ST 7,WSAVAREA+(7*4)


Montador Assembler



Instruções RS :

Referência explícita: op reg1,reg3,desloc2(base2)LM 14,12,12(13) STM 7,11,0(R12)

Referência implícita: op reg1,reg3,expressão2LM 14,12,SAVEAREA+12STM 14,12,SARVA


Montador Assembler



Instruções SI :

Referência explícita: op desloc1(base1),imediato2MVI 10(R12),C’*’XI 0(15),X’FF’

OI 15(R8),X’80’

Referência implícita: op expressão1,imediato2MVI FLAGS+77,C’*’XI TOGGLE,X’FF’

OI PRINTED,X’80’


Montador Assembler



Instruções SS/L :

Referência implícita: op expressão1, expressão2(assume tamanho do 1o operando)

MVC ARIMP+77,C’*’ T-A-K-E C-A-R-E!!!* ACHO QUE NÃO EH ISSO !!!

MVC ARIMP+77,=C’*’* NEM ISSO !!! MVC ARIMP+77(1),=C’*’* AH! ACHO QUE EH ISSO !!! CLC AGENTCOD,CODWANT (tamanho implícito = tamanho de AGENTCOD) CLC IVSAM(3),CODWANT (tamanho = 3 = explicitamente indicado) CLC IVSAM+68(3),CODWANT (tamanho = 3 = explicitamente indicado) CLC IVSAM+68,CODWANT (tamanho implícito = tamanho de IVSAM)


Montador Assembler



Instruções SS/L :

Referência explícita: op desloc1(tamanhoambos,base1),desloc2(base2)

MVC 0(18,7),=C’ERROR’ (tamanho = 18 = explicitamente indicado)CLC AGENTCOD,25(14) (tamanho assumido = tamanho de AGENTCOD)CLC AGENTCOD+33,25(14) (tamanho assumido = tamanho de AGENTCOD)CLC AGENTCOD+33(2),25(14) (tamanho = 2= explicitamente indicado)

CLC 3(22,8),7(15) (tamanho = 22 = explicitamente indicado)


Montador Assembler



Instruções SS/L1-L2 :

Referência implícita: op expressão1, expressão2(Tamanho assumido para o 1o operando = tamanho do 1o operando; Tamanho assumido para o 2o operando = tamanho do 2o operando)

AP COUNTLIN,=P’1’ ZAP TOTVAL,=P’0’ AP BIGTOT,SUBTOT MP WNUM,=P’12’ MP WNUM+44(3),=P’12’


Montador Assembler



Instruções SS/L1-L2 :

Referência explícita: op desloc1(tamanho1,base1),desloc2(tamanho2,base2)

AP 0(4,3),=P’1’ ZAP 17(16,12),=P’0’ AP BIGTOT,127(2,5) MP WNUM+44(8),222(3,R6)


Montador Assembler

Instruções:

- Instruções ou comandos ao montador

- Instruções de máquina

- Macro-instruções


Montador Assembler

Instruções ou comandos ao montador

- Definição de áreas: DC, DS, CCW, CCW0, CCW1

- Seccionamento de um Programa e Ligação: START, CSECT, DSECT, DXD, CXD, COM, ENTRY, EXTRN, WXTRN

- Controle de Registradores Base: USING, DROP

-Controle da listagem: TITLE, EJECT, SPACE, PRINT

- Controle de programa: ICTL, ISEQ, PUNCH, REPRO, ORG, EQU, OPSYN, PUSH, POP, LTORG, CNOP, COPY, END, LOCTR, AMODE, RMODE

- Definição de macro-instrução: AREAD, MACRO, MEXIT, MEND

- Montagem condicional (normalmente usadas para elaborar macro-instruções): ACTR, AGO, AIF, ANOP, GBLA, GBLB, GBLC, LCLA, LCLB, LCLC, MHELP, MNOTE, SETA, SETB, SETC


Montador Assembler

Instruções de máquina (algumas)

- Movimento memória-memória : MVC, MVZ, MVN, MVI, MVO, ZAP, MVCL, PACK, UNPK, MVCI

- Movimento de dados de registrador para memória : ST, STH, STM, STC, STCM, CVD

- Movimento de dados de memória para registrador : L, LH, LM, IC, ICM, CVB

- Movimento de dados de registrador para registrador : LR, LPR, LNR, LCR, LTR

- Aritméticas em memória com campos compactados : AP, SP, MP, DP, SRP

- Aritméticas com registradores : AR, SR, MR, DR, ALR, SLR

- Aritméticas com registradores e memória : A, S, M, D, AH, SH, MH, AL, SL

- Comparação : CP, CLC, CLI, CLCL, C, CH, CL, CLM, CR, CLR

- Desvio : BC, BCR

- Controle de loop : BCT, BCTR, BXH, BXLE

- Edição : ED, EDMK

- Tradução e teste de bytes : TR, TRT

- Shift em registradores : SLL, SRL, SLDL, SRDL, SLA, SRA, SLDA, SRDA

- Álgebra booleana : N, O, X, NR, OR, XR, NI, OI, XI, NC, OC, XC

- Carga e desvio : BALR, BAL, BAS, BASR, BASSM, BSM

- Outras instruções : LA, TM, EX, SVC, MC, SPM, IPM, STCK, TS, CS, CDS


Montador Assembler

Macro-instruções

Da instalação(por ex.) EXTENSO, etc...

Da IBM (do sistema operacional, métodos de acesso)

DCB (para declaração datasets – arquivos)OPEN, CLOSE, GET, PUT, READ, WRITEGETMAIN, FREEMAIN, ATTACH, DETACHetc...

Da IBM (específicas CICS, DB2, etc...) DFHMSD, DFHMDF, etc...


Comandos ao Montador

Comandos ao montador



Estes não estão no escopo deste curso): AREAD, MACRO, MEXIT, MENDACTR, AGO, AIF, ANOP, GBLA, GBLB, GBLC, LCLA, LCLB, LCLC, MHELP, MNOTE, SETA, SETB, SETC

AMODE

CCW

CCW0

CCW1

CNOP

COM

COPY

CSECT

CXD

DC

DROP

DS

DSECT

DXD

EJECT

END

ENTRY

EQU

EXTRN

ICTL

ISEQ

LOCTR

LTORG

OPSYN

ORG

POP

PRINT

PUNCH

PUSH

REPRO

RMODE

SPACE

START

TITLE

USING

WXTRN

Comandos Assembler (ordem alfabética)



Comandos ao montador (por grupo)-Controle de entrada e de listagem: TITLE, EJECT, SPACE, PRINT, PUNCH, REPRO, ICTL, ISEQ- Seccionamento e ligação de programa: START, END, CSECT, DSECT, COM, - Controle de registrador(es) base: USING, DROP, POP, PUSH- Manipulação direta do Location Counter : ORG, EQU, CNOP, LOCTR- Uso de objetos externos ou uso externo de objetos internos: ENTRY, EXTRN, WXTRN, DXD, CXD- Diversos: AMODE, RMODE, COPY, OPSYN - Declaração de literais: LTORG - Definição de áreas: DC, DS, CCW, CCW0, CCW1 - Definição de macro instruções: AREAD, MACRO, MEXIT, MEND- Montagem condicional (normalmente usado para elaborar macro-instruções): ACTR, AGO, AIF, ANOP, GBLA, GBLB, GBLC, LCLA, LCLB, LCLC, MHELP, MNOTE, SETA, SETB, SETC


Comandos ao montador - AMODE

AMODE (Adressing Mode - Modo de endereçamento)

Este comando é utilizado para especificar ao montador Assembler o modo de endereçamento a ser associado a uma Control Section. O seu formato é: [símbolo] AMODE n n podendo ser 24 ou 31 ou ANY. O símbolo é opcional. Se omitido, o modo de endereçamento será associado à Control Section sem nome que deve existir no programa.Se especificado, o modo de endereçamento será associado à Control Section que tiver nome igual ao especificado no símbolo.

O operando indica qual modo de endereçamento deve ser associado à Control Section; pode ser 24 (endereçamento de 24 bits), 31 (endereçamento de 31 bits) ou ANY (a Control Section não é sensível ao modo de endereçamento).

Não pode haver dois ou mais AMODE para uma mesma Control Section.O comando AMODE pode estar em qualquer lugar do programa.AMODE 24 é incompatível com RMODE ANY.

Comandos


Comandos ao montador - AMODE

AMODE (Adressing Mode - Modo de endereçamento)

Os defaults para AMODE e RMODE quando só um deles (ou nenhum) é especificado são os seguintes:

Especificado Assumido nenhum AMODE 24 e RMODE 24AMODE 24 RMODE 24AMODE 31 RMODE 24AMODE ANY RMODE 24RMODE 24 AMODE 24RMODE ANY AMODE 31

Comandos


Comandos ao montador – CCW’s

CCW / CCW0 / CCW1 (Channel Command Word)

Sorry. Não faz parte do escopo deste curso.

Comandos


Comandos ao montador -CNOP

CNOP (Conditional Nop - Nop Condicional)

O comando CNOP alinha o Location Counter para uma halfword. Os bytes "desprezados" são preenchidos com X'0700' (instrução NOPR). O seu formato é:

CNOP a,b

Sendo:

a - Pode ser 0, 2, 4 ou 6. Indica em qual Byte da fullword ou da doubleword deve ser posicionado o Location Counter.

b - Pode ser 4 ou 8. Indica se o campo deve ser uma fullword ou doubleword.

Ex:

CNOP 2,4

• 0,8 • 2,8 • 4,8 • 6,8

• 0,4 • 2,4 • 0,4 • 2,4

Comandos


Comandos ao montador - COM

COM (Blank Common Control Section)

Este comando identifica e aloca uma CSECT que seja uma área de memória comum a mais de uma CSECT (CSECT compartilhada). Ela pode ser referenciada por módulos independentes e carregada como um único programa,

Não admite símbolo nem operandos.

Somente uma COM é permitida em cada programa, embora possa haver diversos comandos COM, o primeiro deles indicando o início (primeiro “pedaço”) da COM, e os demais indicando sua(s) continuação(ões). Sintaxe:

COM

Exemplo:CSPRG START 0 . . COMA DS CL3B DS CL4 . . END

Comandos


Comandos ao montador - COPY

COPY (Copiar)

O comando COPY copia comandos Assembler de uma biblioteca. O seu formato é o seguinte:

COPY símbolo

Sendo símbolo o nome com que o conjunto de comandos se encontra catalogado na biblioteca.

Dentro dos comandos não pode haver nem ICTL nem ISEQ. Ex:

COPY EQUREG

Comandos


Comandos ao montador - CSECT

CSECT (Control Section - Seção de Controle)

O comando CSECT identifica o início ou a continuação de uma Control Section. [símbolo] CSECT

O comando CSECT não admite operandos.

Se o símbolo for colocado, ele dará nome à CSECT.

Os comandos e instruções que forem colocados após o comando CSECT farão parte dela, até que seja colocado um outro comado CSECT ou DSECT.

Diversos comandos CSECT com o mesmo símbolo podem aparecer num programa. O primeiro dará o nome à CSECT e os outros identificarão sua continuação.

Comandos




PROG1 CSECT . . . END

É o mesmo que

PROG1 START . . . END

(Em ambos os casos) há um Location Counter (para a section PROG1).

Comandos




PROG1A START . .PROG1B CSECT . .PROG1B CSECT . . END

Há um Location Counter para a seção PROG1A, outro para a PROG1B, e um terceiro para a PROG1C.É o mesmo que

PROG1A CSECT . .PROG1B CSECT . .PROG1B CSECT . . END

Há um Location Counter para a seção PROG1A, outro para a PROG1B, e um terceiro para a PROG1C.

Comandos




A CSECT CSECT A = 1 + 4 . 1 CSECT B = 2 . CSECT C = 3 + 5B CSECT . 2 .C CSECT . 3 .A CSECT . 4 . C CSECT . 5 END


Comandos




O slide anterior mostra situação semelhante a esta:

A START CSECT A = 1 + 4 . 1 CSECT B = 2 . CSECT C = 3 + 5B CSECT . 2 .C CSECT . 3 .A CSECT . 4 . C CSECT . 5 END


Comandos


Comandos ao montador - CXD

CXD (Control Section)

O comando CXD define uma fullword. O Linkage Editor (ou o Loader) colocará nesta full-eord o tamanho de todas as DSECTS externas especificadas nos programas-fonte (sendo linkeditados ou carregados) e que usam as DSECTs. Sintaxe: simbolo CXD Operandos não são permitidos. Exemplo: TOTALLEN CXD

Comandos


Comandos ao montador - DC

DC (Define Constant)

Veja descrição detalhada

Comandos


Comandos ao montador - DROP

DROP (Por de lado, Deixar)

Este comando tem por função indicar ao montador que um (ou mais) registrador que anteriormente havia sido especificado como base (através de um comando USING), não deve mais ser base. O seu formato é o seguinte: DROP [R1[,R2,R3 ..........R16]] Sendo que R1 .........R16 é a relação dos registradores que não devem mais ser base. Ex:

DROP 3,8 Se não for especificado nenhum operando, todos os registradores base serão desassinalados.

Comandos


Comandos ao montador - DS

DS (Define Storage)

Veja descrição detalhada

Comandos


Comandos ao montador - DSECT

DSECT (Dummy Section - Seção Simulada)

O comando DSECT define uma Control Section que é montada, mas que não fará parte do programa-objeto. Uma DSECT serve, por exemplo, para se descrever o lay-out de uma área, sem que para isso seja preciso definí-la. O seu formato é: símbolo DSECT O comando DSECT não admite operandos. O símbolo dará nome à DSECT. Pode haver diversos comandos DSECT com o mesmo símbolo num programa. O primeiro dará nome à DSECT e os seguintes identificarão a sua continuação. A interrupção de uma DSECT é feita através de outro comando DSECT com símbolo diferente, ou de comando CSECT.

Exemplo:

Comandos


Comandos ao montador - DSECT

DSECT (Dummy Section - Seção Simulada)

CSN1 START . .DSN1 DSECTA DS CL2B DS CL20C DSD DS CL10CSN1 CSECT . . END Para usar como operandos de instruções os símbolos definidos dentro de DSECT's, o programador deve, antes desse uso, providenciar o comando USING que indicará o(s) registrador(es) base das DSECT's.

Comandos


Comandos ao montador - DXD

DXD (Define Dummy External – Definir Seção Dummy externa)

O comando DXD define uma DSECT externa. Sintaxe: símbolo DXD operando O símbolo deve ser referenciado como operando numa constante tipo Q. Corresponde ao endereço do primeiro byte da DSECT externa, e seu atributo de tamanho é 1. O operando tem a mesma sintaxe que um comando DS. O Assembler calcula a quantidade de memória e o alinhamento necessário para a DSECT externa, baseado na área especificada como operando. Exemplo: CONST DXD 5F . .DISPLAC DC Q(CONST)

Comandos


Comandos ao montador - EJECT

EJECT (Ejetar) O comando EJECT causa um salto para a folha seguinte, na hora em que ele for detectado, na listagem dos statements-fonte que o montador Assembler fornece. O seu formato é o seguinte: EJECT Este comando não deve ter símbolo nem operandos.

Comandos


Comandos ao montador - END

END (Fim)

O comando END deve ser o último statement de um programa fonte. O seu formato é:

END [Símbolo]

Símbolo é o símbolo dado à primeira instrução do programa a ser executado. Ex:

END INICIO

Comandos


Comandos ao montador - ENTRY

ENTRY (Entrada)

Este comando identifica símbolos definidos no programa (que contém o ENTRY), e que serão usados por outros programas. O seu formato é: ENTRY símbolo[,símbolo...]

No programa que usa o símbolo, ele deve ser definido através de um comando EXTRN.

PROG1 START 0 . . ROTINA EQU * . . ENTRY ROTINA END

PROG2 START 0 . . CONST DC A(ROTINA) . . EXTRN ROTINA END

Comandos


Comandos ao montador - EQU

EQU (Equate - Igualar)

A função do comando EQU é associar um símbolo a um endereço, que é fornecido através do operando do EQU. O seu formato é um dos seguintes:

Símbolo EQU a

Símbolo EQU a,b

Símbolo EQU a,b,c

Símbolo EQU a,,c

Sendo:a - expressão cujo valor seja o endereço a ser associado ao símbolo.b - termo auto-definido que indica o atributo de tamanho desejado para o símbolo. Se B for omitido, assume tamanho do primeiro termo (ou único) da esquerda da expressão:

--- Se for uma referência ao Location Counter (*), um termo auto-definido ou uma referência a um atributo de

tamanho (L'x), assume 1.

--- Se for um símbolo usado como símbolo num DC ou DS, assume o atributo de tamanho do símbolo

--- Se for um símbolo usado numa instrução de máquina, assume o tamanho da instrução (2,4 ou 6 Bytes)

--- Se for um símbolo usado num comando ao montador (exceto DC, DS e CCW) assume 1. c - termo auto-definido que indica o atributo de tipo que se deseja para o símbolo que se está definindo. Se omitido é assumido U.

Comandos




Ex:

R5 EQU 5... LA R5,TABLE

Normalmente usa-se colocar EQU dos números (endereços) dos registradores com símbolos (por ex. R0 a R15 para os registradores gerais e FP0 etc para os de ponto flutuante para “forçar” com que as referências a eles sejam listadas na cross-reference produzida pelo montador.

INST EQU * LA R13,SAVEAREA

É frequentemente usado ao invés de

INST LA R13,SAVEAREA

Observe que o endereço provavelmente é o mesmo: o conteúdo do location counter tem o mesmo valor em ambos os casos, a menos que no primeiro caso haja uma definição de área com quantidade ímpar de bytes.

A escolha do uso do EQU é apenas por questões de “elegância”.

Veja que no EQU o atributo de tamanho do símbolo INST é 1, e usando o símbolo na instrução LA o atributo é 4 (tamanho da instrução LA).

Comandos




Ex:

OFF EQU X'00'ON EQU X'FF'PAGOU EQU X'80'

Este tipo de uso do EQU é comum devido ao fato de os símbolos aparecerem na listagem da cross-reference.

Se usarmos os símbolos ao invés de valores nas instruções que manipulam máscaras, por exemplo, é fácil achar (via cross-reference) quais as instruções que manipulam as máscaras; se usarmos os termos auto-definidos, a cross-reference não lista as referências.

NI FLAGUSOU,OFF RESTAURA INDICADOR DE USO OI FLAGERR,ON MARCA COMO ERRADO TM FLAGPAG,PAGOU TESTA SE PAGOUAo invés de NI FLAGUSOU,X’00’ RESTAURA INDICADOR DE USO OI FLAGERR,X’FF’ MARCA COMO ERRADO TM FLAGPAG,X’80’ TESTA SE PAGOU

Comandos


Comandos ao montador - EXTRN

EXTRN (External - Externo)

Este comando permite identificar símbolos referidos num programa, mas definidos em outro programa. Seu formato é o seguinte: EXTRN símbolo[,símbolo...] No programa que define o símbolo, deve haver um comando ENTRY para ele.

* ROTINA EH DEFINIDA AQUI EM PROG1 PROG1 START 0 . . ROUTINE EQU * . . ENTRY ROUTINE END

* ROTINA EH REFERENCIADA AQUI EM PROG2 PROG2 START 0 . . CONST DC A(ROUTINE) . . EXTRN ROUTINE END

Comandos


Comandos ao montador - ICTL

ICTL (Input Control - Controle de Entrada) Pelo que foi visto na sintaxe dos statements assembler:--- O símbolo deve começar na posição 1--- Numa instrução, podemos ir até a posição 71--- A continuação, quando existir, deve começar na posição 16O comando ICTL, se usado, deve ser o primeiro statement do programa-fonte (só pode haver um ICTL num programa), e a sua função é modificar a estrutura explicada acima. O seu formato pode ser um dos 3 seguintes:

ICTL a ou ICTL a,b ou ICTL a,b,c

Sendo:a - indica a posição onde começar um símbolo. Pode ser de 1 até 40.b - indica a última posição até onde pode ir uma instrução. Pode ir de 41 a 80. Se omitido, assume-se 71. Deve ser maior ou igual a A+5.c - indica qual a posição de continuação. Pode ser de 2 a 40. Se ele for omitido ou se for colocado 80 no segundo operando, o Assembler assume que não é permitida continuação. ICTL 4,70,71

Comandos


Comandos ao montador - ISEQ

ISEQ (Input Sequence - Sequência de Entrada)

A função deste comando é indicar ao montador Assembler que se deseja que ele teste a sequência (crescente) dos statements-fonte. O seu formato é o seguinte:

ISEQ [a,b]

Sendo:

a - número da primeira posição que forma o campo dos statements, campo esse a partir do qual deve ser testada a sequência.

b - número da última posição do campo.

OBS:- A <= B

Pode-se colocar quantos ISEQ forem necessários num programa. Se os seus dois operandos forem omitidos, não será testada a sequência.

Comandos


Comandos ao montador - LOCTR

LOCTR (Multiple Location Counters)

Este comando ao montador permite o uso de diversos location counters dentro de uma Control Section. Seu formato é:

simbolo LOCTR

O primeiro Location Counter de uma Control Section é definido quando de um comando START, CSECT, DSECT ou COM. Dentro de uma dessas seções, o comando LOCTR define outro location counter; é como se houvesse um location counter para cada símbolo especificado através do START, CSECT, DSECT, COM e de cada LOCTR. Um LOCTR cujo símbolo já tenha sido especificado em outro comando START, DSECT, CSECT, COM ou LOCTR continua a geração do objeto usando o endereço do location counter respectivo; no final, o objeto da seção será um único, com os "pedaços" arranjados. Exemplo:

Se dentro de uma seção for usado um LOCTR cujo símbolo é o de um outro que esteja em outra seção, esta outra seção é continuada com o location counter em questão.

Comandos


Comandos ao montador - LOCTR

LOCTR (Multiple Location Counters)

PROGRAMA Loc.Counter AtivoPGM1 CSECT PGM1 pedaço 1 . PGM1 pedaço 1 . PGM1 pedaço 1 . PGM1 pedaço 1X LOCTR X pedaço 1AREA1 DS CL80 X pedaço 1AREA2 DS CL4 X pedaço 1PGM1 LOCTR PGM1 pedaço 2 . PGM1 pedaço 2 . PGM1 pedaço 2 . PGM1 pedaço 2 Y LOCTR Y pedaço 1 TAB1 DS CL10000 Y pedaço 1 TAB2 DS CL20000 Y pedaço 1 PGM1 LOCTR PGM1 pedaço 3 . PGM1 pedaço 3 . PGM1 pedaço 3 . PGM1 pedaço 3 X LOCTR X pedaço 2 AREA11 DC C'*' X pedaço 2 AREA12 DC F'0' X pedaço 2 PGM1 LOCTR PGM1 pedaço 4 LTORG PGM1 pedaço 4 END

OBJETO GERADOCSECT PGM1 (com “7 pedaços”)

PGM1 =

(pedaço 1 do loc counter PGM1) +




(pedaço 1 do loc counter X) +

(pedaço 2 do loc counter X) +

(pedaço 1 do loc counter Y)

Comandos


Comandos ao montador - LTORG

LTORG

O comando LTORG faz a definição das literais usadas no programa. Antes da definição, ele alinha o Location Counter para o endereço mais próximo múltiplo de 8. Devido a isso, você pode encontrar em alguns programas 2 LTORGS, um após o outro: o primeiro para alinhar e descarregar (declarar) as literais, e o segundo apenas para efetuar o alinhamento (neste caso poderia ser substituído por um CNOP 0,8 ou um DS 0D.

Este comando não tem símbolo nem operandos. Ex:

LTORG

LTORG , DECLARING LITERALS

LTORG , ALIGNMENT

Observe que nestes dois últimos exemplos, para inserir os comentários, é obrigatório colocar as vírgulas para indicar a ausência de operandos.

Comandos


Comandos ao montador - LTORG

LTORG

000476 0000 0000 0000 00000 00000 59 MVC E,DSEKCOP3 IEV044 *** ERROR *** UNDEFINED SYMBOL 00047C D241 6000 B021 03000 00021 60 MVC G,DSEKCPO4 000482 D257 7000 B02C 04000 0002C 61 MVC I,DSEKCPO5 000488 D20A B037 B042 00037 00042 62 MVC DSEKCPO6,DSEKCPO7 63 * . . 00048E 41C0 7FFF 04FFF 64 LA 12,Z-1 000492 0000 0000 00000 65 LA 12,Z+1 IEV034 *** ERROR *** ADDRESSABILITY ERROR 000496 0000 0000 00000 66 LA 12,Z IEV034 *** ERROR *** ADDRESSABILITY ERROR 00049A 58C0 34A8 004A8 67 L 12,=A(Z) 00049E D20F 3400 34AC 00400 004AC 68 MVC A,=C'*' 69 * . . 0004A8 70 LTORG , 0004A8 00005000 71 =A(Z) 0004AC 5C 72 =C'*' 73 * . . 0004AD 00 0004AE D20F 3400 40E4 00400 010E4 74 MVC A,=C'*' 0004B4 0000 0000 00000 75 LA 12,Z IEV034 *** ERROR *** ADDRESSABILITY ERROR 0004B8 58C0 40E0 010E0 76 L 12,=A(Z)

Comandos


Comandos ao montador - OPSYN

OPSYN (Operation Synonim)

O comando OPSYN faz uma equivalência entre um símbolo e um código de operação de uma instrução de máquina ou comando ao montador. O seu formato é:

Símbolo OPSYN [código]

Sendo:

Símbolo - qualquer símbolo válido em Assembler ou um código de operação (se o operando não for especificado).

Código - qualquer código de operação válido. Se não for especificado, o comando anula o código de operação colocado como símbolo.

O comando OPSYN deve ser colocado depois do ICTL (se houver ICTL) e pode ser precedido somente por EJECT, ISEQ, PRINT, SPACE e TITLE. Exemplo:

MOVER OPSYN MVC

MVC OPSYN

Comandos


Comandos ao montador - ORG

ORG

O comando ORG tem por função alterar o conteúdo do Location Counter, colocando nele o valor da expressão especificada como operando do ORG. O seu formato é o seguinte:

símbolo ORG [expressão]

Se não for colocado o seu operando, será colocado no Location Counter o maior conteúdo que ele já teve. Ex:

OBS:- os símbolos usados como operandos do ORG devem ter sido definidos antes do ORG.

Loc.Counter Loc.CounterANTES DEPOIS . . . . . . . . . 0AB84C 0AB94C TABNUM DC 256X'FF' 0AB94C 0AB93C ORG TABNUM+240 0AB93C 0AB946 DC 10X'00' 0AB946 0AB94C ORG . . .

Comandos


Comandos ao montador - POP

POP

O comando POP restaura o estado de PRINT e USING salvos pelo comando PUSH. Pode-se especificar num dos 4 formatos:

POP PRINT

POP USING

POP PRINT,USING

POP USING,PRINT

Comandos


Comandos ao montador - PRINT

PRINT (Imprimir)

O comando PRINT é utilizado para controlar a listagem fornecida pelo montador. O seu formato é o seguinte:

PRINT opções

Sendo que as opções são palavras colocadas uma após a outra, separadas por vírgulas, que indicam ao montador o que deve ou não ser listado. As palavras válidas são as seguintes:

ON - A listagem é fornecidaOFF - A listagem não é fornecidaGEN - As instruções geradas por macro-instruções devem ser listadas.NOGEN - As instruções geradas por macro-instruções não devem ser listadas.DATA - As áreas definidas terão todo o seu conteúdo listado.NODATA - As áreas definidas terão somente os 8 primeiros Bytes seus listados.

PRINT OFF,DATA

Enquanto não for colocado um comando PRINT no programa, será assumido

PRINT ON,GEN,NODATA

Pode haver tantos comandos PRINT no programa quantos se desejar.

Comandos


Comandos ao montador - PUNCH

PUNCH

O comando PUNCH tem por função ordenar ao montador Assembler a gravação imediata de um statement no programa-objeto. O seu formato é: PUNCH a Sendo a um conjunto de 1 a 80 caracteres colocados entre apóstrofes. Se o caracter desejado for um apóstrofe (') ou um E comercial (&), ele deve ser colocado duas vezes. Ex: PUNCH ' CATALR MOD' Neste caso, o statement teria: pos 1 a 2 : brancos pos 3 a 8 : CATALR pos 9 a 10 : brancos pos 11 a 13 : MOD pos 14 a 80 : brancos

Comandos


Comandos ao montador - PUSH

PUSH

O comando PUSH salva o estado atual de PRINT e USING. Pode-se especificar num dos 4 formatos: PUSH PRINT PUSH USING PUSH PRINT,USING PUSH USING,PRINT

Comandos


Comandos ao montador - REPRO

REPRO

O comando REPRO indica ao montador Assembler que ele deve gravar no programa-objeto um statement igual ao seguinte ao REPRO. Este comando não deve ter nem símbolo e nem operando. Ex: REPRO CATALR MOD

Comandos


Comandos ao montador - RMODE

RMODE (Residence Mode - Modo de residência) Este comando é utilizado para especificar ao montador Assembler o modo de residência a ser associado a uma Control Section. O seu formato é: [símbolo] RMODE n n podendo ser 24 ou ANY. O símbolo é opcional. Se ele estiver ausente, o modo de residência será associado à Control Section sem nome que deve existir no programa.Se o símbolo estiver presente, o modo de residência será associado à Control Section que tiver nome igual ao especificado no símbolo.O operando indica qual modo de residência deve ser associado à Control Section; pode ser 24 (residência de 24 bits, isto é, a CSECT deve ficar abaixo dos 16 MB) ou ANY (residência de 24 ou de 31 bits, isto é, a CSECT pode ficar tanto abaixo quanto acima dos 16 MB).Não pode haver dois ou mais RMODE para uma mesma Control Section.O comando RMODE pode estar em qualquer lugar do programa.RMODE ANY é incompatível com AMODE 24.

Comandos


Comandos ao montador - RMODE

RMODE (Residence Mode - Modo de residência)

Os defaults para AMODE e RMODE quando só um deles (ou nenhum) é especificado são os seguintes: Especificado Assumido nenhum AMODE 24 e RMODE 24AMODE 24 RMODE 24AMODE 31 RMODE 24AMODE ANY RMODE 24RMODE 24 AMODE 24RMODE ANY AMODE 31

Comandos


Comandos ao montador - SPACE

SPACE (Espaço) O comando SPACE, quando detectado pelo montador Assembler, faz com que o montador, na listagem que ele fornece, deixe tantas linhas em branco quantas forem especificadas no operando do SPACE. O seu formato é:

SPACE [n] Sendo que n é um número decimal que indica quantas linhas devem ser deixadas em branco. Ex:

SPACE 3

Comandos


Comandos ao montador - START

START (Começo)

O comando START tem por função dar o conteúdo inicial do LOCATION COUNTER. Este comando deve ser um dos primeiros do programa-fonte (antes dele não pode haver nenhum comando ou instrução que altere o Location Counter). O seu formato é:

[símbolo] START a

sendo:

Símbolo: O comando START tem por função também definir a primeira Control Section (CSECT) do programa. Se for colocado o símbolo, ele será o nome da CSECT. Se ele não for colocado, a CSECT é considerada sem nome.

a - Termo auto-definido (cujo valor deve ser múltiplo de 8) que indica o conteúdo inicial do Location Counter. Se omitido, será assumido 0.

Exemplos:

PROG1 START X'308'

START 10240

OBS: - Se o comando START não for colocado, é assumido START 0.

Comandos


Comandos ao montador - TITLE

TITLE (Cabeçalho)

O comando TITLE especifica qual o cabeçalho que deve ser colocado pelo montador Assembler na listagem do programa-fonte que ele fornece. O seu formato é o seguinte: [símbolo] TITLE a Símbolo --- em VSE pode ter de 1 a 4 caracteres. Do primeiro comando TITLE que tiver o programa, o montador Assembler pegará o símbolo e o colocará em todos os statements do programa-objeto, nas posições 73 a 76, identificando-o, portanto. a -- conjunto de 1 ate 100 caracteres colocados entre apóstrofes. Quando o caracter que se desejar colocar no cabeçalho for um apóstrofe (') ou um E comercial (&), então deve-se colocá-lo duas vezes.Ex:

P001 TITLE 'EMISSAO NOTAS FISCAIS' A cada comando TITLE que for colocado, o montador Assembler providenciará um salto para outra folha na listagem que ele faz dos statements-fonte, imprimindo, a partir dessa hora, o novo cabeçalho especificado.

Comandos


Comandos ao montador - USING

USING (Usando)

O comando USING informa ao montador:A) Qual é (ou quais são) o(s) registrador(es) base do programa (através do segundo operando em diante) B) Qual o conteúdo do(s) registrador(es) base (através do primeiro operando).O seu formato é o seguinte:

USING x,R1[,R2,R3 .......R16]

Sendo x uma expressão que indica ao montador o conteúdo do primeiro registrador base especificado (R1). Para o segundo registrador base, se especificado, será assumido conteúdo igual a V+4096. Para o terceiro, será assumido V+8192, e assim por diante. Ex:

USING *,3,8

Neste exemplo, os registradores base serão o 3 (que deverá ter o endereço contido no Location Counter) e o 8 (que deverá ter o endereço contido no Location Counter + 4096).

Observar que o comando USING apenas avisa o montador qual deverá ser o conteúdo do registrador base quando o programa for executado. Cabe ao programador providenciar a carga do registrador base (em geral via instrução BALR).

Observar também que, no caso de DSECT's, o comando USING deve especificar como primeiro operando o nome que foi dado à DSECT.

Comandos


Comandos ao montador - WXTRN

WXTRN

Este comando é análogo ao EXTRN, com as seguintes diferenças:- com o comando EXTRN, o Linkage Editor faz uma pesquisa automática nas bibliotecas para achar o módulo que contém os símbolos especificados como operandos no comando EXTRN.- com o comando WXTRN não é feita essa pesquisa automática. O Linkage Editor somente resolverá as referências feitas através do comando WXTRN se os símbolos especificados nele estão definidos: -- num módulo que é linkeditado e carregado junto com o programa que tem o comando WXTRN ou -- num módulo trazido de uma biblioteca devido à presença de um comando EXTRN em outro módulo linkeditado e carregado junto com o programa que tem o comando WXTRN. Seu formato é o seguinte: WXTRN símbolo[,símbolo ....... ] Ex: WXTRN MOD

Comandos


Declaração de áreas


Comandos



DC = define área COM conteúdo (aloca memória, coloca o conteúdo, atribui nome, tamanho e tipo)

DS = define área SEM conteúdo (aloca memória, atribui nome, tamanho e tipo a ela)

Comandos



O que significa alocar área sem conteúdo em um programa?(pode ser o DS em Assembler, ou um campo declarado sem VALUE em Cobol.

Instruções

Áreas com conteúdo (DC)

Áreas sem conteúdo (DS)

LOADER???????????

ExecutávelMemória

???????????

Comandos



Sintaxe geral:

Ad = atributo de duplicação: quantas áreas definirTipo = tipo de conteúdo (só para atribuição de tamanho e conteúdo inicial; nunca é feita nenhuma validação ou processamento específico em função dessa especificação)At = atributo de tamanhoCi = conteúdo inicial

[nome] DC [ad]tipo[at]ci

[nome] DS [ad]tipo[at][ci]

Comandos



Exemplos:

[nome] DC [ad]tipo[at]ci

SEPARAT1 DC 132CL1’*’ ad=132;tipo=C;at=L1;ci=‘*’* Declara 132 áreas de 1 byte

SEPARAT2 DC CL132’*’ ad=omitido;tipo=C;at=L132;ci=‘*’* Declara 1 área de 132 bytes

CONTLIN DC PL2’99’ ad=omitido;tipo=P;at=L2;ci=‘99’* Declara 1 área de 2 bytes

ADRSTAB DC A(TABAGE) ad=omitido;tipo=A;at=omitido;ci=(TABAGE)* Declara 1 área de 4 bytes

Comandos



Exemplos:

[nome] DS [ad]tipo[at][ci]

SEPARAT1 DS 132CL1 ad=132;tipo=C;at=L1;ci=omitido* Declara 132 áreas de 1 byte

SEPARAT2 DS CL132 ad=omitido;tipo=C;at=L132;ci=omitido* Declara 1 área de 132 bytes

CONTLIN DS PL2 ad=omitido;tipo=P;at=L2 ;ci=omitido* Declara 1 área de 2 bytes

ADRSTAB DS A ad=omitido;tipo=A;at=omitido ;ci=omitido* Declara 1 área de 4 bytes

Comandos



DC - Define Constant

Área COM conteúdo inicial

Comandos



Tipos de conteúdo

TIPO

Tamanhoassumido

Alinha-mento

Tamanhos Válidos

Constantes p/operando

Sentido preench

Completa com

Truncaà

Caracteres Válidos

Cada caractere

C suficiente byte 1 a 256 uma E->D brancos D qualquer 1 byte

X suficiente byte 1 a 256 várias D->E X’0’ E 0 a F ½ byte

B suficiente byte 1 a 256 várias D->E B’0’ E 0 e 1 1 bit

F 4 bytes FullWord 1 a 8 várias D->E (1) E + - 0 a 9 (2) (4)

H 2 bytes HalfWord 1 a 8 várias D->E (1) E + - 0 a 9 (3) (4)

P suficiente Byte 1 a 16 várias D->E X’0’ E + - 0 a 9 ½ byte (5)

Z suficiente Byte 1 a 16 várias D->E C’0’ E + - 0 a 9 1 byte

D 8 bytes DoubleWord 1 a 8 várias -x- -x- -x- + - 0 a 9 -x-

A 4 bytes FullWord 1 a 4 várias E->D B’0’ E expressão -x-

Y 2 bytes HalfWord 1 a 2 várias E->D B’0’ E expressão -x-

S 2 bytes HalfWord 2 várias -x- -x- -x- expressão -x-

OBS:- (1) 0's se o número for positivo; 1's se o numero for negativo (2) O número máximo que pode ser especificado é 2**31 - 1 (3) O número máximo que pode ser especificado é 2**15 - 1 (4) O ponto decimal não ocupa nada (5) O sinal ocupa 1/2 BYTE

Comandos


Declaração de áreas – DC tipo C

DC tipo C (caracter)

[nome] DC [ad]C[at]ci

Comandos


Declaração de áreas – DC tipo C

Cada caracter especificado no conteúdo inicial ocupa um byte (em EBCDIC)Se não for especificado tamanho, será assumido o necessário para conter o conteúdo inicial. Se for especificado o atributo de tamanho, ele prevalece sobre a quantidade de bytes necessária ao conteúdo inicial. Se o tamanho especificado for maior que o necessário, será feito preenchimento dos bytes restantes à direita com brancos (X'40'). Se o tamanho for insuficiente, será feito truncamento à direita (e será indicado erro). O tamanho máximo é 256 bytes. Quando o caracter que se deseja colocar como conteúdo inicial for um apóstrofe (') ou um E comercial (&), deve-se colocá-lo duas vezes. DC 1CL1'*' 5C DC 2CL1'*' 5C5C DC CL1'*' 5C DC CL2'*' 5C40 DC 2CL2'*' 5C405C40 DC C'ABC' C1C2C3 DC CL1'ABC' C1 DC C'A&&B' C150C2 DC C'ZE''S' E9C57DE2 DC C'''' 7D

Comandos


Declaração de áreas – DC tipo X

DC tipo X (hexadecimal)

[nome] DC [ad]X[at]ci

Comandos


Declaração de áreas - DC tipo X

Pode-se especificar como conteúdo inicial os algarismos hexadecimais (de 0 a F). Cada algarismo ocupa meio byte. O preenchimento é da direita para a esquerda. Se sobrarem bytes (ou meios-bytes) à esquerda, será feito preenchimento com zeros binários (X’0’). Se o tamanho especificado for insuficiente, será feito truncamento à esquerda. O tamanho máximo permitido é 256 bytes. Aceita múltiplas definições por constante. DC 1XL1'0B' 0B DC 3X'5C' 5C5C5C DC XL3'5C' 00005C DC XL2'AB0C14' 0C14 DC X'1A2' 01A2 DC X'00A,B,5A8' 000A0B05A8

Comandos


Declaração de áreas - DC tipo B

DC tipo B (binário)

[nome] DC [ad]B[at]ci

Comandos


Declaração de áreas - DC tipo B

Pode-se especificar como conteúdo inicial somente os algarismos binários( 0 e 1). Cada algarismo ocupa um bit. O preenchimento é feito da direita para a esquerda. Se sobrarem bits à esquerda, será feito preenchimento com zeros binários. Se o tamanho especificado for insuficiente, será feito truncamento à esquerda. O tamanho máximo permitido é 256 bytes. Aceita múltiplas definições por constante. DC BL1'0' 00 DC BL2'010001001' 0089 DC B'0101' 05 DC BL2'1' 0001 DC 2B'1' 0101 DC B'1,00101,001' 010501

Comandos


Declaração de áreas - DC tipo F

DC tipo F (fullword)

[nome] DC [ad]F[at]ci

Comandos


Declaração de áreas - DC tipo F

O número desejado deve ser colocado em decimal. O montador irá converte-lo para binário e colocá-lo na fullword. Se o sinal não for colocado, o número será assumido positivo. Se o sinal for colocado, ele deve ser único, e deve vir antes do número. Se não for colocado atributo de tamanho, será feito alinhamento para o próximo endereço múltiplo de 4, antes da alocação da área. Se for colocado o atributo de tamanho, não será feito o alinhamento. Aceita múltiplas definições por constante. DC F'138' 0000008A DC F'+138' 0000008A DC F'-138' FFFFFF76 DC F'4,392' 0000000400000188

Comandos


Declaração de áreas - DC tipo H

DC tipo H (halfword)

[nome] DC [ad]H[at]ci

Comandos


Declaração de áreas - DC tipo H

O número desejado deve ser colocado em decimal. O montador irá converte-lo para binário e colocá-lo na halfword. Se o sinal não for colocado, o número será assumido positivo. Se o sinal for colocado, ele deve ser único, e deve vir antes do número. Se não for colocado atributo de tamanho, será feito alinhamento para o próximo endereço múltiplo de 2, antes da alocação da área. Se for colocado o atributo de tamanho, não será feito o alinhamento. Aceita múltiplas definições por constante. DC H'138' 008A DC H'+138' 008A DC H'-138' FF76 DC H'4,392' 00040188

Comandos


Declaração de áreas - DC tipo P

DC tipo P (Packed - compactado)

[nome] DC [ad]P[at]ci

Comandos


Declaração de áreas - DC tipo P

O sinal é indicado na parte numérica do último Byte à direita do campo. Se o número for positivo, ela terá C. Se o número for negativo, terá D. O conteúdo inicial é colocado em decimal, e cada algarismo irá ocupar 1/2 byte. O preenchimento é feito da direita para a esquerda. Se o tamanho não for especificado, será reservado um campo com tamanho necessário e suficiente para conter o conteúdo inicial (mais, eventualmente, meio byte, para o caso de a quantidade de algarismos especificada ser par). Se o tamanho especificado for maior que o necessário, será feito preenchimento à esquerda com zeros (X'0'). Se for menor, será feito truncamento à esquerda. Aceita múltiplas definições por constante. DC P'122' 122C DC P'10' 010C DC P'-345,45,21.6,7' 345D045C216C7C DC P'0' 0C DC P'+66' 066C DC PL3'1' 00001C DC PL2'43556' 556C DC 3P'1' 1C1C1C

Comandos


Declaração de áreas - DC tipo Z

DC tipo Z (zonado)

[nome] DC [ad]Z[at]ci

Comandos


Declaração de áreas - DC tipo Z

O sinal é indicado na parte de zona do último Byte à direita do campo. Se o número for positivo, ela terá C. Se o número for negativo, terá D. O conteúdo inicial é colocado em decimal, e cada algarismo irá ocupar 1 byte.O preenchimento é feito da direita para a esquerda. Se o tamanho não for especificado, será reservado um campo com tamanho necessário e suficiente para conter o conteúdo inicial. Se o tamanho especificado for maior que o necessário, será feito preenchimento à esquerda com zeros zonados (X'F0'). Se for menor, será feito truncamento à esquerda. Aceita múltiplas definições por constante. DC Z'122' F1F2C2 DC Z'-345,45' F3F4D5F4C5 DC Z'+66' F6C6 DC ZL3'1' F0F0C1 DC ZL2'43556' F5C6 DC 3Z'1' C1C1C1

Comandos


Declaração de áreas - DC tipo A

DC tipo A (address - endereço)

[nome] DC [ad]A[at]ci

Comandos



Se o tamanho for especificado, não será efetuado o alinhamento. O conteúdo é o endereço real correspondente à expressão colocada como conteúdo inicial da constante.Se não for especificado tamanho, será feito alinhamento para o próximo endereço múltiplo de 4.Se for especificado tamanho, NÃO será feito alinhamento.Aceita múltiplas definições por constante.

DC A(TABELA) DC A(TABELA-50) DC A(*) DC A(259) 00000103CAMPO DC 3A(*-CAMPO) 00000000.00000004.00000008 DC A(TCABC+28*52) DC A(FIM-COMECO) DC A(1,2,3) 00000001.00000002.00000003

Comandos



IMPORTANTE:

Endereços com valores relocáveis (verde) são atualizados pelo Linkage Editor e pelo Loader; os endereços absolutos (vermelho) não são alterados. DC A(TABELA) DC A(TABELA-50) DC A(*) DC A(259) 00000103CAMPO DC 3A(*-CAMPO) 00000000.00000004.00000008 DC A(TCABC+28*52) DC A(FIM-COMECO) DC A(1,2,3) 00000001.00000002.00000003

Comandos



Exemplo:(parte de um programa)0008A0 47F0 38AC 008AC 244+ B IHB0004A 008A4 245+IHB0004 EQU * 0008A4 000008B2 246+ DC A(ENTRA) 0008A8 000008B5 247+ DC A(SAI) 008AC 248+IHB0004A EQU *

(parte do RELOCATION DICTIONARY do programa)

RELOCATION DICTIONARY POS.ID REL.ID FLAGS ADDRESS 0001 0001 0C 000070 0001 0001 08 0001B9 0001 0001 0C 000860 0001 0001 0C 000864 0001 0001 0C 000868 0001 0001 0C 00086C 0001 0001 0C 000874 0001 0001 0C 0008A4 0001 0001 0C 0008A8 0001 0001 04 000A46 0001 0001 04 000A48 0001 0001 04 000A54 0001 0001 04 000A56

Comandos



Comandos

Exemplo:

...VVV DC A(VALIDS).........VALIDS DC C’AEIOUaeiou’...

Programa fonte (rotina VALIDAR; supor que endereço de VALIDS seja

X’00001BC0’)

...00001BC0.........C1C5C9D6E481858996A4...

Programa objeto a ser chamado (supor tamanho = 4K = X’1000’)

Programa chamador : vai de X’0000’ até X’9FFF’)

Executável

...

...

... CALL VALIDAR.........

Programa objeto chamador (supor tamanho = 40K = X’A000’)

Rotina chamada : ficou no endereço X’A000’ (o seu zero é o endereço X’A000’): vai de X’A000’ a X’AFFF’

Montador

ASM

Lked

Agrega a rotina chamada ao programa chamador e AJUSTA as constantes de endereço relocáveis.

O conteúdo de VVV é ajustado para X’0000BBC0’

Programa chamador : vai de X’0000’ até X’9FFF’)

... 0000BBC0...



Comandos

Exemplo:

Loader

Carrega o programa executável na memória (por exemplo no endereço X’0BC40000’) e AJUSTA as constantes de endereço relacáveis.

O conteúdo de VVV é ajustado para X’0BC40000’ + X’0000BBC0’ = X’0BC4BBC0’

Programa executável... 0000BBC0...

Memória

Programa executável carregado (LOAD POINT) no endereço X’0BC40000’... 0BC4BBC0...

Load Point = X’0BC40000’


Declaração de áreas - DC tipo Y

DC tipo Y (endereço com 2 bytes)

[nome] DC [ad]Y[at]ci

Comandos


Declaração de áreas - DC tipo Y

Se o tamanho for especificado, não será efetuado o alinhamento. Os dois Bytes da halfword terão o endereço real correspondente à expressão colocada como conteúdo inicial da constante. Observar que o endereço máximo representável através da constante tipo Y é X'FFFF‘.Aceita múltiplas definições por constante.

DC Y(TABELA) DC Y(TABELA-50) DC Y(*) DC Y(259) 0103 DC Y(TCABC+28*52) DC Y(FIM-COMECO) DC S(*,*+2,*+4) 0001.0002.0003

IMPORTANTE:Endereços com valores relocáveis são atualizados pelo Linkage Editor e pelo Loader; os endereços absolutos não são alterados.

Comandos


Declaração de áreas - DC tipo S

DC tipo S (endereço base + deslocamento)

[nome] DC [ad]S[at]ci

Comandos


Declaração de áreas - DC tipo S

Se o tamanho for especificado, não será efetuado o alinhamento. Os dois Bytes da halfword terão o endereço na forma BASE+DESLOCAMENTO correspondente à expressão colocada como conteúdo inicial da constante. DC S(TABELA) DC S(TABELA-50) DC S(*) DC S(TCABC+28*52)

Comandos


Declaração de áreas - DC tipo V

DC tipo V (endereço externo)

[nome] DC [ad]V[at]ci

Comandos


Declaração de áreas - DC tipo V

Se o tamanho for especificado, não será efetuado o alinhamento. Esta constante é usada para reservar memória para o endereço de um símbolo externo. A fullword será reservada com zeros binários, sendo que o endereço será colocado quando da linkedição do programa. DC V(ROTINA)

Comandos


Declaração de áreas - DC tipo Q

DC tipo Q (deslocamento em DSECT externa)

[nome] DC [ad]Q[at]ci

Comandos


Declaração de áreas - DC tipo Q

Esta constante é usada para reservar memória para o deslocamento numa área de memória de uma DSECT externa. O deslocamento é colocado na constante durante a linkedição do programa. O símbolo especificado no conteúdo inicial deve ter sido previamente definido como símbolo de um DXD ou DSECT. DC Q(DUMMYEXT)

Comandos


Declaração de áreas - DS

DS - Define Storage

Área SEM conteúdo inicial

Comandos



A função do comando DS é definir uma área sem conteúdo inicial.

O seu formato é análogo ao DC.

Se for especificado conteúdo inicial, ele não será considerado.

DS CL3

DS XL4

DS PL4'0'

DS 3CL8

Comandos



O comando DS admite atributo de duplicação zero (0). Ex:

ARLEIT DS 0CL80

CODIGO DS CL10

DTEM DS CL8

NOME DS CL50

CIDADE DS CL12

Neste caso, o atributo de duplicação 0 não define a área, mas avisa que as próximas 80 posições definidas formarão uma área de nome ARLEIT, ou seja, ARLEIT terá atributo de tamanho 80.

Em outras palavras, os 80 bytes desde aquele indicado pelo endereço que está no Location Counter formam um campo com atributo de tamanho 80.

Comandos



O atributo de duplicação zero é bastante usado para efetuar alinhamento:

CPOCOM4 DS 0F

BYTE1 DS CL1

BYTE2 DS CL1

BYTE3 DS CL1

BYTE4 DS CL1

Neste caso, o montador primeiramente efetua o alinhamento para endereço múltiplo de 4 (devido ao tipo F indicado), e em seguida faz a alocação dos campos BYTE1, BYTE2, BYTE3 e BYTE4.

Comandos



Outro exemplo de uso para alinhamento:

ALFA DC F’0’

BETA DC C’XYZ’

DS 0H

GAMA DS CL1

DELTA DS CL1

ALFA é alinhado pois a constante tipo F alinha para múltiplo de 4.

BETA está alinhado devido ao alinhamento e tamanho de ALFA.

GAMA, se fosse declarado logo em seguida a BETA, não estaria alinhado pois BETA tem 3 bytes. Para deixar GAMA alinhado (para endereço múltiplo de 2) foi incluída a declaração DS com tipo H e atributo de duplicação zero.

DeltaGama(no

name)BetaAlfa

Comandos



Outro uso do comando DS é para fazer redefinição de áreas (atribuir nomes diferentes a mesmas áreas físicas).

Veja os exemplos a seguir:AREA1 DS 0CL80A1PART1 DS CL10A1PART2 DS CL10A1PART3 DS CL10A1PART4 DS CL10A1PART5 DS CL10A1PART6 DS CL10A1PART7 DS CL10A1PART8 DS CL10 ORG , VOLTA PARA MESMO ENDEREÇO DE AREA1AREA2 DS 0CL80A2PART1 DS CL20A2PART2 DS CL20A2PART3 DS CL20A2PART4 DS CL20 ORG , VOLTA PARA MESMO ENDEREÇO DE AREA1AREA3 DS 0CL80A3PART1 DS CL5A3PART2 DS CL5A3PART3 DS CL20A3PART4 DS CL30A3PART5 DS CL3A3PART6 DS CL4A3PART7 DS CL13

Comandos


Instruções de máquina

INSTRUÇÕES DE MÁQUINA


Instruções de máquina - Dicas

DICAS


Instruções de máquina – Dicas 1

1 - STORE = DE registrador PARA memória2 - LOAD = DE memória PARA registrador

3 - xxxxR = instrução RR, com 2 operandos são registradores Ex. AR,SR, LR, MR, DR, LTR etc4 - xxxxI = instrução SI, 1 operando é operando imediato; é o 2o. byte da instrução, e é especificado via um termo auto-definido (com tamanho de 1 byte) Ex. MVI, SI, NI, OI, XI, etc5 - xxxxP = instrução SS, operandos em decimal compactado,

trabalha com 2 tamanhos Ex. AP, SP, MP, DP, ZAP6 - xxxxH = instruction RX, usa registrador e um campo de memória (halfword) Ex. LH, SH, AH



7 - Nxxxx = instrução booleana AND Ex. NI, NC, N, NR 8 - Oxxxx = instrução booleana OR Ex. OI, OC, O, OR9 - Xxxxx = instrução booleana Exclusive OR Ex. XI, XC, X, XR10 - A maioria das instruções (exceto CVD e as de STORE: CVD, STC, ST, STH, STCM, STM) :símbolo instrução operando_receptor,operando_emissor

11 - Instruções de STORE e CVD:símbolo instrução operando_emissor,operando_receptor



12 - As instruções SS-L, que tem, portanto, um único tamanho, são: MVN, MVC, MVZ, NC, CLC, OC, XC, TR, TRT, ED, EDMK, MVCINO tamanho máximo manipulado por elas é de 256 bytes (vale para os 2 operandos). 13 - As instruções SS-L1/L2, que tem, portanto, dois tamanhos, são : MVO, PACK, UNPK, ZAP, CP, AP, SP, MP, DPO tamanho máximo manipulado por elas para cada operando é 16 bytes. 14 - A instrução SRP é exceção no grupo das SS, à medida que faz referência a um tamanho (em metade do seu segundo byte), e a um arredondamento (na outra metade desse segundo byte).



15 – Uso de instruções Booleanas:

OR (ou) = Para forçar bits em 1 (ligar bits)

Isto permite, por exemplo : (a) Ligar flags (chaves) de programa(b) Transformar letras minúsculas em maiúsculas (máscara 0100 0000 : observe numa tabela EBCDIC que a diferença entre as letras minúsculas e maiúsculas é sempre x’40’, ou seja b’0100 0000’; ligando o 2o. bit transforma-se uma letra minúscula em maiúscula. (c) Transformar um número binário no ímpar maior mais próximo ligando o último bit à direita Por exemplo: 1111 1110 é o decimal 254. Ligando o último bit: 1111 1111 ele se transforma no decimal 255




AND (e) = Para forçar bits em 0 (desligar bits)

Isto permite, por exemplo : (a) Desligar flags (chaves) de programa(b) Transformar letras maiúsculas em minúsculas (máscara 1011 1111 : observe numa tabela EBCDIC que a diferença entre as letras minúsculas e maiúsculas é sempre x’40’, ou seja b’0100 0000’; desligando o 2o. bit transforma-se uma letra maiúscula em minúscula. (c) Transformar um número binário no par menor mais próximo zerando o último bit à direita Por exemplo: 1111 1111 é o decimal 255. Zerando o último bit: 1111 1110 ele se transforma no decimal 254




XOR (ou exclusivo) = Para inverter bits (desligar se ligado, ligar se desligado)

Isto permite, por exemplo : (a) Inverter flags (chaves) de programa (toggle)(b) Transformar letras minuscmaiusc e maiuscminusc (máscara 0100 0000) :

letra x1xx xxxx é transformada em x0xx xxxxletra x0xx xxxx é transformada em x1xx xxxx

(c) Transformar números binário pares em ímpares e vice-versa (máscara 0000 0001) : o último bit à direita é invertido (d) Trocar conteúdo de áreas :

XOR A,B + XOR B,A + XOR A,B(e) “Limpar” (colocar zeros binários) uma área :

XOR A,A



16 – Operações aritméticas e de deslocamento de bits (operações algébricas / lógicas):

A menos que afirmado de forma diferente, essas operações são feitas algebricamente. Isso é verdade para campos no formato decimal compactado.

Para números em no formato binário de ponto fixo (em memória ou em registrador) algumas operações são feitas algebricamente e outras logicamente.

Operações algébricas usam:Números binários de 15 bits + 1 bit para sinal para números com 2 bytesNúmeros binários de 31 bits + 1 bit para sinal para números com 4 bytesNúmeros binários de 63 bits + 1 bit para sinal para números com 8 bytes

Operações lógicas assumem sempre o número como positivo e usam:Números binários de 16 bits para números com 2 bytesNúmeros binários de 32 bits para números com 4 bytesNúmeros binários de 64 bits para números com 8 bytes



Instruções de máquina (ordem alfabética)

A

AH

AL

ALR

AP

AR

BAL

BALR

BAS

BASR

BASSM

BC

BCR

BCT

BCTR

BSM

BXH

BXLE

C

CDS

CH

CL

CLC

CLCL

CLI

CLM

CLR

CP

CR

CS

CVB

CVD

D

DP

DR

ED

EDMK

EX

IC

ICM

IPM

L

LA

LCR

LH

LM

LNR

LPR

LR

LTR

M

MC

MH

MP

MR

MVC

MVCIN

MVCL

MVI

MVN

MVO

MVZ

N

NC

NI

NR

O

OC

OI

OR

PACK

S

SH

SL

SLA

SLDA

SLDL

SLL

SLR

SP

SPM

SR

SRA

SRDA

SRDL

SRL

SRP

ST

STC

STCK

STCM

STH

STM

SVC

TM

TR

TRT

TS

UNPK

X

XC

XI

XR

ZAP



(Algumas) Instruções de máquina (por grupo)- Movto memória-memória : MVC, MVZ, MVN, MVI, MVO, ZAP, MVCL, PACK, UNPK, MVCIN

- Movimento de dados de registrador para memoria : ST, STH, STM, STC, STCM, CVD

- Movimento de dados de memória para registrador : L, LH, LM, IC, ICM, CVB

- Movimento de dados de registrador para registrador : LR, LPR, LNR, LCR, LTR

- Aritméticas em memória com campos compactados : AP, SP, MP, DP, SRP

- Aritméticas com registradores : AR, SR, MR, DR, ALR, SLR

- Aritméticas com registradores e memória : A, S, M, D, AH, SH, MH, AL, SL

- Comparação : CP, CLC, CLI, CLCL, C, CH, CL, CLM, CR, CLR

- Desvio : BC, BCR

- Controle de loop : BCT, BCTR, BXH, BXLE

- Edição : ED, EDMK

- Tradução e teste de bytes : TR, TRT

- Shift em registradores : SLL, SRL, SLDL, SRDL, SLA, SRA, SLDA, SRDA

- Algebra booleana : N, O, X, NR, OR, XR, NI, OI, XI, NC, OC, XC

- Carga e desvio : BALR, BAL, BAS, BASR, BASSM, BSM

- Outras instruções : LA, TM, EX, SVC, MC, SPM, IPM, STCK, TS, CS, CDS



Dicas para saber qual instrução usar para mover um dado de um lugar para outro

Origem Destino Instrução

Memória Memória MVC

Registrador Registrador LR

Memória (zonado) Memória (compactado) PACK

Memória (compactado) Memória (zonado) UNPK (eventualmente +MVZ ou OI)

Registrador Memória ST

Memória (binário) Registrador L

Memória (compactado) Registrador (binário) CVB

Registrador (binário) Memória (compactado) CVD

(endereço) Registrador LA [ ou L reg,=A(endereço) ]

(endereço) Memória (com endereço) LA + ST [ ou L + ST ]


Instruções de máquina - A

A (Add - Somar)

Esta instrução efetua a soma algébrica entre um número binário contido num registrador (especificado no 1º operando) e um número binário contido num campo de memória de 4 bytes (especificado no 2º operando; em geral uma fullword). O resultado é colocado no registrador 1º operando. Ex:Supor os operandos com tamanho e conteúdo conforme mostrado na linha “Antes” registrador 1o operando antes 2o operando antes registrador 1o operando depois 2o operando depois A 5,=F'259' 00.00.BF.D2 00.00.01.03 00.00.C0.D5 00.00.01.03 A 7,FULL 00.00.00.0D 00.00.01.03 00.00.01.10 00.00.01.03 A 7,4(2,8) 07.FF.FF.FE 00.00.00.01 07.FF.FF.FF 00.00.00.01 A 7,4(2) 07.FF.FF.FF FF.FF.FF.FF 07.FF.FF.FE FF.FF.FF.FF A 7,4(,8) 00.00.00.00 FF.FF.FF.FF FF.FF.FF.FF FF.FF.FF.FF

Código de máquina 5A (Instrução RX)

Condition code 00 Resultado = 001 Resultado < 010 Resultado > 011 Overflow

Interrupções Possíveis 0005,0008

Sumario Instr.Máq.


Instruções de máquina - AH

AH (Add Halfword – Somar Halfword)Código de máquina 4A (Instrução RX)



Esta instrução efetua uma soma algébrica entre dois números binários. Um deles esta localizado no registrador especificado no 1º operando, e o outro num campo de memória de 2 bytes especificado no 2º operando (em geral uma halfword). Antes de efetuada a soma pela UCP, o 2º operando é expandido na UCP para que fique com 32 bits (o bit de sinal é expandido a esquerda); aí então é feita a adição. O resultado é colocado no registrador 1º operando. Ex:Supor os operandos com tamanho e conteúdo conforme mostrado na linha “Antes” registrador 1o operando antes 2o operando antes registrador 1o operando depois 2o operando depois AH 5,=H'259' 00.00.2B.C4 01.03 00.00.2C.C7 01.03 AH 5,HALF 00.00.00.0D 01.0D 00.00.01.1A 01.0D AH 5,4(2,8) 11.11.11.11 (decimal 286331153) 88.88 (decimal –30584) 11.10.99.99 (decimal 286300569) 88.88 AH 5,4(2) 11.11.11.11 (decimal 286331153) 78.88 (decimal +30856) 11.11.89.99 (decimal 286362009) 78.88

Sumario Instr.Máq.


Instruções de máquina - AL

AL (Add Logical – Somar Lógico)Código de máquina 5E (Instrução RX)

Condition code 00 Resultado = 0, não perde sinal01 Resultado <> 0, não perde sinal10 Resultado = 0, perde sinal11 Resultado <> 0, perde sinal

Interrupções Possíveis 0005

Esta instrução efetua uma soma lógica entre dois números binários. Um deles está localizado no registrador especificado no 1º operando. O outro, num campo de memória de 4 bytes especificado no 2º operando (em geral uma fullword). O resultado é colocado no registrador 1º operando. Ex:Supor os operandos com tamanho e conteúdo conforme mostrado na linha “Antes” registrador 1o operando antes 2o operando antes registrador 1o operando depois 2o operando depois AL 5,=F'259' 00.00.00.00 00.00.01.03 00.00.01.03 00.00.01.03 AL 5,FULL 00.B0.C4.E2 00.00.00.01 00.B0.C4.E3 00.00.00.01 AL 5,4(2,8) 7F.FF.FF.FF 00.00.00.01 80.00.00.00 00.00.00.01 AL 5,4(2) FF.FF.FF.FF 00.00.00.01 00.00.00.00 00.00.00.01 AL 5,4(,8) 80.00.00.00 00.00.00.01 80.00.00.01 00.00.00.01

Sumario Instr.Máq.


Instruções de máquina - ALR

ALR (Add Logical Register – Somar Lógico Registradores)Código de máquina 1E (Instrução RR)

Condition code 00 Resultado = 0, não perde sinal01 Resultado <> 0, não perde sinal10 Resultado = 0, perde sinal11 Resultado <> 0, perde sinal

Interrupções Possíveis Nenhuma

É efetuada uma soma lógica entre os números binários (considerados com 32 bits cada, positivos) contidos nos registradores especificados como operandos. O resultado é colocado no registrador 1º operando. Ex:Supor os operandos com tamanho e conteúdo conforme mostrado na linha “Antes” registrador 1o operando antes 2o operando antes registrador 1o operando depois 2o operando depois ALR 7,12 00.B0.C4.E2 00.00.00.01 00.B0.C4.E3 00.00.00.01 ALR 8,8 7F.FF.FF.FF 00.00.00.01 80.00.00.00 00.00.00.01 ALR 10,10 FF.FF.FF.FF 00.00.00.01 00.00.00.00 00.00.00.01 ALR 10,10 80.00.00.00 80.00.00.00 00.00.00.00 80.00.00.00

Sumario Instr.Máq.


Instruções de máquina - AP

AP (Add Packed – Somar Compactado)Código de máquina FA (Instrução SS – L1 e L2)


Interrupções Possíveis 0001,0004,0005,0007,000A

A instrução AP efetua a soma entre dois campos de memória que estejam no formato compactado.O resultado da soma é colocado no campo especificado no 1º operando.O campo especificado no 2º operando fica inalterado. Ex: AP CPOA,CPOB antes depoisCPOB 12.3C 12.3CCPOA 12.34.5C 12.46.8C

AP CPOA,CPOA antes depois CPOA 45.2C 90.4C

Veja mais exemplos a seguir:

Sumario Instr.Máq.


Instruções de máquina - AP

AP (Add Packed – Somar Compactado)Código de máquina FA (Instrução SS – L1 e L2)



Supor os operandos com tamanho e conteúdo conforme mostrado na linha “antes” 1o operando antes 2o operando antes 1o operando depois 2o operando depois AP HOWMANY,=P'1‘ 00.00.5F 1C 00.00.6C 1C AP ARL+2(5),ARL+7(2) 01.23.40.00.0C 98.7C 01.23.40.98.7C 98.7C AP TOTAL,2(3,7) 55.66.77.78.8C 11.11.1D 55.66.66.67.7C 11.11.1D AP 4(3,8),WALFA 01.99.9F 02.0C 02.01.9C 02.0C AP 7(07,8),14(2,3) 00.00.00.00.01.23.4C 00.5C 00.00.00.00.01.23.9C 00.5C AP GRANDTOT,SMALLTOT 00.00.00.0C 00.10.1C 00.00.10.1C

Sumario Instr.Máq.


Instruções de máquina - AR

AR (Add register – Somar registradores)Código de máquina 1A (Instrução RR)



O conteúdo do registrador especificado no 2º operando é somado algebricamente ao conteúdo do registrador especificado no 1º operando (ambos os números em binário) e o resultado é colocado no registrador 1º operando. Ex:Supor os operandos com tamanho e conteúdo conforme mostrado na linha “antes” 1o operando antes 2o operando antes 1o operando depois 2o operando depois AR 7,8 00.00.FF.FF 00.00.00.01 00.01.00.00 00.00.00.01 AR 2,2 00.00.FF.FF 00.00.FF.FF 00.01.FF.FE 00.01.FF.FE

Sumario Instr.Máq.


Instruções de máquina - BAL

BAL (Branch And Link – Desviar e ligar)Código de máquina 45 (Instrução RX)

Condition code Não é alterado


A instrução BAL é análoga ao BALR. A diferença é que seu 2º operando especifica o endereço de uma instrução para onde sempre será efetuado o desvio. A instrução BAL carrega no registrador especificado no 1º operando o endereço da instrução (do byte) seguinte ao BAL e, em seguida, desvia para a instrução cujo endereço indicado no 2º operando.OBS:- Para carregar o endereço no registrador 1º operando, o BAL nele coloca os 4 últimos bytes à direita da PSW atual (BC mode). Ex:

Sumario Instr.Máq.

BAL 9,ROUTINE BAL 14,WRTHDR BAL 7,2(5) BAL 7.2(,8) BAL 7,2(5,8)

...

... BAL 9,ROUTINERETINS EQU * continuação......ROUTINE ST 9,SAVEREG9........ L 9,SAVEREG9 BR 9

BAL carrega o endereço da instrução RETINS no

registrador 9

Salva o registrador 9 (endereço de retorno)

em SAVEREG9

Restaura endereço de retorno

Retorna para RETINS


Instruções de máquina - BALR

BALR (Branch And Link Register – Desviar e ligar registrador)Código de máquina 05 (Instrução RR)



A instrução BALR carrega no registrador especificado no 1º operando o endereço da instrução (do byte) seguinte ao BALR e, em seguida, desvia para a instrução cujo endereço esteja no registrador especificado no 2º operando. OBS:- (1) Se o registrador 2º operando for o registrador 0, o desvio não será feito. (2) Para carregar o endereço no registrador 1º operando, o BALR nele coloca os 4 últimos bytes à direita da PSW atual (BC mode). Ex:

Sumario Instr.Máq.

BALR 3,0 BALR 14,15

... LA 15,ROUTINE BALR 14,15RETINS EQU * continuacao......ROUTINE ST 14,SAVEREG........ L 14,SAVEREG BR 14

BALR carrega o endereço da instrução RETINS no

registrador 14

Salva registrador 14 (endereço de retorno)

em SAVEREG


Retorna para RETINS

LA carrega o endereço da instrução ROUTINE no

registrador 15


Instruções de máquina - BAS

BAS (Branch And Save – Desviar e salvar)Código de máquina 4D (Instrução RR)



O endereço da instrução seguinte (do byte seguinte à instrução BAS) é carregado no registrador 1º operando (carregando nos bytes 1,2 e 3 do registrador os bytes 5, 6 e 7 da PSW atual), e em seguida é efetuado um desvio para a instrução especificada no 2º operando.O primeiro byte à esquerda do registrador 1º operando é zerado, e esta é a diferença entre o BAS e o BAL, pois o BAL, ao carregar o endereço do byte seguinte no registrador 1º operando, ele o faz dos 4 últimos bytes da PSW atual, trazendo o conteúdo do byte 4 da PSW para o byte 0 do registrador 1º operando. Exemplo: BAS 14, ROT

Sumario Instr.Máq.

...

... BAS 9,ROUTINERETINS EQU * continuation......ROUTINE ST 9,SAVEREG........ L 9,SAVEREG BR 9

BAS carrega o endereço da instrução RETINS no registrador 9 (bytes 1,2,3) e coloca zeros no byte 0 dele

Salva registrador 9 (endereço de retorno) em SAVEREG


Retorna para RETINS


Instruções de máquina - BASR

BASR (Branch And Save Register – Desviar e salvar registrador)Código de máquina 0D (Instrução RR)



O endereço da instrução seguinte (do byte seguinte à instrução BASR) é carregado no registrador 1º operando (carregando nos bytes 1,2 e 3 do registrador os bytes 5, 6 e 7 da PSW atual), e em seguida é efetuado um desvio para a instrução cujo endereço está no registrador 2º operando.O primeiro byte à esquerda do registrador 1º operando é zerado, e esta é a diferença entre o BASR e o BALR, pois o BALR, ao carregar o endereço do byte seguinte no registrador 1º operando, ele o faz dos 4 últimos bytes da PSW atual, trazendo o conteúdo do byte 4 da PSW para o byte 0 do registrador 1º operando. Se o registrador 2º operando for o zero, não é efetuado o desvio. Exemplo: BASR 14, 15

Sumario Instr.Máq.

... LA 15,ROUTINE BASR 14,15RETINS EQU * continuação......ROUTINE ST 14,SAVEREG........ L 14,SAVEREG BR 14

BASR zera byte 0 do registrador 14 e carrega o endereço da instrução

RETINS nos bytes 1,2,3 do registrador 14

Salva registrador 14 (endereço de retorno)

em SAVEREG


Retorna para RETINS


registrador 15


Instruções de máquina - BASSM

BASSM (Branch And Save and Set Mode – Desviar e salvar e posicionar modo)Código de máquina 0C (Instrução RR)



O endereço da instrução seguinte (do byte seguinte à instrução BASSM) é carregado no registrador 1º operando (carregado dos bytes 4, 5, 6 e 7 da PSW atual), e em seguida é carregado nos bytes 4 a 7 da PSW atual o conteúdo do registrador 2º operando, incluindo o bit de addressing mode e o endereço da próxima instrução; isto causa um posicionamento do addressing mode e o desvio para a instrução.Se o registrador 2º operando for o zero, não é feita a carga da PSW. Exemplo: BASSM 14, 15

Sumario Instr.Máq.

LA 15,ROUTINE ICM 15,8,AMODE BASSM 14,15RETINS EQU * continuation......ROUTINE ST 14,SAVEREG........ L 14,SAVEREG BR 14

BASSM :- Coloca no reg 14 o endereço da instrução RETINS (pega da PSW)- Carrega conteúdo do reg 15 nos bytes 4-7 da PSW- (Posiciona Addressing mode – pega do reg. 15) e - (Desvia para ROUTINE)

Salva registrador 14 (endereço de

retorno) em SAVEREG


Retorna para RETINS


regiostrador 15

ICM coloca addressability mode nos

bits do registrador 15


Instruções de máquina - BC

BC (Branch on condition – Desviar condicionalmente)

As instruções de desvio são duas: BC (instrução RX) e BCR (instrução RR).No entanto, elas possuem uma série de códigos mnemônicos auxiliares, denominados estendidos, para facilitar o seu uso.O funcionamento das instruções de desvio é baseado no estado do Condition Code e de uma máscara de 4 bits existente na instrução, na metade à esquerda de seu segundo byte.Os 4 estados em que o Condition Code pode se encontrar são: 00, 01, 10 e 11.A cada um desses estados atribui-se um código que o representa:

ESTADO CÓDIGO

00 8

01 4

10 2

11 1

A MÁSCARA indica em que condição deve ser efetuado o desvio, e, como ocupa meio byte, pode ir de X'0' a X'F' (em decimal, de 0 a 15).Se a máscara estiver com 8, o desvio será efetuado se o condition code estiver em B'00' ; se ela estiver em 4, o desvio ocorrerá se o condition code estiver em B'01'; máscara 2 causa desvio se o condition code estiver em B'10"; e, finalmente, máscara 1 acarreta desvio se o condition code estiver posicionado em B'11'.

Sumario Instr.Máq.



BC (Branch on condition – Desviar condicionalmente)

Pode-se fazer combinação dessas condições, somando-se os valores referentes aos códigos do condition code. Por exemplo, a máscara estando em X'C', significa que o desvio deve ser efetuado caso o condition code esteja em 8 ou 4 (8 + 4 = C). Se a máscara for zero, não será efetuado desvio (NOP/NOPR = no operation). Se a máscara for 15 (X'F') será efetuado o desvio independentemente do estado do condition code, pois 15 é a soma dos 4 códigos (8+4+2+1); é o desvio incondicional. As instruções de desvio que especificarem máscara de 1 a 14 são as de desvio condicional (desviam condicionalmente, dependendo do posicionamento do condition code). Vejamos, a seguir, a tabela de mnemônicos normais (BC ou BCR) e suas máscaras possíveis, e seus respectivos mnemônicos estendidos.

Sumario Instr.Máq.



BC (Branch on condition – Desviar condicionalmente)-------------------------------------------------------------------------- USO MNEMÔNICO SIGNIFICADO BC/BCR EQUIVALENTE -------------------------------------------------------------------------- Geral B ou BR Desvia sempre BC 15 ou BCR 15 NOP ou NOPR Nao Desvia BC 0 ou BCR 0-------------------------------------------------------------------------- Apos BH ou BHR Desvia se A > B BC 2 ou BCR 2 Comparações BL ou BLR Desvia se A < B BC 4 ou BCR 4 BE ou BER Desvia se A = B BC 8 ou BCR 8 BNH ou BNHR Desvia se A < ou = B BC 13 ou BCR 13 BNL ou BNLR Desvia se A > ou = B BC 11 ou BCR 11 BNE ou BNER Desvia se A não = B BC 7 ou BCR 7-------------------------------------------------------------------------- Apos BO ou BOR Desvia se overflow BC 1 ou BCR 1 Instruções BP ou BPR Desvia se R > 0 BC 2 ou BCR 2 Aritmeticas BM ou BMR Desvia se R < 0 BC 4 ou BCR 4 BZ ou BZR Desvia se R = 0 BC 8 ou BCR 8 BNP ou BNPR Desvia se R < ou = 0 BC 13 ou BCR 13 BNM ou BNMR Desvia se R > ou = 0 BC 11 ou BCR 11 BNZ ou BNZR Desvia se R não = 0 BC 7 ou BCR 7--------------------------------------------------------------------------Apos um TM BO ou BOR Desvia se todos 1 BC 1 ou BCR 1 BM ou BMR Desvia se misturados BC 4 ou BCR 4 BZ ou BZR Desvia se todos 0 BC 8 ou BCR 8 BNO ou BNOR Desvia se nem todos 1 BC 14 ou BCR 14--------------------------------------------------------------------------OBS: - A = 1º operando ; B = 2º operando ; R = 1º operando após a conta

Sumario Instr.Máq.



BC (Branch on condition – Desviar condicionalmente)O significado das instruções é o seguinte: B = Branch (Desvie)NOP = No Operation (Sem operação - não desvie)BH = Branch High (Desvie se Maior)BL = Branch Low (Desvie se Menor)BE = Branch Equal (Desvie se Igual)BNH = Branch Not High (Desvie se Nao Maior)BNL = Branch Not Low (Desvie se Nao Menor)BNE = Branch Not Equal (Desvie se Nao Igual)BO = Branch If Overflow (Desvie se Overflow)BP = Branch If Plus (Desvie se Mais)BM = Branch If Minus (Desvie se Menos)BZ = Branch If Zero (Desvie se Zero)BNP = Branch If Not Plus (Desvie se Nao Mais)BNM = Branch If Not Minus (Desvie se Nao Menos)BNZ = Branch If Not Zero (Desvie se Nao Zero)BO = Branch If Ones (Desvie se Um's)BM = Branch If Mixed (Desvie se Misturados)BZ = Branch If Zeros (Desvie se Zeros)BNO = Branch If Not Ones (Desvie se Nao UM's)

Sumario Instr.Máq.



BC (Branch on condition – Desviar condicionalmente)BC (Branch on Condition – Desviar na Condição) Código de máquina 47 (Instrução RX)



Esta instrução efetua (ou não) um desvio para outra instrução. Seu formato é:CO = 1 byte (código de operação)M1 = 1/2 byte (MÁSCARA)X2 = 1/2 byte (indexador do endereço do segundo operando)E2 = 2 bytes (base+deslocamento do endereço do segundo operando) O endereço do 2º operando é o endereço da instrução para onde deve ser efetuado o desvio. A MÁSCARA indica em que condição deve haver o desvio.

Sumario Instr.Máq.






Se a condição especificada na máscara não for satisfeita, o desvio não será efetuado, isto é, o processamento continuará na instrução seguinte ao BC.Usando o BC, o 1º operando é a máscara, e o 2ºoperando é uma indicação da instrução para onde deve ser efetuado o desvio. Se o mnemônico estendido for usado, deve-se especificar um único operando equivalente ao 2º operando do BC (a máscara estará implícita no código de operação mnemônico). Ex: BC 8,VOLTA É o mesmo que BE VOLTANeste caso, será efetuado o desvio para VOLTA se o condition code tiver 00. Outros exemplos: B LER mesmo que BC 15,LER BH AGAIN mesmo que BC 2,AGAIN BL COMPARA mesmo que BC 4,COMPARA BE 0(2) mesmo que BC 8,0(2) BE 0(,4) mesmo que BC 8,0(,4) BE 0(2,4) mesmo que BC 8,0(2,4)

Sumario Instr.Máq.






Outros exemplos: B READ Mesmo que BC 15,READ BNH LOOP1 Mesmo que BC 13,AGAIN BNL LOOP2 Mesmo que BC 11,COMPARE BNE 0(2) Mesmo que BC 7,0(2) BZ 0(,4) Mesmo que BC 8,0(,4) BNZ 0(2,4) Mesmo que BC 7,0(2,4) BM BTAB(15) Mesmo que BC 4,BTAB(15)

Sumario Instr.Máq.


Instruções de máquina - BCR

BCR (Branch on Condition Register – Desviar condicionalmente [para] registrador)BCR (Branch on Condition Register – Desviar [para endereço de registrador] na Condição)

Código de máquina 07 (Instrução RX)



A instrução BCR é análoga ao BC. VEJA A INSTRUÇÃO BC.A BCR tem o seguinte formato de máquina:CO = 1 byte (código de operação = 07)M1 = 1/2 byte (MÁSCARA)R2 = registrador segundo operando

Usando BCR, o primeiro operando é a máscara, e o segundo é o número do registrador que contém o endereço da instrução para onde será efetuado o desvio. Se usarmos o mnemônico estendido, o único operando especificado é o número do registrador que é o segundo operando da instrução (mas único na especificação).

Exemplo:

Sumario Instr.Máq.


Instruções de máquina - BCR

BCR (Branch on Condition Register – Desviar condicionalmente [para] registrador)BCR (Branch on Condition Register – Desviar [para endereço de registrador] na Condição)




BCR 8,15 É o mesmo que BER 15Neste caso, será efetuado o desvio se o condition code tiver 00.

Veja os exemplos a seguir:

BCR 2,10 mesmo que BHR R10 BR 7 mesmo que BCR 15,R7 BNER 10 mesmo que BCR 7,R10 BLR 15 mesmo que BCR 4,R15

Sumario Instr.Máq.


Instruções de máquina - BCT

BCT (Branch on CounT – Desviar se contador [zero])Código de máquina 46 (Instrução RX)



A instrução BCT tem dois operandos: o 1. é um registrador, e o 2. é o endereço de uma instrução.A sua função é a seguinte: o BCT subtrai 1 do registrador especificado no 1º operando e, em seguida, compara o número resultante com zeros: Se o resultado não for zero, será efetuado um desvio para a instrução especificada no 2º operando. Se o resultado for zero, não será efetuado o desvio, continuando o processamento através da instrução seguinte ao BCT. Exemplos:

Sumario Instr.Máq.

BCT 5,AGAIN BCT 2,0(4,7) BCT 2,0(4) BCT 2,0(,7)

... L 11,=F’200’AGAIN CLC 0(3,5),CODE BE FOUND...... BCT 11,AGAINNOTFND EQU * ........FOUND EQU *...

L carrega no registrador 11 o número de vezes que o loop deve ser repetido

No final do conjunto de instruções do loop, o BCT

subtrai 1 do registrador 11. Se não chegou no zero,

desvia para AGAIN.Se chegou no zero, continua

a execução em NOTFND


Instruções de máquina - BCTR

BCTR (Branch on CounT Register – Desviar se contador [zero] [para] registrador)




A instrução BCTR tem dois operandos registradores. A sua função é a seguinte: o BCTR subtrai 1 do registrador especificado no 1º operando e, em seguida, compara o número resultante com zeros; Se resultado < > 0, será desviado para a instrução cujo endereço estiver no registrador 2º operando. Se o resultado = 0, não será efetuado o desvio; continuando na instrução seguinte ao BCTR.IMPORTANTE: Se o registrador 2º operando for o registrador 0 (zero) o desvio não será efetuado. Exemplos:

Sumario Instr.Máq.

BCTR 2,7 BCTR 4,0

LA 15,AGAIN L 11,=F’200’AGAIN CLC 0(3,5),CODE BE FOUND...... BCTR 11,15NOTFND EQU * ........FOUND EQU *...

L carrega no registrador 11 o número de vezes que o loop deve ser repetido

No final do conjunto de instruções do loop, o BCTR subtrai 1 do registrador 11.

Se não chegou no zero, desvia para AGAIN.

Se chegou no zero, continua a execução em NOTFND

LA carrega no registrador 15 o endereço da instrução AGAIN


Instruções de máquina - BSM

BSM (Branch and Set Mode – Desviar e posicionar modo)Código de máquina 0B (Instrução RR)



(a) O bit 32 da PSW é carregado no bit 0 do registrador primeiro operando (os bits 1 a 31 permanecem inalterados), e depois

(b) o registrador segundo operando é carregado nos bytes 4-7 da PSW (incluindo o bit de addressing mode e o instruction address), de forma que o addressing mode é posicionado e o desvio executado.

Se o registrador segundo operando é o zero, a PSW não é carregada. Exemplo:

BSM 14,15

Sumario Instr.Máq.


Instruções de máquina - BXH

BXH (Branch on indeX High – Desviar se indexador maior)Código de máquina 86 (Instrução RX)



O 1º e o 2º operandos especificados são registradores.O 3º operando é o endereço de uma instrução.O conteúdo do registrador especificado no 2º operando é somado ao conteúdo do registrador especificado no 1º operando, ficando o resultado da soma no registrador especificado no 1º operando.Em seguida, o resultado da soma é comparado com: O conteúdo do registrador especificado no 2º operando, se ele for ímpar ou O conteúdo do registrador seguinte ao especificado no 2º operando, se este for par.Se o resultado da comparação for: Maior, será efetuado um desvio para a instrução cujo endereço estiver especificado no 3. operando. Menor ou igual, não será efetuado o desvio, continuando o processamento através da instrução seguinte ao BXH.

Sumario Instr.Máq.






Exemplos:

BXH 7,8,AGAIN R7 = R8 + R7; Se R7 > R9 Desvia para AGAIN; * Se R7 <= R9 próxima instrução

BXH 7,9,AGAIN R7 = R9 + R7; Se R7 > R9 Desvia para AGAIN;* Se R7 <= R9 próxima instrução

BXH 7,9,8(4) R7 = R9 + R7; Se R7 > R9 Desvia para instrução* Com endereço = [ (conteúdo R4) + x’008’ ]* Se R7 <= R9 próxima instrução

Sumario Instr.Máq.






BXH 7,8,NOTFOUND R7 = R8 + R7; * If R7 > R9 toda tabela varrida; fim da pesquisa * If R7 <= R9 tabela não vista toda; continuar pesquisa

Exemplo: Usar no fim de uma laço para pesquisa. R7 = começa com o endereço da tabela; somado com o tamanho dos itens da tabelaR8 = tamanho dos itens da tabelaR9 = endereço do último elementoNOTFOUND : toda tabela varrida; item desejado não achado

L R7,=A(TABADRS) L R8,=A(20) L R9,=A(TABADRS+(HOWMANY-1)*LENGTH)NEXTITEM compara item apontado vs desejado se achado, processa e desvia para TABLSEEN se não achado, aponta p/ próximo BXH R7,R8,NOTFOUND B NEXTITEMTABLSEEN ...

Sumario Instr.Máq.


Instruções de máquina - BXLE

BXLE (Branch on indeX Less or Equal – Desviar se indexador menor ou igual)Código de máquina 87 (Instrução RS)



A instrução BXLE é análoga ao BXH, com a diferença de que o desvio será efetuado se o resultado da comparação der menor ou igual; e se o resultado der maior não será efetuado o desvio:O 1º e o 2º operandos especificados são registradores. O 3º operando é o endereço de uma instrução.O conteúdo do registrador especificado no 2º operando é somado ao conteúdo do registrador especificado no 1º operando, ficando o resultado da soma no registrador especificado no 1º operando.Em seguida, o resultado da soma é comparado com: O conteúdo do registrador especificado no 2º operando, se ele for ímpar ou O conteúdo do registrador seguinte ao especificado no 2º operando, se este for par.Se o resultado da comparação for: Menor ou igual, será efetuado um desvio para a instrução cujo endereço estiver especificado no 3. operando. Maior, não será efetuado o desvio, continuando o processamento através da instrução seguinte ao BXLE.

Sumario Instr.Máq.






Exemplos:

BXLE 7,8,AGAIN R7 = R8 + R7; Se R7 <= R9 Desvia para AGAIN; * Se R7 > R9 próxima instrução

BXLE 7,9,AGAIN R7 = R9 + R7; Se R7 <= R9 Desvia para AGAIN;* Se R7 > R9 próxima instrução

BXLE 7,9,8(4) R7 = R9 + R7; Se R7 <= R9 Desvia para a instrução * Cujo endereço é [ (conteúdo R4) + x’008’ ]* Se R7 > R9 próxima instrução

Sumario Instr.Máq.






BXLE 7,8,NOTFOUND R7 = R8 + R7; * If R7 <= R9 tabela não vista toda; continuar pesquisa* If R7 > R9 toda tabela varrida; fim da pesquisa

Exemplo: Usar no fim de uma laço para pesquisa. R7 = começa com o endereço da tabela; somado com o tamanho dos itens da tabelaR8 = tamanho dos itens da tabelaR9 = endereço do último elementoNOTFOUND : toda tabela varrida; item desejado não achado

L R7,=A(TABADRS) L R8,=A(20) L R9,=A(TABADRS+(HOWMANY-1)*LENGTH)NEXTITEM compara item apontado vs desejado se achado, processa e desvia para TABLSEEN se não achado, aponta p/ próximo BXLE R7,R8,NEXTITEMNOTFOUND ...TABLSEEN ...

Sumario Instr.Máq.


Instruções de máquina - C

C (Compare)Código de máquina 59 (Instrução RX)

Condition code 00 1ºoperando = 2ºoperando01 1ºoperando < 2ºoperando10 1ºoperando > 2ºoperando 11 O condition code nunca fica em 11 após um C


A instrução C efetua a comparação algébrica entre um número binário contido num registrador (especificado no 1º operando) e um número binário contido num campo de memória de 4 bytes (especificado no 2º operando - em geral uma fullword). Ex: C 9,CPO C 8,=F'0' C 13,=A(TABELA+430) C 1,2(4) C 1,2(,4) C 1,2(7,4)

Sumario Instr.Máq.


Instruções de máquina - CDS

CDS (Compare Double and Swap – Comparar double e trocar)Código de máquina BB (Instrução RS)

Condition code 00 1º e 2º operandos são iguais, o 3º operando foi colocado no 2º operando01 1º e 2º operandos são diferentes, o 2º operando foi colocado no 1º operando10 Nunca fica em 10 após um CDS 11 Nunca fica em 11 após um CDS

Interrupções Possíveis 0004,0005,0006

O primeiro e o terceiro operandos são registradores pares, e são considerados os registradores R1 e R1+1 como 1º operando, e R3 e R3+1 como 3º operando.O segundo operando é um campo de memória (doubleword).O conteúdo dos registradores R1 e R1+1 é comparado com o conteúdo da double word. Se eles forem iguais, o conteúdo dos registradores R3 e R3+1 é colocado na doubleword (store). Se eles forem diferentes, o conteúdo da doubleword é colocado nos registradores R1 e R1+1 (load).

Ver exemplos a seguir:

Sumario Instr.Máq.


Instruções de máquina - CDS

CDS (Compare Double and Swap – Comparar double e trocar)Código de máquina BB (Instrução RS)

Condition code 00 1º e 2º operandos são iguais, o 3º operando foi colocado no 2º operando01 1º e 2º operandos são diferentes, o 2º operando foi colocado no 1º operando10 Nunca fica em 10 após um CDS 11 Nunca fica em 11 após um CDS


CDS 4,8,DW Antes: R4/R5 00.BF.C4.20.50.CC.A0.00 R8/R9 7D.48.C0.00.00.00.00.02 DW 00.BF.C4.20.50.CC.A0.00 Depois: R4/R5 00.BF.C4.20.50.CC.A0.00 R8/R9 7D.48.C0.00.00.00.00.02 DW 7D.48.C0.00.00.00.00.02

CDS 4,8,DW Antes: R4/R5 00.CC.DD.EE.FF.FF.FF.FF R8/R9 7D.48.C0.00.00.00.00.02 DW 00.BF.C4.20.50.CC.A0.00 Depois: R4/R5 00.BF.C4.20.50.CC.A0.00 R8/R9 7D.48.C0.00.00.00.00.02 DW 00.BF.C4.20.50.CC.A0.00

Sumario Instr.Máq.


Instruções de máquina - CH

CH (Compare Halfword)Código de máquina 49 (Instrução RX)

Condition code 00 1ºoperando = 2ºoperando01 1ºoperando < 2ºoperando10 1ºoperando > 2ºoperando 11 O condition code nunca fica em 11 após um CH


A instrução CH efetua a comparação algébrica entre um número binário contido num registrador (1º operando) e um número binário contido num campo de memória de 2 bytes (2º operando - em geral uma halfword). Para isso o campo de 2 bytes é expandido (internamente, na UCP) para 4 bytes; a expansão é feita colocando-se os seus 2 bytes nos 2 bytes à direita do campo de 4 bytes, e repetindo à esquerda o bit de sinal(bit mais à esquerda da halfword). Ex: CH 9,CPO 1o. operando = R9; 2o. operando = campo CPO CH 8,=H'0' 1o. operando = R8; 2o. operando = halfword com zeros CH 13,=Y(TAB+430) 1o. operando = R13; 2o. operando = halfword com endereço de TAB+430 CH 1,2(4) 1o. operando = R1; 2o. operando = halfword com endereço = * Valor do registrador indexador R4 + 0[registrador base omitido] + x’2’ CH 1,2(,4) 1o. operando = R1; 2o. operando = halfword com endereço = * Valor do registrador base R4 + 0[reg. indexador omitido] + x’2’ CH 1,2(7,4) 1o. operando = R1; 2o. operando = halfword com endereço = * Valor do registrador base R4 + valor do reg. indexador R7 + x’2’

Sumario Instr.Máq.


Instruções de máquina - CL

CL (Compare Logical – Comparar logicamente)Código de máquina 55 (Instrução RX)

Condition code 00 1ºoperando = 2ºoperando01 1ºoperando < 2ºoperando10 1ºoperando > 2ºoperando 11 O condition code nunca fica em 11 após um CL


A instrução CL efetua uma comparação lógica entre o conteúdo de um registrador (especificado no 1º operando) e o conteúdo de um campo de 4 bytes (Especificado no 2º operando - em geral uma fullword). A comparação lógica é feita da esquerda para a direita, bit a bit. O primeiro par de bits diferentes detectado termina a comparação. Ex: CL 9,CPO 32 bits do registrador 9 comparados com 32 bits do campo de 4 bytes CPO CL 8,=F'0' 32 bits do registrador 8 comparados com 32 bits do campo de 4 bytes com 0 CL 1,2(4) 32 bits do registrador 1 comparados com o campo de 4 bytes* ( endereço 2o operando = conteúdo indexador 4 + deslocamento X’2’ [reg. base omitido = zero = não considerado] ) CL 1,2(,4) 32 bits do registrador 1 comparados com o campo de 4 bytes* ( endereço do 2o operando = [ indexador omitido = zero = não considerado] + deslocamento X’2’ + reg base 4 ) CL 1,2(7,4) 32 bits do registrador 1 comparados com o campo de 4 bytes* ( endereço do 2o operando = conteúdo do reg. indexador 7 + deslocamento X’2’ + conteúdo do reg. base 4 )

Sumario Instr.Máq.


Instruções de máquina - CLC

CLC (Compare Logical Character – Comparar caracteres logicamente)Código de máquina D5 (Instrução SS – L)

Condition code 00 1ºoperando = 2ºoperando01 1ºoperando < 2ºoperando10 1ºoperando > 2ºoperando 11 O condition code nunca fica em 11 após um CLC


A interrupção CLC faz a comparação lógica (bit a bit, da esquerda para a direita) entre dois campos de memória. O primeiro par de bits diferentes detectado termina a comparação. Ex: CLC CPOA,CPOB Tamanho único usado = tamanho de CPOA (100 bytes) CLC AE+78(2),=C'*1' Campo de 2 bytes (AE+78 e AE+79) é comparado com campo de 2 * bytes referenciado por literal (conteúdo = X’5CF1’) CLC 4(2,7),2(9) Campo de 2 bytes (endereço = base 7 + deslocamento X’4’) * é comparado com campo com endereço = base 9 + deslocamento X’’2’ CLC ID,2(7) Campo com n bytes chamado ID comparado com campo de n bytes* com endereço = base 7 + deslocamento X’2’ CLC 194(5,11),AE+3 Campo de 5 bytes (endereço = base 11 + deslocamento X’C2’) * é comparado com campo de 5 bytes ( endereço = AE+3 )

Sumario Instr.Máq.


Instruções de máquina - CLCL

CLCL (Compare Logical Character Long – Comparar caracteres logicamente - longo)Código de máquina 0F (Instrução RR)

Condition code 00 1ºoperando = 2ºoperando ou ambos os operandos tem tamanho 0.01 1ºoperando < 2ºoperando10 1ºoperando > 2ºoperando11 Nunca o condition code fica em 11 após um CLCL


Tanto o 1. como o 2º operandos especificados devem ser registradores pares, os quais indicam (cada um deles) conjuntos de registradores par-ímpar, os quais chamaremos de R1 e R1+1 e R2 e R2+1.Esta instrução compara dois campos de memória, do mesmo modo que um CLC.O endereço do campo 1º operando deve estar nos 3 últimos bytes à direita de R1.O endereço do campo 2º operando deve estar nos 3 últimos bytes à direita de R2.O tamanho (número de bytes) do 1º operando deve estar nos 3 últimos bytes à direita de R1+1.O tamanho (número de bytes) do 2º operando deve estar nos 3 últimos bytes à direita de R2+1.O 1º byte à esquerda de R2+1 deve conter o caracter de preenchimento.O conteúdo do 1º byte à esquerda de R1, R2 e R1+1 é desprezado.Ex: CLCL 2,8R1=registrador primeiro operando= registrador 2 R1+1= registrador 3R2=registrador segundo operando= registrador 8 R2+1= registrador 9

Sumario Instr.Máq.




Condition code 00 1ºoperando = 2ºoperando ou ambos os operandos tem tamanho 0.01 1ºoperando < 2ºoperando10 1ºoperando > 2ºoperando11 Nunca o condition code fica em 11 após um CLCL


A comparação é feita bit a bit, da esquerda para a direita. Ela termina quando é encontrada uma desigualdade entre bits, ou quando o tamanho do maior operando for alcançado.Se os operandos não tiverem o mesmo tamanho, o menor é estendido com o caracter de preenchimento (para a comparação - a expansão é feita internamente, sem alteração de campos).Se a execução da instrução termina por causa de uma desigualdade, temos que: · Do conteúdo dos 3 últimos bytes à direita de R1+1 e R2+1 é subtraído o número de bytes iguais, a menos que a desigualdade tenha ocorrido com o caracter de preenchimento, sendo que, neste caso, os 3 últimos bytes à direita de R1+1 ou R2+1 (o que indicar o menor tamanho) são zerados. · Ao conteúdo dos 3 últimos bytes à direita de R1 e R2 é somado o número de bytes iguais.Se os 2 operandos forem iguais (incluindo o caracter de preenchimento, se necessário), temos que: · Os 3 últimos bytes à direita de R1+1 e R2+1 são zerados. · Aos 3 últimos bytes à direita de R1 e R2 é somado o número de bytes iguais.Nos 2 casos: o 1º byte à esquerda de R1 e R2 é zerado, e o 1º byte à esquerda de R1+1 e R2+1 não são alterados.

Sumario Instr.Máq.




Condition code 00 1ºoperando = 2ºoperando ou ambos os operandos tem tamanho 0.01 1ºoperando < 2ºoperando10 1ºoperando > 2ºoperando11 Nunca o condition code fica em 11 após um CLCLInterrupções Possíveis 0005,0006

Exemplo:

Sumario Instr.Máq.

Exemplo:

LA 2,BUFEROUT LA 3,12000 LA 8,BUFERIN LA 9,20000 ICM 9,B'1000',C' ' AGAIN CLCL 8,9 BE EQUALSDIFFS EQU *...... ......EQUALS EQU *...

LA carrega no registrador 2 o endereço de

BUFEROUT

CLCL executes the compare between a 12000-byte field (BUFEROUT) and a 20000-

byte field (BUFERIN)

LA carrega no registrador 3 o tamanho de

BUFEROUT

LA carrega no registrador 8 o endereço de BUFERIN

LA carrega no registrador 9 o tamanho de BUFERIN ICM insere o caracter de

preenchimento no byte mais à esquerda do

registrador 9


Instruções de máquina - CLI

CLI (Compare Logical Immediate – Comparar logicamente [operando] imediato)Código de máquina 95 (Instrução SI)

Condition code 00 1ºoperando = 2ºoperando01 1ºoperando < 2ºoperando10 1ºoperando > 2ºoperando 11 O condition code nunca fica em 11 após um CLI


A instrução CLI faz a comparação lógica entre dois campos de memória (1 byte cada). O seu 2º operando deve ser um termo auto definido. Exemplos (observe que b1d1d1d1 é o endereço do 1o. operando na forma base+deslocamento): CLI AE+79,C'*' Instrução de máquina = 95.5C.b1d1.d1d1 Compara com asterisco

CLI 2(5),X'00' Instrução de máquina = 95.00.50.02 Compara com zeros binários

CLI BYTE,B'11110000' Instrução de máquina = 95.F0.b1d1.d1d1 Compara com caracter zero

CLI NOP+1,240 Instrução de máquina = 95.F0.b1d1.d1d1 Compara com caracter zero

Sumario Instr.Máq.


Instruções de máquina - CLM

CLM (Compare Logical under Mask – Comparar logicamente sob máscara)Código de máquina BD (Instrução RS)

Condition code 00 Os bytes selecionados são iguais, ou a máscara é zero.01 Campo selecionado do 1ºoperando é menor10 Campo selecionado do 1ºoperando é maior11 Nunca o condition code fica em 11 após um CLM


O conteúdo do registrador 1º operando é comparado logicamente com o conteúdo do campo de memória 2º operando, sob o controle de uma máscara, e o resultado é indicado no condition code. O seu formato de máquina é o seguinte:CO (código de operação) = 1 byte R1 (registrador primeiro operando) = 1/2 byteM3 (máscara) = 1/2 byte E2 (endereço base+deslocamento do segundo operando) = 2 bytesOs 4 bits da máscara, da esquerda para a direita, correspondem aos 4 bytes do registrador especificado no 1ºoperando. Os bytes do registrador que tiverem os seus bits correspondentes na máscara ligados, são considerados como um "campo" contíguo, e comparados com o campo especificado no último operando da instrução (2º operando), o qual deve ter tantos bytes de tamanho quantos forem os bits da máscara ligados. Os bytes do registrador cujos bits correspondentes na máscara estiverem desligados, não participam da operação. Ex: CLM 5,B'1011',ARCOMPNeste caso o "campo" formado pelos 1º, 3º e 4º bytes do registrador 5, será comparado o campo de 3 bytes denominado ARCOMP.

Sumario Instr.Máq.


Instruções de máquina - CLR

CLR (Compare Logical Register – Comparar logicamente registradores)Código de máquina 15 (Instrução RR)

Condition code 00 1ºoperando = 2ºoperando01 1ºoperando < 2ºoperando10 1ºoperando > 2ºoperando11 O condition code nunca fica em 11 após um CLR


A instrução CLR faz uma comparação lógica entre o conteúdo de um registrador (especificado no 1º operando) e o conteúdo de outro registrador (especificado no 2º operando). Ex:

CLR 4,5 “string” de 32 bits do registrador 4 comparado com o “string’ de 32 bits do registrador 5

CLR 8,13 “string” de 32 bits do registrador 8 comparado com o “string’ de 32 bits do registrador 13

Sumario Instr.Máq.


Instruções de máquina - CP

CP (Compare Packed – Comparar compactado)Código de máquina F9 (Instrução SS – L1 e L2)

Condition code 00 1ºoperando = 2ºoperando01 1ºoperando < 2ºoperando10 1ºoperando > 2ºoperando 11 O condition code nunca fica em 11 após um CP


A instrução CP efetua a comparação algébrica entre dois campos de memória que estejam no formato decimal compactado. Os dois campos permanecem inalterados. Ex: CP FLDA,FLDB Se FLDA = X’00000009999C’ e FLDB = X’10000C’* Resultado é : 1o operando menor que 2o operando

CP COUNTLIN,=P'1' Se COUNTLIN = X’999999D’ comparado com X’1C’* O resultado é : 1o operando menor que 2o operando

CP 0(5,9),=P'0' Compara conteúdo do campo de 5 bytes no endereço * (registrador base 9 + deslocamento X’0’) com zero

CP TOTAL,2(7,9) Compara conteúdo de TOTAL com campo de 7 bytes no endereço (registrador base 9 + X’2’)

Sumario Instr.Máq.


Instruções de máquina - CR

CR (Compare Register – Comparar registradores)Código de máquina 19 (Instrução RR)

Condition code 00 1ºoperando = 2ºoperando01 1ºoperando < 2ºoperando10 1ºoperando > 2ºoperando11 O condition code nunca fica em 11 após um CR

Interrupções Possíveis nenhuma

A instrução CR faz uma comparação algébrica entre um número binário contido num registrador (especificado no 1º operando) e outro número binário contido em outro registrador (especificado no 2º operando). Ex:

CR 4,5 Compara número binário de 31 bits no registrador 4 c/ número binário de 31 bits no registrador 5

CR 8,13 Compara número binário de 31 bits no registrador 8 c/ número binário de 31 bits no registrador 13

Sumario Instr.Máq.


Instruções de máquina - CS

CS (Compare and Swap – Comparar e trocar)Código de máquina BA (Instrução RS)

Condition code 00 1º e 2º operandos são iguais, o 3. Operando foi colocado no 2º operando01 1º e 2º operandos são diferentes, o 2º operando foi colocado no 1º operando10 Nunca fica em 10 após um CS 11 Nunca fica em 11 após um CSInterrupções Possíveis 0004,0005,0006

O primeiro e o terceiro operandos são registradores.O segundo operando é um campo de memória (fullword).O conteúdo do registrador 1º operando é comparado com o conteúdo da fullword. Se eles forem iguais, o conteúdo do registrador 3º operando é colocado na fullword (store). Se eles forem diferentes, o conteúdo da fullword é colocado no registrador 1º operando (load). Exemplos: CS 5,8,FWAntes: R5 00.BF.C4.20 R8 7D.48.C0.00 FW 00.BF.C4.20Depois: R5 00.BF.C4.20 R8 7D.48.C0.00 FW 7D.48.C0.00

Outro exemplo: CS 5,8,FWAntes: R5 00.BF.C4.20 R8 7D.48.C0.00 FW 00.FF.EE.DDDepois: R5 00.FF.EE.DD R8 7D.48.C0.00 FW 00.FF.EE.DD

Sumario Instr.Máq.


Instruções de máquina - CVB

CVB (ConVert to Binary – Converter para binário)Código de máquina 4F (Instrução RX)


Interrupções Possíveis 0005, 0007, 0009

O número compactado que esta no campo de 8 bytes especificado no 2º operando (em geral uma doubleword), o qual permanece inalterado, é transformado para binário e colocado no registrador especificado no 1º operando. Ex:Supor os operandos com tamanho e conteúdo conforme mostrado na linha “antes” 1o operando antes 2o operando antes 1o operando depois 2o operando depois CVB 8,DOUBLE 12.BC.4F.CA 00.00.00.00.00.01.02.4D FF.FF.FC.00 00.00.00.00.00.01.02.4D* 2o operando = DOUBLE CVB 8,0(5,9) FF.FF.FF.FF 00.00.00.00.00.01.02.5C 00.00.04.01 00.00.00.00.00.01.02.5C* Endereço 2o operando = indexador 5 + base 9 + X’0’ CVB 8,0(,9) FF.FF.FF.FF 00.00.00.00.00.01.02.3F 00.00.03.FF 00.00.00.00.00.01.02.3F* Endereço 2o operando = indexador 0 + base 9 + X’0’ CVB 8,0(5) FF.FF.FF.FF 00.00.00.00.00.01.02.3C 00.00.03.FF 00.00.00.00.00.01.02.3C* Endereço 2o operando = indexador 5 + base 0 + X’0’

Sumario Instr.Máq.


Instruções de máquina - CVD

CVD (ConVert to Decimal – Converter para decimal [compactado])Código de máquina 4E (Instrução RX)



O número (binário) contido no registrador especificado no 1º operando é convertido para formato decimal compactado e colocado no campo de memória de 8 bytes (em geral uma doubleword) especificado no 2º operando. OBS:- número positivo: sinal C ; número negativo: sinal D. Exemplos:Supor os operandos com tamanho e conteúdo conforme mostrado na linha “antes” 1o operando antes 2o operando antes 1o operando depois 2o operando depois CVD 8,DOUBLE 00.00.10.00 00.00.00.00.00.00.00.70 00.00.10.00 00.00.00.00.00.04.09.6C* 2o operando = DOUBLE CVD 8,0(5,9) FF.FF.FF.FF 00.00.FB.EC.44.CC.F0.F1 FF.FF.FF.FF 00.00.00.00.00.00.00.1D* Endereço 2o operando = indexador 5 + base 9 + X’0’ CVD 8,0(,9) 00.00.99.99 98.BA.76.FE.54.DC.32.B9 00.00.99.99 00.00.00.00.00.39.32.1C* Endereço 2o operando = indexador 0 + base 9 + X’0’ CVD 8,0(5) 00.00.AA.AA 00.00.00.00.00.00.00.0C 00.00.AA.AA 00.00.00.00.00.43.69.0C* Endereço 2o operando = indexador 5 + base 0 + X’0’

Sumario Instr.Máq.


Instruções de máquina - D

D (Divide)Código de máquina 5D (Instrução RX)



Esta instrução efetua uma divisão entre dois números binários.O registrador especificado no 1º operando deve ser par.O dividendo é um número binário de 64 bits contido no conjunto de registradores par-ímpar indicado no 1º operando.O divisor é um número contido num campo de memória de 4 bytes (especificado no 2º operando - em geral uma fullword).Após efetuada a divisão, o resto será colocado no registrador par do conjunto par-ímpar; o quociente será colocado no registrador ímpar do conjunto par-ímpar. Exemplo: D 6,CPOANeste caso, temos: Dividendo : Regs. 6 e 7 juntos ; Divisor : CPOA ; Quociente : Reg. 7 ; Resto : Reg. 6Outros exemplos: L 6,=F'0' Dividendo: Registradores 6-7 juntos; L 7,=F'257' Eles juntos tem o número 257 D 6,=F'4' Divisor: (literal) com número 4; Quociente: Registrador 7 = conteúdo 64; Resto: Registrador 6 = conteúdo 1* L 10,=F'0' Dividendo: Registradores 10-11 juntos; L 11,=F'17' Eles juntos tem o número 17 D 10,=F'3' Divisor: (literal) com número 3; Quociente: Registrador 11 = conteúdo 5; Resto: Registrador 10 = conteúdo 2*

Sumario Instr.Máq.


Instruções de máquina - DP

DP (Divide Packed – Dividir compactado)Código de máquina FD (Instrução SS – L1 e L2)


Interrupções Possíveis 0004,0005,0006,0007,000B

A instrução DP efetua a divisão entre dois campos de memória que estejam no formato decimal compactado.O 1º operando deve conter o dividendo, e o 2º operando deve conter o divisor. Após efetuada a divisão, o cociente e o resto são colocados no campo especificado no 1º operando. O campo especificado no 2º operando permanece inalterado.O tamanho do 2º operando (divisor) não pode ser maior que 8 bytes, nem maior ou igual ao tamanho do 1º operando; se uma dessas duas condições ocorrer, haverá interrupção de programa (código 0006).O resto da divisão é colocado à direita do campo 1º operando, com tamanho do divisor. No restante do 1º operando, à esquerda, é colocado o cociente da divisão. O 2º operando permanece inalterado.A interrupção de programa por código 000B é causada quando: tamanho do cociente é maior que o tamanho a ele reservado no 1º operando. dividendo não tem pelo menos um 0 (zero) à esquerda. divisor é o número 0.Veja os exemplos a seguir:

Sumario Instr.Máq.


Instruções de máquina - DP

DP (Divide Packed – Dividir compactado)Código de máquina FD (Instrução SS – L1 e L2)


Interrupções Possíveis 0004,0005,0006,0007,000B

Supor que os operandos e seus tamanhos e conteúdos sejam os indicados na linha “antes”

1o operando antes 2o operando antes 1o operando depois 2o operando depois DP FLDA,FLDB 00.00.45.67.8C 00.2C 22.83.9C.00.0C 00.2C DP FLDA,FLDB 00.00.00.11.1C 00.2C 00.05.5C.00.1C 00.2C DP VALUE,=P'5' 00.00.00.00.00.12.7C 5C 00.00.00.00.02.5C.2C 5C

Sumario Instr.Máq.


Instruções de máquina - DR

DR (Divide Register – Dividir registradores)Código de máquina 1D (Instrução RR)



O 1º operando especificado deve ser um registrador par. O número contido nele e no registrador ímpar seguinte a ele (número binário com 64 bits) será o dividendo.O número binário contido no registrador especificado no 2º operando será o divisor.Após a divisão, o registrador ímpar receberá o quociente. Resto ou quociente = 0 : sinal sempre positivoSinal do resto = Sinal do dividendoEx: L 12,=F'2' Divisor: Registrador 12 com número 2 L 4,=F'0' Dividendo: Registradores 4-5 juntos; L 5,=F'257' Eles tem o número 257 DR 4,12 Quociente: Registrador 5 = 128; Resto: Registrador 4 = 1* L 9,=F'12' Divisor: Registrador 9 com número 12 L 6,=F'0' Dividendo: Registradores 6-7 juntos; L 7,=F'148' Eles tem o número 148 DR 6,9 Quociente: Registrador 7 = 12; Resto: Registrador 6 = 4

Sumario Instr.Máq.


Instruções de máquina - ED

ED (Edit - Editar)Código de máquina DE (Instrução SS – L)

Condition code 00 Último Campo = 001 Último Campo < 010 Último Campo > 011 O condition code nunca fica em 11 após o ED


O seu formato é o seguinte: [símbolo] ED camporeceptor,campoemissor O campo emissor (segundo operando) é transformado de compactado para zonado, e colocado no campo receptor (primeiro operando), substituindo, assim, o modelo da edição (que estava no primeiro operando).A edição inclui controle de sinal e pontuação, e a supressão e proteção de zeros não significativos.Pode-se editar diversos campos numa só operação.O tamanho especificado refere-se apenas ao 1º operando.O 2º operando deve estar no formato compactado. Se algum byte do 2º operando tiver em sua parte de zona configuração A, B, C, D , E ou F, então haverá interrupção de programa (0007).A edição é feita da esquerda para a direita.

Sumario Instr.Máq.






Durante a edição, cada caracter do campo receptor (modelo), pode ter um dos três destinos:Não é modificadoÉ substituído por um algarismo do campo emissor, transformado para zonado.É substituído pelo primeiro caracter à esquerda do campo receptor (denominado CARACTER DE PREENCHIMENTO). Qual das 3 ações acima é executada, é determinado pelo conteúdo do modelo e se o algarismo a ser editado é zero ou não.

Veja a seguir como é formado o modelo de edição.

Sumario Instr.Máq.






O seu 1º Byte à esquerda é o caracter de preenchimento; se for X'20' ou X'21', a ação correspondente é tomada após ele ter sido assinalado como caracter de preenchimento.Cada um dos bytes seguintes pode ter um dos seguintes conteúdos:Seletor de dígitos (X'20') ou Início de significância (X'21') ou Separador de campos (X'22') ou Qualquer outroQuando, na edição, é detectado um X'20' ou X'21' no 1º operando, a instrução verifica duas coisas:O Indicador de significância (é um indicador da UCP que pode estar ligado [ON] ou desligado [OFF]), denominado S-TRIGGER.O algarismo correspondente no 2º operando. Como resultado dessa verificação, o caracter do modelo será substituído pelo algarismo do 2º operando transformado para zonado (se no byte do 1o operando tiver X'20' ou X'21'), ou pelo caracter de preenchimento (se não tiver nem X'20' nem X'21').

Sumario Instr.Máq.






Quanto ao S-TRIGGER: Ele é colocado OFF no início da edição, após ser encontrado um X'22', ou após ser encontrado na parte numérica de um byte do 2º operando uma configuração A, C, E ou F (número positivo). Ele é colocado ON após ser encontrado um X'21' ou quando é encontrado um X'20' cujo algarismo correspondente no 2º operando não seja 0; ainda nestes dois casos, o S-TRIGGER só é colocado ON se o byte do 2º operando não tiver nem A, nem C, nem E, e nem F, na sua parte numérica. Quanto ao separador de campos (X'22'): identifica campos numa edição de vários campos. Ele é sempre substituído pelo caracter de preenchimento.

Exemplos:

Sumario Instr.Máq.






Observe que o b minúsculo indica espaço em branco. MVC ARIMP+5(10),MODELO ED ARIMP+5(10),TOTAL ... MODELO DC X'4020204B2021206B2020' Antes: TOTAL 00.12.34.5C ARIMP+5(10) 40.20.20.4B.20.21.20.6B.20.20 b b b b 1 2 3 , 4 5 Depois: TOTAL 00.12.34.5C ARIMP+5(10) 40.40.40.40.F1.F2.F3.6B.F4.F5 b b b b 1 2 3 , 4 5 Outros Exemplos do ED: ED 0(5,7),CPO ED ARIMP+17(8),ISDRT ED 4(12,9),2(10)

Sumario Instr.Máq.


Instruções de máquina - EDMK

EDMK (Edit and Mark – Editar e marcar)Código de máquina DF (Instrução SS – L)

Condition code 00 Último Campo = 001 Último Campo < 010 Último Campo > 011 O condition code nunca fica em 11 após o EDMK


A instrução EDMK é análoga a instrução ED, com a diferença de que ela coloca no registrador 1 (nos bits 8 a 31; os bits 0 a 7 permanecem inalterados) o endereço do byte do 1º operando que recebeu o primeiro algarismo significativo.OBS:- O endereço não é colocado quando a significância foi forçada (via X'21').Ex: EDMK ARIMP+5(10),TOTAL

Sumario Instr.Máq.


Instruções de máquina - EX

EX (Execute)Código de máquina 44 (Instrução RX)

Condition code o seu posicionamento (ou não) depende da instrução que for executada


A instrução especificada no 2º operando é modificada (temporariamente) de acordo com o conteúdo do registrador especificado no 1º operando, e executada.O segundo byte da instrução especificada sofre um OR de acordo com o conteúdo do último byte à direita do registrador 1º operando; em seguida, a instrução é executada.IMPORTANTE: 1) nenhum dos 2 operandos é alterado, pois o OR é feito internamente, na UCP. 2) se o registrador 1º operando for o registrador 0, o OR não será feito.Ex: L 5,=F'22' EX 5,MVC . . . MVC MVC 0,(0,12),=CL256' '

O move será executado com tamanho 23

Sumario Instr.Máq.


Instruções de máquina - IC

IC (Insert Character – Inserir caracter)Código de máquina 43 (Instrução RX)



O conteúdo do campo de um byte especificado no 2º operando é colocado no último byte à direita do registrador especificado no 1º operando.Os outros 3 bytes do registrador permanecem inalterados. Exemplos:Supor os operandos com tamanho e conteúdo conforme mostrado na linha “antes” 1o operando antes 2o operando antes 1o operando depois 2o operando depois IC 4,BYTE 00.00.45.67.8C 6B 00.00.45.67.6B 6B IC 8,=C'K' 00.00.00.11.1C D2 00.00.00.11.D2 D2 IC 11,=HL1'125' 00.00.00.00.00.12.7C 7D 00.00.00.00.02.5C.2C 7D

Sumario Instr.Máq.


Instruções de máquina - ICM

ICM (Insert Character under Mask – Inserir caracter sob máscara)Código de máquina BF (Instrução RS)

Condition code 00 Todos os bits inseridos estão em 0, ou a máscara é 0.01 O 1º bit do campo inserido está em 1.10 O 1º bit do campo inserido está em 0, e nem todos os bits inseridos estão em 0. 11 Nunca o condition code fica em 11 após um ICM.Interrupções Possíveis 0005

O seu formato de máquina é o seguinte: CO (código de operação) = 1 byte; R1 (registrador 1.o operando) = 1/2 byte; E2 (endereço base+deslocamento do 2o. operando) = 2 bytes; M3 (máscara terceiro operando) = 1/2 byte Os 4 bits da máscara, da esquerda para a direita, correspondem aos 4 bytes do registrador 1º operando.O campo de memória especificado no último operando da instrução (2º operando), deve ter tantos bytes quantos forem os bits da máscara ligados. Os bytes do campo de memória são movidos, um a um, da esquerda para a direita, para os bytes do registrador 1º operando que tiverem os bits correspondentes na máscara ligados. Os bytes do registrador 1º operando que tiverem os bits correspondentes na máscara desligados, permanecem inalterados. Ex:Supor os operandos com tamanho e conteúdo conforme mostrado na linha “antes” 1o operando antes 2o operando antes 1o operando depois 2o operando depois ICM 5,B'1010',TWOBYTES 00.00.45.67 9A.BC 9A.00.BC.67 9A.BC Neste caso, o 1º byte de TWOBYTES será movido para o 1º byte do registrador 5, e o 2º byte de TWOBYTES será movido para o 3º byte do registrador 5.

Sumario Instr.Máq.


Instruções de máquina - IPM

IPM (Insert Program Mask – Inserir máscara de programa)Código de máquina B222 (Instrução RRE)



Os bits 16-23 (terceiro byte) e 28-31 (segunda metade do quarto byte) da instrução são ignorados.O condition code e a máscara de programa da PSW atual são colocados nos bits 2-3 )condition code) e 4-7 (máscara de programa) do registrador primeiro (e único) operando; Os bits 0-1 do registrador são zerados e os bits 8-31 não são alterados. Exemplo:

Supor a PSW com condition code ’01’ e program mask ‘1100’ registrador 8 antes registrador 8 depois IPM 8 C4.56.78.9A 1C.56.78.9A

Sumario Instr.Máq.


Instruções de máquina - L

L (Load - Carregar)Código de máquina 58 (Instrução RX)



O conteúdo do campo de memória de 4 bytes especificado no 2º operando (em geral uma fullword) será colocado no registrador especificado no 1º operando. O campo de memória permanece inalterado. Ex:Supor os operandos com tamanho e conteúdo conforme mostrado na linha “antes” 1o operando antes 2o operando antes 1o operando depois 2o operando depois L 7,FULL FE.DC.BA.98 00.01.00.00 00.01.00.00 00.01.00.00 L 14,SALVA 00.00.00.11 FF.FF.FF.FD FF.FF.FF.FD FF.FF.FF.FD L 11,=F'125' 00.00.00.00 00.00.00.7D 00.00.00.7D 00.00.00.7D Outros exemplos: L 8,0(10) L 8,0(,11) L 8,0(10,11) L 5,=F'200'

Sumario Instr.Máq.


Instruções de máquina - LA

LA (Load Address – Carregar endereço)Código de máquina 41 (Instrução RX)



Esta instrução calcula o endereço real do 2º operando especificado (um endereço qualquer de memória), e o coloca nos 3 últimos bytes à direita do registrador, especificado no 1º operando). No primeiro byte à esquerda do registrador são colocados zeros binários. Ex:Supor os registradores com os valores mostrados abaixo (para referências a símbolos supõe-se o registrador 3 como registrador base,e os deslocamentos são apenas para efeito de exemplo) registrador 1o operando antes instrução máquina registrador 3 antes registrador 9 antes registrador 1o operando depois registrador 3 depois registrador 9 depois LA 5,TABLE 01.12.34.56 41.50.3A.C2 00.0B.88.40 nao usado 00.0B.93.02 00.0B.88.40 nao usado LA 5,FLD+17 01.12.34.56 41.50.3F.03 00.A0.00.00 nao usado 00.A0.0F.03 00.A0.00.00 nao usado LA 5,FLD+17(9) 01.12.34.56 41.59.3F.03 00.A0.00.00 00.00.00.14 00.A0.0F.17 00.A0.00.00 00.00.00.14 LA 5,2(9,3) 01.12.34.56 41.59.30.02 00.A0.00.00 00.00.00.14 00.A0.00.16 00.A0.00.00 00.00.00.14 LA 5,200 01.23.45.67 41.50.00.C8 nao usado nao usado 00.00.00.C8 nao usado nao usado

Sumario Instr.Máq.


Instruções de máquina - LA

LA (Load Address – Carregar endereço)Código de máquina 41 (Instrução RX)



Esta instrução calcula o endereço do 2º operando e o carrega nos últimos 3 bytes à direita do registrador 1º operando. O byte mais à esquerda do registrador 1º operando é zerado. Exemplo:

Supor os registradores com os valores mostrados abaixo (para referências a símbolos supõe-se o registrador 3 como registrador base,e os deslocamentos são apenas para efeito de exemplo) registrador 1o operando antes instrução máquina registrador 3 antes registrador 9 antes registrador 1o operando depois registrador 3 depois registrador 9 depois LA 5,4095 01.23.45.67 41.50.0F.FF não usado não usado 00.00.0F.FF não usado não usado LA 5,4095(3) 01.23.45.67 41.53.0F.FF 00.0A.80.00 não usado 00.0A.8F.FF 00.0A.80.00 não usado LA 5,4095(3,9) 01.23.45.67 41.53.9F.FF 00.0A.00.00 00.00.00.01 00.0A.10.00 00.0A.80.00 00.00.00.01

Sumario Instr.Máq.


Instruções de máquina - LCR

LCR (Load Complement Register – Carregar complemento de registrador)Código de máquina 13 (Instrução RR)



O número binário contido no registrador especificado no 2º operando é complementado e colocado no 1o operando.Se for positivo fica negativo e se for negativo fica positivo.O overflow ocorre quando o maior número negativo é complementado. Ex:Supor os operandos com tamanho e conteúdo conforme mostrado na linha “antes” 1o operando antes 2o operando antes 1o operando depois 2o operando depois LCR 4,5 00.00.00.00 FF.FF.FF.FC 00.00.00.04 FF.FF.FF.FC LCR 4,4 00.00.00.02 00.00.00.02 FF.FF.FF.FE 00.00.00.02

Sumario Instr.Máq.


Instruções de máquina - LH

LH (Load Halfword)Código de máquina 48 (Instrução RX)



O conteúdo do campo de 2 bytes especificados no 2º operando (em geral uma halfword) será colocado nos 2 últimos bytes à direita do registrador especificado no 1º operando; os 2 bytes à esquerda do registrador terão os seus bits posicionados do mesmo modo que estiver o 1º bit à esquerda do campo, o qual permanece inalterado. Ex:Supor os operandos com tamanho e conteúdo conforme mostrado na linha “antes” 1o operando antes 2o operando antes 1o operando depois 2o operando depois LH 5,FLD 00.00.00.00 8A.B4 FF.FF.8A.B4 8A.B4 LH 8,HWORD FF.FF.FF.FF 7A.B4 00.00.7A.B4 7A.B4 Mais exemplos: LH 7,HALF LH 8,0(10) LH 8,0(,11) LH 8,0(10,11) LH 8,=H'200'

Sumario Instr.Máq.


Instruções de máquina - LM

LM (Load Multiple – Carregar múltiplos [registradores])

Esta instrução trabalha com 3 operandos: os 2 primeiros especificados são registradores e o terceiro é um endereço de memória.A instrução LM coloca o conteúdo do campo de memória de (n.4) bytes especificado no último operando no conjunto de n registradores (indicados pela faixa indicada pelos registradores especificados 1o. e 2o. operandos). Ex: LM 14,1,SALVA

Reg. 14 Reg.15 Reg.0 Reg.1<----------><---------><----------><----------> |------- SALVA --------------------------------|SALVA = 16 bytes (bytes 0 a 3 = conteúdo vai para reg 14; bytes 4 a 7 = conteúdo vai para reg 15; bytes 8 a 11 = conteúdo vai para reg 0; bytes 12 a 15 = conteúdo vai para reg 1) Outro Exemplo: LM 1,7,2(10)




Sumario Instr.Máq.


Instruções de máquina - LNR

LNR (Load Negative Register – Carregar registrador [com] negativo)Código de máquina 11 (Instrução RR)

Condition code 00 Resultado = 001 Resultado < 010 Nunca o condition code fica em 10 após um LNR11 Nunca o condition code fica em 10 após um LNR


O número binário contido no registrador especificado no 2º operando é transformado para negativo (por complementação) e colocado no registrador especificado no 1º operando.Números negativos não são transformados.O zero permanece inalterado com sinal positivo. Ex: Supor os operandos com tamanho e conteúdo conforme mostrado na linha “antes” 1o operando antes 2o operando antes 1o operando depois 2o operando depois LNR 4,5 00.00.00.00 FF.FF.FF.FC FF.FF.FF.FE FF.FF.FF.FC LNR 4,5 00.00.00.02 00.00.00.02 FF.FF.FF.FE 00.00.00.02 LNR 4,8 00.00.00.02 00.00.00.00 00.00.00.00 00.00.00.00

Sumario Instr.Máq.


Instruções de máquina - LPR

LPR (Load Positive Register – Carregar registrador [com] positivo)Código de máquina 10 (Instrução RR)

Condition code 00 Resultado = 001 Nunca o condition code fica em 1 após um LPR.10 Resultado > 011 Overflow


O número binário contido no registrador especificado no 2º operando é transformado para positivo e colocado no registrador especificado no 1º operando.Números positivos não sofrem transformação. Números negativos são transformados por complementação. O overflow ocorre quando o maior número negativo é complementado; neste caso, o número permanece inalterado. Ex:Supor os operandos com tamanho e conteúdo conforme mostrado na linha “antes” 1o operando antes 2o operando antes 1o operando depois 2o operando depois LPR 4,5 00.00.00.00 FF.FF.FF.FC 00.00.00.04 FF.FF.FF.FC LPR 4,5 00.00.00.02 00.00.00.02 00.00.00.02 00.00.00.02 LPR 4,8 00.00.00.FF 00.00.00.00 00.00.00.00 00.00.00.00

Sumario Instr.Máq.


Instruções de máquina - LR

LR (Load Register – Carregar registrador)Código de máquina 18 (Instrução RR)



O conteúdo do registrador especificado no 2º operando é colocado no registrador especificado no 1º operando. Ex:

Supor os operandos com tamanho e conteúdo conforme mostrado na linha “antes” 1o operando antes 2o operando antes 1o operando depois 2o operando depois LR 4,5 00.00.00.00 FF.FF.FF.FC FF.FF.FF.FC FF.FF.FF.FC LR 4,5 00.00.12.34 00.00.00.02 00.00.00.02 00.00.00.02 LR 4,8 00.00.00.02 00.00.00.00 00.00.00.00 00.00.00.00

Sumario Instr.Máq.


Instruções de máquina - LTR

LTR (Load and Test Register – Carregar e testar registrador)Código de máquina 12 (Instrução RR)

Condition code 00 Resultado = 001 Resultado < 010 Resultado > 011 Nunca o condition code fica em 10 após um LTR


O conteúdo do registrador especificado no 2º operando é colocado no registrador especificado no 1º operando. Ex:Supor os operandos com tamanho e conteúdo conforme mostrado na linha “antes” 1o operando antes 2o operando antes 1o operando depois 2o operando depois LTR 4,5 00.00.00.00 FF.FF.FF.FC FF.FF.FF.FC FF.FF.FF.FC LTR 4,5 00.00.12.34 00.00.00.02 00.00.00.02 00.00.00.02 LTR 4,8 00.00.00.02 00.00.00.00 00.00.00.00 00.00.00.00

Sumario Instr.Máq.


Instruções de máquina - M

M (Multiply - Multiplicar)Código de máquina 5C (Instrução RX)



Esta instrução efetua uma multiplicação entre dois números binários.O registrador especificado no 1º operando deve ser par. O registrador ímpar seguinte deve conter o Multiplicando. O campo de memória de 4 bytes especificado no 2º operando (em geral uma fullword) deve conter o Multiplicador. O resultado é um número binário de 64 bits que é colocado no conjunto de registradores par-ímpar indicado pelo 1º operando. Exemplo: Registrador 6 antes Registrador 7 antes 2o operando antes Registrador 6 depois Registrador 7 depois 2o operando depois M 6,FLDA [ Multiplicando: Reg 7; Multiplicador: FLDA; Resultado: Regs 6 e 7 juntos ] 00.00.00.00 00.00.00.0A 00.00.00.02 00.00.00.00 00.00.00.14 00.00.00.02 M 6,=F'256' Multiplicando: Reg 7; Multiplicador: 256; Resultado: Regs 6 e 7 juntos 00.00.00.00 00.00.04.00 00.00.00.FF 00.00.00.00 00.03.FC.00 00.00.00.FF M 6,4(2,8) Multiplicando: Reg 7; Endereço multiplicador: Indexador 2 + Base 8 + X’4’;

Resultado: Registradores 6 e 7 juntos 00.00.00.00 00.00.04.00 00.00.01.0A 00.00.00.00 00.04.28.00 00.00.01.0A

Sumario Instr.Máq.


Instruções de máquina - M

M (Multiply - Multiplicar)Código de máquina 5C (Instrução RX)



Mais exemplos:

Registrador 6 antes Registrador 7 antes 2o operando antes Registrador 6 depois Registrador 7 depois 2o operando depois M 6,4(2) Multiplicando: Reg 7; Endereço multiplicador: Indexador 2 [ + Base 0 ] + X’4’;

Resultado: Registradores 6 e 7 juntos 00.00.00.00 00.00.00.0C 00.00.00.02 00.00.00.00 00.00.00.18 00.00.00.02 M 6,FLD+4(1) Multiplicando: Reg 7; Endereço multiplicador: Indexador 1 + Base de FLD+4

+ Deslocamento de FLD+4 + X’4’; Resultado: Registradores 6 e 7 juntos 00.00.00.00 00.00.AA.AA 00.11.22.33 00.00.00.0B 6C.16.93.DE 00.11.22.33

Sumario Instr.Máq.


Instruções de máquina - MC

MC (Monitor Call – Chamada ao monitor)Código de máquina AF (Instrução SI)

Condition code Permanece inalterado


Esta instrução causa uma interrupção de programa, se o bit que mascara esta situação no registrador de controle 8 estiver ligado.Os bits de máscara no registrador de controle 8 são os bits 16 a 31, e que correspondem às classes 0 a 15, respectivamente.No operando imediato, os 4 primeiros bits à esquerda (bits 8 a 11 da instrução) devem estar em zero. Os bits 12 a 15 (a metade da direita do segundo byte da instrução) especificam um número binário que indica qual a classe de interrupção desejada; se o bit a ela referente no registrador de controle 8 estiver ligado, será causada a interrupção.O endereço do segundo operando não faz referência a um campo de memória, e sim indicam um código que deve ser colocado na fullword de endereço X'000156' de memória.Se a máscara referente à interrupção desejada estiver desligada no registrador de controle 8, a instrução funciona como um NOP. Exemplo: MC MONITCOD,7

Sumario Instr.Máq.


Instruções de máquina - MH

MH (Multiply Halfword – Multiplicar halfword)Código de máquina 4C (Instrução RX)



Esta instrução efetua uma multiplicação algébrica entre dois números binários.Um deles esta localizado no registrador especificado no 1º operando, e o outro num campo de memória de 2 bytes especificado no 2º operando (em geral uma halfword). Antes de efetuada a multiplicação pela UCP, o 2º operando é expandido na UCP para que fique com 32 bits (o bit de sinal é expandido a esquerda); aí então é feita a multiplicação. O Resultado é colocado no registrador 1º operando.OBS:- em caso de overflow (condição esta que não é indicada pelo condition code) o bit de sinal do produto pode não estar correto. Produto = 0, sinal positivo. Exemplos: Registrador 1o operando antes 2o operando antes Registrador 1o operando depois 2o operando depois MH 5,=H'4' Multiplicando: Registrador 5; Multiplicador: literal 4; Resultado: Registrador 5 00.00.00.0A 00.04 00.00.00.28 00.04 MH 5,=F'2' Multiplicando: Registrador 5; Multiplicador: 0 [ primeiros 2 bytes à esquerda da fullword são pegos como a halfword 2o operando; como a fullword tem X’00000002’, pega X’0000’ ]; Resultado: Registrador 5 00.00.04.00 00.00 [CUIDADO! metade da direita com 00.02 não é pega! ] 00.00.00.00 00.00

Sumario Instr.Máq.


Instruções de máquina - MP

MP (Multiply Packed – Multiplicar compactado)Código de máquina FC (Instrução SS – L1 e L2)


Interrupções Possíveis 0001,0004,0005,0006,0007

A instrução MP efetua a multiplicação entre dois campos de memória que estejam no formato compactado.O resultado da multiplicação é colocado no campo especificado no 1º operando.O 2º operando pode ter tamanho máximo de 8 bytes.O tamanho do 2º operando deve obrigatoriamente ser menor que o tamanho do 1º operando.Se o tamanho do 2º operando for maior que 8 ou for menor ou igual ao tamanho do 1º operando, haverá interrupções de programa (código 0006).O 1º operando deve ter tantos algarismos em zero (à esquerda) quantos forem os algarismos do 2º operando; se isto não acontecer, haverá interrupção de programa (código 0007). Ex: MP CPOA,CPOB 1o operando antes 2o operando antes 1o operando depois 2o operando depois 00.09.99.9C 99.9C 99.89.00.1C 99.9C

00.19.99.9C 99.9C 00.19.99.9C 99.9C (erro! Precisaria ter 3 dígitos em zero à esquerda em CPOA)

Sumario Instr.Máq.


Instruções de máquina – MR

MR (Multiply Register – Multiplicar registradores)Código de máquina 1C (Instrução RR)



O 1º operando especificado deve ser um registrador par (o número binário nele contido será desprezado, a menos que ele seja o multiplicador).O número binário contido no registrador especificado no 2º operando será o multiplicador. O produto será colocado no conjunto de 2 registradores (par-ímpar) indicado pelo 1º operando: o registrador par será ele mesmo, e o ímpar será o seguinte a ele.O multiplicando será o número binário do registrador ímpar do conjunto par-ímpar indicado pelo 1º operando. Exemplo: Registrador 6 antes Registrador 7 antes Registrador 9 antes Registrador 6 depois Registrador 7 depois Registrador 9 depois MR 6,9 [ Multiplicando: Registrador 7; Multiplicador: reg. 9; Resultado: regs. 6 e 7 juntos ] 00.00.00.00 00.00.00.0A 00.00.00.02 00.00.00.00 00.00.00.14 00.00.00.02 MR 6,9 [ Multiplicando: Registrador 7; Multiplicador: reg. 9; Resultado: regs. 6 e 7 juntos ] 00.00.00.00 99.AA.BB.CC 00.FF.FF.FF 00.99.AA.BB 32.55.44.34 00.FF.FF.FF

Sumario Instr.Máq.


Instruções de máquina - MVC

MVC (MoVe Character)Código de máquina D2 (Instrução SS - L)



A instrução MVC move um campo de memória para outro campo de memória, byte a byte, da esquerda para a direita. Ex: MVC CPOA,CPOB antes depoisCPOB C1.C2.C3 C1.C2.C3CPOA C4.C5.C6 C1.C2.C3O campo emissor é o segundo operando e permanece inalterado (a não ser que parte dele seja ao mesmo tempo o campo receptor – ovelapping = sobreposição). O campo receptor é o primeiro operando. Ambos devem ter o mesmo tamanho. Exemplos: Supor os operandos com tamanho e conteúdo conforme exibidos na linha “antes” 1o operando antes 2o operando antes 1o operando depois 2o operando depois MVC WA+5(3),WR+2 40.40.40 E5.C1.D3 E5.C1.D3 E5.C1.D3 MVC WOUT,WIN 00.00.00.00.00 00.00.00.00.1C 00.00.00.00.1C 00.00.00.00.1C MVC NICKNAM,=C'SMAIL' C3.D9.E8.40.40 E2.D4.C1.C9.D3 E2.D4.C1.C9.D3 E2.D4.C1.C9.D3

Sumario Instr.Máq.






Sumario Instr.Máq.

Mais exemplos:

Mover espaços usando área auxiliar de 5 bytes (literal com 5 bytes):Supor os operandos com tamanho e conteúdo como exibidos na linha “antes” 1o operando antes 2o operando antes 1o operando depois 2o operando depois MVC WA(5),=CL5' ' 5C.5C.5C.5C.5C 40.40.40.40.40 40.40.40.40.40 40.40.40.40.40

Alternativamente, pode-se propagando espaços usando área auxiliar de somente 1 byte (a literal) ! - O primeiro MVC move espaço para a primeira posição à esquerda do campo WA.- O outro MVC move 4 bytes; lembrar que o MVC opera byte a byte.- Acompanhe os 4 bytes sendo movidos, um a um: O primeiro byte é movido para o segundo; O segundo byte é movido para o terceiro; O terceiro é movido para o quarto ; O quarto byte é movido para o quintoMVC inicial para o primeiro byte à esquerda: MVC WA(1),=C' ' 5C.??.??.??.?? 40 antes 40.??.??.??.?? 40 depois






Sumario Instr.Máq.

Propagação do 1o para o 2o, do 2o para o 3o, do 3o para o 4o e do 4o para o 5o MVC WA+1(4),WA Acompanhe o MVC byte a byte :

1o byte: 40.??.??.??.?? 40.??.??.??.?? 40.40.??.??.?? 40.40.??.??.??

2o byte: 40.40.??.??.?? 40.40.??.??.?? 40.40.40.??.?? 40.40.40.??.??

3o byte: 40.40.40.??.?? 40.40.40.??.?? 40.40.40.40.?? 40.40.40.40.??

4o byte: 40.40.40.40.?? 40.40.40.40.?? 40.40.40.40.40 40.40.40.40.40

Ou, melhor ainda:

1o byte: 40.??.??.??.?? Antes

40.40.??.??.?? Depois

2o byte: 40.40.??.??.?? Antes

40.40.40.??.?? Depois

3o byte: 40.40.40.??.?? Antes

40.40.40.40.?? Depois

4o byte: 40.40.40.40.?? Antes

40.40.40.40.40 Depois


Instruções de máquina - MVCIN

MVCIN (MoVe Character Inverted – Mover [invertido] caracter)Código de máquina E8 (Instrução SS – L)



Esta instrução move o conteúdo do 2º operando (campo emissor) para o 1º operando (campo receptor), invertendo a sequência.Observar que o endereço especificado do 1º operando é o do seu byte mais à esquerda, enquanto o endereço do segundo operando é o do seu byte mais à direita.O movimento é feito byte a byte; para o emissor, é da direita para a esquerda, e para o receptor é da esquerda para a direita.Se houver sobreposição de mais de um byte entre emissor e receptor, os resultados são imprevisíveis. Exemplo:Supor os operandos com tamanho e conteúdo como mostrados na linha “antes” 1o operando antes 2o operando antes 1o operando depois 2o operando depois MVCIN A(3),B+2 C4.C5.C6 C1.C2.C3 C3.C2.C1 C1.C2.C3 MVCIN A(5),BETA C4.C5.C6.C7.C8 C1.C2.C3.C4.C5 C5.C4.C3.C2.C1 C1.C2.C3.C4.C5

Sumario Instr.Máq.


Instruções de máquina - MVCL

MVCL (MoVe Character Long – Mover [longo] caracter)Código de máquina 0E (Instrução RR)

Condition code 00 Tamanhos do 1. e 2º operandos são iguais 01 Tamanho do 1º operando é menor10 Tamanho do 1º operando é maior11 Movimento não efetuado


Tanto o 1º como o 2º operandos especificados devem ser registradores pares, os quais indicam (cada um deles) conjuntos de registradores par-ímpar, os quais chamaremos de R1 e R1+1 e R2 e R2+1.Esta instrução movimenta um campo de memória para outro campo de memória, byte a byte, da esquerda para a direita.O endereço do campo receptor deve estar nos 3 últimos bytes à direita de R1.O endereço do campo emissor deve estar nos 3 últimos bytes à direita de R2.O tamanho (número de bytes) do campo receptor deve estar nos 3 últimos bytes à direita de R1+1.O tamanho (número de bytes) do campo emissor deve estar nos 3 últimos bytes à direita de R2+1.O 1. byte à esquerda de R2+1 deve conter o caracter de preenchimento.O conteúdo do 1. byte à esquerda de R1, R2 e R1+1 é desprezado.Ex: MVCL 2,8Ver detalhes no próximo slide.

Sumario Instr.Máq.






L 2,=A(RECEIVE) L 3,=A(L’RECEIVE) L 8,=A(SENDING) L 9,=A(L’SENDING) ICM 9,B'1000',=C'*' MVCL 2,8 Se o campo emissor ultrapassar ou não do byte 16.777.215 para o byte 0, o movimento é efetuado da seguinte forma:· quando não ultrapassar, o movimento é executado quando o byte mais à esquerda do campo receptor coincide ou está à esquerda do byte mais à esquerda do campo emissor, ou se o byte mais à esquerda do campo receptor está à direita do byte (que participa da operação) mais à direita do campo emissor.· quando ultrapassar, o movimento é executado quando o byte mais à esquerda do campo receptor coincide ou está à esquerda do byte mais à esquerda do campo emissor, e se o byte mais à esquerda do campo receptor está à direita do byte (que participa da operação) mais à direita do campo emissor.O endereço do byte mais à direita do campo receptor é calculado usando o tamanho do campo receptor ou do emissor (o menor).

Sumario Instr.Máq.






Após efetuado o movimento, temos que:- Os 3 últimos bytes à direita de R1+1 (tamanho do campo receptor) ficam com zero.- Aos 3 últimos bytes à direita de R1 (endereço do campo receptor) é somado o tamanho originalmente especificado em R1+1.- Dos 3 últimos bytes à direita de R2+1 (tamanho do campo emissor) é subtraido o número de bytes movidos do campo emissor para o receptor.- Aos 3 últimos bytes à direita de R2 (endereço do campo emissor) é somado o número de bytes movidos do campo emissor para o receptor.- O byte mais à esquerda, tanto de R1 quanto de R2, fica com 0, mesmo quando o movimento não é efetuado.- O byte mais à esquerda, tanto de R1+1 quanto de R2+1, não é alterado.

Sumario Instr.Máq.


Instruções de máquina - MVI

MVI (MoVe Immediate – Mover [operando] imediato)Código de máquina 92 (Instrução SI)

Condition code não é alterado


A instrução MVI movimenta um byte de memória (o 2. byte da instrução - o operando imediato) para outro byte de memória. O 2º operando é o campo emissor (operando imediato) e o 1º operando é o campo receptor.O operando imediato pode ser especificado somente através de um termo auto-definido. Ex:

MVI CPOA,C'*' ou MVI CPOA,X'5C' ou MVI CPOA,B'01011100' ou MVI CPOA,92 CPOA antes Operando imediato antes CPOA depois Operando imediato depois 12 5C 5C 5COutros exemplos: MVI WAREA+72,C'/' MVI 0(4),X'80'

Sumario Instr.Máq.


Instruções de máquina - MVN

MVN (MoVe Numerics – Mover [partes] numéricas)Código de máquina D1 (Instrução SS - L)



A instrução MVN é análoga à MVC, com a diferença de que ela move somente a parte numérica dos bytes. Ex:Supor os operandos com tamanho e conteúdo como exibidos na linha “antes” 1o operando antes 2o operando antes 1o operando depois 2o operando depois MVN FLDA,FLB 12.34.56 78.9A.BC 18.3A.5C 78.9A.BC MVN TOT+4(1),=X'0C' 00.12.30.00.2F 0C 00.12.30.00.2C 0C

Sumario Instr.Máq.


Instruções de máquina - MVO

MVO (MoVe with Offset Mover com deslocamento)Código de máquina F1 (Instrução SS – L1 e L2)



A instrução MVO move o campo especificado no 2ºoperando para o campo especificado no 1º operando da direita para a esquerda, da seguinte forma:A parte numérica do último byte à direita do 1º operando permanece inalterada. A parte numérica do último byte à direita do 2º operando é colocada na parte de zona do último byte à direita do 1º operando; e assim por diante.Se o 1º operando (campo receptor) não for suficientemente grande para receber todo o 2º operando (campo emissor) os meios-bytes à esquerda serão truncados.Se o 1º operando for maior que o suficiente para conter o 2º operando, a instrução preencherá com 0's à esquerda. Ex: MVO RECFLD,SENFLD

SENFLD Antes 00.00.12.00 SENFLD Depois 00.00.12.00

RECFLD Antes 00.00.00.0C RECFLD Depois 00.01.20.0C

Sumario Instr.Máq.


Instruções de máquina - MVO

MVO (MoVe with Offset Mover com deslocamento)Código de máquina F1 (Instrução SS – L1 e L2)



MVO CPOA,CPOB Antes Depois 1º Caso CPOB 12.34.56 12.34.56 CPOA 78.9A 45.6A2º Caso CPOB AB.72 AB.72 CPOA 4A.5C.B9.FC 00.0A.B7.2C Outros exemplos: MVO ARCALC(5),ARCALC(4) MVO 0(4,7),ARCALC MVO AREA,2(5,8) MVO 2(7,13),19(5,15)

Sumario Instr.Máq.


Instruções de máquina - MVZ

MVZ (MoVe Zones – Mover [partes] de zona)Código de máquina D3 (Instrução SS – L)



A instrução MVZ é análoga à MVC, com a diferença de que ela move somente a parte de zona dos bytes. Ex:Supor os operandos com tamanho e conteúdo como exibidos na linha “antes” 1o operando antes 2o operando antes 1o operando depois 2o operando depois MVZ FLDA,FLB 12.34.56 78.9A.BC 72.94.B6 78.9A.BC MVZ TOT,=4C'0' 01.02.03.04.C5 F0.F0.F0.F0.F0 F1.F2.F3.F4.F5 F0.F0.F0.F0.F0

Sumario Instr.Máq.


Instruções de máquina - N

N (aNd – E booleano)Código de máquina 54 (Instrução RX)

Condition code 00 Resultado = 001 Resultado <> 010 O condition code nunca fica em 10 após um N11 O condition code nunca fica em 11 após um N


A instrução N executa um AND entre um registrador (especificado no 1º operando) e um campo de memória de 4 bytes (especificado no 2º operando - em geral uma fullword). Bit da máscara = 0 então bit resultante = 0; Bit da máscara = 1 então bit resultante não é alteradoEx: N 13,CAMPOF Antes DepoisReg. 13 B4.EF.2F.A8 00.00.00.A8CAMPOF 00.00.00.FF 00.00.00.FFOutros exemplos: N 11,=F'15' N 3,0(4) N 3,0(,4) N 3,0(8,4)

Sumario Instr.Máq.


Instruções de máquina - NC

NC (aNd Character – E [booleano] em caracter)Código de máquina D4 (Instrução SS – L)

Condition code 00 Resultado = 001 Resultado <> 010 O condition code nunca fica em 10 após um NC11 O condition code nunca fica em 11 após um NC

Interrupções Possíveis 0004, 0005

A instrução NC executa um AND entre 2 campos de memória. Ex:Bit da máscara = 0 então bit resultante = 0; Bit da máscara = 1 então bit resultante não é alterado

Exemplo:

NC CPOA,CPOB antes depoisCPOA EF.2F.A8 00.00.A8CPOB 00.00.FF 00.00.FF

Sumario Instr.Máq.


Instruções de máquina - NI

NI (aNd Immediate – E [booleano] com operando imediato)Código de máquina 94 (Instrução SI)

Condition code 00 Resultado = 001 Resultado <> 010 O condition code nunca fica em 10 após um NI11 O condition code nunca fica em 11 após um NI


A instrução NI executa um AND entre 2 campos de memória (um byte cada). Ex:Bit da máscara = 0 então bit resultante = 0; Bit da máscara = 1 então bit resultante não é alteradoExemplo: NI BYTE,X'0F' antes depoisBYTE B4 04Op.Imed. 0F 0F

Sumario Instr.Máq.


Instruções de máquina - NR

NR (aNd Register – E [booleano] com registradores)Código de máquina 14 (Instrução RR)

Condition code 00 Resultado = 001 Resultado <> 010 O condition code nunca fica em 10 após um NR11 O condition code nunca fica em 11 após um NR


A instrução NR executa um AND entre 2 registradores. Bit da máscara = 0 então bit resultante = 0; Bit da máscara = 1 então bit resultante não é alteradoEx: NR 5,8 Antes Depois Reg. 5 B4.EF.2F.A8 00.00.00.A8Reg. 8 00.00.00.FF 00.00.00.FF

Sumario Instr.Máq.


Instruções de máquina - O

O ([boolean] Or – OU booleano)Código de máquina 56 (Instrução RX)

Condition code 00 Resultado = 001 Resultado <> 010 O condition code nunca fica em 10 após um O11 O condition code nunca fica em 11 após um O


A instrução O executa um OR entre um registrador (Especificado no 1º operando) e um campo de memória de 4 bytes (especificado no 2º operando - em geral uma fullword). Bit da máscara = 0 então bit resultante não é alterado ; Bit da máscara = 1 então bit resultante = 1Ex: O 13,CAMPOF

Antes Depois

Reg. 13 B4.EF.2F.A8 B4.EF.2F.FFCAMPOF 00.00.00.FF 00.00.00.FF

Sumario Instr.Máq.


Instruções de máquina - OC

OC (Or Character – OU booleano em caracter)Código de máquina D6 (Instrução SS – L)

Condition code 00 Resultado = 001 Resultado <> 010 O condition code nunca fica em 10 após um OC11 O condition code nunca fica em 11 após um OC


A instrução OC executa um OR entre 2 campos de memória. Bit da máscara = 0 então bit resultante não é alterado ; Bit da máscara = 1 então bit resultante = 1Ex: OC CPOA,CPOB Antes Depois CPOA EF.2F.A8 EF.2F.FFCPOB 00.00.FF 00.00.FF

Sumario Instr.Máq.


Instruções de máquina - OI

OI (Or Immediate – OU [booleano] com operando imediato)Código de máquina 96 (Instrução SI)

Condition code 00 Resultado = 001 Resultado <> 010 O condition code nunca fica em 10 após um OI11 O condition code nunca fica em 11 após um OI


A instrução OI executa um OR (operação booleana) entre 2 campos de memória (um byte cada). Bit da máscara = 0 então bit resultante não é alterado ; Bit da máscara = 1 então bit resultante = 1Ex: OI BYTE,X'0F' antes depois BYTE B4 BF Op.Imed. 0F 0F

Sumario Instr.Máq.


Instruções de máquina - OR

OR (Or Register – OU [booleano] com registradores)Código de máquina 16 (Instrução RR)

Condition code 00 Resultado = 001 Resultado <> 010 O condition code nunca fica em 10 após um OR11 O condition code nunca fica em 11 após um OR


A instrução OR executa um OR entre 2 registradores. Bit da máscara = 0 então bit resultante não é alterado ; Bit da máscara = 1 então bit resultante = 1Ex: OR 5,8 Antes Depois Reg. 5 B4.EF.2F.A8 B4.EF.2F.FFReg. 8 00.00.00.FF 00.00.00.FF

Sumario Instr.Máq.


Instruções de máquina - PACK

PACK (Compactar)Código de máquina F2 (Instrução SS – L1 e L2)



A instrução PACK movimenta um campo de memória para outro campo de memória, transformando-o de zonado para compactado.A movimentação é feita da direita para a esquerda, da seguinte forma (o 2º operando é o campo emissor e o 1º operando é o campo receptor):O byte mais à direita do campo emissor é invertido e colocado no byte mais à direita do campo receptor (Inverter = a sua parte de zona vira parte numérica, e a sua parte numérica vira parte de zona). Em seguida, cada parte numérica de cada byte do campo emissor é colocada num meio byte do campo receptor, desprezando-se as partes de zona do campo emissor.Se o receptor for maior que o necessário, ele será preenchido com zeros à esquerda.Se ele for menor que o necessário, os algarismos em excesso serão truncados.O 2º operando permanece inalterado.Exemplo: PACK CPOA,CPOB antes depois CPOB F1.F2.F3.F4 F1.F2.F3.F4 CPOA 00.B7.2A 01.23.4F

Sumario Instr.Máq.


Instruções de máquina - PACK

PACK (Compactar)Código de máquina F2 (Instrução SS – L1 e L2)



PACK CPOA,CPOB2ºcaso CPOB F1.F2.F3.F4 F1.F2.F3.F4 CPOA C9.4A 23.4F3ºcaso CPOB 9A.48.F9.DB 9A.48.F9.DB CPOA 19.B7.DF 0A.89.BDObservar, pelo 3º Caso, que o campo emissor não é testado quando ao fato de ele estar em zonado e, consequentemente, o campo receptor pode não ficar em compactado. Outros exemplos: PACK VALOR,ARLEIT+5(9) PACK QUANTO+2(7),2(8,5) PACK 0(10,2),AREA PACK 2(5,7),2(3,8) PACK DOUBLE,DOUBLE PACK BYTE,BYTE

Sumario Instr.Máq.


Instruções de máquina - S

S (Subtract – subtrair [conteúdo de fullword])Código de máquina 5B (Instrução RX)



Esta instrução efetua a subtração algébrica entre um número binário contido num registrador (especificado no 1º operando - é o Minuendo) e um número binário contido num campo de memória de 4 bytes (especificado no 2º operando; em geral uma fullword - é o Subtraendo). Exemplos:Supor os operandos com tamanho e conteúdo como exibidos na linha “antes” 1o operando antes 2o operando antes 1o operando depois 2o operando depois S 5,=F'259' 00.00.BF.D2 00.00.01.03 00.00.BE.CF 00.00.01.03 S 7,FULL 00.00.00.0D 00.00.01.03 FF.FF.FF.0A 00.00.01.03 S 7,4(2,8) 07.FF.FF.FE 00.00.00.01 07.FF.FF.FD 00.00.00.01 S 7,4(2) 07.FF.FF.FF 00.00.00.02 07.FF.FF.FD 00.00.00.02 S 7,4(,8) 00.00.00.00 FF.FF.FF.FF 00.00.00.01 FF.FF.FF.FF

Sumario Instr.Máq.


Instruções de máquina - SH

SH (Subtract Halfword – Subtrair [conteúdo de] halfword)Código de máquina 4B (Instrução RX)



Esta instrução efetua uma subtração algébrica entre dois números binários. Um deles está localizado no registrador especificado no 1º operando, e o outro num campo de memória de 2 bytes especificado no 2º operando (em geral uma halfword). O resultado é colocado no registrador 1º operando. Ex:Supor os operandos com tamanho e conteúdo como exibidos na linha “antes” 1o operando antes 2o operando antes 1o operando depois 2o operando depois SH 5,=H'259' 00.00.2B.C4 01.03 00.00.2A.C1 01.03 SH 5,HALF 00.00.00.0D 01.0D FF.FF.FF.00 01.0D SH 5,4(2,8) 11.11.11.11 (decimal 286331153) 88.88 (decimal –30584) 11.11.88.89 (decimal 286361737) 88.88 SH 5,4(2) 11.11.11.11 (decimal 286331153) 78.88 (decimal +30856) 11.10.98.89 (decimal 286300297) 78.88

Sumario Instr.Máq.


Instruções de máquina - SL

SL (Subtract Logical – Subtrair logicamente)Código de máquina 5F (Instrução RX)

Condition code 00 O condition code nunca fica em 00 após um SL01 Resultado <> 0, não perde sinal10 Resultado = 0, perde sinal11 Resultado <> 0, perde sinal


Esta instrução efetua uma subtração lógica entre dois números binários. Um deles localizado no registrador especificado no 1º operando. O outro, num campo de memória de 4 bytes especificado no 2º operando (em geral uma fullword). O resultado é colocado no registrador 1º operando. Ex:Supor os operandos com tamanho e conteúdo como exibidos na linha “antes” 1o operando antes 2o operando antes 1o operando depois 2o operando depois SL 5,=F'259' 00.00.BF.D2 00.00.01.03 00.00.BE.CF 00.00.01.03 SL 7,FULL 00.00.00.0D 00.00.00.03 00.00.00.0A 00.00.00.03 SL 7,4(2,8) 07.FF.FF.FE 00.00.00.01 07.FF.FF.FD 00.00.00.01 SL 7,4(2) 07.FF.FF.FF 00.00.00.02 07.FF.FF.FD 00.00.00.02

Sumario Instr.Máq.


Instruções de máquina - SLA

SLA (Shift Left Algebraic – Deslocamento algébrico à esquerda)Código de máquina 8B (Instrução RS)



É feito deslocamento de bits para a esquerda no conteúdo do registrador primeiro operando. São deslocados os bits 1 a 31 do registrador: todos menos o bit de sinal (o bit de sinal não é deslocado/alterado). Os bits à direita são criados com zero.É uma instrução RS, e os bits 12 a 15 dela são ignorados pela UCP.Os 6 bits mais à direita do número que é o endereço do 2º operando, formam um número que indica quantas "casas" devem ser deslocadas. Pode-se deslocar 15 "casas" no máximo. Ex: SLA 5,3Registrador 5 antes do Shift FF.80.9A.00Registrador 5 após o Shift FC.04.D0.00

Sumario Instr.Máq.


Instruções de máquina - SLDA

SLDA (Shift Left Double Algebraic – Deslocamento algébrico duplo à esquerda)Código de máquina 8F (Instrução RS)



É feito deslocamento de bits para a esquerda no conteúdo do par de registradores indicado registrador primeiro operando e pelo registrador seguinte a ele. São deslocados os 63 bits formados por: bits 1 a 31 do registrador primeiro operando juntamente com os bits 0 a 31 do registrador segundo operando (considera que o par de registradores tenha um número com 1 bit de sinal + 63 bits para o número). Os bits à direita são criados com zero.É uma instrução RS, e os bits 12 a 15 dela são ignorados pela UCP.Os 6 bits mais à direita do número que é o endereço do 2º operando, formam um número que indica quantas "casas" devem ser deslocadas. Pode-se deslocar 63 "casas" no máximo. Ex: SLA 8,3Registradores 8 e 9 antes do Shift 00.00.00.00 FF.80.9A.00Registradores 8 e 9 após o Shift 00.00.00.07 FC.04.D0.00

Sumario Instr.Máq.


Instruções de máquina - SLDL

SLDL (Shift Left Double Logical – Deslocamento lógico duplo à esquerda)Código de máquina 8D (Instrução RS)



É feito deslocamento de bits para a esquerda no conteúdo do par de registradores indicado pelo primeiro operando e pelo registrador seguinte ao primeiro operando. Todos os bits são deslocados para a esquerda (incluindo o bit de sinal).Os bits à direita são criados com zero.É uma instrução RS, e os bits 12 a 15 dela são ignorados pela UCP.Os 6 bits mais à direita do número que é o endereço do 2º operando, formam um número que indica quantas "casas" devem ser deslocadas.Pode-se deslocar 63 "casas" no máximo. Ex: SLDL 8,4Registradores 8 e 9 antes do Shift 12.FE.3D.4C 5B.6A.78.90 8 9Registradores 8 e 9 após o Shift 2F.E3.D4.C5 B6.A7.89.00 8 9

Sumario Instr.Máq.


Instruções de máquina - SLL

SLL (Shift Left Logical – Deslocamento lógico à esquerda)Código de máquina 89 (Instrução RS)



É feito deslocamento de bits para a esquerda no conteúdo do registrador primeiro operando. Todos os bits são deslocados para a esquerda (incluindo o bit de sinal).Os bits à direita são criados com zero.É uma instrução RS, e os bits 12 a 15 dela são ignorados pela UCP.Os 6 bits mais à direita do número que é o endereço do 2º operando, formam um número que indica quantas "casas" devem ser deslocadas.Pode-se deslocar 32 "casas" no máximo. Exemplo: SLL 5,2

Registrador 5 antes do Shift B9.4F.FF.FF

Registrador 5 após o Shift E5.3F.FF.FC

Sumario Instr.Máq.


Instruções de máquina - SLR

SLR (Subtract Logical Register – Subtrair logicamente em registrador)Código de máquina 1F (Instrução RR)

Condition code 00 Nunca o condition code fica em 00 após um SLR01 Resultado <> 0, não perde sinal10 Resultado = 0, perde sinal11 Resultado <> 0, perde sinal


É efetuada uma subtração lógica entre os números binários (considerados com 32 bits cada, positivos) contidos no 1º operando (minuendo) e 2º operando (subtraendo). O resto é colocado no registrador 1º operando. Ex:Supor os operandos com tamanho e conteúdo como exibidos na linha “antes” 1o operando antes 2o operando antes 1o operando depois 2o operando depois SLR 7,12 00.B0.C4.E2 00.00.00.01 00.B0.C4.E1 00.00.00.01 SLR 10,11 80.00.00.00 00.00.00.01 7F.FF.FF.FF 00.00.00.01

Sumario Instr.Máq.


Instruções de máquina - SP

SP (Subtract Packed – Subtrair em compactado)Código de máquina FB (Instrução SS – L1 e L2)



Sumario Instr.Máq.

Esta instrução subtrai o conteúdo do 2o operando do conteúdo do 1o operando.Ambos devem ser campos de memória no formato decimal compactado. O resultado é colocado no 1o operando. Exemplos: SP FLDA,FLDB Antes DepoisFLDB 98.7C 98.7CFLDA 12.34.5C 11.35.8CMais exemplos: SP VALOR,VALOR SP TOTAL,=P'1' SP AE+5(8),AE+15(3) SP 0(2,7),4(1,8)


Instruções de máquina - SPM

SPM (Set Program Mask – Posicionar máscara de programa)Código de máquina 04 (Instrução RR)

Condition code fica com o conteúdo dos bits 2 e 3 do reg. 1º operando

Interrupções Possíveis nenhuma

Os bits 12 a 15 da instrução (onde haveria o registrador 2º operando) são ignorados. O conteúdo do registrador 1º operando é usado como base para colocar o condition code e a máscara de programa na PSW atual.Os bits 2 e 3 do registrador 1º operando tem seu conteúdo colocado no condition code da PSW atual, e os bits 4,5,6 e 7 tem seu conteúdo colocado na máscara de programa da PSW atual.Os bits 0 e 1, e os bits 8 a 31 do registrador 1º operando são ignorados. Ex:

SPM 8

Sumario Instr.Máq.


Instruções de máquina - SR

SR (Subtract Register – Subtrair registrador)Código de máquina 1B (Instrução RR)



O número binário contido no registrador especificado no 2º operando é subtraído algebricamente do número binário contido no registrador especificado no 1º operando, e o resto é colocado no registrador 1º operando.Portanto: Minuendo : 1ºoperando ; Subtraendo : 2ºoperando ; Resto : 1ºoperandoExemplos:Supor os operandos com tamanho e conteúdo como exibidos na linha “antes” 1o operando antes 2o operando antes 1o operando depois 2o operando depois SR 7,8 00.00.FF.FF 00.00.00.01 00.00.FF.FE 00.00.00.01 SR 2,2 00.00.FF.FF 00.00.FF.FF 00.00.00.00 00.00.00.00

Sumario Instr.Máq.


Instruções de máquina - SRA

SRA (Shift Right Algebraic – Deslocamento algebrico à direita)Código de máquina 8A (Instrução RS)

Condition code 00 Resultado = 001 Resultado < 010 Resultado > 011 O copdition code nunca fica em 11 após um SRA


É feito deslocamento de bits para a direita no conteúdo do registrador primeiro operando. São deslocados os bits 1 a 31 do registrador: todos menos o bit de sinal (o bit de sinal não é deslocado/alterado). Os bits à esquerda são criados com zero.É uma instrução RS, e os bits 12 a 15 dela são ignorados pela UCP.Os 6 bits mais à direita do número que é o endereço do 2º operando, formam um número que indica quantas "casas" devem ser deslocadas. Pode-se deslocar 15 "casas" no máximo. Ex: SRA 5,3Registrador 5 antes do Shift FF.80.0A.00Registrador 5 após o Shift 8F.F0.01.40

Sumario Instr.Máq.


Instruções de máquina - SRDA

SRDA (Shift Right Double Algebraic – Deslocamento algébrico duplo à direita)Código de máquina 8E (Instrução RS)

Condition code 00 Resultado = 001 Resultado < 010 Resultado > 011 O condition code nunca fica em 11 após em SRDA


É feito deslocamento de bits para a direita no conteúdo do par de registradores indicado registrador primeiro operando e pelo registrador seguinte a ele. São deslocados os 63 bits formados por: bits 1 a 31 do registrador primeiro operando juntamente com os bits 0 a 31 do registrador segundo operando (considera que o par de registradores tenha um número com 1 bit de sinal + 63 bits para o número). Os bits à esquerda são criados com zero.É uma instrução RS, e os bits 12 a 15 dela são ignorados pela UCP.Os 6 bits mais à direita do número que é o endereço do 2º operando, formam um número que indica quantas "casas" devem ser deslocadas. Pode-se deslocar 63 "casas" no máximo. Ex: SRDA 8,4Registradores 8 e 9 antes do Shift 04.20.08.91 C4.00.02.FFRegistradores 8 e 9 após o Shift 00.42.00.89 1C.40.00.2F

Sumario Instr.Máq.


Instruções de máquina - SRDL

SRDL (Shift Right Double Logical – Deslocamento lógico duplo à direita)

É feito deslocamento de bits para a direita no conteúdo do par de registradores indicado pelo primeiro operando e pelo registrador seguinte ao primeiro operando. Todos os bits são deslocados para a direita (incluindo o bit de sinal).Os bits à esquerda são criados com zero.É uma instrução RS, e os bits 12 a 15 dela são ignorados pela UCP.Os 6 bits mais à direita do número que é o endereço do 2º operando, formam um número que indica quantas "casas" devem ser deslocadas.Pode-se deslocar 63 "casas" no máximo. Ex: SRDL 8,4Registradores 8 e 9 antes do Shift 12.FE.3D.4C 5B.6A.78.90 8 9Registradores 8 e 9 após o Shift 01.2F.E3.D4 C5.B6.A7.89 8 9

Código de máquina 8C (Instrução RS)



Sumario Instr.Máq.


Instruções de máquina - SRL

SRL (Shift Right Logical – Deslocamento lógico à direita)

É feito deslocamento de bits para a direita no conteúdo do registrador primeiro operando. Todos os bits são deslocados para a direita (incluindo o bit de sinal).Os bits à esquerda são criados com zero.É uma instrução RS, e os bits 12 a 15 dela são ignorados pela UCP.Os 6 bits mais à direita do número que é o endereço do 2º operando, formam um número que indica quantas "casas" devem ser deslocadas.Pode-se deslocar 32 "casas" no máximo. Exemplo: SRL 5,2

Registrador 5 antes do Shift B9.4F.FF.FF

Registrador 5 após o Shift 2E.53.FF.FF

Código de máquina 88 (Instrução RS)



Sumario Instr.Máq.


Instruções de máquina - SRP

SRP (Shift and Round Packed – Deslocar e arredondar em compactado)Código de máquina F0 (Instrução SS)



O seu formato de máquina é o seguinte: CO = 1 byte (código de operação)L1 = 1/2 byte (tamanho do primeiro operando - 1)I3 = 1/2 byte (operando imediato (terceiro operando)E1 = 2 bytes (B1D1D1D1 endereço base+deslocamento do primeiro operando)E2 = 2 bytes (B2D2D2D2 endereço base+deslocamento do segundo operando) O campo especificado no 1º operando sofre um deslocamento de dígitos (algarismos) na direção e quantidade de dígitos especificada pelo endereço do 2º operando, e, quando o deslocamento é para a direita, é feito um arredondamento, o qual é especificado no 3. operando.

Sumario Instr.Máq.






O endereço do 2º operando não é usado para especificação de dados; os 6 últimos bits à direita do número que representa o endereço do 2º operando são analisados da seguinte maneira:O 1º bit à esquerda indica o sentido do deslocamento: se estiver desligado, o deslocamento é à esquerda; se estiver ligado, o deslocamento e à direita.s outros 5 bits formam um número que indica quantos dígitos devem ser deslocados (se o deslocamento for à direita, este número está negativo). O campo especificado no 1º operando deve estar em compactado. O arredondamento é feito somando-se o número especificado no 3. operando ao último dígito deslocado, e, se for 1, esse 1 é somado ao número resultante do deslocamento. Vejamos os seguintes exemplos:

Sumario Instr.Máq.






Sumario Instr.Máq.

SRP TOTAL,61,5 TOTAL Antes 12.34.56.78.9C TOTAL Depois 00.01.23.45.7C

(desloca 3 dígitos para a direita)

SRP TOTAL,3,0 TOTAL Antes 12.34.56.78.9C TOTAL Depois 45.67.89.00.0C

(desloca 3 dígitos para a esquerda)

Estas regras facilitam a especificação do sentido de deslocamento e quantidade de dígitos a deslocar:Deslocamento para a esquerda = especificar diretamente a quantidade de dígitos SRP TOTAL,3,5 Especificar quantidade de dígitos no 2o operando = desloca para a esquerda

(no exemplo = 3)

Deslocamento para a direita = especificar (64 – quantidade de dígitos) SRP TOTAL,64-3,5 Especificar [64-qtdade] no 2o operando = desloca para a direita

(no exemplo = 3)


Instruções de máquina - ST

ST (Store – armazenar [registrador em memória])Código de máquina 50 (Instrução RX)



O conteúdo do registrador especificado no 1º operando é colocado no campo de memória de 4 bytes especificado no 2º operando (em geral uma fullword). O registrador 1º operando permanece inalterado. Ex:Supor os operandos com tamanho e conteúdo como exibidos na linha “antes” 1o operando antes 2o operando antes 1o operando depois 2o operando depois ST 7,FULL FE.DC.BA.98 00.01.00.00 FE.DC.BA.98 FE.DC.BA.98 ST 14,SAVE 00.00.00.11 FF.FF.FF.FD 00.00.00.11 00.00.00.11 Outros exemplos: ST 14,FULL+4 ST 14,0(2) ST 14,0(,8)

Sumario Instr.Máq.


Instruções de máquina - STC

STC (STore Character – armazenar 1 byte de registrador)Código de máquina 42 (Instrução RX)



O conteúdo do último byte à direita do registrador especificado no 1º operando (o qual permanece inalterado) é colocado no campo de 1 byte especificado no 2º operando. Ex:Supor os operandos com tamanho e conteúdo como exibidos na linha “antes” 1o operando antes 2o operando antes 1o operando depois 2o operando depois STC 7,BYTE FE.DC.BA.98 00 FE.DC.BA.98 98 STC 14,0(5) 00.00.00.11 FF 00.00.00.11 11

Sumario Instr.Máq.


Instruções de máquina - STCK

STCK (Store ClocK – armazenar relógio)Código de máquina B205 (Instrução S)

Condition code 00 O clock está em estado de set01 O clock não está em estado de set10 O clock está em estado de erro 11 Nunca fica em 11 após um STCK


O conteúdo do TOD clock é armazenado no campo de 8 bytes especificado como operando. O clock deve estar em estado de set, stop ou não-set.As posições à direita não providas pelo TOD clock são preenchidas com zeros.Se o TOD clock está em estado de erro, o conteúdo do campo é imprevisível.Se ele está não operacional, é colocado zeros no campo. Exemplo: STCK DW

Sumario Instr.Máq.


Instruções de máquina - STCM

STCM (STore Character under Mask – Armazenar caracter com máscara)Código de máquina BE (Instrução RS)



O seu formato de máquina é o seguinte:CO (código de operação) = 1 byte; R1 (registrador primeiro operando) = 1/2 byteE2 = 2 bytes (base+deslocamento do 2o. operando); M3 (máscara 3o. operando) = 1/2 byte

Os 4 bits da máscara, da esquerda para a direita, correspondem aos 4 bytes do registrador especificado no 1º operando.Os bytes do registrador que tiverem os seus bits correspondentes na máscara ligados, são considerados como um "campo" contíguo, e movidos para o campo de memória especificado no último operando da instrução (2º operando), o qual deve ter tantos bytes de tamanho quantos forem os bits da máscara ligados. O registrador 1º operando não é alterado. Exemplo:Supor os operandos com tamanho e conteúdo como exibidos na linha “antes” 1o operando antes 2o operando antes 1o operando depois 2o operando depois STCM 5,B'1010',TWOBYTES 00.00.45.67 9A.BC 00.00.45.67 00.45

1o byte do registrador 5 é colocado no byte TWOBYTES e 3o byte do registrador 5 é colocado no byte TWOBYTES+1

Sumario Instr.Máq.


Instruções de máquina - STH

STH (STore Halfword – Armazenar halfword)Código de máquina 40 (Instrução RX)



O conteúdo dos 2 últimos bytes à direita do registrador especificado no 1º operando é colocado no campo de memória de 2 bytes especificado no 2º operando (em geral uma halfword). O registrador 1º operando permanece inalterado. Ex:Supor os operandos com tamanho e conteúdo como exibidos na linha “antes” 1o operando antes 2o operando antes 1o operando depois 2o operando depois STH 5,FLD 00.00.00.0A 8A.B4 00.00.00.0A 00.0A STH 8,HWORD FF.FF.FF.FF FF.FF FF.FF.FF.FF FF.FFMais exemplos: STH 14,SAVE+18 STH 14,0(2) STH 14,0(,8) STH 14,0(2,8) STH 0,FLD

Sumario Instr.Máq.


Instruções de máquina - STM

STM (STore Multiple – Armazenar múltiplos [registradores])Código de máquina 90 (Instrução RX)



Esta instrução trabalha com 3 operandos: os 2 primeiros especificados são registradores e o terceiro é um endereço de memória.A instrução STM coloca o conteúdo do conjunto de n registradores (indicado pelos registradores especificados) no campo de memória de (n.4) bytes especificado no último operando. Ex:STM 14,1,SALVA

SALVA = 16 bytes (bytes 0 a 3 = conteúdo reg 14; bytes 4 a 7 = conteúdo reg 15; bytes 8 a 11 = conteúdo reg 0; bytes 12 a 15 = conteúdo reg 1) |------- SALVA --------------------------------|<----------><---------><----------><----------> Reg. 14 Reg.15 Reg.0 Reg.1 Outro Exemplo: STM 1,7,2(10)

Sumario Instr.Máq.


Instruções de máquina - SVC

SVC (SuperVisor Call – Chamada ao supervisor)Código de máquina 0A (Instrução RR)

Condition code Permanece inalterado na PSW velha


O seu formato de Máquina é o seguinte: CO (código de operação) = 1 byte ; Número do SVC = 1 byteEsta instrução causa interrupção de programa, através de uma chamada ao programa supervisor, chamada essa que pede a ele que execute alguma função. O código especificado no único operando (entre 0 e 255) indica qual a função desejada. Ex: SVC 0 SVC 7Exemplos de SVC's de MVS:X'00' (000) = EXCP/XDAP X'13' (019) = OPENX'01' (001) = WAIT/WAITR/PRTOV X'14' (020) = CLOSEX'02' (002) = POST X'23' (035) = WTO/WTORX'04' (004) = GETMAIN X'24' (036) = WTLX'05' (005) = FREEMAIN X'5D' (093) = TGET/TPUTX'0B' (011) = TIME X'63' (099) = DYNALLOCX'0D' (013) = ABEND X'6B' (107) = MODESET

Sumario Instr.Máq.


Instruções de máquina - TM

TM (Test under Mask – Testar com máscara)Código de máquina 91 (Instrução SI)

Condition code 00 Todos os bits testados estão desligados, ou a máscara é 001 Dos bits testados, alguns estão ligados e outros desligados10 Nunca o condition code fica em 10 após um TM11 Todos os bits testados estão ligados


Esta instrução testa bits do campo de 1 byte especificado no 1º operando, a partir da máscara especificada no 2º operando (termo auto-definido), a qual indica quais são os bits que devem ser testados.Os bits ligados na máscara indicam que os seus correspondentes no 1º operando devem ser testados. Após o teste, o condition code é posicionado. Ex: TM BYTE,X'9C' Bits 0, 3, 4 e 5 of BYTE são testados Neste caso, os bits 0, 3, 4 e 5 de BYTE serão testados. Outros exemplos: TM CHAVE,B'10000001' Bits 0 e 7 de KEYAB são testados TM 0(4),240 Bits 4,5,6 e 7 de [reg base 4 + deslocamento X’0’] são testados TM 2(8),X'80' Bit 0 [reg base 8 + deslocamento X’2’] é testado

Sumario Instr.Máq.


Instruções de máquina - TR

TR (TRanslate - Traduzir)Código de máquina DC (Instrução SS – L)



A instrução TR movimenta o conteúdo do 2º operando para o 1º operando, de acordo com o conteúdo do 1º operando. Para tanto, ela processa da esquerda para a direita, byte a byte, da seguinte forma: ela soma o conteúdo de um byte do 1º operando ao endereço do 2º operando; o byte cujo endereço foi encontrado, será movido para o byte do 1º operando.Ex: TR ACSD,TABELAAntes ACSD 02.00.08.FF.05 TABELA I C1.48.B9.D7.A1.C3.D9.5C.4B ........1A Tem 256 bytesDepois ACSD B9.C1.4B.1A.C3 TABELA não é alteradoOutros exemplos: TR 0(5,7),0(10) TR ARIMP+7(10),TABASTER TR 2(5,124),CAMP

Sumario Instr.Máq.






Sumario Instr.Máq.

Mais exemplos : Para traduzir letras maiúsculas EBCDIC em letras minúsculas EBCDIC; “letras” inválidas são convertidas em espaços EBCDIC CONVTB1 DC 256C' ' 256 espacos EBCDIC ORG CONVTB1+C'A' Volta para A maiusculo DC C'abcdefghi' Substitui espacos originais pelas minusculas ORG CONVTB1+C'J' Volta para J maiusculo DC C'jklmnopqr' Substitui espacos originais pelas minusculas ORG CONVTB1+C'S' Volta para S maiusculo DC C'stuvwxyz’ Substitui espacos originais pelas minusculas ORG , Volta para CONVTB1 +256Para traduzir letras maiúsculas EBCDIC para letras maiúsculas ASCII; “letras” inválidas são convertidas para espaços ASCII CONVTB2 DC 256X'20' 256 ASCII spaces ORG CONVTB2+C'A' Volta para A maiusculo DC X'414243444546474849' Substitui letras EBCDIC pelas ASCII ORG CONVTB1+C'J' Volta para J maiusculo DC X'4A4B4C4D4E4F505152' Substitui letras EBCDIC pelas ASCII ORG CONVTB1+C'S' Volta para S maiusculo DC X'535455565758595A' Substitui letras EBCDIC pelas ASCII ORG , Volta para CONVTB2+256






Sumario Instr.Máq.

Mais exemplos : Para traduzir letras ASCII maiúsculas para letras EBCDIC maiúsculas; “letras” inválidas são convertidas em espaços EBCDIC CONVTB3 DC 256X'40' 256 espacos EBCDIC ORG CONVTB2+X'41' “Return” to Uppercase ASCII A DC C'ABCDEFGHIJKLMNOPQRSTUVWXYZ' Subst letras ASCII pelas EBCDIC ORG , Volta para CONVTB3+256


Instruções de máquina - TRT

TRT (TRanslate and Test – Traduzir e testar)Código de máquina DD (Instrução SS – L)

Condition code 00 Todos os bytes testados estavam em X'00'01 O teste parou num byte que não era o último a ser testado.10 O teste foi ate o último byte a ser testado, o qual não estava em X'00'11 O condition code nunca fica em 11 após um TRT


A instrução TRT testa bytes do campo especificado no 2º operando, verificando se eles estão ou não em X'00'. O primeiro que for testado e que não esteja em X'00' faz com que a execução da instrução seja encerrada. O 1º operando indica quais os bytes do 2º operando a testar: o TRT soma o conteúdo de um byte do 1º operando ao endereço do 2º operando; o byte cujo endereço foi encontrado é que será testado.Quando é encontrado um byte que não esteja em X'00', a instrução coloca no registrador 1 (nos seus bits 8 a 31; os bits 0 a 7 não são alterados) o endereço do byte do 1º operando cujo conteúdo levou ao byte do 2º operando que não estava em X'00"; além disso, ela coloca no último byte à direita do registrador 2 (os seus bits 0 a 23 não são alterados) o conteúdo do byte do 2º operando que não estava em X'00'. A instrução TRT é, em geral, usada num dos casos a seguir:

Sumario Instr.Máq.






a) Testar se um campo (1º operando) está no formato decimal zonado - campo numérico:

TRT CART+9(6),TABNUM BZ NUMÉRICO . . . TABNUM DC 240X'FF',10X'00',6X'FF'

b) Testar se um campo (1º operando) é alfabético (só tem letras e brancos)

TRT CART+9(6),TABALFAB BZ FABETICO . . TABALFAB DC CL256X'FF' ORG TABALFAB+C' ' DC X'00' ORG TABALFAB+C'A' DC 9X'00' ORG TABALFAB+C'J' DC 9X'00' ORG TABALFAB+C'S' DC 8X'00' ORG

Sumario Instr.Máq.






c) Achar o 1º byte de um campo que tenha determinado caracter (* no exemplo). TRT 0(80,7),TABASTER BZ NOTASTER aqui o registrador 1 tem o endereço do byte com * desejado . . . TABASTER DC 256X'00' ORG TABASTER+C'*' DC X'FF' ORG

Sumario Instr.Máq.


Instruções de máquina - TS

TS (Test ans Set – Testar e posicionar)Código de máquina 93 (Instrução S)

Condition code 00 Bit mais à esquerda desligado01 Bit mais à esquerda ligado10 Nunca fica em 10 após um TS 11 Nunca fica em 11 após um TS


O segundo byte da instrução é ignorado.O bit mais à esquerda do único byte do operando é testado para ver se está ligado ou desligado; o condition code é posicionado, e o byte tem todos os seus bits ligados (fica com X'FF'). Exemplo:

TS BYTE

Sumario Instr.Máq.


Instruções de máquina - UNPK

UNPK (UNPacK - Descompactar) Código de máquina F3 (Instrução SS – L1 e L2)



A instrução UNPK movimenta um campo de memória para outro campo de memória, transformando-o de compactado para zonado.Não é feito nenhum teste quanto à validade dos campos.O 1º operando é o campo receptor e o 2º operando é o campo emissor.A movimentação é feita da direita para a esquerda, da seguinte forma:O byte mais à direita do campo emissor é invertido e colocado no byte mais à direita do campo receptor (inverter = a sua parte de zona vira parte numérica, e a sua parte numérica vira parte de zona). Em seguida, cada meio byte do campo emissor é colocado na parte numérica de um byte do campo receptor, sendo que na parte de zona do byte do campo receptor é colocado X'F'.O 2º operando permanece inalterado.Se o campo receptor for menor que o necessário, os algarismos em excesso serão truncados.Se o campo receptor for maior que o necessário, os bytes em excesso serão preenchidos com X'F0'. Ex: UNPK CPOA,CPOB antes depois CPOB 12.34.5C 12.34.5C CPOA 92.B8.4C.D0 F2.F3.F4.C5

Sumario Instr.Máq.


Instruções de máquina - UNPK

UNPK (UNPacK - Descompactar) Código de máquina F3 (Instrução SS – L1 e L2)



Outros exemplos:

UNPK CPOA,CPOB antes depois CPOB 12.3C 12.3C CPOA 92.B8.4C.D0 F0.F1.F2.C3

UNPK ARGRAV+5(12),TOTLIQ UNPK AX2,2(3,7) UNPK 17(10,8),T4B2F+3(5) UNPK 2(13,10),0(5,3)

Sumario Instr.Máq.


Instruções de máquina - X

X ([boolean] eXclusive or - OU exlusivo booleano)Código de máquina 57 (Instrução RX)

Condition code 00 Resultado = 001 Resultado <> 010 O condition code nunca fica em 10 após um X11 O condition code nunca fica em 11 após um X


A instrução X executa um EXCLUSIVE OR entre um registrador (especificado no 1º operando) e um campo de memória de 4 bytes (Especificado no 2º operando - em geral uma fullword). Bit da máscara = 0 então bit resultante não é alterado; Bit da máscara = 1 então bit resultante é o inversoEx: X 13,CAMPOF

antes depoisReg. 13 B4.EF.2F.A8 B4.EF.2F.57CAMPOF 00.00.00.FF 00.00.00.FF

Sumario Instr.Máq.


Instruções de máquina - XC

XC (eXclusive or Character – OU exclusivo [booleano] em caracter)Código de máquina D7 (Instrução SS – L)

Condition code 00 Resultado = 001 Resultado <> 010 O condition code nunca fica em 10 após um XC11 O condition code nunca fica em 11 após um XC


A instrução XC executa um EXCLUSIVE OR entre 2 campos de memória. Bit da máscara = 0 então bit resultante não é alterado; Bit da máscara = 1 então bit resultante é o inversoEx: XC CPOA,CPOB antes depois CPOA EF.2F.A8 EF.2F.57 CPOB 00.00.00 00.00.FF

Sumario Instr.Máq.


Instruções de máquina - XI

XI (eXclusive or Immediate – OU exclusivo [booleano] com operando imediato)Código de máquina 97 (Instrução SI)

Condition code 00 Resultado = 001 Resultado <> 010 O condition code nunca fica em 10 após um OI11 O condition code nunca fica em 11 após um OI


A instrução XI executa um EXCLUSIVE OR entre 2 campos de memória (um byte cada). Bit da máscara = 0 então bit resultante não é alterado; Bit da máscara = 1 então bit resultante é o inversoEx: NI BYE,X'0F'

Antes DepoisBYTE B4 BBOp.Imed. 0F 0F

Sumario Instr.Máq.


Instruções de máquina - XR

XR (eXclusive Or Register – OU exclusivo [booleano] com registradores)Código de máquina 17 (Instrução RR)

Condition code 00 Resultado = 001 Resultado <> 010 O condition code nunca fica em 10 após um XR11 O condition code nunca fica em 11 após um XR


A instrução XR executa um EXCLUSIVE OR entre 2 registradores. Bit da máscara = 0 então bit resultante não é alterado; Bit da máscara = 1 então bit resultante é o inversoEx: XR 5,8 Antes DepoisReg. 5 B4.EF.2F.A8 B4.EF.2F.57Reg. 8 00.00.00.FF 00.00.00.FF

Sumario Instr.Máq.


Instruções de máquina - ZAP

ZAP (Zero and Add Packed – Zerar e somar em compactado)Código de máquina F8 (Instrução SS – L1 e L2)

Condition code 00 Se o campo movido = 001 Se o campo movido < 010 Se o campo movido > 011 Overflow


A instrução ZAP movimenta o campo especificado no 2º operando (campo emissor) para o campo especificado no 1º operando (campo receptor). O emissor permanece inalterado, e deve estar obrigatoriamente em compactado. A movimentação é feita da direita para a esquerda. Se o emissor for maior (em tamanho) que o receptor, os algarismos em excesso à esquerda serão truncados. Se o emissor for menor (em tamanho) que o receptor, o ZAP preencherá à esquerda com zeros. Ex:

Sumario Instr.Máq.


Instruções de máquina - ZAP

ZAP (Zero and Add Packed – Zerar e somar em compactado)Código de máquina F8 (Instrução SS – L1 e L2)

Condition code 00 Se o campo movido = 001 Se o campo movido < 010 Se o campo movido > 011 Overflow


ZAP CPOA,CPOB Antes Depois1º Caso CPOB 12.34.5C 12.34.5C CPOA B4.F8 34.5C2º Caso CPOB 12.3C 12.3C CPOA 07.B8.92 00.12.3C Outros exemplos: ZAP TOTAL,=P'0' ZAP TOTAL,TOTAL ZAP CONTLIN,=P'2'


Macro-instruções

MACRO-INSTRUÇÕES


Macro-instruções

MACRO-INSTRUÇÕES

Sorry... Não é escopo deste curso...


Apêndice - Links

LINKS

z/Architecture

http://publibz.boulder.ibm.com/epubs/pdf/dz9zr006.pdf

ESA Enterprise Systems Architecture / XC Extended Configuration (para z/VM)http://publib.boulder.ibm.com/infocenter/zvm/v5r3/index.jsp?topic=/com.ibm.zvm.v53.hcpb6/abstract.htm

High Level Assembler

http://publib.boulder.ibm.com/infocenter/ratdevz/v7r5/topic/com.ibm.ent.asm.zos.doc/topics/fn1lrmst02.htm#wq2


Apêndice – Resumo instruções por cod. operação

Algumas instruções (ordem código de operação)Mnemônico Cod.Instr Tipo BALR 05 RR BCTR 06 RR BCR 07 RR SVC 0A RR BSM 0B RR BASSM 0C RR BASR 0D RR MVCL 0E RR CLCL 0F RR LPR 10 RR LNR 11 RR LTR 12 RR LCR 13 RR NR 14 RR CLR 15 RR OR 16 RR XR 17 RR LR 18 RR CR 19 RR AR 1A RR

Mnemônico Cod.Instr Tipo SR 1B RR MR 1C RR DR 1D RR ALR 1E RR SLR 1F RR STH 40 RX LA 41 RX STC 42 RX IC 43 RX EX 44 RX BAL 45 RX BCT 46 RX BC 47 RX LH 48 RX CH 49 RX AH 4A RX SH 4B RX MH 4C RX BAS 4D RX CVD 4E RX

Mnemônico Cod.Instr Tipo CVB 4F RX ST 50 RX LAE 51 RX N 54 RX CL 55 RX O 56 RX X 57 RX L 58 RX C 59 RX A 5A RX S 5B RX M 5C RX D 5D RX AL 5E RX SL 5F RX STD 60 RX MXD 67 RX LD 68 RX CD 69 RX AD 6A RX


Apêndice – Resumo instruções por cod. operação

Algumas instruções (ordem código de operação)Mnemônico Cod.Instr Tipo SD 6B RX MD 6C RX DD 6D RX AW 6E RX SW 6F RX STE 70 RX LE 78 RX CE 79 RX BXH 86 RS BXLE 87 RS SRL 88 RS SLL 89 RS SRA 8A RS SLA 8B RS SRDL 8C RS SLDL 8D RS SRDA 8E RS SLDA 8F RS STM 90 RS TM 91 SI

Mnemônico Cod.Instr Tipo MVI 92 SI TS 93 S NI 94 SI CLI 95 SI OI 96 SI XI 97 SI LM 98 RS MC AF SI LRA B1 RX STCK B205 S CS BA RS CDS BB RS CLM BD RS STCM BE RS ICM BF RS MVN D1 SS/L MVC D2 SS/L MVZ D3 SS/L NC D4 SS/L CLC D5 SS/L

Mnemônico Cod.Instr Tipo OC D6 SS/L XC D7 SS/L TR DC SS/L TRT DD SS/L ED DE SS/L EDMK DF SS/L MVCIN E8 SS/L SRP F0 SS/L1I3 MVO F1 SS/L1L2 PACK F2 SS/L1L2 UNPK F3 SS/L1L2 ZAP F8 SS/L1L2 CP F9 SS/L1L2 AP FA SS/L1L2 SP FB SS/L1L2 MP FC SS/L1L2 DP FD SS/L1L2


Apêndice – Resumo instruções por mnemônico

Algumas instruções (ordem mnemônico)Mnemônico Cod.Instr TipoA 5A RXAD 6A RXAH 4A RXAL 5E RXALR 1E RRAP FA SS/L1L2AR 1A RRAW 6E RXBAL 45 RXBALR 05 RRBAS 4D RXBASR 0D RRBASSM 0C RRBC 47 RXBCR 07 RRBCT 46 RXBCTR 06 RRBSM 0B RRBXH 86 RSBXLE 87 RS

Mnemônico Cod.Instr TipoC 59 RXCD 69 RXCDS BB RSCE 79 RXCH 49 RXCL 55 RXCLC D5 SS/LCLCL 0F RRCLI 95 SICLM BD RSCLR 15 RRCP F9 SS/L1L2CR 19 RRCS BA RSCVB 4F RXCVD 4E RXD 5D RXDD 6D RXDP FD SS/L1L2DR 1D RR

Mnemônico Cod.Instr TipoED DE SS/LEDMK DF SS/LEX 44 RXIC 43 RXICM BF RSL 58 RXLA 41 RXLAE 51 RXLCR 13 RRLD 68 RXLE 78 RXLH 48 RXLM 98 RSLNR 11 RRLPR 10 RRLR 18 RRLRA B1 RXLTR 12 RRM 5C RXMC AF SI


Apêndice – Resumo instruções por mnemônico

Algumas instruções (ordem mnemônico)Mnemônico Cod.Instr TipoMD 6C RXMH 4C RXMP FC SS/L1L2MR 1C RRMVC D2 SS/LMVCIN E8 SS/LMVCL 0E RRMVI 92 SIMVN D1 SS/LMVO F1 SS/L1L2MVZ D3 SS/LMXD 67 RXN 54 RXNC D4 SS/LNI 94 SINR 14 RRO 56 RXOC D6 SS/LOI 96 SIOR 16 RR

Mnemônico Cod.Instr TipoPACK F2 SS/L1L2S 5B RXSD 6B RXSH 4B RXSL 5F RXSLA 8B RSSLDA 8F RSSLDL 8D RSSLL 89 RSSLR 1F RRSP FB SS/L1L2SR 1B RRSRA 8A RSSRDA 8E RSSRDL 8C RSSRL 88 RSSRP F0 SS/L1I3ST 50 RXSTC 42 RXSTCK B205 S

Mnemônico Cod.Instr TipoSTCM BE RSSTD 60 RXSTE 70 RXSTH 40 RXSTM 90 RSSVC 0A RRSW 6F RXTM 91 SITR DC SS/LTRT DD SS/LTS 93 SUNPK F3 SS/L1L2X 57 RXXC D7 SS/LXI 97 SIXR 17 RRZAP F8 SS/L1L2


Apêndice – EBCDIC – Alguns caracteres

Algumas configurações EBCDICHEX CARATER

40 Espaço 60 - hífen 81 a A2 s D0 } fecha chave F0 0

4B . ponto 61 / barra 82 b A3 t D1 J F1 1

4C < menor 6B , virgula 83 c

A4 u D2 K F2 2

4D ( abre parênt. 6C % percentual 84 d A5 v D3 L F3 3

4E + mais 6D _ underscore 85 e A6 w D4 M F4 4

4F | barra vertical 6E > maior 86 f A7 x D5 N F5 5

50 & E comercial 6F ? interrogação

87 g

A8 y D6 O F6 6

5A ! exclamação 7A : 2 pontos 88 h A9 z D7 P F7 7

5B $ cifrão 7B # número 91 i C0 { abre chave D8 Q F8 8

5C * asterisco 7C @ arroba 92 j C1 A D9 R F9 9

5D ) fecha parênt. 7D ' apostrofe 93 k

C2 B E0 \ barra invertida

5E ; ponto e vírgula 7E = igual 94 l C3 C E2 S

5F not 7F " aspas 95 m C4 D E3 T

96 n C5 E E4 U

97 o C6 F E5 V

98 p

C7 G E6 W

99 q C8 H E7 X

9A r C9 I E8 Y

E9 Z


Apêndice – ASCII – Alguns caracteres

Algumas configurações ASCIIHEX CARATER

20 Espaço 30 0 zero 40 @ at

50 P 60 ` Acento grave 70 p

21 ! Exclamação 31 1 um 41 A

51 Q 61 a 71 q

22 “ Aspas 32 2 dois 42 B

52 R 62 b 72 r

23 # Número 33 3 tres 43 C

53 S 63 c 73 s

24 $ Cifrão 34 4 quatro 44 D

54 T 64 d 74 t

25 % Percentual 35 5 cinco 45 E

55 U 65 e 75 u

26 & E comercial 36 6 seis 46 F

56 V 66 f 76 v

27 ‘ Apóstrofe 37 7 sete 47 G

57 W 67 g 77 w

28 ( Abre parentheses 38 8 oito 48 H

58 X 68 h 78 x

29 ) Fecha parentheses 39 9 nove 49 I

59 Y 69 i 79 y

2A * Asterisco 3A : dois pontos 4A J

5A Z 6A j 7A z

2B + Soma 3B ; ponto e vírgula 4B K

5B [ Abre colchete 6B k 7B { Abre chave

2C , Virgula 3C < menor que 4C L

5C \ Barra invertida 6C l 7C | Barra vertical

2D - Hífen 3D = igual a 4D M

5D ] Fecha colchete 6D m 7D } Fecha chave

2E . Ponto 3E > maior que 4E N

5E ^ Circumflexo 6E n 7E ~ Til

2F / Barra 3F ? Interrogação 4F O

5F _ (Sublinhado) 6F o


Questões

Questões


(Q) Exercícios 1-12 (Converter de decimal para binário)

Exercício 1 : (987654)10 = (?)2

Exercício 2 : (4095)10 = (?)2

Exercício 3 : (7)10 = (?)2

Exercício 4 : (1023)10 = (?)2

Exercício 5 : (4096)10 = (?)2

Exercício 6 : (255)10 = (?)2

Exercício 7 : (1024)10 = (?)2

Exercício 8 : (10010001)10 = (?)2

Exercício 9 : (256)10 = (?)2

Exercício 10 : (1025)10 = (?)2

Exercício 11 : (999888)10 = (?)2

Exercício 12 : (65432)10 = (?)2


(Q) Exercícios 13-24 (Converter de decimal para hexadecimal)

Exercício 13 : (987654)10 = (?)16

Exercício 14 : (4095)10 = (?)16

Exercício 15 : (7)10 = (?)16

Exercício 16 : (1023)10 = (?)16

Exercício 17 : (4096)10 = (?)16

Exercício 18 : (255)10 = (?)16

Exercício 19 : (1024)10 = (?)16

Exercício 20 : (10010001)10 = (?)16

Exercício 21 : (256)10 = (?)16

Exercício 22 : (1025)10 = (?)16

Exercício 23 : (999888)10 = (?)16

Exercício 24 : (65432)10 = (?)16


(Q) Exercícios 25-36 (Converter de binário para hexadecimal)

Exercício 25 : (11111000111010100100001 )2 = (?)16

Exercício 26 : (1000000111000111111110000011111110)2 = (?)16

Exercício 27 : (1100)2 = (?)16

Exercício 28 : (11111110001)2 = (?)16

Exercício 29 : (1010101010101000110011000111)2 = (?)16

Exercício 30 : (110011001100110011001)2 = (?)16

Exercício 31 : (1000000000000001)2 = (?)16

Exercício 32 : (1000000001)2 = (?)16

Exercício 33 : (111111100000001111111)2 = (?)16

Exercício 34 : (1)2 = (?)16

Exercício 35 : (1100101011111110)2 = (?)16

Exercício 36 : (101011010111000111000000001111110001111)2 = (?)16


(Q) Exercícios 37-48 (Converter de hexadecimal para binário)

Exercício 37 : (CAFE)16 = (?)2

Exercício 38 : (CDF)16 = (?)2

Exercício 39 : (1AB4D)16 = (?)2

Exercício 40 : (15)16 = (?)2

Exercício 41 : (F)16 = (?)2

Exercício 42 : (87B54)16 = (?)2

Exercício 43 : (1001)16 = (?)2

Exercício 44 : (234)16 = (?)2

Exercício 45 : (CAD)16 = (?)2

Exercício 46 : (7F7)16 = (?)2

Exercício 47 : (1990)16 = (?)2

Exercício 48 : (33)16 = (?)2


(Q) Exercícios 49-60 (Converter de binário para decimal)

Exercício 49 : (11)2 = (?)10

Exercício 50 : (100001111111)2 = (?)10

Exercício 51 : (101010010101)2 = (?)10

Exercício 52 : (110000001111111)2 = (?)10

Exercício 53 : (11111110000011)2 = (?)10

Exercício 54 : (11110000111000)2 = (?)10

Exercício 55 : (11)2 = (?)10

Exercício 56 : (111111110)2 = (?)10

Exercício 57 : (1111100001111000111001101)2 = (?)10

Exercício 58 : (1000000000000)2 = (?)10

Exercício 59 : (11111001)2 = (?)10

Exercício 60 : (1000000000000001)2 = (?)10


(Q) Exercícios 61-72 (Converter de hexadecimal para decimal)

Exercício 61 : (11)16 = (?)10

Exercício 62 : (AAF45)16 = (?)10

Exercício 63 : (1B567)16 = (?)10

Exercício 64 : (100)16 = (?)10

Exercício 65 : (1000)16 = (?)10

Exercício 66 : (FF)16 = (?)10

Exercício 67 : (FFF)16 = (?)10

Exercício 68 : (CDF)16 = (?)10

Exercício 69 : (CAFE)16 = (?)10

Exercício 70 : (FACA)16 = (?)10

Exercício 71 : (DAD0)16 = (?)10

Exercício 72 : (F1E2D3C4)16 = (?)10


(Q) Exercícios 73-84 (Somar números binários)

Exercício 73 : (11001100)2 + (10101010)2 = (?)2

Exercício 74 : (1111001111)2 + (1001111001)2 = (?)2

Exercício 75 : (1111)2 + (1)2 = (?)2

Exercício 76 : (1111)2 + (111)2 = (?)2

Exercício 77 : (100001)2 + (11110)2 = (?)2

Exercício 78 : (1011110011)2 + (111101111)2 = (?)2

Exercício 79 : (110011001100)2 + (101011110000)2 = (?)2

Exercício 80 : (1111100001111000)2 + (101111)2 = (?)2

Exercício 81 : (111)2 + (1111)2 + (100)2 = (?)2

Exercício 82 : (11)2 + (111)2 + (1111)2 + (11111)2 = (?)2

Exercício 83 : (1111)2 + (1001)2 + (111)2 + (101)2 + (11)2 + (1)2 = (?)2

Exercício 84 : (111)2 + (1000)2 + (1)2 + (1100)2 = (?)2


(Q) Exercícios 85-96 (Subtrair números binários)

Exercício 85 : (11001100)2 - (1010101)2 = (?)2

Exercício 86 : (1111001111)2 - (1111001)2 = (?)2

Exercício 87 : (1111)2 - (1)2 = (?)2

Exercício 88 : (1111)2 - (111)2 = (?)2

Exercício 89 : (100001)2 - (11110)2 = (?)2

Exercício 90 : (1011110011)2 - (111101111)2 = (?)2

Exercício 91 : (11001100)2 - (111011110000)2 = (?)2

Exercício 92 : (1111000)2 - (101010111)2 = (?)2

Exercício 93 : (111)2 - (1111)2 = (?)2

Exercício 94 : (10001)2 - (111111)2 = (?)2

Exercício 95 : (0)2 - (1)2 = (?)2

Exercício 96 : (0)2 - (10)2 = (?)2


(Q) Exercícios 97-108 (Somar números em hexadecimal)

Exercício 97 : (F12B)16 + (321)16 = (?)16

Exercício 98 : (1100)16 + (111)2 = (?)16

Exercício 99 : (1000F)16 + (F0001)16 = (?)16

Exercício 100 : (A9B8C7)16 + (D6E5F4)16 = (?)16

Exercício 101 : (CAFE)16 + (CDF)16 = (?)16

Exercício 102 : (B001)16 + (FD)16 = (?)16

Exercício 103 : (999)16 + (111)16 = (?)16

Exercício 104 : (123456)16 + (789ABC)16 = (?)16

Exercício 105 : (FFF)16 + (EEE)16 = (?)16

Exercício 106 : (DDD)16 + (333)16 = (?)16

Exercício 107 : (987AED)16 + (CF01)16 = (?)16

Exercício 108 : (FACA)16 + (CAFE)16 = (?)16


(Q) Exercícios 109-120 (Subtrair números em hexadecimal)

Exercício 109 : (F1C5)16 - (101)16 = (?)16

Exercício 110 : (1AD87C)16 - (FDE9)2 = (?)16

Exercício 111 : (112233)16 - (44556)16 = (?)16

Exercício 112 : (AABBCC)16 - (DDEEF)16 = (?)16

Exercício 113 : (F1E2D3)16 - (C4B5A6)16 = (?)16

Exercício 114 : (FF00001)16 - (10000F)16 = (?)16

Exercício 115 : (CAFE)16 - (FACA)16 = (?)16

Exercício 116 : (CDF)16 - (FDC)16 = (?)16

Exercício 117 : (10001)16 - (20001)16 = (?)16

Exercício 118 : (10000)16 - (FFFE)16 = (?)16

Exercício 119 : (0)16 - (9)16 = (?)16

Exercício 120 : (0)16 - (1A)16 = (?)16


(Q) Exercícios 121-126 (Representar números binários em halfword e fullword)

Exercício 121 : (1)10 = (bbbb bbbb bbbb bbbb)2 = (xxxx)16

= (bbbb bbbb bbbb bbbb bbbb bbbb bbbb bbbb)2 = (xxxxxxxx)16

Exercício 122 : (-1)10 = (bbbb bbbb bbbb bbbb)2 = (xxxx)16













































(Q) Exercícios 141-152 (Representar números compactados em bytes)

Exercício 141 : (1)10 = (no formato decimal compactado)

Exercício 142 : (-1)10 = (no formato decimal compactado)












(Q) Exercícios 153-160 (Representar números compactados em bytes)










(Q) Exercícios 161-172 (Representar números zonados em bytes)

Exercício 161 : (1)10 = (no formato decimal zonado)

Exercício 162 : (-1)10 = (no formato decimal zonado)












(Q) Exercícios 173-180 (Representar números zonados em bytes)










(Q) Exercícios 181-194 (Representar strings de caracteres em bytes)

Exercício 181 : “17“ = (em EBCDIC alfanumérico) Exercício 182 : “-17“ = (em EBCDIC alfanumérico) Exercício 183 : “AF$BD“ = (em EBCDIC alfanumérico) Exercício 184 : “-AF4BD“ = (em EBCDIC alfanumérico) Exercício 185 : “ALBERTO“ = (em EBCDIC alfanumérico) Exercício 186 : “15-9“ = (em EBCDIC alfanumérico) Exercício 187 : “-4095“ = (em EBCDIC alfanumérico) Exercício 188 : “4095“ = (em EBCDIC alfanumérico) Exercício 189 : “*&$//“ = (em EBCDIC alfanumérico) Exercício 190 : “12+3“ = (em EBCDIC alfanumérico) Exercício 191 : “I LOVE HER“ = (em EBCDIC alfanumérico) Exercício 192 : “US$ 2,584.73“ = (em EBCDIC alfanumérico) Exercício 193 : “US$ 1 MILLION“ = (em EBCDIC alfanumérico) Exercício 194 : “PANCHO’S BAR“ = (em EBCDIC alfanumérico)


(Q) Exercícios 195-209 (Representar campos em bytes)

Os exercícios 195 a 300 devem ser considerados como um programa, cujo endereço inicial é zero (X’00000000’), ou seja, a primeira área (exercício 195) começa no endereço zero. As áreas definas por DS devem ser computadas para determinar os endereços. Assumir que o 1o statement seja USING *,9.

Exercício 195: DC C'123' Exercício 196: DC C'+123' Exercício 197: DC C'-123' Exercício 198: DC C'12.3' Exercício 199: DC C'1AB8' Exercício 200: DC C'01101' Exercício 201: DC C'A+B=C' Exercício 202: DC CL4'A' Exercício 203: DC CL4'ABCDEF' Exercício 204: DC 3CL2'A' Exercício 205: DC 2CL3'A,B' Exercício 206: DC C'ME&&YOU' Exercício 207: DC C'''S MUSIC' Exercício 208: DC C'@@OI' Exercício 209: DC CL3'*'



Exercício 210: DC 3C'*' Exercício 211: DC X'123' Exercício 212: DC X'-123' Exercício 213: DC X'1AB2C3' Exercício 214: DC X'1AB2F4G3' Exercício 215: DC XL3'12D' Exercício 216: DC XL3'AABBCCDDEE' Exercício 217: DC X'1,22,333,4444' Exercício 218: DC XL2'1,22,333' Exercício 219: DC 2X'1,22,333' Exercício 220: DC 2XL2'1,22' Exercício 221: DC B'01010101' Exercício 222: DC B'1' Exercício 223: DC BL2'1111' Exercício 224: DC B'1,1111111111' Exercício 225: DC BL2'1,1111111111'



Exercício 226: DC 2B'1000' Exercício 227: DC 2BL2'1000' Exercício 228: DC F'10' Exercício 229: DC F'+10' Exercício 230: DC F'-10' Exercício 230: DC F'-15,+16' Exercício 231: DC 2F'22' Exercício 232: DC 2F'33,44' Exercício 233: DC FL3'258' Exercício 234: DC 2FL1'255' Exercício 235: DC F'128000' Exercício 236: DC H'10' Exercício 237: DC H'+10' Exercício 238: DC H'-10' Exercício 239: DC H'-15,+16'



Exercício 240: DC 2H'22' Exercício 241: DC 2H'33,44' Exercício 242: DC HL3'258' Exercício 243: DC 2HL1'255' Exercício 244: DC H'128000' Exercício 245: DC P'123' Exercício 246: DC P'+123' Exercício 247: DC P'-123' Exercício 248: DC PL4'456' Exercício 249: DC PL1'789' Exercício 250: DC P'1,-22,333,-4444' Exercício 251: DC PL2'1,-22,333,-4444'Exercício 252: DC 3P'0' Exercício 253: DC PL3'0' Exercício 254: DC 2P'1,22,333'



Exercício 255: DC 2PL2'1,22,333' Exercício 256: DC Z'123' Exercício 257: DC Z'+123' Exercício 258: DC Z'-123' Exercício 259: DC ZL4'456' Exercício 260: DC ZL1'789' Exercício 261: DC Z'1,-22,333,-4444' Exercício 262: DC ZL3'1,-22,333,-4444' Exercício 263: DC 3Z'0' Exercício 264: DC ZL3'0' Exercício 265: DC 2Z'1,22,333' Exercício 266: DC 2ZL3'1,22,333'



Exercício 267: SIMBZZ DC A(0) Exercício 268: SIMBAA DC A(127) Exercício 269: SIMBBB DC A(X'8000') Exercício 270: SIMBCC DC A(B'1111') Exercício 271: SIMBDD DC A(C'*') Exercício 272: SIMBEE DC A(*) Exercício 273: SIMBFF DS CL17 Exercício 274: SIMBGG DC A(*) Exercício 275: SIMBHH DC A(SIMBGG) Exercício 276: SIMBII DC A(SIMBAA+12) Exercício 277: SIMBJJ DC A(SIMBII-SIMBBB) Exercício 278: SIMBKK DC AL1(*-SIMBKK) Exercício 279: SIMBLL DC 5AL1(*-SIMBLL)



Exercício 280: SIMBMM DC AL2(3,5,7) Exercício 281: SIMBNN DC A(SIMBII+5*2) Exercício 282: SIMBOO DC A(SIMBNN+X'80000000') Exercício 283: SIMBPP DC 4AL2(*-SIMBPP) Exercício 284: SIMBQQ DC A(SIMBVV) Exercício 285: SIMBRR DC A(SIMBKK,SIMBJJ) Exercício 286: SIMBSS DC A(SIMBTT+40) Exercício 287: SIMBTT DC A(SIMBUU,*,80) Exercício 288: SIMBUU DC 2A(*-SIMBUU) Exercício 289: SIMBVV DC A(C'AMO') Exercício 290: SIMBWW DC A(X'7FFFFFFF')



Exercício 291: YY1 DC Y(SIMBWW) Exercício 292: YY2 DC Y(10) Exercício 293: YY3 DC Y(L'YY2) Exercício 294: SS1 DC S(SIMBAA) Exercício 295: SS2 DC S(SS1) Exercício 296: SS3 DC S(10) Exercício 297: SS4 DC S(*) Exercício 298: SS5 DC A(125),F'33',C'*',2H'6,18' Exercício 299: SS6 DC X'1,1',B'1,1',C'1,1' Exercício 300: LAST DC 256AL1(255+LAST-*)


(Q) Exercício 301 (Decodificar instruções)

Exercício 301 : Decodificar o seguinte conjunto de instruções:1ABB41278CF00A13980F334445E00CB490EC0D00FA82305448CCD28233445566Para cada uma delas, informar:- Código de operação (código de máquina)- Menmônico Assembler- Endereço da instrução (supor que a primeira instrução esteja no endereço X’00000000’)- Operandos (registrador, registrador base, registrador indexador, deslocamento; se o operando é na memória, calcular o seu endereço; para isso, supor os registradores gerais com o seguinte conteúdo: R00=00112233 R04=00000400 R08=00000800 R12=00000C00R01=00000100 R05=00000500 R09=00000900 R13=00000D00R02=00000200 R06=00000600 R10=00000A00 R14=00000E00R03=00000300 R07=00000700 R11=00000B00 R15=00000F00


Respostas

Respostas


(A) Exercícios 1-12 (Converter de decimal para binário)

Exercício 1 : (987654)10 = (1111 0001 0010 0000 0110)2

Exercício 2 : (4095)10 = (1111 1111 1111)2

Exercício 3 : (7)10 = (111)2

Exercício 4 : (1023)10 = (11 1111 1111)2

Exercício 5 : (4096)10 = (1 0000 0000 0000)2

Exercício 6 : (255)10 = (1111 1111)2

Exercício 7 : (1024)10 = (100 0000 0000)2

Exercício 8 : (10010001)10 = (1001 1000 1011 1101 1001 0001)2

Exercício 9 : (256)10 = (1 0000 0000)2

Exercício 10 : (1025)10 = (100 0000 0001)2

Exercício 11 : (999888)10 = (1111 0100 0001 1101 0000)2

Exercício 12 : (65432)10 = (1111 1111 1001 1000)2


(A) Exercícios 13-24 (Converter de decimal para hexadecimal)

Exercício 13 : (987654)10 = (F1206)16

Exercício 14 : (4095)10 = (FFF)16

Exercício 15 : (7)10 = (7)16

Exercício 16 : (1023)10 = (3FF)16

Exercício 17 : (4096)10 = (1000)16

Exercício 18 : (255)10 = (FF)16

Exercício 19 : (1024)10 = (400)16

Exercício 20 : (10010001)10 = (98BD91)16

Exercício 21 : (256)10 = (100)16

Exercício 22 : (1025)10 = (401)16

Exercício 23 : (999888)10 = (F41D0)16

Exercício 24 : (65432)10 = (FF98)16


(A) Exercícios 25-36 (Converter de binário para hexadecimal)

Exercício 25 : (11111000111010100100001 )2 = (7C7521)16

Exercício 26 : (1000000111000111111110000011111110)2 = (2071FE0FE)16

Exercício 27 : (1100)2 = (C)16

Exercício 28 : (11111110001)2 = (7F1)16

Exercício 29 : (1010101010101000110011000111)2 = (AAA8CC7)16

Exercício 30 : (110011001100110011001)2 = (199999)16

Exercício 31 : (1000000000000001)2 = (8001)16

Exercício 32 : (1000000001)2 = (201)16

Exercício 33 : (111111100000001111111)2 = (1FC07F)16

Exercício 34 : (1)2 = (1)16

Exercício 35 : (1100101011111110)2 = (CAFE)16

Exercício 36 : (101011010111000111000000001111110001111)2 = (56B8E01F8F)16


(A) Exercícios 37-48 (Converter de hexadecimal para binário)

Exercício 37 : (CAFE)16 = (1100101011111110)2

Exercício 38 : (CDF)16 = (110011011111)2

Exercício 39 : (1AB4D)16 = (11010101101001101)2

Exercício 40 : (15)16 = (10101)2

Exercício 41 : (F)16 = (1111)2

Exercício 42 : (87B54)16 = (10000111101101010100)2

Exercício 43 : (1001)16 = (1000000000001)2

Exercício 44 : (234)16 = (1000110100)2

Exercício 45 : (CAD)16 = (110010101101)2

Exercício 46 : (7F7)16 = (11111110111)2

Exercício 47 : (1990)16 = (1100110010000)2

Exercício 48 : (33)16 = (110011)2


(A) Exercícios 49-60 (Converter de binário para decimal)

Exercício 49 : (11)2 = (3)10

Exercício 50 : (100001111111)2 = (2175)10

Exercício 51 : (101010010101)2 = (2709)10

Exercício 52 : (110000001111111)2 = (24703)10

Exercício 53 : (11111110000011)2 = (16259)10

Exercício 54 : (11110000111000)2 = (15416)10

Exercício 55 : (11)2 = (3)10

Exercício 56 : (111111110)2 = (510)10

Exercício 57 : (1111100001111000111001101)2 = (32567757)10

Exercício 58 : (1000000000000)2 = (4096)10

Exercício 59 : (11111001)2 = (249)10

Exercício 60 : (1000000000000001)2 = (32769)10


(A) Exercícios 61-72 (Converter de hexadecimal para decimal)

Exercício 61 : (11)16 = (17)10

Exercício 62 : (AAF45)16 = (?)10

Exercício 63 : (1B567)16 = (111975)10

Exercício 64 : (100)16 = (256)10

Exercício 65 : (1000)16 = (4096)10

Exercício 66 : (FF)16 = (255)10

Exercício 67 : (FFF)16 = (4095)10

Exercício 68 : (CDF)16 = (3295)10

Exercício 69 : (CAFE)16 = (51966)10

Exercício 70 : (FACA)16 = (64202)10

Exercício 71 : (DAD0)16 = (56016)10

Exercício 72 : (F1E2D3C4)16 = (4058174404)10


(A) Exercícios 73-84 (Somar números em binário)

Exercício 73 : (11001100)2 + (10101010)2 = (1 0111 0110)2

Exercício 74 : (1111001111)2 + (1001111001)2 = (110 0100 1000)2

Exercício 75 : (1111)2 + (1)2 = (10000)2

Exercício 76 : (1111)2 + (111)2 = (10110)2

Exercício 77 : (100001)2 + (11110)2 = (111111)2

Exercício 78 : (1011110011)2 + (111101111)2 = (100 1110 0010)2

Exercício 79 : (110011001100)2 + (101011110000)2 = (1 0111 1011 1100)2

Exercício 80 : (1111100001111000)2 + (101111)2 = (1111 1000 1010 0111)2

Exercício 81 : (111)2 + (1111)2 + (100)2 = (11010)2

Exercício 82 : (11)2 + (111)2 + (1111)2 + (11111)2 = (111000)2

Exercício 83 : (1111)2 + (1001)2 + (111)2 + (101)2 + (11)2 + (1)2 = (101000)2

Exercício 84 : (111)2 + (1000)2 + (1)2 + (1100)2 = (11100)2


(A) Exercícios 85-96 (Subtrair números em binário)

Exercício 85 : (11001100)2 - (1010101)2 = (111 0111)2

Exercício 86 : (1111001111)2 - (1111001)2 = (11 0101 0110)2

Exercício 87 : (1111)2 - (1)2 = (1110)2

Exercício 88 : (1111)2 - (111)2 = (1000)2

Exercício 89 : (100001)2 - (11110)2 = (11)2

Exercício 90 : (1011110011)2 - (111101111)2 = (1 0000 0100)2

Exercício 91 : (11001100)2 - (111011110000)2 = (...1111 1111 1100 1101)2

Exercício 92 : (1111000)2 - (101010111)2 = (... 1111 1111 0010 0001)2

Exercício 93 : (111)2 - (1111)2 = (... 1111 1111 1111 1000)2

Exercício 94 : (10001)2 - (111111)2 = (... 1111 1111 1101 0010)2

Exercício 95 : (0)2 - (1)2 = (... 1111 1111 1111 1111)2

Exercício 96 : (0)2 - (10)2 = (... 1111 1111 1111 1110)2


(A) Exercícios 97-108 (Somar números em hexadecimal)

Exercício 97 : (F12B)16 + (321)16 = (F44C)16

Exercício 98 : (1100)16 + (111)2 = (1211)16

Exercício 99 : (1000F)16 + (F0001)16 = (100010)16

Exercício 100 : (A9B8C7)16 + (D6E5F4)16 = (1809EBB)16

Exercício 101 : (CAFE)16 + (CDF)16 = (D7DD)16

Exercício 102 : (B001)16 + (FD)16 = (B0FE)16

Exercício 103 : (999)16 + (111)16 = (AAA)16

Exercício 104 : (123456)16 + (789ABC)16 = (19BBF12)16

Exercício 105 : (FFF)16 + (EEE)16 = (1EED)16

Exercício 106 : (DDD)16 + (333)16 = (1110)16

Exercício 107 : (987AED)16 + (CF01)16 = (9949EE)16

Exercício 108 : (FACA)16 + (CAFE)16 = (1C5C8)16


(A) Exercícios 109-120 (Subtrair números em hexadecimal)

Exercício 109 : (F1C5)16 - (101)16 = (F0C4)16

Exercício 110 : (1AD87C)16 - (FDE9)2 = (19DA93)16

Exercício 111 : (112233)16 - (44556)16 = (CDCDD)16

Exercício 112 : (AABBCC)16 - (DDEEF)16 = (9CDCDD)16

Exercício 113 : (F1E2D3)16 - (C4B5A6)16 = (2D2D2D)16

Exercício 114 : (FF00001)16 - (10000F)16 = (FDFFFF2)16

Exercício 115 : (CAFE)16 - (FACA)16 = (...FFFFD034)16

Exercício 116 : (CDF)16 - (FDC)16 = (...FFFFFD03)16

Exercício 117 : (10001)16 - (20001)16 = (...FFFF0000)16

Exercício 118 : (10000)16 - (FFFE)16 = (2)16

Exercício 119 : (0)16 - (9)16 = (...FFFFFFF7)16

Exercício 120 : (0)16 - (1A)16 = (...FFFFFFE6)16


(A) Exercícios 121-126 (Representar números binários em bytes)

Exercício 121 : (1)10 = (0000 0000 0000 0001)2 = (0001)16

= (0000 0000 0000 0000 0000 0000 0000 0001)2 = (00000001)16

Exercício 122 : (-1)10 = (1111 1111 1111 1111)2 = (FFFF)16

= (1111 1111 1111 1111 1111 1111 1111 1111)2 = (FFFFFFFF)16

Exercício 123 : (10)10 = (0000 0000 0000 1010)2 = (000A)16

= (0000 0000 0000 0000 0000 0000 0000 1010)2 = (0000000A)16

Exercício 124 : (-10)10 = (1111 1111 1111 0110)2 = (FFF6)16

= (1111 1111 1111 1111 1111 1111 1111 0110)2 = (FFFFFFF6)16

Exercício 125 : (17)10 = (0000 0000 0001 0001)2 = (0011)16

= (0000 0000 0000 0000 0000 0000 0001 0001)2 = (00000011)16

Exercício 126 : (-17)10 = (1111 1111 1110 1111)2 = (FFEF)16

= (1111 1111 1111 1111 1111 1111 1110 1111)2 = (FFFFFFEF)16



Exercício 127 : (254)10 = (0000 0000 1111 1110)2 = (00FE)16

= (0000 0000 0000 0000 0000 0000 1111 1110)2 = (000000FE)16

Exercício 128 : (-254)10 = (1111 1111 0000 0010)2 = (FF02)16

= (1111 1111 1111 1111 1111 1111 0000 0010)2 = (FFFFFF02)16

Exercício 129 : (100000)10 = (imposível representar em 2 bytes)

= (0000 0000 0000 0001 1000 0110 1010 0000)2 = (000186A0)16

Exercício 130 : (-100000)10 = (imposível representar em 2 bytes)

= (1111 1111 1111 1110 0111 1001 0110 0000)2 = (FFFE7960)16

Exercício 131 : (32000)10 = (0111 1101 0000 0000)2 = (7D00)16

= (0000 0000 0000 0000 0111 1101 0000 0000)2 = (00007D00)16

Exercício 132 : (-32000)10 = (1000 0011 0000 0000)2 = (8300)16

= (1111 1111 1111 1111 1000 0011 0000 0000)2 = (FFFF8300)16



Exercício 133 : (63000)10 = (imposível representar em 2 bytes)

= (1111 1111 1111 1111 1111 0110 0001 1000 )2 = (FFFFF618)16

Exercício 134 : (-63000)10 = (imposível representar em 2 bytes)

= (1111 1111 1111 1111 0000 1001 1110 1000)2 = (FFFF09E8)16

Exercício 135 : (1010)10 = (0000 0011 1111 0010)2 = (03F2)16

= (0000 0000 0000 0000 0000 0011 1111 0010)2 = (000003F2)16

Exercício 136 : (-1010)10 = (1111 1100 0000 1110)2 = (FC0E)16

= (1111 1111 1111 1111 1111 1100 0000 1110)2 = (FFFFFC0E)16

Exercício 137 : (4095)10 = (0000 1111 1111 1111)2 = (0FFF)16

= (0000 0000 0000 0000 0000 1111 1111 1111)2 = (00000FFF)16

Exercício 138 : (-4095)10 = (1111 0000 0000 0001)2 = (F001)16

= (1111 1111 1111 1111 1111 0000 0000 0001)2 = (FFFFF001)16



Exercício 139 : (4097)10 = (0001 0000 0000 0001)2 = (1001)16

= (0000 0000 0000 0000 0001 0000 0000 0001)2 = (00001001)16

Exercício 140 : (-4097)10 = (1110 1111 1111 1111)2 = (EFFF)16

= (1111 1111 1111 1111 1110 1111 1111 1111)2 = (FFFFEFFF)16


(A) Exercícios 141-152 (Representar números compactados em bytes)

Exercício 141 : (1)10 = [ 0001 1100 ] = [ 1C ]

Exercício 142 : (-1)10 = [ 0001 1101 } = [ 1D ]

Exercício 143 : (10)10 = [ 0000 0001 0000 1100 ] = [ 010C ]

Exercício 144 : (-10)10 = [ 0000 0001 0000 1101 ] = [ 10D ]

Exercício 145 : (17)10 = [ 0000 0001 0111 1100 ] = [ 017C ]

Exercício 146 : (-17)10 = [ 0000 0001 0111 1101 ] = [ 017D ]

Exercício 147 : (254)10 = [ 0010 0101 0100 1100 ] = [ 254C ]

Exercício 148 : (-254)10 = [0010 0101 0100 1101 ] = [ 254D ]

Exercício 149 : (100000)10 = [ 0000 0001 0000 0000 0000 0000 0000 1100 ] = [ 0100000C ]

Exercício 150 : (100000)10 = [ 0000 0001 0000 0000 0000 0000 0000 1101 ] = [ 0100000D ]

Exercício 151 : (32000)10 = [ 0011 0010 0000 0000 0000 1100 ] = [ 32000C ]

Exercício 152 : (-32000)10 = [ 0011 0010 0000 0000 0000 1101 ] = [ 32000D ]


(A) Exercícios 153-160 (Representar números compactados em bytes)

Exercício 153 : (63000)10 = [ 0110 0011 0000 0000 0000 1100 ] = [ 63000C ]

Exercício 154 : (-63000)10 = [ 0110 0011 0000 0000 0000 1101 ] = [ 63000D ]

Exercício 155 : (1010)10 = [ 0000 0001 0000 0001 0000 1100 ] = [ 01010C ]

Exercício 156 : (-1010)10 = [ 0000 0001 0000 0001 0000 1100 ] = [ 01010D ]

Exercício 157 : (4095)10 = [ 0000 0100 0000 1001 0101 1100 ] = [ 04095C ]

Exercício 158 : (-4095)10 = [ 0000 0100 0000 1001 0101 1101 ] = [ 04095D ]

Exercício 159 : (4097)10 = [ 0000 0100 0000 1001 0111 1100 ] = [ 04097C ]

Exercício 160 : (-4097)10 = [ 0000 0100 0000 1001 0111 1101 ] = [ 04097D ]


(A) Exercícios 161-172 (Representar números zonados em bytes)

Exercício 161 : (1)10 = [ 1111 0001 ] = [ F1 ]Exercício 162 : (-1)10 = [ 1101 0001 } = [ D1 ]Exercício 163 : (10)10 = [ 1111 0001 1111 0000 ] = [ F1F0 ]Exercício 164 : (-10)10 = [ 1111 0001 1101 0000 ] = [ F1D0 ]Exercício 165 : (17)10 = [ 1111 0001 1111 0111 ] = [ F1F7 ]Exercício 166 : (-17)10 = [ 1111 0001 1101 0111 ] = [ F1D7 ]Exercício 167 : (254)10 = [ 1111 0010 1111 0101 1111 0100 ] = [ F2F5F4 ]Exercício 168 : (-254)10 = [ 1111 0010 1111 0101 1101 0100 ] = [ F2F5D4 ]Exercício 169 : (100000)10 = [ 1111 0001 1111 0000 1111 0000 1111 0000 1111 0000 1111 0000 ] = [ F1F0F0F0F0F0 ]Exercício 170 : (-100000)10 = [ 1111 0001 1111 0000 1111 0000 1111 0000 1111 0000 1101 0000 ] = [ F1F0F0F0F0D0 ]Exercício 171 : (32000)10 = [ 1111 0011 1111 0010 1111 0000 1111 0000 1111 0000 ] = [ F3F2F0F0F0 ]Exercício 172 : (-32000)10 = [ 1111 0011 1111 0010 1111 0000 1111 0000 1111 0000 ] = [ F3F2F0F0D0 ]


(A) Exercícios 173-180 (Representar números zonados em bytes)

Exercício 173 : (63000)10 =

[ 1111 0110 1111 0011 1111 0000 1111 0000 1111 0000 ] = [ F6F3F0F0F0 ]

Exercício 174 : (-63000)10 =

[ 1111 0110 1111 0011 1111 0000 1111 0000 1101 0000 ] = [ F6F3F0F0D0 ]

Exercício 175 : (1010)10 = [ 1111 0001 1111 0000 1111 0001 1111 0000 ] = [ F1F0F1F0 ]

Exercício 176 : (-1010)10 = [ 1111 0001 1111 0000 1111 0001 1101 0000 ] = [ F1F0F1D0 ]

Exercício 177 : (4095)10 = [ 1111 0100 1111 0000 1111 1001 1111 0101 ] = [ F4F0F9F5 ]

Exercício 178 : (-4095)10 = [ 1111 0100 1111 0000 1111 1001 1101 0101 ] = [ F4F0F9D5 ]

Exercício 179 : (4097)10 = [ 1111 0100 1111 0000 1111 1001 1111 1111 ] = [ F4F0F9F7 ]

Exercício 180 : (-4097)10 = [ 1111 0100 1111 0000 1111 1001 1101 0111 ] = [ F4F0F9D7 ]


(A) Exercícios 181-194 (Representar strings de caracteres em bytes)

Exercício 181 : “17“ = [ F1F7 ]Exercício 182 : “-17“ = [ 60F1F7 ]Exercício 183 : “AF$BD“ = [ C1C66BC2C4 ]Exercício 184 : “-AF4BD“ = [ 60C1C6F4C2C4 ]Exercício 185 : “ALBERTO“ = [ C1D3C2C5D9E3D6 ] Exercício 186 : “15-9“ = [ F1F560F9 ] Exercício 187 : “-4095“ = [ 60F4F0F9F5 ] Exercício 188 : “4095“ = [ F4F0F9F5 ] Exercício 189 : “*&$//“ = [ 5C505B6161 ] Exercício 190 : “12+3“ = [ F1F24EF3 ] Exercício 191 : “I LOVE HER“ = [ C940D3D6E5C540C8C5D9 ] Exercício 192 : “US$ 2,584.73“ = [ E4E25B40F26BF5F8F44BF7F3 ] Exercício 193 : “US$ 1 MILLION“ = [ E4E25B40F140D4C9D3D3C9D6D5 ]Exercício 194 : “PANCHO’S BAR“ = [ D7C1C5C3C8D67DE240C2C1D9 ]


(A) Exercícios 195-209 (Representar campos em bytes)

Os exercícios 195 a 300 devem ser considerados como um programa, cujo endereço inicial é zero (X’00000000’), ou seja, a primeira área (exercíco 195) começa no endereço zero. As áreas definas por DS devem ser computadas para determinar os endereços. Assumir que o 1o statement seja USING *,9.

* Endereço Conteúdo

Exercício 195: DC C'123' 0000 F1.F2.F3Exercício 196: DC C'+123' 0003 4E.F1.F2.F3Exercício 197: DC C'-123' 0007 60.F1.F2.F3Exercício 198: DC C'12.3' 000B F1.F2.4B.F3Exercício 199: DC C'1AB8' 000F F1.C1.C2.F8Exercício 200: DC C'01101' 0013 F0.F1.F1.F0.F1Exercício 201: DC C'A+B=C' 0018 C1.4E.C2.7E.C3Exercício 202: DC CL4'A' 001D C1.40.40.40Exercício 203: DC CL4'ABCDEF' 0021 C1.C2.C3.C4Exercício 204: DC 3CL2'A' 0025 C1.40.C1.40.C1.40 Exercício 205: DC 2CL3'A,B' 002B C1.6B.C2.C1.6B.C2Exercício 206: DC C'ME&&YOU' 0031 D4.C5.50.E8.D6.E4Exercício 207: DC C'''S MUSIC' 0037 7D.E2.40.D4.E4.E2.C9.C3Exercício 208: DC C'@@OI' 003F 7C.7C.D6.C9Exercício 209: DC CL3'*' 0043 5C.40.40




Exercício 210: DC 3C'*' 0046 5C.5C.5CExercício 211: DC X'123' 0049 01.23Exercício 212: DC X'-123' *** erro *** Exercício 213: DC X'1AB2C3' 004B 1A.B2.C3Exercício 214: DC X'1AB2F4G3' *** erro ***Exercício 215: DC XL3'12D' 004E 00.01.2DExercício 216: DC XL3'AABBCCDDEE' 0051 CC.DD.EE Exercício 217: DC X'1,22,333,4444' 0054 01.22.03.33.44.44 Exercício 218: DC XL2'1,22,333' 005A 00.01.00.22.03.33 Exercício 219: DC 2X'1,22,333' 0060 01.22.03.33.01.22.03.33 Exercício 220: DC 2XL2'1,22' 0068 00.01.00.22.00.01.00.22Exercício 221: DC B'01010101' 0070 55Exercício 222: DC B'1' 0071 01Exercício 223: DC BL2'1111' 0072 00.0FExercício 224: DC B'1,1111111111' 0074 01.03.FFExercício 225: DC BL2'1,1111111111' 0077 00.01.03.FF




Exercício 226: DC 2B'1000' 007B 08.08Exercício 227: DC 2BL2'1000' 007D 00.08.00.08 0081 00.00.00 (align) Exercício 228: DC F'10' 0084 00.00.00.0A Exercício 229: DC F'+10' 0088 00.00.00.0AExercício 230: DC F'-10' 008C FF.FF.FF.F6Exercício 230: DC F'-15,+16' 0090 FF.FF.FF.F1.00.00.00.10Exercício 231: DC 2F'22' 0098 00.00.00.16.00.00.00.16Exercício 232: DC 2F'33,44' 00A0 00.00.00.21.00.00.00.2C 00.00.00.21.00.00.00.2C Exercício 233: DC FL3'258' 00B0 00.01.02Exercício 234: DC 2FL1'255' 00B3 FF.FF 00B5 00.00.00 (align)Exercício 235: DC F'128000' 00B8 00.01.F4.00Exercício 236: DC H'10' 00BC 00.0AExercício 237: DC H'+10' 00BE 00.0AExercício 238: DC H'-10' 00C0 FF.F6Exercício 239: DC H'-15,+16' 00C2 FF.F1.00.10




Exercício 240: DC 2H'22' 00C6 00.16.00.16 Exercício 241: DC 2H'33,44' 00CA 00.21.00.2C.00.21.00.2C Exercício 242: DC HL3'258' 00D2 00.01.02 Exercício 243: DC 2HL1'255' 00D5 FF.FF 00D7 00 (align)Exercício 244: DC H'128000' 00D8 F4.00 Exercício 245: DC P'123' 00DA 12.3C Exercício 246: DC P'+123' 00DC 12.3C Exercício 247: DC P'-123' 00DE 12.3DExercício 248: DC PL4'456' 00E0 00.00.45.6CExercício 249: DC PL1'789' 00E4 9C Exercício 250: DC P'1,-22,333,-4444' 00E5 1C.02.2D.33.3C.04.44.4DExercício 251: DC PL2'1,-22,333,-4444' 00ED 00.1C.02.2D.33.3C.44.4DExercício 252: DC 3P'0' 00F5 0C.0C.0C Exercício 253: DC PL3'0' 00F8 00.00.0CExercício 254: DC 2P'1,22,333' 00FB 1C.02.2C.33.3C.1C.02.2C.33.3C




Exercício 255: DC 2PL2'1,22,333' 0105 00.1C.02.2C.33.3C 00.1C.02.2C.33.3CExercício 256: DC Z'123' 0111 F1.F2.C3Exercício 257: DC Z'+123' 0114 F1.F2.C3Exercício 258: DC Z'-123' 0117 F1.F2.D3Exercício 259: DC ZL4'456' 011A F0.F4.F5.C6Exercício 260: DC ZL1'789' 011E C9Exercício 261: DC Z'1,-22,333,-4444' 011F F1.F2.D2.F3.F3.C3.F4.F4.F4.D4Exercício 262: DC ZL3'1,-22,333,-4444' 0129 F0.F0.C1.F0.F2.D2.F3.F3.C3 F4.F4.F4.D4Exercício 263: DC 3Z'0' 0135 C0.C0.C0Exercício 264: DC ZL3'0' 0138 F0.F0.F0Exercício 265: DC 2Z'1,22,333' 013B C1.F2.C2.F3.F3.C3 C1.F2.C2.F3.F3.C3Exercício 266: DC 2ZL3'1,22,333' 0147 F0.F0.C1.F0.F2.C2.F3.F3.C3 F0.F0.C1.F0.F2.C2.F3.F3.C3



* Endereço Conteúdo 0159 00.00.00 (align)Exercício 267: SIMBZZ DC A(0) 015C 00.00.00.00Exercício 268: SIMBAA DC A(127) 0160 00.00.00.7FExercício 269: SIMBBB DC A(X'8000') 0164 00.00.80.00Exercício 270: SIMBCC DC A(B'1111') 0168 00.00.00.0FExercício 271: SIMBDD DC A(C'*') 016C 00.00.00.5CExercício 272: SIMBEE DC A(*) 0170 00.00.01.70Exercício 273: SIMBFF DS CL17 0174 ??.??.??.??.??.??.??.??.?? ??.??.??.??.??.??.??.?? 0185 00.00.00 (align)Exercício 274: SIMBGG DC A(*) 0188 00.00.01.88Exercício 275: SIMBHH DC A(SIMBGG) 018C 00.00.01.88Exercício 276: SIMBII DC A(SIMBAA+12) 0190 00.00.01.6CExercício 277: SIMBJJ DC A(SIMBII-SIMBBB) 0194 00.00.00.2C Exercício 278: SIMBKK DC AL1(*-SIMBKK) 0198 00Exercício 279: SIMBLL DC 5AL1(*-SIMBLL) 0199 00.01.02.03.04




Exercício 280: SIMBMM DC AL2(3,5,7) 019E 00.03.00.05.00.07 Exercício 281: SIMBNN DC A(SIMBII+5*2) 01A4 00.00.01.9A Exercício 282: SIMBOO DC A(SIMBNN+X'80000000') 01A8 80.00.01.A4Exercício 283: SIMBPP DC 4AL2(*-SIMBPP) 01AC 00.00.00.02.00.04 00.06Exercício 284: SIMBQQ DC A(SIMBVV) 01B4 00.00.01.D8Exercício 285: SIMBRR DC A(SIMBKK,SIMBJJ) 01B8 00.00.01.98 00.00.01.94 Exercício 286: SIMBSS DC A(SIMBTT+40) 01C0 00.00.01.ECExercício 287: SIMBTT DC A(SIMBUU,*,80) 01C4 00.00.01.D0 00.00.01.C8 00.00.00.50 Exercício 288: SIMBUU DC 2A(*-SIMBUU) 01D0 00.00.00.00 00.00.00.04Exercício 289: SIMBVV DC A(C'AMO') 01D8 00.C1.D4.D6Exercício 290: SIMBWW DC A(X'7FFFFFFF') 01DC 7F.FF.FF.FF




Exercício 291: YY1 DC Y(SIMBWW) 01E0 01.DCExercício 292: YY2 DC Y(10) 01E2 00.0AExercício 293: YY3 DC Y(L'YY2) 01E4 00.02Exercício 294: SS1 DC S(SIMBAA) 01E6 91.60 Exercício 295: SS2 DC S(SS1) 01E8 91.E6Exercício 296: SS3 DC S(10) 01EA 00.0A Exercício 297: SS4 DC S(*) 01EC 91.EC 01EE 00.00 (align) Exercício 298: SS5 DC A(125),F'33',C'*',2H'6,18' 01F0 00.00.00.7D 00.00.00.21 5C 00 (align) 00.06.00.12 00.06.00.12 Exercício 299: SS6 DC X'1,1',B'1,1',C'1,1' 0202 01.01.01.01 F1.6B.F1


(A) Exercício 300 (Representar campos em bytes)


Exercício 300: LAST DC 256AL1(255+LAST-*) 0209 FF.FE.FD.FC.FB.FA.F9.F8.F7.F6.F5.F4.F3.F2.F1.F0* 0219 EF.EE.ED.EC.EB.EA.E9.E8.E7.E6.E5.E4.E3.E2.E1.E0* 0229 DF.DE.DD.DC.DB.DA.D9.D8.D7.D6.D5.D4.D3.D2.D1.D0* 0239 CF.CE.CD.CC.CB.CA.C9.C8.C7.C6.C5.C4.C3.C2.C1.C0* 0249 BF.BE.BD.BC.BB.BA.B9.B8.B7.B6.B5.B4.B3.B2.B1.B0* 0259 AF.AE.AD.AC.AB.AA.A9.A8.A7.A6.A5.A4.A3.A2.A1.A0* 0269 9F.9E.9D.9C.9B.9A.99.98.97.96.95.94.93.92.91.90* 0279 8F.8E.8D.8C.8B.8A.89.88.87.86.85.84.83.82.81.80* 0289 7F.7E.7D.7C.7B.7A.79.78.77.76.75.74.73.72.71.70* 0299 6F.6E.6D.6C.6B.6A.69.68.67.66.65.64.63.62.61.60* 02A9 5F.5E.5D.5C.5B.5A.59.58.57.56.55.54.53.52.51.50* 02B9 4F.4E.4D.4C.4B.4A.49.48.47.46.45.44.43.42.41.40* 02C9 3F.3E.3D.3C.3B.3A.39.38.37.36.35.34.33.32.31.30* 02D9 2F.2E.2D.2C.2B.2A.29.28.27.26.25.24.23.22.21.20* 02E9 1F.1E.1D.1C.1B.1A.19.18.17.16.15.14.13.12.11.10* 02F9 0F.0E.0D.0C.0B.0A.09.08.07.06.05.04.03.02.01.00


(A) Exercício 301 (Decodificar instruções)

Exercício 301 : Decodificar o seguinte conjunto de instruções:1ABB41278CF00A13980F334445E00CB490EC0D00FA82305448CCD28233445566----////////----////////--------////////------------////////////

Supor os registradores gerais com o seguinte conteúdo:

R00=00112233 R04=00000400 R08=00000800 R12=00000C00R01=00000100 R05=00000500 R09=00000900 R13=00000D00R02=00000200 R06=00000600 R10=00000A00 R14=00000E00R03=00000300 R07=00000700 R11=00000B00 R15=00000F00



Exercício 301 : Decodificar o seguinte conjunto de instruções:1ABB41278CF00A13980F334445E00CB490EC0D00FA82305448CCD28233445566----////////----////////--------////////------------////////////1ABB - Código de operação (máquina) = 1A- Mnemônico Assembler = AR (add register)- Endereço da instrução = X’00000000’- Operandos = 1o operando = registrador 11; 2o operando = registrador 11

41278CF0 - Código de operação (máquina) = 41- Mnemônico Assembler = LA (load address)- Endereço da instrução = X’00000002’-Operandos = 1st operand = register 2; 2o operando : indexador = registrador 7 2o operando : base register = registrador 8

2o operando : deslocamento = X’CF0’ Endereço 2o operando = X’ 00000700’+X’00000800’+X’CF0’= X’00001BF0’

Continua...



Exercício 301 : Decodificar o seguinte conjunto de instruções: 1ABB41278CF00A13980F334445E00CB490EC0D00FA82305448CCD28233445566----////////----////////--------////////------------////////////0A13 - Código de operação (máquina) = 0A- Mnemônico Assembler = SVC (supervisor call)- Endereço da instrução = X’00000006’- Operandos = códifo de chamada ao supervisor = X’13’ = (19)10 = open

980F3344 - Código de operação (máquina) = 98- Mnemônico Assembler = LM (load multiple)- Endereço da instrução = X’00000008’-Operandos = 1o operando = registrador 0; 3o operando : registrador 15 (X’F’) 2o operando : base = registrador 3

2o operando : deslocamento = X’344’ Endereço 2o operando = X’00000300’+X’344’= X’00000644’

Continua...



Exercício 301 : Decodificar o seguinte conjunto de instruções:1ABB41278CF00A13980F334445E00CB490EC0D00FA82305448CCD28233445566----////////----////////--------////////------------////////////45E00CB4 - Código de operação (máquina) = 45- Mnemônico Assembler = BAL (branch and link)- Endereço da instrução = X’0000000C’-Operandos = 1o operando = registrador 14 (X’E’); 2o operando : indexador = registrador 0 ; 2o operando : base = registrador 0; 2o operando : deslocamento = X’CB4’; Endereço 2o operando = X’CB4’= X’00000CB4’

90EC0D00 - Código de operação (máquina) = 90- Mnemônico Assembler = STM (store multiple)- Endereço da instrução = X’00000010’-Operandos = 1o operando = registrador 14 (X’E’); 3o operando : registrador 12 (X’C’) 2o operando : base = registrador 0; 2o operando : deslocamento = X’D00’

Endereço 2o operando = X’D00’= X’00000D00’ Continua...



Exercício 301 : Decodificar o seguinte conjunto de instruções: 1ABB41278CF00A13980F334445E00CB490EC0D00FA82305448CCD28233445566----////////----////////--------////////------------////////////FA82305448CC - Código de operação (máquina) = FA- Mnemônico Assembler = AP (add packed)- Endereço da instrução = X’00000014’- Tamanho 1o operando = 9 bytes; 1o operando : base = registrador 3; 1o operando : deslocamento = X’054’; Endereço 1o operando= X’00000300’+X’054’ = X’00000354’- Tamanho 2o operando = 3 bytes; 2o operando : base = registrador 4; 2o operando : deslocamento = X’8CC’; Endereço 2o operando = X’00000400’+X’8CC’ = X’00000CCC’

D28233445566 - Código de operação (máquina) = D2- Mnemônico Assembler = MVC (move character)- Endereço da instrução = X’0000001A’- Tamanho 1o operando = 131 bytes; 1o operando : base = registrador 3; 1o operando : deslocamento = X’344’; Endereço 1o operando = X’00000300’+X’344’ = X’00000644’- Tamanho 2o operando = 131 bytes; 2o operando : base = registrador 5; 2o operando : deslocamento = X566’; Endereço 2o operando = X’00000500’+X’566’ = X’00000A66’


Dicas de programação




Interessantes, úteis,

feias mas usadas,

etc...



PROG START 0 USING *,3 Using quando o location counter tem zero LR 3,15 CARREGA PRIMEIRO E UNICO REG BASE ...

4K 4K 3K

Trecho do programa servido pelo registrador base R3; qualquer símbolo definido neste trecho e que precise ser convertido em

Base+Deslocamento terá o registrador R3 como base

Supondo um programa com 11K e 1 registrador base

Trecho do programa sem registrador base; qualquer símbolo definido neste trecho e que

precise ser convertido em Base+Deslocamento : ERRO



PROG START 0 USING *,3,7 LR 3,15 CARREGA PRIMEIRO REG BASE LA 7,1 “INICIO” CARGA SEGUNDO BASE LA 4,4095(3,7) “FIM” CARGA SEGUNDO BASE ...

4K 4K 3K

Trecho do programa servido pelo registrador base R3; qualquer símbolo definido neste trecho e qye precise ser convertido em


Trecho do programa servido pelo registrador base R7; qualquer símbolo definido neste trecho e qye precise ser convertido em


Trecho do programa sem registrador base; qualquer

símbolo definido neste trecho e que precise ser convertido

em Base+Deslocamento : ERRO

Supondo um programa com 11K e 2 registradores base



4K 4K 3K

Trecho do programa servido pelo registrador

base R3


base R7


base R6

“Sobra de

base”

Supondo um programa com 11K e 3 registradores base

PROG START 0 USING *,3,7 LR 3,15 CARREGA PRIMEIRO REG BASE LA 7,1 “INICIO” CARGA SEGUNDO BASE LA 7,4095(3,7) “FIM” CARGA SEGUNDO BASE LA 6,1 “INICIO” CARGA TERCEIRO BASE LA 6,4095(7,6) “FIM” CARGA TERCEIRO BASE ...



PROG START 0 USING *,3 Using quando o location counter tem zero LR 3,15 CARREGA PRIMEIRO E UNICO REG BASE ...

4K 996K








4KInstruções

Áreas

996K








Instruções






Áreas(SEM base)

END

(fim do fonte)

Áreas(com base)

LTORG (emitido

pelo END)

LITERAIS declaradas

pelo LTORG(sem base)



Instruções






Áreas(SEM base)

END

(fim do fonte)

Áreas(com base)

LTORG(explicitamente colocado pelo programador)

LITERAIS declaradas pelo

LTORG(com base)

Áreas ainda

COM base



Instruções


Áreas(SEM base)

END

(fim do fonte)

Áreas(com base)

LTORG(explicitamente colocado pelo programador)

LITERAISdeclaradas pelo

LTORG(com base)

Áreas ainda

COM base

Vamos ver com

detalhes



Instruções Áreas


- as instruções, - as áreas antes do LTORG, - as literais e -o início das áreas “grandes” (específicamente os 100 primeiros bytes de TABXX)

estão dentro do alcance do registrador base.

LTORG

Literais(com base)

Início das áreas “grandes” (supor: 1os

100 bytes de uma área de 500000 bytes, por

ex. TABXX)TABXX DS 1000CL500

Restante da área (499900 bytes) +

uma 2ª área grande TABYY

+Uma pequena área de 4 bytes (XYZ)



Instruções Áreas


Neste caso: Os 100 primeiros bytes de TABXX estão COM base.Os 499900 bytes seguintes de TABXX estão SEM base.Os 520000 bytes de TABYY estão todos sem base.Os 4 bytes de XYZ estão SEM base.

LTORG

Literais(com base)

TABXX DS 1000CL500

100 1os bytes de TABXX

Demias 499900 bytes de TABXX

TABYY DS CL 1000CL52XYZ DS CL4



Instruções Áreas


Isto significa que:

LA R9,TABXX OK! TABXX (o endereço de TABXX é o endereço de seu primeiro bytes à esquerda) está dentro do alcance do registrador baseL R9,=A(TABXX) OK! A literal que tem o endereço de TABXX está dentro do alcance do registrador base

LA R9,TABXX+1 OK! TABXX+1 é um endereço que está dentro do alcance do registrador baseL R9,=A(TABXX+1) OK! A literal que tem o endereço de TABXX+1 está dentro do alcance do registrador base

LA R9,TABXX+99 OK! TABXX+99 é um endereço que está dentro do alcance do registrador baseL R9,=A(TABXX+99)OK! A literal que tem o endereço de TABXX+99 está dentro do alcance do registrador base

LTORG

Literais(com base)

TABXX DS 1000CL500






Instruções Áreas


Isto significa que:

LA R9,TABXX+100 ERRO!!! TABXX+100 é o 101º. Byte de TABXX, e, portanto, o primeiro a NÃO ser servido pelo registrador base.L R9,=A(TABXX+100) OK! A literal que tem o endereço de TABXX+100 está dentro do alcance do registrador base

LA R9,TABYY ERRO!!! TABYY é um endereço que NÃO está dentro do alcance do registrador baseL R9,=A(TABYY) OK! A literal que tem o endereço de TABYY está dentro do alcance do registrador base

LA R9,XYZ ERRO!!! XYZ é um endereço que NÃO está dentro do alcance do registrador baseL R9,=A(XYZ) OK! A literal que tem o endereço de XYZ está dentro do alcance do registrador base

LTORG

Literais(com base)

TABXX DS 1000CL500






Programas com 1 registrador base

Especificação ao montador

e

carga na execução



PROG START 0 USING *,3 LR 3,15 CARREGA PRIMEIRO E UNICO REG BASE* REG 3 FICA COM O ENDERECO DO ENTRY POINT* CARREGAMENTO COM LR MUITO USADO EM MVS

PROG START 0 USING *,3 BALR 3,0 CARREGA ENDERECO SEGUINTE AO BALR BCTR 3,0 SUBTRAI 1 BCTR 3,0 SUBTRAI MAIS 1* NESTE PONTO, O REG 3 ESTAH OK; * ELE TEM O ENDERECO DO ENTRY POINT

Carga do registrador base com o endereço do entry point com LR

Carga do registrador base com o endereço do entry point com BALR+BCTR+BCTR



Programas com 2 registradores base

Especificação ao montador

e

carga na execução



PROG START 0 USING *,3,4 LR 3,15 CARREGA PRIMEIRO REG BASE* REG 3 FICA COM O ENDERECO DO ENTRY POINT LA 4,4096(4) CARREGA NO 4 O QUE TEM NO 3 + 4096

Não! Por que? Porque o deslocamento máximo é de 4095 (X’FFF’) !!!Dá erro de montagem !

Pode fazer assim?

Carga do primeiro registrador base com o entry point address com LR

e

do segundo com entry point address + 4096 com LA



PROG START 0 USING *,3,4 LR 3,15 CARREGA PRIMEIRO REG BASE* REG 3 FICA COM O ENDERECO DO ENTRY POINT LA 4,1 CARREGA NRO 1 NO REG 4 LA 4,4095(4) SOMA 4095 * FICOU COM 4096 AR 4,3 SOMA O ENTRY POINT. * FICOU ENTRY POINT + 4096 * OU ENTRY POINT + X’001000’ * PRONTO ! R4 CARREGADO OK TAMBEM !

Então tem que fazer assim...


e

do segundo com entry point address + 4096 com LA+LA+AR



PROG START 0 USING *,3,4 LR 3,15 CARREGA PRIMEIRO REG BASE* REG 3 FICA COM O ENDERECO DO ENTRY POINT LA 4,4095 CARREGA NRO 4095 NO REG 4 LA 4,1(4) SOMA 1* FICOU COM 4096 AR 4,3 SOMA O ENTRY POINT. * FICOU ENTRY POINT + 4096 * OU ENTRY POINT + X’001000’ * PRONTO ! R4 CARREGADO OK TAMBEM !

Ou assim...


e

do segundo com entry point address + 4096 com LA+LA+AR



PROG START 0 USING *,3,4 LR 3,15 CARREGA PRIMEIRO REG BASE* REG 3 FICA COM O ENDERECO DO ENTRY POINT LA 4,1 CARREGA NRO 1 NO REG 4 LA 4,4095(3,4) SOMA 4095 + ENTRY POINT* FICOU COM ENTRY POINT + 4096 * OU ENTRY POINT + X’001000’ * PRONTO ! R4 CARREGADO OK TAMBEM !

Até assim...


e

do segundo com entry point address + 4096 com LA+LA




Assim...


e





Destre outro

jeitinho...


e




PROG START 0 USING *,3,4 LR 3,15 CARREGA PRIMEIRO REG BASE* REG 3 FICA COM O ENDERECO DO ENTRY POINT LA 4,PROG+4096 CARREGA “DIRETO” ENTRY POINT + 4096

Será que pode fazer

assim?

NÃO! Por que não?Porque o endereço PROG+40096 não está no alcance do primeiro base (R3), até então o único carregado corretamente. Dá erro de montagem.


e

do segundo com entry point address + 4096 com LA



PROG START 0 USING *,3,4 LR 3,15 CARREGA PRIMEIRO REG BASE* REG 3 FICA COM O ENDERECO DO ENTRY POINT L 4,=A(PROG+4096) CARREGA “DIRETO” ENTRY POINT + 4096

Nem assim?

DEPENDE ! O que está sendo carregado no R4 é o conteúdo da literal.Se a literal estiver FORA do alcance do PRIMEIRO REG BASE (R3), QUE É O ÚNICO PREPARADO ATÉ ENTÃO, então NÃO PODE, dá erro de montagem. (CASO 1)Se a literal estiver dentro do alcance do PRIMEIRO REG BASE (R3), QUE É O ÚNICO PREPARADO ATÉ ENTÃO, então PODE (CASO 2).


e

do segundo com entry point address + 4096 com L



CASO 1 : Literal FORA do alcance do PRIMEIRO REG BASE (R3), QUE É O ÚNICO PREPARADO. NÃO PODE! Dá erro de montagem.

PROG START 0 USING *,3,4 LR 3,15 L 4,=A(PROG+4096) ... (o L precisa do 2o base preparado, mas... ele prepara esse base;

então, dá erro de execução)

END (as literais são declaradas após o END)

... =A(PROG+4096)

Programa = 8k

Parte servida pelo 1o reg

base


base

Carga do primeiro registrador base com o entry point address com LR e




CASO 2 : Literal DENTRO do alcance do PRIMEIRO REG BASE (R3), QUE É O ÚNICO PREPARADO ATÉ ENTÃO, então PODE.

PROG START 0 USING *,3,4 LR 3,15 L 4,=A(PROG+4096) B PULA LTORG =A(PROG+4096) PULA ...

END (as outras literais são declaradas)

... =... =...

Programa = 8k

Parte servida pelo 1o reg base. Força que a literal fique nesta

parte


base

Carga do primeiro registrador base com o entry point address com LR e



THE END

Documents

1 Sumário Pag.Ant. Alberto Romano Schiesari – Assembler para Mainframes IBM