Assembler para Mainframes IBM

Assembler para Mainframes IBM

Apresentação Obrigado por usar esta apresentação. Você está livre para fazer isso. Eu agradeço se fizer referência ao autor ao utilizá-la. Agradeço se você me enviar qualquer correção que ache necessária para otimizar a compreensão do leitor. O mesmo se aplica a erros técnicos que você encontrar; por favor me ajude a deixar este material sem erros. Alberto Romano Schiesari – São Paulo - Brasil

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

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

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

ARQUITETURA DE SISTEMAS

Arquitetura – Alguns componentes
CPU do sistema (CISC, RISC, híbrido) CISC = Complex Instruction Set Computer Instruções com tamanho variável. Nelas, explicita ou implicitamente, deve estar especificado: - Qual operação a ser feita - Quais operandos serão usados (locais com dados a processar e locais com dados resultantes): o endereço deles! - Tamanho dos operandos - Formato dos dados nos operandos RISC = Reduced Instruction Set Computer Instruções com tamanho fixo: por ex. 4 bytes; execução, na média, mais rápida

Observar que... Mainframes e PC’s = CISC

Endereçamento (acesso) dos bytes de memória Memória real? Memória virtual? Se tiver memória virtual, o HW precisa conversar com o SW

Em linguagem simbólica a referência a um campo é feita:  Usando seu nome (variáveis ou constantes) ou  Usando seu conteúdo (literais) MOVE 1 TO NPAGIN NPAGIN = 1

Em linguagem de máquina, a referência a um campo é feita indicando seu endereço, ou seja, a localização de um campo deve ser especificada por meio de um número (hexadecimal / binário) que seja o seu endereço. Não há referência aos nomes. A referência ao endereço é denominada ENDEREÇAMENTO. O número hexadecimal que expressa o endereço pode ter 6 algarismos ou 8 algarismos. Se for com 6 algarismos são necessários 3 bytes para especificá-lo. Se for com 8 algarismos são necessários 4 bytes para especificá-lo. (em muitos de nossos exemplos usamos números menores, com 2 ou 3 algarismos, apenas para simplificação visual e de cálculos).

Endereçamento (acesso) dos bytes de memória Instrução MOVE em linguagem de máquina, que indica : (a) é MOVE (F8); (b) Tamanho campo emissor [literal 1] = 0 (significa 1 byte) (c) Tamanho campo receptor [variável NPAGIN] = 3 (significa 4 bytes) (c) Endereço do campo emissor (d) Endereço do campo receptor Acredite em mim: x’B004’ é o endereço de NPAGIN e x’C82F’ é o endereço da literal com 1 Campo emissor [literal com conteúdo 1] E que tem endereço ! Campo receptor [variável NPAGIN] Programa Instruções Áreas F830B004C82F 1C 00

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

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

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

 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

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

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

 Execução de instruções pela CPU – Processo genérico  FETCH (CPU carrega a instrução da memória RAM para área interna da CPU; “problema”: instruções com tamanho variável)  Decode = Análise (decodificação): qual o tamanho da instrução (se RISC não precisa), operação (errada? 0c1!), operandos, etc Erro? Passar o controle para o sistema operacional resolver  Se OK, FETCH dos dados dos operandos  Se estiverem na memória real, “tá” ótimo.; Senão...  Validação do conteúdo dos operandos. Erro? Pode ser um 0C7, por exemplo  Execução : em alguns casos (operações matemáticas, principalmente), colocar resultados em áreas temporárias da CPU OK? Se preciso, STORE do resultado na memória RAM

OUTROS componentes de arquitetura

OUTROS componentes de arquitetura  Sistema de interrupções Quais podem ocorrer? Ex. Por tempo, por erro de programa (0Cx)  Sub-sistemas de entrada e saída Como é a comunicação entre controladoras, devices, memória, CPU e tudo isso e o software?  Sistema de proteção de memória Como um programa está protegido da invasão de outro?  Sistema de memória virtual Qual o processo? Quais algoritmos de page-in e page-out?  Interface/acesso com outros componentes do sistema Quais são os outros componentes? Controladoras, Clocks, etc Como eles se comunicam com a CPU? (por exemplo, CCW) Quais informações após um I/O o software recebe?

Arquitetura Mainframes IBM

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

Mainframes IBM : principais componentes da arquitetura CPU 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)

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

Lay-out da PSW atual BC mode BYTE 0 BITS = 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

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

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

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

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.

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.

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

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

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

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 !!!

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’

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

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 !!!

Base + Deslocamento : Dicas de utilização Usa-se para endereçar “endereços normais” O que são endereços “normais”? Cada pergunta! (aqueles que podem ser expressos por meio de uma expressão)

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

Indexador + Base + Deslocamento Instruções para o Sr. Carteiro da Av. Marginal: Ir até o Restaurante Água Na 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

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 !!!

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’

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

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 !!!

Indexador + Base + Deslocamento – Dicas de utilização Usa-se em geral para endereçar “endereços Anormais” O que são endereços “Anormais”? Segundo Gabriel o Pensador: por exemplo, Itens de tabela

Indexador + Base + Deslocamento – Dicas de utilização Um exemplo de endereçamento de itens de tabela AC AM BA SC SP TO MT MS PB RS CE RN PA DF GO Endereço 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)

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

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)

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) *

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

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’ ’

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.

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

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

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

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.

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’

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

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

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

Representação de dados

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)

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

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

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

Representação de dados numéricos
Dados numéricos Formatos: Decimal zonado ou - Decimal compactado ou - Binário de ponto fixo ou - Binário de ponto flutuante

Representação em formato DECIMAL ZONADO 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.

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”

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”

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.

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

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

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

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.

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

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

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

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

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

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

Representação em formato BINÁRIO PONTO FLUTUANTE Sorry... Não é escopo deste curso...

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‘ ’)

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 ]

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)

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’

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’

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’

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’

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’

Exercício EP Somente veja o resultado aqui depois de tentar resolver

Linguagem Assembler LINGUAGEM ASSEMBLER

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

Jeitão de um programa Assembler

Pode ser assim... Programa Instruções Áreas LOAD POINT = ENTRY POINT

Ou assim... Programa Áreas Instruções LOAD POINT ENTRY POINT

Assim também... Programa I LOAD POINT = ENTRY POINT A

Até com o estilo da casa da sogra... Programa LOAD POINT = ENTRY POINT I A

Ou da sogra da casa... Programa LOAD POINT A I ENTRY POINT

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) +

O que deu para perceber a respeito da estrutura de um programa em Assembler? Pode ser de qualquer jeito ! Se não mandar desviar, ele vai tentar executar uma área como se fosse instrução... É a arquitetura de von Newman... Veja...

Statement STATEMENT Assembler

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

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

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

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

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

Umas “cositas” do montador Assembler

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

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

“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)

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

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

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

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 .

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.

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

Montador Assembler “Cosita” 3 = Expressões

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.

- 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

Montador Assembler EXPRESSÕES Exemplos
Expressão O valor resultante corresponde a LPOUP primeiro byte à esquerda de LPOUP (Supor endereço de LPOUP = x’000A000C’; o valor da expressão LPOUP é x’000A000C’) Esta expressão : somente 1 termo: 1 símbolo [LPOUP] LPOUP+0 primeiro byte à esquerda de LPOUP (Supor endereço de LPOUP = x’000A000C’; o valor da expressão LPOUP+0 é x’000A000C’) Esta expressão : 2 termos: 1 símbolo [LPOUP] e 1 termo auto-definido (decimal) [0]

Montador Assembler EXPRESSÕES
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]

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’

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’

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

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)

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’

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]

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

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

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)

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

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’

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)

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)

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’

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)

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

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

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

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

Comandos ao Montador Comandos ao montador

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

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

Comandos ao montador - AMODE
AMODE (Adressing Mode - Modo de endereçamento) Este comando é utilizado para especificar ao montador Assembler o modo de endereçamento a ser associado a uma Control Section. O seu formato é: [símbolo] AMODE n n podendo ser 24 ou 31 ou ANY. O símbolo é opcional. Se omitido, o modo de endereçamento será associado à Control Section sem nome que deve existir no programa. Se especificado, o modo de endereçamento será associado à Control Section que tiver nome igual ao especificado no símbolo. O operando indica qual modo de endereçamento deve ser associado à Control Section; pode ser 24 (endereçamento de 24 bits), 31 (endereçamento de 31 bits) ou ANY (a Control Section não é sensível ao modo de endereçamento). Não pode haver dois ou mais AMODE para uma mesma Control Section. O comando AMODE pode estar em qualquer lugar do programa. AMODE 24 é incompatível com RMODE ANY. Comandos

Comandos ao montador - AMODE
AMODE (Adressing Mode - Modo de endereçamento) Os defaults para AMODE e RMODE quando só um deles (ou nenhum) é especificado são os seguintes: Especificado Assumido nenhum AMODE 24 e RMODE 24 AMODE RMODE 24 AMODE RMODE 24 AMODE ANY RMODE 24 RMODE AMODE 24 RMODE ANY AMODE 31 Comandos

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

Comandos ao montador -CNOP
CNOP (Conditional Nop - Nop Condicional) O comando CNOP alinha o Location Counter para uma halfword. Os bytes "desprezados" são preenchidos com X'0700' (instrução NOPR). O seu formato é: CNOP a,b Sendo: a - Pode ser 0, 2, 4 ou 6. Indica em qual Byte da fullword ou da doubleword deve ser posicionado o Location Counter. b - Pode ser 4 ou 8. Indica se o campo deve ser uma fullword ou doubleword. Ex: CNOP ,4 • 0,8 • 2,8 • 4,8 • 6,8 • 0,4 • 2,4 • 0,4 • 2,4 Comandos

Comandos ao montador - COM
COM (Blank Common Control Section) Este comando identifica e aloca uma CSECT que seja uma área de memória comum a mais de uma CSECT (CSECT compartilhada). Ela pode ser referenciada por módulos independentes e carregada como um único programa, Não admite símbolo nem operandos. Somente uma COM é permitida em cada programa, embora possa haver diversos comandos COM, o primeiro deles indicando o início (primeiro “pedaço”) da COM, e os demais indicando sua(s) continuação(ões). Sintaxe: COM Exemplo: CSPRG START . A DS CL3 B DS CL4 END Comandos

Comandos ao montador - COPY
COPY (Copiar) O comando COPY copia comandos Assembler de uma biblioteca. O seu formato é o seguinte: COPY símbolo Sendo símbolo o nome com que o conjunto de comandos se encontra catalogado na biblioteca. Dentro dos comandos não pode haver nem ICTL nem ISEQ. Ex: COPY EQUREG Comandos

Comandos ao montador - CSECT
CSECT (Control Section - Seção de Controle) O comando CSECT identifica o início ou a continuação de uma Control Section. [símbolo] CSECT O comando CSECT não admite operandos. Se o símbolo for colocado, ele dará nome à CSECT. Os comandos e instruções que forem colocados após o comando CSECT farão parte dela, até que seja colocado um outro comado CSECT ou DSECT. Diversos comandos CSECT com o mesmo símbolo podem aparecer num programa. O primeiro dará o nome à CSECT e os outros identificarão sua continuação. Comandos

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

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

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

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

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

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

Comandos ao montador - DROP
DROP (Por de lado, Deixar) Este comando tem por função indicar ao montador que um (ou mais) registrador que anteriormente havia sido especificado como base (através de um comando USING), não deve mais ser base. O seu formato é o seguinte: DROP [R1[,R2,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

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

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

Comandos ao montador - DSECT
DSECT (Dummy Section - Seção Simulada) 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

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

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

Comandos ao montador - END
END (Fim) O comando END deve ser o último statement de um programa fonte. O seu formato é: END [Símbolo] Símbolo é o símbolo dado à primeira instrução do programa a ser executado. Ex: END INICIO Comandos

Comandos ao montador - ENTRY
ENTRY (Entrada) Este comando identifica símbolos definidos no programa (que contém o ENTRY), e que serão usados por outros programas. O seu formato é: ENTRY símbolo[,símbolo...] No programa que usa o símbolo, ele deve ser definido através de um comando EXTRN. PROG START . ROTINA EQU * ENTRY ROTINA END PROG START CONST DC A(ROTINA) EXTRN ROTINA Comandos

Comandos ao montador - EQU
EQU (Equate - Igualar) A função do comando EQU é associar um símbolo a um endereço, que é fornecido através do operando do EQU. O seu formato é um dos seguintes: Símbolo EQU a Símbolo EQU a,b Símbolo EQU a,b,c Símbolo EQU a,,c Sendo: a - expressão cujo valor seja o endereço a ser associado ao símbolo. b - termo auto-definido que indica o atributo de tamanho desejado para o símbolo. Se B for omitido, assume tamanho do primeiro termo (ou único) da esquerda da expressão: --- Se for uma referência ao Location Counter (*), um termo auto-definido ou uma referência a um atributo de tamanho (L'x), assume 1. --- Se for um símbolo usado como símbolo num DC ou DS, assume o atributo de tamanho do símbolo --- Se for um símbolo usado numa instrução de máquina, assume o tamanho da instrução (2,4 ou 6 Bytes) --- Se for um símbolo usado num comando ao montador (exceto DC, DS e CCW) assume 1. c - termo auto-definido que indica o atributo de tipo que se deseja para o símbolo que se está definindo. Se omitido é assumido U. Comandos

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

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

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

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

Comandos ao montador - ISEQ
ISEQ (Input Sequence - Sequência de Entrada) A função deste comando é indicar ao montador Assembler que se deseja que ele teste a sequência (crescente) dos statements-fonte. O seu formato é o seguinte: ISEQ [a,b] Sendo: a - número da primeira posição que forma o campo dos statements, campo esse a partir do qual deve ser testada a sequência. b - número da última posição do campo. OBS:- A <= B Pode-se colocar quantos ISEQ forem necessários num programa. Se os seus dois operandos forem omitidos, não será testada a sequência. Comandos

Comandos ao montador - LOCTR
LOCTR (Multiple Location Counters) Este comando ao montador permite o uso de diversos location counters dentro de uma Control Section. Seu formato é: simbolo LOCTR O primeiro Location Counter de uma Control Section é definido quando de um comando START, CSECT, DSECT ou COM. Dentro de uma dessas seções, o comando LOCTR define outro location counter; é como se houvesse um location counter para cada símbolo especificado através do START, CSECT, DSECT, COM e de cada LOCTR. Um LOCTR cujo símbolo já tenha sido especificado em outro comando START, DSECT, CSECT, COM ou LOCTR continua a geração do objeto usando o endereço do location counter respectivo; no final, o objeto da seção será um único, com os "pedaços" arranjados. Exemplo: Se dentro de uma seção for usado um LOCTR cujo símbolo é o de um outro que esteja em outra seção, esta outra seção é continuada com o location counter em questão. Comandos

Comandos ao montador - LOCTR
LOCTR (Multiple Location Counters) PROGRAMA Loc.Counter 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

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

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

Comandos ao montador - OPSYN
OPSYN (Operation Synonim) O comando OPSYN faz uma equivalência entre um símbolo e um código de operação de uma instrução de máquina ou comando ao montador. O seu formato é: Símbolo OPSYN [código] Sendo: Símbolo - qualquer símbolo válido em Assembler ou um código de operação (se o operando não for especificado). Código - qualquer código de operação válido. Se não for especificado, o comando anula o código de operação colocado como símbolo. O comando OPSYN deve ser colocado depois do ICTL (se houver ICTL) e pode ser precedido somente por EJECT, ISEQ, PRINT, SPACE e TITLE. Exemplo: MOVER OPSYN MVC MVC OPSYN Comandos

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

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

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

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

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

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

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

Comandos ao montador - RMODE
RMODE (Residence Mode - Modo de residência) Os defaults para AMODE e RMODE quando só um deles (ou nenhum) é especificado são os seguintes: Especificado Assumido nenhum AMODE 24 e RMODE 24 AMODE RMODE 24 AMODE RMODE 24 AMODE ANY RMODE 24 RMODE AMODE 24 RMODE ANY AMODE 31 Comandos

Comandos ao montador - SPACE
SPACE (Espaço) O comando SPACE, quando detectado pelo montador Assembler, faz com que o montador, na listagem que ele fornece, deixe tantas linhas em branco quantas forem especificadas no operando do SPACE. O seu formato é: SPACE [n] Sendo que n é um número decimal que indica quantas linhas devem ser deixadas em branco. Ex: SPACE Comandos

Comandos ao montador - START
START (Começo) O comando START tem por função dar o conteúdo inicial do LOCATION COUNTER. Este comando deve ser um dos primeiros do programa-fonte (antes dele não pode haver nenhum comando ou instrução que altere o Location Counter). O seu formato é: [símbolo] START a sendo: Símbolo: O comando START tem por função também definir a primeira Control Section (CSECT) do programa. Se for colocado o símbolo, ele será o nome da CSECT. Se ele não for colocado, a CSECT é considerada sem nome. a - Termo auto-definido (cujo valor deve ser múltiplo de 8) que indica o conteúdo inicial do Location Counter. Se omitido, será assumido 0. Exemplos: PROG START X'308' START OBS: - Se o comando START não for colocado, é assumido START 0. Comandos

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

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

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

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

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

(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

[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

[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

[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

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

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

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

Declaração de áreas – DC tipo C
Cada caracter especificado no conteúdo inicial ocupa um byte (em EBCDIC) Se não for especificado tamanho, será assumido o necessário para conter o conteúdo inicial. Se for especificado o atributo de tamanho, ele prevalece sobre a quantidade de bytes necessária ao conteúdo inicial. Se o tamanho especificado for maior que o necessário, será feito preenchimento dos bytes restantes à direita com brancos (X'40'). Se o tamanho for insuficiente, será feito truncamento à direita (e será indicado erro). O tamanho máximo é 256 bytes. Quando o caracter que se deseja colocar como conteúdo inicial for um apóstrofe (') ou um E comercial (&), deve-se colocá-lo duas vezes. DC 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

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

Declaração de áreas - DC tipo X
Pode-se especificar como conteúdo inicial os algarismos hexadecimais (de 0 a F). Cada algarismo ocupa meio byte. O preenchimento é da direita para a esquerda. Se sobrarem bytes (ou meios-bytes) à esquerda, será feito preenchimento com zeros binários (X’0’). Se o tamanho especificado for insuficiente, será feito truncamento à esquerda. O tamanho máximo permitido é 256 bytes. Aceita múltiplas definições por constante. DC 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

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

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

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

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

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

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

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

Declaração de áreas - DC tipo P
O sinal é indicado na parte numérica do último Byte à direita do campo. Se o número for positivo, ela terá C. Se o número for negativo, terá D. O conteúdo inicial é colocado em decimal, e cada algarismo irá ocupar 1/2 byte. O preenchimento é feito da direita para a esquerda. Se o tamanho não for especificado, será reservado um campo com tamanho necessário e suficiente para conter o conteúdo inicial (mais, eventualmente, meio byte, para o caso de a quantidade de algarismos especificada ser par). Se o tamanho especificado for maior que o necessário, será feito preenchimento à esquerda com zeros (X'0'). Se for menor, será feito truncamento à esquerda. Aceita múltiplas definições por constante. DC P'122' 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

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

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

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

Se o tamanho for especificado, não será efetuado o alinhamento. O conteúdo é o endereço real correspondente à expressão colocada como conteúdo inicial da constante. Se não for especificado tamanho, será feito alinhamento para o próximo endereço múltiplo de 4. Se for especificado tamanho, NÃO será feito alinhamento. Aceita múltiplas definições por constante. DC A(TABELA) DC A(TABELA-50) DC A(*) DC A(259) CAMPO DC 3A(*-CAMPO) DC A(TCABC+28*52) DC A(FIM-COMECO) DC A(1,2,3) Comandos

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

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

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

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

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

Declaração de áreas - DC tipo Y
Se o tamanho for especificado, não será efetuado o alinhamento. Os dois Bytes da halfword terão o endereço real correspondente à expressão colocada como conteúdo inicial da constante. Observar que o endereço máximo representável através da constante tipo Y é X'FFFF‘. Aceita múltiplas definições por constante. DC Y(TABELA) DC Y(TABELA-50) DC Y(*) DC Y(259) 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

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

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

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

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

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

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

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

A função do comando DS é definir uma área sem conteúdo inicial. O seu formato é análogo ao DC. Se for especificado conteúdo inicial, ele não será considerado. DS CL3 DS XL4 DS PL4'0' DS CL8 Comandos

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

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

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

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

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

Instruções de máquina - Dicas

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

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

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

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

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

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

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

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

(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

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 ]

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

Instruções de máquina - BC
BC (Branch on condition – Desviar condicionalmente) As instruções de desvio são duas: BC (instrução RX) e BCR (instrução RR). No entanto, elas possuem uma série de códigos mnemônicos auxiliares, denominados estendidos, para facilitar o seu uso. O funcionamento das instruções de desvio é baseado no estado do Condition Code e de uma máscara de 4 bits existente na instrução, na metade à esquerda de seu segundo byte. Os 4 estados em que o Condition Code pode se encontrar são: 00, 01, 10 e 11. A cada um desses estados atribui-se um código que o representa: ESTADO CÓDIGO 00 8 01 4 10 2 11 1 A MÁSCARA indica em que condição deve ser efetuado o desvio, e, como ocupa meio byte, pode ir de X'0' a X'F' (em decimal, de 0 a 15). Se a máscara estiver com 8, o desvio será efetuado se o condition code estiver em B'00' ; se ela estiver em 4, o desvio ocorrerá se o condition code estiver em B'01'; máscara 2 causa desvio se o condition code estiver em B'10"; e, finalmente, máscara 1 acarreta desvio se o condition code estiver posicionado em B'11'. Sumario Instr.Máq.

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

BC (Branch on condition – Desviar condicionalmente) USO MNEMÔNICO SIGNIFICADO BC/BCR EQUIVALENTE Geral B ou BR Desvia sempre BC 15 ou BCR 15 NOP ou NOPR Nao Desvia BC 0 ou BCR 0 Apos BH ou BHR Desvia se A > B BC 2 ou BCR 2 Comparações BL ou BLR Desvia se A < B BC 4 ou BCR 4 BE ou BER Desvia se A = B BC 8 ou BCR 8 BNH ou BNHR Desvia se A < ou = B BC 13 ou BCR 13 BNL ou BNLR Desvia se A > ou = B BC 11 ou BCR 11 BNE ou BNER Desvia se A não = B BC 7 ou BCR 7 Apos BO ou BOR Desvia se overflow BC 1 ou BCR 1 Instruções BP ou BPR Desvia se R > 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.

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

BC (Branch on condition – Desviar condicionalmente) BC (Branch on Condition – Desviar na Condição) Código de máquina 47 (Instrução RX) 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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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. Se o receptor for maior que o necessário, ele será preenchido com zeros à esquerda. Se ele for menor que o necessário, os algarismos em excesso serão truncados. O 2º operando permanece inalterado. Exemplo: PACK CPOA,CPOB antes depois CPOB F1.F2.F3.F4 F1.F2.F3.F4 CPOA B7.2A F Sumario Instr.Máq.

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 PACK CPOA,CPOB 2ºcaso CPOB F1.F2.F3.F4 F1.F2.F3.F4 CPOA C9.4A F 3ºcaso CPOB 9A.48.F9.DB 9A.48.F9.DB CPOA B7.DF A.89.BD Observar, pelo 3º Caso, que o campo emissor não é testado quando ao fato de ele estar em zonado e, consequentemente, o campo receptor pode não ficar em compactado. Outros exemplos: PACK VALOR,ARLEIT+5(9) PACK QUANTO+2(7),2(8,5) PACK (10,2),AREA PACK (5,7),2(3,8) PACK DOUBLE,DOUBLE PACK BYTE,BYTE Sumario Instr.Máq.

Instruções de máquina - S
S (Subtract – subtrair [conteúdo de fullword]) Código de máquina 5B (Instrução RX) Condition code 00 Resultado = 0 01 Resultado < 0 10 Resultado > 0 11 Overflow Interrupções Possíveis 0005,0008 Esta instrução efetua a subtração algébrica entre um número binário contido num registrador (especificado no 1º operando - é o Minuendo) e um número binário contido num campo de memória de 4 bytes (especificado no 2º operando; em geral uma fullword - é o Subtraendo). Exemplos: Supor os operandos com tamanho e conteúdo como exibidos na linha “antes” 1o operando antes o operando antes 1o operando depois o operando depois S 5,=F'259' BF.D 00.00.BE.CF S 7,FULL D FF.FF.FF.0A S 7,4(2,8) FF.FF.FE 07.FF.FF.FD S 7,4(2) FF.FF.FF 07.FF.FF.FD S 7,4(,8) FF.FF.FF.FF FF.FF.FF.FF Sumario Instr.Máq.

Instruções de máquina - SH
SH (Subtract Halfword – Subtrair [conteúdo de] halfword) Código de máquina 4B (Instrução RX) Condition code 00 Resultado = 0 01 Resultado < 0 10 Resultado > 0 11 Overflow Interrupções Possíveis 0005,0008 Esta instrução efetua uma subtração algébrica entre dois números binários. Um deles está localizado no registrador especificado no 1º operando, e o outro num campo de memória de 2 bytes especificado no 2º operando (em geral uma halfword). O resultado é colocado no registrador 1º operando. Ex: Supor os operandos com tamanho e conteúdo como exibidos na linha “antes” 1o operando antes o operando antes 1o operando depois o operando depois SH 5,=H'259' B.C A.C SH 5,HALF D D FF.FF.FF D SH 5,4(2,8) (decimal ) (decimal –30584) (decimal ) SH 5,4(2) (decimal ) (decimal ) (decimal ) Sumario Instr.Máq.

Instruções de máquina - SL
SL (Subtract Logical – Subtrair logicamente) Código de máquina 5F (Instrução RX) Condition code 00 O condition code nunca fica em 00 após um SL 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 subtração lógica entre dois números binários. Um deles localizado no registrador especificado no 1º operando. O outro, num campo de memória de 4 bytes especificado no 2º operando (em geral uma fullword). O resultado é colocado no registrador 1º operando. Ex: Supor os operandos com tamanho e conteúdo como exibidos na linha “antes” 1o operando antes o operando antes 1o operando depois o operando depois SL 5,=F'259' BF.D 00.00.BE.CF SL 7,FULL D A SL 7,4(2,8) FF.FF.FE 07.FF.FF.FD SL 7,4(2) FF.FF.FF 07.FF.FF.FD Sumario Instr.Máq.

Instruções de máquina - SLA
SLA (Shift Left Algebraic – Deslocamento algébrico à esquerda) Código de máquina 8B (Instrução RS) Condition code 00 Resultado = 0 01 Resultado < 0 10 Resultado > 0 11 Overflow Interrupções Possíveis Nenhuma É feito deslocamento de bits para a esquerda no conteúdo do registrador primeiro operando. São deslocados os bits 1 a 31 do registrador: todos menos o bit de sinal (o bit de sinal não é deslocado/alterado). Os bits à direita são criados com zero. É uma instrução RS, e os bits 12 a 15 dela são ignorados pela UCP. Os 6 bits mais à direita do número que é o endereço do 2º operando, formam um número que indica quantas "casas" devem ser deslocadas. Pode-se deslocar 15 "casas" no máximo. Ex: SLA ,3 Registrador 5 antes do Shift FF.80.9A.00 Registrador 5 após o Shift FC.04.D0.00 Sumario Instr.Máq.

Instruções de máquina - SLDA
SLDA (Shift Left Double Algebraic – Deslocamento algébrico duplo à esquerda) Código de máquina 8F (Instrução RS) Condition code 00 Resultado = 0 01 Resultado < 0 10 Resultado > 0 11 Overflow Interrupções Possíveis 0004, 0008 É feito deslocamento de bits para a esquerda no conteúdo do par de registradores indicado registrador primeiro operando e pelo registrador seguinte a ele. São deslocados os 63 bits formados por: bits 1 a 31 do registrador primeiro operando juntamente com os bits 0 a 31 do registrador segundo operando (considera que o par de registradores tenha um número com 1 bit de sinal + 63 bits para o número). Os bits à direita são criados com zero. É uma instrução RS, e os bits 12 a 15 dela são ignorados pela UCP. Os 6 bits mais à direita do número que é o endereço do 2º operando, formam um número que indica quantas "casas" devem ser deslocadas. Pode-se deslocar 63 "casas" no máximo. Ex: SLA ,3 Registradores 8 e 9 antes do Shift FF.80.9A.00 Registradores 8 e 9 após o Shift FC.04.D0.00 Sumario Instr.Máq.

Instruções de máquina - SLDL
SLDL (Shift Left Double Logical – Deslocamento lógico duplo à esquerda) Código de máquina 8D (Instrução RS) Condition code Não é alterado Interrupções Possíveis 0006 É feito deslocamento de bits para a esquerda no conteúdo do par de registradores indicado pelo primeiro operando e pelo registrador seguinte ao primeiro operando. Todos os bits são deslocados para a esquerda (incluindo o bit de sinal). Os bits à direita são criados com zero. É uma instrução RS, e os bits 12 a 15 dela são ignorados pela UCP. Os 6 bits mais à direita do número que é o endereço do 2º operando, formam um número que indica quantas "casas" devem ser deslocadas. Pode-se deslocar 63 "casas" no máximo. Ex: SLDL ,4 Registradores 8 e 9 antes do Shift 12.FE.3D.4C 5B.6A.78.90 Registradores 8 e 9 após o Shift 2F.E3.D4.C5 B6.A Sumario Instr.Máq.

Instruções de máquina - SLL
SLL (Shift Left Logical – Deslocamento lógico à esquerda) Código de máquina 89 (Instrução RS) Condition code Não é alterado Interrupções Possíveis Nenhuma É feito deslocamento de bits para a esquerda no conteúdo do registrador primeiro operando. Todos os bits são deslocados para a esquerda (incluindo o bit de sinal). Os bits à direita são criados com zero. É uma instrução RS, e os bits 12 a 15 dela são ignorados pela UCP. Os 6 bits mais à direita do número que é o endereço do 2º operando, formam um número que indica quantas "casas" devem ser deslocadas. Pode-se deslocar 32 "casas" no máximo. Exemplo: SLL ,2 Registrador 5 antes do Shift B9.4F.FF.FF Registrador 5 após o Shift E5.3F.FF.FC Sumario Instr.Máq.

Instruções de máquina - SLR
SLR (Subtract Logical Register – Subtrair logicamente em registrador) Código de máquina 1F (Instrução RR) Condition code 00 Nunca o condition code fica em 00 após um SLR 01 Resultado <> 0, não perde sinal 10 Resultado = 0, perde sinal 11 Resultado <> 0, perde sinal Interrupções Possíveis Nenhuma É efetuada uma subtração lógica entre os números binários (considerados com 32 bits cada, positivos) contidos no 1º operando (minuendo) e 2º operando (subtraendo). O resto é colocado no registrador 1º operando. Ex: Supor os operandos com tamanho e conteúdo como exibidos na linha “antes” 1o operando antes o operando antes 1o operando depois o operando depois SLR 7, B0.C4.E 00.B0.C4.E SLR 10, 7F.FF.FF.FF Sumario Instr.Máq.

Instruções de máquina - SP
SP (Subtract Packed – Subtrair em compactado) Código de máquina FB (Instrução SS – L1 e L2) Condition code 00 Resultado = 0 01 Resultado < 0 10 Resultado > 0 11 Overflow Interrupções Possíveis 0001,0004,0005,0007,000A Esta instrução subtrai o conteúdo do 2o operando do conteúdo do 1o operando. Ambos devem ser campos de memória no formato decimal compactado. O resultado é colocado no 1o operando. Exemplos: SP FLDA,FLDB Antes Depois FLDB C C FLDA C C Mais exemplos: SP VALOR,VALOR SP TOTAL,=P'1' SP AE+5(8),AE+15(3) SP (2,7),4(1,8) Sumario Instr.Máq.

Instruções de máquina - SPM
SPM (Set Program Mask – Posicionar máscara de programa) Código de máquina 04 (Instrução RR) Condition code fica com o conteúdo dos bits 2 e 3 do reg. 1º operando Interrupções Possíveis nenhuma Os bits 12 a 15 da instrução (onde haveria o registrador 2º operando) são ignorados. O conteúdo do registrador 1º operando é usado como base para colocar o condition code e a máscara de programa na PSW atual. Os bits 2 e 3 do registrador 1º operando tem seu conteúdo colocado no condition code da PSW atual, e os bits 4,5,6 e 7 tem seu conteúdo colocado na máscara de programa da PSW atual. Os bits 0 e 1, e os bits 8 a 31 do registrador 1º operando são ignorados. Ex: SPM 8 Sumario Instr.Máq.

Instruções de máquina - SR
SR (Subtract Register – Subtrair registrador) Código de máquina 1B (Instrução RR) 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 é subtraído algebricamente do número binário contido no registrador especificado no 1º operando, e o resto é colocado no registrador 1º operando. Portanto: Minuendo : 1ºoperando ; Subtraendo : 2ºoperando ; Resto : 1ºoperando Exemplos: 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 SR 7, FF.FF 00.00.FF.FE SR 2, FF.FF FF.FF Sumario Instr.Máq.

Instruções de máquina - SRA
SRA (Shift Right Algebraic – Deslocamento algebrico à direita) Código de máquina 8A (Instrução RS) Condition code 00 Resultado = 0 01 Resultado < 0 10 Resultado > 0 11 O copdition code nunca fica em 11 após um SRA Interrupções Possíveis Nenhuma É feito deslocamento de bits para a direita no conteúdo do registrador primeiro operando. São deslocados os bits 1 a 31 do registrador: todos menos o bit de sinal (o bit de sinal não é deslocado/alterado). Os bits à esquerda são criados com zero. É uma instrução RS, e os bits 12 a 15 dela são ignorados pela UCP. Os 6 bits mais à direita do número que é o endereço do 2º operando, formam um número que indica quantas "casas" devem ser deslocadas. Pode-se deslocar 15 "casas" no máximo. Ex: SRA ,3 Registrador 5 antes do Shift FF.80.0A.00 Registrador 5 após o Shift 8F.F Sumario Instr.Máq.

Instruções de máquina - SRDA
SRDA (Shift Right Double Algebraic – Deslocamento algébrico duplo à direita) Código de máquina 8E (Instrução RS) Condition code 00 Resultado = 0 01 Resultado < 0 10 Resultado > 0 11 O condition code nunca fica em 11 após em SRDA Interrupções Possíveis 0006 É feito deslocamento de bits para a direita no conteúdo do par de registradores indicado registrador primeiro operando e pelo registrador seguinte a ele. São deslocados os 63 bits formados por: bits 1 a 31 do registrador primeiro operando juntamente com os bits 0 a 31 do registrador segundo operando (considera que o par de registradores tenha um número com 1 bit de sinal + 63 bits para o número). Os bits à esquerda são criados com zero. É uma instrução RS, e os bits 12 a 15 dela são ignorados pela UCP. Os 6 bits mais à direita do número que é o endereço do 2º operando, formam um número que indica quantas "casas" devem ser deslocadas. Pode-se deslocar 63 "casas" no máximo. Ex: SRDA ,4 Registradores 8 e 9 antes do Shift C FF Registradores 8 e 9 após o Shift C F Sumario Instr.Máq.

Instruções de máquina - SRDL
SRDL (Shift Right Double Logical – Deslocamento lógico duplo à direita) Código de máquina 8C (Instrução RS) Condition code Não é alterado Interrupções Possíveis 0006 É feito deslocamento de bits para a direita no conteúdo do par de registradores indicado pelo primeiro operando e pelo registrador seguinte ao primeiro operando. Todos os bits são deslocados para a direita (incluindo o bit de sinal). Os bits à esquerda são criados com zero. É uma instrução RS, e os bits 12 a 15 dela são ignorados pela UCP. Os 6 bits mais à direita do número que é o endereço do 2º operando, formam um número que indica quantas "casas" devem ser deslocadas. Pode-se deslocar 63 "casas" no máximo. Ex: SRDL ,4 Registradores 8 e 9 antes do Shift 12.FE.3D.4C 5B.6A.78.90 Registradores 8 e 9 após o Shift 01.2F.E3.D4 C5.B6.A7.89 Sumario Instr.Máq.

Instruções de máquina - SRL
SRL (Shift Right Logical – Deslocamento lógico à direita) Código de máquina 88 (Instrução RS) Condition code Não é alterado Interrupções Possíveis Nenhuma É feito deslocamento de bits para a direita no conteúdo do registrador primeiro operando. Todos os bits são deslocados para a direita (incluindo o bit de sinal). Os bits à esquerda são criados com zero. É uma instrução RS, e os bits 12 a 15 dela são ignorados pela UCP. Os 6 bits mais à direita do número que é o endereço do 2º operando, formam um número que indica quantas "casas" devem ser deslocadas. Pode-se deslocar 32 "casas" no máximo. Exemplo: SRL ,2 Registrador 5 antes do Shift B9.4F.FF.FF Registrador 5 após o Shift 2E.53.FF.FF Sumario Instr.Máq.

Instruções de máquina - SRP
SRP (Shift and Round Packed – Deslocar e arredondar em compactado) Código de máquina F0 (Instrução SS) Condition code 00 Resultado = 0 01 Resultado < 0 10 Resultado > 0 11 Overflow Interrupções Possíveis 0001,0004,0005,0007,000A O seu formato de máquina é o seguinte: CO = 1 byte (código de operação) L1 = 1/2 byte (tamanho do primeiro operando - 1) I3 = 1/2 byte (operando imediato (terceiro operando) E1 = 2 bytes (B1D1D1D1 endereço base+deslocamento do primeiro operando) E2 = 2 bytes (B2D2D2D2 endereço base+deslocamento do segundo operando) O campo especificado no 1º operando sofre um deslocamento de dígitos (algarismos) na direção e quantidade de dígitos especificada pelo endereço do 2º operando, e, quando o deslocamento é para a direita, é feito um arredondamento, o qual é especificado no 3. operando. Sumario Instr.Máq.

SRP (Shift and Round Packed – Deslocar e arredondar em compactado) Código de máquina F0 (Instrução SS) Condition code 00 Resultado = 0 01 Resultado < 0 10 Resultado > 0 11 Overflow Interrupções Possíveis 0001,0004,0005,0007,000A O endereço do 2º operando não é usado para especificação de dados; os 6 últimos bits à direita do número que representa o endereço do 2º operando são analisados da seguinte maneira: · O 1º bit à esquerda indica o sentido do deslocamento: se estiver desligado, o deslocamento é à esquerda; se estiver ligado, o deslocamento e à direita. · Os outros 5 bits formam um número que indica quantos dígitos devem ser deslocados (se o deslocamento for à direita, este número está negativo). O campo especificado no 1º operando deve estar em compactado. O arredondamento é feito somando-se o número especificado no 3. operando ao último dígito deslocado, e, se for 1, esse 1 é somado ao número resultante do deslocamento. Vejamos os seguintes exemplos: Sumario Instr.Máq.

SRP (Shift and Round Packed – Deslocar e arredondar em compactado) Código de máquina F0 (Instrução SS) Condition code 00 Resultado = 0 01 Resultado < 0 10 Resultado > 0 11 Overflow Interrupções Possíveis 0001,0004,0005,0007,000A SRP TOTAL,61,5 TOTAL Antes C TOTAL Depois C (desloca 3 dígitos para a direita) SRP TOTAL,3,0 TOTAL Antes C TOTAL Depois C (desloca 3 dígitos para a esquerda) Estas regras facilitam a especificação do sentido de deslocamento e quantidade de dígitos a deslocar: Deslocamento para a esquerda = especificar diretamente a quantidade de dígitos SRP TOTAL,3,5 Especificar quantidade de dígitos no 2o operando = desloca para a esquerda (no exemplo = 3) Deslocamento para a direita = especificar (64 – quantidade de dígitos) SRP TOTAL,64-3,5 Especificar [64-qtdade] no 2o operando = desloca para a direita Sumario Instr.Máq.

Instruções de máquina - ST
ST (Store – armazenar [registrador em memória]) Código de máquina 50 (Instrução RX) Condition code Não é alterado Interrupções Possíveis 0004,0005 O conteúdo do registrador especificado no 1º operando é colocado no campo de memória de 4 bytes especificado no 2º operando (em geral uma fullword). O registrador 1º operando permanece inalterado. Ex: Supor os operandos com tamanho e conteúdo como exibidos na linha “antes” 1o operando antes o operando antes 1o operando depois o operando depois ST 7,FULL FE.DC.BA FE.DC.BA FE.DC.BA.98 ST 14,SAVE FF.FF.FF.FD Outros exemplos: ST ,FULL+4 ST ,0(2) ST ,0(,8) Sumario Instr.Máq.

Instruções de máquina - STC
STC (STore Character – armazenar 1 byte de registrador) Código de máquina 42 (Instrução RX) Condition code Não é alterado Interrupções Possíveis 0004,0005 O conteúdo do último byte à direita do registrador especificado no 1º operando (o qual permanece inalterado) é colocado no campo de 1 byte especificado no 2º operando. Ex: Supor os operandos com tamanho e conteúdo como exibidos na linha “antes” 1o operando antes o operando antes 1o operando depois o operando depois STC 7,BYTE FE.DC.BA FE.DC.BA STC 14,0(5) FF Sumario Instr.Máq.

Instruções de máquina - STCK
STCK (Store ClocK – armazenar relógio) Código de máquina B205 (Instrução S) Condition code 00 O clock está em estado de set 01 O clock não está em estado de set 10 O clock está em estado de erro 11 Nunca fica em 11 após um STCK Interrupções Possíveis 0004 O conteúdo do TOD clock é armazenado no campo de 8 bytes especificado como operando. O clock deve estar em estado de set, stop ou não-set. As posições à direita não providas pelo TOD clock são preenchidas com zeros. Se o TOD clock está em estado de erro, o conteúdo do campo é imprevisível. Se ele está não operacional, é colocado zeros no campo. Exemplo: STCK DW Sumario Instr.Máq.

Instruções de máquina - STCM
STCM (STore Character under Mask – Armazenar caracter com máscara) Código de máquina BE (Instrução RS) Condition code Não é alterado Interrupções Possíveis 0004,0005 O seu formato de máquina é o seguinte: CO (código de operação) = 1 byte; R1 (registrador primeiro operando) = 1/2 byte E2 = 2 bytes (base+deslocamento do 2o. operando); M3 (máscara 3o. operando) = 1/2 byte Os 4 bits da máscara, da esquerda para a direita, correspondem aos 4 bytes do registrador especificado no 1º operando. Os bytes do registrador que tiverem os seus bits correspondentes na máscara ligados, são considerados como um "campo" contíguo, e movidos para o campo de memória especificado no último operando da instrução (2º operando), o qual deve ter tantos bytes de tamanho quantos forem os bits da máscara ligados. O registrador 1º operando não é alterado. Exemplo: Supor os operandos com tamanho e conteúdo como exibidos na linha “antes” 1o operando antes o operando antes 1o operando depois o operando depois STCM 5,B'1010',TWOBYTES A.BC 1o byte do registrador 5 é colocado no byte TWOBYTES e 3o byte do registrador 5 é colocado no byte TWOBYTES+1 Sumario Instr.Máq.

Instruções de máquina - STH
STH (STore Halfword – Armazenar halfword) Código de máquina 40 (Instrução RX) Condition code Não é alterado Interrupções Possíveis 0004,0005 O conteúdo dos 2 últimos bytes à direita do registrador especificado no 1º operando é colocado no campo de memória de 2 bytes especificado no 2º operando (em geral uma halfword). O registrador 1º operando permanece inalterado. Ex: Supor os operandos com tamanho e conteúdo como exibidos na linha “antes” 1o operando antes o operando antes 1o operando depois o operando depois STH 5,FLD A A.B4 A A STH 8,HWORD FF.FF.FF.FF FF.FF FF.FF.FF.FF FF.FF Mais exemplos: STH ,SAVE+18 STH ,0(2) STH ,0(,8) STH ,0(2,8) STH ,FLD Sumario Instr.Máq.

Instruções de máquina - STM
STM (STore Multiple – Armazenar múltiplos [registradores]) Código de máquina 90 (Instrução RX) Condition code Não é alterado Interrupções Possíveis 0004,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 STM coloca o conteúdo do conjunto de n registradores (indicado pelos registradores especificados) no campo de memória de (n.4) bytes especificado no último operando. Ex: STM ,1,SALVA SALVA = 16 bytes (bytes 0 a 3 = conteúdo reg 14; bytes 4 a 7 = conteúdo reg 15; bytes 8 a 11 = conteúdo reg 0; bytes 12 a 15 = conteúdo reg 1) | SALVA | < >< >< >< > Reg Reg Reg Reg.1 Outro Exemplo: STM ,7,2(10) Sumario Instr.Máq.

Instruções de máquina - SVC
SVC (SuperVisor Call – Chamada ao supervisor) Código de máquina 0A (Instrução RR) Condition code Permanece inalterado na PSW velha Interrupções Possíveis Nenhuma O seu formato de Máquina é o seguinte: CO (código de operação) = 1 byte ; Número do SVC = 1 byte Esta instrução causa interrupção de programa, através de uma chamada ao programa supervisor, chamada essa que pede a ele que execute alguma função. O código especificado no único operando (entre 0 e 255) indica qual a função desejada. Ex: SVC SVC Exemplos de SVC's de MVS: X'00' (000) = EXCP/XDAP X'13' (019) = OPEN X'01' (001) = WAIT/WAITR/PRTOV X'14' (020) = CLOSE X'02' (002) = POST X'23' (035) = WTO/WTOR X'04' (004) = GETMAIN X'24' (036) = WTL X'05' (005) = FREEMAIN X'5D' (093) = TGET/TPUT X'0B' (011) = TIME X'63' (099) = DYNALLOC X'0D' (013) = ABEND X'6B' (107) = MODESET Sumario Instr.Máq.

Instruções de máquina - TM
TM (Test under Mask – Testar com máscara) Código de máquina 91 (Instrução SI) Condition code 00 Todos os bits testados estão desligados, ou a máscara é 0 01 Dos bits testados, alguns estão ligados e outros desligados 10 Nunca o condition code fica em 10 após um TM 11 Todos os bits testados estão ligados Interrupções Possíveis 0005 Esta instrução testa bits do campo de 1 byte especificado no 1º operando, a partir da máscara especificada no 2º operando (termo auto-definido), a qual indica quais são os bits que devem ser testados. Os bits ligados na máscara indicam que os seus correspondentes no 1º operando devem ser testados. Após o teste, o condition code é posicionado. Ex: TM BYTE,X'9C' Bits 0, 3, 4 e 5 of BYTE são testados Neste caso, os bits 0, 3, 4 e 5 de BYTE serão testados. Outros exemplos: TM CHAVE,B' ' Bits 0 e 7 de KEYAB são testados TM 0(4),240 Bits 4,5,6 e 7 de [reg base 4 + deslocamento X’0’] são testados TM 2(8),X'80' Bit 0 [reg base 8 + deslocamento X’2’] é testado Sumario Instr.Máq.

Instruções de máquina - TR
TR (TRanslate - Traduzir) Código de máquina DC (Instrução SS – L) Condition code Não é alterado Interrupções Possíveis 0004,0005 A instrução TR movimenta o conteúdo do 2º operando para o 1º operando, de acordo com o conteúdo do 1º operando. Para tanto, ela processa da esquerda para a direita, byte a byte, da seguinte forma: · ela soma o conteúdo de um byte do 1º operando ao endereço do 2º operando; · o byte cujo endereço foi encontrado, será movido para o byte do 1º operando. Ex: TR ACSD,TABELA Antes ACSD FF.05 TABELA I C1.48.B9.D7.A1.C3.D9.5C.4B A Tem 256 bytes Depois ACSD B9.C1.4B.1A.C3 TABELA não é alterado Outros exemplos: TR (5,7),0(10) TR ARIMP+7(10),TABASTER TR (5,124),CAMP Sumario Instr.Máq.

TR (TRanslate - Traduzir) Código de máquina DC (Instrução SS – L) Condition code Não é alterado Interrupções Possíveis 0004,0005 Mais exemplos : Para traduzir letras maiúsculas EBCDIC em letras minúsculas EBCDIC; “letras” inválidas são convertidas em espaços EBCDIC CONVTB1 DC 256C' ' espacos EBCDIC ORG CONVTB1+C'A' Volta para A maiusculo DC C'abcdefghi' Substitui espacos originais pelas minusculas ORG CONVTB1+C'J' Volta para J maiusculo DC C'jklmnopqr' Substitui espacos originais pelas minusculas ORG CONVTB1+C'S' Volta para S maiusculo DC C'stuvwxyz’ Substitui espacos originais pelas minusculas ORG , Volta para CONVTB1 +256 Para traduzir letras maiúsculas EBCDIC para letras maiúsculas ASCII; “letras” inválidas são convertidas para espaços ASCII CONVTB2 DC 256X'20' ASCII spaces ORG CONVTB2+C'A' Volta para A maiusculo DC X' ' Substitui letras EBCDIC pelas ASCII ORG CONVTB1+C'J' Volta para J maiusculo DC X'4A4B4C4D4E4F505152' Substitui letras EBCDIC pelas ASCII ORG CONVTB1+C'S' Volta para S maiusculo DC X' A' Substitui letras EBCDIC pelas ASCII ORG , Volta para CONVTB2+256 Sumario Instr.Máq.

TR (TRanslate - Traduzir) Código de máquina DC (Instrução SS – L) Condition code Não é alterado Interrupções Possíveis 0004,0005 Mais exemplos : Para traduzir letras ASCII maiúsculas para letras EBCDIC maiúsculas; “letras” inválidas são convertidas em espaços EBCDIC CONVTB3 DC 256X'40' espacos EBCDIC ORG CONVTB2+X'41' “Return” to Uppercase ASCII A DC C'ABCDEFGHIJKLMNOPQRSTUVWXYZ' Subst letras ASCII pelas EBCDIC ORG , Volta para CONVTB3+256 Sumario Instr.Máq.

Instruções de máquina - TRT
TRT (TRanslate and Test – Traduzir e testar) Código de máquina DD (Instrução SS – L) Condition code 00 Todos os bytes testados estavam em X'00' 01 O teste parou num byte que não era o último a ser testado. 10 O teste foi ate o último byte a ser testado, o qual não estava em X'00' 11 O condition code nunca fica em 11 após um TRT Interrupções Possíveis 0005 A instrução TRT testa bytes do campo especificado no 2º operando, verificando se eles estão ou não em X'00'. O primeiro que for testado e que não esteja em X'00' faz com que a execução da instrução seja encerrada. O 1º operando indica quais os bytes do 2º operando a testar: o TRT soma o conteúdo de um byte do 1º operando ao endereço do 2º operando; o byte cujo endereço foi encontrado é que será testado. Quando é encontrado um byte que não esteja em X'00', a instrução coloca no registrador 1 (nos seus bits 8 a 31; os bits 0 a 7 não são alterados) o endereço do byte do 1º operando cujo conteúdo levou ao byte do 2º operando que não estava em X'00"; além disso, ela coloca no último byte à direita do registrador 2 (os seus bits 0 a 23 não são alterados) o conteúdo do byte do 2º operando que não estava em X'00'. A instrução TRT é, em geral, usada num dos casos a seguir: Sumario Instr.Máq.

TRT (TRanslate and Test – Traduzir e testar) Código de máquina DD (Instrução SS – L) Condition code 00 Todos os bytes testados estavam em X'00' 01 O teste parou num byte que não era o último a ser testado. 10 O teste foi ate o último byte a ser testado, o qual não estava em X'00' 11 O condition code nunca fica em 11 após um TRT Interrupções Possíveis 0005 a) Testar se um campo (1º operando) está no formato decimal zonado - campo numérico: TRT CART+9(6),TABNUM BZ NUMÉRICO . TABNUM DC X'FF',10X'00',6X'FF' b) Testar se um campo (1º operando) é alfabético (só tem letras e brancos) TRT CART+9(6),TABALFAB BZ FABETICO TABALFAB DC CL256X'FF' ORG TABALFAB+C' ' DC X'00' ORG TABALFAB+C'A' DC X'00' ORG TABALFAB+C'J' ORG TABALFAB+C'S' DC X'00' ORG Sumario Instr.Máq.

TRT (TRanslate and Test – Traduzir e testar) Código de máquina DD (Instrução SS – L) Condition code 00 Todos os bytes testados estavam em X'00' 01 O teste parou num byte que não era o último a ser testado. 10 O teste foi ate o último byte a ser testado, o qual não estava em X'00' 11 O condition code nunca fica em 11 após um TRT Interrupções Possíveis 0005 c) Achar o 1º byte de um campo que tenha determinado caracter (* no exemplo). TRT (80,7),TABASTER BZ NOTASTER aqui o registrador 1 tem o endereço do byte com * desejado . TABASTER DC X'00' ORG TABASTER+C'*' DC X'FF' ORG Sumario Instr.Máq.

Instruções de máquina - TS
TS (Test ans Set – Testar e posicionar) Código de máquina 93 (Instrução S) Condition code 00 Bit mais à esquerda desligado 01 Bit mais à esquerda ligado 10 Nunca fica em 10 após um TS 11 Nunca fica em 11 após um TS Interrupções Possíveis 0004,0005 O segundo byte da instrução é ignorado. O bit mais à esquerda do único byte do operando é testado para ver se está ligado ou desligado; o condition code é posicionado, e o byte tem todos os seus bits ligados (fica com X'FF'). Exemplo: TS BYTE Sumario Instr.Máq.

Instruções de máquina - UNPK
UNPK (UNPacK - Descompactar) Código de máquina F3 (Instrução SS – L1 e L2) Condition code não é alterado Interrupções Possíveis 0004,0005 A instrução UNPK movimenta um campo de memória para outro campo de memória, transformando-o de compactado para zonado. Não é feito nenhum teste quanto à validade dos campos. O 1º operando é o campo receptor e o 2º operando é o campo emissor. A movimentação é feita da direita para a esquerda, da seguinte forma: O byte mais à direita do campo emissor é invertido e colocado no byte mais à direita do campo receptor (inverter = a sua parte de zona vira parte numérica, e a sua parte numérica vira parte de zona). Em seguida, cada meio byte do campo emissor é colocado na parte numérica de um byte do campo receptor, sendo que na parte de zona do byte do campo receptor é colocado X'F'. O 2º operando permanece inalterado. Se o campo receptor for menor que o necessário, os algarismos em excesso serão truncados. Se o campo receptor for maior que o necessário, os bytes em excesso serão preenchidos com X'F0'. Ex: UNPK CPOA,CPOB antes depois CPOB C C CPOA B8.4C.D0 F2.F3.F4.C5 Sumario Instr.Máq.

Instruções de máquina - UNPK
UNPK (UNPacK - Descompactar) Código de máquina F3 (Instrução SS – L1 e L2) Condition code não é alterado Interrupções Possíveis 0004,0005 Outros exemplos: UNPK CPOA,CPOB antes depois CPOB C C CPOA B8.4C.D0 F0.F1.F2.C3 UNPK ARGRAV+5(12),TOTLIQ UNPK AX2,2(3,7) UNPK (10,8),T4B2F+3(5) UNPK (13,10),0(5,3) Sumario Instr.Máq.

Instruções de máquina - X
X ([boolean] eXclusive or - OU exlusivo booleano) Código de máquina 57 (Instrução RX) Condition code 00 Resultado = 0 01 Resultado <> 0 10 O condition code nunca fica em 10 após um X 11 O condition code nunca fica em 11 após um X Interrupções Possíveis 0005 A instrução X executa um EXCLUSIVE OR entre um registrador (especificado no 1º operando) e um campo de memória de 4 bytes (Especificado no 2º operando - em geral uma fullword). Bit da máscara = 0 então bit resultante não é alterado; Bit da máscara = 1 então bit resultante é o inverso Ex: X ,CAMPOF antes depois Reg B4.EF.2F.A8 B4.EF.2F.57 CAMPOF FF FF Sumario Instr.Máq.

Instruções de máquina - XC
XC (eXclusive or Character – OU exclusivo [booleano] em caracter) Código de máquina D7 (Instrução SS – L) Condition code 00 Resultado = 0 01 Resultado <> 0 10 O condition code nunca fica em 10 após um XC 11 O condition code nunca fica em 11 após um XC Interrupções Possíveis 0004, 0005 A instrução XC executa um EXCLUSIVE OR entre 2 campos de memória. Bit da máscara = 0 então bit resultante não é alterado; Bit da máscara = 1 então bit resultante é o inverso Ex: XC CPOA,CPOB antes depois CPOA EF.2F.A8 EF.2F.57 CPOB FF Sumario Instr.Máq.

Instruções de máquina - XI
XI (eXclusive or Immediate – OU exclusivo [booleano] com operando imediato) Código de máquina 97 (Instrução SI) Condition code 00 Resultado = 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 XI executa um EXCLUSIVE OR entre 2 campos de memória (um byte cada). Bit da máscara = 0 então bit resultante não é alterado; Bit da máscara = 1 então bit resultante é o inverso Ex: NI BYE,X'0F' Antes Depois BYTE B BB Op.Imed F F Sumario Instr.Máq.

Instruções de máquina - XR
XR (eXclusive Or Register – OU exclusivo [booleano] com registradores) Código de máquina 17 (Instrução RR) Condition code 00 Resultado = 0 01 Resultado <> 0 10 O condition code nunca fica em 10 após um XR 11 O condition code nunca fica em 11 após um XR Interrupções Possíveis Nenhuma A instrução XR executa um EXCLUSIVE OR entre 2 registradores. Bit da máscara = 0 então bit resultante não é alterado; Bit da máscara = 1 então bit resultante é o inverso Ex: XR ,8 Antes Depois Reg B4.EF.2F.A8 B4.EF.2F.57 Reg FF FF Sumario Instr.Máq.

Instruções de máquina - ZAP
ZAP (Zero and Add Packed – Zerar e somar em compactado) Código de máquina F8 (Instrução SS – L1 e L2) Condition code 00 Se o campo movido = 0 01 Se o campo movido < 0 10 Se o campo movido > 0 11 Overflow Interrupções Possíveis 0001,0004,0005,0007,000A A instrução ZAP movimenta o campo especificado no 2º operando (campo emissor) para o campo especificado no 1º operando (campo receptor). O emissor permanece inalterado, e deve estar obrigatoriamente em compactado. A movimentação é feita da direita para a esquerda. Se o emissor for maior (em tamanho) que o receptor, os algarismos em excesso à esquerda serão truncados. Se o emissor for menor (em tamanho) que o receptor, o ZAP preencherá à esquerda com zeros. Ex: Sumario Instr.Máq.

Instruções de máquina - ZAP
ZAP (Zero and Add Packed – Zerar e somar em compactado) Código de máquina F8 (Instrução SS – L1 e L2) Condition code 00 Se o campo movido = 0 01 Se o campo movido < 0 10 Se o campo movido > 0 11 Overflow Interrupções Possíveis 0001,0004,0005,0007,000A ZAP CPOA,CPOB Antes Depois 1º Caso CPOB C C CPOA B4.F C 2º Caso CPOB C C CPOA B C Outros exemplos: ZAP TOTAL,=P'0' ZAP TOTAL,TOTAL ZAP CONTLIN,=P'2'

Macro-instruções MACRO-INSTRUÇÕES

Sorry... Não é escopo deste curso...
Macro-instruções MACRO-INSTRUÇÕES Sorry... Não é escopo deste curso...

Apêndice - Links LINKS z/Architecture
ESA Enterprise Systems Architecture / XC Extended Configuration (para z/VM) High Level Assembler

Apêndice – Resumo instruções por cod. operação
Algumas instruções (ordem código de operação) Mnemônico Cod.Instr Tipo BALR RR BCTR RR BCR RR SVC A RR BSM B RR BASSM 0C RR BASR D RR MVCL E RR CLCL F RR LPR RR LNR RR LTR RR LCR RR NR RR CLR RR OR RR XR RR LR RR CR RR AR A RR Mnemônico Cod.Instr Tipo SR B RR MR C RR DR D RR ALR E RR SLR F RR STH RX LA RX STC RX IC RX EX RX BAL RX BCT RX BC RX LH RX CH RX AH A RX SH B RX MH C RX BAS D RX CVD E RX Mnemônico Cod.Instr Tipo CVB F RX ST RX LAE RX N RX CL RX O RX X RX L RX C RX A A RX S B RX M C RX D D RX AL E RX SL F RX STD RX MXD RX LD RX CD RX AD A RX

Apêndice – Resumo instruções por cod. operação
Algumas instruções (ordem código de operação) Mnemônico Cod.Instr Tipo SD B RX MD C RX DD D RX AW E RX SW F RX STE RX LE RX CE RX BXH RS BXLE RS SRL RS SLL RS SRA A RS SLA B RS SRDL C RS SLDL D RS SRDA E RS SLDA F RS STM RS TM SI Mnemônico Cod.Instr Tipo MVI SI TS S NI SI CLI SI OI SI XI SI LM RS MC AF SI LRA B RX STCK B S CS BA RS CDS BB RS CLM BD RS STCM BE RS ICM BF RS MVN D SS/L MVC D SS/L MVZ D SS/L NC D SS/L CLC D SS/L Mnemônico Cod.Instr Tipo OC D SS/L XC D SS/L TR DC SS/L TRT DD SS/L ED DE SS/L EDMK DF SS/L MVCIN E SS/L SRP F SS/L1I3 MVO F SS/L1L2 PACK F SS/L1L2 UNPK F SS/L1L2 ZAP F SS/L1L2 CP F SS/L1L2 AP FA SS/L1L2 SP FB SS/L1L2 MP FC SS/L1L2 DP FD SS/L1L2

Apêndice – Resumo instruções por mnemônico
Algumas instruções (ordem mnemônico) Mnemônico Cod.Instr Tipo A A RX AD A RX AH A RX AL E RX ALR E RR AP FA SS/L1L2 AR A RR AW E RX BAL RX BALR RR BAS D RX BASR D RR BASSM 0C RR BC RX BCR RR BCT RX BCTR RR BSM B RR BXH RS BXLE RS Mnemônico Cod.Instr Tipo C RX CD RX CDS BB RS CE RX CH RX CL RX CLC D SS/L CLCL F RR CLI SI CLM BD RS CLR RR CP F SS/L1L2 CR RR CS BA RS CVB F RX CVD E RX D D RX DD D RX DP FD SS/L1L2 DR D RR Mnemônico Cod.Instr Tipo ED DE SS/L EDMK DF SS/L EX RX IC RX ICM BF RS L RX LA RX LAE RX LCR RR LD RX LE RX LH RX LM RS LNR RR LPR RR LR RR LRA B RX LTR RR M C RX MC AF SI

Apêndice – Resumo instruções por mnemônico
Algumas instruções (ordem mnemônico) Mnemônico Cod.Instr Tipo MD C RX MH C RX MP FC SS/L1L2 MR C RR MVC D SS/L MVCIN E SS/L MVCL E RR MVI SI MVN D SS/L MVO F SS/L1L2 MVZ D SS/L MXD RX N RX NC D SS/L NI SI NR RR O RX OC D SS/L OI SI OR RR Mnemônico Cod.Instr Tipo PACK F SS/L1L2 S B RX SD B RX SH B RX SL F RX SLA B RS SLDA F RS SLDL D RS SLL RS SLR F RR SP FB SS/L1L2 SR B RR SRA A RS SRDA E RS SRDL C RS SRL RS SRP F SS/L1I3 ST RX STC RX STCK B S Mnemônico Cod.Instr Tipo STCM BE RS STD RX STE RX STH RX STM RS SVC A RR SW F RX TM SI TR DC SS/L TRT DD SS/L TS S UNPK F SS/L1L2 X RX XC D SS/L XI SI XR RR ZAP F SS/L1L2

Apêndice – EBCDIC – Alguns caracteres
Algumas configurações EBCDIC HEX CARATER 40 Espaço 60 - hífen 81 a A2 s D0 } fecha chave F0 4B . ponto 61 / barra 82 b A3 t D1 J F1 1 4C < menor 6B , virgula 83 c A4 u D2 K F2 2 4D ( abre parênt. 6C % percentual 84 d A5 v D3 L F3 3 4E + mais 6D _ underscore 85 e A6 w D4 M F4 4 4F | barra vertical 6E > maior 86 f A7 x D5 N F5 5 50 & E comercial 6F ? interrogação 87 g A8 y D6 O F6 6 5A ! exclamação 7A : 2 pontos 88 h A9 z D7 P F7 7 5B $ cifrão 7B # número 91 i C0 { abre chave D8 Q F8 8 5C * asterisco 7C @ arroba 92 j C1 A D9 R F9 9 5D ) fecha parênt. 7D ' apostrofe 93 k C2 B E0 \ barra invertida 5E ; ponto e vírgula 7E = igual 94 l C3 C E2 S 5F  not 7F " aspas 95 m C4 D E3 T 96 n C5 E E4 U 97 o C6 F E5 V 98 p C7 G E6 W 99 q C8 H E7 X 9A r C9 I E8 Y E9 Z

Apêndice – ASCII – Alguns caracteres
Algumas configurações ASCII HEX CARATER 20 Espaço 30 0 zero 40 @ at 50 P 60 ` Acento grave 70 p 21 ! Exclamação 31 1 um 41 A 51 Q 61 a 71 q 22 “ Aspas 32 2 dois 42 B 52 R 62 b 72 r 23 # Número 33 3 tres 43 C 53 S 63 c 73 s 24 $ Cifrão 34 4 quatro 44 D 54 T 64 d 74 t 25 % Percentual 35 5 cinco 45 E 55 U 65 e 75 u 26 & E comercial 36 6 seis 46 F 56 V 66 f 76 v 27 ‘ Apóstrofe 37 7 sete 47 G 57 W 67 g 77 w 28 ( Abre parentheses 38 8 oito 48 H 58 X 68 h 78 x 29 ) Fecha parentheses 39 9 nove 49 I 59 Y 69 i 79 y 2A * Asterisco 3A : dois pontos 4A J 5A Z 6A j 7A z 2B + Soma 3B ; ponto e vírgula 4B K 5B [ Abre colchete 6B k 7B { Abre chave 2C , Virgula 3C < menor que 4C L 5C \ Barra invertida 6C l 7C | Barra vertical 2D - Hífen 3D = igual a 4D M 5D ] Fecha colchete 6D m 7D } Fecha chave 2E . Ponto 3E > maior que 4E N 5E ^ Circumflexo 6E n 7E ~ Til 2F / Barra 3F ? Interrogação 4F O 5F _ (Sublinhado) 6F o

Questões Questões

(Q) Exercícios 1-12 (Converter de decimal para binário)

(Q) Exercícios 13-24 (Converter de decimal para hexadecimal)

(Q) Exercícios 25-36 (Converter de binário para hexadecimal)

(Q) Exercícios 37-48 (Converter de hexadecimal para binário)
Exercício 37 : (CAFE)16 = (?)2 Exercício 38 : (CDF)16 = (?)2 Exercício 39 : (1AB4D)16 = (?)2 Exercício 40 : (15)16 = (?)2 Exercício 41 : (F)16 = (?)2 Exercício 42 : (87B54)16 = (?)2 Exercício 43 : (1001)16 = (?)2 Exercício 44 : (234)16 = (?)2 Exercício 45 : (CAD)16 = (?)2 Exercício 46 : (7F7)16 = (?)2 Exercício 47 : (1990)16 = (?)2 Exercício 48 : (33)16 = (?)2

(Q) Exercícios 49-60 (Converter de binário para decimal)

(Q) Exercícios 61-72 (Converter de hexadecimal para decimal)
Exercício 62 : (AAF45)16 = (?)10 Exercício 63 : (1B567)16 = (?)10 Exercício 64 : (100)16 = (?)10 Exercício 65 : (1000)16 = (?)10 Exercício 66 : (FF)16 = (?)10 Exercício 67 : (FFF)16 = (?)10 Exercício 68 : (CDF)16 = (?)10 Exercício 69 : (CAFE)16 = (?)10 Exercício 70 : (FACA)16 = (?)10 Exercício 71 : (DAD0)16 = (?)10 Exercício 72 : (F1E2D3C4)16 = (?)10

(Q) Exercícios 73-84 (Somar números binários)

(Q) Exercícios 85-96 (Subtrair números binários)

(Q) Exercícios 97-108 (Somar números em hexadecimal)
Exercício 97 : (F12B)16 + (321)16 = (?)16 Exercício 98 : (1100)16 + (111)2 = (?)16 Exercício 99 : (1000F)16 + (F0001)16 = (?)16 Exercício 100 : (A9B8C7)16 + (D6E5F4)16 = (?)16 Exercício 101 : (CAFE)16 + (CDF)16 = (?)16 Exercício 102 : (B001)16 + (FD)16 = (?)16 Exercício 103 : (999)16 + (111)16 = (?)16 Exercício 104 : (123456)16 + (789ABC)16 = (?)16 Exercício 105 : (FFF)16 + (EEE)16 = (?)16 Exercício 106 : (DDD)16 + (333)16 = (?)16 Exercício 107 : (987AED)16 + (CF01)16 = (?)16 Exercício 108 : (FACA)16 + (CAFE)16 = (?)16

(Q) Exercícios 109-120 (Subtrair números em hexadecimal)
Exercício 109 : (F1C5)16 - (101)16 = (?)16 Exercício 110 : (1AD87C)16 - (FDE9)2 = (?)16 Exercício 111 : (112233)16 - (44556)16 = (?)16 Exercício 112 : (AABBCC)16 - (DDEEF)16 = (?)16 Exercício 113 : (F1E2D3)16 - (C4B5A6)16 = (?)16 Exercício 114 : (FF00001)16 - (10000F)16 = (?)16 Exercício 115 : (CAFE)16 - (FACA)16 = (?)16 Exercício 116 : (CDF)16 - (FDC)16 = (?)16 Exercício 117 : (10001)16 - (20001)16 = (?)16 Exercício 118 : (10000)16 - (FFFE)16 = (?)16 Exercício 119 : (0)16 - (9)16 = (?)16 Exercício 120 : (0)16 - (1A)16 = (?)16

Exercício 121 : (1)10 = (bbbb bbbb bbbb bbbb)2 = (xxxx)16
(Q) Exercícios (Representar números binários em halfword e fullword) Exercício 121 : (1)10 = (bbbb bbbb bbbb bbbb)2 = (xxxx)16 = (bbbb bbbb bbbb bbbb bbbb bbbb bbbb bbbb)2 = (xxxxxxxx)16 Exercício 122 : (-1)10 = (bbbb bbbb bbbb bbbb)2 = (xxxx)16 Exercício 123 : (10)10 = (bbbb bbbb bbbb bbbb)2 = (xxxx)16 Exercício 124 : (-10)10 = (bbbb bbbb bbbb bbbb)2 = (xxxx)16 Exercício 125 : (17)10 = (bbbb bbbb bbbb bbbb)2 = (xxxx)16 Exercício 126 : (-17)10 = (bbbb bbbb bbbb bbbb)2 = (xxxx)16

(Q) Exercícios (Representar números binários em halfword e fullword) Exercício 127 : (254)10 = (bbbb bbbb bbbb bbbb)2 = (xxxx)16 = (bbbb bbbb bbbb bbbb bbbb bbbb bbbb bbbb)2 = (xxxxxxxx)16 Exercício 128 : (-254)10 = (bbbb bbbb bbbb bbbb)2 = (xxxx)16 Exercício 129 : (100000)10 = (bbbb bbbb bbbb bbbb)2 = (xxxx)16 Exercício 130 : ( )10 = (bbbb bbbb bbbb bbbb)2 = (xxxx)16 Exercício 131 : (32000)10 = (bbbb bbbb bbbb bbbb)2 = (xxxx)16 Exercício 132 : (-32000)10 = (bbbb bbbb bbbb bbbb)2 = (xxxx)16

(Q) Exercícios (Representar números binários em halfword e fullword) Exercício 133 : (63000)10 = (bbbb bbbb bbbb bbbb)2 = (xxxx)16 = (bbbb bbbb bbbb bbbb bbbb bbbb bbbb bbbb)2 = (xxxxxxxx)16 Exercício 134 : (-63000)10 = (bbbb bbbb bbbb bbbb)2 = (xxxx)16 Exercício 135 : (1010)10 = (bbbb bbbb bbbb bbbb)2 = (xxxx)16 Exercício 136 : (-1010)10 = (bbbb bbbb bbbb bbbb)2 = (xxxx)16 Exercício 137 : (4095)10 = (bbbb bbbb bbbb bbbb)2 = (xxxx)16 Exercício 138 : (-4095)10 = (bbbb bbbb bbbb bbbb)2 = (xxxx)16

(Q) Exercícios (Representar números binários em halfword e fullword) Exercício 139 : (4097)10 = (bbbb bbbb bbbb bbbb)2 = (xxxx)16 = (bbbb bbbb bbbb bbbb bbbb bbbb bbbb bbbb)2 = (xxxxxxxx)16 Exercício 140 : (-4097)10 = (bbbb bbbb bbbb bbbb)2 = (xxxx)16

(Q) Exercícios 141-152 (Representar números compactados em bytes)
Exercício 141 : (1)10 = (no formato decimal compactado) Exercício 142 : (-1)10 = (no formato decimal compactado) Exercício 143 : (10)10 = (no formato decimal compactado) Exercício 144 : (-10)10 = (no formato decimal compactado) Exercício 145 : (17)10 = (no formato decimal compactado) Exercício 146 : (-17)10 = (no formato decimal compactado) Exercício 147 : (254)10 = (no formato decimal compactado) Exercício 148 : (-254)10 = (no formato decimal compactado) Exercício 149 : (100000)10 = (no formato decimal compactado) Exercício 150 : ( )10 = (no formato decimal compactado) Exercício 151 : (32000)10 = (no formato decimal compactado) Exercício 152 : (-32000)10 = (no formato decimal compactado)

(Q) Exercícios 153-160 (Representar números compactados em bytes)
Exercício 153 : (63000)10 = (no formato decimal compactado) Exercício 154 : (-63000)10 = (no formato decimal compactado) Exercício 155 : (1010)10 = (no formato decimal compactado) Exercício 156 : (-1010)10 = (no formato decimal compactado) Exercício 157 : (4095)10 = (no formato decimal compactado) Exercício 158 : (-4095)10 = (no formato decimal compactado) Exercício 159 : (4097)10 = (no formato decimal compactado) Exercício 160 : (-4097)10 = (no formato decimal compactado)

(Q) Exercícios 161-172 (Representar números zonados em bytes)
Exercício 161 : (1)10 = (no formato decimal zonado) Exercício 162 : (-1)10 = (no formato decimal zonado) Exercício 163 : (10)10 = (no formato decimal zonado) Exercício 164 : (-10)10 = (no formato decimal zonado) Exercício 165 : (17)10 = (no formato decimal zonado) Exercício 166 : (-17)10 = (no formato decimal zonado) Exercício 167 : (254)10 = (no formato decimal zonado) Exercício 168 : (-254)10 = (no formato decimal zonado) Exercício 169 : (100000)10 = (no formato decimal zonado) Exercício 170 : ( )10 = (no formato decimal zonado) Exercício 171 : (32000)10 = (no formato decimal zonado) Exercício 172 : (-32000)10 = (no formato decimal zonado)

(Q) Exercícios 173-180 (Representar números zonados em bytes)
Exercício 173 : (63000)10 = (no formato decimal zonado) Exercício 174 : (-63000)10 = (no formato decimal zonado) Exercício 175 : (1010)10 = (no formato decimal zonado) Exercício 176 : (-1010)10 = (no formato decimal zonado) Exercício 177 : (4095)10 = (no formato decimal zonado) Exercício 178 : (-4095)10 = (no formato decimal zonado) Exercício 179 : (4097)10 = (no formato decimal zonado) Exercício 180 : (-4097)10 = (no formato decimal zonado)

(Q) Exercícios 181-194 (Representar strings de caracteres em bytes)
Exercício 181 : “17“ = (em EBCDIC alfanumérico) Exercício 182 : “-17“ = (em EBCDIC alfanumérico) Exercício 183 : “AF$BD“ = (em EBCDIC alfanumérico) Exercício 184 : “-AF4BD“ = (em EBCDIC alfanumérico) Exercício 185 : “ALBERTO“ = (em EBCDIC alfanumérico) Exercício 186 : “15-9“ = (em EBCDIC alfanumérico) Exercício 187 : “-4095“ = (em EBCDIC alfanumérico) Exercício 188 : “4095“ = (em EBCDIC alfanumérico) Exercício 189 : “*&$//“ = (em EBCDIC alfanumérico) Exercício 190 : “12+3“ = (em EBCDIC alfanumérico) Exercício 191 : “I LOVE HER“ = (em EBCDIC alfanumérico) Exercício 192 : “US$ 2,584.73“ = (em EBCDIC alfanumérico) Exercício 193 : “US$ 1 MILLION“ = (em EBCDIC alfanumérico) Exercício 194 : “PANCHO’S BAR“ = (em EBCDIC alfanumérico)

(Q) Exercícios 195-209 (Representar campos em bytes)
Os exercícios 195 a 300 devem ser considerados como um programa, cujo endereço inicial é zero (X’ ’), ou seja, a primeira área (exercício 195) começa no endereço zero. As áreas definas por DS devem ser computadas para determinar os endereços. Assumir que o 1o statement seja USING *,9. Exercício 195: DC C'123' Exercício 196: DC C'+123' Exercício 197: DC C'-123' Exercício 198: DC C'12.3' Exercício 199: DC C'1AB8' Exercício 200: DC C'01101' Exercício 201: DC C'A+B=C' Exercício 202: DC CL4'A' Exercício 203: DC CL4'ABCDEF' Exercício 204: DC 3CL2'A' Exercício 205: DC 2CL3'A,B' Exercício 206: DC C'ME&&YOU' Exercício 207: DC C'''S MUSIC' Exercício 208: DC Exercício 209: DC CL3'*'

Exercício 210: DC 3C'*' Exercício 211: DC X'123' Exercício 212: DC X'-123' Exercício 213: DC X'1AB2C3' Exercício 214: DC X'1AB2F4G3' Exercício 215: DC XL3'12D' Exercício 216: DC XL3'AABBCCDDEE' Exercício 217: DC X'1,22,333,4444' Exercício 218: DC XL2'1,22,333' Exercício 219: DC 2X'1,22,333' Exercício 220: DC 2XL2'1,22' Exercício 221: DC B' ' Exercício 222: DC B'1' Exercício 223: DC BL2'1111' Exercício 224: DC B'1, ' Exercício 225: DC BL2'1, '

Exercício 226: DC 2B'1000' Exercício 227: DC 2BL2'1000' Exercício 228: DC F'10' Exercício 229: DC F'+10' Exercício 230: DC F'-10' Exercício 230: DC F'-15,+16' Exercício 231: DC 2F'22' Exercício 232: DC 2F'33,44' Exercício 233: DC FL3'258' Exercício 234: DC 2FL1'255' Exercício 235: DC F'128000' Exercício 236: DC H'10' Exercício 237: DC H'+10' Exercício 238: DC H'-10' Exercício 239: DC H'-15,+16'

Exercício 240: DC 2H'22' Exercício 241: DC 2H'33,44' Exercício 242: DC HL3'258' Exercício 243: DC 2HL1'255' Exercício 244: DC H'128000' Exercício 245: DC P'123' Exercício 246: DC P'+123' Exercício 247: DC P'-123' Exercício 248: DC PL4'456' Exercício 249: DC PL1'789' Exercício 250: DC P'1,-22,333,-4444' Exercício 251: DC PL2'1,-22,333,-4444' Exercício 252: DC 3P'0' Exercício 253: DC PL3'0' Exercício 254: DC 2P'1,22,333'

Exercício 255: DC 2PL2'1,22,333' Exercício 256: DC Z'123' Exercício 257: DC Z'+123' Exercício 258: DC Z'-123' Exercício 259: DC ZL4'456' Exercício 260: DC ZL1'789' Exercício 261: DC Z'1,-22,333,-4444' Exercício 262: DC ZL3'1,-22,333,-4444' Exercício 263: DC 3Z'0' Exercício 264: DC ZL3'0' Exercício 265: DC 2Z'1,22,333' Exercício 266: DC 2ZL3'1,22,333'

Exercício 267: SIMBZZ DC A(0) Exercício 268: SIMBAA DC A(127) Exercício 269: SIMBBB DC A(X'8000') Exercício 270: SIMBCC DC A(B'1111') Exercício 271: SIMBDD DC A(C'*') Exercício 272: SIMBEE DC A(*) Exercício 273: SIMBFF DS CL17 Exercício 274: SIMBGG DC A(*) Exercício 275: SIMBHH DC A(SIMBGG) Exercício 276: SIMBII DC A(SIMBAA+12) Exercício 277: SIMBJJ DC A(SIMBII-SIMBBB) Exercício 278: SIMBKK DC AL1(*-SIMBKK) Exercício 279: SIMBLL DC 5AL1(*-SIMBLL)

Exercício 280: SIMBMM DC AL2(3,5,7) Exercício 281: SIMBNN DC A(SIMBII+5*2) Exercício 282: SIMBOO DC A(SIMBNN+X' ') Exercício 283: SIMBPP DC 4AL2(*-SIMBPP) Exercício 284: SIMBQQ DC A(SIMBVV) Exercício 285: SIMBRR DC A(SIMBKK,SIMBJJ) Exercício 286: SIMBSS DC A(SIMBTT+40) Exercício 287: SIMBTT DC A(SIMBUU,*,80) Exercício 288: SIMBUU DC 2A(*-SIMBUU) Exercício 289: SIMBVV DC A(C'AMO') Exercício 290: SIMBWW DC A(X'7FFFFFFF')

Exercício 291: YY1 DC Y(SIMBWW) Exercício 292: YY2 DC Y(10) Exercício 293: YY3 DC Y(L'YY2) Exercício 294: SS1 DC S(SIMBAA) Exercício 295: SS2 DC S(SS1) Exercício 296: SS3 DC S(10) Exercício 297: SS4 DC S(*) Exercício 298: SS5 DC A(125),F'33',C'*',2H'6,18' Exercício 299: SS6 DC X'1,1',B'1,1',C'1,1' Exercício 300: LAST DC 256AL1(255+LAST-*)

(Q) Exercício 301 (Decodificar instruções)
Exercício 301 : Decodificar o seguinte conjunto de instruções: 1ABB41278CF00A13980F334445E00CB490EC0D00FA CCD Para cada uma delas, informar: Código de operação (código de máquina) Menmônico Assembler - Endereço da instrução (supor que a primeira instrução esteja no endereço X’ ’) - Operandos (registrador, registrador base, registrador indexador, deslocamento; se o operando é na memória, calcular o seu endereço; para isso, supor os registradores gerais com o seguinte conteúdo: R00= R04= R08= R12=00000C00 R01= R05= R09= R13=00000D00 R02= R06= R10=00000A00 R14=00000E00 R03= R07= R11=00000B00 R15=00000F00

Respostas Respostas

(A) Exercícios 1-12 (Converter de decimal para binário)

(A) Exercícios 13-24 (Converter de decimal para hexadecimal)
Exercício 13 : (987654)10 = (F1206)16 Exercício 14 : (4095)10 = (FFF)16 Exercício 15 : (7)10 = (7)16 Exercício 16 : (1023)10 = (3FF)16 Exercício 17 : (4096)10 = (1000)16 Exercício 18 : (255)10 = (FF)16 Exercício 19 : (1024)10 = (400)16 Exercício 20 : ( )10 = (98BD91)16 Exercício 21 : (256)10 = (100)16 Exercício 22 : (1025)10 = (401)16 Exercício 23 : (999888)10 = (F41D0)16 Exercício 24 : (65432)10 = (FF98)16

(A) Exercícios 25-36 (Converter de binário para hexadecimal)
Exercício 25 : ( )2 = (7C7521)16 Exercício 26 : ( )2 = (2071FE0FE)16 Exercício 27 : (1100)2 = (C)16 Exercício 28 : ( )2 = (7F1)16 Exercício 29 : ( )2 = (AAA8CC7)16 Exercício 30 : ( )2 = (199999)16 Exercício 31 : ( )2 = (8001)16 Exercício 32 : ( )2 = (201)16 Exercício 33 : ( )2 = (1FC07F)16 Exercício 34 : (1)2 = (1)16 Exercício 35 : ( )2 = (CAFE)16 Exercício 36 : ( )2 = (56B8E01F8F)16

(A) Exercícios 37-48 (Converter de hexadecimal para binário)
Exercício 37 : (CAFE)16 = ( )2 Exercício 38 : (CDF)16 = ( )2 Exercício 39 : (1AB4D)16 = ( )2 Exercício 40 : (15)16 = (10101)2 Exercício 41 : (F)16 = (1111)2 Exercício 42 : (87B54)16 = ( )2 Exercício 43 : (1001)16 = ( )2 Exercício 44 : (234)16 = ( )2 Exercício 45 : (CAD)16 = ( )2 Exercício 46 : (7F7)16 = ( )2 Exercício 47 : (1990)16 = ( )2 Exercício 48 : (33)16 = (110011)2

(A) Exercícios 49-60 (Converter de binário para decimal)

(A) Exercícios 61-72 (Converter de hexadecimal para decimal)
Exercício 62 : (AAF45)16 = (?)10 Exercício 63 : (1B567)16 = (111975)10 Exercício 64 : (100)16 = (256)10 Exercício 65 : (1000)16 = (4096)10 Exercício 66 : (FF)16 = (255)10 Exercício 67 : (FFF)16 = (4095)10 Exercício 68 : (CDF)16 = (3295)10 Exercício 69 : (CAFE)16 = (51966)10 Exercício 70 : (FACA)16 = (64202)10 Exercício 71 : (DAD0)16 = (56016)10 Exercício 72 : (F1E2D3C4)16 = ( )10

(A) Exercícios 73-84 (Somar números em binário)

(A) Exercícios 85-96 (Subtrair números em binário)

(A) Exercícios 97-108 (Somar números em hexadecimal)
Exercício 97 : (F12B)16 + (321)16 = (F44C)16 Exercício 98 : (1100)16 + (111)2 = (1211)16 Exercício 99 : (1000F)16 + (F0001)16 = (100010)16 Exercício 100 : (A9B8C7)16 + (D6E5F4)16 = (1809EBB)16 Exercício 101 : (CAFE)16 + (CDF)16 = (D7DD)16 Exercício 102 : (B001)16 + (FD)16 = (B0FE)16 Exercício 103 : (999)16 + (111)16 = (AAA)16 Exercício 104 : (123456)16 + (789ABC)16 = (19BBF12)16 Exercício 105 : (FFF)16 + (EEE)16 = (1EED)16 Exercício 106 : (DDD)16 + (333)16 = (1110)16 Exercício 107 : (987AED)16 + (CF01)16 = (9949EE)16 Exercício 108 : (FACA)16 + (CAFE)16 = (1C5C8)16

(A) Exercícios 109-120 (Subtrair números em hexadecimal)
Exercício 109 : (F1C5)16 - (101)16 = (F0C4)16 Exercício 110 : (1AD87C)16 - (FDE9)2 = (19DA93)16 Exercício 111 : (112233)16 - (44556)16 = (CDCDD)16 Exercício 112 : (AABBCC)16 - (DDEEF)16 = (9CDCDD)16 Exercício 113 : (F1E2D3)16 - (C4B5A6)16 = (2D2D2D)16 Exercício 114 : (FF00001)16 - (10000F)16 = (FDFFFF2)16 Exercício 115 : (CAFE)16 - (FACA)16 = (...FFFFD034)16 Exercício 116 : (CDF)16 - (FDC)16 = (...FFFFFD03)16 Exercício 117 : (10001)16 - (20001)16 = (...FFFF0000)16 Exercício 118 : (10000)16 - (FFFE)16 = (2)16 Exercício 119 : (0)16 - (9)16 = (...FFFFFFF7)16 Exercício 120 : (0)16 - (1A)16 = (...FFFFFFE6)16

(A) Exercícios 121-126 (Representar números binários em bytes)
= ( )2 = ( )16 Exercício 122 : (-1)10 = ( )2 = (FFFF)16 = ( )2 = (FFFFFFFF)16 Exercício 123 : (10)10 = ( )2 = (000A)16 = ( )2 = ( A)16 Exercício 124 : (-10)10 = ( )2 = (FFF6)16 = ( )2 = (FFFFFFF6)16 Exercício 125 : (17)10 = ( )2 = (0011)16 = ( )2 = ( )16 Exercício 126 : (-17)10 = ( )2 = (FFEF)16 = ( )2 = (FFFFFFEF)16

Exercício 127 : (254)10 = ( )2 = (00FE)16 = ( )2 = (000000FE)16 Exercício 128 : (-254)10 = ( )2 = (FF02)16 = ( )2 = (FFFFFF02)16 Exercício 129 : (100000)10 = (imposível representar em 2 bytes) = ( )2 = (000186A0)16 Exercício 130 : ( )10 = (imposível representar em 2 bytes) = ( )2 = (FFFE7960)16 Exercício 131 : (32000)10 = ( )2 = (7D00)16 = ( )2 = (00007D00)16 Exercício 132 : (-32000)10 = ( )2 = (8300)16 = ( )2 = (FFFF8300)16

Exercício 133 : (63000)10 = (imposível representar em 2 bytes) = ( )2 = (FFFFF618)16 Exercício 134 : (-63000)10 = (imposível representar em 2 bytes) = ( )2 = (FFFF09E8)16 Exercício 135 : (1010)10 = ( )2 = (03F2)16 = ( )2 = (000003F2)16 Exercício 136 : (-1010)10 = ( )2 = (FC0E)16 = ( )2 = (FFFFFC0E)16 Exercício 137 : (4095)10 = ( )2 = (0FFF)16 = ( )2 = (00000FFF)16 Exercício 138 : (-4095)10 = ( )2 = (F001)16 = ( )2 = (FFFFF001)16

= ( )2 = ( )16 Exercício 140 : (-4097)10 = ( )2 = (EFFF)16 = ( )2 = (FFFFEFFF)16

(A) Exercícios 141-152 (Representar números compactados em bytes)
Exercício 141 : (1)10 = [ ] = [ 1C ] Exercício 142 : (-1)10 = [ } = [ 1D ] Exercício 143 : (10)10 = [ ] = [ 010C ] Exercício 144 : (-10)10 = [ ] = [ 10D ] Exercício 145 : (17)10 = [ ] = [ 017C ] Exercício 146 : (-17)10 = [ ] = [ 017D ] Exercício 147 : (254)10 = [ ] = [ 254C ] Exercício 148 : (-254)10 = [ ] = [ 254D ] Exercício 149 : (100000)10 = [ ] = [ C ] Exercício 150 : (100000)10 = [ ] = [ D ] Exercício 151 : (32000)10 = [ ] = [ 32000C ] Exercício 152 : (-32000)10 = [ ] = [ 32000D ]

(A) Exercícios 153-160 (Representar números compactados em bytes)
Exercício 153 : (63000)10 = [ ] = [ 63000C ] Exercício 154 : (-63000)10 = [ ] = [ 63000D ] Exercício 155 : (1010)10 = [ ] = [ 01010C ] Exercício 156 : (-1010)10 = [ ] = [ 01010D ] Exercício 157 : (4095)10 = [ ] = [ 04095C ] Exercício 158 : (-4095)10 = [ ] = [ 04095D ] Exercício 159 : (4097)10 = [ ] = [ 04097C ] Exercício 160 : (-4097)10 = [ ] = [ 04097D ]

(A) Exercícios 161-172 (Representar números zonados em bytes)
Exercício 161 : (1)10 = [ ] = [ F1 ] Exercício 162 : (-1)10 = [ } = [ D1 ] Exercício 163 : (10)10 = [ ] = [ F1F0 ] Exercício 164 : (-10)10 = [ ] = [ F1D0 ] Exercício 165 : (17)10 = [ ] = [ F1F7 ] Exercício 166 : (-17)10 = [ ] = [ F1D7 ] Exercício 167 : (254)10 = [ ] = [ F2F5F4 ] Exercício 168 : (-254)10 = [ ] = [ F2F5D4 ] Exercício 169 : (100000)10 = [ ] = [ F1F0F0F0F0F0 ] Exercício 170 : ( )10 = [ ] = [ F1F0F0F0F0D0 ] Exercício 171 : (32000)10 = [ ] = [ F3F2F0F0F0 ] Exercício 172 : (-32000)10 = [ ] = [ F3F2F0F0D0 ]

(A) Exercícios 173-180 (Representar números zonados em bytes)
[ ] = [ F6F3F0F0F0 ] Exercício 174 : (-63000)10 = [ ] = [ F6F3F0F0D0 ] Exercício 175 : (1010)10 = [ ] = [ F1F0F1F0 ] Exercício 176 : (-1010)10 = [ ] = [ F1F0F1D0 ] Exercício 177 : (4095)10 = [ ] = [ F4F0F9F5 ] Exercício 178 : (-4095)10 = [ ] = [ F4F0F9D5 ] Exercício 179 : (4097)10 = [ ] = [ F4F0F9F7 ] Exercício 180 : (-4097)10 = [ ] = [ F4F0F9D7 ]

(A) Exercícios 181-194 (Representar strings de caracteres em bytes)
Exercício 181 : “17“ = [ F1F7 ] Exercício 182 : “-17“ = [ 60F1F7 ] Exercício 183 : “AF$BD“ = [ C1C66BC2C4 ] Exercício 184 : “-AF4BD“ = [ 60C1C6F4C2C4 ] Exercício 185 : “ALBERTO“ = [ C1D3C2C5D9E3D6 ] Exercício 186 : “15-9“ = [ F1F560F9 ] Exercício 187 : “-4095“ = [ 60F4F0F9F5 ] Exercício 188 : “4095“ = [ F4F0F9F5 ] Exercício 189 : “*&$//“ = [ 5C505B6161 ] Exercício 190 : “12+3“ = [ F1F24EF3 ] Exercício 191 : “I LOVE HER“ = [ C940D3D6E5C540C8C5D9 ] Exercício 192 : “US$ 2,584.73“ = [ E4E25B40F26BF5F8F44BF7F3 ] Exercício 193 : “US$ 1 MILLION“ = [ E4E25B40F140D4C9D3D3C9D6D5 ] Exercício 194 : “PANCHO’S BAR“ = [ D7C1C5C3C8D67DE240C2C1D9 ]

(A) Exercícios 195-209 (Representar campos em bytes)
Os exercícios 195 a 300 devem ser considerados como um programa, cujo endereço inicial é zero (X’ ’), ou seja, a primeira área (exercíco 195) começa no endereço zero. As áreas definas por DS devem ser computadas para determinar os endereços. Assumir que o 1o statement seja USING *,9. * Endereço Conteúdo Exercício 195: DC C'123' F1.F2.F3 Exercício 196: DC C'+123' E.F1.F2.F3 Exercício 197: DC C'-123' F1.F2.F3 Exercício 198: DC C'12.3' B F1.F2.4B.F3 Exercício 199: DC C'1AB8' F F1.C1.C2.F8 Exercício 200: DC C'01101' F0.F1.F1.F0.F1 Exercício 201: DC C'A+B=C' C1.4E.C2.7E.C3 Exercício 202: DC CL4'A' D C Exercício 203: DC CL4'ABCDEF' C1.C2.C3.C4 Exercício 204: DC 3CL2'A' C1.40.C1.40.C1.40 Exercício 205: DC 2CL3'A,B' B C1.6B.C2.C1.6B.C2 Exercício 206: DC C'ME&&YOU' D4.C5.50.E8.D6.E4 Exercício 207: DC C'''S MUSIC' D.E2.40.D4.E4.E2.C9.C3 Exercício 208: DC F 7C.7C.D6.C9 Exercício 209: DC CL3'*' C.40.40

* Endereço Conteúdo Exercício 210: DC 3C'*' C.5C.5C Exercício 211: DC X'123' Exercício 212: DC X'-123' *** erro *** Exercício 213: DC X'1AB2C3' B 1A.B2.C3 Exercício 214: DC X'1AB2F4G3' *** erro *** Exercício 215: DC XL3'12D' E D Exercício 216: DC XL3'AABBCCDDEE' CC.DD.EE Exercício 217: DC X'1,22,333,4444' Exercício 218: DC XL2'1,22,333' A Exercício 219: DC 2X'1,22,333' Exercício 220: DC 2XL2'1,22' Exercício 221: DC B' ' Exercício 222: DC B'1' Exercício 223: DC BL2'1111' F Exercício 224: DC B'1, ' FF Exercício 225: DC BL2'1, ' FF

* Endereço Conteúdo Exercício 226: DC 2B'1000' B 08.08 Exercício 227: DC 2BL2'1000' D (align) Exercício 228: DC F'10' A Exercício 229: DC F'+10' A Exercício 230: DC F'-10' C FF.FF.FF.F6 Exercício 230: DC F'-15,+16' FF.FF.FF.F Exercício 231: DC 2F'22' Exercício 232: DC 2F'33,44' A C C Exercício 233: DC FL3'258' B Exercício 234: DC 2FL1'255' B3 FF.FF 00B (align) Exercício 235: DC F'128000' B F4.00 Exercício 236: DC H'10' BC 00.0A Exercício 237: DC H'+10' BE 00.0A Exercício 238: DC H'-10' C0 FF.F6 Exercício 239: DC H'-15,+16' C2 FF.F

* Endereço Conteúdo Exercício 240: DC 2H'22' C Exercício 241: DC 2H'33,44' CA C C Exercício 242: DC HL3'258' D Exercício 243: DC 2HL1'255' D5 FF.FF 00D7 00 (align) Exercício 244: DC H'128000' D8 F4.00 Exercício 245: DC P'123' DA 12.3C Exercício 246: DC P'+123' DC 12.3C Exercício 247: DC P'-123' DE 12.3D Exercício 248: DC PL4'456' E C Exercício 249: DC PL1'789' E4 9C Exercício 250: DC P'1,-22,333,-4444' 00E5 1C.02.2D.33.3C D Exercício 251: DC PL2'1,-22,333,-4444' 00ED 00.1C.02.2D.33.3C.44.4D Exercício 252: DC 3P'0' F5 0C.0C.0C Exercício 253: DC PL3'0' F C Exercício 254: DC 2P'1,22,333' FB 1C.02.2C.33.3C.1C.02.2C.33.3C

* Endereço Conteúdo Exercício 255: DC 2PL2'1,22,333' C.02.2C.33.3C 00.1C.02.2C.33.3C Exercício 256: DC Z'123' F1.F2.C3 Exercício 257: DC Z'+123' F1.F2.C3 Exercício 258: DC Z'-123' F1.F2.D3 Exercício 259: DC ZL4'456' A F0.F4.F5.C6 Exercício 260: DC ZL1'789' E C9 Exercício 261: DC Z'1,-22,333,-4444' 011F F1.F2.D2.F3.F3.C3.F4.F4.F4.D4 Exercício 262: DC ZL3'1,-22,333,-4444' 0129 F0.F0.C1.F0.F2.D2.F3.F3.C3 F4.F4.F4.D4 Exercício 263: DC 3Z'0' C0.C0.C0 Exercício 264: DC ZL3'0' F0.F0.F0 Exercício 265: DC 2Z'1,22,333' B C1.F2.C2.F3.F3.C3 C1.F2.C2.F3.F3.C3 Exercício 266: DC 2ZL3'1,22,333' F0.F0.C1.F0.F2.C2.F3.F3.C3 F0.F0.C1.F0.F2.C2.F3.F3.C3

* Endereço Conteúdo (align) Exercício 267: SIMBZZ DC A(0) C Exercício 268: SIMBAA DC A(127) F Exercício 269: SIMBBB DC A(X'8000') Exercício 270: SIMBCC DC A(B'1111') F Exercício 271: SIMBDD DC A(C'*') C C Exercício 272: SIMBEE DC A(*) Exercício 273: SIMBFF DS CL ??.??.??.??.??.??.??.??.?? ??.??.??.??.??.??.??.?? (align) Exercício 274: SIMBGG DC A(*) Exercício 275: SIMBHH DC A(SIMBGG) C Exercício 276: SIMBII DC A(SIMBAA+12) C Exercício 277: SIMBJJ DC A(SIMBII-SIMBBB) C Exercício 278: SIMBKK DC AL1(*-SIMBKK) Exercício 279: SIMBLL DC 5AL1(*-SIMBLL)

* Endereço Conteúdo Exercício 280: SIMBMM DC AL2(3,5,7) E Exercício 281: SIMBNN DC A(SIMBII+5*2) A A Exercício 282: SIMBOO DC A(SIMBNN+X' ') 01A A4 Exercício 283: SIMBPP DC 4AL2(*-SIMBPP) AC 00.06 Exercício 284: SIMBQQ DC A(SIMBVV) B D8 Exercício 285: SIMBRR DC A(SIMBKK,SIMBJJ) B Exercício 286: SIMBSS DC A(SIMBTT+40) C EC Exercício 287: SIMBTT DC A(SIMBUU,*,80) C D0 C8 Exercício 288: SIMBUU DC 2A(*-SIMBUU) D Exercício 289: SIMBVV DC A(C'AMO') D8 00.C1.D4.D6 Exercício 290: SIMBWW DC A(X'7FFFFFFF') DC 7F.FF.FF.FF

* Endereço Conteúdo Exercício 291: YY1 DC Y(SIMBWW) E0 01.DC Exercício 292: YY2 DC Y(10) E2 00.0A Exercício 293: YY3 DC Y(L'YY2) E Exercício 294: SS1 DC S(SIMBAA) E Exercício 295: SS2 DC S(SS1) E8 91.E6 Exercício 296: SS3 DC S(10) EA 00.0A Exercício 297: SS4 DC S(*) EC 91.EC 01EE (align) Exercício 298: SS5 DC A(125),F'33',C'*',2H'6,18' 01F D 5C 00 (align) Exercício 299: SS6 DC X'1,1',B'1,1',C'1,1' F1.6B.F1

(A) Exercício 300 (Representar campos em bytes)
* Endereço Conteúdo Exercício 300: LAST DC 256AL1(255+LAST-*) FF.FE.FD.FC.FB.FA.F9.F8.F7.F6.F5.F4.F3.F2.F1.F0 * EF.EE.ED.EC.EB.EA.E9.E8.E7.E6.E5.E4.E3.E2.E1.E0 * DF.DE.DD.DC.DB.DA.D9.D8.D7.D6.D5.D4.D3.D2.D1.D0 * CF.CE.CD.CC.CB.CA.C9.C8.C7.C6.C5.C4.C3.C2.C1.C0 * BF.BE.BD.BC.BB.BA.B9.B8.B7.B6.B5.B4.B3.B2.B1.B0 * AF.AE.AD.AC.AB.AA.A9.A8.A7.A6.A5.A4.A3.A2.A1.A0 * F.9E.9D.9C.9B.9A * F.8E.8D.8C.8B.8A * F.7E.7D.7C.7B.7A * F.6E.6D.6C.6B.6A * A9 5F.5E.5D.5C.5B.5A * B9 4F.4E.4D.4C.4B.4A * C9 3F.3E.3D.3C.3B.3A * D9 2F.2E.2D.2C.2B.2A * E9 1F.1E.1D.1C.1B.1A * F9 0F.0E.0D.0C.0B.0A

(A) Exercício 301 (Decodificar instruções)
Exercício 301 : Decodificar o seguinte conjunto de instruções: 1ABB41278CF00A13980F334445E00CB490EC0D00FA CCD ----////////----//////// //////// //////////// Supor os registradores gerais com o seguinte conteúdo: R00= R04= R08= R12=00000C00 R01= R05= R09= R13=00000D00 R02= R06= R10=00000A00 R14=00000E00 R03= R07= R11=00000B00 R15=00000F00

Exercício 301 : Decodificar o seguinte conjunto de instruções: 1ABB41278CF00A13980F334445E00CB490EC0D00FA CCD ----////////----//////// //////// //////////// 1ABB Código de operação (máquina) = 1A Mnemônico Assembler = AR (add register) - Endereço da instrução = X’ ’ - Operandos = 1o operando = registrador 11; 2o operando = registrador 11 41278CF0 Código de operação (máquina) = 41 Mnemônico Assembler = LA (load address) - Endereço da instrução = X’ ’ Operandos = 1st operand = register 2; 2o operando : indexador = registrador 7 2o operando : base register = registrador 8 2o operando : deslocamento = X’CF0’ Endereço 2o operando = X’ ’+X’ ’+X’CF0’= X’00001BF0’ Continua...

Exercício 301 : Decodificar o seguinte conjunto de instruções: 1ABB41278CF00A13980F334445E00CB490EC0D00FA CCD ----////////----//////// //////// //////////// 0A13 Código de operação (máquina) = 0A Mnemônico Assembler = SVC (supervisor call) - Endereço da instrução = X’ ’ - Operandos = códifo de chamada ao supervisor = X’13’ = (19)10 = open 980F3344 Código de operação (máquina) = 98 Mnemônico Assembler = LM (load multiple) - Endereço da instrução = X’ ’ Operandos = 1o operando = registrador 0; 3o operando : registrador 15 (X’F’) 2o operando : base = registrador 3 2o operando : deslocamento = X’344’ Endereço 2o operando = X’ ’+X’344’= X’ ’ Continua...

Exercício 301 : Decodificar o seguinte conjunto de instruções: 1ABB41278CF00A13980F334445E00CB490EC0D00FA CCD ----////////----//////// //////// //////////// 45E00CB4 Código de operação (máquina) = 45 Mnemônico Assembler = BAL (branch and link) - Endereço da instrução = X’ C’ Operandos = 1o operando = registrador 14 (X’E’); 2o operando : indexador = registrador 0 ; 2o operando : base = registrador 0; 2o operando : deslocamento = X’CB4’; Endereço 2o operando = X’CB4’= X’00000CB4’ 90EC0D00 Código de operação (máquina) = 90 Mnemônico Assembler = STM (store multiple) - Endereço da instrução = X’ ’ Operandos = 1o operando = registrador 14 (X’E’); 3o operando : registrador 12 (X’C’) 2o operando : base = registrador 0; 2o operando : deslocamento = X’D00’ Endereço 2o operando = X’D00’= X’00000D00’ Continua...

Exercício 301 : Decodificar o seguinte conjunto de instruções: 1ABB41278CF00A13980F334445E00CB490EC0D00FA CCD ----////////----//////// //////// //////////// FA CC Código de operação (máquina) = FA Mnemônico Assembler = AP (add packed) - Endereço da instrução = X’ ’ Tamanho 1o operando = 9 bytes; 1o operando : base = registrador 3; 1o operando : deslocamento = X’054’; Endereço 1o operando= X’ ’+X’054’ = X’ ’ Tamanho 2o operando = 3 bytes; 2o operando : base = registrador 4; 2o operando : deslocamento = X’8CC’; Endereço 2o operando = X’ ’+X’8CC’ = X’00000CCC’ D Código de operação (máquina) = D2 Mnemônico Assembler = MVC (move character) - Endereço da instrução = X’ A’ Tamanho 1o operando = 131 bytes; 1o operando : base = registrador 3; 1o operando : deslocamento = X’344’; Endereço 1o operando = X’ ’+X’344’ = X’ ’ Tamanho 2o operando = 131 bytes; 2o operando : base = registrador 5; 2o operando : deslocamento = X566’; Endereço 2o operando = X’ ’+X’566’ = X’00000A66’

Dicas de programação Dicas de programação

Interessantes, úteis, feias mas usadas, etc...
Dicas de programação Interessantes, úteis, feias mas usadas, etc...

Dicas de programação Supondo um programa com 11K e 1 registrador base PROG START USING *,3 Using quando o location counter tem zero LR 3,15 CARREGA PRIMEIRO E UNICO REG BASE 4K 3K Trecho do programa servido pelo registrador base R3; qualquer símbolo definido neste trecho e que precise ser convertido em Base+Deslocamento terá o registrador R3 como base Trecho do programa sem registrador base; qualquer símbolo definido neste trecho e que precise ser convertido em Base+Deslocamento : ERRO

Dicas de programação Supondo um programa com 11K e 2 registradores base PROG START USING *,3, LR 3, CARREGA PRIMEIRO REG BASE LA 7, “INICIO” CARGA SEGUNDO BASE LA 4,4095(3,7) “FIM” CARGA SEGUNDO BASE 4K 3K Trecho do programa servido pelo registrador base R3; qualquer símbolo definido neste trecho e qye precise ser convertido em Base+Deslocamento terá o registrador R3 como base Trecho do programa servido pelo registrador base R7; qualquer símbolo definido neste trecho e qye precise ser convertido em Base+Deslocamento terá o registrador R7 como base Trecho do programa sem registrador base; qualquer símbolo definido neste trecho e que precise ser convertido em Base+Deslocamento : ERRO

Dicas de programação Supondo um programa com 11K e 3 registradores base PROG START USING *,3, LR 3, CARREGA PRIMEIRO REG BASE LA 7, “INICIO” CARGA SEGUNDO BASE LA 7,4095(3,7) “FIM” CARGA SEGUNDO BASE LA 6, “INICIO” CARGA TERCEIRO BASE LA 6,4095(7,6) “FIM” CARGA TERCEIRO BASE 4K 3K Trecho do programa servido pelo registrador base R3 Trecho do programa servido pelo registrador base R7 Trecho do programa servido pelo registrador base R6 “Sobra de base”

Dicas de programação Supondo um programa com 1000K e 1 registrador base PROG START USING *,3 Using quando o location counter tem zero LR 3,15 CARREGA PRIMEIRO E UNICO REG BASE 4K 996K Trecho do programa servido pelo registrador base R3; qualquer símbolo definido neste trecho e que precise ser convertido em Base+Deslocamento terá o registrador R3 como base Trecho do programa sem registrador base; qualquer símbolo definido neste trecho e que precise ser convertido em Base+Deslocamento : ERRO

Dicas de programação Supondo um programa com 1000K e 1 registrador base 4K Instruções Áreas 996K Trecho do programa servido pelo registrador base R3; qualquer símbolo definido neste trecho e que precise ser convertido em Base+Deslocamento terá o registrador R3 como base Trecho do programa sem registrador base; qualquer símbolo definido neste trecho e que precise ser convertido em Base+Deslocamento : ERRO

LTORG (emitido pelo END) LITERAIS declaradas pelo LTORG
Dicas de programação Supondo um programa com 1000K e 1 registrador base Instruções Áreas (com base) Áreas (SEM base) END (fim do fonte) LTORG (emitido pelo END) LITERAIS declaradas pelo LTORG (sem base) Trecho do programa servido pelo registrador base R3; qualquer símbolo definido neste trecho e que precise ser convertido em Base+Deslocamento terá o registrador R3 como base Trecho do programa sem registrador base; qualquer símbolo definido neste trecho e que precise ser convertido em Base+Deslocamento : ERRO

Dicas de programação Supondo um programa com 1000K e 1 registrador base Instruções Áreas (com base) Áreas (SEM base) END (fim do fonte) LTORG (explicitamente colocado pelo programador) LITERAIS declaradas pelo LTORG (com base) Áreas ainda COM base Trecho do programa servido pelo registrador base R3; qualquer símbolo definido neste trecho e que precise ser convertido em Base+Deslocamento terá o registrador R3 como base Trecho do programa sem registrador base; qualquer símbolo definido neste trecho e que precise ser convertido em Base+Deslocamento : ERRO

(explicitamente colocado pelo programador)
Dicas de programação Supondo um programa com 1000K e 1 registrador base Instruções Áreas (com base) Áreas (SEM base) END (fim do fonte) LTORG (explicitamente colocado pelo programador) LITERAIS declaradas pelo LTORG (com base) Áreas ainda COM base Vamos ver com detalhes

estão dentro do alcance do registrador base.
Dicas de programação Supondo um programa com 1000K e 1 registrador base Instruções Áreas Início das áreas “grandes” (supor: 1os 100 bytes de uma área de bytes, por ex. TABXX) TABXX DS 1000CL500 Literais (com base) Restante da área ( bytes) + uma 2ª área grande TABYY + Uma pequena área de 4 bytes (XYZ) LTORG - as instruções, - as áreas antes do LTORG, - as literais e o início das áreas “grandes” (específicamente os 100 primeiros bytes de TABXX) estão dentro do alcance do registrador base.

Dicas de programação Neste caso:
Supondo um programa com 1000K e 1 registrador base Instruções Áreas LTORG TABXX DS CL500 100 1os bytes de TABXX Demias bytes de TABXX TABYY DS CL 1000CL52 XYZ DS CL4 Literais (com base) Neste caso: Os 100 primeiros bytes de TABXX estão COM base. Os bytes seguintes de TABXX estão SEM base. Os bytes de TABYY estão todos sem base. Os 4 bytes de XYZ estão SEM base.

Dicas de programação Supondo um programa com 1000K e 1 registrador base Instruções Áreas LTORG TABXX DS CL500 100 1os bytes de TABXX Demias bytes de TABXX TABYY DS CL 1000CL52 XYZ DS CL4 Literais (com base) Isto significa que: LA R9,TABXX OK! TABXX (o endereço de TABXX é o endereço de seu primeiro bytes à esquerda) está dentro do alcance do registrador base L R9,=A(TABXX) OK! A literal que tem o endereço de TABXX está dentro do alcance do registrador base LA R9,TABXX+1 OK! TABXX+1 é um endereço que está dentro do alcance do registrador base L R9,=A(TABXX+1) OK! A literal que tem o endereço de TABXX+1 está dentro do alcance do registrador base LA R9,TABXX+99 OK! TABXX+99 é um endereço que está dentro do alcance do registrador base L R9,=A(TABXX+99) OK! A literal que tem o endereço de TABXX+99 está dentro do alcance do registrador base

Dicas de programação Supondo um programa com 1000K e 1 registrador base Instruções Áreas LTORG TABXX DS CL500 100 1os bytes de TABXX Demias bytes de TABXX TABYY DS CL 1000CL52 XYZ DS CL4 Literais (com base) Isto significa que: LA R9,TABXX+100 ERRO!!! TABXX+100 é o 101º. Byte de TABXX, e, portanto, o primeiro a NÃO ser servido pelo registrador base. L R9,=A(TABXX+100) OK! A literal que tem o endereço de TABXX+100 está dentro do alcance do registrador base LA R9,TABYY ERRO!!! TABYY é um endereço que NÃO está dentro do alcance do registrador base L R9,=A(TABYY) OK! A literal que tem o endereço de TABYY está dentro do alcance do registrador base LA R9,XYZ ERRO!!! XYZ é um endereço que NÃO está dentro do alcance do registrador base L R9,=A(XYZ) OK! A literal que tem o endereço de XYZ está dentro do alcance do registrador base

Programas com 1 registrador base Especificação ao montador
Dicas de programação Programas com 1 registrador base Especificação ao montador e carga na execução

Carga do registrador base com o endereço do entry point com LR
Dicas de programação Carga do registrador base com o endereço do entry point com LR PROG START USING *, LR 3,15 CARREGA PRIMEIRO E UNICO REG BASE * REG 3 FICA COM O ENDERECO DO ENTRY POINT * CARREGAMENTO COM LR MUITO USADO EM MVS Carga do registrador base com o endereço do entry point com BALR+BCTR+BCTR PROG START USING *, BALR 3,0 CARREGA ENDERECO SEGUINTE AO BALR BCTR 3,0 SUBTRAI BCTR 3,0 SUBTRAI MAIS 1 * NESTE PONTO, O REG 3 ESTAH OK; * ELE TEM O ENDERECO DO ENTRY POINT

Programas com 2 registradores base Especificação ao montador
Dicas de programação Programas com 2 registradores base Especificação ao montador e carga na execução

Dicas de programação Carga do primeiro registrador base com o entry point address com LR e do segundo com entry point address com LA Pode fazer assim? PROG START USING *,3, LR 3,15 CARREGA PRIMEIRO REG BASE * REG 3 FICA COM O ENDERECO DO ENTRY POINT LA 4,4096(4) CARREGA NO 4 O QUE TEM NO Não! Por que? Porque o deslocamento máximo é de 4095 (X’FFF’) !!! Dá erro de montagem !

Dicas de programação Carga do primeiro registrador base com o entry point address com LR e do segundo com entry point address com LA+LA+AR Então tem que fazer assim... PROG START USING *,3, LR 3,15 CARREGA PRIMEIRO REG BASE * REG 3 FICA COM O ENDERECO DO ENTRY POINT LA 4,1 CARREGA NRO 1 NO REG LA 4,4095(4) SOMA * FICOU COM AR 4,3 SOMA O ENTRY POINT. * FICOU ENTRY POINT * OU ENTRY POINT + X’001000’ * PRONTO ! R4 CARREGADO OK TAMBEM !

Dicas de programação Carga do primeiro registrador base com o entry point address com LR e do segundo com entry point address com LA+LA+AR Ou assim... PROG START USING *,3, LR 3,15 CARREGA PRIMEIRO REG BASE * REG 3 FICA COM O ENDERECO DO ENTRY POINT LA 4,4095 CARREGA NRO 4095 NO REG LA 4,1(4) SOMA 1 * FICOU COM AR 4,3 SOMA O ENTRY POINT. * FICOU ENTRY POINT * OU ENTRY POINT + X’001000’ * PRONTO ! R4 CARREGADO OK TAMBEM !

Dicas de programação Carga do primeiro registrador base com o entry point address com LR e do segundo com entry point address com LA+LA Até assim... PROG START USING *,3, LR 3,15 CARREGA PRIMEIRO REG BASE * REG 3 FICA COM O ENDERECO DO ENTRY POINT LA 4,1 CARREGA NRO 1 NO REG LA 4,4095(3,4) SOMA ENTRY POINT * FICOU COM ENTRY POINT * OU ENTRY POINT + X’001000’ * PRONTO ! R4 CARREGADO OK TAMBEM !

Dicas de programação Carga do primeiro registrador base com o entry point address com LR e do segundo com entry point address com LA+LA Assim... PROG START USING *,3, LR 3,15 CARREGA PRIMEIRO REG BASE * REG 3 FICA COM O ENDERECO DO ENTRY POINT LA 4, CARREGA NRO 2048 NO REG LA 4,2048(3,4) SOMA ENTRY POINT * FICOU COM ENTRY POINT * OU ENTRY POINT + X’001000’ * PRONTO ! R4 CARREGADO OK TAMBEM !

Dicas de programação Carga do primeiro registrador base com o entry point address com LR e do segundo com entry point address com LA+LA Destre outro jeitinho... PROG START USING *,3, LR 3,15 CARREGA PRIMEIRO REG BASE * REG 3 FICA COM O ENDERECO DO ENTRY POINT LA 4, CARREGA NRO 1000 NO REG LA 4,3096(3,4) SOMA ENTRY POINT * FICOU COM ENTRY POINT * OU ENTRY POINT + X’001000’ * PRONTO ! R4 CARREGADO OK TAMBEM !

Dicas de programação Carga do primeiro registrador base com o entry point address com LR e do segundo com entry point address com LA Será que pode fazer assim? PROG START USING *,3, LR 3,15 CARREGA PRIMEIRO REG BASE * REG 3 FICA COM O ENDERECO DO ENTRY POINT LA 4,PROG+4096 CARREGA “DIRETO” ENTRY POINT NÃO! Por que não? Porque o endereço PROG não está no alcance do primeiro base (R3), até então o único carregado corretamente. Dá erro de montagem.

Dicas de programação Carga do primeiro registrador base com o entry point address com LR e do segundo com entry point address com L Nem assim? PROG START USING *,3, LR 3,15 CARREGA PRIMEIRO REG BASE * REG 3 FICA COM O ENDERECO DO ENTRY POINT L ,=A(PROG+4096) CARREGA “DIRETO” ENTRY POINT DEPENDE ! O que está sendo carregado no R4 é o conteúdo da literal. Se a literal estiver FORA do alcance do PRIMEIRO REG BASE (R3), QUE É O ÚNICO PREPARADO ATÉ ENTÃO, então NÃO PODE, dá erro de montagem. (CASO 1) Se a literal estiver dentro do alcance do PRIMEIRO REG BASE (R3), QUE É O ÚNICO PREPARADO ATÉ ENTÃO, então PODE (CASO 2).

Dicas de programação Programa = 8k
Carga do primeiro registrador base com o entry point address com LR e do segundo com entry point address com L CASO 1 : Literal FORA do alcance do PRIMEIRO REG BASE (R3), QUE É O ÚNICO PREPARADO. NÃO PODE! Dá erro de montagem. PROG START USING *,3, LR 3, L ,=A(PROG+4096) (o L precisa do 2o base preparado, mas... ele prepara esse base; então, dá erro de execução) END (as literais são declaradas após o END) =A(PROG+4096) Programa = 8k Parte servida pelo 1o reg base Parte servida pelo 2o reg base

Dicas de programação Programa = 8k
Carga do primeiro registrador base com o entry point address com LR e do segundo com entry point address com L CASO 2 : Literal DENTRO do alcance do PRIMEIRO REG BASE (R3), QUE É O ÚNICO PREPARADO ATÉ ENTÃO, então PODE. PROG START USING *,3, LR 3, L ,=A(PROG+4096) B PULA LTORG =A(PROG+4096) PULA ... END (as outras literais são declaradas) = =... Programa = 8k Parte servida pelo 1o reg base. Força que a literal fique nesta parte Parte servida pelo 2o reg base

THE END

Assembler para Mainframes IBM

Apresentações semelhantes

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

Apresentações semelhantes

Sobre projeto

Feedback

Login

Autorizar-se através da rede social:

Assembler para Mainframes IBM

Apresentações semelhantes

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

Apresentações semelhantes

Sobre projeto

Feedback