A apresentação está carregando. Por favor, espere

A apresentação está carregando. Por favor, espere

Assembler para Mainframes IBM

Apresentações semelhantes


Apresentação em tema: "Assembler para Mainframes IBM"— Transcrição da apresentação:

1 Assembler para Mainframes IBM

2 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

3 Sumário Arquitetura / alguns componentes Arquitetura mainframes IBM
Representação de dados Representação de instruções Linguagem Assembler Fluxo Jeitão de um programa Assembler Statement Elementos do montador assembler Tipos de statements Comandos ao Montador Assembler Instruções de máquina Dicas Instruções por grupo Instruções Macro-Instruções Apêndice - Links Apêndice – Sumário de instruções (por cod op) (por mnemônico) Apêndice - Alguns caracteres EBCDIC Alguns caracteres ASCII Apêndice - Questões Respostas Apêndice – Dicas de programação

4 Sumário Comandos Assembler (ordem alfabética) AMODE CCW CCW0 CCW1 CNOP
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 Não estão no escopo deste curso: AREAD, MACRO, MEXIT, MEND ACTR, AGO, AIF, ANOP, GBLA, GBLB, GBLC, LCLA, LCLB, LCLC, MHELP, MNOTE, SETA, SETB, SETC

5 Sumário 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

6 ARQUITETURA DE SISTEMAS

7 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

8 Arquitetura – Alguns componentes
Observar que... Mainframes e PC’s = CISC

9 Arquitetura – Alguns componentes
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

10 Arquitetura – Alguns componentes
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

11 Arquitetura – Alguns componentes
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).

12 Arquitetura – Alguns componentes
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] Programa Instruções Áreas F830B004C82F 1C 00

13 Arquitetura – Alguns componentes
Endereçamento (acesso) dos bytes de memória 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...)

14 Arquitetura – Alguns componentes
Endereçamento (acesso) dos bytes de memória 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)...

15 Arquitetura – Alguns componentes
 Capacidade de endereçamento dos bytes de memória Tamanho de memória; quantos “bits” tem a CPU do Mainframe?

16 Arquitetura – Alguns componentes
 Capacidade de endereçamento dos bytes de memória 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

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

18 Arquitetura – Alguns componentes
Execução de instruções pela CPU Qual o processo de execução das instruções?

19 Arquitetura – Alguns componentes
 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

20 Arquitetura – Alguns componentes
OUTROS componentes de arquitetura

21 Arquitetura – Alguns componentes
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?

22 Arquitetura Mainframes IBM

23 Arquitetura Mainframes IBM
Tributo A quem os mainframeiros devem os empregos ! Gene Myron Amdahl (1922-)

24 Arquitetura Mainframes IBM
Mainframes IBM : principais componentes da arquitetura CPU 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 FPR0 FPR2 FPR4 FPR6 4 Registradores de ponto flutuante – 8 bytes cada 1 Registrador especial de 8 bytes denominado PSW atual (Program Status Word) PSW etc... (cache...) Memória (RAM)

25 Arquitetura Mainframes IBM
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)

26 Arquitetura Mainframes IBM
Lay-out da PSW atual BC mode BYTE 0 BITS = máscaras de canal BIT = máscara para canais 6 e acima BIT = máscara externa BYTE 1 BITS = chave de proteção BIT = 0 = Basic Control Mode BIT = máscara de machine-check BIT = 1 = estado de wait BIT = 1 = estado de programa problema BYTES 2-3 (BITS 16-31) = Interruption code BYTE 4 BITS = ILC = Instruction length code BITS = CC = Condition code BITS = máscara de programa BYTES 5-7 (BITS 40-63) = Instruction address

27 Arquitetura Mainframes IBM
Lay-out da PSW atual EC mode BYTE 0 BIT = BIT = máscara de program-event recording BIT = BIT = BIT = BIT = translation mode BIT = máscara de I/O BIT = máscara externa BYTE 1 BITS = chave de proteção BIT = 1 = Extended Control Mode BIT = máscara de machine-check BIT = 1 = estado de wait BIT = 1 = estado de programa problema BYTE 2 BIT = BIT = BITS = CC = condition code BITS = 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ância BYTE 3 (BITS 24-31) = BYTE 4 (BITS 32-39) = BYTES 5-7 (BITS 40-63) = Instruction address

28 Arquitetura Mainframes IBM
Lay-out da PSW atual XA mode BYTE 0 BIT = BIT = máscara de program-event recording BIT = BIT = translation mode BIT = máscara de I/O BIT = máscara externa BYTE 1 BITS = chave de proteção BIT = BIT = máscara de machine-check BIT = 1 = estado de wait BIT = 1 = estado de programa problema BYTE 2 BIT = address space mode (junto c/ bit 5) BIT = BITS = CC = condition code BITS = 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ância BYTE 3 (BITS 24-31) = BYTE 4 BIT = 0 = 24 bit addressing = 1 = 31 bit addressing BYTE 4/5/6/7 (BITS 33-63) = Instruction address

29 Arquitetura Mainframes IBM
Lay-out da PSW atual ESA mode BYTE 0 BIT = BIT = máscara de program-event recording BIT = BIT = translation mode BIT = máscara de I/O BIT = máscara externa BYTE 1 BITS = chave de proteção BIT = BIT = máscara de machine-check BIT = 1 = estado de wait BIT = 1 = estado de programa problema BYTE 2 BIT = 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 = CC = condition code BITS = 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ância BYTE 3 (BITS 24-31) = BYTE 4 BIT = 0 = 24 bit addressing = 1 = 31 bit addressing BYTE 4/5/6/7 (BITS 33-63) = Instruction address

30 Arquitetura Mainframes IBM
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 etc.

31 Arquitetura Mainframes IBM
Mainframes IBM : interrupções por erro de programa (0Cx) Cod Razão 0008 OVERFLOW DE PONTO FIXO = A instrução faz alguma operação com um registrador geral e nele não cabe o resultado. 0009 DIVISÃO DE PONTO FIXO = Divisão em binário, divisor 0. 000A OVERFLOW DECIMAL = Numa operação entre campos em compactado, o campo de resultado não é suficientemente grande para conter o resultado. 000B DIVISÃO DECIMAL = Divisão em compactado com divisor 0. 000C OVERFLOW DE EXPOENTE = Para operações com números em ponto flutuante. 000D UNDERFLOW DE EXPOENTE = Para operações com números em ponto flutuante. 000E SIGNIFICÂNCIA = Para operações com números em ponto flutuante. 000F DIVISÃO EM PONTO FLUTUANTE = Para operações em ponto flutuante. Cod Razão 0001 OPERAÇÃO = O código de operação da instrução é inválido, isto é, não corresponde a nenhuma instrução executável. 0002 OPERAÇÃO PRIVILEGIADA = O programa tentou executar uma instrução privilegiada, isto é, que só pode ser executada em estado de supervisor. 0003 EXECUTE = Foi dada uma instrução Execute para outra instrução Execute. 0004 PROTEÇÃO = Uma instrução do programa tentou estragar uma área fora da sua partição. 0005 ENDEREÇAMENTO = Uma instrução do programa fez referência a endereço não existente. 0006 ESPECIFICAÇÃ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. 0007 DADOS = Os campos que uma instrução utiliza não estão no formato que deveriam estar.

32 Arquitetura Mainframes IBM
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

33 Arquitetura Mainframes IBM
Mainframes IBM : endereçamento 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...

34 Arquitetura Mainframes IBM
Base + Deslocamento Instruções para o Sr. Carteiro da Av. Marginal: Ir até o Restaurante Água Na Boca Andar mais 850 metros; então você chegou na 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 = Deslocamento

35 Arquitetura Mainframes IBM
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 !!!

36 Arquitetura Mainframes IBM
Base + Deslocamento : especificação (usa-se 2 bytes) x y Registrador base Deslocamento 3 5 A C x Registrador Base = 3 Deslocamento = 5AC Endereço = conteúdo do reg 3 + x’5AC’ D 8 x Registrador Base = 13 (D) Deslocamento = 08D Endereço = conteúdo do reg D + x’08D’

37 Arquitetura Mainframes IBM
Base + Deslocamento x y Registrador base Deslocamento Portanto: Deslocamento máximo = x’FFF’ = 4095

38 Arquitetura Mainframes IBM
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 B40 00002B40 4B40 00B2F02C 1A2 00B2F1CE 41A2 15 DB4 00000DB4 FDB4 0046B28C 114 0114 O conteúdo do registrador zero NÃO É levado em consideração para cálculo de endereço !!!

39 Arquitetura Mainframes IBM
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)

40 Arquitetura Mainframes IBM
Base + Deslocamento – Dicas de utilização O que é expressão? De novo! Cada pergunta! (veja mais adiante nas “cositas” do montador Assembler)

41 Arquitetura Mainframes IBM
Indexador + Base + Deslocamento Instruções para o Sr. Carteiro da Av. Marginal: Ir até o Restaurante Água Na Boca Andar mais 850 metros; então você chegou na vila Dentro 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

42 Arquitetura Mainframes IBM
Indexador + Base + Deslocamento Número binário contido num Registrador Geral (nesta hora “apelidado” de registrador base) Número hexadecimal que é o Endereço (na memória Real) + = Número hexadecimal de x’000’ até x’FFF’ (na instrução) “apelidado” de deslocamento Número binário contido num Registrador Geral (nesta hora “apelidado” de registrador indexador) Obs.: a caixinha tracejada indica que o número (endereço) NÃO ESTÁ num registrador geral e sim numa área interna da CPU !!!

43 Arquitetura Mainframes IBM
Indexador + Base + Deslocamento : especificação (usa-se 21/2 bytes) Registrador base Deslocamento Registrador Indexador x y z Registrador Indexador = 7 Registrador Base = 3 Deslocamento = 5AC Endereço = conteúdo do reg 7 + conteúdo do reg 3 + x’5AC’ 3 5 A C 7 F B x Registrador Indexador = 11 (B) Registrador Base = 5 Deslocamento = FAC Endereço = conteúdo do reg B + conteúdo do reg 5 + x’FAC’

44 Arquitetura Mainframes IBM
Indexador + Base + Deslocamento : especificação (usa-se 21/2 bytes) x y Registrador base Deslocamento z Registrador Indexador Portanto: Deslocamento máximo = x’FFF’ = 4095

45 Arquitetura Mainframes IBM
Indexador + Base + Deslocamento – Exemplos Reg Index : QUAL é Reg Index : Conteúdo Reg Base : 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 4 B40 00102B40 C4B40 00F4CAFE 10 000C8B00 1F0 000C8CF0 0A1F0 1A2 0000E1A2 441A2 15 00C42B06 002 00C42B08 FC002 O conteúdo do registrador zero NÃO É levado em consideração para cálculo de endereço !!!

46 Arquitetura Mainframes IBM
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

47 Arquitetura Mainframes IBM
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 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 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’ E’ Endereço de TABUFS Indexador+base+deslocamento = X’17C0A’ Endereço inicial da tabela : Símbolo = TABUFS (transformado pelo montador em base + deslocamento)

48 Arquitetura Mainframes IBM
Mainframes IBM : endereçamento X’ ’ X’ ’ X’ ’ X’ ’ X’ ’ X’ ’ X’ ’ X’ ’ X’ ’ X’ ’ X’000000A0’ X’000000B0’ X’000000C0’ X’000000D0’ X’000000E0’ X’000000F0’ Memória de 256 bytes

49 Arquitetura Mainframes IBM
Mainframes IBM : endereçamento * X’ ’ X’ ’ X’ ’ X’ ’ X’ ’ X’ ’ X’ ’ X’ ’ X’ ’ X’ ’ 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’ ’: Se o registrador 12 for usado como base e tiver, por exemplo x’ ’, 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)

50 Arquitetura Mainframes IBM
Mainframes IBM : endereçamento X’ ’ X’ ’ X’ ’ X’ ’ X’ ’ X’ ’ X’ ’ X’ ’ X’ ’ X’ ’ 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) *

51 Arquitetura Mainframes IBM
Mainframes IBM : endereçamento Byte de endereço x’ ’ : Base C (conteúdo x’ ’) + Deslocamento x’048’ Lembrar que DESLOCAMENTO MÁXIMO = x’FFF’ Ou seja O registrador C, enquanto tiver x’ ’ como conteúdo, só consegue ser usado como base para fazer referência aos endereços desde x’ ’ até x’00000FFF’.

52 Arquitetura Mainframes IBM
Mainframes IBM : endereçamento DESLOCAMENTO MÁXIMO = x’FFF’ Se uma instrução precisar endereçar 2 campos: O de endereço x’ ’ 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’ ’, e Ter outro registrador (o D, por exemplo) com o conteúdo x’ ’

53 Arquitetura Mainframes IBM
Mainframes IBM : endereçamento DESLOCAMENTO MÁXIMO = x’FFF’ O registrador base C (12) endereça o primeiro campo C048  Base C (com conteúdo x’ ’ + Deslocamento x’048’ O registrador base D (13) endereça o segundo campo DCB0  Base D (com conteúdo x’ ’ + Deslocamento x’CB0’ NÃO TEM JEITO DE numa única instrução, neste caso, usar só um registrador base.

54 Arquitetura Mainframes IBM
Mainframes IBM : endereçamento 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

55 Arquitetura Mainframes IBM
Mainframes IBM : endereçamento Usando (quase) todos os registradores como registradores base, NÃO SOBRA NENHUM (além do zero) ! Cuidado !

56 Arquitetura Mainframes IBM
Mainframes IBM : endereçamento Só isso? E se o programa for maior?

57 Arquitetura Mainframes IBM
Mainframes IBM : endereçamento 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.

58 Arquitetura Mainframes IBM
Mainframes IBM : endereçamento Memória de 60K bytes 56K 52K 48K 44K 40K 36K 32K 28K 24K 20K 16K 12K 8K 4K 0K Programa R3 com x’ ’ R4 com x’ ’ R5 com x’ ’ R6 com x’ ’ R7 com x’ ’ R3 com x’ ’ R4 com x’ ’ R5 com x’ ’ R6 com x’ ’ R7 com x’ ’ R3 com x’0000A000’ R4 com x’0000B000’ R5 com x’0000C000’ R6 com x’0000D000’ R7 com x’0000E000’

59 Arquitetura Mainframes IBM
Uso de registradores : idéia / sugestão / dica

60 Arquitetura Mainframes IBM
Uso de registradores : idéia / sugestão / dica Reg Uso 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 5 6 7

61 Arquitetura Mainframes IBM
Registradores : idéia / sugestão / dica Reg Uso 8 Usar como work 9 10 11 12 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

62 Representação de dados

63 Representação de dados
Dados alfanuméricos Representação em formato caracter, padrão EBCDIC  Dados numéricos Representaçã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)

64 Representação de dados alfanuméricos
Dados alfanuméricos Representação em formato caracter, padrão EBCDIC

65 Representação de dados alfanuméricos
Representação em formato caracter, padrão EBCDIC 1 byte por caracter Ex.: representar palavra “ALBERTO” Para efeito de comparação, em ASCII é A L B E R T O C1 D3 C2 C5 D9 E4 D6 A L B E R T O 41 4C 42 45 52 54 4F

66 Representação de dados alfanuméricos
Representação em formato caracter, padrão EBCDIC 1 byte por caracter Ex.: representar palavra “Alberto” Para efeito de comparação, em ASCII é A l b e r t o C1 93 82 85 99 A4 96 A 1 b e r t o 41 6C 62 65 72 74 6F

67 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

68 Representação de dados numéricos
Representação em formato DECIMAL ZONADO byte por algarismo, máximo 16 bytes = máximo 16 algarismos Cada 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.

69 Representação de dados numéricos
Representação em formato DECIMAL ZONADO F1 F2 F3 Representação do número 123 F1 F2 D3 Representação do número -123 Atenção !!! : se for impresso (ou visualizado em caracter) esta configuração aparece como a letra “L”

70 Representação de dados numéricos
Representação em formato DECIMAL ZONADO Representação do número 123 em um campo de 5 bytes F0 F1 F2 F3 Representação do número -123 em um campo de 5 bytes F0 F1 F2 D3 Atenção !!! : se for impresso (ou visualizado em caracter) esta configuração aparece como a letra “L”

71 Representação de dados numéricos
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ções aritméticas somente são feitas em binário) 2  A máquina só trabalha esses números como números INTEIROS.

72 Representação de dados numéricos
Representação em formato DECIMAL COMPACTADO 02 3F Número 23 : precisa 2 bytes 02 3C 02 3D Número - 23 : precisa 2 bytes Atenção !!! : se for impresso (ou visualizado em caracter) estas configurações poder aparecer como “outros” caracteres

73 Representação de dados numéricos
Representação em formato DECIMAL COMPACTADO 12 3F Representação do número 123 12 3C 12 3D Representação do número -123 Atenção !!! : se for impresso (ou visualizado em caracter) estas configurações poder aparecer como “outros” caracteres

74 Representação de dados numéricos
Representação em formato DECIMAL COMPACTADO Número 123 num campo de 5 bytes 00 12 3C Número num campo de 5 bytes 00 12 3D Atenção !!! : se for impresso (ou visualizado em caracter) estas configurações poder aparecer como “outros” caracteres

75 Representação de dados numéricos
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 : ; número negativo : 1 MAS 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.

76 Representação de dados numéricos
Representação em formato BINÁRIO PONTO FIXO 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 a 4 Bilhões (2G) Salário, Código de peça, Código de cliente a 8 Quintilhões (9Exa) Receitas de empresas, População mundial, distâncias astronômicas a

77 Representação de dados numéricos
Representação em formato BINÁRIO PONTO FIXO Exemplo de números e complementos: Número +123 em binário = Número –123 em binário = Por quê? 4 - 1 ----- 3 -1 ---- 2 - 1 1 -2 -3 Etc... -122 -123

78 Representação de dados numéricos
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 torna-se 1  Somar 1  Preencher à esquerda com 1’s até completar uma halfword, fullword ou doubleword Exemplo: supor o número decimal –123; é  Converter o número positivo correspondente para binário  Inverter: 1 torna-se 0 e 0 torna-se  Somar  preencher à esquerda com 1’s para completar uma halfword, fullword ou doubleword F F F F F F F F F F F F F F F F

79 Representação de dados numéricos
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 FF A  Somar A B  X’7B’ é o hexadecimal equivalente ao decimal  Portanto, o número desejado é o decimal -123

80 Representação de dados numéricos
Representação em formato BINÁRIO PONTO FIXO Representação do número 123 Em (halfword) X’007B’ Em (fullword) X’ B’ Em (doubleword) X’ B’ Atenção !!! : as configurações dos bytes, se visualizado em caracter, podem aparecer como “outros” caracteres

81 Representação de dados numéricos
Representação em formato BINÁRIO PONTO FIXO Representação do número -123 Em (halfword) X’FF85’ Em (fullword) X’FFFFFF85’ Em (doubleword) X’FFFFFFFFFFFFFF85’ Atenção !!! : as configurações dos bytes, se visualizado em caracter, podem aparecer como “outros” caracteres

82 Representação de dados numéricos
Representação em formato BINÁRIO PONTO FLUTUANTE Sorry... Não é escopo deste curso...

83 Representação de instruções

84 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’ ’ a b‘ ’) 4 bytes : códigos de operação entre x’40’ e x’BF’ (b’ ’ a b‘ ’’) 6 bytes : códigos de operação entre x’C0’ e x’FF’ (b’ ’ a b‘ ’)

85 Representação de instruções
Principais formatos de instruções RR – (em princípio) 2 operandos, ambos em registradores  RX – 2 operandos: em registrador em memória : especificação de endereço indicando Indexador + [ Base + Deslocamento ]  RS – 3 operandos, 2 em registradores e 1 em memória registradores (pode ser um “range”/faixa) em memória : especificação de endereço indicando [ Base + Deslocamento ]  SI – 2 operandos, ambos em memória em memória imediata = 1 único byte que é parte da própria instrução (ou seja, não precisa especificar endereço) 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 ]

86 Representação de instruções
Principais formatos de instruções RR – (em princípio) 2 operandos, ambos em registradores x CO Registrador 1o. operandox Registrador 2o. operandox código operação R R2 5 E F x Código de operação = X’05’ Registrador 1o operando = X’E’ (registrador 14) Registrador 2o operando = X’F’ (registrador 15)

87 Representação de instruções
Principais formatos de instruções  RX – 2 operandos: 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 R X2 B D2 Base + Deslocamento do 2o. operando D D2 4 5 E x 3 C 2 8 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’

88 Representação de instruções
Principais formatos de instruções  RS – 3 operandos, 2 em registradores e 1 em memória registradores (pode ser um “range”/faixa) em memória : especificação de endereço indicando [ Base + Deslocamento ] x CO Registrador 1o. operandox Registrador 3o. operandox código operação R R3 B D2 Base + Deslocamento do 2o. operando D D2 9 8 E C x D 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’

89 Representação de instruções
Principais formatos de instruções  SI – 2 operandos, ambos em memória em memória imediata = 1 único byte que é parte da própria instrução em memória : especificação de endereço indicando [ Base + Deslocamento ] x CO Operando Imediato (2o. Operando) código operação I2 B D1 Base + Deslocamento do 1o. operando D D1 9 2 5 C x 6 D 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’

90 Representação de instruções
Principais formatos de instruções  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 L B D1 Base + Deslocamento do 1o. operando D D1 B D2 D D2 do 2o. operando Tamanho dos 2 operandos - 1 4 F x 3 B 9 6 2 A D 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’

91 Representação de instruções
Principais formatos de instruções  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 L2 B D1 Base + Deslocamento do 1o. operando D D1 B D2 D D2 do 2o. operando Tamanho 1o. Operando - 1 Tamanho 2o. Operando - 1 F 8 4 3 7 E 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’

92 Representação de instruções
Exercício EP Somente veja o resultado aqui depois de tentar resolver

93 Linguagem Assembler LINGUAGEM ASSEMBLER

94 Fluxo do montador LOADER Storage SYSLIB SYSIN SYSUT1 IEV90 SYSPUNCH
Macros/Copys SYSIN Fonte SYSUT1 Work IEV90 SYSPUNCH Objeto SYSGO SYSPRINT List LOADER Storage SYSLIN Objeto SYSIN Control stmts SYSLIB Outras entradas SYSUT1 Work IEWL SYSPRINT List SYSLMOD Executável LINKLIB

95 Jeitão de um programa Assembler

96 Jeitão de um programa Assembler
Pode ser assim... Programa Instruções Áreas LOAD POINT = ENTRY POINT

97 Jeitão de um programa Assembler
Ou assim... Programa Áreas Instruções LOAD POINT ENTRY POINT

98 Jeitão de um programa Assembler
Assim também... Programa I LOAD POINT = ENTRY POINT A

99 Jeitão de um programa Assembler
Até com o estilo da casa da sogra... Programa LOAD POINT = ENTRY POINT I A

100 Jeitão de um programa Assembler
Ou da sogra da casa... Programa LOAD POINT A I ENTRY POINT

101 Jeitão de um programa Assembler
Lembrar que um programa reentrante pode ser assim... Programa P1 An .... A3 A2 A1 Instruções de P1 ( manipulando A1, e, concorrentemente ou paralelamente, manipulando A2, manipulando A3, etc... manipulando An) O programa P1 na verdade é : Áreas de P1 (ou A1 ou A2 ou etc) +

102 Jeitão de um programa Assembler
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...

103 Statement STATEMENT Assembler

104 Operandos e Comentários
Statement Posição : Se tiver *, statement inteiro é comentário Posições 1 a 8: Símbolo Posições 10 a 14: Código da Instrução Posições 16 a 71: Operandos e Comentários Posição : Indicador de Continuação Posições 73 a 80: Identificação e Sequência * ESTE STATEMENT TODINHO EH UM COMENTARIO COMPLETA MVC ARIMP,=CL133'b' COMENTARIO = LIMPAR ARIMP OI *+5,X’F0’ COMENTARIO = FORCE BRANCH AQUI 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

105 Começando a sentir o cheirinho do jeitão do Assembler...
Statement Começando a sentir o cheirinho do jeitão do Assembler... 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,R TAMANHO DA COMMAREA STH R3,TWLENGTH EM TWLENGTH SPACE 2

106 Statement + Cheirinho (amarelo = Instr, azul = áreas, branco = comandos ao montador) ... COPY COVER CWA DSECT USING *,R COPY CWAREA COPY TADSECT COMMAREA DSECT USING *,R COPY TWAREA DFHEISTG DSECT DFHEISTG DFHEIEND EJECT T TITLE 'TABELA DE TRANSACOES DE SERAG - NUMERO 131' SPACE SEG131 DFHEIENT CODEREG=(7,9),DATAREG=(10,11),EIBREG= B BEGIN SALTA CONSTANTES DC C'5785-XAW COPYRIGHT IBM BRASIL 1985' DC CL16'***SEG131,3.2***' DC CL24'***ULT.MANUT.19/07/2001*' BEGIN L R12,DFHEICAP ENDERECO DA COMMAREA L R8,TWSVTERM ENDERECO DA AREA DE TERMINAIS L R13,TWSVCWA ENDERECO DA CWA volta pro jeitão ...

107 Statement + Cheirinho (amarelo = Instr, azul = áreas, branco = comandos ao montador) ... * ================================================================== * * LOGICA COMUM PARA LOCALIZAR UMA ENTRADA NA TABELA DE TRANSACOES * * ================================================================== * LA R2,TRLT TRLTLOOK CLI 0(R2),X'FF' FIM DA TABELA ? BE ERRO TRLT NAO ESTA NA TABELA CLC TWDBL(6),0(R2) CODIGO TRANSACAO ESTA NA TABELA ? BE TRL SIM SR R15,R LIMPA REGISTRADOR IC R15,40(R2) BYTE DE COMPRIMENTO DA ENTRADA N R15,=F'127' ELIMINA BIT DE MAIS ALTA ORDEM-X'7F' AR R2,R INCREMENTA POINTER DA TABELA B TRLTLOOK E PESQUISA NOVAMENTE TRL0100 MVC TWTRLT,0(R2) MOVE TRLT PARA TWA EXIT EXEC CICS RETURN ERRO LA R2, CODIGO ERRADO OI TWSW,X'01' LIGA SWITCH DE CANCELAMENTO LA R3, TAMANHO DA WORKAREA DE MENSAGENS LA R1,TWMSG ENDERECO WORKAREA DE MENSAGENS STC R2,0(R1) MOVE NUM.MENSAGEM PARA WORKAREA B EXIT RETORNA LTORG

108 Statement + Cheirinho (amarelo = Instr, azul = áreas, branco = comandos ao montador) ... * ================================================================== * * TRANSACOES VALIDAS * * ================================================================== * TRLT TRLT CODE=000301, X TIT='CHEQUE SACADO ', X MAPN='NAO', X PTCM=01, X SPEC=14, X MNEM='CHS' TRLT CODE=000302, X TIT='SAQUE AVULSO ', X MAPN='NAO', X PTCM=02, X SPEC=14, X MNEM='SAV' END SEG

109 Umas “cositas” do montador Assembler

110 “Cosita” 1 = Location Counter
Montador Assembler “Cosita” 1 = Location Counter

111 Location Counter : há 1 para cada Section (Control e Dummy)
Montador Assembler Location Counter : há 1 para cada Section (Control e Dummy) É um contador que começa com x’ ’ 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) BLOCO1 EQU * DS CL4096 ORG BLOCO1 DS CL1024 A DS CL16 B DS CL16 40 * DC S(A) DC S(B) C DC S(C,D,E,F) 00042C DC S(G,H,I,J) 45 * D20F MVC A,B 00043A D MVC C,D D22B C C MVC E,F D MVC G,H 00044C D MVC I,J

112 “Cosita” 2 = “Listagem gerada (algumas das coisas listadas também
Montador Assembler “Cosita” 2 = “Listagem gerada (algumas das coisas listadas também fazem parte do programa-objeto)

113 External Symbol Dictionary :
Montador Assembler External Symbol Dictionary : Lista de elementos que devem ser tratados pelo Linkage Editor e Loader EXTERNAL SYMBOL DICTIONARY SYMBOL TYPE ID ADDR LENGTH LD ID FLAGS PROGDEMO SD AF FORA ER 0002 Z LD SUBROT ER 0003

114 Montador Assembler Listagem do programa
LOC OBJECT CODE ADDR1 ADDR2 STMT SOURCE STATEMENT 49 * VOU MUDAR PARA PRINT DATA PRINT DATA 00003B C1D3C2C5D9E3D DC CL7'ALBERTO' C1D3C2C5D9E3D65C DC CL8'ALBERTO*' 00004A C1D3C2C5D9E3C9D DC CL10'ALBERTINHO' C8D6 54 * VOU RESTAURAR O DEFAULT PRINT NODATA C1D3C2C5D9E3D DC CL7'ALBERTO' 00005B C1D3C2C5D9E3D65C DC CL8'ALBERTO*' C1D3C2C5D9E3C9D DC CL10'ALBERTINHO' 59 * 60 * PRINT ON/OFF

115 Relocation Dictionary : mais trabalho para o Linkage Editor e o Loader
Montador Assembler Relocation Dictionary : mais trabalho para o Linkage Editor e o Loader RELOCATION DICTIONARY POS.ID REL.ID FLAGS ADDRESS C B9 C C C C C C C A4 C A8 A46

116 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). Atributo de tamanho Símbolos (labels) Endereços CROSS REFERENCE SYMBOL LEN VALUE DEFN REFERENCES AAALIN A ANO AE6 0319 ARIMP C A A A A A C A A A C BYTE ****UNDEFINED**** BYTEON FF 0085 CAMPO A CAMPO ****DUPLICATE**** COCIENTE DATA AE2 0316 .

117 Se você usa um símbolo que vai ser convertido para endereço
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.

118 Montador Assembler Diagnósticos THE FOLLOWING STATEMENTS WERE FLAGGED
DIAGNOSTIC CROSS REFERENCE AND ASSEMBLER S THE FOLLOWING STATEMENTS WERE FLAGGED 30 STATEMENTS FLAGGED IN THIS ASSEMBLY 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 CARDS FROM SYSLIB 572 LINES OUTPUT CARDS OUTPUT

119 Montador Assembler “Cosita” 3 = Expressões

120 Se for convertido o formato será base + deslocamento.
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.

121 - Termos auto-definidos (decimal, binário, caracter ou hexadecimal)
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

122 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]

123 Montador Assembler EXPRESSÕES
Expressão O valor resultante corresponde a LPOUP+3 quarto byte de LPOUP (Supor endereço de LPOUP = x’000A000C’; o valor da expressão LPOUP+3 é x’000A000F’) Esta expressão : 2 termos: 1 símbolo [LPOUP] e 1 termo auto-definido (decimal) [3] LPOUP o. byte de LPOUP (Supor endereço de LPOUP = x’000A000C’; o valor da expressão LPOUP+15’ é x’000A001B’) 1 termo auto-definido (decimal) [15]

124 Montador Assembler EXPRESSÕES
Expressão O valor resultante corresponde a 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’ o. byte de LPOUP (Supor endereço de LPOUP = x’000A000C’; o valor da expressão LPOUP+C’F’’ é x’000A00D2’) 1 termo auto-definido (caracter) [C’F’] Lembre que C’F’ = X’C6’ X’000A000C’ + X’C6’ = X’000A00D2’

125 Montador Assembler EXPRESSÕES
Expressão O valor resultante corresponde a 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 382 X’000A000C’ X’32’ + X’100’ + X’C’ + X’40’ = X’000A018A’

126 Montador Assembler EXPRESSÕES
Expressão O valor resultante corresponde a WAREA+L’WAREA 1o. byte depois de (toda) WAREA Esta 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) 1 termo decimal auto-definido [1] WAREA+L’WAREA-1 último byte de WAREA Esta expressão : 3 termos: 1 símbolo (WAREA) e

127 Montador Assembler EXPRESSÕES
Expressão O valor resultante corresponde a WAREA+L’FIXDLEN+1000 Esta 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 bytes. O valor da expressão WAREA+L’FIXDLEN corresponde ao primeiro byte após toda a área WAREA ( WAREA + tamanho de FIXDLEN + 1000)

128 Montador Assembler EXPRESSÕES
Expressão O valor resultante corresponde a 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’

129 Montador Assembler EXPRESSÕES
Expressão O valor resultante corresponde a *+1 byte seguinte onde está o loc. Counter Esta 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) 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]

130 “Cosita” 4 = Referências explícitas e implícitas
Montador Assembler “Cosita” 4 = Referências explícitas e implícitas Nos operandos

131 Referências explícitas e implícitas
Montador Assembler Referências explícitas e implícitas Registradores: sempre referenciados explicitamente AR 1,6 LR R5,R14 LR 5,14 LR R5, Sacanagem... LR 5,R Sacanagem...

132 Referências explícitas e implícitas
Montador Assembler Referências explícitas e implícitas Memória: referenciada explicitamente ou implicitamente Instruções RX : Referência explícita: op reg1,d2(x2,b2) L ,12(13) L R14,12(R13) SE TIVER EQUATES ST 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 ,SAVE14 L ,SAVEAREA+12 ST 7,WSALVA(7) ST 7,WSAVAREA+(7*4)

133 Referências explícitas e implícitas
Montador Assembler Referências explícitas e implícitas Memória: referenciada explicitamente ou implicitamente 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ão2 LM 14,12,SAVEAREA+12 STM 14,12,SARVA

134 Referências explícitas e implícitas
Montador Assembler Referências explícitas e implícitas Memória: referenciada explicitamente ou implicitamente Instruções SI : Referência explícita: op desloc1(base1),imediato2 MVI 10(R12),C’*’ XI 0(15),X’FF’ OI 15(R8),X’80’ Referência implícita: op expressão1,imediato2 MVI FLAGS+77,C’*’ XI TOGGLE,X’FF’ OI PRINTED,X’80’

135 Referências explícitas e implícitas
Montador Assembler Referências explícitas e implícitas Memória: referenciada explicitamente ou implicitamente 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)

136 Referências explícitas e implícitas
Montador Assembler Referências explícitas e implícitas Memória: referenciada explicitamente ou implicitamente 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)

137 Referências explícitas e implícitas
Montador Assembler Referências explícitas e implícitas Memória: referenciada explicitamente ou implicitamente 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’

138 Referências explícitas e implícitas
Montador Assembler Referências explícitas e implícitas Memória: referenciada explicitamente ou implicitamente 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)

139 Montador Assembler Instruções: - Instruções ou comandos ao montador - Instruções de máquina - Macro-instruções

140 Instruções ou comandos ao montador
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

141 Instruções de máquina (algumas)
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

142 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, WRITE GETMAIN, FREEMAIN, ATTACH, DETACH etc... Da IBM (específicas CICS, DB2, etc...) DFHMSD, DFHMDF, etc...

143 Comandos ao Montador Comandos ao montador

144 Comandos Assembler (ordem alfabética)
Comandos ao montador 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 Estes não estão no escopo deste curso): AREAD, MACRO, MEXIT, MEND ACTR, AGO, AIF, ANOP, GBLA, GBLB, GBLC, LCLA, LCLB, LCLC, MHELP, MNOTE, SETA, SETB, SETC

145 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

146 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

147 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 24 AMODE RMODE 24 AMODE RMODE 24 AMODE ANY RMODE 24 RMODE AMODE 24 RMODE ANY AMODE 31 Comandos

148 Comandos ao montador – CCW’s
CCW / CCW0 / CCW1 (Channel Command Word) Sorry. Não faz parte do escopo deste curso. Comandos

149 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 ,4 0,8 2,8 4,8 6,8 0,4 2,4 0,4 2,4 Comandos

150 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 . A DS CL3 B DS CL4 END Comandos

151 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

152 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

153 Comandos ao montador - CSECT
CSECT (Control Section - Seção de Controle) PROG CSECT . END É o mesmo que PROG START (Em ambos os casos) há um Location Counter (para a section PROG1). Comandos

154 Comandos ao montador - CSECT
CSECT (Control Section - Seção de Controle) PROG1A START . 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 Comandos

155 Comandos ao montador - CSECT
CSECT (Control Section - Seção de Controle) A CSECT CSECT A = CSECT B = 2 CSECT C = B CSECT . C CSECT A CSECT END Há um Location Counter para a seção PROG1A, outro para a PROG1B, e um terceiro para a PROG1C. Comandos

156 Comandos ao montador - CSECT
CSECT (Control Section - Seção de Controle) O slide anterior mostra situação semelhante a esta: A START CSECT A = CSECT B = 2 CSECT C = B CSECT . C CSECT A CSECT END Há um Location Counter para a seção PROG1A, outro para a PROG1B, e um terceiro para a PROG1C. Comandos

157 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

158 Comandos ao montador - DC
DC (Define Constant) Veja descrição detalhada Comandos

159 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,R R16]] Sendo que R R16 é a relação dos registradores que não devem mais ser base. Ex: DROP ,8 Se não for especificado nenhum operando, todos os registradores base serão desassinalados. Comandos

160 Comandos ao montador - DS
DS (Define Storage) Veja descrição detalhada Comandos

161 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

162 Comandos ao montador - DSECT
DSECT (Dummy Section - Seção Simulada) CSN START . DSN DSECT A DS CL2 B DS CL20 C DS D DS CL10 CSN 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

163 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 F . DISPLAC DC Q(CONST) Comandos

164 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

165 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

166 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. PROG START . ROTINA EQU * ENTRY ROTINA END PROG START CONST DC A(ROTINA) EXTRN ROTINA Comandos

167 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

168 Comandos ao montador - EQU
EQU (Equate - Igualar) Ex: R EQU ... 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

169 Comandos ao montador - EQU
EQU (Equate - Igualar) 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 PAGOU Ao 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

170 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 PROG START . ROUTINE EQU * ENTRY ROUTINE END * ROTINA EH REFERENCIADA AQUI EM PROG2 PROG START CONST DC A(ROUTINE) EXTRN ROUTINE Comandos

171 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 16 O 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 ,70,71 Comandos

172 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

173 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

174 Comandos ao montador - LOCTR
LOCTR (Multiple Location Counters) PROGRAMA Loc.Counter Ativo PGM CSECT PGM1 pedaço 1 PGM1 pedaço 1 X LOCTR X pedaço 1 AREA1 DS CL X pedaço 1 AREA2 DS CL X pedaço 1 PGM LOCTR PGM1 pedaço 2 PGM1 pedaço 2 Y LOCTR Y pedaço 1 TAB DS CL Y pedaço 1 TAB DS CL Y pedaço 1 PGM LOCTR 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 PGM LOCTR PGM1 pedaço 4 LTORG PGM1 pedaço 4 END OBJETO GERADO CSECT PGM1 (com “7 pedaços”) PGM1 = (pedaço 1 do loc counter PGM1) + (pedaço 2 do loc counter PGM1) + (pedaço 3 do loc counter PGM1) + (pedaço 4 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

175 Comandos ao montador - 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 , 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

176 Comandos ao montador - LTORG
MVC E,DSEKCOP3 IEV044 *** ERROR *** UNDEFINED SYMBOL 00047C D B MVC G,DSEKCPO4 D B02C C MVC I,DSEKCPO5 D20A B037 B MVC DSEKCPO6,DSEKCPO7 63 * 00048E 41C0 7FFF FFF LA 12,Z-1 LA 12,Z+1 IEV034 *** ERROR *** ADDRESSABILITY ERROR LA 12,Z 00049A 58C0 34A A L ,=A(Z) 00049E D20F AC AC MVC A,=C'*' 69 * 0004A LTORG , 0004A =A(Z) 0004AC 5C =C'*' 73 * 0004AD 00 0004AE D20F E E MVC A,=C'*' 0004B LA 12,Z 0004B8 58C0 40E E L ,=A(Z) Comandos

177 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

178 Comandos ao montador - 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.Counter ANTES DEPOIS 0AB84C AB94C TABNUM DC X'FF' 0AB94C AB93C ORG TABNUM+240 0AB93C AB DC X'00' 0AB AB94C ORG Comandos

179 Comandos ao montador - 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

180 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 é fornecida OFF A listagem não é fornecida GEN 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

181 Comandos ao montador - 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 a 2 : brancos pos a 8 : CATALR pos a 10 : brancos pos a 13 : MOD pos a 80 : brancos Comandos

182 Comandos ao montador - 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

183 Comandos ao montador - 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: CATALR MOD Comandos

184 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

185 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 24 AMODE RMODE 24 AMODE RMODE 24 AMODE ANY RMODE 24 RMODE AMODE 24 RMODE ANY AMODE 31 Comandos

186 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 Comandos

187 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: PROG START X'308' START OBS: - Se o comando START não for colocado, é assumido START 0. Comandos

188 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: P 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

189 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,R 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 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 ). 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

190 Comandos ao montador - 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

191 Declaração de áreas Declaração de áreas Comandos

192 Declaração de áreas 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

193 (pode ser o DS em Assembler, ou um campo declarado sem VALUE em Cobol.
Declaração de áreas 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. LOADER ??????????? Executável Memória Instruções Áreas com conteúdo (DC) Áreas sem conteúdo (DS) Comandos

194 [nome] DC [ad]tipo[at]ci [nome] DS [ad]tipo[at][ci]
Declaração de áreas Sintaxe geral: Ad = atributo de duplicação: quantas áreas definir Tipo = 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 tamanho Ci = conteúdo inicial [nome] DC [ad]tipo[at]ci [nome] DS [ad]tipo[at][ci] Comandos

195 [nome] DC [ad]tipo[at]ci
Declaração de áreas 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

196 [nome] DS [ad]tipo[at][ci]
Declaração de áreas 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 CL ad=omitido;tipo=C;at=L132;ci=omitido * Declara 1 área de 132 bytes CONTLIN DS PL 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

197 Área COM conteúdo inicial
Declaração de áreas DC - Define Constant Área COM conteúdo inicial Comandos

198 Constantes p/operando
Declaração de áreas Tipos de conteúdo TIPO Tamanho assumido 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 várias D->E X’0’ E 0 a F ½ byte B B’0’ 0 e 1 1 bit F 4 bytes FullWord 1 a 8 (1) + - 0 a 9 (2) (4) H 2 bytes HalfWord (3) (4) P Byte 1 a 16 ½ byte (5) Z C’0’ 8 bytes DoubleWord -x- A 1 a 4 expressão Y 1 a 2 S 2 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

199 Declaração de áreas – DC tipo C
DC tipo C (caracter) [nome] DC [ad]C[at]ci Comandos

200 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 CL1'*' C DC CL1'*' C5C DC CL1'*' C DC CL2'*' C40 DC CL2'*' C405C40 DC C'ABC' C1C2C3 DC CL1'ABC' C1 DC C'A&&B' C150C2 DC C'ZE''S' E9C57DE2 DC C'''' D Comandos

201 Declaração de áreas – DC tipo X
DC tipo X (hexadecimal) [nome] DC [ad]X[at]ci Comandos

202 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 XL1'0B' B DC X'5C' C5C5C DC XL3'5C' C DC XL2'AB0C14' 0C14 DC X'1A2' A2 DC X'00A,B,5A8' 000A0B05A8 Comandos

203 Declaração de áreas - DC tipo B
DC tipo B (binário) [nome] DC [ad]B[at]ci Comandos

204 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' DC BL2' ' 0089 DC B'0101' DC BL2'1' DC B'1' DC B'1,00101,001' Comandos

205 Declaração de áreas - DC tipo F
DC tipo F (fullword) [nome] DC [ad]F[at]ci Comandos

206 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' A DC F'+138' A DC F'-138' FFFFFF76 DC F'4,392' Comandos

207 Declaração de áreas - DC tipo H
DC tipo H (halfword) [nome] DC [ad]H[at]ci Comandos

208 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' A DC H'+138' A DC H'-138' FF76 DC H'4,392' Comandos

209 Declaração de áreas - DC tipo P
DC tipo P (Packed - compactado) [nome] DC [ad]P[at]ci Comandos

210 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' C DC P'10' C DC P'-345,45,21.6,7' 345D045C216C7C DC P'0' C DC P'+66' C DC PL3'1' C DC PL2'43556' C DC P'1' C1C1C Comandos

211 Declaração de áreas - DC tipo Z
DC tipo Z (zonado) [nome] DC [ad]Z[at]ci Comandos

212 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 Z'1' C1C1C1 Comandos

213 Declaração de áreas - DC tipo A
DC tipo A (address - endereço) [nome] DC [ad]A[at]ci Comandos

214 Declaração de áreas - DC tipo A
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) CAMPO DC 3A(*-CAMPO) DC A(TCABC+28*52) DC A(FIM-COMECO) DC A(1,2,3) Comandos

215 Declaração de áreas - DC tipo A
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) CAMPO DC 3A(*-CAMPO) DC A(TCABC+28*52) DC A(FIM-COMECO) DC A(1,2,3) Comandos

216 Declaração de áreas - DC tipo A
Exemplo: (parte de um programa) 0008A0 47F0 38AC AC B IHB0004A 008A IHB0004 EQU * 0008A B DC A(ENTRA) 0008A B DC A(SAI) 008AC IHB0004A EQU * (parte do RELOCATION DICTIONARY do programa) RELOCATION DICTIONARY POS.ID REL.ID FLAGS ADDRESS C B9 C C C C C C C A4 C A8 A46 A48 A54 A56 Comandos

217 Declaração de áreas - DC tipo A
Exemplo: ... VVV DC A(VALIDS) VALIDS DC C’AEIOUaeiou’ Programa fonte (rotina VALIDAR; supor que endereço de VALIDS seja X’00001BC0’) 00001BC0 C1C5C9D6E A4 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’ 0000BBC0 Comandos

218 Declaração de áreas - DC tipo A
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’ Comandos

219 Declaração de áreas - DC tipo Y
DC tipo Y (endereço com 2 bytes) [nome] DC [ad]Y[at]ci Comandos

220 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) DC Y(TCABC+28*52) DC Y(FIM-COMECO) DC S(*,*+2,*+4) 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

221 Declaração de áreas - DC tipo S
DC tipo S (endereço base + deslocamento) [nome] DC [ad]S[at]ci Comandos

222 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

223 Declaração de áreas - DC tipo V
DC tipo V (endereço externo) [nome] DC [ad]V[at]ci Comandos

224 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

225 Declaração de áreas - DC tipo Q
DC tipo Q (deslocamento em DSECT externa) [nome] DC [ad]Q[at]ci Comandos

226 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

227 Declaração de áreas - DS
DS - Define Storage Área SEM conteúdo inicial Comandos

228 Declaração de áreas - DS
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 CL8 Comandos

229 Declaração de áreas - DS
O comando DS admite atributo de duplicação zero (0). Ex: ARLEIT DS CL80 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

230 Declaração de áreas - DS
O atributo de duplicação zero é bastante usado para efetuar alinhamento: CPOCOM4 DS F BYTE DS CL1 BYTE DS CL1 BYTE DS CL1 BYTE 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

231 Declaração de áreas - DS
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. Delta Gama (no name) Beta Alfa Comandos

232 Declaração de áreas - DS
Outro uso do comando DS é para fazer redefinição de áreas (atribuir nomes diferentes a mesmas áreas físicas). Veja os exemplos a seguir: AREA DS CL80 A1PART1 DS CL10 A1PART2 DS CL10 A1PART3 DS CL10 A1PART4 DS CL10 A1PART5 DS CL10 A1PART6 DS CL10 A1PART7 DS CL10 A1PART8 DS CL10 ORG , VOLTA PARA MESMO ENDEREÇO DE AREA1 AREA DS CL80 A2PART1 DS CL20 A2PART2 DS CL20 A2PART3 DS CL20 A2PART4 DS CL20 AREA DS CL80 A3PART1 DS CL5 A3PART2 DS CL5 A3PART3 DS CL20 A3PART4 DS CL30 A3PART5 DS CL3 A3PART6 DS CL4 A3PART7 DS CL13 Comandos

233 Instruções de máquina INSTRUÇÕES DE MÁQUINA

234 Instruções de máquina - Dicas

235 Instruções de máquina – Dicas 1
1 - STORE = DE registrador PARA memória 2 - LOAD = DE memória PARA registrador 3 - xxxxR = instrução RR, com 2 operandos são registradores Ex. AR,SR, LR, MR, DR, LTR etc 4 - 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, etc 5 - xxxxP = instrução SS, operandos em decimal compactado, trabalha com 2 tamanhos Ex. AP, SP, MP, DP, ZAP 6 - xxxxH = instruction RX, usa registrador e um campo de memória (halfword) Ex. LH, SH, AH

236 Instruções de máquina – Dicas 2
7 - Nxxxx = instrução booleana AND Ex. NI, NC, N, NR 8 - Oxxxx = instrução booleana OR Ex. OI, OC, O, OR 9 - Xxxxx = instrução booleana Exclusive OR Ex. XI, XC, X, XR 10 - 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 Instruções de STORE e CVD: símbolo instrução operando_emissor,operando_receptor

237 Instruções de máquina – Dicas 3
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, MVCIN O 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, DP O 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).

238 Instruções de máquina – Dicas 4
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 : observe numa tabela EBCDIC que a diferença entre as letras minúsculas e maiúsculas é sempre x’40’, ou seja b’ ’; 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: é o decimal 254. Ligando o último bit: ele se transforma no decimal 255

239 Instruções de máquina – Dicas 4
15 – Uso de instruções Booleanas: 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 : observe numa tabela EBCDIC que a diferença entre as letras minúsculas e maiúsculas é sempre x’40’, ou seja b’ ’; 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: é o decimal 255. Zerando o último bit: ele se transforma no decimal 254

240 Instruções de máquina – Dicas 4
15 – Uso de instruções Booleanas: 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 minuscmaiusc e maiuscminusc (máscara ) : letra x1xx xxxx é transformada em x0xx xxxx letra x0xx xxxx é transformada em x1xx xxxx (c) Transformar números binário pares em ímpares e vice-versa (máscara ) : 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

241 Instruções de máquina – Dicas 4
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 bytes Números binários de 31 bits + 1 bit para sinal para números com 4 bytes Nú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 bytes Números binários de 32 bits para números com 4 bytes Números binários de 64 bits para números com 8 bytes

242 Instruções de máquina (ordem alfabética)
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

243 (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

244 Instruções de máquina Dicas para saber qual instrução usar para mover um dado de um lugar para outro Origem Destino Instrução Memória MVC Registrador LR Memória (zonado) Memória (compactado) PACK UNPK (eventualmente +MVZ ou OI) ST Memória (binário) L Registrador (binário) CVB CVD (endereço) LA [ ou L reg,=A(endereço) ] Memória (com endereço) LA + ST [ ou L + ST ]

245 Instruções de máquina - A
A (Add - Somar) Código de máquina 5A (Instrução RX) Condition code 00 Resultado = 0 01 Resultado < 0 10 Resultado > 0 11 Overflow Interrupções Possíveis 0005,0008 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 o operando antes registrador 1o operando depois 2o operando depois A 5,=F'259' BF.D 00.00.C0.D A 7,FULL D A 7,4(2,8) FF.FF.FE 07.FF.FF.FF A 7,4(2) FF.FF.FF FF.FF.FF.FF 07.FF.FF.FE FF.FF.FF.FF A 7,4(,8) FF.FF.FF.FF FF.FF.FF.FF FF.FF.FF.FF Sumario Instr.Máq.

246 Instruções de máquina - AH
AH (Add Halfword – Somar Halfword) Código de máquina 4A (Instrução RX) Condition code 00 Resultado = 0 01 Resultado < 0 10 Resultado > 0 11 Overflow Interrupções Possíveis 0005,0008 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 o operando antes registrador 1o operando depois o operando depois AH ,=H'259' B.C C.C AH ,HALF D D A D AH ,4(2,8) (decimal ) (decimal –30584) (decimal ) AH ,4(2) (decimal ) (decimal ) (decimal ) Sumario Instr.Máq.

247 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 sinal 01 Resultado <> 0, não perde sinal 10 Resultado = 0, perde sinal 11 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 o operando antes registrador 1o operando depois o operando depois AL ,=F'259' AL ,FULL B0.C4.E 00.B0.C4.E AL ,4(2,8) 7F.FF.FF.FF AL ,4(2) FF.FF.FF.FF AL ,4(,8) Sumario Instr.Máq.

248 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 sinal 01 Resultado <> 0, não perde sinal 10 Resultado = 0, perde sinal 11 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 o operando antes registrador 1o operando depois o operando depois ALR 7, B0.C4.E 00.B0.C4.E ALR 8, F.FF.FF.FF ALR 10, FF.FF.FF.FF ALR 10, Sumario Instr.Máq.

249 Instruções de máquina - AP
AP (Add Packed – Somar Compactado) Código de máquina FA (Instrução SS – L1 e L2) Condition code 00 Resultado = 0 01 Resultado < 0 10 Resultado > 0 11 Overflow 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 depois CPOB C C CPOA C C AP CPOA,CPOA CPOA C C Veja mais exemplos a seguir: Sumario Instr.Máq.

250 Instruções de máquina - AP
AP (Add Packed – Somar Compactado) Código de máquina FA (Instrução SS – L1 e L2) Condition code 00 Resultado = 0 01 Resultado < 0 10 Resultado > 0 11 Overflow Interrupções Possíveis 0001,0004,0005,0007,000A Supor os operandos com tamanho e conteúdo conforme mostrado na linha “antes” 1o operando antes o operando antes 1o operando depois o operando depois AP HOWMANY,=P'1‘ F C C C AP ARL+2(5),ARL+7(2) C C C C AP TOTAL,2(3,7) C D C D AP 4(3,8),WALFA F C C C AP 7(07,8),14(2,3) C 00.5C C 00.5C AP GRANDTOT,SMALLTOT C C C Sumario Instr.Máq.

251 Instruções de máquina - AR
AR (Add register – Somar registradores) Código de máquina 1A (Instrução RR) Condition code 00 Resultado = 0 01 Resultado < 0 10 Resultado > 0 11 Overflow Interrupções Possíveis 0008 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 o operando antes 1o operando depois o operando depois AR 7, FF.FF AR 2, FF.FF FF.FF 00.01.FF.FE FF.FE Sumario Instr.Máq.

252 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 Interrupções Possíveis Nenhuma 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: BAL carrega o endereço da instrução RETINS no registrador 9 BAL ,ROUTINE BAL ,WRTHDR BAL ,2(5) BAL (,8) BAL ,2(5,8) ... BAL 9,ROUTINE RETINS EQU * continuação ROUTINE ST 9,SAVEREG9 .... L 9,SAVEREG9 BR 9 Salva o registrador 9 (endereço de retorno) em SAVEREG9 Restaura endereço de retorno Retorna para RETINS Sumario Instr.Máq.

253 Instruções de máquina - BALR
BALR (Branch And Link Register – Desviar e ligar registrador) Código de máquina 05 (Instrução RR) Condition code Não é alterado Interrupções Possíveis Nenhuma 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: BALR carrega o endereço da instrução RETINS no registrador 14 BALR ,0 BALR ,15 ... LA 15,ROUTINE BALR 14,15 RETINS EQU * continuacao ROUTINE ST 14,SAVEREG .... L 14,SAVEREG BR 14 Salva registrador 14 (endereço de retorno) em SAVEREG LA carrega o endereço da instrução ROUTINE no registrador 15 Restaura endereço de retorno Retorna para RETINS Sumario Instr.Máq.

254 Instruções de máquina - BAS
BAS (Branch And Save – Desviar e salvar) Código de máquina 4D (Instrução RR) Condition code Não é alterado Interrupções Possíveis Nenhuma 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 BAS carrega o endereço da instrução RETINS no registrador 9 (bytes 1,2,3) e coloca zeros no byte 0 dele ... BAS 9,ROUTINE RETINS EQU * continuation ROUTINE ST 9,SAVEREG .... L 9,SAVEREG BR 9 Salva registrador 9 (endereço de retorno) em SAVEREG Restaura endereço de retorno Retorna para RETINS Sumario Instr.Máq.

255 Instruções de máquina - BASR
BASR (Branch And Save Register – Desviar e salvar registrador) Código de máquina 0D (Instrução RR) Condition code Não é alterado Interrupções Possíveis Nenhuma 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 BASR zera byte 0 do registrador 14 e carrega o endereço da instrução RETINS nos bytes 1,2,3 do registrador 14 ... LA 15,ROUTINE BASR 14,15 RETINS EQU * continuação ROUTINE ST 14,SAVEREG .... L 14,SAVEREG BR 14 LA carrega o endereço da instrução ROUTINE no registrador 15 Restaura endereço de retorno Salva registrador 14 (endereço de retorno) em SAVEREG Retorna para RETINS Sumario Instr.Máq.

256 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) Condition code Não é alterado Interrupções Possíveis Nenhuma 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 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) LA carrega o endereço da instrução ROUTINE no regiostrador 15 LA 15,ROUTINE ICM 15,8,AMODE BASSM 14,15 RETINS EQU * continuation ... ROUTINE ST 14,SAVEREG .... L ,SAVEREG BR 14 ICM coloca addressability mode nos bits do registrador 15 Restaura endereço de retorno Salva registrador 14 (endereço de retorno) em SAVEREG Retorna para RETINS Sumario Instr.Máq.

257 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.

258 Instruções de máquina - BC
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 ( ); é 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.

259 Instruções de máquina - BC
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 > BC 2 ou BCR 2 Aritmeticas BM ou BMR Desvia se R < BC 4 ou BCR 4 BZ ou BZR Desvia se R = 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 BC 1 ou BCR 1 BM ou BMR Desvia se misturados BC 4 ou BCR 4 BZ ou BZR Desvia se todos 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.

260 Instruções de máquina - BC
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.

261 Instruções de máquina - BC
BC (Branch on condition – Desviar condicionalmente) BC (Branch on Condition – Desviar na Condição) Código de máquina 47 (Instrução RX) Condition code Não é alterado Interrupções Possíveis Nenhuma 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.

262 Instruções de máquina - BC
BC (Branch on condition – Desviar condicionalmente) BC (Branch on Condition – Desviar na Condição) Código de máquina 47 (Instrução RX) Condition code Não é alterado Interrupções Possíveis Nenhuma 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 ,VOLTA É o mesmo que BE VOLTA Neste 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 (2) mesmo que BC 8,0(2) BE (,4) mesmo que BC 8,0(,4) BE (2,4) mesmo que BC 8,0(2,4) Sumario Instr.Máq.

263 Instruções de máquina - BC
BC (Branch on condition – Desviar condicionalmente) BC (Branch on Condition – Desviar na Condição) Código de máquina 47 (Instrução RX) Condition code Não é alterado Interrupções Possíveis Nenhuma Outros exemplos: B READ Mesmo que BC 15,READ BNH LOOP Mesmo que BC 13,AGAIN BNL LOOP 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.

264 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) Condition code Não é alterado Interrupções Possíveis Nenhuma 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.

265 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) Condition code Não é alterado Interrupções Possíveis Nenhuma BCR ,15 É o mesmo que BER Neste caso, será efetuado o desvio se o condition code tiver 00. Veja os exemplos a seguir: BCR , mesmo que BHR R10 BR mesmo que BCR 15,R7 BNER mesmo que BCR 7,R10 BLR mesmo que BCR 4,R15 Sumario Instr.Máq.

266 Instruções de máquina - BCT
BCT (Branch on CounT – Desviar se contador [zero]) Código de máquina 46 (Instrução RX) Condition code Não é alterado Interrupções Possíveis Nenhuma   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: ... L 11,=F’200’ AGAIN CLC 0(3,5),CODE BE FOUND BCT 11,AGAIN NOTFND EQU * .... FOUND EQU * L carrega no registrador 11 o número de vezes que o loop deve ser repetido BCT 5,AGAIN BCT 2,0(4,7) BCT 2,0(4) BCT 2,0(,7) 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 Sumario Instr.Máq.

267 Instruções de máquina - BCTR
BCTR (Branch on CounT Register – Desviar se contador [zero] [para] registrador) Código de máquina 06 (Instrução RX) Condition code Não é alterado Interrupções Possíveis Nenhuma 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: L carrega no registrador 11 o número de vezes que o loop deve ser repetido LA 15,AGAIN L 11,=F’200’ AGAIN CLC 0(3,5),CODE BE FOUND ... BCTR 11,15 NOTFND EQU * .... FOUND EQU * BCTR 2,7 BCTR 4,0 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 Sumario Instr.Máq.

268 Instruções de máquina - BSM
BSM (Branch and Set Mode – Desviar e posicionar modo) Código de máquina 0B (Instrução RR) Condition code Não é alterado Interrupções Possíveis Nenhuma O bit 32 da PSW é carregado no bit 0 do registrador primeiro operando (os bits 1 a 31 permanecem inalterados), e depois 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.

269 Instruções de máquina - BXH
BXH (Branch on indeX High – Desviar se indexador maior) Código de máquina 86 (Instrução RX) Condition code Não é alterado Interrupções Possíveis Nenhuma 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.

270 Instruções de máquina - BXH
BXH (Branch on indeX High – Desviar se indexador maior) Código de máquina 86 (Instrução RX) Condition code Não é alterado Interrupções Possíveis Nenhuma 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; BXH 7,9,8(4) R7 = R9 + R7; Se R7 > R9 Desvia para instrução * Com endereço = [ (conteúdo R4) + x’008’ ] Sumario Instr.Máq.

271 Instruções de máquina - BXH
BXH (Branch on indeX High – Desviar se indexador maior) Código de máquina 86 (Instrução RX) Condition code Não é alterado Interrupções Possíveis Nenhuma 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 NEXTITEM TABLSEEN ... 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 tabela R8 = tamanho dos itens da tabela R9 = endereço do último elemento NOTFOUND : toda tabela varrida; item desejado não achado 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 Sumario Instr.Máq.

272 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) Condition code Não é alterado Interrupções Possíveis Nenhuma 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.

273 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) Condition code Não é alterado Interrupções Possíveis Nenhuma 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; BXLE 7,9,8(4) R7 = R9 + R7; Se R7 <= R9 Desvia para a instrução * Cujo endereço é [ (conteúdo R4) + x’008’ ] Sumario Instr.Máq.

274 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) Condition code Não é alterado Interrupções Possíveis Nenhuma 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,NEXTITEM NOTFOUND ... TABLSEEN ... 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 tabela R8 = tamanho dos itens da tabela R9 = endereço do último elemento NOTFOUND : toda tabela varrida; item desejado não achado 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 Sumario Instr.Máq.

275 Instruções de máquina - C
C (Compare) Código de máquina 59 (Instrução RX) Condition code 00 1ºoperando = 2ºoperando 01 1ºoperando < 2ºoperando 10 1ºoperando > 2ºoperando 11 O condition code nunca fica em 11 após um C Interrupções Possíveis 0005 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 ,CPO C ,=F'0' C ,=A(TABELA+430) C ,2(4) C ,2(,4) C ,2(7,4) Sumario Instr.Máq.

276 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º operando 01 1º e 2º operandos são diferentes, o 2º operando foi colocado no 1º operando 10 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.

277 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º operando 01 1º e 2º operandos são diferentes, o 2º operando foi colocado no 1º operando 10 Nunca fica em 10 após um CDS 11 Nunca fica em 11 após um CDS Interrupções Possíveis 0004,0005,0006 CDS 4,8,DW Antes: R4/R5 00.BF.C CC.A0.00 R8/R9 7D.48.C DW BF.C CC.A0.00 Depois: R4/R5 00.BF.C CC.A0.00 DW 7D.48.C CDS 4,8,DW Antes: R4/R5 00.CC.DD.EE.FF.FF.FF.FF R8/R9 7D.48.C DW BF.C CC.A0.00 Depois: R4/R5 00.BF.C CC.A0.00 Sumario Instr.Máq.

278 Instruções de máquina - CH
CH (Compare Halfword) Código de máquina 49 (Instrução RX) Condition code 00 1ºoperando = 2ºoperando 01 1ºoperando < 2ºoperando 10 1ºoperando > 2ºoperando 11 O condition code nunca fica em 11 após um CH Interrupções Possíveis 0005 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 o. operando = R9; 2o. operando = campo CPO CH 8,=H'0' o. 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) o. operando = R1; 2o. operando = halfword com endereço = * Valor do registrador indexador R4 + 0[registrador base omitido] + x’2’ CH 1,2(,4) o. operando = R1; 2o. operando = halfword com endereço = * Valor do registrador base R4 + 0[reg. indexador omitido] + x’2’ CH 1,2(7,4) o. operando = R1; 2o. operando = halfword com endereço = * Valor do registrador base R4 + valor do reg. indexador R7 + x’2’ Sumario Instr.Máq.

279 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ºoperando 01 1ºoperando < 2ºoperando 10 1ºoperando > 2ºoperando 11 O condition code nunca fica em 11 após um CL Interrupções Possíveis 0005 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 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.

280 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ºoperando 01 1ºoperando < 2ºoperando 10 1ºoperando > 2ºoperando 11 O condition code nunca fica em 11 após um CLC Interrupções Possíveis 0005 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 (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.

281 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ºoperando 10 1ºoperando > 2ºoperando 11 Nunca o condition code fica em 11 após um CLCL Interrupções Possíveis 0005,0006 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 ,8 R1=registrador primeiro operando= registrador 2 R1+1= registrador 3 R2=registrador segundo operando= registrador 8 R2+1= registrador 9 Sumario Instr.Máq.

282 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ºoperando 10 1ºoperando > 2ºoperando 11 Nunca o condition code fica em 11 após um CLCL Interrupções Possíveis 0005,0006 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.

283 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ºoperando 10 1ºoperando > 2ºoperando 11 Nunca o condition code fica em 11 após um CLCL Interrupções Possíveis 0005,0006 Exemplo: Exemplo: LA 2,BUFEROUT LA 3,12000 LA 8,BUFERIN LA 9,20000 ICM 9,B'1000',C' ' AGAIN CLCL 8,9 BE EQUALS DIFFS EQU * ... EQUALS EQU * LA carrega no registrador 2 o endereço de BUFEROUT CLCL executes the compare between a byte field (BUFEROUT) and a 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 Sumario Instr.Máq.

284 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ºoperando 01 1ºoperando < 2ºoperando 10 1ºoperando > 2ºoperando 11 O condition code nunca fica em 11 após um CLI Interrupções Possíveis 0005 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 = Compara com zeros binários CLI BYTE,B' ' Instrução de máquina = 95.F0.b1d1.d1d1 Compara com caracter zero CLI NOP+1, Instrução de máquina = 95.F0.b1d1.d1d1 Compara com caracter zero Sumario Instr.Máq.

285 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 é menor 10 Campo selecionado do 1ºoperando é maior 11 Nunca o condition code fica em 11 após um CLM Interrupções Possíveis 0005 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 byte M3 (máscara) = 1/2 byte E2 (endereço base+deslocamento do segundo operando) = 2 bytes 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 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 ,B'1011',ARCOMP Neste 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.

286 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ºoperando 01 1ºoperando < 2ºoperando 10 1ºoperando > 2ºoperando 11 O condition code nunca fica em 11 após um CLR Interrupções Possíveis Nenhuma 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, “string” de 32 bits do registrador 4 comparado com o “string’ de 32 bits do registrador 5 CLR 8, “string” de 32 bits do registrador 8 comparado com o “string’ de 32 bits do registrador 13 Sumario Instr.Máq.

287 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ºoperando 01 1ºoperando < 2ºoperando 10 1ºoperando > 2ºoperando 11 O condition code nunca fica em 11 após um CP Interrupções Possíveis 0005,0007 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’ C’ 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.

288 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ºoperando 01 1ºoperando < 2ºoperando 10 1ºoperando > 2ºoperando 11 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.

289 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º operando 01 1º e 2º operandos são diferentes, o 2º operando foi colocado no 1º operando 10 Nunca fica em 10 após um CS 11 Nunca fica em 11 após um CS Interrupçõ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,FW Antes: R5 00.BF.C R8 7D.48.C FW 00.BF.C4.20 Depois: R5 00.BF.C R8 7D.48.C FW 7D.48.C0.00 Outro exemplo: CS 5,8,FW Antes: R5 00.BF.C R8 7D.48.C FW 00.FF.EE.DD Depois: R5 00.FF.EE.DD R8 7D.48.C FW 00.FF.EE.DD Sumario Instr.Máq.

290 Instruções de máquina - CVB
CVB (ConVert to Binary – Converter para binário) Código de máquina 4F (Instrução RX) Condition code Não é alterado 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 o operando antes 1o operando depois o operando depois CVB 8,DOUBLE BC.4F.CA D FF.FF.FC D * o operando = DOUBLE CVB 8,0(5,9) FF.FF.FF.FF C C * Endereço 2o operando = indexador 5 + base 9 + X’0’ CVB 8,0(,9) FF.FF.FF.FF F FF F * Endereço 2o operando = indexador 0 + base 9 + X’0’ CVB 8,0(5) FF.FF.FF.FF C FF C * Endereço 2o operando = indexador 5 + base 0 + X’0’ Sumario Instr.Máq.

291 Instruções de máquina - CVD
CVD (ConVert to Decimal – Converter para decimal [compactado]) Código de máquina 4E (Instrução RX) Condition code Não é alterado Interrupções Possíveis 0004,0005 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 o operando antes 1o operando depois o operando depois CVD 8,DOUBLE C * o operando = DOUBLE CVD 8,0(5,9) FF.FF.FF.FF FB.EC.44.CC.F0.F1 FF.FF.FF.FF D * Endereço 2o operando = indexador 5 + base 9 + X’0’ CVD 8,0(,9) BA.76.FE.54.DC.32.B9 C * Endereço 2o operando = indexador 0 + base 9 + X’0’ CVD 8,0(5) AA.AA C 00.00.AA.AA C * Endereço 2o operando = indexador 5 + base 0 + X’0’ Sumario Instr.Máq.

292 Instruções de máquina - D
D (Divide) Código de máquina 5D (Instrução RX) Condition code Não é alterado Interrupções Possíveis 0005,0006,0008 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 ,CPOA Neste caso, temos: Dividendo : Regs. 6 e 7 juntos ; Divisor : CPOA ; Quociente : Reg. 7 ; Resto : Reg. 6 Outros 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 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.

293 Instruções de máquina - DP
DP (Divide Packed – Dividir compactado) Código de máquina FD (Instrução SS – L1 e L2) Condition code Não é alterado 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.

294 Instruções de máquina - DP
DP (Divide Packed – Dividir compactado) Código de máquina FD (Instrução SS – L1 e L2) Condition code Não é alterado 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 o operando antes 1o operando depois o operando depois DP FLDA,FLDB C C C.00.0C C DP FLDA,FLDB C C C.00.1C C DP VALUE,=P'5' C 5C C.2C 5C Sumario Instr.Máq.

295 Instruções de máquina - DR
DR (Divide Register – Dividir registradores) Código de máquina 1D (Instrução RR) Condition code Não é alterado Interrupções Possíveis 0006,0009 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 positivo Sinal do resto = Sinal do dividendo Ex: 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, 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, Quociente: Registrador 7 = 12; Resto: Registrador 6 = 4 Sumario Instr.Máq.

296 Instruções de máquina - ED
ED (Edit - Editar) Código de máquina DE (Instrução SS – L) Condition code 00 Último Campo = 0 01 Último Campo < 0 10 Último Campo > 0 11 O condition code nunca fica em 11 após o ED Interrupções Possíveis 0004,0005,0007 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.

297 Instruções de máquina - ED
ED (Edit - Editar) Código de máquina DE (Instrução SS – L) Condition code 00 Último Campo = 0 01 Último Campo < 0 10 Último Campo > 0 11 O condition code nunca fica em 11 após o ED Interrupções Possíveis 0004,0005,0007 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.

298 Instruções de máquina - ED
ED (Edit - Editar) Código de máquina DE (Instrução SS – L) Condition code 00 Último Campo = 0 01 Último Campo < 0 10 Último Campo > 0 11 O condition code nunca fica em 11 após o ED Interrupções Possíveis 0004,0005,0007 · 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 outro · Quando, 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.

299 Instruções de máquina - ED
ED (Edit - Editar) Código de máquina DE (Instrução SS – L) Condition code 00 Último Campo = 0 01 Último Campo < 0 10 Último Campo > 0 11 O condition code nunca fica em 11 após o ED Interrupções Possíveis 0004,0005,0007 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.

300 Instruções de máquina - ED
ED (Edit - Editar) Código de máquina DE (Instrução SS – L) Condition code 00 Último Campo = 0 01 Último Campo < 0 10 Último Campo > 0 11 O condition code nunca fica em 11 após o ED Interrupções Possíveis 0004,0005,0007 Observe que o b minúsculo indica espaço em branco. MVC ARIMP+5(10),MODELO ED ARIMP+5(10),TOTAL ... MODELO DC X' B B2020' Antes: TOTAL C ARIMP+5(10) B B.20.20   b b b b , 4 5 Depois: TOTAL C ARIMP+5(10) F1.F2.F3.6B.F4.F5 b b b b , 4 5   Outros Exemplos do ED: ED (5,7),CPO ED ARIMP+17(8),ISDRT ED (12,9),2(10) Sumario Instr.Máq.

301 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 = 0 01 Último Campo < 0 10 Último Campo > 0 11 O condition code nunca fica em 11 após o EDMK Interrupções Possíveis 0004,0005,0007 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.

302 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 Interrupções Possíveis 0003,0005,0006 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 ,=F'22' EX ,MVC . MVC MVC ,(0,12),=CL256' ' O move será executado com tamanho 23 Sumario Instr.Máq.

303 Instruções de máquina - IC
IC (Insert Character – Inserir caracter) Código de máquina 43 (Instrução RX) Condition code Não é alterado Interrupções Possíveis 0005 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 o operando antes 1o operando depois o operando depois IC 4,BYTE C B B B IC 8,=C'K' C D2 D D2 IC 11,=HL1'125' C 7D C.2C 7D Sumario Instr.Máq.

304 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 o operando antes 1o operando depois o operando depois ICM 5,B'1010',TWOBYTES A.BC 9A.00.BC A.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.

305 Instruções de máquina - IPM
IPM (Insert Program Mask – Inserir máscara de programa) Código de máquina B222 (Instrução RRE) Condition code Não é alterado Interrupções Possíveis Nenhuma Os bits (terceiro byte) e (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 C A 1C A Sumario Instr.Máq.

306 Instruções de máquina - L
L (Load - Carregar) Código de máquina 58 (Instrução RX) Condition code Não é alterado Interrupções Possíveis 0005 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 o operando antes 1o operando depois o operando depois L 7,FULL FE.DC.BA L 14,SALVA FF.FF.FF.FD FF.FF.FF.FD FF.FF.FF.FD L 11,=F'125' D D D Outros exemplos:  L ,0(10) L ,0(,11) L ,0(10,11) L ,=F'200' Sumario Instr.Máq.

307 Instruções de máquina - LA
LA (Load Address – Carregar endereço) Código de máquina 41 (Instrução RX) Condition code Não é alterado Interrupções Possíveis Nenhuma 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 A.C B nao usado 00.0B B nao usado LA 5,FLD F A nao usado 00.A0.0F A nao usado LA 5,FLD+17(9) F A 00.A0.0F A LA 5,2(9,3) A 00.A A LA 5, C8 nao usado nao usado C nao usado nao usado Sumario Instr.Máq.

308 Instruções de máquina - LA
LA (Load Address – Carregar endereço) Código de máquina 41 (Instrução RX) Condition code Não é alterado Interrupções Possíveis Nenhuma 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, F.FF não usado não usado F.FF não usado não usado LA 5,4095(3) F.FF 00.0A não usado 00.0A.8F.FF A não usado LA 5,4095(3,9) F.FF 00.0A 00.0A A Sumario Instr.Máq.

309 Instruções de máquina - LCR
LCR (Load Complement Register – Carregar complemento de registrador) Código de máquina 13 (Instrução RR) Condition code 00 Resultado = 0 01 Resultado < 0 10 Resultado > 0 11 Overflow Interrupções Possíveis 0008 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 o operando antes 1o operando depois o operando depois LCR 4, FF.FF.FF.FC FF.FF.FF.FC LCR 4, FF.FF.FF.FE Sumario Instr.Máq.

310 Instruções de máquina - LH
LH (Load Halfword) Código de máquina 48 (Instrução RX) Condition code Não é alterado Interrupções Possíveis 0005 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 o operando antes 1o operando depois o operando depois LH 5,FLD A.B4 FF.FF.8A.B A.B4 LH 8,HWORD FF.FF.FF.FF A.B4  A.B A.B4 Mais exemplos: LH ,HALF LH ,0(10) LH ,0(,11) LH ,0(10,11) LH ,=H'200' Sumario Instr.Máq.

311 Instruções de máquina - LM
LM (Load Multiple – Carregar múltiplos [registradores]) Código de máquina 98 (Instrução RX) Condition code Não é alterado Interrupções Possíveis 0005 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 ,1,SALVA Reg Reg Reg 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 ,7,2(10) Sumario Instr.Máq.

312 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 = 0 01 Resultado < 0 10 Nunca o condition code fica em 10 após um LNR 11 Nunca o condition code fica em 10 após um LNR Interrupções Possíveis Nenhuma 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 o operando antes 1o operando depois o operando depois LNR 4, FF.FF.FF.FC FF.FF.FF.FE FF.FF.FF.FC LNR 4, FF.FF.FF.FE LNR 4, Sumario Instr.Máq.

313 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 = 0 01 Nunca o condition code fica em 1 após um LPR. 10 Resultado > 0 11 Overflow Interrupções Possíveis 0008 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 o operando antes 1o operando depois o operando depois LPR 4, FF.FF.FF.FC FF.FF.FF.FC LPR 4, LPR 4, FF Sumario Instr.Máq.

314 Instruções de máquina - LR
LR (Load Register – Carregar registrador) Código de máquina 18 (Instrução RR) Condition code Não é alterado Interrupções Possíveis Nenhuma 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 o operando antes 1o operando depois o operando depois LR 4, FF.FF.FF.FC FF.FF.FF.FC FF.FF.FF.FC LR 4, LR 4, Sumario Instr.Máq.

315 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 = 0 01 Resultado < 0 10 Resultado > 0 11 Nunca o condition code fica em 10 após um LTR Interrupções Possíveis Nenhuma 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 o operando antes 1o operando depois o operando depois LTR 4, FF.FF.FF.FC FF.FF.FF.FC FF.FF.FF.FC LTR 4, LTR 4, Sumario Instr.Máq.

316 Instruções de máquina - M
M (Multiply - Multiplicar) Código de máquina 5C (Instrução RX) Condition code Não é alterado Interrupções Possíveis 0005,0006 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 ] A M 6,=F'256' Multiplicando: Reg 7; Multiplicador: 256; Resultado: Regs 6 e 7 juntos FF FC FF M 6,4(2,8) Multiplicando: Reg 7; Endereço multiplicador: Indexador 2 + Base 8 + X’4’; Resultado: Registradores 6 e 7 juntos A A Sumario Instr.Máq.

317 Instruções de máquina - M
M (Multiply - Multiplicar) Código de máquina 5C (Instrução RX) Condition code Não é alterado Interrupções Possíveis 0005,0006 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 C 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 AA.AA B 6C DE Sumario Instr.Máq.

318 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 Interrupções Possíveis 0006,0040 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.

319 Instruções de máquina - MH
MH (Multiply Halfword – Multiplicar halfword) Código de máquina 4C (Instrução RX) Condition code Não é alterado Interrupções Possíveis 0005 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 o operando antes Registrador 1o operando depois 2o operando depois MH 5,=H'4' Multiplicando: Registrador 5; Multiplicador: literal 4; Resultado: Registrador 5 A 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’ ’, pega X’0000’ ]; Resultado: Registrador 5 [CUIDADO! metade da direita com não é pega! ] Sumario Instr.Máq.

320 Instruções de máquina - MP
MP (Multiply Packed – Multiplicar compactado) Código de máquina FC (Instrução SS – L1 e L2) Condition code Não é alterado 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 o operando antes 1o operando depois o operando depois C C   C C C C   C C (erro! Precisaria ter 3 dígitos em zero à esquerda em CPOA) Sumario Instr.Máq.

321 Instruções de máquina – MR
MR (Multiply Register – Multiplicar registradores) Código de máquina 1C (Instrução RR) Condition code Não é alterado Interrupções Possíveis 0006 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 ] A AA.BB.CC FF.FF.FF 00.99.AA.BB FF.FF.FF Sumario Instr.Máq.

322 Instruções de máquina - MVC
MVC (MoVe Character) Código de máquina D2 (Instrução SS - L) Condition code Não é alterado Interrupções Possíveis 0004,0005  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 depois CPOB C1.C2.C3 C1.C2.C3 CPOA C4.C5.C6 C1.C2.C3 O 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 o operando antes 1o operando depois o operando depois MVC WA+5(3),WR E5.C1.D3 E5.C1.D E5.C1.D3 MVC WOUT,WIN C C C MVC NICKNAM,=C'SMAIL' C3.D9.E E2.D4.C1.C9.D3 E2.D4.C1.C9.D3 E2.D4.C1.C9.D3 Sumario Instr.Máq.

323 Instruções de máquina - MVC
MVC (MoVe Character) Código de máquina D2 (Instrução SS - L) Condition code Não é alterado Interrupções Possíveis 0004,0005 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 o operando antes 1o operando depois o operando depois MVC WA(5),=CL5' ' 5C.5C.5C.5C.5C 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 quinto MVC inicial para o primeiro byte à esquerda: MVC WA(1),=C' ' C.??.??.??.?? antes 40.??.??.??.?? depois Sumario Instr.Máq.

324 Instruções de máquina - MVC
MVC (MoVe Character) Código de máquina D2 (Instrução SS - L) Condition code Não é alterado Interrupções Possíveis 0004,0005 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.??.??.?? ??.??.?? 2o byte: ??.??.?? ??.??.?? ??.?? ??.?? 3o byte: ??.?? ??.?? ?? ?? 4o byte: ?? ?? Ou, melhor ainda: 1o byte: 40.??.??.??.?? Antes 40.40.??.??.?? Depois 2o byte: ??.??.?? Antes ??.?? Depois 3o byte: ??.?? Antes ?? Depois 4o byte: ?? Antes Depois Sumario Instr.Máq.

325 Instruções de máquina - MVCIN
MVCIN (MoVe Character Inverted – Mover [invertido] caracter) Código de máquina E8 (Instrução SS – L) Condition code Não é alterado Interrupções Possíveis 0001,0004,0005 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 o operando antes 1o operando depois o operando depois MVCIN A(3),B C4.C5.C C1.C2.C3 C3.C2.C 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.

326 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 é menor 10 Tamanho do 1º operando é maior 11 Movimento não efetuado Interrupções Possíveis 0004,0005,0006 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 ,8 Ver detalhes no próximo slide. Sumario Instr.Máq.

327 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 é menor 10 Tamanho do 1º operando é maior 11 Movimento não efetuado Interrupções Possíveis 0004,0005,0006 L ,=A(RECEIVE) L ,=A(L’RECEIVE) L ,=A(SENDING) L ,=A(L’SENDING) ICM 9,B'1000',=C'*' MVCL 2,8 Se o campo emissor ultrapassar ou não do byte 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.

328 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 é menor 10 Tamanho do 1º operando é maior 11 Movimento não efetuado Interrupções Possíveis 0004,0005,0006 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.

329 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 Interrupções Possíveis 0004,0005 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' ' ou MVI CPOA,92 CPOA antes Operando imediato antes CPOA depois Operando imediato depois C 5C C Outros exemplos:  MVI WAREA+72,C'/' MVI (4),X'80' Sumario Instr.Máq.

330 Instruções de máquina - MVN
MVN (MoVe Numerics – Mover [partes] numéricas) Código de máquina D1 (Instrução SS - L) Condition code Não é alterado Interrupções Possíveis 0004,0005 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 o operando antes 1o operando depois o operando depois MVN FLDA,FLB A.BC 18.3A.5C A.BC MVN TOT+4(1),=X'0C' F 0C C 0C Sumario Instr.Máq.

331 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) Condition code Não é alterado Interrupções Possíveis 0004,0005 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 SENFLD Depois RECFLD Antes C RECFLD Depois C Sumario Instr.Máq.

332 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) Condition code Não é alterado Interrupções Possíveis 0004,0005 MVO CPOA,CPOB Antes Depois 1º Caso CPOB CPOA A A 2º Caso CPOB AB AB.72 CPOA A.5C.B9.FC A.B7.2C Outros exemplos: MVO ARCALC(5),ARCALC(4) MVO (4,7),ARCALC MVO AREA,2(5,8) MVO (7,13),19(5,15) Sumario Instr.Máq.

333 Instruções de máquina - MVZ
MVZ (MoVe Zones – Mover [partes] de zona) Código de máquina D3 (Instrução SS – L) Condition code Não é alterado Interrupções Possíveis 0004,0005 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 o operando antes 1o operando depois o operando depois MVZ FLDA,FLB A.BC 72.94.B A.BC MVZ TOT,=4C'0' C5 F0.F0.F0.F0.F0 F1.F2.F3.F4.F5 F0.F0.F0.F0.F0 Sumario Instr.Máq.

334 Instruções de máquina - N
N (aNd – E booleano) Código de máquina 54 (Instrução RX) Condition code 00 Resultado = 0 01 Resultado <> 0 10 O condition code nunca fica em 10 após um N 11 O condition code nunca fica em 11 após um N Interrupções Possíveis 0005 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 é alterado Ex: N ,CAMPOF Antes Depois Reg B4.EF.2F.A A8 CAMPOF FF FF Outros exemplos: N ,=F'15' N ,0(4) N ,0(,4) N ,0(8,4) Sumario Instr.Máq.

335 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 = 0 01 Resultado <> 0 10 O condition code nunca fica em 10 após um NC 11 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 depois CPOA EF.2F.A A8 CPOB FF FF Sumario Instr.Máq.

336 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 = 0 01 Resultado <> 0 10 O condition code nunca fica em 10 após um NI 11 O condition code nunca fica em 11 após um NI Interrupções Possíveis 0004, 0005 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 é alterado Exemplo: NI BYTE,X'0F' antes depois BYTE B Op.Imed F F Sumario Instr.Máq.

337 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 = 0 01 Resultado <> 0 10 O condition code nunca fica em 10 após um NR 11 O condition code nunca fica em 11 após um NR Interrupções Possíveis Nenhuma 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 é alterado Ex:   NR ,8 Antes Depois Reg B4.EF.2F.A A8 Reg FF FF Sumario Instr.Máq.

338 Instruções de máquina - O
O ([boolean] Or – OU booleano) Código de máquina 56 (Instrução RX) Condition code 00 Resultado = 0 01 Resultado <> 0 10 O condition code nunca fica em 10 após um O 11 O condition code nunca fica em 11 após um O Interrupções Possíveis 0005 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 = 1 Ex: O ,CAMPOF Antes Depois Reg B4.EF.2F.A8 B4.EF.2F.FF CAMPOF FF FF Sumario Instr.Máq.

339 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 = 0 01 Resultado <> 0 10 O condition code nunca fica em 10 após um OC 11 O condition code nunca fica em 11 após um OC Interrupções Possíveis 0004, 0005 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 = 1 Ex: OC CPOA,CPOB Antes Depois CPOA EF.2F.A8 EF.2F.FF CPOB FF FF Sumario Instr.Máq.

340 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 = 0 01 Resultado <> 0 10 O condition code nunca fica em 10 após um OI 11 O condition code nunca fica em 11 após um OI Interrupções Possíveis 0004, 0005 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 = 1 Ex: OI BYTE,X'0F' antes depois BYTE B BF Op.Imed F F Sumario Instr.Máq.

341 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 = 0 01 Resultado <> 0 10 O condition code nunca fica em 10 após um OR 11 O condition code nunca fica em 11 após um OR Interrupções Possíveis Nenhuma 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 = 1 Ex: OR ,8 Antes Depois Reg. 5 B4.EF.2F.A8 B4.EF.2F.FF Reg FF FF Sumario Instr.Máq.

342 Instruções de máquina - PACK
PACK (Compactar) Código de máquina F2 (Instrução SS – L1 e L2) Condition code não é alterado Interrupções Possíveis 0004,0005 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.